Enumerates the simple on-or-off dynamic flags

Test whether a DumpFlag is set

Set a DumpFlag

Unset a DumpFlag

Test whether a GeneralFlag is set

Set a GeneralFlag

Unset a GeneralFlag

Test whether a WarningFlag is set

Set a WarningFlag

Unset a WarningFlag

Test whether a ExtensionFlag is set

Set a ExtensionFlag

Unset a ExtensionFlag

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

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 try to run code from an imported module. This will fail if no code has been generated for this module. You can use needsTemplateHaskell to detect whether this might be the case and choose to either switch to a different target or avoid typechecking such modules. (The latter may be preferable for security reasons.)

Will this target result in an object file on the disk?

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

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.

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.

What to do in the link step, if there is one.

When invoking external tools as part of the compilation pipeline, we pass these a sequence of options on the command-line. Rather than just using a list of Strings, we use a type that allows us to distinguish between filepaths and 'other stuff'. The reason for this is that this type gives us a handle on transforming filenames, and filenames only, to whatever format they're expected to be on a particular platform.

These -f<blah> flags can all be reversed with -fno-<blah>

These -f<blah> flags can all be reversed with -fno-<blah>

These -f<blah> flags can all be reversed with -fno-<blah>

These -Xblah flags can all be reversed with -XNoblah

Some modules have dependencies on others through the DynFlags rather than textual imports

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.

The various Safe Haskell modes

Is Safe Haskell on in some way (including inference mode)

Test if Safe Imports are on in some form

Is the Safe Haskell safe language in use

Is the Safe Haskell safe inference mode active

Is the -fpackage-trust mode on

Are all direct imports required to be safe for this Safe Haskell mode? Direct imports are when the code explicitly imports a module

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.

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

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

The directory for this version of ghc in the user's app directory (typically something like ~.ghcx86_64-linux-7.6.3)

The normal DynFlags. Note that they are not suitable for use in this form and must be fully initialized by runGhc first.

Used by runGhc to partially initialize a new DynFlags value

Retrieve the options corresponding to a particular opt_* field in the correct order

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

Sets the DynFlags to be appropriate to the optimisation level

Find the package environment (if one exists)

We interpret the package environment as a set of package flags; to be specific, if we find a package environment

id1
id2
..
idn

we interpret this as

[ -hide-all-packages
, -package-id id1
, -package-id id2
, ..
, -package-id idn
]

Parse dynamic flags from a list of command line arguments. Returns the 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).

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.

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.

All dynamic flags option strings. These are the user facing strings for enabling and disabling options.

Make a list of flags for shell completion. Filter all available flags into two groups, for interactive GHC vs all other.