Language.Haskell.GhcMod.Internal

Low level access to the ghc-mod library.

Types

type GHCOption = String

A single GHC command line option.

type Package = (PackageBaseName, PackageVersion, PackageId)

A package's name, verson and id.

type PackageBaseName = String

A package name.

type PackageVersion = String

A package version.

type PackageId = String

A package id.

type IncludeDir = FilePath

An include directory for modules.

data CompilerOptions

Option information for GHC

Constructors

CompilerOptions

Fields

ghcOptions :: [GHCOption]

Command line options

includeDirs :: [IncludeDir]

Include directories for modules

depPackages :: [Package]

Dependent package names

Instances

Eq CompilerOptions

Show CompilerOptions

Cabal API

parseCabalFile :: (IOish m, MonadError GhcModError m) => Cradle -> FilePath -> m PackageDescription

Parse a cabal file and return a PackageDescription.

getCompilerOptions :: (IOish m, MonadError GhcModError m) => [GHCOption] -> Cradle -> PackageDescription -> m CompilerOptions

Getting necessary CompilerOptions from three information sources.

cabalAllBuildInfo :: PackageDescription -> [BuildInfo]

Extracting all BuildInfo for libraries, executables, and tests.

cabalDependPackages :: [BuildInfo] -> [PackageBaseName]

Extracting package names of dependency.

cabalSourceDirs :: [BuildInfo] -> [IncludeDir]

Extracting include directories for modules.

cabalAllTargets :: PackageDescription -> IO ([String], [String], [String], [String])

Extracting all Module FilePaths for libraries, executables, tests and benchmarks.

Various Paths

ghcLibDir :: FilePath

Obtaining the directory for ghc system libraries.

ghcModExecutable :: IO FilePath

Returns the path to the currently running ghc-mod executable. With ghc<7.6 this is a guess but >=7.6 uses getExecutablePath.

IO

getDynamicFlags :: IO DynFlags

Return the DynFlags currently in use in the GHC session.

Targets

setTargetFiles :: IOish m => [FilePath] -> GhcModT m ()

Set the files as targets and load them.

Logging

withLogger :: IOish m => (DynFlags -> DynFlags) -> GhcModT m () -> GhcModT m (Either String String)

Set the session flag (e.g. -Wall or -w:) then executes a body. Logged messages are returned as String. Right is success and Left is failure.

setNoWarningFlags :: DynFlags -> DynFlags

Set DynFlags equivalent to -w:.

setAllWarningFlags :: DynFlags -> DynFlags

Set DynFlags equivalent to -Wall.

Environment, state and logging

data GhcModEnv

Constructors

GhcModEnv

Fields

gmGhcSession :: !(IORef HscEnv)

gmOptions :: Options

gmCradle :: Cradle

Instances

Monad m => MonadReader GhcModEnv (GhcModT m)

newGhcModEnv :: Options -> FilePath -> IO GhcModEnv

data GhcModState

Instances

Eq GhcModState

Read GhcModState

Show GhcModState

defaultState :: GhcModState

data CompilerMode

Constructors

Simple

Intelligent

Instances

Eq CompilerMode

Read CompilerMode

Show CompilerMode

type GhcModLog = ()

Monad utilities

runGhcModT' :: IOish m => GhcModEnv -> GhcModState -> GhcModT m a -> m (Either GhcModError (a, GhcModState), GhcModLog)

Run a computation inside GhcModT providing the RWST environment and initial state. This is a low level function, use it only if you know what to do with GhcModEnv and GhcModState.

You should probably look at runGhcModT instead.

hoistGhcModT :: IOish m => (Either GhcModError a, GhcModLog) -> GhcModT m a

hoistGhcModT result. Embed a GhcModT computation's result into a GhcModT computation. Note that if the computation that returned result modified the state part of GhcModT this cannot be restored.

Accessing GhcModEnv and GhcModState

options :: IOish m => GhcModT m Options

cradle :: IOish m => GhcModT m Cradle

getCompilerMode :: IOish m => GhcModT m CompilerMode

setCompilerMode :: IOish m => CompilerMode -> GhcModT m ()

withOptions :: IOish m => (Options -> Options) -> GhcModT m a -> GhcModT m a

GhcModError

gmeDoc :: GhcModError -> Doc

GhcMonad Choice

(||>) :: GhcMonad m => m a -> m a -> m a

Try the left Ghc action. If IOException occurs, try the right Ghc action.

goNext :: GhcMonad m => m a

Go to the next Ghc monad by throwing AltGhcgoNext.

runAnyOne :: GhcMonad m => [m a] -> m a

Run any one Ghc monad.

World

data World

Instances

Eq World

Show World

getCurrentWorld :: Cradle -> IO World

isWorldChanged :: World -> Cradle -> IO Bool