ghcide-0.3.0: The core of an IDE

Safe HaskellNone
LanguageHaskell2010

Development.IDE.GHC.Compat

Description

Attempt at hiding the GHC version differences we can.

Synopsis

Documentation

getHeaderImports :: DynFlags -> StringBuffer -> FilePath -> FilePath -> IO (Either ErrorMessages ([(Maybe FastString, Located ModuleName)], [(Maybe FastString, Located ModuleName)], Located ModuleName)) Source #

data HieFileResult Source #

Constructors

HieFileResult 

Fields

data HieFile Source #

GHC builds up a wealth of information about Haskell source as it compiles it. .hie files are a way of persisting some of this information to disk so that external tools that need to work with haskell source don't need to parse, typecheck, and rename all over again. These files contain:

  • a simplified AST

    • nodes are annotated with source positions and types
    • identifiers are annotated with scope information
  • the raw bytes of the initial Haskell source

Besides saving compilation cycles, .hie files also offer a more stable interface than the GHC API.

Constructors

HieFile 

Fields

Instances
Show HieFile Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> HieFile -> ShowS #

show :: HieFile -> String #

showList :: [HieFile] -> ShowS #

NFData HieFile Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: HieFile -> () #

Binary HieFile Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

put_ :: BinHandle -> HieFile -> IO () #

put :: BinHandle -> HieFile -> IO (Bin HieFile) #

get :: BinHandle -> IO HieFile #

newtype NameCacheUpdater #

A function that atomically updates the name cache given a modifier function. The second result of the modifier function will be the result of the IO action.

Constructors

NCU 

Fields

hieExportNames :: HieFile -> [(SrcSpan, Name)] Source #

mkHieFile :: ModSummary -> TcGblEnv -> RenamedSource -> ByteString -> Hsc HieFile Source #

Construct an HieFile from the outputs of the typechecker.

writeHieFile :: FilePath -> HieFile -> IO () Source #

Write a HieFile to the given FilePath, with a proper header and symbol tables for Names and FastStrings

readHieFile :: NameCacheUpdater -> FilePath -> IO HieFileResult Source #

Read a HieFile from a FilePath. Can use an existing NameCache.

supportsHieFiles :: Bool Source #

setHieDir :: FilePath -> DynFlags -> DynFlags Source #

dontWriteHieFiles :: DynFlags -> DynFlags Source #

ml_hie_file :: ModLocation -> FilePath Source #

hPutStringBuffer :: Handle -> StringBuffer -> IO () Source #

includePathsGlobal :: IncludeSpecs -> [String] #

includePathsQuote :: IncludeSpecs -> [String] #

addIncludePathsQuote :: FilePath -> DynFlags -> DynFlags Source #

getModuleHash :: ModIface -> Fingerprint Source #

getPackageName :: DynFlags -> InstalledUnitId -> Maybe PackageName Source #

pattern DerivD :: DerivDecl p -> HsDecl p Source #

pattern ForD :: ForeignDecl p -> HsDecl p Source #

pattern InstD :: InstDecl p -> HsDecl p Source #

pattern TyClD :: TyClDecl p -> HsDecl p Source #

pattern ValD :: HsBind p -> HsDecl p Source #

pattern SigD :: Sig p -> HsDecl p Source #

pattern TypeSig :: [Located (IdP p)] -> LHsSigWcType p -> Sig p Source #

pattern ClassOpSig :: Bool -> [Located (IdP pass)] -> LHsSigType pass -> Sig pass Source #

pattern IEThingAll :: LIEWrappedName (IdP pass) -> IE pass Source #

pattern IEThingWith :: LIEWrappedName (IdP pass) -> IEWildcard -> [LIEWrappedName (IdP pass)] -> [Located (FieldLbl (IdP pass))] -> IE pass Source #

pattern VarPat :: Located (IdP p) -> Pat p Source #

pattern PatSynBind :: PatSynBind p p -> HsBind p Source #

data ModLocation #

Module Location

Where a module lives on the file system: the actual locations of the .hs, .hi and .o files, if we have them

Instances
Show ModLocation 
Instance details

Defined in Module

Methods

showsPrec :: Int -> ModLocation -> ShowS #

show :: ModLocation -> String #

showList :: [ModLocation] -> ShowS #

Outputable ModLocation 
Instance details

Defined in Module

Methods

ppr :: ModLocation -> SDoc #

pprPrec :: Rational -> ModLocation -> SDoc #

addBootSuffix :: FilePath -> FilePath #

Add the -boot suffix to .hs, .hi and .o files

pattern ModLocation :: Maybe FilePath -> FilePath -> FilePath -> ModLocation Source #

getConArgs :: ConDecl pass -> HsConDeclDetails pass Source #

class HasSrcSpan a Source #

Minimal complete definition

getLoc

Instances
HasSrcSpan Name Source # 
Instance details

Defined in Development.IDE.GHC.Compat

Methods

getLoc :: Name -> SrcSpan Source #

HasSrcSpan (GenLocated SrcSpan a) Source # 
Instance details

Defined in Development.IDE.GHC.Compat

Methods

getLoc :: GenLocated SrcSpan a -> SrcSpan Source #

getLoc :: HasSrcSpan a => a -> SrcSpan Source #

upNameCache :: IORef NameCache -> (NameCache -> (NameCache, c)) -> IO c Source #

parser #

Arguments

:: String

Haskell module source text (full Unicode is supported)

-> DynFlags

the flags

-> FilePath

the filename (for source locations)

-> (WarningMessages, Either ErrorMessages (Located (HsModule GhcPs))) 

A pure interface to the module parser.

obtainTermFromId :: GhcMonad m => Int -> Bool -> Id -> m Term #

obtainTermFromVal :: GhcMonad m => Int -> Bool -> Type -> a -> m Term #

getHistorySpan :: GhcMonad m => History -> m SrcSpan #

getGHCiMonad :: GhcMonad m => m Name #

Get the monad GHCi lifts user statements into.

setGHCiMonad :: GhcMonad m => String -> m () #

Set the monad GHCi lifts user statements into.

Checks that a type (in string form) is an instance of the GHC.GHCi.GHCiSandboxIO type class. Sets it to be the GHCi monad if it is, throws an error otherwise.

moduleTrustReqs :: GhcMonad m => Module -> m (Bool, Set InstalledUnitId) #

Return if a module is trusted and the pkgs it depends on to be trusted.

isModuleTrusted :: GhcMonad m => Module -> m Bool #

Check that a module is safe to import (according to Safe Haskell).

We return True to indicate the import is safe and False otherwise although in the False case an error may be thrown first.

lookupModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module #

Like findModule, but differs slightly when the module refers to a source file, and the file has not been loaded via load. In this case, findModule will throw an error (module not loaded), but lookupModule will check to see whether the module can also be found in a package, and if so, that package Module will be returned. If not, the usual module-not-found error will be thrown.

findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module #

Takes a ModuleName and possibly a UnitId, and consults the filesystem and package database to find the corresponding Module, using the algorithm that is used for an import declaration.

showRichTokenStream :: [(Located Token, String)] -> String #

Take a rich token stream such as produced from getRichTokenStream and return source code almost identical to the original code (except for insignificant whitespace.)

addSourceToTokens :: RealSrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)] #

Given a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.

getRichTokenStream :: GhcMonad m => Module -> m [(Located Token, String)] #

Give even more information on the source than getTokenStream This function allows reconstructing the source completely with showRichTokenStream.

getTokenStream :: GhcMonad m => Module -> m [Located Token] #

Return module source as token stream, including comments.

The module must be in the module graph and its source must be available. Throws a SourceError on parse error.

pprParenSymName :: NamedThing a => a -> SDoc #

print a NamedThing, adding parentheses if the name is an operator.

dataConType :: DataCon -> Type #

getNameToInstancesIndex #

Arguments

:: GhcMonad m 
=> [Module]

visible modules. An orphan instance will be returned if it is visible from at least one module in the list.

-> Maybe [Module]

modules to load. If this is not specified, we load modules for everything that is in scope unqualified.

-> m (Messages, Maybe (NameEnv ([ClsInst], [FamInst]))) 

Retrieve all type and family instances in the environment, indexed by Name. Each name's lists will contain every instance in which that name is mentioned in the instance head.

getGRE :: GhcMonad m => m GlobalRdrEnv #

get the GlobalRdrEnv for a session

findGlobalAnns :: (GhcMonad m, Typeable a) => ([Word8] -> a) -> AnnTarget Name -> m [a] #

lookupGlobalName :: GhcMonad m => Name -> m (Maybe TyThing) #

Looks up a global name: that is, any top-level name in any visible module. Unlike lookupName, lookupGlobalName does not use the interactive context, and therefore does not require a preceding setContext.

isDictonaryId :: Id -> Bool #

modInfoModBreaks :: ModuleInfo -> ModBreaks #

modInfoSafe :: ModuleInfo -> SafeHaskellMode #

Retrieve module safe haskell mode

modInfoIface :: ModuleInfo -> Maybe ModIface #

modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing) #

mkPrintUnqualifiedForModule :: GhcMonad m => ModuleInfo -> m (Maybe PrintUnqualified) #

modInfoIsExportedName :: ModuleInfo -> Name -> Bool #

modInfoInstances :: ModuleInfo -> [ClsInst] #

Returns the instances defined by the specified module. Warning: currently unimplemented for package modules.

modInfoExportsWithSelectors :: ModuleInfo -> [Name] #

modInfoExports :: ModuleInfo -> [Name] #

modInfoTopLevelScope :: ModuleInfo -> Maybe [Name] #

modInfoTyThings :: ModuleInfo -> [TyThing] #

The list of top-level entities defined in a module

getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo) #

Request information about a loaded Module

getPrintUnqual :: GhcMonad m => m PrintUnqualified #

getInsts :: GhcMonad m => m ([ClsInst], [FamInst]) #

Return the instances for the current interactive session.

getBindings :: GhcMonad m => m [TyThing] #

Return the bindings for the current interactive session.

isLoaded :: GhcMonad m => ModuleName -> m Bool #

Return True == module is loaded.

getModuleGraph :: GhcMonad m => m ModuleGraph #

Get the module dependency graph.

compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule #

Like compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.

compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule #

This is the way to get access to the Core bindings corresponding to a module. compileToCore parses, typechecks, and desugars the module, then returns the resulting Core module (consisting of the module name, type declarations, and function declarations) if successful.

loadModule :: (TypecheckedMod mod, GhcMonad m) => mod -> m mod #

Load a module. Input doesn't need to be desugared.

A module must be loaded before dependent modules can be typechecked. This always includes generating a ModIface and, depending on the hscTarget, may also include code generation.

This function will always cause recompilation and will always overwrite previous compilation results (potentially files on disk).

desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule #

Desugar a typechecked module.

typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule #

Typecheck and rename a parsed module.

Throws a SourceError if either fails.

parseModule :: GhcMonad m => ModSummary -> m ParsedModule #

Parse a module.

Throws a SourceError on parse error.

getModSummary :: GhcMonad m => ModuleName -> m ModSummary #

Return the ModSummary of a module with the given name.

The module must be part of the module graph (see hsc_mod_graph and ModuleGraph). If this is not the case, this function will throw a GhcApiError.

This function ignores boot modules and requires that there is only one non-boot module with the given name.

workingDirectoryChanged :: GhcMonad m => m () #

Inform GHC that the working directory has changed. GHC will flush its cache of module locations, since it may no longer be valid.

Note: Before changing the working directory make sure all threads running in the same session have stopped. If you change the working directory, you should also unload the current program (set targets to empty, followed by load).

guessTarget :: GhcMonad m => String -> Maybe Phase -> m Target #

Attempts to guess what Target a string refers to. This function implements the --make/GHCi command-line syntax for filenames:

  • if the string looks like a Haskell source filename, then interpret it as such
  • if adding a .hs or .lhs suffix yields the name of an existing file, then use that
  • otherwise interpret the string as a module name

removeTarget :: GhcMonad m => TargetId -> m () #

Remove a target

addTarget :: GhcMonad m => Target -> m () #

Add another target.

getTargets :: GhcMonad m => m [Target] #

Returns the current set of targets

setTargets :: GhcMonad m => [Target] -> m () #

Sets the targets for this session. Each target may be a module name or a filename. The targets correspond to the set of root modules for the program/library. Unloading the current program is achieved by setting the current set of targets to be empty, followed by load.

parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn]) #

getInteractiveDynFlags :: GhcMonad m => m DynFlags #

Get the DynFlags used to evaluate interactive expressions.

setInteractiveDynFlags :: GhcMonad m => DynFlags -> m () #

Set the DynFlags used to evaluate interactive expressions. Note: this cannot be used for changes to packages. Use setSessionDynFlags, or setProgramDynFlags and then copy the pkgState into the interactive DynFlags.

getProgramDynFlags :: GhcMonad m => m DynFlags #

Returns the program DynFlags.

setLogAction :: GhcMonad m => LogAction -> m () #

Set the action taken when the compiler produces a message. This can also be accomplished using setProgramDynFlags, but using setLogAction avoids invalidating the cached module graph.

setProgramDynFlags :: GhcMonad m => DynFlags -> m [InstalledUnitId] #

Sets the program DynFlags. Note: this invalidates the internal cached module graph, causing more work to be done the next time load is called.

setSessionDynFlags :: GhcMonad m => DynFlags -> m [InstalledUnitId] #

Updates both the interactive and program DynFlags in a Session. This also reads the package database (unless it has already been read), and prepares the compilers knowledge about packages. It can be called again to load new packages: just add new package flags to (packageFlags dflags).

Returns a list of new packages that may need to be linked in using the dynamic linker (see linkPackages) as a result of new package flags. If you are not doing linking or doing static linking, you can ignore the list of packages returned.

initGhcMonad :: GhcMonad m => Maybe FilePath -> m () #

Initialise a GHC session.

If you implement a custom GhcMonad you must call this function in the monad run function. It will initialise the session variable and clear all warnings.

The first argument should point to the directory where GHC's library files reside. More precisely, this should be the output of ghc --print-libdir of the version of GHC the module using this API is compiled with. For portability, you should use the ghc-paths package, available at http://hackage.haskell.org/package/ghc-paths.

withCleanupSession :: GhcMonad m => m a -> m a #

runGhcT #

Arguments

:: ExceptionMonad m 
=> Maybe FilePath

See argument to initGhcMonad.

-> GhcT m a

The action to perform.

-> m a 

Run function for GhcT monad transformer.

It initialises the GHC session and warnings via initGhcMonad. Each call to this function will create a new session which should not be shared among several threads.

runGhc #

Arguments

:: Maybe FilePath

See argument to initGhcMonad.

-> Ghc a

The action to perform.

-> IO a 

Run function for the Ghc monad.

It initialises the GHC session and warnings via initGhcMonad. Each call to this function will create a new session which should not be shared among several threads.

Any errors not handled inside the Ghc action are propagated as IO exceptions.

defaultCleanupHandler :: ExceptionMonad m => DynFlags -> m a -> m a #

This function is no longer necessary, cleanup is now done by runGhc/runGhcT.

defaultErrorHandler :: ExceptionMonad m => FatalMessager -> FlushOut -> m a -> m a #

Install some default exception handlers and run the inner computation. Unless you want to handle exceptions yourself, you should wrap this around the top level of your program. The default handlers output the error message(s) to stderr and exit cleanly.

class ParsedMod m where #

Minimal complete definition

modSummary, parsedSource

Methods

parsedSource :: m -> ParsedSource #

Instances
ParsedMod ParsedModule 
Instance details

Defined in GHC

Methods

modSummary :: ParsedModule -> ModSummary

parsedSource :: ParsedModule -> ParsedSource #

ParsedMod TypecheckedModule 
Instance details

Defined in GHC

Methods

modSummary :: TypecheckedModule -> ModSummary

parsedSource :: TypecheckedModule -> ParsedSource #

ParsedMod DesugaredModule 
Instance details

Defined in GHC

Methods

modSummary :: DesugaredModule -> ModSummary

parsedSource :: DesugaredModule -> ParsedSource #

class ParsedMod m => TypecheckedMod m where #

Minimal complete definition

renamedSource, typecheckedSource, moduleInfo, tm_internals

Methods

renamedSource :: m -> Maybe RenamedSource #

typecheckedSource :: m -> TypecheckedSource #

moduleInfo :: m -> ModuleInfo #

Instances
TypecheckedMod TypecheckedModule 
Instance details

Defined in GHC

Methods

renamedSource :: TypecheckedModule -> Maybe RenamedSource #

typecheckedSource :: TypecheckedModule -> TypecheckedSource #

moduleInfo :: TypecheckedModule -> ModuleInfo #

tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

TypecheckedMod DesugaredModule 
Instance details

Defined in GHC

Methods

renamedSource :: DesugaredModule -> Maybe RenamedSource #

typecheckedSource :: DesugaredModule -> TypecheckedSource #

moduleInfo :: DesugaredModule -> ModuleInfo #

tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)

data ParsedModule #

The result of successful parsing.

Constructors

ParsedModule 

Fields

Instances
Show ParsedModule Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> ParsedModule -> ShowS #

show :: ParsedModule -> String #

showList :: [ParsedModule] -> ShowS #

NFData ParsedModule Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: ParsedModule -> () #

ParsedMod ParsedModule 
Instance details

Defined in GHC

Methods

modSummary :: ParsedModule -> ModSummary

parsedSource :: ParsedModule -> ParsedSource #

data TypecheckedModule #

The result of successful typechecking. It also contains the parser result.

Constructors

TypecheckedModule 

Fields

Instances
ParsedMod TypecheckedModule 
Instance details

Defined in GHC

Methods

modSummary :: TypecheckedModule -> ModSummary

parsedSource :: TypecheckedModule -> ParsedSource #

TypecheckedMod TypecheckedModule 
Instance details

Defined in GHC

Methods

renamedSource :: TypecheckedModule -> Maybe RenamedSource #

typecheckedSource :: TypecheckedModule -> TypecheckedSource #

moduleInfo :: TypecheckedModule -> ModuleInfo #

tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

data DesugaredModule #

The result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.

Constructors

DesugaredModule 

Fields

Instances
ParsedMod DesugaredModule 
Instance details

Defined in GHC

Methods

modSummary :: DesugaredModule -> ModSummary

parsedSource :: DesugaredModule -> ParsedSource #

TypecheckedMod DesugaredModule 
Instance details

Defined in GHC

Methods

renamedSource :: DesugaredModule -> Maybe RenamedSource #

typecheckedSource :: DesugaredModule -> TypecheckedSource #

moduleInfo :: DesugaredModule -> ModuleInfo #

tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)

DesugaredMod DesugaredModule 
Instance details

Defined in GHC

Methods

coreModule :: DesugaredModule -> ModGuts #

type ParsedSource = Located (HsModule GhcPs) #

type RenamedSource = (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe LHsDocString) #

type TypecheckedSource = LHsBinds GhcTc #

data CoreModule #

A CoreModule consists of just the fields of a ModGuts that are needed for the compileToCoreModule interface.

Constructors

CoreModule 

Fields

Instances
Show CoreModule Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> CoreModule -> ShowS #

show :: CoreModule -> String #

showList :: [CoreModule] -> ShowS #

NFData CoreModule Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: CoreModule -> () #

Outputable CoreModule 
Instance details

Defined in GHC

Methods

ppr :: CoreModule -> SDoc #

pprPrec :: Rational -> CoreModule -> SDoc #

data ModuleInfo #

Container for information about a Module.

cyclicModuleErr :: [ModSummary] -> SDoc #

topSortModuleGraph #

Arguments

:: Bool

Drop hi-boot nodes? (see below)

-> ModuleGraph 
-> Maybe ModuleName

Root module name. If Nothing, use the full graph.

-> [SCC ModSummary] 

Topological sort of the module graph

Calculate SCCs of the module graph, possibly dropping the hi-boot nodes The resulting list of strongly-connected-components is in topologically sorted order, starting with the module(s) at the bottom of the dependency graph (ie compile them first) and ending with the ones at the top.

Drop hi-boot nodes (first boolean arg)?

  • False: treat the hi-boot summaries as nodes of the graph, so the graph must be acyclic
  • True: eliminate the hi-boot nodes, and instead pretend the a source-import of Foo is an import of Foo The resulting graph has no hi-boot nodes, but can be cyclic

load :: GhcMonad m => LoadHowMuch -> m SuccessFlag #

Try to load the program. See LoadHowMuch for the different modes.

This function implements the core of GHC's --make mode. It preprocesses, compiles and loads the specified modules, avoiding re-compilation wherever possible. Depending on the target (see hscTarget) compiling and loading may result in files being created on disk.

Calls the defaultWarnErrLogger after each compiling each module, whether successful or not.

Throw a SourceError if errors are encountered before the actual compilation starts (e.g., during dependency analysis). All other errors are reported using the defaultWarnErrLogger.

depanal #

Arguments

:: GhcMonad m 
=> [ModuleName]

excluded modules

-> Bool

allow duplicate roots

-> m ModuleGraph 

Perform a dependency analysis starting from the current targets and update the session with the new module graph.

Dependency analysis entails parsing the import directives and may therefore require running certain preprocessors.

Note that each ModSummary in the module graph caches its DynFlags. These DynFlags are determined by the current session DynFlags and the OPTIONS and LANGUAGE pragmas of the parsed module. Thus if you want changes to the DynFlags to take effect you need to call this function again.

data LoadHowMuch #

Describes which modules of the module graph need to be loaded.

Constructors

LoadAllTargets

Load all targets and its dependencies.

LoadUpTo ModuleName

Load only the given module and its dependencies.

LoadDependenciesOf ModuleName

Load only the dependencies of the given module, but not the module itself.

reconstructType :: HscEnv -> Int -> Id -> IO (Maybe Type) #

moduleIsBootOrNotObjectLinkable :: GhcMonad m => ModSummary -> m Bool #

showModule :: GhcMonad m => ModSummary -> m String #

dynCompileExpr :: GhcMonad m => String -> m Dynamic #

Compile an expression, run it and return the result as a Dynamic.

compileParsedExpr :: GhcMonad m => LHsExpr GhcPs -> m HValue #

compileParsedExprRemote :: GhcMonad m => LHsExpr GhcPs -> m ForeignHValue #

Compile a parsed expression (before renaming), run it, and deliver the resulting HValue.

compileExprRemote :: GhcMonad m => String -> m ForeignHValue #

Compile an expression, run it, and deliver the resulting HValue.

compileExpr :: GhcMonad m => String -> m HValue #

Compile an expression, run it, and deliver the resulting HValue.

parseExpr :: GhcMonad m => String -> m (LHsExpr GhcPs) #

Parse an expression, the parsed expression can be further processed and passed to compileParsedExpr.

typeKind :: GhcMonad m => Bool -> String -> m (Type, Kind) #

Get the kind of a type

exprType :: GhcMonad m => TcRnExprMode -> String -> m Type #

Get the type of an expression Returns the type as described by TcRnExprMode

getDocs :: GhcMonad m => Name -> m (Either GetDocsFailure (Maybe HsDocString, Map Int HsDocString)) #

isDecl :: DynFlags -> String -> Bool #

Returns True if passed string is a declaration but not a splice.

isImport :: DynFlags -> String -> Bool #

Returns True if passed string is an import declaration.

hasImport :: DynFlags -> String -> Bool #

Returns True if passed string has an import declaration.

isStmt :: DynFlags -> String -> Bool #

Returns True if passed string is a statement.

parseName :: GhcMonad m => String -> m [Name] #

Parses a string as an identifier, and returns the list of Names that the identifier can refer to in the current interactive context.

getRdrNamesInScope :: GhcMonad m => m [RdrName] #

Returns all RdrNames in scope in the current interactive context, excluding any that are internally-generated.

getNamesInScope :: GhcMonad m => m [Name] #

Returns all names in scope in the current interactive context

getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc)) #

Looks up an identifier in the current interactive context (for :info) Filter the instances by the ones whose tycons (or clases resp) are in scope (qualified or otherwise). Otherwise we list a whole lot too many! The exact choice of which ones to show, and which to hide, is a judgement call. (see Trac #1581)

moduleIsInterpreted :: GhcMonad m => Module -> m Bool #

Returns True if the specified module is interpreted, and hence has its full top-level scope available.

getContext :: GhcMonad m => m [InteractiveImport] #

Get the interactive evaluation context, consisting of a pair of the set of modules from which we take the full top-level scope, and the set of modules from which we take just the exports respectively.

setContext :: GhcMonad m => [InteractiveImport] -> m () #

Set the interactive evaluation context.

(setContext imports) sets the ic_imports field (which in turn determines what is in scope at the prompt) to imports, and constructs the ic_rn_glb_env environment to reflect it.

We retain in scope all the things defined at the prompt, and kept in ic_tythings. (Indeed, they shadow stuff from ic_imports.)

abandonAll :: GhcMonad m => m Bool #

abandon :: GhcMonad m => m Bool #

forward :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String) #

back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String) #

resumeExec :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> m ExecResult #

parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs) #

runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name] #

Run some declarations and return any user-visible names that were brought into scope.

runDecls :: GhcMonad m => String -> m [Name] #

execStmt #

Arguments

:: GhcMonad m 
=> String

a statement (bind or expression)

-> ExecOptions 
-> m ExecResult 

Run a statement in the current interactive context.

execOptions :: ExecOptions #

default ExecOptions

getHistoryModule :: History -> Module #

getResumeContext :: GhcMonad m => m [Resume] #

data GetDocsFailure #

Failure modes for getDocs.

Constructors

NameHasNoModule Name

nameModule_maybe returned Nothing.

NoDocsInIface Module Bool

True: The module was compiled. False: The module was :loaded.

InteractiveName

The Name was defined interactively.

Instances
Outputable GetDocsFailure 
Instance details

Defined in InteractiveEval

Methods

ppr :: GetDocsFailure -> SDoc #

pprPrec :: Rational -> GetDocsFailure -> SDoc #

runTcInteractive :: HscEnv -> TcRn a -> IO (Messages, Maybe a) #

data TcRnExprMode #

How should we infer a type? See Note [TcRnExprMode]

Constructors

TM_Inst

Instantiate the type fully (:type)

TM_NoInst

Do not instantiate the type (:type +v)

TM_Default

Default the type eagerly (:type +d)

pprFamInst :: FamInst -> SDoc #

Pretty-prints a FamInst (type/data family instance) with its defining location.

defaultWarnErrLogger :: WarnErrLogger #

printException :: GhcMonad m => SourceError -> m () #

Print the error message and all warnings. Useful inside exception handlers. Clears warnings after printing.

getSessionDynFlags :: GhcMonad m => m DynFlags #

Grabs the DynFlags from the Session

class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad (m :: Type -> Type) where #

A monad that has all the features needed by GHC API calls.

In short, a GHC monad

  • allows embedding of IO actions,
  • can log warnings,
  • allows handling of (extensible) exceptions, and
  • maintains a current session.

If you do not use Ghc or GhcT, make sure to call initGhcMonad before any call to the GHC API functions can occur.

Methods

getSession :: m HscEnv #

setSession :: HscEnv -> m () #

Instances
GhcMonad Ghc 
Instance details

Defined in GhcMonad

Methods

getSession :: Ghc HscEnv #

setSession :: HscEnv -> Ghc () #

ExceptionMonad m => GhcMonad (GhcT m) 
Instance details

Defined in GhcMonad

Methods

getSession :: GhcT m HscEnv #

setSession :: HscEnv -> GhcT m () #

data Ghc a #

A minimal implementation of a GhcMonad. If you need a custom monad, e.g., to maintain additional state consider wrapping this monad or using GhcT.

Instances
Monad Ghc 
Instance details

Defined in GhcMonad

Methods

(>>=) :: Ghc a -> (a -> Ghc b) -> Ghc b #

(>>) :: Ghc a -> Ghc b -> Ghc b #

return :: a -> Ghc a #

fail :: String -> Ghc a #

Functor Ghc 
Instance details

Defined in GhcMonad

Methods

fmap :: (a -> b) -> Ghc a -> Ghc b #

(<$) :: a -> Ghc b -> Ghc a #

MonadFix Ghc 
Instance details

Defined in GhcMonad

Methods

mfix :: (a -> Ghc a) -> Ghc a #

Applicative Ghc 
Instance details

Defined in GhcMonad

Methods

pure :: a -> Ghc a #

(<*>) :: Ghc (a -> b) -> Ghc a -> Ghc b #

liftA2 :: (a -> b -> c) -> Ghc a -> Ghc b -> Ghc c #

(*>) :: Ghc a -> Ghc b -> Ghc b #

(<*) :: Ghc a -> Ghc b -> Ghc a #

MonadIO Ghc 
Instance details

Defined in GhcMonad

Methods

liftIO :: IO a -> Ghc a #

GhcMonad Ghc 
Instance details

Defined in GhcMonad

Methods

getSession :: Ghc HscEnv #

setSession :: HscEnv -> Ghc () #

HasDynFlags Ghc 
Instance details

Defined in GhcMonad

Methods

getDynFlags :: Ghc DynFlags #

ExceptionMonad Ghc 
Instance details

Defined in GhcMonad

Methods

gcatch :: Exception e => Ghc a -> (e -> Ghc a) -> Ghc a #

gmask :: ((Ghc a -> Ghc a) -> Ghc b) -> Ghc b #

gbracket :: Ghc a -> (a -> Ghc b) -> (a -> Ghc c) -> Ghc c #

gfinally :: Ghc a -> Ghc b -> Ghc a #

data GhcT (m :: Type -> Type) a #

A monad transformer to add GHC specific features to another monad.

Note that the wrapped monad must support IO and handling of exceptions.

Instances
Monad m => Monad (GhcT m) 
Instance details

Defined in GhcMonad

Methods

(>>=) :: GhcT m a -> (a -> GhcT m b) -> GhcT m b #

(>>) :: GhcT m a -> GhcT m b -> GhcT m b #

return :: a -> GhcT m a #

fail :: String -> GhcT m a #

Functor m => Functor (GhcT m) 
Instance details

Defined in GhcMonad

Methods

fmap :: (a -> b) -> GhcT m a -> GhcT m b #

(<$) :: a -> GhcT m b -> GhcT m a #

Applicative m => Applicative (GhcT m) 
Instance details

Defined in GhcMonad

Methods

pure :: a -> GhcT m a #

(<*>) :: GhcT m (a -> b) -> GhcT m a -> GhcT m b #

liftA2 :: (a -> b -> c) -> GhcT m a -> GhcT m b -> GhcT m c #

(*>) :: GhcT m a -> GhcT m b -> GhcT m b #

(<*) :: GhcT m a -> GhcT m b -> GhcT m a #

MonadIO m => MonadIO (GhcT m) 
Instance details

Defined in GhcMonad

Methods

liftIO :: IO a -> GhcT m a #

ExceptionMonad m => GhcMonad (GhcT m) 
Instance details

Defined in GhcMonad

Methods

getSession :: GhcT m HscEnv #

setSession :: HscEnv -> GhcT m () #

MonadIO m => HasDynFlags (GhcT m) 
Instance details

Defined in GhcMonad

Methods

getDynFlags :: GhcT m DynFlags #

ExceptionMonad m => ExceptionMonad (GhcT m) 
Instance details

Defined in GhcMonad

Methods

gcatch :: Exception e => GhcT m a -> (e -> GhcT m a) -> GhcT m a #

gmask :: ((GhcT m a -> GhcT m a) -> GhcT m b) -> GhcT m b #

gbracket :: GhcT m a -> (a -> GhcT m b) -> (a -> GhcT m c) -> GhcT m c #

gfinally :: GhcT m a -> GhcT m b -> GhcT m a #

type WarnErrLogger = forall (m :: Type -> Type). GhcMonad m => Maybe SourceError -> m () #

A function called to log warnings and errors.

ms_mod_name :: ModSummary -> ModuleName #

mkModuleGraph :: [ModSummary] -> ModuleGraph #

emptyMG :: ModuleGraph #

mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary #

Look up a ModSummary in the ModuleGraph

mgModSummaries :: ModuleGraph -> [ModSummary] #

mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph #

Map a function f over all the ModSummaries. To preserve invariants f can't change the isBoot status.

needsTemplateHaskellOrQQ :: ModuleGraph -> Bool #

Determines whether a set of modules requires Template Haskell or Quasi Quotes

Note that if the session's DynFlags enabled Template Haskell when depanal was called, then each module in the returned module graph will have Template Haskell enabled whether it is actually needed or not.

handleSourceError #

Arguments

:: ExceptionMonad m 
=> (SourceError -> m a)

exception handler

-> m a

action to perform

-> m a 

Perform the given action and call the exception handler if the action throws a SourceError. See SourceError for more information.

data HscEnv #

HscEnv is like Session, except that some of the fields are immutable. An HscEnv is used to compile a single module from plain Haskell source code (after preprocessing) to either C, assembly or C--. Things like the module graph don't change during a single compilation.

Historical note: "hsc" used to be the name of the compiler binary, when there was a separate driver and compiler. To compile a single module, the driver would invoke hsc on the source code... so nowadays we think of hsc as the layer of the compiler that deals with compiling a single module.

data Target #

A compilation target.

A target may be supplied with the actual text of the module. If so, use this instead of the file contents (this is for use in an IDE where the file hasn't been saved by the user yet).

Constructors

Target 

Fields

Instances
Outputable Target 
Instance details

Defined in HscTypes

Methods

ppr :: Target -> SDoc #

pprPrec :: Rational -> Target -> SDoc #

data TargetId #

Constructors

TargetModule ModuleName

A module name: search for the file

TargetFile FilePath (Maybe Phase)

A filename: preprocess & parse it to find the module name. If specified, the Phase indicates how to compile this file (which phase to start from). Nothing indicates the starting phase should be determined from the suffix of the filename.

Instances
Eq TargetId 
Instance details

Defined in HscTypes

Methods

(==) :: TargetId -> TargetId -> Bool #

(/=) :: TargetId -> TargetId -> Bool #

Outputable TargetId 
Instance details

Defined in HscTypes

Methods

ppr :: TargetId -> SDoc #

pprPrec :: Rational -> TargetId -> SDoc #

data ModIface #

A ModIface plus a ModDetails summarises everything we know about a compiled module. The ModIface is the stuff *before* linking, and can be written out to an interface file. The 'ModDetails is after linking and can be completely recovered from just the ModIface.

When we read an interface file, we also construct a ModIface from it, except that we explicitly make the mi_decls and a few other fields empty; as when reading we consolidate the declarations etc. into a number of indexed maps and environments in the ExternalPackageState.

Constructors

ModIface 

Fields

Instances
Binary ModIface 
Instance details

Defined in HscTypes

Methods

put_ :: BinHandle -> ModIface -> IO () #

put :: BinHandle -> ModIface -> IO (Bin ModIface) #

get :: BinHandle -> IO ModIface #

data InteractiveImport #

Constructors

IIDecl (ImportDecl GhcPs)

Bring the exports of a particular module (filtered by an import decl) into scope

IIModule ModuleName

Bring into scope the entire top-level envt of of this module, including the things imported into it.

Instances
Outputable InteractiveImport 
Instance details

Defined in HscTypes

Methods

ppr :: InteractiveImport -> SDoc #

pprPrec :: Rational -> InteractiveImport -> SDoc #

data ModuleGraph #

A ModuleGraph contains all the nodes from the home package (only). There will be a node for each source module, plus a node for each hi-boot module.

The graph is not necessarily stored in topologically-sorted order. Use topSortModuleGraph and flattenSCC to achieve this.

data ModSummary #

A single node in a ModuleGraph. The nodes of the module graph are one of:

  • A regular Haskell source module
  • A hi-boot source module

Constructors

ModSummary 

Fields

Instances
Show ModSummary Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> ModSummary -> ShowS #

show :: ModSummary -> String #

showList :: [ModSummary] -> ShowS #

NFData ModSummary Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: ModSummary -> () #

Outputable ModSummary 
Instance details

Defined in HscTypes

Methods

ppr :: ModSummary -> SDoc #

pprPrec :: Rational -> ModSummary -> SDoc #

data HsModule pass #

Haskell Module

All we actually declare here is the top-level structure for a module.

Constructors

HsModule

AnnKeywordIds

Fields

Instances
Data (HsModule GhcPs) 
Instance details

Defined in HsSyn

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcPs -> c (HsModule GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcPs) #

toConstr :: HsModule GhcPs -> Constr #

dataTypeOf :: HsModule GhcPs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcPs)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcPs)) #

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcPs -> HsModule GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcPs -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs) #

Data (HsModule GhcRn) 
Instance details

Defined in HsSyn

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcRn -> c (HsModule GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcRn) #

toConstr :: HsModule GhcRn -> Constr #

dataTypeOf :: HsModule GhcRn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcRn)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcRn)) #

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcRn -> HsModule GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcRn -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn) #

Data (HsModule GhcTc) 
Instance details

Defined in HsSyn

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcTc -> c (HsModule GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcTc) #

toConstr :: HsModule GhcTc -> Constr #

dataTypeOf :: HsModule GhcTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcTc)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcTc)) #

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcTc -> HsModule GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcTc -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc) #

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsModule p) 
Instance details

Defined in HsSyn

Methods

ppr :: HsModule p -> SDoc #

pprPrec :: Rational -> HsModule p -> SDoc #

lPatImplicits :: LPat GhcRn -> NameSet #

hsValBindsImplicits :: HsValBindsLR GhcRn (GhcPass idR) -> NameSet #

lStmtsImplicits :: [LStmtLR GhcRn (GhcPass idR) (Located (body (GhcPass idR)))] -> NameSet #

hsDataFamInstBinders :: DataFamInstDecl pass -> ([Located (IdP pass)], [LFieldOcc pass]) #

getPatSynBinds :: [(RecFlag, LHsBinds id)] -> [PatSynBind id id] #

hsPatSynSelectors :: HsValBinds (GhcPass p) -> [IdP (GhcPass p)] #

hsForeignDeclsBinders :: [LForeignDecl pass] -> [Located (IdP pass)] #

hsLTyClDeclBinders :: Located (TyClDecl pass) -> ([Located (IdP pass)], [LFieldOcc pass]) #

Returns all the binding names of the decl. The first one is guaranteed to be the name of the decl. The first component represents all binding names except record fields; the second represents field occurrences. For record fields mentioned in multiple constructors, the SrcLoc will be from the first occurrence.

Each returned (Located name) has a SrcSpan for the whole declaration. See Note [SrcSpan for binders]

hsTyClForeignBinders :: [TyClGroup GhcRn] -> [LForeignDecl GhcRn] -> [Name] #

hsGroupBinders :: HsGroup GhcRn -> [Name] #

collectPatsBinders :: [LPat a] -> [IdP a] #

collectPatBinders :: LPat a -> [IdP a] #

collectStmtBinders :: StmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)] #

collectLStmtBinders :: LStmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)] #

collectStmtsBinders :: [StmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)] #

collectLStmtsBinders :: [LStmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)] #

collectMethodBinders :: LHsBindsLR idL idR -> [Located (IdP idL)] #

collectHsBindListBinders :: [LHsBindLR idL idR] -> [IdP idL] #

collectHsBindsBinders :: LHsBindsLR idL idR -> [IdP idL] #

collectHsBindBinders :: HsBindLR idL idR -> [IdP idL] #

collectHsValBinders :: HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)] #

collectHsIdBinders :: HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)] #

collectLocalBinders :: HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)] #

isBangedHsBind :: HsBind GhcTc -> Bool #

Is a binding a strict variable or pattern bind (e.g. !x = ...)?

isUnliftedHsBind :: HsBind GhcTc -> Bool #

Should we treat this as an unlifted bind? This will be true for any bind that binds an unlifted variable, but we must be careful around AbsBinds. See Note [Unlifted id check in isUnliftedHsBind]. For usage information, see Note [Strict binds check] is DsBinds.

mkMatch :: HsMatchContext (NameOrRdrName (IdP (GhcPass p))) -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> Located (HsLocalBinds (GhcPass p)) -> LMatch (GhcPass p) (LHsExpr (GhcPass p)) #

mkPrefixFunRhs :: Located id -> HsMatchContext id #

Make a prefix, non-strict function HsMatchContext

mk_easy_FunBind :: SrcSpan -> RdrName -> [LPat GhcPs] -> LHsExpr GhcPs -> LHsBind GhcPs #

isInfixFunBind :: HsBindLR id1 id2 -> Bool #

If any of the matches in the FunBind are infix, the FunBind is considered infix.

mkPatSynBind :: Located RdrName -> HsPatSynDetails (Located RdrName) -> LPat GhcPs -> HsPatSynDir GhcPs -> HsBind GhcPs #

mkVarBind :: IdP (GhcPass p) -> LHsExpr (GhcPass p) -> LHsBind (GhcPass p) #

mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr GhcPs -> LHsBind GhcPs #

mkTopFunBind :: Origin -> Located Name -> [LMatch GhcRn (LHsExpr GhcRn)] -> HsBind GhcRn #

mkFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> HsBind GhcPs #

mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc #

mkHsWrapPatCo :: TcCoercionN -> Pat (GhcPass id) -> Type -> Pat (GhcPass id) #

mkHsWrapPat :: HsWrapper -> Pat (GhcPass id) -> Type -> Pat (GhcPass id) #

mkLHsCmdWrap :: HsWrapper -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p) #

mkHsCmdWrap :: HsWrapper -> HsCmd (GhcPass p) -> HsCmd (GhcPass p) #

mkLHsWrapCo :: TcCoercionN -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

mkHsWrapCoR :: TcCoercionR -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkHsWrapCo :: TcCoercionN -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkHsWrap :: HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkLHsWrap :: HsWrapper -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

typeToLHsType :: Type -> LHsType GhcPs #

Converting a Type to an HsType RdrName This is needed to implement GeneralizedNewtypeDeriving.

Note that we use getRdrName extensively, which generates Exact RdrNames rather than strings.

mkClassOpSigs :: [LSig GhcPs] -> [LSig GhcPs] #

mkHsSigEnv :: (LSig GhcRn -> Maybe ([Located Name], a)) -> [LSig GhcRn] -> NameEnv a #

mkLHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs #

mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs #

chunkify :: [a] -> [[a]] #

Split a list into lists that are small enough to have a corresponding tuple arity. The sub-lists of the result all have length <= mAX_TUPLE_SIZE But there may be more than mAX_TUPLE_SIZE sub-lists

mkChunkified #

Arguments

:: ([a] -> a)

"Small" constructor function, of maximum input arity mAX_TUPLE_SIZE

-> [a]

Possible "big" list of things to construct from

-> a

Constructed thing made possible by recursive decomposition

Lifts a "small" constructor into a "big" constructor by recursive decompositon

mkBigLHsPatTup :: [LPat GhcRn] -> LPat GhcRn #

mkBigLHsVarPatTup :: [IdP GhcRn] -> LPat GhcRn #

mkBigLHsTup :: [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #

mkBigLHsVarTup :: [IdP (GhcPass id)] -> LHsExpr (GhcPass id) #

missingTupArg :: HsTupArg GhcPs #

nlTuplePat :: [LPat GhcPs] -> Boxity -> LPat GhcPs #

mkLHsVarTuple :: [IdP (GhcPass a)] -> LHsExpr (GhcPass a) #

mkLHsTupleExpr :: [LHsExpr (GhcPass a)] -> LHsExpr (GhcPass a) #

nlHsTyConApp :: IdP (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p) #

nlHsParTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsFunTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsTyVar :: IdP (GhcPass p) -> LHsType (GhcPass p) #

nlHsAppTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs #

nlHsCase :: LHsExpr GhcPs -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs #

nlHsIf :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

nlHsPar :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

nlHsLam :: LMatch GhcPs (LHsExpr GhcPs) -> LHsExpr GhcPs #

nlHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs #

nlHsDo :: HsStmtContext Name -> [LStmt GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs #

nlWildPatName :: LPat GhcRn #

nlWildPat :: LPat GhcPs #

nlWildConPat :: DataCon -> LPat GhcPs #

nlNullaryConPat :: IdP id -> LPat id #

nlConPatName :: Name -> [LPat GhcRn] -> LPat GhcRn #

nlConPat :: RdrName -> [LPat GhcPs] -> LPat GhcPs #

nlInfixConPat :: RdrName -> LPat GhcPs -> LPat GhcPs -> LPat GhcPs #

nlConVarPatName :: Name -> [Name] -> LPat GhcRn #

nlConVarPat :: RdrName -> [RdrName] -> LPat GhcPs #

nlHsVarApps :: IdP (GhcPass id) -> [IdP (GhcPass id)] -> LHsExpr (GhcPass id) #

nlHsApps :: IdP (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #

nlHsSyntaxApps :: SyntaxExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #

nlHsApp :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

nlLitPat :: HsLit GhcPs -> LPat GhcPs #

nlVarPat :: IdP (GhcPass id) -> LPat (GhcPass id) #

nlHsIntLit :: Integer -> LHsExpr (GhcPass p) #

nlHsLit :: HsLit (GhcPass p) -> LHsExpr (GhcPass p) #

nlHsDataCon :: DataCon -> LHsExpr GhcTc #

nlHsVar :: IdP (GhcPass id) -> LHsExpr (GhcPass id) #

userHsTyVarBndrs :: SrcSpan -> [IdP (GhcPass p)] -> [LHsTyVarBndr (GhcPass p)] #

userHsLTyVarBndrs :: SrcSpan -> [Located (IdP (GhcPass p))] -> [LHsTyVarBndr (GhcPass p)] #

mkHsStringPrimLit :: FastString -> HsLit (GhcPass p) #

mkHsString :: String -> HsLit (GhcPass p) #

unqualQuasiQuote :: RdrName #

mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsSplice GhcPs #

mkHsSpliceTy :: SpliceDecoration -> LHsExpr GhcPs -> HsType GhcPs #

mkHsSpliceTE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs #

mkHsSpliceE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs #

mkUntypedSplice :: SpliceDecoration -> LHsExpr GhcPs -> HsSplice GhcPs #

mkHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs #

mkRecStmt :: [LStmtLR (GhcPass idL) GhcPs bodyR] -> StmtLR (GhcPass idL) GhcPs bodyR #

emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR #

emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR #

emptyRecStmt :: StmtLR (GhcPass idL) GhcPs bodyR #

unitRecStmtTc :: RecStmtTc #

mkTcBindStmt :: LPat GhcTc -> Located (bodyR GhcTc) -> StmtLR GhcTc GhcTc (Located (bodyR GhcTc)) #

mkBindStmt :: XBindStmt (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) ~ NoExt => LPat (GhcPass idL) -> Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) #

mkBodyStmt :: Located (bodyR GhcPs) -> StmtLR (GhcPass idL) GhcPs (Located (bodyR GhcPs)) #

mkLastStmt :: Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) #

mkGroupByUsingStmt :: [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

mkGroupUsingStmt :: [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

mkTransformByStmt :: [Ex