{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleInstances #-}

-------------------------------------------------------------------------------
--
-- | 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 -fno-cse #-}
-- -fno-cse is needed for GLOBAL_VAR's to behave properly

module DynFlags (
        -- * Dynamic flags and associated configuration types
        DumpFlag(..),
        GeneralFlag(..),
        WarningFlag(..), WarnReason(..),
        Language(..),
        PlatformConstants(..),
        FatalMessager, LogAction, FlushOut(..), FlushErr(..),
        ProfAuto(..),
        glasgowExtsFlags,
        warningGroups, warningHierarchies,
        hasPprDebug, hasNoDebugOutput, hasNoStateHack, hasNoOptCoercion,
        dopt, dopt_set, dopt_unset,
        gopt, gopt_set, gopt_unset, setGeneralFlag', unSetGeneralFlag',
        wopt, wopt_set, wopt_unset,
        wopt_fatal, wopt_set_fatal, wopt_unset_fatal,
        xopt, xopt_set, xopt_unset,
        xopt_set_unlessExplSpec,
        lang_set,
        useUnicodeSyntax,
        useStarIsType,
        whenGeneratingDynamicToo, ifGeneratingDynamicToo,
        whenCannotGenerateDynamicToo,
        dynamicTooMkDynamicDynFlags,
        dynamicOutputFile,
        DynFlags(..),
        FlagSpec(..),
        HasDynFlags(..), ContainsDynFlags(..),
        RtsOptsEnabled(..),
        HscTarget(..), isObjectTarget, defaultObjectTarget,
        targetRetainsAllBindings,
        GhcMode(..), isOneShot,
        GhcLink(..), isNoLink,
        PackageFlag(..), PackageArg(..), ModRenaming(..),
        packageFlagsChanged,
        IgnorePackageFlag(..), TrustFlag(..),
        PackageDBFlag(..), PkgConfRef(..),
        Option(..), showOpt,
        DynLibLoader(..),
        fFlags, fLangFlags, xFlags,
        wWarningFlags,
        dynFlagDependencies,
        makeDynFlagsConsistent,
        shouldUseColor,
        shouldUseHexWordLiterals,
        positionIndependent,
        optimisationFlags,
        setFlagsFromEnvFile,

        Way(..), mkBuildTag, wayRTSOnly, addWay', updateWays,
        wayGeneralFlags, wayUnsetGeneralFlags,

        thisPackage, thisComponentId, thisUnitIdInsts,

        -- ** Log output
        putLogMsg,

        -- ** Safe Haskell
        SafeHaskellMode(..),
        safeHaskellOn, safeHaskellModeEnabled,
        safeImportsOn, safeLanguageOn, safeInferOn,
        packageTrustOn,
        safeDirectImpsReq, safeImplicitImpsReq,
        unsafeFlags, unsafeFlagsForInfer,

        -- ** LLVM Targets
        LlvmTarget(..), LlvmConfig(..),

        -- ** System tool settings and locations
        Settings(..),
        sProgramName,
        sProjectVersion,
        sGhcUsagePath,
        sGhciUsagePath,
        sToolDir,
        sTopDir,
        sTmpDir,
        sSystemPackageConfig,
        sLdSupportsCompactUnwind,
        sLdSupportsBuildId,
        sLdSupportsFilelist,
        sLdIsGnuLd,
        sGccSupportsNoPie,
        sPgm_L,
        sPgm_P,
        sPgm_F,
        sPgm_c,
        sPgm_a,
        sPgm_l,
        sPgm_dll,
        sPgm_T,
        sPgm_windres,
        sPgm_libtool,
        sPgm_ar,
        sPgm_ranlib,
        sPgm_lo,
        sPgm_lc,
        sPgm_lcc,
        sPgm_i,
        sOpt_L,
        sOpt_P,
        sOpt_P_fingerprint,
        sOpt_F,
        sOpt_c,
        sOpt_cxx,
        sOpt_a,
        sOpt_l,
        sOpt_windres,
        sOpt_lo,
        sOpt_lc,
        sOpt_lcc,
        sOpt_i,
        sExtraGccViaCFlags,
        sTargetPlatformString,
        sIntegerLibrary,
        sIntegerLibraryType,
        sGhcWithInterpreter,
        sGhcWithNativeCodeGen,
        sGhcWithSMP,
        sGhcRTSWays,
        sTablesNextToCode,
        sLeadingUnderscore,
        sLibFFI,
        sGhcThreaded,
        sGhcDebugged,
        sGhcRtsWithLibdw,
        IntegerLibrary(..),
        GhcNameVersion(..),
        FileSettings(..),
        PlatformMisc(..),
        settings,
        programName, projectVersion,
        ghcUsagePath, ghciUsagePath, topDir, tmpDir,
        versionedAppDir, versionedFilePath,
        extraGccViaCFlags, systemPackageConfig,
        pgm_L, pgm_P, pgm_F, pgm_c, pgm_a, pgm_l, pgm_dll, pgm_T,
        pgm_windres, pgm_libtool, pgm_ar, pgm_ranlib, pgm_lo, pgm_lc,
        pgm_lcc, pgm_i,
        opt_L, opt_P, opt_F, opt_c, opt_cxx, opt_a, opt_l, opt_i,
        opt_P_signature,
        opt_windres, opt_lo, opt_lc, opt_lcc,
        tablesNextToCode,

        -- ** Manipulating DynFlags
        addPluginModuleName,
        defaultDynFlags,                -- Settings -> DynFlags
        defaultWays,
        interpWays,
        interpreterProfiled, interpreterDynamic,
        initDynFlags,                   -- DynFlags -> IO DynFlags
        defaultFatalMessager,
        defaultLogAction,
        defaultLogActionHPrintDoc,
        defaultLogActionHPutStrDoc,
        defaultFlushOut,
        defaultFlushErr,

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

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

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

        supportedLanguagesAndExtensions,
        languageExtensions,

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

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

        rtsIsProfiled,
        dynamicGhc,

#include "GHCConstantsHaskellExports.hs"
        bLOCK_SIZE_W,
        wORD_SIZE_IN_BITS,
        wordAlignment,
        tAG_MASK,
        mAX_PTR_TAG,
        tARGET_MIN_INT, tARGET_MAX_INT, tARGET_MAX_WORD,

        unsafeGlobalDynFlags, setUnsafeGlobalDynFlags,

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

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

        -- * File cleanup
        FilesToClean(..), emptyFilesToClean,

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


        -- * Make use of the Cmm CFG
        CfgWeights(..), backendMaintainsCfg
  ) where

#include "HsVersions.h"

import GhcPrelude

import GHC.Platform
import GHC.UniqueSubdir (uniqueSubdir)
import PlatformConstants
import Module
import PackageConfig
import {-# SOURCE #-} Plugins
import {-# SOURCE #-} Hooks
import {-# SOURCE #-} PrelNames ( mAIN )
import {-# SOURCE #-} Packages (PackageState, emptyPackageState)
import DriverPhases     ( Phase(..), phaseInputExt )
import Config
import CliOption
import CmdLineParser hiding (WarnReason(..))
import qualified CmdLineParser as Cmd
import Constants
import GhcNameVersion
import Panic
import qualified PprColour as Col
import Util
import Maybes
import MonadUtils
import qualified Pretty
import SrcLoc
import BasicTypes       ( Alignment, alignmentOf, IntWithInf, treatZeroAsInf )
import FastString
import Fingerprint
import FileSettings
import Outputable
import Settings
import ToolSettings

import Foreign.C        ( CInt(..) )
import System.IO.Unsafe ( unsafeDupablePerformIO )
import {-# SOURCE #-} ErrUtils ( Severity(..), MsgDoc, mkLocMessageAnn
                               , getCaretDiagnostic )
import Json
import SysTools.Terminal ( stderrSupportsAnsiColors )
import SysTools.BaseDir ( expandToolDir, expandTopDir )

import System.IO.Unsafe ( unsafePerformIO )
import Data.IORef
import Control.Arrow ((&&&))
import Control.Monad
import Control.Monad.Trans.Class
import Control.Monad.Trans.Writer
import Control.Monad.Trans.Reader
import Control.Monad.Trans.Except

import Data.Ord
import Data.Bits
import Data.Char
import Data.Int
import Data.List
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Word
import System.FilePath
import System.Directory
import System.Environment (lookupEnv)
import System.IO
import System.IO.Error
import Text.ParserCombinators.ReadP hiding (char)
import Text.ParserCombinators.ReadP as R

import EnumSet (EnumSet)
import qualified EnumSet

import GHC.Foreign (withCString, peekCString)
import qualified GHC.LanguageExtensions as LangExt

#if GHC_STAGE >= 2
-- used by SHARED_GLOBAL_VAR
import Foreign (Ptr)
#endif

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

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

data DumpFlag
-- See Note [Updating flag description in the User's Guide]

   -- debugging flags
   = Opt_D_dump_cmm
   | Opt_D_dump_cmm_from_stg
   | Opt_D_dump_cmm_raw
   | Opt_D_dump_cmm_verbose_by_proc
   -- All of the cmm subflags (there are a lot!) automatically
   -- enabled if you run -ddump-cmm-verbose-by-proc
   -- Each flag corresponds to exact stage of Cmm pipeline.
   | Opt_D_dump_cmm_verbose
   -- same as -ddump-cmm-verbose-by-proc but writes each stage
   -- to a separate file (if used with -ddump-to-file)
   | Opt_D_dump_cmm_cfg
   | Opt_D_dump_cmm_cbe
   | Opt_D_dump_cmm_switch
   | Opt_D_dump_cmm_proc
   | Opt_D_dump_cmm_sp
   | Opt_D_dump_cmm_sink
   | Opt_D_dump_cmm_caf
   | Opt_D_dump_cmm_procmap
   | Opt_D_dump_cmm_split
   | Opt_D_dump_cmm_info
   | Opt_D_dump_cmm_cps
   -- end cmm subflags
   | Opt_D_dump_cfg_weights -- ^ Dump the cfg used for block layout.
   | Opt_D_dump_asm
   | Opt_D_dump_asm_native
   | Opt_D_dump_asm_liveness
   | Opt_D_dump_asm_regalloc
   | Opt_D_dump_asm_regalloc_stages
   | Opt_D_dump_asm_conflicts
   | Opt_D_dump_asm_stats
   | Opt_D_dump_asm_expanded
   | Opt_D_dump_llvm
   | Opt_D_dump_core_stats
   | Opt_D_dump_deriv
   | Opt_D_dump_ds
   | Opt_D_dump_ds_preopt
   | Opt_D_dump_foreign
   | Opt_D_dump_inlinings
   | Opt_D_dump_rule_firings
   | Opt_D_dump_rule_rewrites
   | Opt_D_dump_simpl_trace
   | Opt_D_dump_occur_anal
   | Opt_D_dump_parsed
   | Opt_D_dump_parsed_ast
   | Opt_D_dump_rn
   | Opt_D_dump_rn_ast
   | Opt_D_dump_simpl
   | Opt_D_dump_simpl_iterations
   | Opt_D_dump_spec
   | Opt_D_dump_prep
   | Opt_D_dump_stg -- CoreToStg output
   | Opt_D_dump_stg_unarised -- STG after unarise
   | Opt_D_dump_stg_final -- STG after stg2stg
   | Opt_D_dump_call_arity
   | Opt_D_dump_exitify
   | Opt_D_dump_stranal
   | Opt_D_dump_str_signatures
   | Opt_D_dump_tc
   | Opt_D_dump_tc_ast
   | Opt_D_dump_types
   | Opt_D_dump_rules
   | Opt_D_dump_cse
   | Opt_D_dump_worker_wrapper
   | Opt_D_dump_rn_trace
   | Opt_D_dump_rn_stats
   | Opt_D_dump_opt_cmm
   | Opt_D_dump_simpl_stats
   | Opt_D_dump_cs_trace -- Constraint solver in type checker
   | Opt_D_dump_tc_trace
   | Opt_D_dump_ec_trace -- Pattern match exhaustiveness checker
   | Opt_D_dump_if_trace
   | Opt_D_dump_vt_trace
   | Opt_D_dump_splices
   | Opt_D_th_dec_file
   | Opt_D_dump_BCOs
   | Opt_D_dump_ticked
   | Opt_D_dump_rtti
   | Opt_D_source_stats
   | Opt_D_verbose_stg2stg
   | Opt_D_dump_hi
   | Opt_D_dump_hi_diffs
   | Opt_D_dump_mod_cycles
   | Opt_D_dump_mod_map
   | Opt_D_dump_timings
   | Opt_D_dump_view_pattern_commoning
   | Opt_D_verbose_core2core
   | Opt_D_dump_debug
   | Opt_D_dump_json
   | Opt_D_ppr_debug
   | Opt_D_no_debug_output
   deriving (DumpFlag -> DumpFlag -> Bool
(DumpFlag -> DumpFlag -> Bool)
-> (DumpFlag -> DumpFlag -> Bool) -> Eq DumpFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DumpFlag -> DumpFlag -> Bool
$c/= :: DumpFlag -> DumpFlag -> Bool
== :: DumpFlag -> DumpFlag -> Bool
$c== :: DumpFlag -> DumpFlag -> Bool
Eq, Int -> DumpFlag -> ShowS
[DumpFlag] -> ShowS
DumpFlag -> String
(Int -> DumpFlag -> ShowS)
-> (DumpFlag -> String) -> ([DumpFlag] -> ShowS) -> Show DumpFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DumpFlag] -> ShowS
$cshowList :: [DumpFlag] -> ShowS
show :: DumpFlag -> String
$cshow :: DumpFlag -> String
showsPrec :: Int -> DumpFlag -> ShowS
$cshowsPrec :: Int -> DumpFlag -> ShowS
Show, Int -> DumpFlag
DumpFlag -> Int
DumpFlag -> [DumpFlag]
DumpFlag -> DumpFlag
DumpFlag -> DumpFlag -> [DumpFlag]
DumpFlag -> DumpFlag -> DumpFlag -> [DumpFlag]
(DumpFlag -> DumpFlag)
-> (DumpFlag -> DumpFlag)
-> (Int -> DumpFlag)
-> (DumpFlag -> Int)
-> (DumpFlag -> [DumpFlag])
-> (DumpFlag -> DumpFlag -> [DumpFlag])
-> (DumpFlag -> DumpFlag -> [DumpFlag])
-> (DumpFlag -> DumpFlag -> DumpFlag -> [DumpFlag])
-> Enum DumpFlag
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: DumpFlag -> DumpFlag -> DumpFlag -> [DumpFlag]
$cenumFromThenTo :: DumpFlag -> DumpFlag -> DumpFlag -> [DumpFlag]
enumFromTo :: DumpFlag -> DumpFlag -> [DumpFlag]
$cenumFromTo :: DumpFlag -> DumpFlag -> [DumpFlag]
enumFromThen :: DumpFlag -> DumpFlag -> [DumpFlag]
$cenumFromThen :: DumpFlag -> DumpFlag -> [DumpFlag]
enumFrom :: DumpFlag -> [DumpFlag]
$cenumFrom :: DumpFlag -> [DumpFlag]
fromEnum :: DumpFlag -> Int
$cfromEnum :: DumpFlag -> Int
toEnum :: Int -> DumpFlag
$ctoEnum :: Int -> DumpFlag
pred :: DumpFlag -> DumpFlag
$cpred :: DumpFlag -> DumpFlag
succ :: DumpFlag -> DumpFlag
$csucc :: DumpFlag -> DumpFlag
Enum)


-- | Enumerates the simple on-or-off dynamic flags
data GeneralFlag
-- See Note [Updating flag description in the User's Guide]

   = Opt_DumpToFile                     -- ^ Append dump output to files instead of stdout.
   | Opt_D_faststring_stats
   | Opt_D_dump_minimal_imports
   | Opt_DoCoreLinting
   | Opt_DoStgLinting
   | Opt_DoCmmLinting
   | Opt_DoAsmLinting
   | Opt_DoAnnotationLinting
   | Opt_NoLlvmMangler                  -- hidden flag
   | Opt_FastLlvm                       -- hidden flag
   | Opt_NoTypeableBinds

   | Opt_WarnIsError                    -- -Werror; makes warnings fatal
   | Opt_ShowWarnGroups                 -- Show the group a warning belongs to
   | Opt_HideSourcePaths                -- Hide module source/object paths

   | Opt_PrintExplicitForalls
   | Opt_PrintExplicitKinds
   | Opt_PrintExplicitCoercions
   | Opt_PrintExplicitRuntimeReps
   | Opt_PrintEqualityRelations
   | Opt_PrintAxiomIncomps
   | Opt_PrintUnicodeSyntax
   | Opt_PrintExpandedSynonyms
   | Opt_PrintPotentialInstances
   | Opt_PrintTypecheckerElaboration

   -- optimisation opts
   | Opt_CallArity
   | Opt_Exitification
   | Opt_Strictness
   | Opt_LateDmdAnal                    -- #6087
   | Opt_KillAbsence
   | Opt_KillOneShot
   | Opt_FullLaziness
   | Opt_FloatIn
   | Opt_LateSpecialise
   | Opt_Specialise
   | Opt_SpecialiseAggressively
   | Opt_CrossModuleSpecialise
   | Opt_StaticArgumentTransformation
   | Opt_CSE
   | Opt_StgCSE
   | Opt_StgLiftLams
   | Opt_LiberateCase
   | Opt_SpecConstr
   | Opt_SpecConstrKeen
   | Opt_DoLambdaEtaExpansion
   | Opt_IgnoreAsserts
   | Opt_DoEtaReduction
   | Opt_CaseMerge
   | Opt_CaseFolding                    -- Constant folding through case-expressions
   | Opt_UnboxStrictFields
   | Opt_UnboxSmallStrictFields
   | Opt_DictsCheap
   | Opt_EnableRewriteRules             -- Apply rewrite rules during simplification
   | Opt_EnableThSpliceWarnings         -- Enable warnings for TH splices
   | Opt_RegsGraph                      -- do graph coloring register allocation
   | Opt_RegsIterative                  -- do iterative coalescing graph coloring register allocation
   | Opt_PedanticBottoms                -- Be picky about how we treat bottom
   | Opt_LlvmTBAA                       -- Use LLVM TBAA infastructure for improving AA (hidden flag)
   | Opt_LlvmFillUndefWithGarbage       -- Testing for undef bugs (hidden flag)
   | Opt_IrrefutableTuples
   | Opt_CmmSink
   | Opt_CmmElimCommonBlocks
   | Opt_AsmShortcutting
   | Opt_OmitYields
   | Opt_FunToThunk               -- allow WwLib.mkWorkerArgs to remove all value lambdas
   | Opt_DictsStrict                     -- be strict in argument dictionaries
   | Opt_DmdTxDictSel              -- use a special demand transformer for dictionary selectors
   | Opt_Loopification                  -- See Note [Self-recursive tail calls]
   | Opt_CfgBlocklayout             -- ^ Use the cfg based block layout algorithm.
   | Opt_WeightlessBlocklayout         -- ^ Layout based on last instruction per block.
   | Opt_CprAnal
   | Opt_WorkerWrapper
   | Opt_SolveConstantDicts
   | Opt_AlignmentSanitisation
   | Opt_CatchBottoms
   | Opt_NumConstantFolding

   -- PreInlining is on by default. The option is there just to see how
   -- bad things get if you turn it off!
   | Opt_SimplPreInlining

   -- Interface files
   | Opt_IgnoreInterfacePragmas
   | Opt_OmitInterfacePragmas
   | Opt_ExposeAllUnfoldings
   | Opt_WriteInterface -- forces .hi files to be written even with -fno-code
   | Opt_WriteHie -- generate .hie files

   -- profiling opts
   | Opt_AutoSccsOnIndividualCafs
   | Opt_ProfCountEntries

   -- misc opts
   | Opt_Pp
   | Opt_ForceRecomp
   | Opt_IgnoreOptimChanges
   | Opt_IgnoreHpcChanges
   | Opt_ExcessPrecision
   | Opt_EagerBlackHoling
   | Opt_NoHsMain
   | Opt_SplitSections
   | Opt_StgStats
   | Opt_HideAllPackages
   | Opt_HideAllPluginPackages
   | Opt_PrintBindResult
   | Opt_Haddock
   | Opt_HaddockOptions
   | Opt_BreakOnException
   | Opt_BreakOnError
   | Opt_PrintEvldWithShow
   | Opt_PrintBindContents
   | Opt_GenManifest
   | Opt_EmbedManifest
   | Opt_SharedImplib
   | Opt_BuildingCabalPackage
   | Opt_IgnoreDotGhci
   | Opt_GhciSandbox
   | Opt_GhciHistory
   | Opt_GhciLeakCheck
   | Opt_ValidateHie
   | Opt_LocalGhciHistory
   | Opt_NoIt
   | Opt_HelpfulErrors
   | Opt_DeferTypeErrors
   | Opt_DeferTypedHoles
   | Opt_DeferOutOfScopeVariables
   | Opt_PIC                         -- ^ @-fPIC@
   | Opt_PIE                         -- ^ @-fPIE@
   | Opt_PICExecutable               -- ^ @-pie@
   | Opt_ExternalDynamicRefs
   | Opt_SccProfilingOn
   | Opt_Ticky
   | Opt_Ticky_Allocd
   | Opt_Ticky_LNE
   | Opt_Ticky_Dyn_Thunk
   | Opt_RPath
   | Opt_RelativeDynlibPaths
   | Opt_Hpc
   | Opt_FlatCache
   | Opt_ExternalInterpreter
   | Opt_OptimalApplicativeDo
   | Opt_VersionMacros
   | Opt_WholeArchiveHsLibs
   -- copy all libs into a single folder prior to linking binaries
   -- this should elivate the excessive command line limit restrictions
   -- on windows, by only requiring a single -L argument instead of
   -- one for each dependency.  At the time of this writing, gcc
   -- forwards all -L flags to the collect2 command without using a
   -- response file and as such breaking apart.
   | Opt_SingleLibFolder
   | Opt_KeepCAFs
   | Opt_KeepGoing
   | Opt_ByteCode

   -- output style opts
   | Opt_ErrorSpans -- Include full span info in error messages,
                    -- instead of just the start position.
   | Opt_DeferDiagnostics
   | Opt_DiagnosticsShowCaret -- Show snippets of offending code
   | Opt_PprCaseAsLet
   | Opt_PprShowTicks
   | Opt_ShowHoleConstraints
    -- Options relating to the display of valid hole fits
    -- when generating an error message for a typed hole
    -- See Note [Valid hole fits include] in TcHoleErrors.hs
   | Opt_ShowValidHoleFits
   | Opt_SortValidHoleFits
   | Opt_SortBySizeHoleFits
   | Opt_SortBySubsumHoleFits
   | Opt_AbstractRefHoleFits
   | Opt_UnclutterValidHoleFits
   | Opt_ShowTypeAppOfHoleFits
   | Opt_ShowTypeAppVarsOfHoleFits
   | Opt_ShowDocsOfHoleFits
   | Opt_ShowTypeOfHoleFits
   | Opt_ShowProvOfHoleFits
   | Opt_ShowMatchesOfHoleFits

   | Opt_ShowLoadedModules
   | Opt_HexWordLiterals -- See Note [Print Hexadecimal Literals]

   -- Suppress all coercions, them replacing with '...'
   | Opt_SuppressCoercions
   | Opt_SuppressVarKinds
   -- Suppress module id prefixes on variables.
   | Opt_SuppressModulePrefixes
   -- Suppress type applications.
   | Opt_SuppressTypeApplications
   -- Suppress info such as arity and unfoldings on identifiers.
   | Opt_SuppressIdInfo
   -- Suppress separate type signatures in core, but leave types on
   -- lambda bound vars
   | Opt_SuppressUnfoldings
   -- Suppress the details of even stable unfoldings
   | Opt_SuppressTypeSignatures
   -- Suppress unique ids on variables.
   -- Except for uniques, as some simplifier phases introduce new
   -- variables that have otherwise identical names.
   | Opt_SuppressUniques
   | Opt_SuppressStgExts
   | Opt_SuppressTicks     -- Replaces Opt_PprShowTicks
   | Opt_SuppressTimestamps -- ^ Suppress timestamps in dumps

   -- temporary flags
   | Opt_AutoLinkPackages
   | Opt_ImplicitImportQualified

   -- keeping stuff
   | Opt_KeepHscppFiles
   | Opt_KeepHiDiffs
   | Opt_KeepHcFiles
   | Opt_KeepSFiles
   | Opt_KeepTmpFiles
   | Opt_KeepRawTokenStream
   | Opt_KeepLlvmFiles
   | Opt_KeepHiFiles
   | Opt_KeepOFiles

   | Opt_BuildDynamicToo

   -- safe haskell flags
   | Opt_DistrustAllPackages
   | Opt_PackageTrust
   | Opt_PluginTrustworthy

   | Opt_G_NoStateHack
   | Opt_G_NoOptCoercion
   deriving (GeneralFlag -> GeneralFlag -> Bool
(GeneralFlag -> GeneralFlag -> Bool)
-> (GeneralFlag -> GeneralFlag -> Bool) -> Eq GeneralFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeneralFlag -> GeneralFlag -> Bool
$c/= :: GeneralFlag -> GeneralFlag -> Bool
== :: GeneralFlag -> GeneralFlag -> Bool
$c== :: GeneralFlag -> GeneralFlag -> Bool
Eq, Int -> GeneralFlag -> ShowS
[GeneralFlag] -> ShowS
GeneralFlag -> String
(Int -> GeneralFlag -> ShowS)
-> (GeneralFlag -> String)
-> ([GeneralFlag] -> ShowS)
-> Show GeneralFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeneralFlag] -> ShowS
$cshowList :: [GeneralFlag] -> ShowS
show :: GeneralFlag -> String
$cshow :: GeneralFlag -> String
showsPrec :: Int -> GeneralFlag -> ShowS
$cshowsPrec :: Int -> GeneralFlag -> ShowS
Show, Int -> GeneralFlag
GeneralFlag -> Int
GeneralFlag -> [GeneralFlag]
GeneralFlag -> GeneralFlag
GeneralFlag -> GeneralFlag -> [GeneralFlag]
GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag]
(GeneralFlag -> GeneralFlag)
-> (GeneralFlag -> GeneralFlag)
-> (Int -> GeneralFlag)
-> (GeneralFlag -> Int)
-> (GeneralFlag -> [GeneralFlag])
-> (GeneralFlag -> GeneralFlag -> [GeneralFlag])
-> (GeneralFlag -> GeneralFlag -> [GeneralFlag])
-> (GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag])
-> Enum GeneralFlag
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag]
$cenumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag]
enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag]
$cenumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag]
enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag]
$cenumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag]
enumFrom :: GeneralFlag -> [GeneralFlag]
$cenumFrom :: GeneralFlag -> [GeneralFlag]
fromEnum :: GeneralFlag -> Int
$cfromEnum :: GeneralFlag -> Int
toEnum :: Int -> GeneralFlag
$ctoEnum :: Int -> GeneralFlag
pred :: GeneralFlag -> GeneralFlag
$cpred :: GeneralFlag -> GeneralFlag
succ :: GeneralFlag -> GeneralFlag
$csucc :: GeneralFlag -> GeneralFlag
Enum)

-- Check whether a flag should be considered an "optimisation flag"
-- for purposes of recompilation avoidance (see
-- Note [Ignoring some flag changes] in FlagChecker). Being listed here is
-- not a guarantee that the flag has no other effect. We could, and
-- perhaps should, separate out the flags that have some minor impact on
-- program semantics and/or error behavior (e.g., assertions), but
-- then we'd need to go to extra trouble (and an additional flag)
-- to allow users to ignore the optimisation level even though that
-- means ignoring some change.
optimisationFlags :: EnumSet GeneralFlag
optimisationFlags :: EnumSet GeneralFlag
optimisationFlags = [GeneralFlag] -> EnumSet GeneralFlag
forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList
   [ GeneralFlag
Opt_CallArity
   , GeneralFlag
Opt_Strictness
   , GeneralFlag
Opt_LateDmdAnal
   , GeneralFlag
Opt_KillAbsence
   , GeneralFlag
Opt_KillOneShot
   , GeneralFlag
Opt_FullLaziness
   , GeneralFlag
Opt_FloatIn
   , GeneralFlag
Opt_LateSpecialise
   , GeneralFlag
Opt_Specialise
   , GeneralFlag
Opt_SpecialiseAggressively
   , GeneralFlag
Opt_CrossModuleSpecialise
   , GeneralFlag
Opt_StaticArgumentTransformation
   , GeneralFlag
Opt_CSE
   , GeneralFlag
Opt_StgCSE
   , GeneralFlag
Opt_StgLiftLams
   , GeneralFlag
Opt_LiberateCase
   , GeneralFlag
Opt_SpecConstr
   , GeneralFlag
Opt_SpecConstrKeen
   , GeneralFlag
Opt_DoLambdaEtaExpansion
   , GeneralFlag
Opt_IgnoreAsserts
   , GeneralFlag
Opt_DoEtaReduction
   , GeneralFlag
Opt_CaseMerge
   , GeneralFlag
Opt_CaseFolding
   , GeneralFlag
Opt_UnboxStrictFields
   , GeneralFlag
Opt_UnboxSmallStrictFields
   , GeneralFlag
Opt_DictsCheap
   , GeneralFlag
Opt_EnableRewriteRules
   , GeneralFlag
Opt_RegsGraph
   , GeneralFlag
Opt_RegsIterative
   , GeneralFlag
Opt_PedanticBottoms
   , GeneralFlag
Opt_LlvmTBAA
   , GeneralFlag
Opt_LlvmFillUndefWithGarbage
   , GeneralFlag
Opt_IrrefutableTuples
   , GeneralFlag
Opt_CmmSink
   , GeneralFlag
Opt_CmmElimCommonBlocks
   , GeneralFlag
Opt_AsmShortcutting
   , GeneralFlag
Opt_OmitYields
   , GeneralFlag
Opt_FunToThunk
   , GeneralFlag
Opt_DictsStrict
   , GeneralFlag
Opt_DmdTxDictSel
   , GeneralFlag
Opt_Loopification
   , GeneralFlag
Opt_CfgBlocklayout
   , GeneralFlag
Opt_WeightlessBlocklayout
   , GeneralFlag
Opt_CprAnal
   , GeneralFlag
Opt_WorkerWrapper
   , GeneralFlag
Opt_SolveConstantDicts
   , GeneralFlag
Opt_CatchBottoms
   , GeneralFlag
Opt_IgnoreAsserts
   ]

-- | Used when outputting warnings: if a reason is given, it is
-- displayed. If a warning isn't controlled by a flag, this is made
-- explicit at the point of use.
data WarnReason
  = NoReason
  -- | Warning was enabled with the flag
  | Reason !WarningFlag
  -- | Warning was made an error because of -Werror or -Werror=WarningFlag
  | ErrReason !(Maybe WarningFlag)
  deriving Int -> WarnReason -> ShowS
[WarnReason] -> ShowS
WarnReason -> String
(Int -> WarnReason -> ShowS)
-> (WarnReason -> String)
-> ([WarnReason] -> ShowS)
-> Show WarnReason
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WarnReason] -> ShowS
$cshowList :: [WarnReason] -> ShowS
show :: WarnReason -> String
$cshow :: WarnReason -> String
showsPrec :: Int -> WarnReason -> ShowS
$cshowsPrec :: Int -> WarnReason -> ShowS
Show

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

-- | Append to the list of includes a path that shall be included using `-I`
-- when the C compiler is called. These paths override system search paths.
addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addGlobalInclude IncludeSpecs
spec [String]
paths  = let f :: [String]
f = IncludeSpecs -> [String]
includePathsGlobal IncludeSpecs
spec
                               in IncludeSpecs
spec { includePathsGlobal :: [String]
includePathsGlobal = [String]
f [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
paths }

-- | Append to the list of includes a path that shall be included using
-- `-iquote` when the C compiler is called. These paths only apply when quoted
-- includes are used. e.g. #include "foo.h"
addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addQuoteInclude IncludeSpecs
spec [String]
paths  = let f :: [String]
f = IncludeSpecs -> [String]
includePathsQuote IncludeSpecs
spec
                              in IncludeSpecs
spec { includePathsQuote :: [String]
includePathsQuote = [String]
f [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
paths }

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

instance Outputable WarnReason where
  ppr :: WarnReason -> SDoc
ppr = String -> SDoc
text (String -> SDoc) -> (WarnReason -> String) -> WarnReason -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WarnReason -> String
forall a. Show a => a -> String
show

instance ToJson WarnReason where
  json :: WarnReason -> JsonDoc
json WarnReason
NoReason = JsonDoc
JSNull
  json (Reason WarningFlag
wf) = String -> JsonDoc
JSString (WarningFlag -> String
forall a. Show a => a -> String
show WarningFlag
wf)
  json (ErrReason Maybe WarningFlag
Nothing) = String -> JsonDoc
JSString String
"Opt_WarnIsError"
  json (ErrReason (Just WarningFlag
wf)) = String -> JsonDoc
JSString (WarningFlag -> String
forall a. Show a => a -> String
show WarningFlag
wf)

data WarningFlag =
-- See Note [Updating flag description in the User's Guide]
     Opt_WarnDuplicateExports
   | Opt_WarnDuplicateConstraints
   | Opt_WarnRedundantConstraints
   | Opt_WarnHiShadows
   | Opt_WarnImplicitPrelude
   | Opt_WarnIncompletePatterns
   | Opt_WarnIncompleteUniPatterns
   | Opt_WarnIncompletePatternsRecUpd
   | Opt_WarnOverflowedLiterals
   | Opt_WarnEmptyEnumerations
   | Opt_WarnMissingFields
   | Opt_WarnMissingImportList
   | Opt_WarnMissingMethods
   | Opt_WarnMissingSignatures
   | Opt_WarnMissingLocalSignatures
   | Opt_WarnNameShadowing
   | Opt_WarnOverlappingPatterns
   | Opt_WarnTypeDefaults
   | Opt_WarnMonomorphism
   | Opt_WarnUnusedTopBinds
   | Opt_WarnUnusedLocalBinds
   | Opt_WarnUnusedPatternBinds
   | Opt_WarnUnusedImports
   | Opt_WarnUnusedMatches
   | Opt_WarnUnusedTypePatterns
   | Opt_WarnUnusedForalls
   | Opt_WarnUnusedRecordWildcards
   | Opt_WarnRedundantRecordWildcards
   | Opt_WarnWarningsDeprecations
   | Opt_WarnDeprecatedFlags
   | Opt_WarnMissingMonadFailInstances -- since 8.0
   | Opt_WarnSemigroup -- since 8.0
   | Opt_WarnDodgyExports
   | Opt_WarnDodgyImports
   | Opt_WarnOrphans
   | Opt_WarnAutoOrphans
   | Opt_WarnIdentities
   | Opt_WarnTabs
   | Opt_WarnUnrecognisedPragmas
   | Opt_WarnDodgyForeignImports
   | Opt_WarnUnusedDoBind
   | Opt_WarnWrongDoBind
   | Opt_WarnAlternativeLayoutRuleTransitional
   | Opt_WarnUnsafe
   | Opt_WarnSafe
   | Opt_WarnTrustworthySafe
   | Opt_WarnMissedSpecs
   | Opt_WarnAllMissedSpecs
   | Opt_WarnUnsupportedCallingConventions
   | Opt_WarnUnsupportedLlvmVersion
   | Opt_WarnMissedExtraSharedLib
   | Opt_WarnInlineRuleShadowing
   | Opt_WarnTypedHoles
   | Opt_WarnPartialTypeSignatures
   | Opt_WarnMissingExportedSignatures
   | Opt_WarnUntickedPromotedConstructors
   | Opt_WarnDerivingTypeable
   | Opt_WarnDeferredTypeErrors
   | Opt_WarnDeferredOutOfScopeVariables
   | Opt_WarnNonCanonicalMonadInstances   -- since 8.0
   | Opt_WarnNonCanonicalMonadFailInstances   -- since 8.0, removed 8.8
   | Opt_WarnNonCanonicalMonoidInstances  -- since 8.0
   | Opt_WarnMissingPatternSynonymSignatures -- since 8.0
   | Opt_WarnUnrecognisedWarningFlags     -- since 8.0
   | Opt_WarnSimplifiableClassConstraints -- Since 8.2
   | Opt_WarnCPPUndef                     -- Since 8.2
   | Opt_WarnUnbangedStrictPatterns       -- Since 8.2
   | Opt_WarnMissingHomeModules           -- Since 8.2
   | Opt_WarnPartialFields                -- Since 8.4
   | Opt_WarnMissingExportList
   | Opt_WarnInaccessibleCode
   | Opt_WarnStarIsType                   -- Since 8.6
   | Opt_WarnStarBinder                   -- Since 8.6
   | Opt_WarnImplicitKindVars             -- Since 8.6
   | Opt_WarnSpaceAfterBang
   | Opt_WarnMissingDerivingStrategies    -- Since 8.8
   | Opt_WarnPrepositiveQualifiedModule   -- Since TBD
   | Opt_WarnUnusedPackages               -- Since 8.10
   | Opt_WarnInferredSafeImports          -- Since 8.10
   | Opt_WarnMissingSafeHaskellMode       -- Since 8.10
   | Opt_WarnCompatUnqualifiedImports     -- Since 8.10
   | Opt_WarnDerivingDefaults
   deriving (WarningFlag -> WarningFlag -> Bool
(WarningFlag -> WarningFlag -> Bool)
-> (WarningFlag -> WarningFlag -> Bool) -> Eq WarningFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WarningFlag -> WarningFlag -> Bool
$c/= :: WarningFlag -> WarningFlag -> Bool
== :: WarningFlag -> WarningFlag -> Bool
$c== :: WarningFlag -> WarningFlag -> Bool
Eq, Int -> WarningFlag -> ShowS
[WarningFlag] -> ShowS
WarningFlag -> String
(Int -> WarningFlag -> ShowS)
-> (WarningFlag -> String)
-> ([WarningFlag] -> ShowS)
-> Show WarningFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WarningFlag] -> ShowS
$cshowList :: [WarningFlag] -> ShowS
show :: WarningFlag -> String
$cshow :: WarningFlag -> String
showsPrec :: Int -> WarningFlag -> ShowS
$cshowsPrec :: Int -> WarningFlag -> ShowS
Show, Int -> WarningFlag
WarningFlag -> Int
WarningFlag -> [WarningFlag]
WarningFlag -> WarningFlag
WarningFlag -> WarningFlag -> [WarningFlag]
WarningFlag -> WarningFlag -> WarningFlag -> [WarningFlag]
(WarningFlag -> WarningFlag)
-> (WarningFlag -> WarningFlag)
-> (Int -> WarningFlag)
-> (WarningFlag -> Int)
-> (WarningFlag -> [WarningFlag])
-> (WarningFlag -> WarningFlag -> [WarningFlag])
-> (WarningFlag -> WarningFlag -> [WarningFlag])
-> (WarningFlag -> WarningFlag -> WarningFlag -> [WarningFlag])
-> Enum WarningFlag
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: WarningFlag -> WarningFlag -> WarningFlag -> [WarningFlag]
$cenumFromThenTo :: WarningFlag -> WarningFlag -> WarningFlag -> [WarningFlag]
enumFromTo :: WarningFlag -> WarningFlag -> [WarningFlag]
$cenumFromTo :: WarningFlag -> WarningFlag -> [WarningFlag]
enumFromThen :: WarningFlag -> WarningFlag -> [WarningFlag]
$cenumFromThen :: WarningFlag -> WarningFlag -> [WarningFlag]
enumFrom :: WarningFlag -> [WarningFlag]
$cenumFrom :: WarningFlag -> [WarningFlag]
fromEnum :: WarningFlag -> Int
$cfromEnum :: WarningFlag -> Int
toEnum :: Int -> WarningFlag
$ctoEnum :: Int -> WarningFlag
pred :: WarningFlag -> WarningFlag
$cpred :: WarningFlag -> WarningFlag
succ :: WarningFlag -> WarningFlag
$csucc :: WarningFlag -> WarningFlag
Enum)

data Language = Haskell98 | Haskell2010
   deriving (Language -> Language -> Bool
(Language -> Language -> Bool)
-> (Language -> Language -> Bool) -> Eq Language
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Language -> Language -> Bool
$c/= :: Language -> Language -> Bool
== :: Language -> Language -> Bool
$c== :: Language -> Language -> Bool
Eq, Int -> Language
Language -> Int
Language -> [Language]
Language -> Language
Language -> Language -> [Language]
Language -> Language -> Language -> [Language]
(Language -> Language)
-> (Language -> Language)
-> (Int -> Language)
-> (Language -> Int)
-> (Language -> [Language])
-> (Language -> Language -> [Language])
-> (Language -> Language -> [Language])
-> (Language -> Language -> Language -> [Language])
-> Enum Language
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Language -> Language -> Language -> [Language]
$cenumFromThenTo :: Language -> Language -> Language -> [Language]
enumFromTo :: Language -> Language -> [Language]
$cenumFromTo :: Language -> Language -> [Language]
enumFromThen :: Language -> Language -> [Language]
$cenumFromThen :: Language -> Language -> [Language]
enumFrom :: Language -> [Language]
$cenumFrom :: Language -> [Language]
fromEnum :: Language -> Int
$cfromEnum :: Language -> Int
toEnum :: Int -> Language
$ctoEnum :: Int -> Language
pred :: Language -> Language
$cpred :: Language -> Language
succ :: Language -> Language
$csucc :: Language -> Language
Enum, Int -> Language -> ShowS
[Language] -> ShowS
Language -> String
(Int -> Language -> ShowS)
-> (Language -> String) -> ([Language] -> ShowS) -> Show Language
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Language] -> ShowS
$cshowList :: [Language] -> ShowS
show :: Language -> String
$cshow :: Language -> String
showsPrec :: Int -> Language -> ShowS
$cshowsPrec :: Int -> Language -> ShowS
Show)

instance Outputable Language where
    ppr :: Language -> SDoc
ppr = String -> SDoc
text (String -> SDoc) -> (Language -> String) -> Language -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Language -> String
forall a. Show a => a -> String
show

-- | The various Safe Haskell modes
data SafeHaskellMode
   = Sf_None          -- ^ inferred unsafe
   | Sf_Unsafe        -- ^ declared and checked
   | Sf_Trustworthy   -- ^ declared and checked
   | Sf_Safe          -- ^ declared and checked
   | Sf_SafeInferred  -- ^ inferred as safe
   | Sf_Ignore        -- ^ @-fno-safe-haskell@ state
   deriving (SafeHaskellMode -> SafeHaskellMode -> Bool
(SafeHaskellMode -> SafeHaskellMode -> Bool)
-> (SafeHaskellMode -> SafeHaskellMode -> Bool)
-> Eq SafeHaskellMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SafeHaskellMode -> SafeHaskellMode -> Bool
$c/= :: SafeHaskellMode -> SafeHaskellMode -> Bool
== :: SafeHaskellMode -> SafeHaskellMode -> Bool
$c== :: SafeHaskellMode -> SafeHaskellMode -> Bool
Eq)

instance Show SafeHaskellMode where
    show :: SafeHaskellMode -> String
show SafeHaskellMode
Sf_None         = String
"None"
    show SafeHaskellMode
Sf_Unsafe       = String
"Unsafe"
    show SafeHaskellMode
Sf_Trustworthy  = String
"Trustworthy"
    show SafeHaskellMode
Sf_Safe         = String
"Safe"
    show SafeHaskellMode
Sf_SafeInferred = String
"Safe-Inferred"
    show SafeHaskellMode
Sf_Ignore       = String
"Ignore"

instance Outputable SafeHaskellMode where
    ppr :: SafeHaskellMode -> SDoc
ppr = String -> SDoc
text (String -> SDoc)
-> (SafeHaskellMode -> String) -> SafeHaskellMode -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SafeHaskellMode -> String
forall a. Show a => a -> String
show

-- | Contains not only a collection of 'GeneralFlag's but also a plethora of
-- information relating to the compilation of a single file or GHC session
data DynFlags = DynFlags {
  DynFlags -> GhcMode
ghcMode               :: GhcMode,
  DynFlags -> GhcLink
ghcLink               :: GhcLink,
  DynFlags -> HscTarget
hscTarget             :: HscTarget,

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

  DynFlags -> IntegerLibrary
integerLibrary        :: IntegerLibrary,
    -- ^ IntegerGMP or IntegerSimple. Set at configure time, but may be overriden
    --   by GHC-API users. See Note [The integer library] in PrelNames
  DynFlags -> LlvmConfig
llvmConfig            :: LlvmConfig,
    -- ^ N.B. It's important that this field is lazy since we load the LLVM
    -- configuration lazily. See Note [LLVM Configuration] in SysTools.
  DynFlags -> Int
verbosity             :: Int,         -- ^ Verbosity level: see Note [Verbosity levels]
  DynFlags -> Int
optLevel              :: Int,         -- ^ Optimisation level
  DynFlags -> Int
debugLevel            :: Int,         -- ^ How much debug information to produce
  DynFlags -> Int
simplPhases           :: Int,         -- ^ Number of simplifier phases
  DynFlags -> Int
maxSimplIterations    :: Int,         -- ^ Max simplifier iterations
  DynFlags -> Maybe String
ruleCheck             :: Maybe String,
  DynFlags -> Maybe String
inlineCheck           :: Maybe String, -- ^ A prefix to report inlining decisions about
  DynFlags -> [Int]
strictnessBefore      :: [Int],       -- ^ Additional demand analysis

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

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

  DynFlags -> Maybe Int
maxRelevantBinds      :: Maybe Int,   -- ^ Maximum number of bindings from the type envt
                                        --   to show in type error messages
  DynFlags -> Maybe Int
maxValidHoleFits      :: Maybe Int,   -- ^ Maximum number of hole fits to show
                                        --   in typed hole error messages
  DynFlags -> Maybe Int
maxRefHoleFits        :: Maybe Int,   -- ^ Maximum number of refinement hole
                                        --   fits to show in typed hole error
                                        --   messages
  DynFlags -> Maybe Int
refLevelHoleFits      :: Maybe Int,   -- ^ Maximum level of refinement for
                                        --   refinement hole fits in typed hole
                                        --   error messages
  DynFlags -> Int
maxUncoveredPatterns  :: Int,         -- ^ Maximum number of unmatched patterns to show
                                        --   in non-exhaustiveness warnings
  DynFlags -> Int
maxPmCheckModels      :: Int,         -- ^ Soft limit on the number of models
                                        --   the pattern match checker checks
                                        --   a pattern against. A safe guard
                                        --   against exponential blow-up.
  DynFlags -> Int
simplTickFactor       :: Int,         -- ^ Multiplier for simplifier ticks
  DynFlags -> Maybe Int
specConstrThreshold   :: Maybe Int,   -- ^ Threshold for SpecConstr
  DynFlags -> Maybe Int
specConstrCount       :: Maybe Int,   -- ^ Max number of specialisations for any one function
  DynFlags -> Int
specConstrRecursive   :: Int,         -- ^ Max number of specialisations for recursive types
                                        --   Not optional; otherwise ForceSpecConstr can diverge.
  DynFlags -> Word
binBlobThreshold      :: Word,        -- ^ Binary literals (e.g. strings) whose size is above
                                        --   this threshold will be dumped in a binary file
                                        --   by the assembler code generator (0 to disable)
  DynFlags -> Maybe Int
liberateCaseThreshold :: Maybe Int,   -- ^ Threshold for LiberateCase
  DynFlags -> Maybe Int
floatLamArgs          :: Maybe Int,   -- ^ Arg count for lambda floating
                                        --   See CoreMonad.FloatOutSwitches

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

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

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

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

  DynFlags -> InstalledUnitId
thisInstalledUnitId   :: InstalledUnitId,
  DynFlags -> Maybe ComponentId
thisComponentId_      :: Maybe ComponentId,
  DynFlags -> Maybe [(ModuleName, Module)]
thisUnitIdInsts_      :: Maybe [(ModuleName, Module)],

  -- ways
  DynFlags -> [Way]
ways                  :: [Way],       -- ^ Way flags from the command line
  DynFlags -> String
buildTag              :: String,      -- ^ The global \"way\" (e.g. \"p\" for prof)

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

  -- paths etc.
  DynFlags -> Maybe String
objectDir             :: Maybe String,
  DynFlags -> Maybe String
dylibInstallName      :: Maybe String,
  DynFlags -> Maybe String
hiDir                 :: Maybe String,
  DynFlags -> Maybe String
hieDir                :: Maybe String,
  DynFlags -> Maybe String
stubDir               :: Maybe String,
  DynFlags -> Maybe String
dumpDir               :: Maybe String,

  DynFlags -> String
objectSuf             :: String,
  DynFlags -> String
hcSuf                 :: String,
  DynFlags -> String
hiSuf                 :: String,
  DynFlags -> String
hieSuf                :: String,

  DynFlags -> IORef Bool
canGenerateDynamicToo :: IORef Bool,
  DynFlags -> String
dynObjectSuf          :: String,
  DynFlags -> String
dynHiSuf              :: String,

  DynFlags -> Maybe String
outputFile            :: Maybe String,
  DynFlags -> Maybe String
dynOutputFile         :: Maybe String,
  DynFlags -> Maybe String
outputHi              :: Maybe String,
  DynFlags -> DynLibLoader
dynLibLoader          :: DynLibLoader,

  -- | This is set by 'DriverPipeline.runPipeline' based on where
  --    its output is going.
  DynFlags -> Maybe String
dumpPrefix            :: Maybe FilePath,

  -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
  --    Set by @-ddump-file-prefix@
  DynFlags -> Maybe String
dumpPrefixForce       :: Maybe FilePath,

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

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

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

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

  -- Plugins
  DynFlags -> [ModuleName]
pluginModNames        :: [ModuleName],
  DynFlags -> [(ModuleName, String)]
pluginModNameOpts     :: [(ModuleName,String)],
  DynFlags -> [String]
frontendPluginOpts    :: [String],
    -- ^ the @-ffrontend-opt@ flags given on the command line, in *reverse*
    -- order that they're specified on the command line.
  DynFlags -> [LoadedPlugin]
cachedPlugins         :: [LoadedPlugin],
    -- ^ plugins dynamically loaded after processing arguments. What will be
    -- loaded here is directed by pluginModNames. Arguments are loaded from
    -- pluginModNameOpts. The purpose of this field is to cache the plugins so
    -- they don't have to be loaded each time they are needed.  See
    -- 'DynamicLoading.initializePlugins'.
  DynFlags -> [StaticPlugin]
staticPlugins            :: [StaticPlugin],
    -- ^ staic plugins which do not need dynamic loading. These plugins are
    -- intended to be added by GHC API users directly to this list.
    --
    -- To add dynamically loaded plugins through the GHC API see
    -- 'addPluginModuleName' instead.

  -- GHC API hooks
  DynFlags -> Hooks
hooks                 :: Hooks,

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

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

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

  -- Package state
  -- NB. do not modify this field, it is calculated by
  -- Packages.initPackages
  DynFlags -> Maybe [(String, [PackageConfig])]
pkgDatabase           :: Maybe [(FilePath, [PackageConfig])],
  DynFlags -> PackageState
pkgState              :: PackageState,

  -- Temporary files
  -- These have to be IORefs, because the defaultCleanupHandler needs to
  -- know what to clean when an exception happens
  DynFlags -> IORef FilesToClean
filesToClean          :: IORef FilesToClean,
  DynFlags -> IORef (Map String String)
dirsToClean           :: IORef (Map FilePath FilePath),
  -- The next available suffix to uniquely name a temp file, updated atomically
  DynFlags -> IORef Int
nextTempSuffix        :: IORef Int,

  -- Names of files which were generated from -ddump-to-file; used to
  -- track which ones we need to truncate because it's our first run
  -- through
  DynFlags -> IORef (Set String)
generatedDumps        :: IORef (Set FilePath),

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

  -- Unfolding control
  -- See Note [Discounts and thresholds] in CoreUnfold
  DynFlags -> Int
ufCreationThreshold   :: Int,
  DynFlags -> Int
ufUseThreshold        :: Int,
  DynFlags -> Int
ufFunAppDiscount      :: Int,
  DynFlags -> Int
ufDictDiscount        :: Int,
  DynFlags -> Float
ufKeenessFactor       :: Float,
  DynFlags -> Int
ufDearOp              :: Int,
  DynFlags -> Bool
ufVeryAggressive      :: Bool,

  DynFlags -> Int
maxWorkerArgs         :: Int,

  DynFlags -> Int
ghciHistSize          :: Int,

  -- | MsgDoc output action: use "ErrUtils" instead of this if you can
  DynFlags -> LogAction
log_action            :: LogAction,
  DynFlags -> FlushOut
flushOut              :: FlushOut,
  DynFlags -> FlushErr
flushErr              :: FlushErr,

  DynFlags -> Maybe String
ghcVersionFile        :: Maybe FilePath,
  DynFlags -> Maybe String
haddockOptions        :: Maybe String,

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

  -- Output style options
  DynFlags -> Int
pprUserLength         :: Int,
  DynFlags -> Int
pprCols               :: Int,

  DynFlags -> Bool
useUnicode            :: Bool,
  DynFlags -> OverridingBool
useColor              :: OverridingBool,
  DynFlags -> Bool
canUseColor           :: Bool,
  DynFlags -> Scheme
colScheme             :: Col.Scheme,

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

  DynFlags -> Maybe String
interactivePrint      :: Maybe String,

  DynFlags -> IORef (ModuleEnv Int)
nextWrapperNum        :: IORef (ModuleEnv Int),

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

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

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

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

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

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

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

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

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

  -- | Unique supply configuration for testing build determinism
  DynFlags -> Int
initialUnique         :: Int,
  DynFlags -> Int
uniqueIncrement       :: Int,

  -- | Temporary: CFG Edge weights for fast iterations
  DynFlags -> CfgWeights
cfgWeightInfo         :: CfgWeights
}

-- | Edge weights to use when generating a CFG from CMM
data CfgWeights
    = CFGWeights
    { CfgWeights -> Int
uncondWeight :: Int
    , CfgWeights -> Int
condBranchWeight :: Int
    , CfgWeights -> Int
switchWeight :: Int
    , CfgWeights -> Int
callWeight :: Int
    , CfgWeights -> Int
likelyCondWeight :: Int
    , CfgWeights -> Int
unlikelyCondWeight :: Int
    , CfgWeights -> Int
infoTablePenalty :: Int
    , CfgWeights -> Int
backEdgeBonus :: Int
    }

defaultCfgWeights :: CfgWeights
defaultCfgWeights :: CfgWeights
defaultCfgWeights
    = CFGWeights :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> CfgWeights
CFGWeights
    { uncondWeight :: Int
uncondWeight = Int
1000
    , condBranchWeight :: Int
condBranchWeight = Int
800
    , switchWeight :: Int
switchWeight = Int
1
    , callWeight :: Int
callWeight = -Int
10
    , likelyCondWeight :: Int
likelyCondWeight = Int
900
    , unlikelyCondWeight :: Int
unlikelyCondWeight = Int
300
    , infoTablePenalty :: Int
infoTablePenalty = Int
300
    , backEdgeBonus :: Int
backEdgeBonus = Int
400
    }

parseCfgWeights :: String -> CfgWeights -> CfgWeights
parseCfgWeights :: String -> CfgWeights -> CfgWeights
parseCfgWeights String
s CfgWeights
oldWeights =
        (CfgWeights -> (String, Int) -> CfgWeights)
-> CfgWeights -> [(String, Int)] -> CfgWeights
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\CfgWeights
cfg (String
n,Int
v) -> String -> Int -> CfgWeights -> CfgWeights
update String
n Int
v CfgWeights
cfg) CfgWeights
oldWeights [(String, Int)]
assignments
    where
        assignments :: [(String, Int)]
assignments = (String -> (String, Int)) -> [String] -> [(String, Int)]
forall a b. (a -> b) -> [a] -> [b]
map String -> (String, Int)
forall b. Read b => String -> (String, b)
assignment ([String] -> [(String, Int)]) -> [String] -> [(String, Int)]
forall a b. (a -> b) -> a -> b
$ String -> [String]
settings String
s
        update :: String -> Int -> CfgWeights -> CfgWeights
update String
"uncondWeight" Int
n CfgWeights
w =
            CfgWeights
w {uncondWeight :: Int
uncondWeight = Int
n}
        update String
"condBranchWeight" Int
n CfgWeights
w =
            CfgWeights
w {condBranchWeight :: Int
condBranchWeight = Int
n}
        update String
"switchWeight" Int
n CfgWeights
w =
            CfgWeights
w {switchWeight :: Int
switchWeight = Int
n}
        update String
"callWeight" Int
n CfgWeights
w =
            CfgWeights
w {callWeight :: Int
callWeight = Int
n}
        update String
"likelyCondWeight" Int
n CfgWeights
w =
            CfgWeights
w {likelyCondWeight :: Int
likelyCondWeight = Int
n}
        update String
"unlikelyCondWeight" Int
n CfgWeights
w =
            CfgWeights
w {unlikelyCondWeight :: Int
unlikelyCondWeight = Int
n}
        update String
"infoTablePenalty" Int
n CfgWeights
w =
            CfgWeights
w {infoTablePenalty :: Int
infoTablePenalty = Int
n}
        update String
"backEdgeBonus" Int
n CfgWeights
w =
            CfgWeights
w {backEdgeBonus :: Int
backEdgeBonus = Int
n}
        update String
other Int
_ CfgWeights
_
            = String -> CfgWeights
forall a. String -> a
panic (String -> CfgWeights) -> String -> CfgWeights
forall a b. (a -> b) -> a -> b
$ String
other String -> ShowS
forall a. [a] -> [a] -> [a]
++
                      String
" is not a cfg weight parameter. " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                      String
exampleString
        settings :: String -> [String]
settings String
s
            | (String
s1,String
rest) <- (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
',') String
s
            , String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
rest
            = [String
s1]
            | (String
s1,String
rest) <- (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
',') String
s
            = [String
s1] [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ String -> [String]
settings (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 String
rest)
            | Bool
otherwise = String -> [String]
forall a. String -> a
panic (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ String
"Invalid cfg parameters." String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
exampleString
        assignment :: String -> (String, b)
assignment String
as
            | (String
name, Char
_:String
val) <- (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=') String
as
            = (String
name,String -> b
forall a. Read a => String -> a
read String
val)
            | Bool
otherwise
            = String -> (String, b)
forall a. String -> a
panic (String -> (String, b)) -> String -> (String, b)
forall a b. (a -> b) -> a -> b
$ String
"Invalid cfg parameters." String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
exampleString
        exampleString :: String
exampleString = String
"Example parameters: uncondWeight=1000," String -> ShowS
forall a. [a] -> [a] -> [a]
++
            String
"condBranchWeight=800,switchWeight=0,callWeight=300" String -> ShowS
forall a. [a] -> [a] -> [a]
++
            String
",likelyCondWeight=900,unlikelyCondWeight=300" String -> ShowS
forall a. [a] -> [a] -> [a]
++
            String
",infoTablePenalty=300,backEdgeBonus=400"

backendMaintainsCfg :: DynFlags -> Bool
backendMaintainsCfg :: DynFlags -> Bool
backendMaintainsCfg DynFlags
dflags = case (Platform -> Arch
platformArch (Platform -> Arch) -> Platform -> Arch
forall a b. (a -> b) -> a -> b
$ DynFlags -> Platform
targetPlatform DynFlags
dflags) of
    -- ArchX86 -- Should work but not tested so disabled currently.
    Arch
ArchX86_64 -> Bool
True
    Arch
_otherwise -> Bool
False

class HasDynFlags m where
    getDynFlags :: m DynFlags

{- It would be desirable to have the more generalised

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

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

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

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

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

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

class ContainsDynFlags t where
    extractDynFlags :: t -> DynFlags

data ProfAuto
  = NoProfAuto         -- ^ no SCC annotations added
  | ProfAutoAll        -- ^ top-level and nested functions are annotated
  | ProfAutoTop        -- ^ top-level functions annotated only
  | ProfAutoExports    -- ^ exported functions annotated only
  | ProfAutoCalls      -- ^ annotate call-sites
  deriving (ProfAuto -> ProfAuto -> Bool
(ProfAuto -> ProfAuto -> Bool)
-> (ProfAuto -> ProfAuto -> Bool) -> Eq ProfAuto
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProfAuto -> ProfAuto -> Bool
$c/= :: ProfAuto -> ProfAuto -> Bool
== :: ProfAuto -> ProfAuto -> Bool
$c== :: ProfAuto -> ProfAuto -> Bool
Eq,Int -> ProfAuto
ProfAuto -> Int
ProfAuto -> [ProfAuto]
ProfAuto -> ProfAuto
ProfAuto -> ProfAuto -> [ProfAuto]
ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto]
(ProfAuto -> ProfAuto)
-> (ProfAuto -> ProfAuto)
-> (Int -> ProfAuto)
-> (ProfAuto -> Int)
-> (ProfAuto -> [ProfAuto])
-> (ProfAuto -> ProfAuto -> [ProfAuto])
-> (ProfAuto -> ProfAuto -> [ProfAuto])
-> (ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto])
-> Enum ProfAuto
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto]
$cenumFromThenTo :: ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto]
enumFromTo :: ProfAuto -> ProfAuto -> [ProfAuto]
$cenumFromTo :: ProfAuto -> ProfAuto -> [ProfAuto]
enumFromThen :: ProfAuto -> ProfAuto -> [ProfAuto]
$cenumFromThen :: ProfAuto -> ProfAuto -> [ProfAuto]
enumFrom :: ProfAuto -> [ProfAuto]
$cenumFrom :: ProfAuto -> [ProfAuto]
fromEnum :: ProfAuto -> Int
$cfromEnum :: ProfAuto -> Int
toEnum :: Int -> ProfAuto
$ctoEnum :: Int -> ProfAuto
pred :: ProfAuto -> ProfAuto
$cpred :: ProfAuto -> ProfAuto
succ :: ProfAuto -> ProfAuto
$csucc :: ProfAuto -> ProfAuto
Enum)

data LlvmTarget = LlvmTarget
  { LlvmTarget -> String
lDataLayout :: String
  , LlvmTarget -> String
lCPU        :: String
  , LlvmTarget -> [String]
lAttributes :: [String]
  }

-- | See Note [LLVM Configuration] in SysTools.
data LlvmConfig = LlvmConfig { LlvmConfig -> [(String, LlvmTarget)]
llvmTargets :: [(String, LlvmTarget)]
                             , LlvmConfig -> [(Int, String)]
llvmPasses  :: [(Int, String)]
                             }

-----------------------------------------------------------------------------
-- Accessessors 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 :: GhcNameVersion
-> FileSettings
-> Platform
-> ToolSettings
-> PlatformMisc
-> PlatformConstants
-> [(String, String)]
-> Settings
Settings
  { sGhcNameVersion :: GhcNameVersion
sGhcNameVersion = DynFlags -> GhcNameVersion
ghcNameVersion DynFlags
dflags
  , sFileSettings :: FileSettings
sFileSettings = DynFlags -> FileSettings
fileSettings DynFlags
dflags
  , sTargetPlatform :: Platform
sTargetPlatform = DynFlags -> Platform
targetPlatform DynFlags
dflags
  , sToolSettings :: ToolSettings
sToolSettings = DynFlags -> ToolSettings
toolSettings DynFlags
dflags
  , sPlatformMisc :: PlatformMisc
sPlatformMisc = DynFlags -> PlatformMisc
platformMisc DynFlags
dflags
  , sPlatformConstants :: PlatformConstants
sPlatformConstants = DynFlags -> PlatformConstants
platformConstants DynFlags
dflags
  , sRawSettings :: [(String, String)]
sRawSettings = DynFlags -> [(String, String)]
rawSettings DynFlags
dflags
  }

programName :: DynFlags -> String
programName :: DynFlags -> String
programName DynFlags
dflags = GhcNameVersion -> String
ghcNameVersion_programName (GhcNameVersion -> String) -> GhcNameVersion -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> GhcNameVersion
ghcNameVersion DynFlags
dflags
projectVersion :: DynFlags -> String
projectVersion :: DynFlags -> String
projectVersion DynFlags
dflags = GhcNameVersion -> String
ghcNameVersion_projectVersion (DynFlags -> GhcNameVersion
ghcNameVersion DynFlags
dflags)
ghcUsagePath          :: DynFlags -> FilePath
ghcUsagePath :: DynFlags -> String
ghcUsagePath DynFlags
dflags = FileSettings -> String
fileSettings_ghcUsagePath (FileSettings -> String) -> FileSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
ghciUsagePath         :: DynFlags -> FilePath
ghciUsagePath :: DynFlags -> String
ghciUsagePath DynFlags
dflags = FileSettings -> String
fileSettings_ghciUsagePath (FileSettings -> String) -> FileSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
toolDir               :: DynFlags -> Maybe FilePath
toolDir :: DynFlags -> Maybe String
toolDir DynFlags
dflags = FileSettings -> Maybe String
fileSettings_toolDir (FileSettings -> Maybe String) -> FileSettings -> Maybe String
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
topDir                :: DynFlags -> FilePath
topDir :: DynFlags -> String
topDir DynFlags
dflags = FileSettings -> String
fileSettings_topDir (FileSettings -> String) -> FileSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
tmpDir                :: DynFlags -> String
tmpDir :: DynFlags -> String
tmpDir DynFlags
dflags = FileSettings -> String
fileSettings_tmpDir (FileSettings -> String) -> FileSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
extraGccViaCFlags     :: DynFlags -> [String]
extraGccViaCFlags :: DynFlags -> [String]
extraGccViaCFlags DynFlags
dflags = ToolSettings -> [String]
toolSettings_extraGccViaCFlags (ToolSettings -> [String]) -> ToolSettings -> [String]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
systemPackageConfig   :: DynFlags -> FilePath
systemPackageConfig :: DynFlags -> String
systemPackageConfig DynFlags
dflags = FileSettings -> String
fileSettings_systemPackageConfig (FileSettings -> String) -> FileSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
pgm_L                 :: DynFlags -> String
pgm_L :: DynFlags -> String
pgm_L DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_L (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_P                 :: DynFlags -> (String,[Option])
pgm_P :: DynFlags -> (String, [Option])
pgm_P DynFlags
dflags = ToolSettings -> (String, [Option])
toolSettings_pgm_P (ToolSettings -> (String, [Option]))
-> ToolSettings -> (String, [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_F                 :: DynFlags -> String
pgm_F :: DynFlags -> String
pgm_F DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_F (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_c                 :: DynFlags -> String
pgm_c :: DynFlags -> String
pgm_c DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_c (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_a                 :: DynFlags -> (String,[Option])
pgm_a :: DynFlags -> (String, [Option])
pgm_a DynFlags
dflags = ToolSettings -> (String, [Option])
toolSettings_pgm_a (ToolSettings -> (String, [Option]))
-> ToolSettings -> (String, [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_l                 :: DynFlags -> (String,[Option])
pgm_l :: DynFlags -> (String, [Option])
pgm_l DynFlags
dflags = ToolSettings -> (String, [Option])
toolSettings_pgm_l (ToolSettings -> (String, [Option]))
-> ToolSettings -> (String, [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_dll               :: DynFlags -> (String,[Option])
pgm_dll :: DynFlags -> (String, [Option])
pgm_dll DynFlags
dflags = ToolSettings -> (String, [Option])
toolSettings_pgm_dll (ToolSettings -> (String, [Option]))
-> ToolSettings -> (String, [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_T                 :: DynFlags -> String
pgm_T :: DynFlags -> String
pgm_T DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_T (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_windres           :: DynFlags -> String
pgm_windres :: DynFlags -> String
pgm_windres DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_windres (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_libtool           :: DynFlags -> String
pgm_libtool :: DynFlags -> String
pgm_libtool DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_libtool (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lcc               :: DynFlags -> (String,[Option])
pgm_lcc :: DynFlags -> (String, [Option])
pgm_lcc DynFlags
dflags = ToolSettings -> (String, [Option])
toolSettings_pgm_lcc (ToolSettings -> (String, [Option]))
-> ToolSettings -> (String, [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_ar                :: DynFlags -> String
pgm_ar :: DynFlags -> String
pgm_ar DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_ar (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_ranlib            :: DynFlags -> String
pgm_ranlib :: DynFlags -> String
pgm_ranlib DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_ranlib (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lo                :: DynFlags -> (String,[Option])
pgm_lo :: DynFlags -> (String, [Option])
pgm_lo DynFlags
dflags = ToolSettings -> (String, [Option])
toolSettings_pgm_lo (ToolSettings -> (String, [Option]))
-> ToolSettings -> (String, [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lc                :: DynFlags -> (String,[Option])
pgm_lc :: DynFlags -> (String, [Option])
pgm_lc DynFlags
dflags = ToolSettings -> (String, [Option])
toolSettings_pgm_lc (ToolSettings -> (String, [Option]))
-> ToolSettings -> (String, [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_i                 :: DynFlags -> String
pgm_i :: DynFlags -> String
pgm_i DynFlags
dflags = ToolSettings -> String
toolSettings_pgm_i (ToolSettings -> String) -> ToolSettings -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_L                 :: DynFlags -> [String]
opt_L :: DynFlags -> [String]
opt_L DynFlags
dflags = ToolSettings -> [String]
toolSettings_opt_L (ToolSettings -> [String]) -> ToolSettings -> [String]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_P                 :: DynFlags -> [String]
opt_P :: DynFlags -> [String]
opt_P DynFlags
dflags = (Way -> [String]) -> [Way] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [String]
wayOptP (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> [Way]
ways DynFlags
dflags)
            [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [String]
toolSettings_opt_P (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)

-- This function packages everything that's needed to fingerprint opt_P
-- flags. See Note [Repeated -optP hashing].
opt_P_signature       :: DynFlags -> ([String], Fingerprint)
opt_P_signature :: DynFlags -> ([String], Fingerprint)
opt_P_signature DynFlags
dflags =
  ( (Way -> [String]) -> [Way] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [String]
wayOptP (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> [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
  )

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

tablesNextToCode :: DynFlags -> Bool
tablesNextToCode :: DynFlags -> Bool
tablesNextToCode = PlatformMisc -> Bool
platformMisc_tablesNextToCode (PlatformMisc -> Bool)
-> (DynFlags -> PlatformMisc) -> DynFlags -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DynFlags -> PlatformMisc
platformMisc

-- | The directory for this version of ghc in the user's app directory
-- (typically something like @~/.ghc/x86_64-linux-7.6.3@)
--
versionedAppDir :: DynFlags -> MaybeT IO FilePath
versionedAppDir :: DynFlags -> MaybeT IO String
versionedAppDir DynFlags
dflags = do
  -- Make sure we handle the case the HOME isn't set (see #11678)
  String
appdir <- IO String -> MaybeT IO String
forall a. IO a -> MaybeT IO a
tryMaybeT (IO String -> MaybeT IO String) -> IO String -> MaybeT IO String
forall a b. (a -> b) -> a -> b
$ String -> IO String
getAppUserDataDirectory (DynFlags -> String
programName DynFlags
dflags)
  String -> MaybeT IO String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> MaybeT IO String) -> String -> MaybeT IO String
forall a b. (a -> b) -> a -> b
$ String
appdir String -> ShowS
</> DynFlags -> String
versionedFilePath DynFlags
dflags

versionedFilePath :: DynFlags -> FilePath
versionedFilePath :: DynFlags -> String
versionedFilePath DynFlags
dflags = PlatformMini -> String
uniqueSubdir (PlatformMini -> String) -> PlatformMini -> String
forall a b. (a -> b) -> a -> b
$ Platform -> PlatformMini
platformMini (Platform -> PlatformMini) -> Platform -> PlatformMini
forall a b. (a -> b) -> a -> b
$ DynFlags -> Platform
targetPlatform DynFlags
dflags

-- | The target code type of the compilation (if any).
--
-- Whenever you change the target, also make sure to set 'ghcLink' to
-- something sensible.
--
-- 'HscNothing' can be used to avoid generating any output, however, note
-- that:
--
--  * If a program uses Template Haskell the typechecker may need to run code
--    from an imported module.  To facilitate this, code generation is enabled
--    for modules imported by modules that use template haskell.
--    See Note [-fno-code mode].
--
data HscTarget
  = HscC           -- ^ Generate C code.
  | HscAsm         -- ^ Generate assembly using the native code generator.
  | HscLlvm        -- ^ Generate assembly using the llvm code generator.
  | HscInterpreted -- ^ Generate bytecode.  (Requires 'LinkInMemory')
  | HscNothing     -- ^ Don't generate any code.  See notes above.
  deriving (HscTarget -> HscTarget -> Bool
(HscTarget -> HscTarget -> Bool)
-> (HscTarget -> HscTarget -> Bool) -> Eq HscTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HscTarget -> HscTarget -> Bool
$c/= :: HscTarget -> HscTarget -> Bool
== :: HscTarget -> HscTarget -> Bool
$c== :: HscTarget -> HscTarget -> Bool
Eq, Int -> HscTarget -> ShowS
[HscTarget] -> ShowS
HscTarget -> String
(Int -> HscTarget -> ShowS)
-> (HscTarget -> String)
-> ([HscTarget] -> ShowS)
-> Show HscTarget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HscTarget] -> ShowS
$cshowList :: [HscTarget] -> ShowS
show :: HscTarget -> String
$cshow :: HscTarget -> String
showsPrec :: Int -> HscTarget -> ShowS
$cshowsPrec :: Int -> HscTarget -> ShowS
Show)

-- | Will this target result in an object file on the disk?
isObjectTarget :: HscTarget -> Bool
isObjectTarget :: HscTarget -> Bool
isObjectTarget HscTarget
HscC     = Bool
True
isObjectTarget HscTarget
HscAsm   = Bool
True
isObjectTarget HscTarget
HscLlvm  = Bool
True
isObjectTarget HscTarget
_        = Bool
False

-- | Does this target retain *all* top-level bindings for a module,
-- rather than just the exported bindings, in the TypeEnv and compiled
-- code (if any)?  In interpreted mode we do this, so that GHCi can
-- call functions inside a module.  In HscNothing mode we also do it,
-- so that Haddock can get access to the GlobalRdrEnv for a module
-- after typechecking it.
targetRetainsAllBindings :: HscTarget -> Bool
targetRetainsAllBindings :: HscTarget -> Bool
targetRetainsAllBindings HscTarget
HscInterpreted = Bool
True
targetRetainsAllBindings HscTarget
HscNothing     = Bool
True
targetRetainsAllBindings HscTarget
_              = Bool
False

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

instance Outputable GhcMode where
  ppr :: GhcMode -> SDoc
ppr GhcMode
CompManager = String -> SDoc
text String
"CompManager"
  ppr GhcMode
OneShot     = String -> SDoc
text String
"OneShot"
  ppr GhcMode
MkDepend    = String -> SDoc
text String
"MkDepend"

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

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

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

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

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

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

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

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

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

packageFlagsChanged :: DynFlags -> DynFlags -> Bool
packageFlagsChanged :: DynFlags -> DynFlags -> Bool
packageFlagsChanged DynFlags
idflags1 DynFlags
idflags0 =
  DynFlags -> [PackageFlag]
packageFlags DynFlags
idflags1 [PackageFlag] -> [PackageFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageFlag]
packageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [IgnorePackageFlag]
ignorePackageFlags DynFlags
idflags1 [IgnorePackageFlag] -> [IgnorePackageFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [IgnorePackageFlag]
ignorePackageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [PackageFlag]
pluginPackageFlags DynFlags
idflags1 [PackageFlag] -> [PackageFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageFlag]
pluginPackageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [TrustFlag]
trustFlags DynFlags
idflags1 [TrustFlag] -> [TrustFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [TrustFlag]
trustFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
idflags1 [PackageDBFlag] -> [PackageDBFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [Bool]
packageGFlags DynFlags
idflags1 [Bool] -> [Bool] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [Bool]
packageGFlags DynFlags
idflags0
 where
   packageGFlags :: DynFlags -> [Bool]
packageGFlags DynFlags
dflags = (GeneralFlag -> Bool) -> [GeneralFlag] -> [Bool]
forall a b. (a -> b) -> [a] -> [b]
map (GeneralFlag -> DynFlags -> Bool
`gopt` DynFlags
dflags)
     [ GeneralFlag
Opt_HideAllPackages
     , GeneralFlag
Opt_HideAllPluginPackages
     , GeneralFlag
Opt_AutoLinkPackages ]

instance Outputable PackageFlag where
    ppr :: PackageFlag -> SDoc
ppr (ExposePackage String
n PackageArg
arg ModRenaming
rn) = String -> SDoc
text String
n SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
braces (PackageArg -> SDoc
forall a. Outputable a => a -> SDoc
ppr PackageArg
arg SDoc -> SDoc -> SDoc
<+> ModRenaming -> SDoc
forall a. Outputable a => a -> SDoc
ppr ModRenaming
rn)
    ppr (HidePackage String
str) = String -> SDoc
text String
"-hide-package" SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
str

-- | The 'HscTarget' value corresponding to the default way to create
-- object files on the current platform.

defaultHscTarget :: Platform -> PlatformMisc -> HscTarget
defaultHscTarget :: Platform -> PlatformMisc -> HscTarget
defaultHscTarget Platform
platform PlatformMisc
pMisc
  | Platform -> Bool
platformUnregisterised Platform
platform = HscTarget
HscC
  | PlatformMisc -> Bool
platformMisc_ghcWithNativeCodeGen PlatformMisc
pMisc = HscTarget
HscAsm
  | Bool
otherwise = HscTarget
HscLlvm

defaultObjectTarget :: DynFlags -> HscTarget
defaultObjectTarget :: DynFlags -> HscTarget
defaultObjectTarget DynFlags
dflags = Platform -> PlatformMisc -> HscTarget
defaultHscTarget
  (DynFlags -> Platform
targetPlatform DynFlags
dflags)
  (DynFlags -> PlatformMisc
platformMisc DynFlags
dflags)

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

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

shouldUseColor :: DynFlags -> Bool
shouldUseColor :: DynFlags -> Bool
shouldUseColor DynFlags
dflags = Bool -> OverridingBool -> Bool
overrideWith (DynFlags -> Bool
canUseColor DynFlags
dflags) (DynFlags -> OverridingBool
useColor DynFlags
dflags)

shouldUseHexWordLiterals :: DynFlags -> Bool
shouldUseHexWordLiterals :: DynFlags -> Bool
shouldUseHexWordLiterals DynFlags
dflags =
  GeneralFlag
Opt_HexWordLiterals GeneralFlag -> EnumSet GeneralFlag -> Bool
forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
dflags

-- | Are we building with @-fPIE@ or @-fPIC@ enabled?
positionIndependent :: DynFlags -> Bool
positionIndependent :: DynFlags -> Bool
positionIndependent DynFlags
dflags = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags Bool -> Bool -> Bool
|| GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIE DynFlags
dflags

-----------------------------------------------------------------------------
-- Ways

-- The central concept of a "way" is that all objects in a given
-- program must be compiled in the same "way".  Certain options change
-- parameters of the virtual machine, eg. profiling adds an extra word
-- to the object header, so profiling objects cannot be linked with
-- non-profiling objects.

-- After parsing the command-line options, we determine which "way" we
-- are building - this might be a combination way, eg. profiling+threaded.

-- We then find the "build-tag" associated with this way, and this
-- becomes the suffix used to find .hi files and libraries used in
-- this compilation.

data Way
  = WayCustom String -- for GHC API clients building custom variants
  | WayThreaded
  | WayDebug
  | WayProf
  | WayEventLog
  | WayDyn
  deriving (Way -> Way -> Bool
(Way -> Way -> Bool) -> (Way -> Way -> Bool) -> Eq Way
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Way -> Way -> Bool
$c/= :: Way -> Way -> Bool
== :: Way -> Way -> Bool
$c== :: Way -> Way -> Bool
Eq, Eq Way
Eq Way
-> (Way -> Way -> Ordering)
-> (Way -> Way -> Bool)
-> (Way -> Way -> Bool)
-> (Way -> Way -> Bool)
-> (Way -> Way -> Bool)
-> (Way -> Way -> Way)
-> (Way -> Way -> Way)
-> Ord Way
Way -> Way -> Bool
Way -> Way -> Ordering
Way -> Way -> Way
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Way -> Way -> Way
$cmin :: Way -> Way -> Way
max :: Way -> Way -> Way
$cmax :: Way -> Way -> Way
>= :: Way -> Way -> Bool
$c>= :: Way -> Way -> Bool
> :: Way -> Way -> Bool
$c> :: Way -> Way -> Bool
<= :: Way -> Way -> Bool
$c<= :: Way -> Way -> Bool
< :: Way -> Way -> Bool
$c< :: Way -> Way -> Bool
compare :: Way -> Way -> Ordering
$ccompare :: Way -> Way -> Ordering
$cp1Ord :: Eq Way
Ord, Int -> Way -> ShowS
[Way] -> ShowS
Way -> String
(Int -> Way -> ShowS)
-> (Way -> String) -> ([Way] -> ShowS) -> Show Way
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Way] -> ShowS
$cshowList :: [Way] -> ShowS
show :: Way -> String
$cshow :: Way -> String
showsPrec :: Int -> Way -> ShowS
$cshowsPrec :: Int -> Way -> ShowS
Show)

allowed_combination :: [Way] -> Bool
allowed_combination :: [Way] -> Bool
allowed_combination [Way]
way = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [ Way
x Way -> Way -> Bool
`allowedWith` Way
y
                              | Way
x <- [Way]
way, Way
y <- [Way]
way, Way
x Way -> Way -> Bool
forall a. Ord a => a -> a -> Bool
< Way
y ]
  where
        -- Note ordering in these tests: the left argument is
        -- <= the right argument, according to the Ord instance
        -- on Way above.

        -- dyn is allowed with everything
        Way
_ allowedWith :: Way -> Way -> Bool
`allowedWith` Way
WayDyn                  = Bool
True
        Way
WayDyn `allowedWith` Way
_                  = Bool
True

        -- debug is allowed with everything
        Way
_ `allowedWith` Way
WayDebug                = Bool
True
        Way
WayDebug `allowedWith` Way
_                = Bool
True

        (WayCustom {}) `allowedWith` Way
_          = Bool
True
        Way
WayThreaded `allowedWith` Way
WayProf       = Bool
True
        Way
WayThreaded `allowedWith` Way
WayEventLog   = Bool
True
        Way
WayProf     `allowedWith` Way
WayEventLog   = Bool
True
        Way
_ `allowedWith` Way
_                       = Bool
False

mkBuildTag :: [Way] -> String
mkBuildTag :: [Way] -> String
mkBuildTag [Way]
ways = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (String -> [String] -> [String]
forall a. a -> [a] -> [a]
intersperse String
"_" ((Way -> String) -> [Way] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Way -> String
wayTag [Way]
ways))

wayTag :: Way -> String
wayTag :: Way -> String
wayTag (WayCustom String
xs) = String
xs
wayTag Way
WayThreaded = String
"thr"
wayTag Way
WayDebug    = String
"debug"
wayTag Way
WayDyn      = String
"dyn"
wayTag Way
WayProf     = String
"p"
wayTag Way
WayEventLog = String
"l"

wayRTSOnly :: Way -> Bool
wayRTSOnly :: Way -> Bool
wayRTSOnly (WayCustom {}) = Bool
False
wayRTSOnly Way
WayThreaded = Bool
True
wayRTSOnly Way
WayDebug    = Bool
True
wayRTSOnly Way
WayDyn      = Bool
False
wayRTSOnly Way
WayProf     = Bool
False
wayRTSOnly Way
WayEventLog = Bool
True

wayDesc :: Way -> String
wayDesc :: Way -> String
wayDesc (WayCustom String
xs) = String
xs
wayDesc Way
WayThreaded = String
"Threaded"
wayDesc Way
WayDebug    = String
"Debug"
wayDesc Way
WayDyn      = String
"Dynamic"
wayDesc Way
WayProf     = String
"Profiling"
wayDesc Way
WayEventLog = String
"RTS Event Logging"

-- Turn these flags on when enabling this way
wayGeneralFlags :: Platform -> Way -> [GeneralFlag]
wayGeneralFlags :: Platform -> Way -> [GeneralFlag]
wayGeneralFlags Platform
_ (WayCustom {}) = []
wayGeneralFlags Platform
_ Way
WayThreaded = []
wayGeneralFlags Platform
_ Way
WayDebug    = []
wayGeneralFlags Platform
_ Way
WayDyn      = [GeneralFlag
Opt_PIC, GeneralFlag
Opt_ExternalDynamicRefs]
    -- We could get away without adding -fPIC when compiling the
    -- modules of a program that is to be linked with -dynamic; the
    -- program itself does not need to be position-independent, only
    -- the libraries need to be.  HOWEVER, GHCi links objects into a
    -- .so before loading the .so using the system linker.  Since only
    -- PIC objects can be linked into a .so, we have to compile even
    -- modules of the main program with -fPIC when using -dynamic.
wayGeneralFlags Platform
_ Way
WayProf     = [GeneralFlag
Opt_SccProfilingOn]
wayGeneralFlags Platform
_ Way
WayEventLog = []

-- Turn these flags off when enabling this way
wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]
wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]
wayUnsetGeneralFlags Platform
_ (WayCustom {}) = []
wayUnsetGeneralFlags Platform
_ Way
WayThreaded = []
wayUnsetGeneralFlags Platform
_ Way
WayDebug    = []
wayUnsetGeneralFlags Platform
_ Way
WayDyn      = [-- There's no point splitting
                                      -- when we're going to be dynamically
                                      -- linking. Plus it breaks compilation
                                      -- on OSX x86.
                                      GeneralFlag
Opt_SplitSections]
wayUnsetGeneralFlags Platform
_ Way
WayProf     = []
wayUnsetGeneralFlags Platform
_ Way
WayEventLog = []

wayOptc :: Platform -> Way -> [String]
wayOptc :: Platform -> Way -> [String]
wayOptc Platform
_ (WayCustom {}) = []
wayOptc Platform
platform Way
WayThreaded = case Platform -> OS
platformOS Platform
platform of
                               OS
OSOpenBSD -> [String
"-pthread"]
                               OS
OSNetBSD  -> [String
"-pthread"]
                               OS
_         -> []
wayOptc Platform
_ Way
WayDebug      = []
wayOptc Platform
_ Way
WayDyn        = []
wayOptc Platform
_ Way
WayProf       = [String
"-DPROFILING"]
wayOptc Platform
_ Way
WayEventLog   = [String
"-DTRACING"]

wayOptl :: Platform -> Way -> [String]
wayOptl :: Platform -> Way -> [String]
wayOptl Platform
_ (WayCustom {}) = []
wayOptl Platform
platform Way
WayThreaded =
        case Platform -> OS
platformOS Platform
platform of
        OS
OSFreeBSD  -> [String
"-pthread"]
        OS
OSOpenBSD  -> [String
"-pthread"]
        OS
OSNetBSD   -> [String
"-pthread"]
        OS
_          -> []
wayOptl Platform
_ Way
WayDebug      = []
wayOptl Platform
_ Way
WayDyn        = []
wayOptl Platform
_ Way
WayProf       = []
wayOptl Platform
_ Way
WayEventLog   = []

wayOptP :: Platform -> Way -> [String]
wayOptP :: Platform -> Way -> [String]
wayOptP Platform
_ (WayCustom {}) = []
wayOptP Platform
_ Way
WayThreaded = []
wayOptP Platform
_ Way
WayDebug    = []
wayOptP Platform
_ Way
WayDyn      = []
wayOptP Platform
_ Way
WayProf     = [String
"-DPROFILING"]
wayOptP Platform
_ Way
WayEventLog = [String
"-DTRACING"]

whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
whenGeneratingDynamicToo :: DynFlags -> m () -> m ()
whenGeneratingDynamicToo DynFlags
dflags m ()
f = DynFlags -> m () -> m () -> m ()
forall (m :: * -> *) a. MonadIO m => DynFlags -> m a -> m a -> m a
ifGeneratingDynamicToo DynFlags
dflags m ()
f (() -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ())

ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a
ifGeneratingDynamicToo :: DynFlags -> m a -> m a -> m a
ifGeneratingDynamicToo DynFlags
dflags m a
f m a
g = DynFlags -> m a -> m a -> m a -> m a
forall (m :: * -> *) a.
MonadIO m =>
DynFlags -> m a -> m a -> m a -> m a
generateDynamicTooConditional DynFlags
dflags m a
f m a
g m a
g

whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
whenCannotGenerateDynamicToo :: DynFlags -> m () -> m ()
whenCannotGenerateDynamicToo DynFlags
dflags m ()
f
    = DynFlags -> m () -> m () -> m ()
forall (m :: * -> *) a. MonadIO m => DynFlags -> m a -> m a -> m a
ifCannotGenerateDynamicToo DynFlags
dflags m ()
f (() -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ())

ifCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a
ifCannotGenerateDynamicToo :: DynFlags -> m a -> m a -> m a
ifCannotGenerateDynamicToo DynFlags
dflags m a
f m a
g
    = DynFlags -> m a -> m a -> m a -> m a
forall (m :: * -> *) a.
MonadIO m =>
DynFlags -> m a -> m a -> m a -> m a
generateDynamicTooConditional DynFlags
dflags m a
g m a
f m a
g

generateDynamicTooConditional :: MonadIO m
                              => DynFlags -> m a -> m a -> m a -> m a
generateDynamicTooConditional :: DynFlags -> m a -> m a -> m a -> m a
generateDynamicTooConditional DynFlags
dflags m a
canGen m a
cannotGen m a
notTryingToGen
    = if GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_BuildDynamicToo DynFlags
dflags
      then do let ref :: IORef Bool
ref = DynFlags -> IORef Bool
canGenerateDynamicToo DynFlags
dflags
              Bool
b <- IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ IORef Bool -> IO Bool
forall a. IORef a -> IO a
readIORef IORef Bool
ref
              if Bool
b then m a
canGen else m a
cannotGen
      else m a
notTryingToGen

dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags
dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags
dynamicTooMkDynamicDynFlags DynFlags
dflags0
    = let dflags1 :: DynFlags
dflags1 = Way -> DynFlags -> DynFlags
addWay' Way
WayDyn DynFlags
dflags0
          dflags2 :: DynFlags
dflags2 = DynFlags
dflags1 {
                        outputFile :: Maybe String
outputFile = DynFlags -> Maybe String
dynOutputFile DynFlags
dflags1,
                        hiSuf :: String
hiSuf = DynFlags -> String
dynHiSuf DynFlags
dflags1,
                        objectSuf :: String
objectSuf = DynFlags -> String
dynObjectSuf DynFlags
dflags1
                    }
          dflags3 :: DynFlags
dflags3 = DynFlags -> DynFlags
updateWays DynFlags
dflags2
          dflags4 :: DynFlags
dflags4 = DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags3 GeneralFlag
Opt_BuildDynamicToo
      in DynFlags
dflags4

-- | Compute the path of the dynamic object corresponding to an object file.
dynamicOutputFile :: DynFlags -> FilePath -> FilePath
dynamicOutputFile :: DynFlags -> ShowS
dynamicOutputFile DynFlags
dflags String
outputFile = ShowS
dynOut String
outputFile
  where
    dynOut :: ShowS
dynOut = (String -> ShowS) -> String -> ShowS
forall a b c. (a -> b -> c) -> b -> a -> c
flip String -> ShowS
addExtension (DynFlags -> String
dynObjectSuf DynFlags
dflags) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
dropExtension

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

-- | Used by 'GHC.runGhc' to partially initialize a new 'DynFlags' value
initDynFlags :: DynFlags -> IO DynFlags
initDynFlags :: DynFlags -> IO DynFlags
initDynFlags DynFlags
dflags = do
 let -- We can't build with dynamic-too on Windows, as labels before
     -- the fork point are different depending on whether we are
     -- building dynamically or not.
     platformCanGenerateDynamicToo :: Bool
platformCanGenerateDynamicToo
         = Platform -> OS
platformOS (DynFlags -> Platform
targetPlatform DynFlags
dflags) OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
/= OS
OSMinGW32
 IORef Bool
refCanGenerateDynamicToo <- Bool -> IO (IORef Bool)
forall a. a -> IO (IORef a)
newIORef Bool
platformCanGenerateDynamicToo
 IORef Int
refNextTempSuffix <- Int -> IO (IORef Int)
forall a. a -> IO (IORef a)
newIORef Int
0
 IORef FilesToClean
refFilesToClean <- FilesToClean -> IO (IORef FilesToClean)
forall a. a -> IO (IORef a)
newIORef FilesToClean
emptyFilesToClean
 IORef (Map String String)
refDirsToClean <- Map String String -> IO (IORef (Map String String))
forall a. a -> IO (IORef a)
newIORef Map String String
forall k a. Map k a
Map.empty
 IORef (Set String)
refGeneratedDumps <- Set String -> IO (IORef (Set String))
forall a. a -> IO (IORef a)
newIORef Set String
forall a. Set a
Set.empty
 IORef (Maybe LinkerInfo)
refRtldInfo <- Maybe LinkerInfo -> IO (IORef (Maybe LinkerInfo))
forall a. a -> IO (IORef a)
newIORef Maybe LinkerInfo
forall a. Maybe a
Nothing
 IORef (Maybe CompilerInfo)
refRtccInfo <- Maybe CompilerInfo -> IO (IORef (Maybe CompilerInfo))
forall a. a -> IO (IORef a)
newIORef Maybe CompilerInfo
forall a. Maybe a
Nothing
 IORef (ModuleEnv Int)
wrapperNum <- ModuleEnv Int -> IO (IORef (ModuleEnv Int))
forall a. a -> IO (IORef a)
newIORef ModuleEnv Int
forall a. ModuleEnv a
emptyModuleEnv
 Bool
canUseUnicode <- do let enc :: TextEncoding
enc = TextEncoding
localeEncoding
                         str :: String
str = String
"‘’"
                     (TextEncoding -> String -> (CString -> IO Bool) -> IO Bool
forall a. TextEncoding -> String -> (CString -> IO a) -> IO a
withCString TextEncoding
enc String
str ((CString -> IO Bool) -> IO Bool)
-> (CString -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \CString
cstr ->
                          do String
str' <- TextEncoding -> CString -> IO String
peekCString TextEncoding
enc CString
cstr
                             Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (String
str String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
str'))
                         IO Bool -> (IOError -> IO Bool) -> IO Bool
forall a. IO a -> (IOError -> IO a) -> IO a
`catchIOError` \IOError
_ -> Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
 Maybe String
maybeGhcNoUnicodeEnv <- String -> IO (Maybe String)
lookupEnv String
"GHC_NO_UNICODE"
 let adjustNoUnicode :: Maybe a -> Bool
adjustNoUnicode (Just a
_) = Bool
False
     adjustNoUnicode Maybe a
Nothing = Bool
True
 let useUnicode' :: Bool
useUnicode' = (Maybe String -> Bool
forall a. Maybe a -> Bool
adjustNoUnicode Maybe String
maybeGhcNoUnicodeEnv) Bool -> Bool -> Bool
&& Bool
canUseUnicode
 Bool
canUseColor <- IO Bool
stderrSupportsAnsiColors
 Maybe String
maybeGhcColorsEnv  <- String -> IO (Maybe String)
lookupEnv String
"GHC_COLORS"
 Maybe String
maybeGhcColoursEnv <- String -> IO (Maybe String)
lookupEnv String
"GHC_COLOURS"
 let adjustCols :: Maybe String
-> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
adjustCols (Just String
env) = String -> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
Col.parseScheme String
env
     adjustCols Maybe String
Nothing    = (OverridingBool, Scheme) -> (OverridingBool, Scheme)
forall a. a -> a
id
 let (OverridingBool
useColor', Scheme
colScheme') =
       (Maybe String
-> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
adjustCols Maybe String
maybeGhcColoursEnv ((OverridingBool, Scheme) -> (OverridingBool, Scheme))
-> ((OverridingBool, Scheme) -> (OverridingBool, Scheme))
-> (OverridingBool, Scheme)
-> (OverridingBool, Scheme)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe String
-> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
adjustCols Maybe String
maybeGhcColorsEnv)
       (DynFlags -> OverridingBool
useColor DynFlags
dflags, DynFlags -> Scheme
colScheme DynFlags
dflags)
 DynFlags -> IO DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
dflags{
        canGenerateDynamicToo :: IORef Bool
canGenerateDynamicToo = IORef Bool
refCanGenerateDynamicToo,
        nextTempSuffix :: IORef Int
nextTempSuffix = IORef Int
refNextTempSuffix,
        filesToClean :: IORef FilesToClean
filesToClean   = IORef FilesToClean
refFilesToClean,
        dirsToClean :: IORef (Map String String)
dirsToClean    = IORef (Map String String)
refDirsToClean,
        generatedDumps :: IORef (Set String)
generatedDumps = IORef (Set String)
refGeneratedDumps,
        nextWrapperNum :: IORef (ModuleEnv Int)
nextWrapperNum = IORef (ModuleEnv Int)
wrapperNum,
        useUnicode :: Bool
useUnicode    = Bool
useUnicode',
        useColor :: OverridingBool
useColor      = OverridingBool
useColor',
        canUseColor :: Bool
canUseColor   = Bool
canUseColor,
        colScheme :: Scheme
colScheme     = Scheme
colScheme',
        rtldInfo :: IORef (Maybe LinkerInfo)
rtldInfo      = IORef (Maybe LinkerInfo)
refRtldInfo,
        rtccInfo :: IORef (Maybe CompilerInfo)
rtccInfo      = IORef (Maybe CompilerInfo)
refRtccInfo
        }

-- | The normal 'DynFlags'. Note that they are not suitable for use in this form
-- and must be fully initialized by 'GHC.runGhc' first.
defaultDynFlags :: Settings -> LlvmConfig -> DynFlags
defaultDynFlags :: Settings -> LlvmConfig -> DynFlags
defaultDynFlags Settings
mySettings LlvmConfig
llvmConfig =
-- See Note [Updating flag description in the User's Guide]
     DynFlags :: GhcMode
-> GhcLink
-> HscTarget
-> GhcNameVersion
-> FileSettings
-> Platform
-> ToolSettings
-> PlatformMisc
-> PlatformConstants
-> [(String, String)]
-> IntegerLibrary
-> LlvmConfig
-> Int
-> Int
-> Int
-> Int
-> Int
-> Maybe String
-> Maybe String
-> [Int]
-> Maybe Int
-> Bool
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Int
-> Int
-> Int
-> Maybe Int
-> Maybe Int
-> Int
-> Word
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Bool
-> Maybe Int
-> Int
-> [String]
-> Module
-> Maybe String
-> IntWithInf
-> IntWithInf
-> InstalledUnitId
-> Maybe ComponentId
-> Maybe [(ModuleName, Module)]
-> [Way]
-> String
-> Maybe (String, Int)
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> String
-> String
-> String
-> String
-> IORef Bool
-> String
-> String
-> Maybe String
-> Maybe String
-> Maybe String
-> DynLibLoader
-> Maybe String
-> Maybe String
-> [Option]
-> IncludeSpecs
-> [String]
-> [String]
-> [String]
-> Maybe String
-> RtsOptsEnabled
-> Bool
-> String
-> [ModuleName]
-> [(ModuleName, String)]
-> [String]
-> [LoadedPlugin]
-> [StaticPlugin]
-> Hooks
-> String
-> Bool
-> Bool
-> [ModuleName]
-> [String]
-> [PackageDBFlag]
-> [IgnorePackageFlag]
-> [PackageFlag]
-> [PackageFlag]
-> [TrustFlag]
-> Maybe String
-> Maybe [(String, [PackageConfig])]
-> PackageState
-> IORef FilesToClean
-> IORef (Map String String)
-> IORef Int
-> IORef (Set String)
-> EnumSet DumpFlag
-> EnumSet GeneralFlag
-> EnumSet WarningFlag
-> EnumSet WarningFlag
-> Maybe Language
-> SafeHaskellMode
-> Bool
-> Bool
-> SrcSpan
-> SrcSpan
-> SrcSpan
-> SrcSpan
-> SrcSpan
-> SrcSpan
-> SrcSpan
-> SrcSpan
-> [OnOff Extension]
-> EnumSet Extension
-> Int
-> Int
-> Int
-> Int
-> Float
-> Int
-> Bool
-> Int
-> Int
-> LogAction
-> FlushOut
-> FlushErr
-> Maybe String
-> Maybe String
-> [String]
-> Int
-> Int
-> Bool
-> OverridingBool
-> Bool
-> Scheme
-> ProfAuto
-> Maybe String
-> IORef (ModuleEnv Int)
-> Maybe SseVersion
-> Maybe BmiVersion
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> IORef (Maybe LinkerInfo)
-> IORef (Maybe CompilerInfo)
-> Int
-> Int
-> Int
-> Bool
-> Maybe Int
-> Int
-> Int
-> CfgWeights
-> DynFlags
DynFlags {
        ghcMode :: GhcMode
ghcMode                 = GhcMode
CompManager,
        ghcLink :: GhcLink
ghcLink                 = GhcLink
LinkBinary,
        hscTarget :: HscTarget
hscTarget               = Platform -> PlatformMisc -> HscTarget
defaultHscTarget (Settings -> Platform
sTargetPlatform Settings
mySettings) (Settings -> PlatformMisc
sPlatformMisc Settings
mySettings),
        integerLibrary :: IntegerLibrary
integerLibrary          = Settings -> IntegerLibrary
sIntegerLibraryType Settings
mySettings,
        verbosity :: Int
verbosity               = Int
0,
        optLevel :: Int
optLevel                = Int
0,
        debugLevel :: Int
debugLevel              = Int
0,
        simplPhases :: Int
simplPhases             = Int
2,
        maxSimplIterations :: Int
maxSimplIterations      = Int
4,
        ruleCheck :: Maybe String
ruleCheck               = Maybe String
forall a. Maybe a
Nothing,
        inlineCheck :: Maybe String
inlineCheck             = Maybe String
forall a. Maybe a
Nothing,
        binBlobThreshold :: Word
binBlobThreshold        = Word
500000, -- 500K is a good default (see #16190)
        maxRelevantBinds :: Maybe Int
maxRelevantBinds        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6,
        maxValidHoleFits :: Maybe Int
maxValidHoleFits   = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6,
        maxRefHoleFits :: Maybe Int
maxRefHoleFits     = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6,
        refLevelHoleFits :: Maybe Int
refLevelHoleFits   = Maybe Int
forall a. Maybe a
Nothing,
        maxUncoveredPatterns :: Int
maxUncoveredPatterns    = Int
4,
        maxPmCheckModels :: Int
maxPmCheckModels        = Int
100,
        simplTickFactor :: Int
simplTickFactor         = Int
100,
        specConstrThreshold :: Maybe Int
specConstrThreshold     = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2000,
        specConstrCount :: Maybe Int
specConstrCount         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
3,
        specConstrRecursive :: Int
specConstrRecursive     = Int
3,
        liberateCaseThreshold :: Maybe Int
liberateCaseThreshold   = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2000,
        floatLamArgs :: Maybe Int
floatLamArgs            = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0, -- Default: float only if no fvs
        liftLamsRecArgs :: Maybe Int
liftLamsRecArgs         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5, -- Default: the number of available argument hardware registers on x86_64
        liftLamsNonRecArgs :: Maybe Int
liftLamsNonRecArgs      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5, -- Default: the number of available argument hardware registers on x86_64
        liftLamsKnown :: Bool
liftLamsKnown           = Bool
False,  -- Default: don't turn known calls into unknown ones
        cmmProcAlignment :: Maybe Int
cmmProcAlignment        = Maybe Int
forall a. Maybe a
Nothing,

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

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

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

        importPaths :: [String]
importPaths             = [String
"."],
        mainModIs :: Module
mainModIs               = Module
mAIN,
        mainFunIs :: Maybe String
mainFunIs               = Maybe String
forall a. Maybe a
Nothing,
        reductionDepth :: IntWithInf
reductionDepth          = Int -> IntWithInf
treatZeroAsInf Int
mAX_REDUCTION_DEPTH,
        solverIterations :: IntWithInf
solverIterations        = Int -> IntWithInf
treatZeroAsInf Int
mAX_SOLVER_ITERATIONS,

        thisInstalledUnitId :: InstalledUnitId
thisInstalledUnitId     = UnitId -> InstalledUnitId
toInstalledUnitId UnitId
mainUnitId,
        thisUnitIdInsts_ :: Maybe [(ModuleName, Module)]
thisUnitIdInsts_        = Maybe [(ModuleName, Module)]
forall a. Maybe a
Nothing,
        thisComponentId_ :: Maybe ComponentId
thisComponentId_        = Maybe ComponentId
forall a. Maybe a
Nothing,

        objectDir :: Maybe String
objectDir               = Maybe String
forall a. Maybe a
Nothing,
        dylibInstallName :: Maybe String
dylibInstallName        = Maybe String
forall a. Maybe a
Nothing,
        hiDir :: Maybe String
hiDir                   = Maybe String
forall a. Maybe a
Nothing,
        hieDir :: Maybe String
hieDir                  = Maybe String
forall a. Maybe a
Nothing,
        stubDir :: Maybe String
stubDir                 = Maybe String
forall a. Maybe a
Nothing,
        dumpDir :: Maybe String
dumpDir                 = Maybe String
forall a. Maybe a
Nothing,

        objectSuf :: String
objectSuf               = Phase -> String
phaseInputExt Phase
StopLn,
        hcSuf :: String
hcSuf                   = Phase -> String
phaseInputExt Phase
HCc,
        hiSuf :: String
hiSuf                   = String
"hi",
        hieSuf :: String
hieSuf                  = String
"hie",

        canGenerateDynamicToo :: IORef Bool
canGenerateDynamicToo   = String -> IORef Bool
forall a. String -> a
panic String
"defaultDynFlags: No canGenerateDynamicToo",
        dynObjectSuf :: String
dynObjectSuf            = String
"dyn_" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Phase -> String
phaseInputExt Phase
StopLn,
        dynHiSuf :: String
dynHiSuf                = String
"dyn_hi",

        pluginModNames :: [ModuleName]
pluginModNames          = [],
        pluginModNameOpts :: [(ModuleName, String)]
pluginModNameOpts       = [],
        frontendPluginOpts :: [String]
frontendPluginOpts      = [],
        cachedPlugins :: [LoadedPlugin]
cachedPlugins           = [],
        staticPlugins :: [StaticPlugin]
staticPlugins           = [],
        hooks :: Hooks
hooks                   = Hooks
emptyHooks,

        outputFile :: Maybe String
outputFile              = Maybe String
forall a. Maybe a
Nothing,
        dynOutputFile :: Maybe String
dynOutputFile           = Maybe String
forall a. Maybe a
Nothing,
        outputHi :: Maybe String
outputHi                = Maybe String
forall a. Maybe a
Nothing,
        dynLibLoader :: DynLibLoader
dynLibLoader            = DynLibLoader
SystemDependent,
        dumpPrefix :: Maybe String
dumpPrefix              = Maybe String
forall a. Maybe a
Nothing,
        dumpPrefixForce :: Maybe String
dumpPrefixForce         = Maybe String
forall a. Maybe a
Nothing,
        ldInputs :: [Option]
ldInputs                = [],
        includePaths :: IncludeSpecs
includePaths            = [String] -> [String] -> IncludeSpecs
IncludeSpecs [] [],
        libraryPaths :: [String]
libraryPaths            = [],
        frameworkPaths :: [String]
frameworkPaths          = [],
        cmdlineFrameworks :: [String]
cmdlineFrameworks       = [],
        rtsOpts :: Maybe String
rtsOpts                 = Maybe String
forall a. Maybe a
Nothing,
        rtsOptsEnabled :: RtsOptsEnabled
rtsOptsEnabled          = RtsOptsEnabled
RtsOptsSafeOnly,
        rtsOptsSuggestions :: Bool
rtsOptsSuggestions      = Bool
True,

        hpcDir :: String
hpcDir                  = String
".hpc",

        packageDBFlags :: [PackageDBFlag]
packageDBFlags          = [],
        packageFlags :: [PackageFlag]
packageFlags            = [],
        pluginPackageFlags :: [PackageFlag]
pluginPackageFlags      = [],
        ignorePackageFlags :: [IgnorePackageFlag]
ignorePackageFlags      = [],
        trustFlags :: [TrustFlag]
trustFlags              = [],
        packageEnv :: Maybe String
packageEnv              = Maybe String
forall a. Maybe a
Nothing,
        pkgDatabase :: Maybe [(String, [PackageConfig])]
pkgDatabase             = Maybe [(String, [PackageConfig])]
forall a. Maybe a
Nothing,
        -- This gets filled in with GHC.setSessionDynFlags
        pkgState :: PackageState
pkgState                = PackageState
emptyPackageState,
        ways :: [Way]
ways                    = Settings -> [Way]
defaultWays Settings
mySettings,
        buildTag :: String
buildTag                = [Way] -> String
mkBuildTag (Settings -> [Way]
defaultWays Settings
mySettings),
        splitInfo :: Maybe (String, Int)
splitInfo               = Maybe (String, Int)
forall a. Maybe a
Nothing,

        ghcNameVersion :: GhcNameVersion
ghcNameVersion = Settings -> GhcNameVersion
sGhcNameVersion Settings
mySettings,
        fileSettings :: FileSettings
fileSettings = Settings -> FileSettings
sFileSettings Settings
mySettings,
        toolSettings :: ToolSettings
toolSettings = Settings -> ToolSettings
sToolSettings Settings
mySettings,
        targetPlatform :: Platform
targetPlatform = Settings -> Platform
sTargetPlatform Settings
mySettings,
        platformMisc :: PlatformMisc
platformMisc = Settings -> PlatformMisc
sPlatformMisc Settings
mySettings,
        platformConstants :: PlatformConstants
platformConstants = Settings -> PlatformConstants
sPlatformConstants Settings
mySettings,
        rawSettings :: [(String, String)]
rawSettings = Settings -> [(String, String)]
sRawSettings Settings
mySettings,

        -- See Note [LLVM configuration].
        llvmConfig :: LlvmConfig
llvmConfig              = LlvmConfig
llvmConfig,

        -- ghc -M values
        depMakefile :: String
depMakefile       = String
"Makefile",
        depIncludePkgDeps :: Bool
depIncludePkgDeps = Bool
False,
        depIncludeCppDeps :: Bool
depIncludeCppDeps = Bool
False,
        depExcludeMods :: [ModuleName]
depExcludeMods    = [],
        depSuffixes :: [String]
depSuffixes       = [],
        -- end of ghc -M values
        nextTempSuffix :: IORef Int
nextTempSuffix = String -> IORef Int
forall a. String -> a
panic String
"defaultDynFlags: No nextTempSuffix",
        filesToClean :: IORef FilesToClean
filesToClean   = String -> IORef FilesToClean
forall a. String -> a
panic String
"defaultDynFlags: No filesToClean",
        dirsToClean :: IORef (Map String String)
dirsToClean    = String -> IORef (Map String String)
forall a. String -> a
panic String
"defaultDynFlags: No dirsToClean",
        generatedDumps :: IORef (Set String)
generatedDumps = String -> IORef (Set String)
forall a. String -> a
panic String
"defaultDynFlags: No generatedDumps",
        ghcVersionFile :: Maybe String
ghcVersionFile = Maybe String
forall a. Maybe a
Nothing,
        haddockOptions :: Maybe String
haddockOptions = Maybe String
forall a. Maybe a
Nothing,
        dumpFlags :: EnumSet DumpFlag
dumpFlags = EnumSet DumpFlag
forall a. EnumSet a
EnumSet.empty,
        generalFlags :: EnumSet GeneralFlag
generalFlags = [GeneralFlag] -> EnumSet GeneralFlag
forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList (Settings -> [GeneralFlag]
defaultFlags Settings
mySettings),
        warningFlags :: EnumSet WarningFlag
warningFlags = [WarningFlag] -> EnumSet WarningFlag
forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList [WarningFlag]
standardWarnings,
        fatalWarningFlags :: EnumSet WarningFlag
fatalWarningFlags = EnumSet WarningFlag
forall a. EnumSet a
EnumSet.empty,
        ghciScripts :: [String]
ghciScripts = [],
        language :: Maybe Language
language = Maybe Language
forall a. Maybe a
Nothing,
        safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
Sf_None,
        safeInfer :: Bool
safeInfer   = Bool
True,
        safeInferred :: Bool
safeInferred = Bool
True,
        thOnLoc :: SrcSpan
thOnLoc = SrcSpan
noSrcSpan,
        newDerivOnLoc :: SrcSpan
newDerivOnLoc = SrcSpan
noSrcSpan,
        overlapInstLoc :: SrcSpan
overlapInstLoc = SrcSpan
noSrcSpan,
        incoherentOnLoc :: SrcSpan
incoherentOnLoc = SrcSpan
noSrcSpan,
        pkgTrustOnLoc :: SrcSpan
pkgTrustOnLoc = SrcSpan
noSrcSpan,
        warnSafeOnLoc :: SrcSpan
warnSafeOnLoc = SrcSpan
noSrcSpan,
        warnUnsafeOnLoc :: SrcSpan
warnUnsafeOnLoc = SrcSpan
noSrcSpan,
        trustworthyOnLoc :: SrcSpan
trustworthyOnLoc = SrcSpan
noSrcSpan,
        extensions :: [OnOff Extension]
extensions = [],
        extensionFlags :: EnumSet Extension
extensionFlags = Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags Maybe Language
forall a. Maybe a
Nothing [],

        -- The ufCreationThreshold threshold must be reasonably high to
        -- take account of possible discounts.
        -- E.g. 450 is not enough in 'fulsom' for Interval.sqr to inline
        -- into Csg.calc (The unfolding for sqr never makes it into the
        -- interface file.)
        ufCreationThreshold :: Int
ufCreationThreshold = Int
750,
        ufUseThreshold :: Int
ufUseThreshold      = Int
60,
        ufFunAppDiscount :: Int
ufFunAppDiscount    = Int
60,
        -- Be fairly keen to inline a function if that means
        -- we'll be able to pick the right method from a dictionary
        ufDictDiscount :: Int
ufDictDiscount      = Int
30,
        ufKeenessFactor :: Float
ufKeenessFactor     = Float
1.5,
        ufDearOp :: Int
ufDearOp            = Int
40,
        ufVeryAggressive :: Bool
ufVeryAggressive    = Bool
False,

        maxWorkerArgs :: Int
maxWorkerArgs = Int
10,

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

        -- Logging

        log_action :: LogAction
log_action = LogAction
defaultLogAction,

        flushOut :: FlushOut
flushOut = FlushOut
defaultFlushOut,
        flushErr :: FlushErr
flushErr = FlushErr
defaultFlushErr,
        pprUserLength :: Int
pprUserLength = Int
5,
        pprCols :: Int
pprCols = Int
100,
        useUnicode :: Bool
useUnicode = Bool
False,
        useColor :: OverridingBool
useColor = OverridingBool
Auto,
        canUseColor :: Bool
canUseColor = Bool
False,
        colScheme :: Scheme
colScheme = Scheme
Col.defaultScheme,
        profAuto :: ProfAuto
profAuto = ProfAuto
NoProfAuto,
        interactivePrint :: Maybe String
interactivePrint = Maybe String
forall a. Maybe a
Nothing,
        nextWrapperNum :: IORef (ModuleEnv Int)
nextWrapperNum = String -> IORef (ModuleEnv Int)
forall a. String -> a
panic String
"defaultDynFlags: No nextWrapperNum",
        sseVersion :: Maybe SseVersion
sseVersion = Maybe SseVersion
forall a. Maybe a
Nothing,
        bmiVersion :: Maybe BmiVersion
bmiVersion = Maybe BmiVersion
forall a. Maybe a
Nothing,
        avx :: Bool
avx = Bool
False,
        avx2 :: Bool
avx2 = Bool
False,
        avx512cd :: Bool
avx512cd = Bool
False,
        avx512er :: Bool
avx512er = Bool
False,
        avx512f :: Bool
avx512f = Bool
False,
        avx512pf :: Bool
avx512pf = Bool
False,
        rtldInfo :: IORef (Maybe LinkerInfo)
rtldInfo = String -> IORef (Maybe LinkerInfo)
forall a. String -> a
panic String
"defaultDynFlags: no rtldInfo",
        rtccInfo :: IORef (Maybe CompilerInfo)
rtccInfo = String -> IORef (Maybe CompilerInfo)
forall a. String -> a
panic String
"defaultDynFlags: no rtccInfo",

        maxInlineAllocSize :: Int
maxInlineAllocSize = Int
128,
        maxInlineMemcpyInsns :: Int
maxInlineMemcpyInsns = Int
32,
        maxInlineMemsetInsns :: Int
maxInlineMemsetInsns = Int
32,

        initialUnique :: Int
initialUnique = Int
0,
        uniqueIncrement :: Int
uniqueIncrement = Int
1,

        reverseErrors :: Bool
reverseErrors = Bool
False,
        maxErrors :: Maybe Int
maxErrors     = Maybe Int
forall a. Maybe a
Nothing,
        cfgWeightInfo :: CfgWeights
cfgWeightInfo = CfgWeights
defaultCfgWeights
      }

defaultWays :: Settings -> [Way]
defaultWays :: Settings -> [Way]
defaultWays Settings
settings = if PlatformConstants -> Bool
pc_DYNAMIC_BY_DEFAULT (Settings -> PlatformConstants
sPlatformConstants Settings
settings)
                       then [Way
WayDyn]
                       else []

interpWays :: [Way]
interpWays :: [Way]
interpWays
  | Bool
dynamicGhc = [Way
WayDyn]
  | Bool
rtsIsProfiled = [Way
WayProf]
  | Bool
otherwise = []

interpreterProfiled :: DynFlags -> Bool
interpreterProfiled :: DynFlags -> Bool
interpreterProfiled DynFlags
dflags
  | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_ExternalInterpreter DynFlags
dflags = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SccProfilingOn DynFlags
dflags
  | Bool
otherwise = Bool
rtsIsProfiled

interpreterDynamic :: DynFlags -> Bool
interpreterDynamic :: DynFlags -> Bool
interpreterDynamic DynFlags
dflags
  | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_ExternalInterpreter DynFlags
dflags = Way
WayDyn Way -> [Way] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` DynFlags -> [Way]
ways DynFlags
dflags
  | Bool
otherwise = Bool
dynamicGhc

--------------------------------------------------------------------------
--
-- Note [JSON Error Messages]
--
-- When the user requests the compiler output to be dumped as json
-- we used to collect them all in an IORef and then print them at the end.
-- This doesn't work very well with GHCi. (See #14078) So instead we now
-- use the simpler method of just outputting a JSON document inplace to
-- stdout.
--
-- Before the compiler calls log_action, it has already turned the `ErrMsg`
-- into a formatted message. This means that we lose some possible
-- information to provide to the user but refactoring log_action is quite
-- invasive as it is called in many places. So, for now I left it alone
-- and we can refine its behaviour as users request different output.

type FatalMessager = String -> IO ()

type LogAction = DynFlags
              -> WarnReason
              -> Severity
              -> SrcSpan
              -> PprStyle
              -> MsgDoc
              -> IO ()

defaultFatalMessager :: FatalMessager
defaultFatalMessager :: FatalMessager
defaultFatalMessager = Handle -> FatalMessager
hPutStrLn Handle
stderr


-- See Note [JSON Error Messages]
--
jsonLogAction :: LogAction
jsonLogAction :: LogAction
jsonLogAction DynFlags
dflags WarnReason
reason Severity
severity SrcSpan
srcSpan PprStyle
_style SDoc
msg
  = do
    DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPutStrDoc DynFlags
dflags Handle
stdout (SDoc
doc SDoc -> SDoc -> SDoc
$$ String -> SDoc
text String
"")
                               (CodeStyle -> PprStyle
mkCodeStyle CodeStyle
CStyle)
    where
      doc :: SDoc
doc = JsonDoc -> SDoc
renderJSON (JsonDoc -> SDoc) -> JsonDoc -> SDoc
forall a b. (a -> b) -> a -> b
$
              [(String, JsonDoc)] -> JsonDoc
JSObject [ ( String
"span", SrcSpan -> JsonDoc
forall a. ToJson a => a -> JsonDoc
json SrcSpan
srcSpan )
                       , ( String
"doc" , String -> JsonDoc
JSString (DynFlags -> SDoc -> String
showSDoc DynFlags
dflags SDoc
msg) )
                       , ( String
"severity", Severity -> JsonDoc
forall a. ToJson a => a -> JsonDoc
json Severity
severity )
                       , ( String
"reason" ,   WarnReason -> JsonDoc
forall a. ToJson a => a -> JsonDoc
json WarnReason
reason )
                       ]


defaultLogAction :: LogAction
defaultLogAction :: LogAction
defaultLogAction DynFlags
dflags WarnReason
reason Severity
severity SrcSpan
srcSpan PprStyle
style SDoc
msg
    = case Severity
severity of
      Severity
SevOutput      -> SDoc -> PprStyle -> IO ()
printOut SDoc
msg PprStyle
style
      Severity
SevDump        -> SDoc -> PprStyle -> IO ()
printOut (SDoc
msg SDoc -> SDoc -> SDoc
$$ SDoc
blankLine) PprStyle
style
      Severity
SevInteractive -> SDoc -> PprStyle -> IO ()
putStrSDoc SDoc
msg PprStyle
style
      Severity
SevInfo        -> SDoc -> PprStyle -> IO ()
printErrs SDoc
msg PprStyle
style
      Severity
SevFatal       -> SDoc -> PprStyle -> IO ()
printErrs SDoc
msg PprStyle
style
      Severity
SevWarning     -> IO ()
printWarns
      Severity
SevError       -> IO ()
printWarns
    where
      printOut :: SDoc -> PprStyle -> IO ()
printOut   = DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPrintDoc  DynFlags
dflags Handle
stdout
      printErrs :: SDoc -> PprStyle -> IO ()
printErrs  = DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPrintDoc  DynFlags
dflags Handle
stderr
      putStrSDoc :: SDoc -> PprStyle -> IO ()
putStrSDoc = DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPutStrDoc DynFlags
dflags Handle
stdout
      -- Pretty print the warning flag, if any (#10752)
      message :: SDoc
message = Maybe String -> Severity -> SrcSpan -> SDoc -> SDoc
mkLocMessageAnn Maybe String
flagMsg Severity
severity SrcSpan
srcSpan SDoc
msg

      printWarns :: IO ()
printWarns = do
        Handle -> Char -> IO ()
hPutChar Handle
stderr Char
'\n'
        SDoc
caretDiagnostic <-
            if GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_DiagnosticsShowCaret DynFlags
dflags
            then Severity -> SrcSpan -> IO SDoc
getCaretDiagnostic Severity
severity SrcSpan
srcSpan
            else SDoc -> IO SDoc
forall (f :: * -> *) a. Applicative f => a -> f a
pure SDoc
empty
        SDoc -> PprStyle -> IO ()
printErrs (SDoc
message SDoc -> SDoc -> SDoc
$+$ SDoc
caretDiagnostic)
            (Bool -> PprStyle -> PprStyle
setStyleColoured Bool
True PprStyle
style)
        -- careful (#2302): printErrs prints in UTF-8,
        -- whereas converting to string first and using
        -- hPutStr would just emit the low 8 bits of
        -- each unicode char.

      flagMsg :: Maybe String
flagMsg =
        case WarnReason
reason of
          WarnReason
NoReason -> Maybe String
forall a. Maybe a
Nothing
          Reason WarningFlag
wflag -> do
            FlagSpec WarningFlag
spec <- WarningFlag -> Maybe (FlagSpec WarningFlag)
flagSpecOf WarningFlag
wflag
            String -> Maybe String
forall (m :: * -> *) a. Monad m => a -> m a
return (String
"-W" String -> ShowS
forall a. [a] -> [a] -> [a]
++ FlagSpec WarningFlag -> String
forall flag. FlagSpec flag -> String
flagSpecName FlagSpec WarningFlag
spec String -> ShowS
forall a. [a] -> [a] -> [a]
++ WarningFlag -> String
warnFlagGrp WarningFlag
wflag)
          ErrReason Maybe WarningFlag
Nothing ->
            String -> Maybe String
forall (m :: * -> *) a. Monad m => a -> m a
return String
"-Werror"
          ErrReason (Just WarningFlag
wflag) -> do
            FlagSpec WarningFlag
spec <- WarningFlag -> Maybe (FlagSpec WarningFlag)
flagSpecOf WarningFlag
wflag
            String -> Maybe String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$
              String
"-W" String -> ShowS
forall a. [a] -> [a] -> [a]
++ FlagSpec WarningFlag -> String
forall flag. FlagSpec flag -> String
flagSpecName FlagSpec WarningFlag
spec String -> ShowS
forall a. [a] -> [a] -> [a]
++ WarningFlag -> String
warnFlagGrp WarningFlag
wflag String -> ShowS
forall a. [a] -> [a] -> [a]
++
              String
", -Werror=" String -> ShowS
forall a. [a] -> [a] -> [a]
++ FlagSpec WarningFlag -> String
forall flag. FlagSpec flag -> String
flagSpecName FlagSpec WarningFlag
spec

      warnFlagGrp :: WarningFlag -> String
warnFlagGrp WarningFlag
flag
          | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_ShowWarnGroups DynFlags
dflags =
                case WarningFlag -> [String]
smallestGroups WarningFlag
flag of
                    [] -> String
""
                    [String]
groups -> String
" (in " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
", " (ShowS -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String
"-W"String -> ShowS
forall a. [a] -> [a] -> [a]
++) [String]
groups) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
          | Bool
otherwise = String
""

-- | Like 'defaultLogActionHPutStrDoc' but appends an extra newline.
defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPrintDoc DynFlags
dflags Handle
h SDoc
d PprStyle
sty
 = DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPutStrDoc DynFlags
dflags Handle
h (SDoc
d SDoc -> SDoc -> SDoc
$$ String -> SDoc
text String
"") PprStyle
sty

defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPutStrDoc DynFlags
dflags Handle
h SDoc
d PprStyle
sty
  -- Don't add a newline at the end, so that successive
  -- calls to this log-action can output all on the same line
  = Mode -> DynFlags -> Handle -> PprStyle -> SDoc -> IO ()
printSDoc Mode
Pretty.PageMode DynFlags
dflags Handle
h PprStyle
sty SDoc
d

newtype FlushOut = FlushOut (IO ())

defaultFlushOut :: FlushOut
defaultFlushOut :: FlushOut
defaultFlushOut = IO () -> FlushOut
FlushOut (IO () -> FlushOut) -> IO () -> FlushOut
forall a b. (a -> b) -> a -> b
$ Handle -> IO ()
hFlush Handle
stdout

newtype FlushErr = FlushErr (IO ())

defaultFlushErr :: FlushErr
defaultFlushErr :: FlushErr
defaultFlushErr = IO () -> FlushErr
FlushErr (IO () -> FlushErr) -> IO () -> FlushErr
forall a b. (a -> b) -> a -> b
$ Handle -> IO ()
hFlush Handle
stderr

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

data OnOff a = On a
             | Off a
  deriving (OnOff a -> OnOff a -> Bool
(OnOff a -> OnOff a -> Bool)
-> (OnOff a -> OnOff a -> Bool) -> Eq (OnOff a)
forall a. Eq a => OnOff a -> OnOff a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OnOff a -> OnOff a -> Bool
$c/= :: forall a. Eq a => OnOff a -> OnOff a -> Bool
== :: OnOff a -> OnOff a -> Bool
$c== :: forall a. Eq a => OnOff a -> OnOff a -> Bool
Eq, Int -> OnOff a -> ShowS
[OnOff a] -> ShowS
OnOff a -> String
(Int -> OnOff a -> ShowS)
-> (OnOff a -> String) -> ([OnOff a] -> ShowS) -> Show (OnOff a)
forall a. Show a => Int -> OnOff a -> ShowS
forall a. Show a => [OnOff a] -> ShowS
forall a. Show a => OnOff a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OnOff a] -> ShowS
$cshowList :: forall a. Show a => [OnOff a] -> ShowS
show :: OnOff a -> String
$cshow :: forall a. Show a => OnOff a -> String
showsPrec :: Int -> OnOff a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> OnOff a -> ShowS
Show)

instance Outputable a => Outputable (OnOff a) where
  ppr :: OnOff a -> SDoc
ppr (On a
x)  = String -> SDoc
text String
"On" SDoc -> SDoc -> SDoc
<+> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
x
  ppr (Off a
x) = String -> SDoc
text String
"Off" SDoc -> SDoc -> SDoc
<+> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
x

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

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

languageExtensions :: Maybe Language -> [Extension]
languageExtensions Maybe Language
Nothing
    -- Nothing => the default case
    = Extension
LangExt.NondecreasingIndentation -- This has been on by default for some time
    Extension -> [Extension] -> [Extension]
forall a. a -> [a] -> [a]
: Extension -> [Extension] -> [Extension]
forall a. Eq a => a -> [a] -> [a]
delete Extension
LangExt.DatatypeContexts  -- The Haskell' committee decided to
                                       -- remove datatype contexts from the
                                       -- language:
   -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
      (Maybe Language -> [Extension]
languageExtensions (Language -> Maybe Language
forall a. a -> Maybe a
Just Language
Haskell2010))

   -- NB: MonoPatBinds is no longer the default

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

languageExtensions (Just Language
Haskell2010)
    = [Extension
LangExt.ImplicitPrelude,
       -- See Note [When is StarIsType enabled]
       Extension
LangExt.StarIsType,
       Extension
LangExt.CUSKs,
       Extension
LangExt.MonomorphismRestriction,
       Extension
LangExt.DatatypeContexts,
       Extension
LangExt.TraditionalRecordSyntax,
       Extension
LangExt.EmptyDataDecls,
       Extension
LangExt.ForeignFunctionInterface,
       Extension
LangExt.PatternGuards,
       Extension
LangExt.DoAndIfThenElse,
       Extension
LangExt.RelaxedPolyRec]

hasPprDebug :: DynFlags -> Bool
hasPprDebug :: DynFlags -> Bool
hasPprDebug = DumpFlag -> DynFlags -> Bool
dopt DumpFlag
Opt_D_ppr_debug

hasNoDebugOutput :: DynFlags -> Bool
hasNoDebugOutput :: DynFlags -> Bool
hasNoDebugOutput = DumpFlag -> DynFlags -> Bool
dopt DumpFlag
Opt_D_no_debug_output

hasNoStateHack :: DynFlags -> Bool
hasNoStateHack :: DynFlags -> Bool
hasNoStateHack = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_G_NoStateHack

hasNoOptCoercion :: DynFlags -> Bool
hasNoOptCoercion :: DynFlags -> Bool
hasNoOptCoercion = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_G_NoOptCoercion


-- | Test whether a 'DumpFlag' is set
dopt :: DumpFlag -> DynFlags -> Bool
dopt :: DumpFlag -> DynFlags -> Bool
dopt DumpFlag
f DynFlags
dflags = (DumpFlag
f DumpFlag -> EnumSet DumpFlag -> Bool
forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet DumpFlag
dumpFlags DynFlags
dflags)
             Bool -> Bool -> Bool
|| (DynFlags -> Int
verbosity DynFlags
dflags Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
4 Bool -> Bool -> Bool
&& DumpFlag -> Bool
enableIfVerbose DumpFlag
f)
    where enableIfVerbose :: DumpFlag -> Bool
enableIfVerbose DumpFlag
Opt_D_dump_tc_trace               = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_rn_trace               = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_cs_trace               = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_if_trace               = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_vt_trace               = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_tc                     = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_rn                     = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_rn_stats               = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_hi_diffs               = Bool
False
          enableIfVerbose DumpFlag
Opt_D_verbose_core2core           = Bool
False
          enableIfVerbose DumpFlag
Opt_D_verbose_stg2stg             = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_splices                = Bool
False
          enableIfVerbose DumpFlag
Opt_D_th_dec_file                 = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_rule_firings           = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_rule_rewrites          = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_simpl_trace            = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_rtti                   = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_inlinings              = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_core_stats             = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_asm_stats              = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_types                  = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_simpl_iterations       = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_ticked                 = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_view_pattern_commoning = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_mod_cycles             = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_mod_map                = Bool
False
          enableIfVerbose DumpFlag
Opt_D_dump_ec_trace               = Bool
False
          enableIfVerbose DumpFlag
_                                 = Bool
True

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

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

-- | Test whether a 'GeneralFlag' is set
gopt :: GeneralFlag -> DynFlags -> Bool
gopt :: GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
f DynFlags
dflags  = GeneralFlag
f GeneralFlag -> EnumSet GeneralFlag -> Bool
forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
dflags

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

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

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

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

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

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

-- | Mark a 'WarningFlag' as fatal (do not set the flag)
wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_set_fatal DynFlags
dfs WarningFlag
f
    = DynFlags
dfs { fatalWarningFlags :: EnumSet WarningFlag
fatalWarningFlags = WarningFlag -> EnumSet WarningFlag -> EnumSet WarningFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert WarningFlag
f (DynFlags -> EnumSet WarningFlag
fatalWarningFlags DynFlags
dfs) }

-- | Mark a 'WarningFlag' as not fatal
wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_unset_fatal DynFlags
dfs WarningFlag
f
    = DynFlags
dfs { fatalWarningFlags :: EnumSet WarningFlag
fatalWarningFlags = WarningFlag -> EnumSet WarningFlag -> EnumSet WarningFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete WarningFlag
f (DynFlags -> EnumSet WarningFlag
fatalWarningFlags DynFlags
dfs) }

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

-- | Set a 'LangExt.Extension'
xopt_set :: DynFlags -> LangExt.Extension -> DynFlags
xopt_set :: DynFlags -> Extension -> DynFlags
xopt_set DynFlags
dfs Extension
f
    = let onoffs :: [OnOff Extension]
onoffs = Extension -> OnOff Extension
forall a. a -> OnOff a
On Extension
f OnOff Extension -> [OnOff Extension] -> [OnOff Extension]
forall a. a -> [a] -> [a]
: DynFlags -> [OnOff Extension]
extensions DynFlags
dfs
      in DynFlags
dfs { extensions :: [OnOff Extension]
extensions = [OnOff Extension]
onoffs,
               extensionFlags :: EnumSet Extension
extensionFlags = Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags (DynFlags -> Maybe Language
language DynFlags
dfs) [OnOff Extension]
onoffs }

-- | Unset a 'LangExt.Extension'
xopt_unset :: DynFlags -> LangExt.Extension -> DynFlags
xopt_unset :: DynFlags -> Extension -> DynFlags
xopt_unset DynFlags
dfs Extension
f
    = let onoffs :: [OnOff Extension]
onoffs = Extension -> OnOff Extension
forall a. a -> OnOff a
Off Extension
f OnOff Extension -> [OnOff Extension] -> [OnOff Extension]
forall a. a -> [a] -> [a]
: DynFlags -> [OnOff Extension]
extensions DynFlags
dfs
      in DynFlags
dfs { extensions :: [OnOff Extension]
extensions = [OnOff Extension]
onoffs,
               extensionFlags :: EnumSet Extension
extensionFlags = Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags (DynFlags -> Maybe Language
language DynFlags
dfs) [OnOff Extension]
onoffs }

-- | Set or unset a 'LangExt.Extension', unless it has been explicitly
--   set or unset before.
xopt_set_unlessExplSpec
        :: LangExt.Extension
        -> (DynFlags -> LangExt.Extension -> DynFlags)
        -> DynFlags -> DynFlags
xopt_set_unlessExplSpec :: Extension
-> (DynFlags -> Extension -> DynFlags) -> DynFlags -> DynFlags
xopt_set_unlessExplSpec Extension
ext DynFlags -> Extension -> DynFlags
setUnset DynFlags
dflags =
    let referedExts :: [Extension]
referedExts = OnOff Extension -> Extension
forall p. OnOff p -> p
stripOnOff (OnOff Extension -> Extension) -> [OnOff Extension] -> [Extension]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DynFlags -> [OnOff Extension]
extensions DynFlags
dflags
        stripOnOff :: OnOff p -> p
stripOnOff (On p
x)  = p
x
        stripOnOff (Off p
x) = p
x
    in
        if Extension
ext Extension -> [Extension] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Extension]
referedExts then DynFlags
dflags else DynFlags -> Extension -> DynFlags
setUnset DynFlags
dflags Extension
ext

lang_set :: DynFlags -> Maybe Language -> DynFlags
lang_set :: DynFlags -> Maybe Language -> DynFlags
lang_set DynFlags
dflags Maybe Language
lang =
   DynFlags
dflags {
            language :: Maybe Language
language = Maybe Language
lang,
            extensionFlags :: EnumSet Extension
extensionFlags = Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags Maybe Language
lang (DynFlags -> [OnOff Extension]
extensions DynFlags
dflags)
          }

-- | An internal helper to check whether to use unicode syntax for output.
--
-- Note: You should very likely be using 'Outputable.unicodeSyntax' instead
-- of this function.
useUnicodeSyntax :: DynFlags -> Bool
useUnicodeSyntax :: DynFlags -> Bool
useUnicodeSyntax = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintUnicodeSyntax

useStarIsType :: DynFlags -> Bool
useStarIsType :: DynFlags -> Bool
useStarIsType = Extension -> DynFlags -> Bool
xopt Extension
LangExt.StarIsType

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

-- | Some modules have dependencies on others through the DynFlags rather than textual imports
dynFlagDependencies :: DynFlags -> [ModuleName]
dynFlagDependencies :: DynFlags -> [ModuleName]
dynFlagDependencies = DynFlags -> [ModuleName]
pluginModNames

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

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

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


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

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

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

-- | Set a 'Safe Haskell' flag
setSafeHaskell :: SafeHaskellMode -> DynP ()
setSafeHaskell :: SafeHaskellMode -> DynP ()
setSafeHaskell SafeHaskellMode
s = (DynFlags -> DynP DynFlags) -> DynP ()
updM DynFlags -> DynP DynFlags
f
    where f :: DynFlags -> DynP DynFlags
f DynFlags
dfs = do
              let sf :: SafeHaskellMode
sf = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dfs
              SafeHaskellMode
safeM <- SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
combineSafeFlags SafeHaskellMode
sf SafeHaskellMode
s
              case SafeHaskellMode
s of
                SafeHaskellMode
Sf_Safe -> DynFlags -> DynP DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM, safeInfer :: Bool
safeInfer = Bool
False }
                -- leave safe inferrence on in Trustworthy mode so we can warn
                -- if it could have been inferred safe.
                SafeHaskellMode
Sf_Trustworthy -> do
                  SrcSpan
l <- EwM (CmdLineP DynFlags) SrcSpan
forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc
                  DynFlags -> DynP DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM, trustworthyOnLoc :: SrcSpan
trustworthyOnLoc = SrcSpan
l }
                -- leave safe inference on in Unsafe mode as well.
                SafeHaskellMode
_ -> DynFlags -> DynP DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM }

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

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

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

-- | A list of unsafe flags under Safe Haskell. Tuple elements are:
--     * name of the flag
--     * function to get srcspan that enabled the flag
--     * function to test if the flag is on
--     * function to turn the flag off
unsafeFlags, unsafeFlagsForInfer
  :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool,
  DynFlags -> DynFlags)]
unsafeFlags = [ (String
"-XGeneralizedNewtypeDeriving", DynFlags -> SrcSpan
newDerivOnLoc,
                    Extension -> DynFlags -> Bool
xopt Extension
LangExt.GeneralizedNewtypeDeriving,
                    (DynFlags -> Extension -> DynFlags)
-> Extension -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> Extension -> DynFlags
xopt_unset Extension
LangExt.GeneralizedNewtypeDeriving)
              , (String
"-XTemplateHaskell", DynFlags -> SrcSpan
thOnLoc,
                    Extension -> DynFlags -> Bool
xopt Extension
LangExt.TemplateHaskell,
                    (DynFlags -> Extension -> DynFlags)
-> Extension -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> Extension -> DynFlags
xopt_unset Extension
LangExt.TemplateHaskell)
              ]
unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool,
  DynFlags -> DynFlags)]
unsafeFlagsForInfer = [(String, DynFlags -> SrcSpan, DynFlags -> Bool,
  DynFlags -> DynFlags)]
unsafeFlags


-- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
getOpts :: DynFlags             -- ^ 'DynFlags' to retrieve the options from
        -> (DynFlags -> [a])    -- ^ Relevant record accessor: one of the @opt_*@ accessors
        -> [a]                  -- ^ Correctly ordered extracted options
getOpts :: 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 -> [String]
getVerbFlags DynFlags
dflags
  | DynFlags -> Int
verbosity DynFlags
dflags Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
4 = [String
"-v"]
  | Bool
otherwise             = []

setObjectDir, setHiDir, setHieDir, setStubDir, setDumpDir, setOutputDir,
         setDynObjectSuf, setDynHiSuf,
         setDylibInstallName,
         setObjectSuf, setHiSuf, setHieSuf, setHcSuf, parseDynLibLoaderMode,
         setPgmP, addOptl, addOptc, addOptcxx, addOptP,
         addCmdlineFramework, addHaddockOpts, addGhciScript,
         setInteractivePrint
   :: String -> DynFlags -> DynFlags
setOutputFile, setDynOutputFile, setOutputHi, setDumpPrefixForce
   :: Maybe String -> DynFlags -> DynFlags

setObjectDir :: String -> DynFlags -> DynFlags
setObjectDir  String
f DynFlags
d = DynFlags
d { objectDir :: Maybe String
objectDir  = String -> Maybe String
forall a. a -> Maybe a
Just String
f}
setHiDir :: String -> DynFlags -> DynFlags
setHiDir      String
f DynFlags
d = DynFlags
d { hiDir :: Maybe String
hiDir      = String -> Maybe String
forall a. a -> Maybe a
Just String
f}
setHieDir :: String -> DynFlags -> DynFlags
setHieDir     String
f DynFlags
d = DynFlags
d { hieDir :: Maybe String
hieDir     = String -> Maybe String
forall a. a -> Maybe a
Just String
f}
setStubDir :: String -> DynFlags -> DynFlags
setStubDir    String
f DynFlags
d = DynFlags
d { stubDir :: Maybe String
stubDir    = String -> Maybe String
forall a. a -> Maybe a
Just String
f
                      , includePaths :: IncludeSpecs
includePaths = IncludeSpecs -> [String] -> IncludeSpecs
addGlobalInclude (DynFlags -> IncludeSpecs
includePaths DynFlags
d) [String
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 :: String -> DynFlags -> DynFlags
setDumpDir    String
f DynFlags
d = DynFlags
d { dumpDir :: Maybe String
dumpDir    = String -> Maybe String
forall a. a -> Maybe a
Just String
f}
setOutputDir :: String -> DynFlags -> DynFlags
setOutputDir  String
f = String -> DynFlags -> DynFlags
setObjectDir String
f
                (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> DynFlags -> DynFlags
setHieDir String
f
                (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> DynFlags -> DynFlags
setHiDir String
f
                (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> DynFlags -> DynFlags
setStubDir String
f
                (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> DynFlags -> DynFlags
setDumpDir String
f
setDylibInstallName :: String -> DynFlags -> DynFlags
setDylibInstallName  String
f DynFlags
d = DynFlags
d { dylibInstallName :: Maybe String
dylibInstallName = String -> Maybe String
forall a. a -> Maybe a
Just String
f}

setObjectSuf :: String -> DynFlags -> DynFlags
setObjectSuf    String
f DynFlags
d = DynFlags
d { objectSuf :: String
objectSuf    = String
f}
setDynObjectSuf :: String -> DynFlags -> DynFlags
setDynObjectSuf String
f DynFlags
d = DynFlags
d { dynObjectSuf :: String
dynObjectSuf = String
f}
setHiSuf :: String -> DynFlags -> DynFlags
setHiSuf        String
f DynFlags
d = DynFlags
d { hiSuf :: String
hiSuf        = String
f}
setHieSuf :: String -> DynFlags -> DynFlags
setHieSuf       String
f DynFlags
d = DynFlags
d { hieSuf :: String
hieSuf       = String
f}
setDynHiSuf :: String -> DynFlags -> DynFlags
setDynHiSuf     String
f DynFlags
d = DynFlags
d { dynHiSuf :: String
dynHiSuf     = String
f}
setHcSuf :: String -> DynFlags -> DynFlags
setHcSuf        String
f DynFlags
d = DynFlags
d { hcSuf :: String
hcSuf        = String
f}

setOutputFile :: Maybe String -> DynFlags -> DynFlags
setOutputFile Maybe String
f DynFlags
d = DynFlags
d { outputFile :: Maybe String
outputFile = Maybe String
f}
setDynOutputFile :: Maybe String -> DynFlags -> DynFlags
setDynOutputFile Maybe String
f DynFlags
d = DynFlags
d { dynOutputFile :: Maybe String
dynOutputFile = Maybe String
f}
setOutputHi :: Maybe String -> DynFlags -> DynFlags
setOutputHi   Maybe String
f DynFlags
d = DynFlags
d { outputHi :: Maybe String
outputHi   = Maybe String
f}

setJsonLogAction :: DynFlags -> DynFlags
setJsonLogAction :: DynFlags -> DynFlags
setJsonLogAction DynFlags
d = DynFlags
d { log_action :: LogAction
log_action = LogAction
jsonLogAction }

thisComponentId :: DynFlags -> ComponentId
thisComponentId :: DynFlags -> ComponentId
thisComponentId DynFlags
dflags =
  case DynFlags -> Maybe ComponentId
thisComponentId_ DynFlags
dflags of
    Just ComponentId
cid -> ComponentId
cid
    Maybe ComponentId
Nothing  ->
      case DynFlags -> Maybe [(ModuleName, Module)]
thisUnitIdInsts_ DynFlags
dflags of
        Just [(ModuleName, Module)]
_  ->
          GhcException -> ComponentId
forall a. GhcException -> a
throwGhcException (GhcException -> ComponentId) -> GhcException -> ComponentId
forall a b. (a -> b) -> a -> b
$ String -> GhcException
CmdLineError (String
"Use of -instantiated-with requires -this-component-id")
        Maybe [(ModuleName, Module)]
Nothing -> FastString -> ComponentId
ComponentId (UnitId -> FastString
unitIdFS (DynFlags -> UnitId
thisPackage DynFlags
dflags))

thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]
thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]
thisUnitIdInsts DynFlags
dflags =
    case DynFlags -> Maybe [(ModuleName, Module)]
thisUnitIdInsts_ DynFlags
dflags of
        Just [(ModuleName, Module)]
insts -> [(ModuleName, Module)]
insts
        Maybe [(ModuleName, Module)]
Nothing    -> []

thisPackage :: DynFlags -> UnitId
thisPackage :: DynFlags -> UnitId
thisPackage DynFlags
dflags =
    case DynFlags -> Maybe [(ModuleName, Module)]
thisUnitIdInsts_ DynFlags
dflags of
        Maybe [(ModuleName, Module)]
Nothing -> UnitId
default_uid
        Just [(ModuleName, Module)]
insts
          | ((ModuleName, Module) -> Bool) -> [(ModuleName, Module)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\(ModuleName
x,Module
y) -> ModuleName -> Module
mkHoleModule ModuleName
x Module -> Module -> Bool
forall a. Eq a => a -> a -> Bool
== Module
y) [(ModuleName, Module)]
insts
          -> ComponentId -> [(ModuleName, Module)] -> UnitId
newUnitId (DynFlags -> ComponentId
thisComponentId DynFlags
dflags) [(ModuleName, Module)]
insts
          | Bool
otherwise
          -> UnitId
default_uid
  where
    default_uid :: UnitId
default_uid = DefUnitId -> UnitId
DefiniteUnitId (InstalledUnitId -> DefUnitId
DefUnitId (DynFlags -> InstalledUnitId
thisInstalledUnitId DynFlags
dflags))

parseUnitIdInsts :: String -> [(ModuleName, Module)]
parseUnitIdInsts :: String -> [(ModuleName, Module)]
parseUnitIdInsts String
str = case (([(ModuleName, Module)], String) -> Bool)
-> [([(ModuleName, Module)], String)]
-> [([(ModuleName, Module)], String)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((String -> String -> Bool
forall a. Eq a => a -> a -> Bool
==String
"")(String -> Bool)
-> (([(ModuleName, Module)], String) -> String)
-> ([(ModuleName, Module)], String)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([(ModuleName, Module)], String) -> String
forall a b. (a, b) -> b
snd) (ReadP [(ModuleName, Module)] -> ReadS [(ModuleName, Module)]
forall a. ReadP a -> ReadS a
readP_to_S ReadP [(ModuleName, Module)]
parse String
str) of
    [([(ModuleName, Module)]
r, String
"")] -> [(ModuleName, Module)]
r
    [([(ModuleName, Module)], String)]
_ -> GhcException -> [(ModuleName, Module)]
forall a. GhcException -> a
throwGhcException (GhcException -> [(ModuleName, Module)])
-> GhcException -> [(ModuleName, Module)]
forall a b. (a -> b) -> a -> b
$ String -> GhcException
CmdLineError (String
"Can't parse -instantiated-with: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
str)
  where parse :: ReadP [(ModuleName, Module)]
parse = ReadP (ModuleName, Module)
-> ReadP Char -> ReadP [(ModuleName, Module)]
forall a sep. ReadP a -> ReadP sep -> ReadP [a]
sepBy ReadP (ModuleName, Module)
parseEntry (Char -> ReadP Char
R.char Char
',')
        parseEntry :: ReadP (ModuleName, Module)
parseEntry = do
            ModuleName
n <- ReadP ModuleName
parseModuleName
            Char
_ <- Char -> ReadP Char
R.char Char
'='
            Module
m <- ReadP Module
parseModuleId
            (ModuleName, Module) -> ReadP (ModuleName, Module)
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
n, Module
m)

setUnitIdInsts :: String -> DynFlags -> DynFlags
setUnitIdInsts :: String -> DynFlags -> DynFlags
setUnitIdInsts String
s DynFlags
d =
    DynFlags
d { thisUnitIdInsts_ :: Maybe [(ModuleName, Module)]
thisUnitIdInsts_ = [(ModuleName, Module)] -> Maybe [(ModuleName, Module)]
forall a. a -> Maybe a
Just (String -> [(ModuleName, Module)]
parseUnitIdInsts String
s) }

setComponentId :: String -> DynFlags -> DynFlags
setComponentId :: String -> DynFlags -> DynFlags
setComponentId String
s DynFlags
d =
    DynFlags
d { thisComponentId_ :: Maybe ComponentId
thisComponentId_ = ComponentId -> Maybe ComponentId
forall a. a -> Maybe a
Just (FastString -> ComponentId
ComponentId (String -> FastString
fsLit String
s)) }

addPluginModuleName :: String -> DynFlags -> DynFlags
addPluginModuleName :: String -> DynFlags -> DynFlags
addPluginModuleName String
name DynFlags
d = DynFlags
d { pluginModNames :: [ModuleName]
pluginModNames = (String -> ModuleName
mkModuleName String
name) ModuleName -> [ModuleName] -> [ModuleName]
forall a. a -> [a] -> [a]
: (DynFlags -> [ModuleName]
pluginModNames DynFlags
d) }

clearPluginModuleNames :: DynFlags -> DynFlags
clearPluginModuleNames :: DynFlags -> DynFlags
clearPluginModuleNames DynFlags
d =
    DynFlags
d { pluginModNames :: [ModuleName]
pluginModNames = []
      , pluginModNameOpts :: [(ModuleName, String)]
pluginModNameOpts = []
      , cachedPlugins :: [LoadedPlugin]
cachedPlugins = [] }

addPluginModuleNameOption :: String -> DynFlags -> DynFlags
addPluginModuleNameOption :: String -> DynFlags -> DynFlags
addPluginModuleNameOption String
optflag DynFlags
d = DynFlags
d { pluginModNameOpts :: [(ModuleName, String)]
pluginModNameOpts = (String -> ModuleName
mkModuleName String
m, String
option) (ModuleName, String)
-> [(ModuleName, String)] -> [(ModuleName, String)]
forall a. a -> [a] -> [a]
: (DynFlags -> [(ModuleName, String)]
pluginModNameOpts DynFlags
d) }
  where (String
m, String
rest) = (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
':') String
optflag
        option :: String
option = case String
rest of
          [] -> String
"" -- should probably signal an error
          (Char
_:String
plug_opt) -> String
plug_opt -- ignore the ':' from break

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

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

setDumpPrefixForce :: Maybe String -> DynFlags -> DynFlags
setDumpPrefixForce Maybe String
f DynFlags
d = DynFlags
d { dumpPrefixForce :: Maybe String
dumpPrefixForce = Maybe String
f}

-- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
-- Config.hs should really use Option.
setPgmP :: String -> DynFlags -> DynFlags
setPgmP   String
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_pgm_P :: (String, [Option])
toolSettings_pgm_P   = (String
pgm, (String -> Option) -> [String] -> [Option]
forall a b. (a -> b) -> [a] -> [b]
map String -> Option
Option [String]
args)})
  where (String
pgm:[String]
args) = String -> [String]
words String
f
addOptl :: String -> DynFlags -> DynFlags
addOptl   String
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_opt_l :: [String]
toolSettings_opt_l   = String
f String -> [String] -> [String]
forall a. a -> [a] -> [a]
: ToolSettings -> [String]
toolSettings_opt_l ToolSettings
s})
addOptc :: String -> DynFlags -> DynFlags
addOptc   String
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_opt_c :: [String]
toolSettings_opt_c   = String
f String -> [String] -> [String]
forall a. a -> [a] -> [a]
: ToolSettings -> [String]
toolSettings_opt_c ToolSettings
s})
addOptcxx :: String -> DynFlags -> DynFlags
addOptcxx String
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_opt_cxx :: [String]
toolSettings_opt_cxx = String
f String -> [String] -> [String]
forall a. a -> [a] -> [a]
: ToolSettings -> [String]
toolSettings_opt_cxx ToolSettings
s})
addOptP :: String -> DynFlags -> DynFlags
addOptP   String
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 :: [String]
toolSettings_opt_P   = String
f String -> [String] -> [String]
forall a. a -> [a] -> [a]
: ToolSettings -> [String]
toolSettings_opt_P ToolSettings
s
          , toolSettings_opt_P_fingerprint :: Fingerprint
toolSettings_opt_P_fingerprint = [String] -> Fingerprint
fingerprintStrings (String
f String -> [String] -> [String]
forall a. a -> [a] -> [a]
: ToolSettings -> [String]
toolSettings_opt_P ToolSettings
s)
          }
          -- See Note [Repeated -optP hashing]
  where
  fingerprintStrings :: [String] -> Fingerprint
fingerprintStrings [String]
ss = [Fingerprint] -> Fingerprint
fingerprintFingerprints ([Fingerprint] -> Fingerprint) -> [Fingerprint] -> Fingerprint
forall a b. (a -> b) -> a -> b
$ (String -> Fingerprint) -> [String] -> [Fingerprint]
forall a b. (a -> b) -> [a] -> [b]
map String -> Fingerprint
fingerprintString [String]
ss


setDepMakefile :: FilePath -> DynFlags -> DynFlags
setDepMakefile :: String -> DynFlags -> DynFlags
setDepMakefile String
f DynFlags
d = DynFlags
d { depMakefile :: String
depMakefile = String
f }

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

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

addDepExcludeMod :: String -> DynFlags -> DynFlags
addDepExcludeMod :: String -> DynFlags -> DynFlags
addDepExcludeMod String
m DynFlags
d
    = DynFlags
d { depExcludeMods :: [ModuleName]
depExcludeMods = String -> ModuleName
mkModuleName String
m ModuleName -> [ModuleName] -> [ModuleName]
forall a. a -> [a] -> [a]
: DynFlags -> [ModuleName]
depExcludeMods DynFlags
d }

addDepSuffix :: FilePath -> DynFlags -> DynFlags
addDepSuffix :: String -> DynFlags -> DynFlags
addDepSuffix String
s DynFlags
d = DynFlags
d { depSuffixes :: [String]
depSuffixes = String
s String -> [String] -> [String]
forall a. a -> [a] -> [a]
: DynFlags -> [String]
depSuffixes DynFlags
d }

addCmdlineFramework :: String -> DynFlags -> DynFlags
addCmdlineFramework String
f DynFlags
d = DynFlags
d { cmdlineFrameworks :: [String]
cmdlineFrameworks = String
f String -> [String] -> [String]
forall a. a -> [a] -> [a]
: DynFlags -> [String]
cmdlineFrameworks DynFlags
d}

addGhcVersionFile :: FilePath -> DynFlags -> DynFlags
addGhcVersionFile :: String -> DynFlags -> DynFlags
addGhcVersionFile String
f DynFlags
d = DynFlags
d { ghcVersionFile :: Maybe String
ghcVersionFile = String -> Maybe String
forall a. a -> Maybe a
Just String
f }

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

addGhciScript :: String -> DynFlags -> DynFlags
addGhciScript String
f DynFlags
d = DynFlags
d { ghciScripts :: [String]
ghciScripts = String
f String -> [String] -> [String]
forall a. a -> [a] -> [a]
: DynFlags -> [String]
ghciScripts DynFlags
d}

setInteractivePrint :: String -> DynFlags -> DynFlags
setInteractivePrint String
f DynFlags
d = DynFlags
d { interactivePrint :: Maybe String
interactivePrint = String -> Maybe String
forall a. a -> Maybe a
Just String
f}

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

updOptLevel :: Int -> DynFlags -> DynFlags
-- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
updOptLevel :: Int -> DynFlags -> DynFlags
updOptLevel Int
n DynFlags
dfs
  = DynFlags
dfs2{ optLevel :: Int
optLevel = Int
final_n }
  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
   dfs1 :: DynFlags
dfs1 = (GeneralFlag -> DynFlags -> DynFlags)
-> DynFlags -> [GeneralFlag] -> DynFlags
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((DynFlags -> GeneralFlag -> DynFlags)
-> GeneralFlag -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> GeneralFlag -> DynFlags
gopt_unset) DynFlags
dfs  [GeneralFlag]
remove_gopts
   dfs2 :: DynFlags
dfs2 = (GeneralFlag -> DynFlags -> DynFlags)
-> DynFlags -> [GeneralFlag] -> DynFlags
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((DynFlags -> GeneralFlag -> DynFlags)
-> GeneralFlag -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> GeneralFlag -> DynFlags
gopt_set)   DynFlags
dfs1 [GeneralFlag]
extra_gopts

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

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

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


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


-- | Like 'parseDynamicFlagsCmdLine' but does not allow the package flags
-- (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db).
-- Used to parse flags set in a modules pragma.
parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String]
                       -> m (DynFlags, [Located String], [Warn])
                          -- ^ Updated 'DynFlags', left-over arguments, and
                          -- list of warnings.
parseDynamicFilePragma :: DynFlags
-> [Located String] -> m (DynFlags, [Located String], [Warn])
parseDynamicFilePragma = [Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located String]
-> m (DynFlags, [Located String], [Warn])
forall (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located String]
-> m (DynFlags, [Located String], [Warn])
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
flagsDynamic Bool
False


-- | 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 :: MonadIO m
                  => [Flag (CmdLineP DynFlags)]    -- ^ valid flags to match against
                  -> Bool                          -- ^ are the arguments from the command line?
                  -> DynFlags                      -- ^ current dynamic flags
                  -> [Located String]              -- ^ arguments to parse
                  -> m (DynFlags, [Located String], [Warn])
parseDynamicFlagsFull :: [Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located String]
-> m (DynFlags, [Located String], [Warn])
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
activeFlags Bool
cmdline DynFlags
dflags0 [Located String]
args = do
  let (([Located String]
leftover, [Err]
errs, [Warn]
warns), DynFlags
dflags1)
          = CmdLineP DynFlags ([Located String], [Err], [Warn])
-> DynFlags -> (([Located String], [Err], [Warn]), DynFlags)
forall s a. CmdLineP s a -> s -> (a, s)
runCmdLine ([Flag (CmdLineP DynFlags)]
-> [Located String]
-> CmdLineP DynFlags ([Located String], [Err], [Warn])
forall (m :: * -> *).
Monad m =>
[Flag m] -> [Located String] -> m ([Located String], [Err], [Warn])
processArgs [Flag (CmdLineP DynFlags)]
activeFlags [Located String]
args) DynFlags
dflags0

  -- See Note [Handling errors when parsing commandline flags]
  Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([Err] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Err]
errs) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ GhcException -> IO ()
forall a. GhcException -> IO a
throwGhcExceptionIO (GhcException -> IO ()) -> GhcException -> IO ()
forall a b. (a -> b) -> a -> b
$ [(String, String)] -> GhcException
errorsToGhcException ([(String, String)] -> GhcException)
-> [(String, String)] -> GhcException
forall a b. (a -> b) -> a -> b
$
    (Err -> (String, String)) -> [Err] -> [(String, String)]
forall a b. (a -> b) -> [a] -> [b]
map ((DynFlags -> SrcSpan -> String
forall a. Outputable a => DynFlags -> a -> String
showPpr DynFlags
dflags0 (SrcSpan -> String)
-> (Located String -> SrcSpan) -> Located String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located String -> SrcSpan
forall a. HasSrcSpan a => a -> SrcSpan
getLoc (Located String -> String)
-> (Located String -> String) -> Located String -> (String, String)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& Located String -> String
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc) (Located String -> (String, String))
-> (Err -> Located String) -> Err -> (String, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Err -> Located String
errMsg) ([Err] -> [(String, String)]) -> [Err] -> [(String, String)]
forall a b. (a -> b) -> a -> b
$ [Err]
errs

  -- check for disabled flags in safe haskell
  let (DynFlags
dflags2, [Located String]
sh_warns) = Bool -> DynFlags -> (DynFlags, [Located String])
safeFlagCheck Bool
cmdline DynFlags
dflags1
      dflags3 :: DynFlags
dflags3 = DynFlags -> DynFlags
updateWays DynFlags
dflags2
      theWays :: [Way]
theWays = DynFlags -> [Way]
ways DynFlags
dflags3

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

  let chooseOutput :: m DynFlags
chooseOutput
        | Maybe String -> Bool
forall a. Maybe a -> Bool
isJust (DynFlags -> Maybe String
outputFile DynFlags
dflags3)          -- Only iff user specified -o ...
        , Bool -> Bool
not (Maybe String -> Bool
forall a. Maybe a -> Bool
isJust (DynFlags -> Maybe String
dynOutputFile DynFlags
dflags3)) -- but not -dyno
        = DynFlags -> m DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> m DynFlags) -> DynFlags -> m DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dflags3 { dynOutputFile :: Maybe String
dynOutputFile = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ DynFlags -> ShowS
dynamicOutputFile DynFlags
dflags3 String
outFile }
        | Bool
otherwise
        = DynFlags -> m DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
dflags3
        where
          outFile :: String
outFile = Maybe String -> String
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe String -> String) -> Maybe String -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> Maybe String
outputFile DynFlags
dflags3
  DynFlags
dflags4 <- DynFlags -> m DynFlags -> m DynFlags -> m DynFlags
forall (m :: * -> *) a. MonadIO m => DynFlags -> m a -> m a -> m a
ifGeneratingDynamicToo DynFlags
dflags3 m DynFlags
chooseOutput (DynFlags -> m DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
dflags3)

  let (DynFlags
dflags5, [Located String]
consistency_warnings) = DynFlags -> (DynFlags, [Located String])
makeDynFlagsConsistent DynFlags
dflags4

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

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

  let warns' :: [Warn]
warns' = (Located String -> Warn) -> [Located String] -> [Warn]
forall a b. (a -> b) -> [a] -> [b]
map (WarnReason -> Located String -> Warn
Warn WarnReason
Cmd.NoReason) ([Located String]
consistency_warnings [Located String] -> [Located String] -> [Located String]
forall a. [a] -> [a] -> [a]
++ [Located String]
sh_warns)

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

-- | Write an error or warning to the 'LogOutput'.
putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle
          -> MsgDoc -> IO ()
putLogMsg :: LogAction
putLogMsg DynFlags
dflags = DynFlags -> LogAction
log_action DynFlags
dflags DynFlags
dflags

updateWays :: DynFlags -> DynFlags
updateWays :: DynFlags -> DynFlags
updateWays DynFlags
dflags
    = let theWays :: [Way]
theWays = [Way] -> [Way]
forall a. Ord a => [a] -> [a]
sort ([Way] -> [Way]) -> [Way] -> [Way]
forall a b. (a -> b) -> a -> b
$ [Way] -> [Way]
forall a. Eq a => [a] -> [a]
nub ([Way] -> [Way]) -> [Way] -> [Way]
forall a b. (a -> b) -> a -> b
$ DynFlags -> [Way]
ways DynFlags
dflags
      in DynFlags
dflags {
             ways :: [Way]
ways        = [Way]
theWays,
             buildTag :: String
buildTag    = [Way] -> String
mkBuildTag ((Way -> Bool) -> [Way] -> [Way]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Way -> Bool) -> Way -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Way -> Bool
wayRTSOnly) [Way]
theWays)
         }

-- | Check (and potentially disable) any extensions that aren't allowed
-- in safe mode.
--
-- The bool is to indicate if we are parsing command line flags (false means
-- file pragma). This allows us to generate better warnings.
safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located String])
safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located String])
safeFlagCheck Bool
_ DynFlags
dflags | DynFlags -> Bool
safeLanguageOn DynFlags
dflags = (DynFlags
dflagsUnset, [Located String]
warns)
  where
    -- Handle illegal flags under safe language.
    (DynFlags
dflagsUnset, [Located String]
warns) = ((DynFlags, [Located String])
 -> (String, DynFlags -> SrcSpan, DynFlags -> Bool,
     DynFlags -> DynFlags)
 -> (DynFlags, [Located String]))
-> (DynFlags, [Located String])
-> [(String, DynFlags -> SrcSpan, DynFlags -> Bool,
     DynFlags -> DynFlags)]
-> (DynFlags, [Located String])
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (DynFlags, [Located String])
-> (String, DynFlags -> SrcSpan, DynFlags -> Bool,
    DynFlags -> DynFlags)
-> (DynFlags, [Located String])
forall a l.
(a, [GenLocated l String])
-> (String, a -> l, a -> Bool, a -> a)
-> (a, [GenLocated l String])
check_method (DynFlags
dflags, []) [(String, DynFlags -> SrcSpan, DynFlags -> Bool,
  DynFlags -> DynFlags)]
unsafeFlags

    check_method :: (a, [GenLocated l String])
-> (String, a -> l, a -> Bool, a -> a)
-> (a, [GenLocated l String])
check_method (a
df, [GenLocated l String]
warns) (String
str,a -> l
loc,a -> Bool
test,a -> a
fix)
        | a -> Bool
test a
df   = (a -> a
fix a
df, [GenLocated l String]
warns [GenLocated l String]
-> [GenLocated l String] -> [GenLocated l String]
forall a. [a] -> [a] -> [a]
++ l -> String -> [GenLocated l String]
forall l. l -> String -> [GenLocated l String]
safeFailure (a -> l
loc a
df) String
str)
        | Bool
otherwise = (a
df, [GenLocated l String]
warns)

    safeFailure :: l -> String -> [GenLocated l String]
safeFailure l
loc String
str
       = [l -> String -> GenLocated l String
forall l e. l -> e -> GenLocated l e
L l
loc (String -> GenLocated l String) -> String -> GenLocated l String
forall a b. (a -> b) -> a -> b
$ String
str String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" is not allowed in Safe Haskell; ignoring "
           String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
str]

safeFlagCheck Bool
cmdl DynFlags
dflags =
  case (DynFlags -> Bool
safeInferOn DynFlags
dflags) of
    Bool
True | Bool
safeFlags -> (DynFlags
dflags', [Located String]
warn)
    Bool
True             -> (DynFlags
dflags' { safeInferred :: Bool
safeInferred = Bool
False }, [Located String]
warn)
    Bool
False            -> (DynFlags
dflags', [Located String]
warn)

  where
    -- dynflags and warn for when -fpackage-trust by itself with no safe
    -- haskell flag
    (DynFlags
dflags', [Located String]
warn)
      | Bool -> Bool
not (DynFlags -> Bool
safeHaskellModeEnabled DynFlags
dflags) Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
cmdl Bool -> Bool -> Bool
&& DynFlags -> Bool
packageTrustOn DynFlags
dflags
      = (DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_PackageTrust, [Located String]
pkgWarnMsg)
      | Bool
otherwise = (DynFlags
dflags, [])

    pkgWarnMsg :: [Located String]
pkgWarnMsg = [SrcSpan -> String -> Located String
forall l e. l -> e -> GenLocated l e
L (DynFlags -> SrcSpan
pkgTrustOnLoc DynFlags
dflags') (String -> Located String) -> String -> Located String
forall a b. (a -> b) -> a -> b
$
                    String
"-fpackage-trust ignored;" String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
" must be specified with a Safe Haskell flag"]

    -- Have we inferred Unsafe? See Note [HscMain . Safe Haskell Inference]
    safeFlags :: Bool
safeFlags = ((String, DynFlags -> SrcSpan, DynFlags -> Bool,
  DynFlags -> DynFlags)
 -> Bool)
-> [(String, DynFlags -> SrcSpan, DynFlags -> Bool,
     DynFlags -> DynFlags)]
-> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\(String
_,DynFlags -> SrcSpan
_,DynFlags -> Bool
t,DynFlags -> DynFlags
_) -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ DynFlags -> Bool
t DynFlags
dflags) [(String, DynFlags -> SrcSpan, DynFlags -> Bool,
  DynFlags -> DynFlags)]
unsafeFlagsForInfer


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

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

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

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

-- All dynamic flags present in GHC.
flagsAll :: [Flag (CmdLineP DynFlags)]
flagsAll :: [Flag (CmdLineP DynFlags)]
flagsAll = ((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)
data Deprecation = NotDeprecated | Deprecated deriving (Deprecation -> Deprecation -> Bool
(Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Bool) -> Eq Deprecation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Deprecation -> Deprecation -> Bool
$c/= :: Deprecation -> Deprecation -> Bool
== :: Deprecation -> Deprecation -> Bool
$c== :: Deprecation -> Deprecation -> Bool
Eq, Eq Deprecation
Eq Deprecation
-> (Deprecation -> Deprecation -> Ordering)
-> (Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Deprecation)
-> (Deprecation -> Deprecation -> Deprecation)
-> Ord Deprecation
Deprecation -> Deprecation -> Bool
Deprecation -> Deprecation -> Ordering
Deprecation -> Deprecation -> Deprecation
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Deprecation -> Deprecation -> Deprecation
$cmin :: Deprecation -> Deprecation -> Deprecation
max :: Deprecation -> Deprecation -> Deprecation
$cmax :: Deprecation -> Deprecation -> Deprecation
>= :: Deprecation -> Deprecation -> Bool
$c>= :: Deprecation -> Deprecation -> Bool
> :: Deprecation -> Deprecation -> Bool
$c> :: Deprecation -> Deprecation -> Bool
<= :: Deprecation -> Deprecation -> Bool
$c<= :: Deprecation -> Deprecation -> Bool
< :: Deprecation -> Deprecation -> Bool
$c< :: Deprecation -> Deprecation -> Bool
compare :: Deprecation -> Deprecation -> Ordering
$ccompare :: Deprecation -> Deprecation -> Ordering
$cp1Ord :: Eq Deprecation
Ord)

-- Make a non-deprecated flag
make_ord_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags)
              -> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag :: DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
fm String
name OptKind (CmdLineP DynFlags)
kind = (Deprecation
NotDeprecated, DynFlagMaker
fm String
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
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
fm String
name OptKind (CmdLineP DynFlags)
kind String
message = (Deprecation
Deprecated,
                                      DynFlagMaker
fm String
name (OptKind (CmdLineP DynFlags) -> Flag (CmdLineP DynFlags))
-> OptKind (CmdLineP DynFlags) -> Flag (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ OptKind (CmdLineP DynFlags)
-> String -> OptKind (CmdLineP DynFlags)
add_dep_message OptKind (CmdLineP DynFlags)
kind String
message)

add_dep_message :: OptKind (CmdLineP DynFlags) -> String
                -> OptKind (CmdLineP DynFlags)
add_dep_message :: OptKind (CmdLineP DynFlags)
-> String -> OptKind (CmdLineP DynFlags)
add_dep_message (NoArg DynP ()
f) String
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (HasArg String -> DynP ()
f) String
message = (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
s -> String -> DynP ()
f String
s DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (SepArg String -> DynP ()
f) String
message = (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
SepArg ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
s -> String -> DynP ()
f String
s DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (Prefix String -> DynP ()
f) String
message = (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
Prefix ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
s -> String -> DynP ()
f String
s DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (OptPrefix String -> DynP ()
f) String
message =
                                  (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
OptPrefix ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
s -> String -> DynP ()
f String
s DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (OptIntSuffix Maybe Int -> DynP ()
f) String
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (IntSuffix Int -> DynP ()
f) String
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (FloatSuffix Float -> DynP ()
f) String
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (PassFlag String -> DynP ()
f) String
message =
                                   (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
PassFlag ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
s -> String -> DynP ()
f String
s DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
message
add_dep_message (AnySuffix String -> DynP ()
f) String
message =
                                  (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
AnySuffix ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
s -> String -> DynP ()
f String
s DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate String
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
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"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 (m :: * -> *) a. Monad m => a -> m a
return ())
        String
"The -n flag is deprecated and no longer has any effect"
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"cpp"      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Extension -> DynP ()
setExtensionFlag Extension
LangExt.Cpp))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"F"        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Pp))
  , (Deprecation
Deprecated, DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"#include"
      ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg (\String
_s ->
         String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate (String
"-#include and INCLUDE pragmas are " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
"deprecated: They no longer have any effect"))))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"v"        ((Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix Maybe Int -> DynP ()
setVerbosity)

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

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

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

    ------- ways ---------------------------------------------------------------
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"prof"           (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWay Way
WayProf))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"eventlog"       (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWay Way
WayEventLog))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"smp"
      (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
$ Way -> DynP ()
addWay Way
WayThreaded) String
"Use -threaded instead"
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"debug"          (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWay Way
WayDebug))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"threaded"       (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWay Way
WayThreaded))

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

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

        ----- Linker --------------------------------------------------------
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"static"         (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
removeWayDyn)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dynamic"        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWay Way
WayDyn))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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)
                              String -> DynFlags -> DynFlags
addOptl String
"-rdynamic"
#elif defined(mingw32_HOST_OS)
                              addOptl "-Wl,--export-all-symbols"
#else
    -- ignored for compat w/ gcc:
                              id
#endif
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"relative-dynlib-paths"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_RelativeDynlibPaths))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"copy-libs-when-linking"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SingleLibFolder))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"pie"            (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_PICExecutable))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmlo"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: (String, [Option])
toolSettings_pgm_lo  = (String
f,[]) }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmlc"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: (String, [Option])
toolSettings_pgm_lc  = (String
f,[]) }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmi"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: String
toolSettings_pgm_i   =  String
f }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmL"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: String
toolSettings_pgm_L   = String
f }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmP"
      ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg String -> DynFlags -> DynFlags
setPgmP)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmF"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: String
toolSettings_pgm_F   = String
f }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmc"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: String
toolSettings_pgm_c   = String
f
         , -- Don't pass -no-pie with -pgmc
           -- (see #15319)
           toolSettings_ccSupportsNoPie :: Bool
toolSettings_ccSupportsNoPie = Bool
False
         }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgms"
      ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg (\String
_ -> String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
addWarn String
"Object splitting was removed in GHC 8.8"))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgma"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: (String, [Option])
toolSettings_pgm_a   = (String
f,[]) }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgml"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: (String, [Option])
toolSettings_pgm_l   = (String
f,[]) }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmdll"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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_dll :: (String, [Option])
toolSettings_pgm_dll = (String
f,[]) }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmwindres"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: String
toolSettings_pgm_windres = String
f }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmlibtool"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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_libtool :: String
toolSettings_pgm_libtool = String
f }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmar"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: String
toolSettings_pgm_ar = String
f }
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"pgmranlib"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
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 :: String
toolSettings_pgm_ranlib = String
f }


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

  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"split-objs"
      (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
$ String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
addWarn String
"ignoring -split-objs")

  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"split-sections"
      ((DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM (\DynFlags
dflags -> do
        if Platform -> Bool
platformHasSubsectionsViaSymbols (DynFlags -> Platform
targetPlatform DynFlags
dflags)
          then do String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
addWarn (String -> DynP ()) -> String -> DynP ()
forall a b. (a -> b) -> a -> b
$
                    String
"-split-sections is not useful on this platform " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
"since it always uses subsections via symbols. Ignoring."
                  DynFlags -> DynP DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
dflags
          else DynFlags -> DynP DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dflags GeneralFlag
Opt_SplitSections)))

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

        -------- Linking ----------------------------------------------------
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"no-link"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink :: GhcLink
ghcLink=GhcLink
NoLink }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"shared"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink :: GhcLink
ghcLink=GhcLink
LinkDynLib }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"staticlib"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink :: GhcLink
ghcLink=GhcLink
LinkStaticLib }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dynload"            ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg String -> DynFlags -> DynFlags
parseDynLibLoaderMode)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dylib-install-name" ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg String -> DynFlags -> DynFlags
setDylibInstallName)

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

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

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

  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-hc-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHcFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-hc-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHcFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-hscpp-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHscppFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-hscpp-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHscppFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-s-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepSFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-s-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepSFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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
$ HscTarget -> DynP ()
setObjTarget HscTarget
HscLlvm DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepLlvmFiles)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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
$ HscTarget -> DynP ()
setObjTarget HscTarget
HscLlvm DynP () -> DynP () -> DynP ()
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
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-tmp-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepTmpFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-hi-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHiFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"no-keep-hi-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_KeepHiFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-hi-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHiFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"no-keep-hi-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_KeepHiFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-o-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepOFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"no-keep-o-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_KeepOFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"keep-o-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepOFiles))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"no-keep-o-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_KeepOFiles))

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

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

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

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

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

  -- Suppress all that is suppressable in core dumps.
  -- Except for uniques, as some simplifier phases introduce new variables that
  -- have otherwise identical names.
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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_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_SuppressTypeSignatures
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressTimestamps)

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

  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-from-stg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_from_stg)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-raw"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_raw)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-verbose"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_verbose)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-verbose-by-proc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_verbose_by_proc)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-cfg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_cfg)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-cbe"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_cbe)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-switch"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_switch)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-proc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_proc)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-sp"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_sp)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-sink"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_sink)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-caf"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_caf)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-procmap"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_procmap)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-split"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_split)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-info"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_info)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cmm-cps"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_cps)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cfg-weights"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cfg_weights)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-core-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_core_stats)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-asm"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-asm-native"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_native)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-asm-liveness"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_liveness)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-asm-regalloc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_regalloc)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-asm-conflicts"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_conflicts)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-asm-regalloc-stages"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_regalloc_stages)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-asm-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_stats)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-asm-expanded"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_expanded)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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
$ HscTarget -> DynP ()
setObjTarget HscTarget
HscLlvm DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_dump_llvm)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-deriv"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_deriv)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-ds"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ds)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-ds-preopt"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ds_preopt)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-foreign"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_foreign)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-inlinings"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_inlinings)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-rule-firings"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rule_firings)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-rule-rewrites"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rule_rewrites)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-simpl-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_simpl_trace)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-occur-anal"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_occur_anal)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-parsed"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_parsed)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-parsed-ast"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_parsed_ast)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-rn"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rn)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-rn-ast"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rn_ast)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-simpl"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_simpl)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-simpl-iterations"
      (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_simpl_iterations)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-spec"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_spec)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-prep"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_prep)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-stg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-stg-unarised"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_unarised)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-stg-final"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_final)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-call-arity"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_call_arity)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-exitify"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_exitify)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-stranal"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stranal)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-str-signatures"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_str_signatures)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-tc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_tc)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-tc-ast"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_tc_ast)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-types"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_types)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-rules"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rules)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cse"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cse)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-worker-wrapper"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_worker_wrapper)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-rn-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rn_trace)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-if-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_if_trace)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-cs-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cs_trace)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-ec-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ec_trace)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-vt-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_vt_trace)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-splices"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_splices)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dth-dec-file"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_th_dec_file)

  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-rn-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rn_stats)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-opt-cmm"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_opt_cmm)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-simpl-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_simpl_stats)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-bcos"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_BCOs)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dsource-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_source_stats)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> DynP ()
setVerboseCore2Core)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dverbose-stg2stg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_verbose_stg2stg)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-hi"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_hi)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-minimal-imports"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_D_dump_minimal_imports))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-hpc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ticked) -- back compat
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-ticked"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ticked)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-mod-cycles"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_mod_cycles)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-mod-map"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_mod_map)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-timings"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_timings)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-view-pattern-commoning"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_view_pattern_commoning)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-to-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DumpToFile))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-hi-diffs"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_hi_diffs)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-rtti"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rtti)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dcore-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoCoreLinting))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dstg-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoStgLinting))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dcmm-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoCmmLinting))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dasm-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoAsmLinting))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dannot-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoAnnotationLinting))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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 (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
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dfaststring-stats"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_D_faststring_stats))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dno-llvm-mangler"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_NoLlvmMangler)) -- hidden flag
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"fast-llvm"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_FastLlvm)) -- hidden flag
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dno-typeable-binds"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_NoTypeableBinds))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-debug"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_debug)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"ddump-json"
        ((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_set DumpFlag
Opt_D_dump_json (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DynFlags -> DynFlags
setJsonLogAction ) )
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dppr-debug"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_ppr_debug)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dno-debug-output"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_no_debug_output)

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

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

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

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

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

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

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

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

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

        ------ Optimisation flags ------------------------------------------
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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 )
                                                            String
"Use -O0 instead"
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fbinary-blob-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { binBlobThreshold :: Word
binBlobThreshold = Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n }))

  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fmax-relevant-binds"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxRelevantBinds :: Maybe Int
maxRelevantBinds = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fno-max-relevant-binds"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { maxRelevantBinds :: Maybe Int
maxRelevantBinds = Maybe Int
forall a. Maybe a
Nothing }))

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

  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"fllvm-pass-vectors-in-regs"
            ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg DynFlags -> DynFlags
forall a. a -> a
id)
            String
"vectors registers are now passed in registers by default."
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fmax-uncovered-patterns"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxUncoveredPatterns :: Int
maxUncoveredPatterns = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fmax-pmcheck-models"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxPmCheckModels :: Int
maxPmCheckModels = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fsimplifier-phases"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { simplPhases :: Int
simplPhases = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fmax-simplifier-iterations"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxSimplIterations :: Int
maxSimplIterations = Int
n }))
  , (Deprecation
Deprecated, DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fmax-pmcheck-iterations"
      ((Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffixM (\Int
_ DynFlags
d ->
       do { String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate (String -> DynP ()) -> String -> DynP ()
forall a b. (a -> b) -> a -> b
$ String
"use -fmax-pmcheck-models instead"
          ; DynFlags -> DynP DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
d })))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fsimpl-tick-factor"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { simplTickFactor :: Int
simplTickFactor = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fspec-constr-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { specConstrThreshold :: Maybe Int
specConstrThreshold = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fno-spec-constr-threshold"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { specConstrThreshold :: Maybe Int
specConstrThreshold = Maybe Int
forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fspec-constr-count"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { specConstrCount :: Maybe Int
specConstrCount = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fno-spec-constr-count"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { specConstrCount :: Maybe Int
specConstrCount = Maybe Int
forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fspec-constr-recursive"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { specConstrRecursive :: Int
specConstrRecursive = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fliberate-case-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { liberateCaseThreshold :: Maybe Int
liberateCaseThreshold = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fno-liberate-case-threshold"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liberateCaseThreshold :: Maybe Int
liberateCaseThreshold = Maybe Int
forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"drule-check"
      ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg (\String
s DynFlags
d -> DynFlags
d { ruleCheck :: Maybe String
ruleCheck = String -> Maybe String
forall a. a -> Maybe a
Just String
s }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"dinline-check"
      ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg (\String
s DynFlags
d -> DynFlags
d { inlineCheck :: Maybe String
inlineCheck = String -> Maybe String
forall a. a -> Maybe a
Just String
s }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"freduction-depth"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { reductionDepth :: IntWithInf
reductionDepth = Int -> IntWithInf
treatZeroAsInf Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fconstraint-solver-iterations"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { solverIterations :: IntWithInf
solverIterations = Int -> IntWithInf
treatZeroAsInf Int
n }))
  , (Deprecation
Deprecated, DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fcontext-stack"
      ((Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffixM (\Int
n DynFlags
d ->
       do { String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate (String -> DynP ()) -> String -> DynP ()
forall a b. (a -> b) -> a -> b
$ String
"use -freduction-depth=" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" instead"
          ; DynFlags -> DynP DynFlags
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 :: IntWithInf
reductionDepth = Int -> IntWithInf
treatZeroAsInf Int
n } })))
  , (Deprecation
Deprecated, DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"ftype-function-depth"
      ((Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffixM (\Int
n DynFlags
d ->
       do { String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate (String -> DynP ()) -> String -> DynP ()
forall a b. (a -> b) -> a -> b
$ String
"use -freduction-depth=" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" instead"
          ; DynFlags -> DynP DynFlags
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 :: IntWithInf
reductionDepth = Int -> IntWithInf
treatZeroAsInf Int
n } })))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fstrictness-before"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { strictnessBefore :: [Int]
strictnessBefore = Int
n Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: DynFlags -> [Int]
strictnessBefore DynFlags
d }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"ffloat-lam-args"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { floatLamArgs :: Maybe Int
floatLamArgs = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"ffloat-all-lams"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { floatLamArgs :: Maybe Int
floatLamArgs = Maybe Int
forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fstg-lift-lams-rec-args"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { liftLamsRecArgs :: Maybe Int
liftLamsRecArgs = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fstg-lift-lams-rec-args-any"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liftLamsRecArgs :: Maybe Int
liftLamsRecArgs = Maybe Int
forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fstg-lift-lams-non-rec-args"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { liftLamsRecArgs :: Maybe Int
liftLamsRecArgs = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fstg-lift-lams-non-rec-args-any"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liftLamsRecArgs :: Maybe Int
liftLamsRecArgs = Maybe Int
forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fstg-lift-lams-known"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liftLamsKnown :: Bool
liftLamsKnown = Bool
True }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fno-stg-lift-lams-known"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liftLamsKnown :: Bool
liftLamsKnown = Bool
False }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fproc-alignment"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { cmmProcAlignment :: Maybe Int
cmmProcAlignment = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fblock-layout-weights"
        ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg (\String
s ->
            (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { cfgWeightInfo :: CfgWeights
cfgWeightInfo =
                String -> CfgWeights -> CfgWeights
parseCfgWeights String
s (DynFlags -> CfgWeights
cfgWeightInfo DynFlags
d)})))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fhistory-size"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { historySize :: Int
historySize = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"funfolding-creation-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d {ufCreationThreshold :: Int
ufCreationThreshold = Int
n}))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"funfolding-use-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d {ufUseThreshold :: Int
ufUseThreshold = Int
n}))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"funfolding-fun-discount"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d {ufFunAppDiscount :: Int
ufFunAppDiscount = Int
n}))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"funfolding-dict-discount"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d {ufDictDiscount :: Int
ufDictDiscount = Int
n}))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"funfolding-keeness-factor"
      ((Float -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
floatSuffix (\Float
n DynFlags
d -> DynFlags
d {ufKeenessFactor :: Float
ufKeenessFactor = Float
n}))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fmax-worker-args"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d {maxWorkerArgs :: Int
maxWorkerArgs = Int
n}))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhciFlag String
"fghci-hist-size"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d {ghciHistSize :: Int
ghciHistSize = Int
n}))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"fmax-inline-alloc-size"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxInlineAllocSize :: Int
maxInlineAllocSize = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"fmax-inline-memcpy-insns"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxInlineMemcpyInsns :: Int
maxInlineMemcpyInsns = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"fmax-inline-memset-insns"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxInlineMemsetInsns :: Int
maxInlineMemsetInsns = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dinitial-unique"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { initialUnique :: Int
initialUnique = Int
n }))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"dunique-increment"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { uniqueIncrement :: Int
uniqueIncrement = Int
n }))

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

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

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

        ------ Compiler flags -----------------------------------------------

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

  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"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 :: GhcLink
ghcLink=GhcLink
NoLink }) DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> HscTarget -> DynP ()
setTarget HscTarget
HscNothing))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"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
        HscTarget -> DynP ()
setTarget HscTarget
HscInterpreted
        DynFlags -> DynP DynFlags
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
gopt_set DynFlags
dflags GeneralFlag
Opt_ByteCode)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"fobject-code"     (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ 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
      DynFlags
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
      HscTarget -> DynP ()
setTarget (HscTarget -> DynP ()) -> HscTarget -> DynP ()
forall a b. (a -> b) -> a -> b
$ DynFlags -> HscTarget
defaultObjectTarget DynFlags
dflags

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

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

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

         ------ Debugging flags ----------------------------------------------
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"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 (Bool
-> String
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
""          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 (Bool
-> String
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff String
"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 (Bool
-> String
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"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 (Bool
-> String
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff String
"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 (Bool
-> String
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"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 (Bool
-> String
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff String
"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]
++ ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (Bool
-> String
-> (WarningFlag -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"W"         WarningFlag -> DynP ()
setWarningFlag    ) [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (Bool
-> String
-> (WarningFlag -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff String
"Wno-"      WarningFlag -> DynP ()
unSetWarningFlag  ) [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (Bool
-> String
-> (WarningFlag -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"Werror="   WarningFlag -> DynP ()
setWErrorFlag )     [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (Bool
-> String
-> (WarningFlag -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"Wwarn="     WarningFlag -> DynP ()
unSetFatalWarningFlag )
                                                        [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (Bool
-> String
-> (WarningFlag -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"Wno-error=" WarningFlag -> DynP ()
unSetFatalWarningFlag )
                                                        [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (Bool
-> String
-> (WarningFlag -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"fwarn-"    WarningFlag -> DynP ()
setWarningFlag   ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> ((Deprecation, FlagSpec WarningFlag)
    -> (Deprecation, FlagSpec WarningFlag))
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, FlagSpec WarningFlag)
forall a. (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
hideFlag)
    [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (Bool
-> String
-> (WarningFlag -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff String
"fno-warn-" WarningFlag -> DynP ()
unSetWarningFlag ((Deprecation, FlagSpec WarningFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> ((Deprecation, FlagSpec WarningFlag)
    -> (Deprecation, FlagSpec WarningFlag))
-> (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Deprecation, FlagSpec WarningFlag)
-> (Deprecation, FlagSpec WarningFlag)
forall a. (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
hideFlag)
    [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ [ (Deprecation
NotDeprecated, String -> Flag (CmdLineP DynFlags)
unrecognisedWarning String
"W"),
      (Deprecation
Deprecated,    String -> Flag (CmdLineP DynFlags)
unrecognisedWarning String
"fwarn-"),
      (Deprecation
Deprecated,    String -> Flag (CmdLineP DynFlags)
unrecognisedWarning String
"fno-warn-") ]
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ [ DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"Werror=compat"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((WarningFlag -> DynP ()) -> [WarningFlag] -> DynP ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
setWErrorFlag [WarningFlag]
minusWcompatOpts))
    , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"Wno-error=compat"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((WarningFlag -> DynP ()) -> [WarningFlag] -> DynP ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
unSetFatalWarningFlag [WarningFlag]
minusWcompatOpts))
    , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"Wwarn=compat"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((WarningFlag -> DynP ()) -> [WarningFlag] -> DynP ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
unSetFatalWarningFlag [WarningFlag]
minusWcompatOpts)) ]
 [(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 (Bool
-> String
-> (Extension -> DynP ())
-> (Deprecation, FlagSpec Extension)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"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 (Bool
-> String
-> (Extension -> DynP ())
-> (Deprecation, FlagSpec Extension)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff String
"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 (Bool
-> String
-> (Extension -> DynP ())
-> (Deprecation, FlagSpec Extension)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"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 (Bool
-> String
-> (Extension -> DynP ())
-> (Deprecation, FlagSpec Extension)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff String
"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 (Bool
-> String
-> (Language -> DynP ())
-> (Deprecation, FlagSpec Language)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"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 (Bool
-> String
-> (SafeHaskellMode -> DynP ())
-> (Deprecation, FlagSpec SafeHaskellMode)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
Bool
-> String
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  String
"X"         SafeHaskellMode -> DynP ()
setSafeHaskell    ) [(Deprecation, FlagSpec SafeHaskellMode)]
safeHaskellFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ [ DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"XGenerics"
        (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 (m :: * -> *) a. Monad m => a -> m a
return ())
                  (String
"it does nothing; look into -XDefaultSignatures " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                   String
"and -XDeriveGeneric for generic programming support.")
    , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"XNoGenerics"
        (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 (m :: * -> *) a. Monad m => a -> m a
return ())
               (String
"it does nothing; look into -XDefaultSignatures and " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                  String
"-XDeriveGeneric for generic programming support.") ]

-- | This is where we handle unrecognised warning flags. We only issue a warning
-- if -Wunrecognised-warning-flags is set. See #11429 for context.
unrecognisedWarning :: String -> Flag (CmdLineP DynFlags)
unrecognisedWarning :: String -> Flag (CmdLineP DynFlags)
unrecognisedWarning String
prefix = DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defHiddenFlag String
prefix ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
Prefix String -> DynP ()
action)
  where
    action :: String -> EwM (CmdLineP DynFlags) ()
    action :: String -> DynP ()
action String
flag = do
      Bool
f <- WarningFlag -> DynFlags -> Bool
wopt WarningFlag
Opt_WarnUnrecognisedWarningFlags (DynFlags -> Bool) -> DynP DynFlags -> EwM (CmdLineP DynFlags) Bool
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
      Bool -> DynP () -> DynP ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
f (DynP () -> DynP ()) -> DynP () -> DynP ()
forall a b. (a -> b) -> a -> b
$ WarnReason -> String -> DynP ()
forall (m :: * -> *). Monad m => WarnReason -> String -> EwM m ()
addFlagWarn WarnReason
Cmd.ReasonUnrecognisedFlag (String -> DynP ()) -> String -> DynP ()
forall a b. (a -> b) -> a -> b
$
        String
"unrecognised warning flag: -" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
prefix String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
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
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"package-db"
      ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg (PkgConfRef -> DynP ()
addPkgConfRef (PkgConfRef -> DynP ())
-> (String -> PkgConfRef) -> String -> DynP ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PkgConfRef
PkgConfFile))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"clear-package-db"      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
clearPkgConf)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"no-global-package-db"  (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
removeGlobalPkgConf)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"no-user-package-db"    (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
removeUserPkgConf)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"global-package-db"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (PkgConfRef -> DynP ()
addPkgConfRef PkgConfRef
GlobalPkgConf))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"user-package-db"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (PkgConfRef -> DynP ()
addPkgConfRef PkgConfRef
UserPkgConf))
    -- backwards compat with GHC<=7.4 :
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"package-conf"
      ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ PkgConfRef -> DynP ()
addPkgConfRef (PkgConfRef -> DynP ())
-> (String -> PkgConfRef) -> String -> DynP ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PkgConfRef
PkgConfFile) String
"Use -package-db instead"
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"no-user-package-conf"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
removeUserPkgConf)              String
"Use -no-user-package-db instead"
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"package-name"       ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \String
name -> do
                                      (DynFlags -> DynFlags) -> DynP ()
upd (String -> DynFlags -> DynFlags
setUnitId String
name))
                                      -- TODO: Since we JUST deprecated
                                      -- -this-package-key, let's keep this
                                      -- undeprecated for another cycle.
                                      -- Deprecate this eventually.
                                      -- deprecate "Use -this-unit-id instead")
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"this-package-key"   ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg ((String -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (String -> DynFlags -> DynFlags) -> String -> DynP ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> DynFlags -> DynFlags
setUnitId)
                                                  String
"Use -this-unit-id instead"
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defGhcFlag String
"this-unit-id"       ((String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg String -> DynFlags -> DynFlags
setUnitId)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"package"               ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
exposePackage)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"plugin-package-id"     ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
exposePluginPackageId)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"plugin-package"        ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
exposePluginPackage)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"package-id"            ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
exposePackageId)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"hide-package"          ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
hidePackage)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"hide-all-packages"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_HideAllPackages))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"hide-all-plugin-packages"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_HideAllPluginPackages))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"package-env"           ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
setPackageEnv)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"ignore-package"        ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
ignorePackage)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"syslib" ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
exposePackage) String
"Use -package instead"
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"distrust-all-packages"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DistrustAllPackages))
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"trust"                 ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
trustPackage)
  , DynFlagMaker
-> String
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). String -> OptKind m -> Flag m
defFlag String
"distrust"              ((String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg String -> DynP ()
distrustPackage)
  ]
  where
    setPackageEnv :: String -> DynP ()
setPackageEnv String
env = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \DynFlags
s -> DynFlags
s { packageEnv :: Maybe String
packageEnv = String -> Maybe String
forall a. a -> Maybe a
Just String
env }

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

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

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

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

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

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

-- | Define a new deprecated flag.
depFlagSpec :: String -> flag -> String
            -> (Deprecation, FlagSpec flag)
depFlagSpec :: String -> flag -> String -> (Deprecation, FlagSpec flag)
depFlagSpec String
name flag
flag String
dep = String
-> flag
-> (Bool -> DynP ())
-> String
-> (Deprecation, FlagSpec flag)
forall flag.
String
-> flag
-> (Bool -> DynP ())
-> String
-> (Deprecation, FlagSpec flag)
depFlagSpecOp String
name flag
flag Bool -> DynP ()
nop String
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' :: String
-> flag
-> (Bool -> DynP ())
-> (Bool -> String)
-> (Deprecation, FlagSpec flag)
depFlagSpecOp' String
name flag
flag Bool -> DynP ()
act Bool -> String
dep =
    (Deprecation
Deprecated, String -> flag -> (Bool -> DynP ()) -> GhcFlagMode -> FlagSpec flag
forall flag.
String -> flag -> (Bool -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec String
name flag
flag (\Bool
f -> Bool -> DynP ()
act Bool
f DynP () -> DynP () -> DynP ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (String -> DynP ()
forall (m :: * -> *). Monad m => String -> EwM m ()
deprecate (String -> DynP ()) -> String -> DynP ()
forall a b. (a -> b) -> a -> b
$ Bool -> String
dep Bool
f))
                                                                       GhcFlagMode
AllModes)

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


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

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

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

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

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

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

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

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

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

nop :: TurnOnFlag -> DynP ()
nop :: Bool -> DynP ()
nop Bool
_ = () -> DynP ()
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
flag = [FlagSpec WarningFlag] -> Maybe (FlagSpec WarningFlag)
forall a. [a] -> Maybe a
listToMaybe ([FlagSpec WarningFlag] -> Maybe (FlagSpec WarningFlag))
-> [FlagSpec WarningFlag] -> Maybe (FlagSpec WarningFlag)
forall a b. (a -> b) -> a -> b
$ (FlagSpec WarningFlag -> Bool)
-> [FlagSpec WarningFlag] -> [FlagSpec WarningFlag]
forall a. (a -> Bool) -> [a] -> [a]
filter FlagSpec WarningFlag -> Bool
check [FlagSpec WarningFlag]
wWarningFlags
  where
    check :: FlagSpec WarningFlag -> Bool
check FlagSpec WarningFlag
fs = FlagSpec WarningFlag -> WarningFlag
forall flag. FlagSpec flag -> flag
flagSpecFlag FlagSpec WarningFlag
fs WarningFlag -> WarningFlag -> Bool
forall a. Eq a => a -> a -> Bool
== WarningFlag
flag

-- | 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 = [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
-- Please keep the list of flags below sorted alphabetically
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"alternative-layout-rule-transitional"
                                      WarningFlag
Opt_WarnAlternativeLayoutRuleTransitional,
  String
-> WarningFlag -> String -> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> String -> (Deprecation, FlagSpec flag)
depFlagSpec String
"auto-orphans"             WarningFlag
Opt_WarnAutoOrphans
    String
"it has no effect",
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"cpp-undef"                   WarningFlag
Opt_WarnCPPUndef,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unbanged-strict-patterns"    WarningFlag
Opt_WarnUnbangedStrictPatterns,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"deferred-type-errors"        WarningFlag
Opt_WarnDeferredTypeErrors,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"deferred-out-of-scope-variables"
                                         WarningFlag
Opt_WarnDeferredOutOfScopeVariables,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"deprecations"                WarningFlag
Opt_WarnWarningsDeprecations,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"deprecated-flags"            WarningFlag
Opt_WarnDeprecatedFlags,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"deriving-defaults"           WarningFlag
Opt_WarnDerivingDefaults,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"deriving-typeable"           WarningFlag
Opt_WarnDerivingTypeable,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"dodgy-exports"               WarningFlag
Opt_WarnDodgyExports,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"dodgy-foreign-imports"       WarningFlag
Opt_WarnDodgyForeignImports,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"dodgy-imports"               WarningFlag
Opt_WarnDodgyImports,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"empty-enumerations"          WarningFlag
Opt_WarnEmptyEnumerations,
  String
-> WarningFlag -> String -> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> String -> (Deprecation, FlagSpec flag)
depFlagSpec String
"duplicate-constraints"    WarningFlag
Opt_WarnDuplicateConstraints
    String
"it is subsumed by -Wredundant-constraints",
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"redundant-constraints"       WarningFlag
Opt_WarnRedundantConstraints,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"duplicate-exports"           WarningFlag
Opt_WarnDuplicateExports,
  String
-> WarningFlag -> String -> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> String -> (Deprecation, FlagSpec flag)
depFlagSpec String
"hi-shadowing"                WarningFlag
Opt_WarnHiShadows
    String
"it is not used, and was never implemented",
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"inaccessible-code"           WarningFlag
Opt_WarnInaccessibleCode,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"implicit-prelude"            WarningFlag
Opt_WarnImplicitPrelude,
  String
-> WarningFlag -> String -> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> String -> (Deprecation, FlagSpec flag)
depFlagSpec String
"implicit-kind-vars"       WarningFlag
Opt_WarnImplicitKindVars
    String
"it is now an error",
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"incomplete-patterns"         WarningFlag
Opt_WarnIncompletePatterns,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"incomplete-record-updates"   WarningFlag
Opt_WarnIncompletePatternsRecUpd,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"incomplete-uni-patterns"     WarningFlag
Opt_WarnIncompleteUniPatterns,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"inline-rule-shadowing"       WarningFlag
Opt_WarnInlineRuleShadowing,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"identities"                  WarningFlag
Opt_WarnIdentities,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-fields"              WarningFlag
Opt_WarnMissingFields,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-import-lists"        WarningFlag
Opt_WarnMissingImportList,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-export-lists"        WarningFlag
Opt_WarnMissingExportList,
  String
-> WarningFlag -> String -> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> String -> (Deprecation, FlagSpec flag)
depFlagSpec String
"missing-local-sigs"       WarningFlag
Opt_WarnMissingLocalSignatures
    String
"it is replaced by -Wmissing-local-signatures",
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-local-signatures"    WarningFlag
Opt_WarnMissingLocalSignatures,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-methods"             WarningFlag
Opt_WarnMissingMethods,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-monadfail-instances" WarningFlag
Opt_WarnMissingMonadFailInstances,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"semigroup"                   WarningFlag
Opt_WarnSemigroup,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-signatures"          WarningFlag
Opt_WarnMissingSignatures,
  String
-> WarningFlag -> String -> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> String -> (Deprecation, FlagSpec flag)
depFlagSpec String
"missing-exported-sigs"    WarningFlag
Opt_WarnMissingExportedSignatures
    String
"it is replaced by -Wmissing-exported-signatures",
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-exported-signatures" WarningFlag
Opt_WarnMissingExportedSignatures,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"monomorphism-restriction"    WarningFlag
Opt_WarnMonomorphism,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"name-shadowing"              WarningFlag
Opt_WarnNameShadowing,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"noncanonical-monad-instances"
                                         WarningFlag
Opt_WarnNonCanonicalMonadInstances,
  String
-> WarningFlag -> String -> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> String -> (Deprecation, FlagSpec flag)
depFlagSpec String
"noncanonical-monadfail-instances"
                                         WarningFlag
Opt_WarnNonCanonicalMonadInstances
    String
"fail is no longer a method of Monad",
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"noncanonical-monoid-instances"
                                         WarningFlag
Opt_WarnNonCanonicalMonoidInstances,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"orphans"                     WarningFlag
Opt_WarnOrphans,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"overflowed-literals"         WarningFlag
Opt_WarnOverflowedLiterals,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"overlapping-patterns"        WarningFlag
Opt_WarnOverlappingPatterns,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missed-specialisations"      WarningFlag
Opt_WarnMissedSpecs,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missed-specializations"      WarningFlag
Opt_WarnMissedSpecs,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"all-missed-specialisations"  WarningFlag
Opt_WarnAllMissedSpecs,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"all-missed-specializations"  WarningFlag
Opt_WarnAllMissedSpecs,
  String
-> WarningFlag
-> (Bool -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' String
"safe"                       WarningFlag
Opt_WarnSafe Bool -> DynP ()
setWarnSafe,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"trustworthy-safe"            WarningFlag
Opt_WarnTrustworthySafe,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"inferred-safe-imports"       WarningFlag
Opt_WarnInferredSafeImports,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-safe-haskell-mode"   WarningFlag
Opt_WarnMissingSafeHaskellMode,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"tabs"                        WarningFlag
Opt_WarnTabs,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"type-defaults"               WarningFlag
Opt_WarnTypeDefaults,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"typed-holes"                 WarningFlag
Opt_WarnTypedHoles,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"partial-type-signatures"     WarningFlag
Opt_WarnPartialTypeSignatures,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unrecognised-pragmas"        WarningFlag
Opt_WarnUnrecognisedPragmas,
  String
-> WarningFlag
-> (Bool -> DynP ())
-> (Deprecation, FlagSpec WarningFlag)
forall flag.
String -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' String
"unsafe"                     WarningFlag
Opt_WarnUnsafe Bool -> DynP ()
setWarnUnsafe,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unsupported-calling-conventions"
                                         WarningFlag
Opt_WarnUnsupportedCallingConventions,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unsupported-llvm-version"    WarningFlag
Opt_WarnUnsupportedLlvmVersion,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missed-extra-shared-lib"     WarningFlag
Opt_WarnMissedExtraSharedLib,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unticked-promoted-constructors"
                                         WarningFlag
Opt_WarnUntickedPromotedConstructors,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-do-bind"              WarningFlag
Opt_WarnUnusedDoBind,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-foralls"              WarningFlag
Opt_WarnUnusedForalls,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-imports"              WarningFlag
Opt_WarnUnusedImports,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-local-binds"          WarningFlag
Opt_WarnUnusedLocalBinds,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-matches"              WarningFlag
Opt_WarnUnusedMatches,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-pattern-binds"        WarningFlag
Opt_WarnUnusedPatternBinds,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-top-binds"            WarningFlag
Opt_WarnUnusedTopBinds,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-type-patterns"        WarningFlag
Opt_WarnUnusedTypePatterns,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-record-wildcards"     WarningFlag
Opt_WarnUnusedRecordWildcards,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"redundant-record-wildcards"  WarningFlag
Opt_WarnRedundantRecordWildcards,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"warnings-deprecations"       WarningFlag
Opt_WarnWarningsDeprecations,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"wrong-do-bind"               WarningFlag
Opt_WarnWrongDoBind,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-pattern-synonym-signatures"
                                    WarningFlag
Opt_WarnMissingPatternSynonymSignatures,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-deriving-strategies" WarningFlag
Opt_WarnMissingDerivingStrategies,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"simplifiable-class-constraints" WarningFlag
Opt_WarnSimplifiableClassConstraints,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-home-modules"        WarningFlag
Opt_WarnMissingHomeModules,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unrecognised-warning-flags"  WarningFlag
Opt_WarnUnrecognisedWarningFlags,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"star-binder"                 WarningFlag
Opt_WarnStarBinder,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"star-is-type"                WarningFlag
Opt_WarnStarIsType,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"missing-space-after-bang"    WarningFlag
Opt_WarnSpaceAfterBang,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"partial-fields"              WarningFlag
Opt_WarnPartialFields,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"prepositive-qualified-module"
                                         WarningFlag
Opt_WarnPrepositiveQualifiedModule,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unused-packages"             WarningFlag
Opt_WarnUnusedPackages,
  String -> WarningFlag -> (Deprecation, FlagSpec WarningFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"compat-unqualified-imports"  WarningFlag
Opt_WarnCompatUnqualifiedImports
 ]

-- | These @-\<blah\>@ flags can all be reversed with @-no-\<blah\>@
negatableFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]
negatableFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]
negatableFlagsDeps = [
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"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
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"ppr-case-as-let"            GeneralFlag
Opt_PprCaseAsLet,
  String
-> GeneralFlag
-> (Bool -> String)
-> (Deprecation, FlagSpec GeneralFlag)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"ppr-ticks"              GeneralFlag
Opt_PprShowTicks
     (\Bool
turn_on -> String -> String -> Bool -> String
useInstead String
"-d" String
"suppress-ticks" (Bool -> Bool
not Bool
turn_on)),
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-ticks"             GeneralFlag
Opt_SuppressTicks,
  String
-> GeneralFlag
-> (Bool -> String)
-> (Deprecation, FlagSpec GeneralFlag)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"suppress-stg-free-vars" GeneralFlag
Opt_SuppressStgExts
     (String -> String -> Bool -> String
useInstead String
"-d" String
"suppress-stg-exts"),
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-stg-exts"          GeneralFlag
Opt_SuppressStgExts,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-coercions"         GeneralFlag
Opt_SuppressCoercions,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-idinfo"            GeneralFlag
Opt_SuppressIdInfo,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-unfoldings"        GeneralFlag
Opt_SuppressUnfoldings,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-module-prefixes"   GeneralFlag
Opt_SuppressModulePrefixes,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-timestamps"        GeneralFlag
Opt_SuppressTimestamps,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-type-applications" GeneralFlag
Opt_SuppressTypeApplications,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-type-signatures"   GeneralFlag
Opt_SuppressTypeSignatures,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-uniques"           GeneralFlag
Opt_SuppressUniques,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"suppress-var-kinds"         GeneralFlag
Opt_SuppressVarKinds
  ]

-- | 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
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"asm-shortcutting"                 GeneralFlag
Opt_AsmShortcutting,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"break-on-error"               GeneralFlag
Opt_BreakOnError,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"break-on-exception"           GeneralFlag
Opt_BreakOnException,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"building-cabal-package"           GeneralFlag
Opt_BuildingCabalPackage,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"call-arity"                       GeneralFlag
Opt_CallArity,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"exitification"                    GeneralFlag
Opt_Exitification,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"case-merge"                       GeneralFlag
Opt_CaseMerge,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"case-folding"                     GeneralFlag
Opt_CaseFolding,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"cmm-elim-common-blocks"           GeneralFlag
Opt_CmmElimCommonBlocks,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"cmm-sink"                         GeneralFlag
Opt_CmmSink,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"cse"                              GeneralFlag
Opt_CSE,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"stg-cse"                          GeneralFlag
Opt_StgCSE,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"stg-lift-lams"                    GeneralFlag
Opt_StgLiftLams,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"cpr-anal"                         GeneralFlag
Opt_CprAnal,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"defer-diagnostics"                GeneralFlag
Opt_DeferDiagnostics,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"defer-type-errors"                GeneralFlag
Opt_DeferTypeErrors,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"defer-typed-holes"                GeneralFlag
Opt_DeferTypedHoles,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"defer-out-of-scope-variables"     GeneralFlag
Opt_DeferOutOfScopeVariables,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"diagnostics-show-caret"           GeneralFlag
Opt_DiagnosticsShowCaret,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"dicts-cheap"                      GeneralFlag
Opt_DictsCheap,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"dicts-strict"                     GeneralFlag
Opt_DictsStrict,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"dmd-tx-dict-sel"                  GeneralFlag
Opt_DmdTxDictSel,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"do-eta-reduction"                 GeneralFlag
Opt_DoEtaReduction,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"do-lambda-eta-expansion"          GeneralFlag
Opt_DoLambdaEtaExpansion,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"eager-blackholing"                GeneralFlag
Opt_EagerBlackHoling,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"embed-manifest"                   GeneralFlag
Opt_EmbedManifest,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"enable-rewrite-rules"             GeneralFlag
Opt_EnableRewriteRules,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"enable-th-splice-warnings"        GeneralFlag
Opt_EnableThSpliceWarnings,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"error-spans"                      GeneralFlag
Opt_ErrorSpans,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"excess-precision"                 GeneralFlag
Opt_ExcessPrecision,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"expose-all-unfoldings"            GeneralFlag
Opt_ExposeAllUnfoldings,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"external-dynamic-refs"            GeneralFlag
Opt_ExternalDynamicRefs,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"external-interpreter"             GeneralFlag
Opt_ExternalInterpreter,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"flat-cache"                       GeneralFlag
Opt_FlatCache,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"float-in"                         GeneralFlag
Opt_FloatIn,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"force-recomp"                     GeneralFlag
Opt_ForceRecomp,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"ignore-optim-changes"             GeneralFlag
Opt_IgnoreOptimChanges,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"ignore-hpc-changes"               GeneralFlag
Opt_IgnoreHpcChanges,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"full-laziness"                    GeneralFlag
Opt_FullLaziness,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"fun-to-thunk"                     GeneralFlag
Opt_FunToThunk,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"gen-manifest"                     GeneralFlag
Opt_GenManifest,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"ghci-history"                     GeneralFlag
Opt_GhciHistory,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"ghci-leak-check"                  GeneralFlag
Opt_GhciLeakCheck,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"validate-ide-info"                GeneralFlag
Opt_ValidateHie,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"local-ghci-history"           GeneralFlag
Opt_LocalGhciHistory,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"no-it"                        GeneralFlag
Opt_NoIt,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"ghci-sandbox"                     GeneralFlag
Opt_GhciSandbox,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"helpful-errors"                   GeneralFlag
Opt_HelpfulErrors,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"hpc"                              GeneralFlag
Opt_Hpc,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"ignore-asserts"                   GeneralFlag
Opt_IgnoreAsserts,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"ignore-interface-pragmas"         GeneralFlag
Opt_IgnoreInterfacePragmas,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"implicit-import-qualified"    GeneralFlag
Opt_ImplicitImportQualified,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"irrefutable-tuples"               GeneralFlag
Opt_IrrefutableTuples,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"keep-going"                       GeneralFlag
Opt_KeepGoing,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"kill-absence"                     GeneralFlag
Opt_KillAbsence,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"kill-one-shot"                    GeneralFlag
Opt_KillOneShot,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"late-dmd-anal"                    GeneralFlag
Opt_LateDmdAnal,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"late-specialise"                  GeneralFlag
Opt_LateSpecialise,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"liberate-case"                    GeneralFlag
Opt_LiberateCase,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagHiddenSpec String
"llvm-tbaa"                  GeneralFlag
Opt_LlvmTBAA,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagHiddenSpec String
"llvm-fill-undef-with-garbage" GeneralFlag
Opt_LlvmFillUndefWithGarbage,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"loopification"                    GeneralFlag
Opt_Loopification,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"block-layout-cfg"                 GeneralFlag
Opt_CfgBlocklayout,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"block-layout-weightless"          GeneralFlag
Opt_WeightlessBlocklayout,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"omit-interface-pragmas"           GeneralFlag
Opt_OmitInterfacePragmas,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"omit-yields"                      GeneralFlag
Opt_OmitYields,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"optimal-applicative-do"           GeneralFlag
Opt_OptimalApplicativeDo,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"pedantic-bottoms"                 GeneralFlag
Opt_PedanticBottoms,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"pre-inlining"                     GeneralFlag
Opt_SimplPreInlining,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"print-bind-contents"          GeneralFlag
Opt_PrintBindContents,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"print-bind-result"            GeneralFlag
Opt_PrintBindResult,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec String
"print-evld-with-show"         GeneralFlag
Opt_PrintEvldWithShow,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-explicit-foralls"           GeneralFlag
Opt_PrintExplicitForalls,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-explicit-kinds"             GeneralFlag
Opt_PrintExplicitKinds,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-explicit-coercions"         GeneralFlag
Opt_PrintExplicitCoercions,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-explicit-runtime-reps"      GeneralFlag
Opt_PrintExplicitRuntimeReps,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-equality-relations"         GeneralFlag
Opt_PrintEqualityRelations,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-axiom-incomps"              GeneralFlag
Opt_PrintAxiomIncomps,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-unicode-syntax"             GeneralFlag
Opt_PrintUnicodeSyntax,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-expanded-synonyms"          GeneralFlag
Opt_PrintExpandedSynonyms,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-potential-instances"        GeneralFlag
Opt_PrintPotentialInstances,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"print-typechecker-elaboration"    GeneralFlag
Opt_PrintTypecheckerElaboration,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"prof-cafs"                        GeneralFlag
Opt_AutoSccsOnIndividualCafs,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"prof-count-entries"               GeneralFlag
Opt_ProfCountEntries,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"regs-graph"                       GeneralFlag
Opt_RegsGraph,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"regs-iterative"                   GeneralFlag
Opt_RegsIterative,
  String
-> GeneralFlag
-> (Bool -> String)
-> (Deprecation, FlagSpec GeneralFlag)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"rewrite-rules"                GeneralFlag
Opt_EnableRewriteRules
   (String -> String -> Bool -> String
useInstead String
"-f" String
"enable-rewrite-rules"),
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"shared-implib"                    GeneralFlag
Opt_SharedImplib,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"spec-constr"                      GeneralFlag
Opt_SpecConstr,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"spec-constr-keen"                 GeneralFlag
Opt_SpecConstrKeen,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"specialise"                       GeneralFlag
Opt_Specialise,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"specialize"                       GeneralFlag
Opt_Specialise,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"specialise-aggressively"          GeneralFlag
Opt_SpecialiseAggressively,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"specialize-aggressively"          GeneralFlag
Opt_SpecialiseAggressively,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"cross-module-specialise"          GeneralFlag
Opt_CrossModuleSpecialise,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"cross-module-specialize"          GeneralFlag
Opt_CrossModuleSpecialise,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"static-argument-transformation"   GeneralFlag
Opt_StaticArgumentTransformation,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"strictness"                       GeneralFlag
Opt_Strictness,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"use-rpaths"                       GeneralFlag
Opt_RPath,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"write-interface"                  GeneralFlag
Opt_WriteInterface,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"write-ide-info"                   GeneralFlag
Opt_WriteHie,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unbox-small-strict-fields"        GeneralFlag
Opt_UnboxSmallStrictFields,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"unbox-strict-fields"              GeneralFlag
Opt_UnboxStrictFields,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"version-macros"                   GeneralFlag
Opt_VersionMacros,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"worker-wrapper"                   GeneralFlag
Opt_WorkerWrapper,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"solve-constant-dicts"             GeneralFlag
Opt_SolveConstantDicts,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"catch-bottoms"                    GeneralFlag
Opt_CatchBottoms,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"alignment-sanitisation"           GeneralFlag
Opt_AlignmentSanitisation,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"num-constant-folding"             GeneralFlag
Opt_NumConstantFolding,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-warning-groups"              GeneralFlag
Opt_ShowWarnGroups,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"hide-source-paths"                GeneralFlag
Opt_HideSourcePaths,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-loaded-modules"              GeneralFlag
Opt_ShowLoadedModules,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"whole-archive-hs-libs"            GeneralFlag
Opt_WholeArchiveHsLibs,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"keep-cafs"                        GeneralFlag
Opt_KeepCAFs
  ]
  [(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 TcHoleErrors module. These flags can all be reversed with
-- @-fno-\<blah\>@
fHoleFlags :: [(Deprecation, FlagSpec GeneralFlag)]
fHoleFlags :: [(Deprecation, FlagSpec GeneralFlag)]
fHoleFlags = [
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-hole-constraints"            GeneralFlag
Opt_ShowHoleConstraints,
  String
-> GeneralFlag
-> (Bool -> String)
-> (Deprecation, FlagSpec GeneralFlag)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"show-valid-substitutions"     GeneralFlag
Opt_ShowValidHoleFits
   (String -> String -> Bool -> String
useInstead String
"-f" String
"show-valid-hole-fits"),
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-valid-hole-fits"             GeneralFlag
Opt_ShowValidHoleFits,
  -- Sorting settings
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"sort-valid-hole-fits"             GeneralFlag
Opt_SortValidHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"sort-by-size-hole-fits"           GeneralFlag
Opt_SortBySizeHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"sort-by-subsumption-hole-fits"    GeneralFlag
Opt_SortBySubsumHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"abstract-refinement-hole-fits"    GeneralFlag
Opt_AbstractRefHoleFits,
  -- Output format settings
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-hole-matches-of-hole-fits"   GeneralFlag
Opt_ShowMatchesOfHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-provenance-of-hole-fits"     GeneralFlag
Opt_ShowProvOfHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-type-of-hole-fits"           GeneralFlag
Opt_ShowTypeOfHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-type-app-of-hole-fits"       GeneralFlag
Opt_ShowTypeAppOfHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-type-app-vars-of-hole-fits"  GeneralFlag
Opt_ShowTypeAppVarsOfHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"show-docs-of-hole-fits"           GeneralFlag
Opt_ShowDocsOfHoleFits,
  String -> GeneralFlag -> (Deprecation, FlagSpec GeneralFlag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec String
"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]
  String
-> Extension
-> (Bool -> DynP ())
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String
-> flag
-> (Bool -> DynP ())
-> (Bool -> String)
-> (Deprecation, FlagSpec flag)
depFlagSpecOp' String
"th"                           Extension
LangExt.TemplateHaskell
    Bool -> DynP ()
checkTemplateHaskellOk
    (String -> Bool -> String
deprecatedForExtension String
"TemplateHaskell"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"fi"                             Extension
LangExt.ForeignFunctionInterface
    (String -> Bool -> String
deprecatedForExtension String
"ForeignFunctionInterface"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"ffi"                            Extension
LangExt.ForeignFunctionInterface
    (String -> Bool -> String
deprecatedForExtension String
"ForeignFunctionInterface"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"arrows"                         Extension
LangExt.Arrows
    (String -> Bool -> String
deprecatedForExtension String
"Arrows"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"implicit-prelude"               Extension
LangExt.ImplicitPrelude
    (String -> Bool -> String
deprecatedForExtension String
"ImplicitPrelude"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"bang-patterns"                  Extension
LangExt.BangPatterns
    (String -> Bool -> String
deprecatedForExtension String
"BangPatterns"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"monomorphism-restriction"       Extension
LangExt.MonomorphismRestriction
    (String -> Bool -> String
deprecatedForExtension String
"MonomorphismRestriction"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"mono-pat-binds"                 Extension
LangExt.MonoPatBinds
    (String -> Bool -> String
deprecatedForExtension String
"MonoPatBinds"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"extended-default-rules"         Extension
LangExt.ExtendedDefaultRules
    (String -> Bool -> String
deprecatedForExtension String
"ExtendedDefaultRules"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"implicit-params"                Extension
LangExt.ImplicitParams
    (String -> Bool -> String
deprecatedForExtension String
"ImplicitParams"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"scoped-type-variables"          Extension
LangExt.ScopedTypeVariables
    (String -> Bool -> String
deprecatedForExtension String
"ScopedTypeVariables"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"allow-overlapping-instances"    Extension
LangExt.OverlappingInstances
    (String -> Bool -> String
deprecatedForExtension String
"OverlappingInstances"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"allow-undecidable-instances"    Extension
LangExt.UndecidableInstances
    (String -> Bool -> String
deprecatedForExtension String
"UndecidableInstances"),
  String
-> Extension
-> (Bool -> String)
-> (Deprecation, FlagSpec Extension)
forall flag.
String -> flag -> (Bool -> String) -> (Deprecation, FlagSpec flag)
depFlagSpec' String
"allow-incoherent-instances"     Extension
LangExt.IncoherentInstances
    (String -> Bool -> String
deprecatedForExtension String
"IncoherentInstances")
  ]

supportedLanguages :: [String]
supportedLanguages :: [String]
supportedLanguages = ((Deprecation, FlagSpec Language) -> String)
-> [(Deprecation, FlagSpec Language)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (FlagSpec Language -> String
forall flag. FlagSpec flag -> String
flagSpecName (FlagSpec Language -> String)
-> ((Deprecation, FlagSpec Language) -> FlagSpec Language)
-> (Deprecation, FlagSpec Language)
-> String
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 :: [String]
supportedLanguageOverlays = ((Deprecation, FlagSpec SafeHaskellMode) -> String)
-> [(Deprecation, FlagSpec SafeHaskellMode)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (FlagSpec SafeHaskellMode -> String
forall flag. FlagSpec flag -> String
flagSpecName (FlagSpec SafeHaskellMode -> String)
-> ((Deprecation, FlagSpec SafeHaskellMode)
    -> FlagSpec SafeHaskellMode)
-> (Deprecation, FlagSpec SafeHaskellMode)
-> String
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 :: PlatformMini -> [String]
supportedExtensions :: PlatformMini -> [String]
supportedExtensions PlatformMini
targetPlatformMini = (FlagSpec Extension -> [String])
-> [FlagSpec Extension] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap FlagSpec Extension -> [String]
toFlagSpecNamePair [FlagSpec Extension]
xFlags
  where
    toFlagSpecNamePair :: FlagSpec Extension -> [String]
toFlagSpecNamePair FlagSpec Extension
flg
      -- IMPORTANT! Make sure that `ghc --supported-extensions` omits
      -- "TemplateHaskell"/"QuasiQuotes" when it's known not to work out of the
      -- box. See also GHC #11102 and #16331 for more details about
      -- the rationale
      | Bool
isAIX, FlagSpec Extension -> Extension
forall flag. FlagSpec flag -> flag
flagSpecFlag FlagSpec Extension
flg Extension -> Extension -> Bool
forall a. Eq a => a -> a -> Bool
== Extension
LangExt.TemplateHaskell  = [String
noName]
      | Bool
isAIX, FlagSpec Extension -> Extension
forall flag. FlagSpec flag -> flag
flagSpecFlag FlagSpec Extension
flg Extension -> Extension -> Bool
forall a. Eq a => a -> a -> Bool
== Extension
LangExt.QuasiQuotes      = [String
noName]
      | Bool
otherwise = [String
name, String
noName]
      where
        isAIX :: Bool
isAIX = PlatformMini -> OS
platformMini_os PlatformMini
targetPlatformMini OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== OS
OSAIX
        noName :: String
noName = String
"No" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
name
        name :: String
name = FlagSpec Extension -> String
forall flag. FlagSpec flag -> String
flagSpecName FlagSpec Extension
flg

supportedLanguagesAndExtensions :: PlatformMini -> [String]
supportedLanguagesAndExtensions :: PlatformMini -> [String]
supportedLanguagesAndExtensions PlatformMini
targetPlatformMini =
    [String]
supportedLanguages [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
supportedLanguageOverlays [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ PlatformMini -> [String]
supportedExtensions PlatformMini
targetPlatformMini

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

-- | 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 = String -> flag -> (Deprecation, FlagSpec flag)
forall flag. String -> flag -> (Deprecation, FlagSpec flag)
flagSpec (flag -> String
forall a. Show a => a -> String
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

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

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

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

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

    [GeneralFlag] -> [GeneralFlag] -> [GeneralFlag]
forall a. [a] -> [a] -> [a]
++ (Way -> [GeneralFlag]) -> [Way] -> [GeneralFlag]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [GeneralFlag]
wayGeneralFlags Platform
platform) (Settings -> [Way]
defaultWays Settings
settings)
    [GeneralFlag] -> [GeneralFlag] -> [GeneralFlag]
forall a. [a] -> [a] -> [a]
++ [GeneralFlag]
validHoleFitDefaults

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

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


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

default_PIC :: Platform -> [GeneralFlag]
default_PIC :: Platform -> [GeneralFlag]
default_PIC Platform
platform =
  case (Platform -> OS
platformOS Platform
platform, Platform -> Arch
platformArch Platform
platform) of
    (OS
OSDarwin, Arch
ArchX86_64) -> [GeneralFlag
Opt_PIC]
    (OS
OSOpenBSD, Arch
ArchX86_64) -> [GeneralFlag
Opt_PIC] -- Due to PIE support in
                                         -- OpenBSD since 5.3 release
                                         -- (1 May 2013) we need to
                                         -- always generate PIC. See
                                         -- #10597 for more
                                         -- information.
    (OS, Arch)
_                      -> []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

optLevelFlags :: [([Int], GeneralFlag)]
optLevelFlags :: [([Int], GeneralFlag)]
optLevelFlags -- see Note [Documenting optimisation flags]
  = [ ([Int
0,Int
1,Int
2], GeneralFlag
Opt_DoLambdaEtaExpansion)
    , ([Int
0,Int
1,Int
2], GeneralFlag
Opt_DoEtaReduction)       -- See Note [Eta-reduction in -O0]
    , ([Int
0,Int
1,Int
2], GeneralFlag
Opt_DmdTxDictSel)
    , ([Int
0,Int
1,Int
2], GeneralFlag
Opt_LlvmTBAA)

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

    , ([Int
1,Int
2],   GeneralFlag
Opt_CallArity)
    , ([Int
1,Int
2],   GeneralFlag
Opt_Exitification)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CaseMerge)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CaseFolding)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CmmElimCommonBlocks)
    , ([Int
2],     GeneralFlag
Opt_AsmShortcutting)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CmmSink)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CSE)
    , ([Int
1,Int
2],   GeneralFlag
Opt_StgCSE)
    , ([Int
2],     GeneralFlag
Opt_StgLiftLams)
    , ([Int
1,Int
2],   GeneralFlag
Opt_EnableRewriteRules)  -- Off for -O0; see Note [Scoping for Builtin rules]
                                         --              in PrelRules
    , ([Int
1,Int
2],   GeneralFlag
Opt_FloatIn)
    , ([Int
1,Int
2],   GeneralFlag
Opt_FullLaziness)
    , ([Int
1,Int
2],   GeneralFlag
Opt_IgnoreAsserts)
    , ([Int
1,Int
2],   GeneralFlag
Opt_Loopification)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CfgBlocklayout)      -- Experimental

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

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

{- Note [Eta-reduction in -O0]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#11562 showed an example which tripped an ASSERT in CoreToStg; a
function was marked as MayHaveCafRefs when in fact it obviously
didn't.  Reason was:
 * Eta reduction wasn't happening in the simplifier, but it was
   happening in CorePrep, on
        $fBla = MkDict (/\a. K a)
 * Result: rhsIsStatic told TidyPgm that $fBla might have CAF refs
   but the eta-reduced version (MkDict K) obviously doesn't
Simple solution: just let the simplifier do eta-reduction even in -O0.
After all, CorePrep does it unconditionally!  Not a big deal, but
removes an assertion failure. -}


-- -----------------------------------------------------------------------------
-- Standard sets of warning options

-- Note [Documenting warning flags]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- If you change the list of warning enabled by default
-- please remember to update the User's Guide. The relevant file is:
--
--  docs/users_guide/using-warnings.rst

-- | Warning groups.
--
-- As all warnings are in the Weverything set, it is ignored when
-- displaying to the user which group a warning is in.
warningGroups :: [(String, [WarningFlag])]
warningGroups :: [(String, [WarningFlag])]
warningGroups =
    [ (String
"compat",       [WarningFlag]
minusWcompatOpts)
    , (String
"unused-binds", [WarningFlag]
unusedBindsFlags)
    , (String
"default",      [WarningFlag]
standardWarnings)
    , (String
"extra",        [WarningFlag]
minusWOpts)
    , (String
"all",          [WarningFlag]
minusWallOpts)
    , (String
"everything",   [WarningFlag]
minusWeverythingOpts)
    ]

-- | Warning group hierarchies, where there is an explicit inclusion
-- relation.
--
-- Each inner list is a hierarchy of warning groups, ordered from
-- smallest to largest, where each group is a superset of the one
-- before it.
--
-- Separating this from 'warningGroups' allows for multiple
-- hierarchies with no inherent relation to be defined.
--
-- The special-case Weverything group is not included.
warningHierarchies :: [[String]]
warningHierarchies :: [[String]]
warningHierarchies = [[String]]
hierarchies [[String]] -> [[String]] -> [[String]]
forall a. [a] -> [a] -> [a]
++ (String -> [String]) -> [String] -> [[String]]
forall a b. (a -> b) -> [a] -> [b]
map (String -> [String] -> [String]
forall a. a -> [a] -> [a]
:[]) [String]
rest
  where
    hierarchies :: [[String]]
hierarchies = [[String
"default", String
"extra", String
"all"]]
    rest :: [String]
rest = (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` String
"everything" String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [[String]] -> [String]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[String]]
hierarchies) ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$
           ((String, [WarningFlag]) -> String)
-> [(String, [WarningFlag])] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, [WarningFlag]) -> String
forall a b. (a, b) -> a
fst [(String, [WarningFlag])]
warningGroups

-- | Find the smallest group in every hierarchy which a warning
-- belongs to, excluding Weverything.
smallestGroups :: WarningFlag -> [String]
smallestGroups :: WarningFlag -> [String]
smallestGroups WarningFlag
flag = ([String] -> Maybe String) -> [[String]] -> [String]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe [String] -> Maybe String
go [[String]]
warningHierarchies where
    -- Because each hierarchy is arranged from smallest to largest,
    -- the first group we find in a hierarchy which contains the flag
    -- is the smallest.
    go :: [String] -> Maybe String
go (String
group:[String]
rest) = Maybe String -> Maybe (Maybe String) -> Maybe String
forall a. a -> Maybe a -> a
fromMaybe ([String] -> Maybe String
go [String]
rest) (Maybe (Maybe String) -> Maybe String)
-> Maybe (Maybe String) -> Maybe String
forall a b. (a -> b) -> a -> b
$ do
        [WarningFlag]
flags <- String -> [(String, [WarningFlag])] -> Maybe [WarningFlag]
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup String
group [(String, [WarningFlag])]
warningGroups
        Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (WarningFlag
flag WarningFlag -> [WarningFlag] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [WarningFlag]
flags)
        Maybe String -> Maybe (Maybe String)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Maybe String
forall a. a -> Maybe a
Just String
group)
    go [] = Maybe String
forall a. Maybe a
Nothing

-- | Warnings enabled unless specified otherwise
standardWarnings :: [WarningFlag]
standardWarnings :: [WarningFlag]
standardWarnings -- see Note [Documenting warning flags]
    = [ WarningFlag
Opt_WarnOverlappingPatterns,
        WarningFlag
Opt_WarnWarningsDeprecations,
        WarningFlag
Opt_WarnDeprecatedFlags,
        WarningFlag
Opt_WarnDeferredTypeErrors,
        WarningFlag
Opt_WarnTypedHoles,
        WarningFlag
Opt_WarnDeferredOutOfScopeVariables,
        WarningFlag
Opt_WarnPartialTypeSignatures,
        WarningFlag
Opt_WarnUnrecognisedPragmas,
        WarningFlag
Opt_WarnDuplicateExports,
        WarningFlag
Opt_WarnDerivingDefaults,
        WarningFlag
Opt_WarnOverflowedLiterals,
        WarningFlag
Opt_WarnEmptyEnumerations,
        WarningFlag
Opt_WarnMissingFields,
        WarningFlag
Opt_WarnMissingMethods,
        WarningFlag
Opt_WarnWrongDoBind,
        WarningFlag
Opt_WarnUnsupportedCallingConventions,
        WarningFlag
Opt_WarnDodgyForeignImports,
        WarningFlag
Opt_WarnInlineRuleShadowing,
        WarningFlag
Opt_WarnAlternativeLayoutRuleTransitional,
        WarningFlag
Opt_WarnUnsupportedLlvmVersion,
        WarningFlag
Opt_WarnMissedExtraSharedLib,
        WarningFlag
Opt_WarnTabs,
        WarningFlag
Opt_WarnUnrecognisedWarningFlags,
        WarningFlag
Opt_WarnSimplifiableClassConstraints,
        WarningFlag
Opt_WarnStarBinder,
        WarningFlag
Opt_WarnInaccessibleCode,
        WarningFlag
Opt_WarnSpaceAfterBang
      ]

-- | Things you get with -W
minusWOpts :: [WarningFlag]
minusWOpts :: [WarningFlag]
minusWOpts
    = [WarningFlag]
standardWarnings [WarningFlag] -> [WarningFlag] -> [WarningFlag]
forall a. [a] -> [a] -> [a]
++
      [ WarningFlag
Opt_WarnUnusedTopBinds,
        WarningFlag
Opt_WarnUnusedLocalBinds,
        WarningFlag
Opt_WarnUnusedPatternBinds,
        WarningFlag
Opt_WarnUnusedMatches,
        WarningFlag
Opt_WarnUnusedForalls,
        WarningFlag
Opt_WarnUnusedImports,
        WarningFlag
Opt_WarnIncompletePatterns,
        WarningFlag
Opt_WarnDodgyExports,
        WarningFlag
Opt_WarnDodgyImports,
        WarningFlag
Opt_WarnUnbangedStrictPatterns
      ]

-- | Things you get with -Wall
minusWallOpts :: [WarningFlag]
minusWallOpts :: [WarningFlag]
minusWallOpts
    = [WarningFlag]
minusWOpts [WarningFlag] -> [WarningFlag] -> [WarningFlag]
forall a. [a] -> [a] -> [a]
++
      [ WarningFlag
Opt_WarnTypeDefaults,
        WarningFlag
Opt_WarnNameShadowing,
        WarningFlag
Opt_WarnMissingSignatures,
        WarningFlag
Opt_WarnHiShadows,
        WarningFlag
Opt_WarnOrphans,
        WarningFlag
Opt_WarnUnusedDoBind,
        WarningFlag
Opt_WarnTrustworthySafe,
        WarningFlag
Opt_WarnUntickedPromotedConstructors,
        WarningFlag
Opt_WarnMissingPatternSynonymSignatures,
        WarningFlag
Opt_WarnUnusedRecordWildcards,
        WarningFlag
Opt_WarnRedundantRecordWildcards
      ]

-- | Things you get with -Weverything, i.e. *all* known warnings flags
minusWeverythingOpts :: [WarningFlag]
minusWeverythingOpts :: [WarningFlag]
minusWeverythingOpts = [ Int -> WarningFlag
forall a. Enum a => Int -> a
toEnum Int
0 .. ]

-- | Things you get with -Wcompat.
--
-- This is intended to group together warnings that will be enabled by default
-- at some point in the future, so that library authors eager to make their
-- code future compatible to fix issues before they even generate warnings.
minusWcompatOpts :: [WarningFlag]
minusWcompatOpts :: [WarningFlag]
minusWcompatOpts
    = [ WarningFlag
Opt_WarnMissingMonadFailInstances
      , WarningFlag
Opt_WarnSemigroup
      , WarningFlag
Opt_WarnNonCanonicalMonoidInstances
      , WarningFlag
Opt_WarnStarIsType
      , WarningFlag
Opt_WarnCompatUnqualifiedImports
      ]

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

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

-- Things you get with -Wunused-binds
unusedBindsFlags :: [WarningFlag]
unusedBindsFlags :: [WarningFlag]
unusedBindsFlags = [ WarningFlag
Opt_WarnUnusedTopBinds
                   , WarningFlag
Opt_WarnUnusedLocalBinds
                   , WarningFlag
Opt_WarnUnusedPatternBinds
                   ]

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

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

foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt

-- | Was the runtime system built with profiling enabled?
rtsIsProfiled :: Bool
rtsIsProfiled :: Bool
rtsIsProfiled = IO CInt -> CInt
forall a. IO a -> a
unsafeDupablePerformIO IO CInt
rtsIsProfiledIO CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0

-- Consult the RTS to find whether GHC itself has been built with
-- dynamic linking.  This can't be statically known at compile-time,
-- because we build both the static and dynamic versions together with
-- -dynamic-too.
foreign import ccall unsafe "rts_isDynamic" rtsIsDynamicIO :: IO CInt

dynamicGhc :: Bool
dynamicGhc :: Bool
dynamicGhc = IO CInt -> CInt
forall a. IO a -> a
unsafeDupablePerformIO IO CInt
rtsIsDynamicIO CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0

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

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

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

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

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

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

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

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

type DynP = EwM (CmdLineP DynFlags)

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

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

--------------- Constructor functions for OptKind -----------------
noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg DynFlags -> DynFlags
fn = 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 :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg String -> DynFlags -> DynFlags
fn = (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
HasArg ((DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (String -> DynFlags -> DynFlags) -> String -> DynP ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> DynFlags -> DynFlags
fn)

sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg String -> DynFlags -> DynFlags
fn = (String -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (String -> EwM m ()) -> OptKind m
SepArg ((DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (String -> DynFlags -> DynFlags) -> String -> DynP ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> 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))

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)

--------------------------
addWay :: Way -> DynP ()
addWay :: Way -> DynP ()
addWay Way
w = (DynFlags -> DynFlags) -> DynP ()
upd (Way -> DynFlags -> DynFlags
addWay' Way
w)

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 { ways :: [Way]
ways = Way
w Way -> [Way] -> [Way]
forall a. a -> [a] -> [a]
: DynFlags -> [Way]
ways DynFlags
dflags0 }
                        dflags2 :: DynFlags
dflags2 = (GeneralFlag -> DynFlags -> DynFlags)
-> DynFlags -> [GeneralFlag] -> DynFlags
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 (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' DynFlags
dflags2
                                        (Platform -> Way -> [GeneralFlag]
wayUnsetGeneralFlags Platform
platform Way
w)
                    in DynFlags
dflags3

removeWayDyn :: DynP ()
removeWayDyn :: DynP ()
removeWayDyn = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags
dfs { ways :: [Way]
ways = (Way -> Bool) -> [Way] -> [Way]
forall a. (a -> Bool) -> [a] -> [a]
filter (Way
WayDyn Way -> Way -> Bool
forall a. Eq a => a -> a -> Bool
/=) (DynFlags -> [Way]
ways DynFlags
dfs) })

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

setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' GeneralFlag
f DynFlags
dflags = ((DynFlags -> DynFlags) -> DynFlags -> DynFlags)
-> DynFlags -> [DynFlags -> DynFlags] -> DynFlags
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 Bool
turn_on then GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag'   GeneralFlag
d
                        else GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' GeneralFlag
d
           | (GeneralFlag
f', Bool
turn_on, GeneralFlag
d) <- [(GeneralFlag, Bool, GeneralFlag)]
impliedGFlags, GeneralFlag
f' GeneralFlag -> GeneralFlag -> Bool
forall a. Eq a => a -> a -> Bool
== GeneralFlag
f ]
        -- When you set f, set the ones it implies
        -- NB: use setGeneralFlag recursively, in case the implied flags
        --     implies further flags

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

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

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

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

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

setExtensionFlag', unSetExtensionFlag' :: LangExt.Extension -> DynFlags -> DynFlags
setExtensionFlag' :: Extension -> DynFlags -> DynFlags
setExtensionFlag' Extension
f DynFlags
dflags = ((DynFlags -> DynFlags) -> DynFlags -> DynFlags)
-> DynFlags -> [DynFlags -> DynFlags] -> DynFlags
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 = [ if Bool
turn_on then Extension -> DynFlags -> DynFlags
setExtensionFlag'   Extension
d
                        else Extension -> DynFlags -> DynFlags
unSetExtensionFlag' Extension
d
           | (Extension
f', Bool
turn_on, Extension
d) <- [(Extension, Bool, Extension)]
impliedXFlags, Extension
f' Extension -> Extension -> Bool
forall a. Eq a => a -> a -> Bool
== Extension
f ]
        -- When you set f, set the ones it implies
        -- NB: use setExtensionFlag recursively, in case the implied flags
        --     implies further flags

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

--------------------------
alterFileSettings :: (FileSettings -> FileSettings) -> DynFlags -> DynFlags
alterFileSettings :: (FileSettings -> FileSettings) -> DynFlags -> DynFlags
alterFileSettings FileSettings -> FileSettings
f DynFlags
dynFlags = DynFlags
dynFlags { fileSettings :: FileSettings
fileSettings = FileSettings -> FileSettings
f (DynFlags -> FileSettings
fileSettings DynFlags
dynFlags) }

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

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

forceRecompile :: DynP ()
-- Whenver we -ddump, force recompilation (by switching off the
-- recompilation checker), else you don't see the dump! However,
-- don't switch it off in --make mode, else *everything* gets
-- recompiled which probably isn't what you want
forceRecompile :: DynP ()
forceRecompile = do DynFlags
dfs <- 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
                    Bool -> DynP () -> DynP ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DynFlags -> Bool
force_recomp DynFlags
dfs) (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_ForceRecomp)
        where
          force_recomp :: DynFlags -> Bool
force_recomp DynFlags
dfs = GhcMode -> Bool
isOneShot (DynFlags -> GhcMode
ghcMode DynFlags
dfs)


setVerboseCore2Core :: DynP ()
setVerboseCore2Core :: DynP ()
setVerboseCore2Core = DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_verbose_core2core

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

setDebugLevel :: Maybe Int -> DynP ()
setDebugLevel :: Maybe Int -> DynP ()
setDebugLevel Maybe Int
mb_n = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags
dfs{ debugLevel :: Int
debugLevel = Maybe Int
mb_n Maybe Int -> Int -> Int
forall a. Maybe a -> a -> a
`orElse` Int
2 })

data PkgConfRef
  = GlobalPkgConf
  | UserPkgConf
  | PkgConfFile FilePath
  deriving PkgConfRef -> PkgConfRef -> Bool
(PkgConfRef -> PkgConfRef -> Bool)
-> (PkgConfRef -> PkgConfRef -> Bool) -> Eq PkgConfRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PkgConfRef -> PkgConfRef -> Bool
$c/= :: PkgConfRef -> PkgConfRef -> Bool
== :: PkgConfRef -> PkgConfRef -> Bool
$c== :: PkgConfRef -> PkgConfRef -> Bool
Eq

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

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

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

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

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

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

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

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

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

parseUnitIdArg :: ReadP PackageArg
parseUnitIdArg :: ReadP PackageArg
parseUnitIdArg =
    (UnitId -> PackageArg) -> ReadP UnitId -> ReadP PackageArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap UnitId -> PackageArg
UnitIdArg ReadP UnitId
parseUnitId

setUnitId :: String -> DynFlags -> DynFlags
setUnitId :: String -> DynFlags -> DynFlags
setUnitId String
p DynFlags
d = DynFlags
d { thisInstalledUnitId :: InstalledUnitId
thisInstalledUnitId = String -> InstalledUnitId
stringToInstalledUnitId String
p }

-- | Given a 'ModuleName' of a signature in the home library, find
-- out how it is instantiated.  E.g., the canonical form of
-- A in @p[A=q[]:A]@ is @q[]:A@.
canonicalizeHomeModule :: DynFlags -> ModuleName -> Module
canonicalizeHomeModule :: DynFlags -> ModuleName -> Module
canonicalizeHomeModule DynFlags
dflags ModuleName
mod_name =
    case ModuleName -> [(ModuleName, Module)] -> Maybe Module
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup ModuleName
mod_name (DynFlags -> [(ModuleName, Module)]
thisUnitIdInsts DynFlags
dflags) of
        Maybe Module
Nothing  -> UnitId -> ModuleName -> Module
mkModule (DynFlags -> UnitId
thisPackage DynFlags
dflags) ModuleName
mod_name
        Just Module
mod -> Module
mod

canonicalizeModuleIfHome :: DynFlags -> Module -> Module
canonicalizeModuleIfHome :: DynFlags -> Module -> Module
canonicalizeModuleIfHome DynFlags
dflags Module
mod
    = if DynFlags -> UnitId
thisPackage DynFlags
dflags UnitId -> UnitId -> Bool
forall a. Eq a => a -> a -> Bool
== Module -> UnitId
moduleUnitId Module
mod
                      then DynFlags -> ModuleName -> Module
canonicalizeHomeModule DynFlags
dflags (Module -> ModuleName
moduleName Module
mod)
                      else Module
mod

-- If we're linking a binary, then only targets that produce object
-- code are allowed (requests for other target types are ignored).
setTarget :: HscTarget -> DynP ()
setTarget :: HscTarget -> DynP ()
setTarget HscTarget
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 -> Bool
forall a. Eq a => a -> a -> Bool
/= GhcLink
LinkBinary Bool -> Bool -> Bool
|| HscTarget -> Bool
isObjectTarget HscTarget
l
  then DynFlags
dfs{ hscTarget :: HscTarget
hscTarget = HscTarget
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.
setObjTarget :: HscTarget -> DynP ()
setObjTarget :: HscTarget -> DynP ()
setObjTarget HscTarget
l = (DynFlags -> DynP DynFlags) -> DynP ()
updM DynFlags -> DynP DynFlags
forall (m :: * -> *). Monad m => DynFlags -> m DynFlags
set
  where
   set :: DynFlags -> m DynFlags
set DynFlags
dflags
     | HscTarget -> Bool
isObjectTarget (DynFlags -> HscTarget
hscTarget DynFlags
dflags)
       = DynFlags -> m DynFlags
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> m DynFlags) -> DynFlags -> m DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dflags { hscTarget :: HscTarget
hscTarget = HscTarget
l }
     | Bool
otherwise = DynFlags -> m DynFlags
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 (m :: * -> *) a. Monad m => a -> m a
return (Int -> DynFlags -> DynFlags
updOptLevel Int
n DynFlags
dflags)

checkOptLevel :: Int -> DynFlags -> Either String DynFlags
checkOptLevel :: Int -> DynFlags -> Either String DynFlags
checkOptLevel Int
n DynFlags
dflags
   | DynFlags -> HscTarget
hscTarget DynFlags
dflags HscTarget -> HscTarget -> Bool
forall a. Eq a => a -> a -> Bool
== HscTarget
HscInterpreted Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0
     = String -> Either String DynFlags
forall a b. a -> Either a b
Left String
"-O conflicts with --interactive; -O ignored."
   | Bool
otherwise
     = DynFlags -> Either String DynFlags
forall a b. b -> Either a b
Right DynFlags
dflags

setMainIs :: String -> DynP ()
setMainIs :: String -> DynP ()
setMainIs String
arg
  | Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
main_fn) Bool -> Bool -> Bool
&& Char -> Bool
isLower (String -> Char
forall a. [a] -> a
head String
main_fn)
     -- The arg looked like "Foo.Bar.baz"
  = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { mainFunIs :: Maybe String
mainFunIs = String -> Maybe String
forall a. a -> Maybe a
Just String
main_fn,
                   mainModIs :: Module
mainModIs = UnitId -> ModuleName -> Module
mkModule UnitId
mainUnitId (String -> ModuleName
mkModuleName String
main_mod) }

  | Char -> Bool
isUpper (String -> Char
forall a. [a] -> a
head String
arg)  -- The arg looked like "Foo" or "Foo.Bar"
  = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { mainModIs :: Module
mainModIs = UnitId -> ModuleName -> Module
mkModule UnitId
mainUnitId (String -> ModuleName
mkModuleName String
arg) }

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

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

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

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

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


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

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

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

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

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

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

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

splitPathList :: String -> [String]
splitPathList :: String -> [String]
splitPathList String
s = (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter String -> Bool
forall a. [a] -> Bool
notNull (String -> [String]
splitUp String
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 :: String -> [String]
splitUp String
xs = Char -> String -> [String]
split Char
split_marker String
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 :: String -> DynFlags -> DynFlags
setTmpDir String
dir = (FileSettings -> FileSettings) -> DynFlags -> DynFlags
alterFileSettings ((FileSettings -> FileSettings) -> DynFlags -> DynFlags)
-> (FileSettings -> FileSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \FileSettings
s -> FileSettings
s { fileSettings_tmpDir :: String
fileSettings_tmpDir = ShowS
normalise String
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 :: String -> DynP ()
setRtsOpts String
arg  = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \ DynFlags
d -> DynFlags
d {rtsOpts :: Maybe String
rtsOpts = String -> Maybe String
forall a. a -> Maybe a
Just String
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 :: RtsOptsEnabled
rtsOptsEnabled = RtsOptsEnabled
arg}

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

setOptHpcDir :: String -> DynP ()
setOptHpcDir :: String -> DynP ()
setOptHpcDir String
arg  = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \ DynFlags
d -> DynFlags
d {hpcDir :: String
hpcDir = String
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 -> [String]
picCCOpts DynFlags
dflags = [String]
pieOpts [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
picOpts
  where
    picOpts :: [String]
picOpts =
      case Platform -> OS
platformOS (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
      OS
OSDarwin
          -- Apple prefers to do things the other way round.
          -- PIC is on by default.
          -- -mdynamic-no-pic:
          --     Turn off PIC code generation.
          -- -fno-common:
          --     Don't generate "common" symbols - these are unwanted
          --     in dynamic libraries.

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

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


{-
Note [No PIE while 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 -> [String]
picPOpts DynFlags
dflags
 | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags = [String
"-U__PIC__", String
"-D__PIC__"]
 | Bool
otherwise           = []

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

compilerInfo :: DynFlags -> [(String, String)]
compilerInfo :: DynFlags -> [(String, String)]
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
      (String
"Project name",                 String
cProjectName)
      -- Next come the settings, so anything else can be overridden
      -- in the settings file (as "lookup" uses the first match for the
      -- key)
    (String, String) -> [(String, String)] -> [(String, String)]
forall a. a -> [a] -> [a]
: ((String, String) -> (String, String))
-> [(String, String)] -> [(String, String)]
forall a b. (a -> b) -> [a] -> [b]
map (ShowS -> (String, String) -> (String, String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ShowS -> (String, String) -> (String, String))
-> ShowS -> (String, String) -> (String, String)
forall a b. (a -> b) -> a -> b
$ String -> Maybe String -> ShowS
expandDirectories (DynFlags -> String
topDir DynFlags
dflags) (DynFlags -> Maybe String
toolDir DynFlags
dflags))
          (DynFlags -> [(String, String)]
rawSettings DynFlags
dflags)
   [(String, String)] -> [(String, String)] -> [(String, String)]
forall a. [a] -> [a] -> [a]
++ [(String
"Project version",             DynFlags -> String
projectVersion DynFlags
dflags),
       (String
"Project Git commit id",       String
cProjectGitCommitId),
       (String
"Booter version",              String
cBooterVersion),
       (String
"Stage",                       String
cStage),
       (String
"Build platform",              String
cBuildPlatformString),
       (String
"Host platform",               String
cHostPlatformString),
       (String
"Target platform",             PlatformMisc -> String
platformMisc_targetPlatformString (PlatformMisc -> String) -> PlatformMisc -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> PlatformMisc
platformMisc DynFlags
dflags),
       (String
"Have interpreter",            Bool -> String
showBool (Bool -> String) -> Bool -> String
forall a b. (a -> b) -> a -> b
$ PlatformMisc -> Bool
platformMisc_ghcWithInterpreter (PlatformMisc -> Bool) -> PlatformMisc -> Bool
forall a b. (a -> b) -> a -> b
$ DynFlags -> PlatformMisc
platformMisc DynFlags
dflags),
       (String
"Object splitting supported",  Bool -> String
showBool Bool
False),
       (String
"Have native code generator",  Bool -> String
showBool (Bool -> String) -> Bool -> String
forall a b. (a -> b) -> a -> b
$ PlatformMisc -> Bool
platformMisc_ghcWithNativeCodeGen (PlatformMisc -> Bool) -> PlatformMisc -> Bool
forall a b. (a -> b) -> a -> b
$ DynFlags -> PlatformMisc
platformMisc DynFlags
dflags),
       -- Whether or not we support @-dynamic-too@
       (String
"Support dynamic-too",         Bool -> String
showBool (Bool -> String) -> Bool -> String
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not Bool
isWindows),
       -- Whether or not we support the @-j@ flag with @--make@.
       (String
"Support parallel --make",     String
"YES"),
       -- Whether or not we support "Foo from foo-0.1-XXX:Foo" syntax in
       -- installed package info.
       (String
"Support reexported-modules",  String
"YES"),
       -- Whether or not we support extended @-package foo (Foo)@ syntax.
       (String
"Support thinning and renaming package flags", String
"YES"),
       -- Whether or not we support Backpack.
       (String
"Support Backpack", String
"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
       (String
"Requires unified installed package IDs", String
"YES"),
       -- Whether or not we support the @-this-package-key@ flag.  Prefer
       -- "Uses unit IDs" over it.
       (String
"Uses package keys",           String
"YES"),
       -- Whether or not we support the @-this-unit-id@ flag
       (String
"Uses unit IDs",               String
"YES"),
       -- Whether or not GHC compiles libraries as dynamic by default
       (String
"Dynamic by default",          Bool -> String
showBool (Bool -> String) -> Bool -> String
forall a b. (a -> b) -> a -> b
$ DynFlags -> Bool
dYNAMIC_BY_DEFAULT DynFlags
dflags),
       -- Whether or not GHC was compiled using -dynamic
       (String
"GHC Dynamic",                 Bool -> String
showBool Bool
dynamicGhc),
       -- Whether or not GHC was compiled using -prof
       (String
"GHC Profiled",                Bool -> String
showBool Bool
rtsIsProfiled),
       (String
"Debug on",                    Bool -> String
showBool Bool
debugIsOn),
       (String
"LibDir",                      DynFlags -> String
topDir DynFlags
dflags),
       -- The path of the global package database used by GHC
       (String
"Global Package DB",           DynFlags -> String
systemPackageConfig DynFlags
dflags)
      ]
  where
    showBool :: Bool -> String
showBool Bool
True  = String
"YES"
    showBool Bool
False = String
"NO"
    isWindows :: Bool
isWindows = Platform -> OS
platformOS (DynFlags -> Platform
targetPlatform DynFlags
dflags) OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== OS
OSMinGW32
    expandDirectories :: FilePath -> Maybe FilePath -> String -> String
    expandDirectories :: String -> Maybe String -> ShowS
expandDirectories String
topd Maybe String
mtoold = Maybe String -> ShowS
expandToolDir Maybe String
mtoold ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
expandTopDir String
topd

-- Produced by deriveConstants
#include "GHCConstantsHaskellWrappers.hs"

bLOCK_SIZE_W :: DynFlags -> Int
bLOCK_SIZE_W :: DynFlags -> Int
bLOCK_SIZE_W DynFlags
dflags = DynFlags -> Int
bLOCK_SIZE DynFlags
dflags Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` DynFlags -> Int
wORD_SIZE DynFlags
dflags

wORD_SIZE_IN_BITS :: DynFlags -> Int
wORD_SIZE_IN_BITS :: DynFlags -> Int
wORD_SIZE_IN_BITS DynFlags
dflags = DynFlags -> Int
wORD_SIZE DynFlags
dflags Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
8

wordAlignment :: DynFlags -> Alignment
wordAlignment :: DynFlags -> Alignment
wordAlignment DynFlags
dflags = Int -> Alignment
alignmentOf (DynFlags -> Int
wORD_SIZE DynFlags
dflags)

tAG_MASK :: DynFlags -> Int
tAG_MASK :: DynFlags -> Int
tAG_MASK DynFlags
dflags = (Int
1 Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`shiftL` DynFlags -> Int
tAG_BITS DynFlags
dflags) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1

mAX_PTR_TAG :: DynFlags -> Int
mAX_PTR_TAG :: DynFlags -> Int
mAX_PTR_TAG = DynFlags -> Int
tAG_MASK

-- Might be worth caching these in targetPlatform?
tARGET_MIN_INT, tARGET_MAX_INT, tARGET_MAX_WORD :: DynFlags -> Integer
tARGET_MIN_INT :: DynFlags -> Integer
tARGET_MIN_INT DynFlags
dflags
    = case Platform -> PlatformWordSize
platformWordSize (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
      PlatformWordSize
PW4 -> Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int32
forall a. Bounded a => a
minBound :: Int32)
      PlatformWordSize
PW8 -> Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int64
forall a. Bounded a => a
minBound :: Int64)
tARGET_MAX_INT :: DynFlags -> Integer
tARGET_MAX_INT DynFlags
dflags
    = case Platform -> PlatformWordSize
platformWordSize (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
      PlatformWordSize
PW4 -> Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int32
forall a. Bounded a => a
maxBound :: Int32)
      PlatformWordSize
PW8 -> Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int64
forall a. Bounded a => a
maxBound :: Int64)
tARGET_MAX_WORD :: DynFlags -> Integer
tARGET_MAX_WORD DynFlags
dflags
    = case Platform -> PlatformWordSize
platformWordSize (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
      PlatformWordSize
PW4 -> Word32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word32
forall a. Bounded a => a
maxBound :: Word32)
      PlatformWordSize
PW8 -> Word64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word64
forall a. Bounded a => a
maxBound :: Word64)


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

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

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

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

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

-- | Resolve any internal inconsistencies in a set of 'DynFlags'.
-- Returns the consistent 'DynFlags' as well as a list of warnings
-- to report to the user.
makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])
-- Whenever makeDynFlagsConsistent does anything, it starts over, to
-- ensure that a later change doesn't invalidate an earlier check.
-- Be careful not to introduce potential loops!
makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])
makeDynFlagsConsistent DynFlags
dflags
 -- Disable -dynamic-too on Windows (#8228, #7134, #5987)
 | OS
os OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== OS
OSMinGW32 Bool -> Bool -> Bool
&& GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_BuildDynamicToo DynFlags
dflags
    = let dflags' :: DynFlags
dflags' = DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_BuildDynamicToo
          warn :: String
warn    = String
"-dynamic-too is not supported on Windows"
      in DynFlags -> String -> (DynFlags, [Located String])
loop DynFlags
dflags' String
warn
 | DynFlags -> HscTarget
hscTarget DynFlags
dflags HscTarget -> HscTarget -> Bool
forall a. Eq a => a -> a -> Bool
== HscTarget
HscC Bool -> Bool -> Bool
&&
   Bool -> Bool
not (Platform -> Bool
platformUnregisterised (DynFlags -> Platform
targetPlatform DynFlags
dflags))
    = if PlatformMisc -> Bool
platformMisc_ghcWithNativeCodeGen (PlatformMisc -> Bool) -> PlatformMisc -> Bool
forall a b. (a -> b) -> a -> b
$ DynFlags -> PlatformMisc
platformMisc DynFlags
dflags
      then let dflags' :: DynFlags
dflags' = DynFlags
dflags { hscTarget :: HscTarget
hscTarget = HscTarget
HscAsm }
               warn :: String
warn = String
"Compiler not unregisterised, so using native code generator rather than compiling via C"
           in DynFlags -> String -> (DynFlags, [Located String])
loop DynFlags
dflags' String
warn
      else let dflags' :: DynFlags
dflags' = DynFlags
dflags { hscTarget :: HscTarget
hscTarget = HscTarget
HscLlvm }
               warn :: String
warn = String
"Compiler not unregisterised, so using LLVM rather than compiling via C"
           in DynFlags -> String -> (DynFlags, [Located String])
loop DynFlags
dflags' String
warn
 | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_Hpc DynFlags
dflags Bool -> Bool -> Bool
&& DynFlags -> HscTarget
hscTarget DynFlags
dflags HscTarget -> HscTarget -> Bool
forall a. Eq a => a -> a -> Bool
== HscTarget
HscInterpreted
    = let dflags' :: DynFlags
dflags' = DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_Hpc
          warn :: String
warn = String
"Hpc can't be used with byte-code interpreter. Ignoring -fhpc."
      in DynFlags -> String -> (DynFlags, [Located String])
loop DynFlags
dflags' String
warn
 | DynFlags -> HscTarget
hscTarget DynFlags
dflags HscTarget -> [HscTarget] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [HscTarget
HscAsm, HscTarget
HscLlvm] Bool -> Bool -> Bool
&&
   Platform -> Bool
platformUnregisterised (DynFlags -> Platform
targetPlatform DynFlags
dflags)
    = DynFlags -> String -> (DynFlags, [Located String])
loop (DynFlags
dflags { hscTarget :: HscTarget
hscTarget = HscTarget
HscC })
           String
"Compiler unregisterised, so compiling via C"
 | DynFlags -> HscTarget
hscTarget DynFlags
dflags HscTarget -> HscTarget -> Bool
forall a. Eq a => a -> a -> Bool
== HscTarget
HscAsm Bool -> Bool -> Bool
&&
   Bool -> Bool
not (PlatformMisc -> Bool
platformMisc_ghcWithNativeCodeGen (PlatformMisc -> Bool) -> PlatformMisc -> Bool
forall a b. (a -> b) -> a -> b
$ DynFlags -> PlatformMisc
platformMisc DynFlags
dflags)
      = let dflags' :: DynFlags
dflags' = DynFlags
dflags { hscTarget :: HscTarget
hscTarget = HscTarget
HscLlvm }
            warn :: String
warn = String
"No native code generator, so using LLVM"
        in DynFlags -> String -> (DynFlags, [Located String])
loop DynFlags
dflags' String
warn
 | Bool -> Bool
not (OS -> Bool
osElfTarget OS
os) Bool -> Bool -> Bool
&& GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIE DynFlags
dflags
    = DynFlags -> String -> (DynFlags, [Located String])
loop (DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_PIE)
           String
"Position-independent only supported on ELF platforms"
 | OS
os OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== OS
OSDarwin Bool -> Bool -> Bool
&&
   Arch
arch Arch -> Arch -> Bool
forall a. Eq a => a -> a -> Bool
== Arch
ArchX86_64 Bool -> Bool -> Bool
&&
   Bool -> Bool
not (GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags)
    = DynFlags -> String -> (DynFlags, [Located String])
loop (DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dflags GeneralFlag
Opt_PIC)
           String
"Enabling -fPIC as it is always on for this platform"
 | Left String
err <- Int -> DynFlags -> Either String DynFlags
checkOptLevel (DynFlags -> Int
optLevel DynFlags
dflags) DynFlags
dflags
    = DynFlags -> String -> (DynFlags, [Located String])
loop (Int -> DynFlags -> DynFlags
updOptLevel Int
0 DynFlags
dflags) String
err

 | GhcLink
LinkInMemory <- DynFlags -> GhcLink
ghcLink DynFlags
dflags
 , Bool -> Bool
not (GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_ExternalInterpreter DynFlags
dflags)
 , Bool
rtsIsProfiled
 , HscTarget -> Bool
isObjectTarget (DynFlags -> HscTarget
hscTarget DynFlags
dflags)
 , Way
WayProf Way -> [Way] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` DynFlags -> [Way]
ways DynFlags
dflags
    = DynFlags -> String -> (DynFlags, [Located String])
loop DynFlags
dflags{ways :: [Way]
ways = Way
WayProf Way -> [Way] -> [Way]
forall a. a -> [a] -> [a]
: DynFlags -> [Way]
ways DynFlags
dflags}
         String
"Enabling -prof, because -fobject-code is enabled and GHCi is profiled"

 | Bool
otherwise = (DynFlags
dflags, [])
    where loc :: SrcSpan
loc = FastString -> SrcSpan
mkGeneralSrcSpan (String -> FastString
fsLit String
"when making flags consistent")
          loop :: DynFlags -> String -> (DynFlags, [Located String])
loop DynFlags
updated_dflags String
warning
              = case DynFlags -> (DynFlags, [Located String])
makeDynFlagsConsistent DynFlags
updated_dflags of
                (DynFlags
dflags', [Located String]
ws) -> (DynFlags
dflags', SrcSpan -> String -> Located String
forall l e. l -> e -> GenLocated l e
L SrcSpan
loc String
warning Located String -> [Located String] -> [Located String]
forall a. a -> [a] -> [a]
: [Located String]
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


--------------------------------------------------------------------------
-- Do not use unsafeGlobalDynFlags!
--
-- unsafeGlobalDynFlags is a hack, necessary because we need to be able
-- to show SDocs when tracing, but we don't always have DynFlags
-- available.
--
-- Do not use it if you can help it. You may get the wrong value, or this
-- panic!

-- | This is the value that 'unsafeGlobalDynFlags' takes before it is
-- initialized.
defaultGlobalDynFlags :: DynFlags
defaultGlobalDynFlags :: DynFlags
defaultGlobalDynFlags =
    (Settings -> LlvmConfig -> DynFlags
defaultDynFlags Settings
forall a. a
settings LlvmConfig
forall a. a
llvmConfig) { verbosity :: Int
verbosity = Int
2 }
  where
    settings :: a
settings = String -> a
forall a. String -> a
panic String
"v_unsafeGlobalDynFlags: settings not initialised"
    llvmConfig :: a
llvmConfig = String -> a
forall a. String -> a
panic String
"v_unsafeGlobalDynFlags: llvmConfig not initialised"

#if GHC_STAGE < 2
GLOBAL_VAR(v_unsafeGlobalDynFlags, defaultGlobalDynFlags, DynFlags)
#else
SHARED_GLOBAL_VAR( v_unsafeGlobalDynFlags
                 , getOrSetLibHSghcGlobalDynFlags
                 , "getOrSetLibHSghcGlobalDynFlags"
                 , defaultGlobalDynFlags
                 , DynFlags )
#endif

unsafeGlobalDynFlags :: DynFlags
unsafeGlobalDynFlags :: DynFlags
unsafeGlobalDynFlags = IO DynFlags -> DynFlags
forall a. IO a -> a
unsafePerformIO (IO DynFlags -> DynFlags) -> IO DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ IORef DynFlags -> IO DynFlags
forall a. IORef a -> IO a
readIORef IORef DynFlags
v_unsafeGlobalDynFlags

setUnsafeGlobalDynFlags :: DynFlags -> IO ()
setUnsafeGlobalDynFlags :: DynFlags -> IO ()
setUnsafeGlobalDynFlags = IORef DynFlags -> DynFlags -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef DynFlags
v_unsafeGlobalDynFlags

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

-- TODO: Instead of using a separate predicate (i.e. isSse2Enabled) to
-- check if SSE is enabled, we might have x86-64 imply the -msse2
-- flag.

data SseVersion = SSE1
                | SSE2
                | SSE3
                | SSE4
                | SSE42
                deriving (SseVersion -> SseVersion -> Bool
(SseVersion -> SseVersion -> Bool)
-> (SseVersion -> SseVersion -> Bool) -> Eq SseVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SseVersion -> SseVersion -> Bool
$c/= :: SseVersion -> SseVersion -> Bool
== :: SseVersion -> SseVersion -> Bool
$c== :: SseVersion -> SseVersion -> Bool
Eq, Eq SseVersion
Eq SseVersion
-> (SseVersion -> SseVersion -> Ordering)
-> (SseVersion -> SseVersion -> Bool)
-> (SseVersion -> SseVersion -> Bool)
-> (SseVersion -> SseVersion -> Bool)
-> (SseVersion -> SseVersion -> Bool)
-> (SseVersion -> SseVersion -> SseVersion)
-> (SseVersion -> SseVersion -> SseVersion)
-> Ord SseVersion
SseVersion -> SseVersion -> Bool
SseVersion -> SseVersion -> Ordering
SseVersion -> SseVersion -> SseVersion
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SseVersion -> SseVersion -> SseVersion
$cmin :: SseVersion -> SseVersion -> SseVersion
max :: SseVersion -> SseVersion -> SseVersion
$cmax :: SseVersion -> SseVersion -> SseVersion
>= :: SseVersion -> SseVersion -> Bool
$c>= :: SseVersion -> SseVersion -> Bool
> :: SseVersion -> SseVersion -> Bool
$c> :: SseVersion -> SseVersion -> Bool
<= :: SseVersion -> SseVersion -> Bool
$c<= :: SseVersion -> SseVersion -> Bool
< :: SseVersion -> SseVersion -> Bool
$c< :: SseVersion -> SseVersion -> Bool
compare :: SseVersion -> SseVersion -> Ordering
$ccompare :: SseVersion -> SseVersion -> Ordering
$cp1Ord :: Eq SseVersion
Ord)

isSseEnabled :: DynFlags -> Bool
isSseEnabled :: DynFlags -> Bool
isSseEnabled DynFlags
dflags = case Platform -> Arch
platformArch (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
    Arch
ArchX86_64 -> Bool
True
    Arch
ArchX86    -> Bool
True
    Arch
_          -> Bool
False

isSse2Enabled :: DynFlags -> Bool
isSse2Enabled :: DynFlags -> Bool
isSse2Enabled DynFlags
dflags = case Platform -> Arch
platformArch (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
  -- We Assume  SSE1 and SSE2 operations are available on both
  -- x86 and x86_64. Historically we didn't default to SSE2 and
  -- SSE1 on x86, which results in defacto nondeterminism for how
  -- rounding behaves in the associated x87 floating point instructions
  -- because variations in the spill/fpu stack placement of arguments for
  -- operations would change the precision and final result of what
  -- would otherwise be the same expressions with respect to single or
  -- double precision IEEE floating point computations.
    Arch
ArchX86_64 -> Bool
True
    Arch
ArchX86    -> Bool
True
    Arch
_          -> Bool
False


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

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

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

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

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

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

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

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

data BmiVersion = BMI1
                | BMI2
                deriving (BmiVersion -> BmiVersion -> Bool
(BmiVersion -> BmiVersion -> Bool)
-> (BmiVersion -> BmiVersion -> Bool) -> Eq BmiVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BmiVersion -> BmiVersion -> Bool
$c/= :: BmiVersion -> BmiVersion -> Bool
== :: BmiVersion -> BmiVersion -> Bool
$c== :: BmiVersion -> BmiVersion -> Bool
Eq, Eq BmiVersion
Eq BmiVersion
-> (BmiVersion -> BmiVersion -> Ordering)
-> (BmiVersion -> BmiVersion -> Bool)
-> (BmiVersion -> BmiVersion -> Bool)
-> (BmiVersion -> BmiVersion -> Bool)
-> (BmiVersion -> BmiVersion -> Bool)
-> (BmiVersion -> BmiVersion -> BmiVersion)
-> (BmiVersion -> BmiVersion -> BmiVersion)
-> Ord BmiVersion
BmiVersion -> BmiVersion -> Bool
BmiVersion -> BmiVersion -> Ordering
BmiVersion -> BmiVersion -> BmiVersion
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BmiVersion -> BmiVersion -> BmiVersion
$cmin :: BmiVersion -> BmiVersion -> BmiVersion
max :: BmiVersion -> BmiVersion -> BmiVersion
$cmax :: BmiVersion -> BmiVersion -> BmiVersion
>= :: BmiVersion -> BmiVersion -> Bool
$c>= :: BmiVersion -> BmiVersion -> Bool
> :: BmiVersion -> BmiVersion -> Bool
$c> :: BmiVersion -> BmiVersion -> Bool
<= :: BmiVersion -> BmiVersion -> Bool
$c<= :: BmiVersion -> BmiVersion -> Bool
< :: BmiVersion -> BmiVersion -> Bool
$c< :: BmiVersion -> BmiVersion -> Bool
compare :: BmiVersion -> BmiVersion -> Ordering
$ccompare :: BmiVersion -> BmiVersion -> Ordering
$cp1Ord :: Eq BmiVersion
Ord)

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

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

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

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

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

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

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

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

-- -----------------------------------------------------------------------------
-- Types for managing temporary files.
--
-- these are here because FilesToClean is used in DynFlags

-- | A collection of files that must be deleted before ghc exits.
-- The current collection
-- is stored in an IORef in DynFlags, 'filesToClean'.
data FilesToClean = FilesToClean {
  FilesToClean -> Set String
ftcGhcSession :: !(Set FilePath),
  -- ^ Files that will be deleted at the end of runGhc(T)
  FilesToClean -> Set String
ftcCurrentModule :: !(Set FilePath)
  -- ^ Files that will be deleted the next time
  -- 'FileCleanup.cleanCurrentModuleTempFiles' is called, or otherwise at the
  -- end of the session.
  }

-- | An empty FilesToClean
emptyFilesToClean :: FilesToClean
emptyFilesToClean :: FilesToClean
emptyFilesToClean = Set String -> Set String -> FilesToClean
FilesToClean Set String
forall a. Set a
Set.empty Set String
forall a. Set a
Set.empty