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

data HieFileResult #

Constructors

HieFileResult 

Fields

data HieFile #

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

Instances details
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 
Instance details

Defined in 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 #

Construct an HieFile from the outputs of the typechecker.

mkHieFile' :: ModSummary -> [AvailInfo] -> HieASTs Type -> ByteString -> Hsc HieFile Source #

enrichHie :: TypecheckedSource -> RenamedSource -> Hsc (HieASTs Type) #

type RefMap = Map Identifier [(Span, IdentifierDetails Type)] Source #

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

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

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

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

supportsHieFiles :: Bool Source #

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

dontWriteHieFiles :: DynFlags -> DynFlags Source #

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

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

getModuleHash :: ModIface -> Fingerprint Source #

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

setUpTypedHoles :: DynFlags -> DynFlags 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

Instances details
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 #

pattern ExposePackage :: String -> PackageArg -> ModRenaming -> PackageFlag Source #

type HasSrcSpan = HasSrcSpan Source #

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

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

disableWarningsAsErrors :: DynFlags -> DynFlags Source #

data AvailInfo #

Records what things are "available", i.e. in scope

Instances

Instances details
Eq AvailInfo

Used when deciding if the interface has changed

Instance details

Defined in Avail

Methods

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

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

Data AvailInfo 
Instance details

Defined in Avail

Methods

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

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

toConstr :: AvailInfo -> Constr #

dataTypeOf :: AvailInfo -> DataType #

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

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

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

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

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

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

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

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

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

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

Binary AvailInfo 
Instance details

Defined in Avail

Methods

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

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

get :: BinHandle -> IO AvailInfo #

Outputable AvailInfo 
Instance details

Defined in Avail

Methods

ppr :: AvailInfo -> SDoc #

pprPrec :: Rational -> AvailInfo -> SDoc #

tcg_exports :: TcGblEnv -> [AvailInfo] #

What is exported

module GHC.Hs.Extension

module LinkerTypes

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

modInfoRdrEnv :: ModuleInfo -> Maybe GlobalRdrEnv #

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

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

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

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

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

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

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

parseInstanceHead :: GhcMonad m => String -> m Type #

getInstancesForType :: GhcMonad m => Type -> m [ClsInst] #

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

runParsedDecls :: GhcMonad m => [LHsDecl GhcPs] -> m [Name] #

Like runDeclsWithLocation, but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).

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' :: GhcMonad m => GhciLStmt GhcPs -> String -> ExecOptions -> m ExecResult #

Like execStmt, but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).

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

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

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

Instances details
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 #

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

Instances details
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 #

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--. It's also used to store the dynamic linker state to allow for multiple linkers in the same address space. 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

  • targetId :: TargetId

    module or filename

  • targetAllowObjCode :: Bool

    object code allowed?

  • targetContents :: Maybe (InputFileBuffer, UTCTime)

    Optional in-memory buffer containing the source code GHC should use for this target instead of reading it from disk.

    Since GHC version 8.10 modules which require preprocessors such as Literate Haskell or CPP to run are also supported.

    If a corresponding source file does not exist on disk this will result in a SourceError exception if targetId = TargetModule _ is used. However together with targetId = TargetFile _ GHC will not complain about the file missing.

Instances

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

Instances details
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 #

type ModIface = ModIface_ 'ModIfaceFinal #

data ModIface_ (phase :: ModIfacePhase) #

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

  • mi_module :: !Module

    Name of the module we are for

  • mi_sig_of :: !(Maybe Module)

    Are we a sig of another mod?

  • mi_hsc_src :: !HscSource

    Boot? Signature?

  • mi_deps :: Dependencies

    The dependencies of the module. This is consulted for directly-imported modules, but not for anything else (hence lazy)

  • mi_usages :: [Usage]

    Usages; kept sorted so that it's easy to decide whether to write a new iface file (changing usages doesn't affect the hash of this module) NOT STRICT! we read this field lazily from the interface file It is *only* consulted by the recompilation checker

  • mi_exports :: ![IfaceExport]

    Exports Kept sorted by (mod,occ), to make version comparisons easier Records the modules that are the declaration points for things exported by this module, and the OccNames of those things

  • mi_used_th :: !Bool

    Module required TH splices when it was compiled. This disables recompilation avoidance (see #481).

  • mi_fixities :: [(OccName, Fixity)]

    Fixities NOT STRICT! we read this field lazily from the interface file

  • mi_warns :: Warnings

    Warnings NOT STRICT! we read this field lazily from the interface file

  • mi_anns :: [IfaceAnnotation]

    Annotations NOT STRICT! we read this field lazily from the interface file

  • mi_decls :: [IfaceDeclExts phase]

    Type, class and variable declarations The hash of an Id changes if its fixity or deprecations change (as well as its type of course) Ditto data constructors, class operations, except that the hash of the parent class/tycon changes

  • mi_globals :: !(Maybe GlobalRdrEnv)

    Binds all the things defined at the top level in the original source code for this module. which is NOT the same as mi_exports, nor mi_decls (which may contains declarations for things not actually defined by the user). Used for GHCi and for inspecting the contents of modules via the GHC API only.

    (We need the source file to figure out the top-level environment, if we didn't compile this module from source then this field contains Nothing).

    Strictly speaking this field should live in the HomeModInfo, but that leads to more plumbing.

  • mi_insts :: [IfaceClsInst]

    Sorted class instance

  • mi_fam_insts :: [IfaceFamInst]

    Sorted family instances

  • mi_rules :: [IfaceRule]

    Sorted rules

  • mi_hpc :: !AnyHpcUsage

    True if this program uses Hpc at any point in the program.

  • mi_trust :: !IfaceTrustInfo

    Safe Haskell Trust information for this module.

  • mi_trust_pkg :: !Bool

    Do we require the package this module resides in be trusted to trust this module? This is used for the situation where a module is Safe (so doesn't require the package be trusted itself) but imports some trustworthy modules from its own package (which does require its own package be trusted). See Note [RnNames . Trust Own Package]

  • mi_complete_sigs :: [IfaceCompleteMatch]
     
  • mi_doc_hdr :: Maybe HsDocString

    Module header.

  • mi_decl_docs :: DeclDocMap

    Docs on declarations.

  • mi_arg_docs :: ArgDocMap

    Docs on arguments.

  • mi_final_exts :: !(IfaceBackendExts phase)

    Either () or ModIfaceBackend for a fully instantiated interface.

Instances

Instances details
Binary ModIface 
Instance details

Defined in HscTypes

Methods

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

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

get :: BinHandle -> IO ModIface #

(NFData (IfaceBackendExts phase), NFData (IfaceDeclExts phase)) => NFData (ModIface_ phase) 
Instance details

Defined in HscTypes

Methods

rnf :: ModIface_ phase -> () #

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

Instances details
Show InteractiveImport Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> InteractiveImport -> ShowS #

show :: InteractiveImport -> String #

showList :: [InteractiveImport] -> ShowS #

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

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

Instances details
Data (HsModule GhcPs) 
Instance details

Defined in GHC.Hs

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 :: forall r r'. (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 GHC.Hs

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 :: forall r r'. (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 GHC.Hs

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 :: forall r r'. (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) #

OutputableBndrId p => Outputable (HsModule (GhcPass p)) 
Instance details

Defined in GHC.Hs

Methods

ppr :: HsModule (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsModule (GhcPass p) -> SDoc #

lPatImplicits :: LPat GhcRn -> [(SrcSpan, [Name])] #

hsValBindsImplicits :: forall (idR :: Pass). HsValBindsLR GhcRn (GhcPass idR) -> [(SrcSpan, [Name])] #

lStmtsImplicits :: forall (idR :: Pass) body. [LStmtLR GhcRn (GhcPass idR) (Located (body (GhcPass idR)))] -> [(SrcSpan, [Name])] #

hsDataFamInstBinders :: forall (p :: Pass). DataFamInstDecl (GhcPass p) -> ([Located (IdP (GhcPass p))], [LFieldOcc (GhcPass p)]) #

the SrcLoc returned are for the whole declarations, not just the names

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

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

Collects record pattern-synonym selectors only; the pattern synonym names are collected by collectHsValBinders.

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

See Note [SrcSpan for binders]

hsLTyClDeclBinders :: forall (p :: Pass). Located (TyClDecl (GhcPass p)) -> ([Located (IdP (GhcPass p))], [LFieldOcc (GhcPass p)]) #

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 :: forall (p :: Pass). [LPat (GhcPass p)] -> [IdP (GhcPass p)] #

collectPatBinders :: forall (p :: Pass). LPat (GhcPass p) -> [IdP (GhcPass p)] #

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

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

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

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

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

Used exclusively for the bindings of an instance decl which are all FunBinds

collectHsBindListBinders :: forall (p :: Pass) idR. [LHsBindLR (GhcPass p) idR] -> [IdP (GhcPass p)] #

Same as collectHsBindsBinders, but works over a list of bindings

collectHsBindsBinders :: forall (p :: Pass) idR. LHsBindsLR (GhcPass p) idR -> [IdP (GhcPass p)] #

collectHsBindBinders :: (SrcSpanLess (LPat p) ~ Pat p, HasSrcSpan (LPat p)) => HsBindLR p idR -> [IdP p] #

Collect both Ids and pattern-synonym binders

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

Collect Id binders only, or Ids + pattern synonyms, respectively

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

Collect Id binders only, or Ids + pattern synonyms, respectively

collectLocalBinders :: forall (idL :: Pass) (idR :: Pass). 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 :: forall (p :: Pass). 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

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

Convenience function using mkFunBind. This is for generated bindings only, do not use for user-written code.

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 :: forall (p :: Pass). 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 #

In Name-land, with empty bind_fvs

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

Not infix, with place holders for coercion and free vars

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

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

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

mkLHsCmdWrap :: forall (p :: Pass). HsWrapper -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p) #

mkHsCmdWrap :: forall (p :: Pass). HsWrapper -> HsCmd (GhcPass p) -> HsCmd (GhcPass p) #

mkLHsWrapCo :: forall (id :: Pass). TcCoercionN -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

mkHsWrapCoR :: forall (id :: Pass). TcCoercionR -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkHsWrapCo :: forall (id :: Pass). TcCoercionN -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkHsWrap :: forall (id :: Pass). HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

Avoid (HsWrap co (HsWrap co' _)). See Note [Detecting forced eta expansion] in DsExpr

mkLHsWrap :: forall (id :: Pass). 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] #

Convert TypeSig to ClassOpSig The former is what is parsed, but the latter is what we need in class/instance declarations

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 #

The Big equivalents for the source tuple patterns

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

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

The Big equivalents for the source tuple expressions

missingTupArg :: HsTupArg GhcPs #

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

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

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

nlHsAppKindTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsKind (GhcPass p) -> LHsType (GhcPass p) #

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

nlHsParTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsFunTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsTyVar :: forall (p :: Pass). IdP (GhcPass p) -> LHsType (GhcPass p) #

nlHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

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

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

nlHsIf :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

Note [Rebindable nlHsIf] nlHsIf should generate if-expressions which are NOT subject to RebindableSyntax, so the first field of HsIf is Nothing. (#12080)

nlHsPar :: forall (id :: Pass). 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 #

Wildcard pattern - after renaming

nlWildPat :: LPat GhcPs #

Wildcard pattern - after parsing

nlWildConPat :: DataCon -> LPat GhcPs #

nlNullaryConPat :: forall (p :: Pass). IdP (GhcPass p) -> LPat (GhcPass p) #

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 :: forall (id :: Pass). IdP (GhcPass id) -> [IdP (GhcPass id)] -> LHsExpr (GhcPass id) #

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

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

nlHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

nlLitPat :: HsLit GhcPs -> LPat GhcPs #

nlVarPat :: forall (id :: Pass). IdP (GhcPass id) -> LPat (GhcPass id) #

nlHsIntLit :: forall (p :: Pass). Integer -> LHsExpr (GhcPass p) #

nlHsLit :: forall (p :: Pass). HsLit (GhcPass p) -> LHsExpr (GhcPass p) #

nlHsDataCon :: DataCon -> LHsExpr GhcTc #

NB: Only for LHsExpr **Id**

nlHsVar :: forall (id :: Pass). IdP (GhcPass id) -> LHsExpr (GhcPass id) #

mkHsStringPrimLit :: forall (p :: Pass). FastString -> HsLit (GhcPass p) #

mkHsString :: forall (p :: Pass). String -> HsLit (GhcPass p) #

unqualQuasiQuote :: RdrName #

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

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

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

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

A useful function for building OpApps. The operator is always a variable, and we don't know the fixity yet.

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

emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR #

emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR #

emptyRecStmt :: forall (idL :: Pass) bodyR. StmtLR (GhcPass idL) GhcPs bodyR #

unitRecStmtTc :: RecStmtTc #

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

mkBindStmt :: forall (idL :: Pass) (idR :: Pass) bodyR. XBindStmt (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) ~ NoExtField => LPat (GhcPass idL) -> Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) #

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

mkLastStmt :: forall bodyR (idR :: Pass) (idL :: Pass). 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 :: [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

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

emptyTransStmt :: StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

mkNPlusKPat :: Located RdrName -> Located (HsOverLit GhcPs) -> Pat GhcPs #

mkNPat :: Located (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs) -> Pat GhcPs #

mkHsCmdIf :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p) -> HsCmd (GhcPass p) #

mkHsIf :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) -> HsExpr (GhcPass p) #

mkHsComp :: HsStmtContext Name -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> HsExpr GhcPs #

mkHsDo :: HsStmtContext Name -> [ExprLStmt GhcPs] -> HsExpr GhcPs #

mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs #

mkHsFractional :: FractionalLit -> HsOverLit GhcPs #

mkHsIntegral :: IntegralLit -> HsOverLit GhcPs #

nlParPat :: forall (name :: Pass). LPat (GhcPass name) -> LPat (GhcPass name) #

mkParPat :: forall (name :: Pass). LPat (GhcPass name) -> LPat (GhcPass name) #

mkLHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

Wrap in parens if (hsExprNeedsParens appPrec) says it needs them So 'f x' becomes '(f x)', but '3' stays as '3'

nlHsTyApps :: forall (id :: Pass). IdP (GhcPass id) -> [Type] -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #

nlHsTyApp :: forall (id :: Pass). IdP (GhcPass id) -> [Type] -> LHsExpr (GhcPass id) #

mkHsCaseAlt :: forall (p :: Pass) body. LPat (GhcPass p) -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p))) #

A simple case alternative with a single pattern, no binds, no guards; pre-typechecking

mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr GhcTc -> LHsExpr GhcTc #

mkHsLam :: forall (p :: Pass). XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ NoExtField => [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #

mkHsAppTypes :: LHsExpr GhcRn -> [LHsWcType GhcRn] -> LHsExpr GhcRn #

mkHsAppType :: forall (id :: Pass). NoGhcTc (GhcPass id) ~ GhcRn => LHsExpr (GhcPass id) -> LHsWcType GhcRn -> LHsExpr (GhcPass id) #

mkHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

mkMatchGroup :: XMG name (Located (body name)) ~ NoExtField => Origin -> [LMatch name (Located (body name))] -> MatchGroup name (Located (body name)) #

unguardedRHS :: forall body (p :: Pass). SrcSpan -> Located (body (GhcPass p)) -> [LGRHS (GhcPass p) (Located (body (GhcPass p)))] #

unguardedGRHSs :: forall body (p :: Pass). Located (body (GhcPass p)) -> GRHSs (GhcPass p) (Located (body (GhcPass p))) #

mkSimpleMatch :: forall (p :: Pass) body. HsMatchContext (NameOrRdrName (IdP (GhcPass p))) -> [LPat (GhcPass p)] -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p))) #

mkHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

e => (e)

pprStmtInCtxt :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => HsStmtContext (IdP (GhcPass idL)) -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc #

pprMatchInCtxt :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable (NameOrRdrName (NameOrRdrName (IdP (GhcPass idR)))), Outputable body) => Match (GhcPass idR) body -> SDoc #

matchContextErrString :: Outputable id => HsMatchContext id -> SDoc #

pprStmtContext :: (Outputable id, Outputable (NameOrRdrName id)) => HsStmtContext id -> SDoc #

pprAStmtContext :: (Outputable id, Outputable (NameOrRdrName id)) => HsStmtContext id -> SDoc #

pprMatchContextNoun :: (Outputable (NameOrRdrName id), Outputable id) => HsMatchContext id -> SDoc #

pprMatchContext :: (Outputable (NameOrRdrName id), Outputable id) => HsMatchContext id -> SDoc #

matchSeparator :: HsMatchContext id -> SDoc #

isMonadCompContext :: HsStmtContext id -> Bool #

isMonadFailStmtContext :: HsStmtContext id -> Bool #

Should pattern match failure in a HsStmtContext be desugared using MonadFail?

isComprehensionContext :: HsStmtContext id -> Bool #

isPatSynCtxt :: HsMatchContext id -> Bool #

pp_dotdot :: SDoc #

thTyBrackets :: SDoc -> SDoc #

thBrackets :: SDoc -> SDoc -> SDoc #

pprHsBracket :: forall (p :: Pass). OutputableBndrId p => HsBracket (GhcPass p) -> SDoc #

isTypedBracket :: HsBracket id -> Bool #

ppr_splice :: forall (p :: Pass). OutputableBndrId p => SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc #

ppr_quasi :: OutputableBndr p => p -> p -> FastString -> SDoc #

ppr_splice_decl :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SDoc #

pprPendingSplice :: forall (p :: Pass). OutputableBndrId p => SplicePointName -> LHsExpr (GhcPass p) -> SDoc #

isTypedSplice :: HsSplice id -> Bool #

pprQuals :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body) => [LStmt (GhcPass p) body] -> SDoc #

pprComp :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body) => [LStmt (GhcPass p) body] -> SDoc #

ppr_do_stmts :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc #

pprDo :: forall (p :: Pass) body any. (OutputableBndrId p, Outputable body) => HsStmtContext any -> [LStmt (GhcPass p) body] -> SDoc #

pprBy :: Outputable body => Maybe body -> SDoc #

pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> SDoc #

pprTransformStmt :: forall (p :: Pass). OutputableBndrId p => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc #

pprArg :: forall (idL :: Pass). OutputableBndrId idL => ApplicativeArg (GhcPass idL) -> SDoc #

pprStmt :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc #

pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc #

pprGRHS :: forall (idR :: Pass) body idL. (OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc #

pprGRHSs :: forall (idR :: Pass) body idL. (OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc #

pprMatch :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc #

pprMatches :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc #

hsLMatchPats :: forall (id :: Pass) body. LMatch (GhcPass id) body -> [LPat (GhcPass id)] #

matchGroupArity :: forall (id :: Pass) body. MatchGroup (GhcPass id) body -> Arity #

isSingletonMatchGroup :: [LMatch id body] -> Bool #

Is there only one RHS in this list of matches?

isEmptyMatchGroup :: MatchGroup id body -> Bool #

isInfixMatch :: Match id body -> Bool #

pprCmdArg :: forall (p :: Pass). OutputableBndrId p => HsCmdTop (GhcPass p) -> SDoc #

ppr_cmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc #

ppr_lcmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc #

isQuietHsCmd :: HsCmd id -> Bool #

pprCmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc #

pprLCmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc #

isAtomicHsExpr :: HsExpr id -> Bool #

parenthesizeHsExpr :: forall (p :: Pass). PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #

parenthesizeHsExpr p e checks if hsExprNeedsParens p e is true, and if so, surrounds e with an HsPar. Otherwise, it simply returns e.

hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool #

hsExprNeedsParens p e returns True if the expression e needs parentheses under precedence p.

pprParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> HsExpr (GhcPass p) -> SDoc #

pprParendLExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc #

pprDebugParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc #

pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc #

ppr_apps :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))] -> SDoc #

ppr_infix_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc #

ppr_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc #

ppr_lexpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc #

pprBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc #

isQuietHsExpr :: HsExpr id -> Bool #

tupArgPresent :: LHsTupArg id -> Bool #

unboundVarOcc :: UnboundVar -> OccName #

mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn #

Make a 'SyntaxExpr Name' (the "rn" is because this is used in the renamer), missing its HsWrappers.

mkSyntaxExpr :: forall (p :: Pass). HsExpr (GhcPass p) -> SyntaxExpr (GhcPass p) #

Make a 'SyntaxExpr (HsExpr _)', missing its HsWrappers.

noSyntaxExpr :: forall (p :: Pass). SyntaxExpr (GhcPass p) #

noExpr :: forall (p :: Pass). HsExpr (GhcPass p) #

This is used for rebindable-syntax pieces that are too polymorphic for tcSyntaxOp (trS_fmap and the mzip in ParStmt)

type PostTcExpr = HsExpr GhcTc #

Post-Type checking Expression

PostTcExpr is an evidence expression attached to the syntax tree by the type checker (c.f. postTcType).

type PostTcTable = [(Name, PostTcExpr)] #

Post-Type checking Table

We use a PostTcTable where there are a bunch of pieces of evidence, more than is convenient to keep individually.

type CmdSyntaxTable p = [(Name, HsExpr p)] #

Command Syntax Table (for Arrow syntax)

data UnboundVar #

An unbound variable; used for treating out-of-scope variables as expression holes

Either "x", "y" Plain OutOfScope or "_", "_x" A TrueExprHole

Both forms indicate an out-of-scope variable, but the latter indicates that the user expects it to be out of scope, and just wants GHC to report its type

Constructors

OutOfScope OccName GlobalRdrEnv

An (unqualified) out-of-scope variable, together with the GlobalRdrEnv with respect to which it is unbound

TrueExprHole OccName

A "true" expression hole (_ or _x)

Instances

Instances details
Data UnboundVar 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: UnboundVar -> Constr #

dataTypeOf :: UnboundVar -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable UnboundVar 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: UnboundVar -> SDoc #

pprPrec :: Rational -> UnboundVar -> SDoc #

data RecordConTc #

Extra data fields for a RecordCon, added by the type checker

Constructors

RecordConTc 

Fields

data RecordUpdTc #

Extra data fields for a RecordUpd, added by the type checker

Constructors

RecordUpdTc 

Fields

Instances

Instances details
Data RecordUpdTc 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: RecordUpdTc -> Constr #

dataTypeOf :: RecordUpdTc -> DataType #

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

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

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

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

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

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

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

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

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

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

type LHsTupArg id = Located (HsTupArg id) #

Located Haskell Tuple Argument

HsTupArg is used for tuple sections (,a,) is represented by ExplicitTuple [Missing ty1, Present a, Missing ty3] Which in turn stands for (x:ty1 y:ty2. (x,a,y))

data HsTupArg id #

Haskell Tuple Argument

Constructors

Present (XPresent id) (LHsExpr id)

The argument

Missing (XMissing id)

The argument is missing, but this is its type

XTupArg (XXTupArg id)

Note [Trees that Grow] extension point

Instances

Instances details
(a ~ GhcPass p, ToHie (LHsExpr a), Data (HsTupArg a)) => ToHie (LHsTupArg (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsTupArg (GhcPass p) -> HieM [HieAST Type]

type LHsCmd id = Located (HsCmd id) #

Located Haskell Command (for arrow syntax)

data HsArrAppType #

Haskell Array Application Type

Constructors

HsHigherOrderApp 
HsFirstOrderApp 

Instances

Instances details
Data HsArrAppType 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HsArrAppType -> Constr #

dataTypeOf :: HsArrAppType -> DataType #

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

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

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

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

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

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

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

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

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

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

type LHsCmdTop p = Located (HsCmdTop p) #

Top-level command, introducing a new arrow. This may occur inside a proc (where the stack is empty) or as an argument of a command-forming operator.

Located Haskell Top-level Command

data HsCmdTop p #

Haskell Top-level Command

Constructors

HsCmdTop (XCmdTop p) (LHsCmd p) 
XCmdTop (XXCmdTop p) 

Instances

Instances details
OutputableBndrId p => Outputable (HsCmdTop (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmdTop (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsCmdTop (GhcPass p) -> SDoc #

(ToHie (LHsCmd a), Data (HsCmdTop a)) => ToHie (LHsCmdTop a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsCmdTop a -> HieM [HieAST Type]

data CmdTopTc #

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc) 

type HsRecordBinds p = HsRecFields p (LHsExpr p) #

Haskell Record Bindings

data MatchGroupTc #

Constructors

MatchGroupTc 

Fields

Instances

Instances details
Data MatchGroupTc 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: MatchGroupTc -> Constr #

dataTypeOf :: MatchGroupTc -> DataType #

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

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

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

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

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

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

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

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

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

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

type LMatch id body = Located (Match id body) #

Located Match

May have AnnKeywordId : AnnSemi when in a list

data Match p body #

Constructors

Match 

Fields

XMatch (XXMatch p body) 

Instances

Instances details
(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: Match (GhcPass pr) body -> SDoc #

pprPrec :: Rational -> Match (GhcPass pr) body -> SDoc #

(a ~ GhcPass p, ToHie body, ToHie (HsMatchContext (NameOrRdrName (IdP a))), ToHie (PScoped (LPat a)), ToHie (GRHSs a body), Data (Match a body)) => ToHie (LMatch (GhcPass p) body) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LMatch (GhcPass p) body -> HieM [HieAST Type]

type LGRHS id body = Located (GRHS id body) #

Located Guarded Right-Hand Side

data GRHS p body #

Guarded Right Hand Side.

Constructors

GRHS (XCGRHS p body) [GuardLStmt p] body 
XGRHS (XXGRHS p body) 

Instances

Instances details
(ToHie (Located body), ToHie (RScoped (GuardLStmt a)), Data (GRHS a (Located body))) => ToHie (LGRHS a (Located body)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LGRHS a (Located body) -> HieM [HieAST Type]

type LStmt id body = Located (StmtLR id id body) #

Located do block Statement

type LStmtLR idL idR body = Located (StmtLR idL idR body) #

Located Statement with separate Left and Right id's

type Stmt id body = StmtLR id id body #

do block Statement

type CmdLStmt id = LStmt id (LHsCmd id) #

Command Located Statement

type CmdStmt id = Stmt id (LHsCmd id) #

Command Statement

type ExprLStmt id = LStmt id (LHsExpr id) #

Expression Located Statement

type ExprStmt id = Stmt id (LHsExpr id) #

Expression Statement

type GuardLStmt id = LStmt id (LHsExpr id) #

Guard Located Statement

type GuardStmt id = Stmt id (LHsExpr id) #

Guard Statement

type GhciLStmt id = LStmt id (LHsExpr id) #

Ghci Located Statement

type GhciStmt id = Stmt id (LHsExpr id) #

Ghci Statement

data StmtLR idL idR body #

API Annotations when in qualifier lists or guards - AnnKeywordId : AnnVbar, AnnComma,AnnThen, AnnBy,AnnBy, AnnGroup,AnnUsing

Constructors

LastStmt (XLastStmt idL idR body) body Bool (SyntaxExpr idR) 
BindStmt (XBindStmt idL idR body) (LPat idL) body (SyntaxExpr idR) (SyntaxExpr idR) 
ApplicativeStmt (XApplicativeStmt idL idR body) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))

ApplicativeStmt represents an applicative expression built with <$> and <*>. It is generated by the renamer, and is desugared into the appropriate applicative expression by the desugarer, but it is intended to be invisible in error messages.

For full details, see Note [ApplicativeDo] in RnExpr

BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR) 
LetStmt (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)
ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR) 
TransStmt 

Fields

RecStmt

Fields

XStmtLR (XXStmtLR idL idR body) 

Instances

Instances details
(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (LHsExpr a), ToHie (SigContext (LSig a)), ToHie (RScoped (LHsLocalBinds a)), ToHie (RScoped (ApplicativeArg a)), ToHie (Located body), Data (StmtLR a a (Located body)), Data (StmtLR a a (Located (HsExpr a)))) => ToHie (RScoped (LStmt (GhcPass p) (Located body))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LStmt (GhcPass p) (Located body)) -> HieM [HieAST Type]

(OutputableBndrId pl, OutputableBndrId pr, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc #

pprPrec :: Rational -> StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc #

data RecStmtTc #

Constructors

RecStmtTc 

Fields

data TransForm #

Constructors

ThenForm 
GroupForm 

Instances

Instances details
Data TransForm 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: TransForm -> Constr #

dataTypeOf :: TransForm -> DataType #

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

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

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

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

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

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

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

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

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

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

data ParStmtBlock idL idR #

Parenthesised Statement Block

Constructors

ParStmtBlock (XParStmtBlock idL idR) [ExprLStmt idL] [IdP idR] (SyntaxExpr idR) 
XParStmtBlock (XXParStmtBlock idL idR) 

Instances

Instances details
(Outputable (StmtLR idL idL (LHsExpr idL)), Outputable (XXParStmtBlock idL idR)) => Outputable (ParStmtBlock idL idR) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: ParStmtBlock idL idR -> SDoc #

pprPrec :: Rational -> ParStmtBlock idL idR -> SDoc #

data ApplicativeArg idL #

Applicative Argument

Constructors

ApplicativeArgOne 

Fields

ApplicativeArgMany 

Fields

XApplicativeArg (XXApplicativeArg idL) 

Instances

Instances details
OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: ApplicativeArg (GhcPass idL) -> SDoc #

pprPrec :: Rational -> ApplicativeArg (GhcPass idL) -> SDoc #

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (LHsExpr a), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (StmtLR a a (Located (HsExpr a))), Data (HsLocalBinds a)) => ToHie (RScoped (ApplicativeArg (GhcPass p))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (ApplicativeArg (GhcPass p)) -> HieM [HieAST Type]

data SpliceDecoration #

A splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.

Constructors

HasParens

$( splice ) or $$( splice )

HasDollar

$splice or $$splice

NoParens

bare splice

Instances

Instances details
Eq SpliceDecoration 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

Data SpliceDecoration 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: SpliceDecoration -> Constr #

dataTypeOf :: SpliceDecoration -> DataType #

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

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

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

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

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

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

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

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

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

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

Show SpliceDecoration 
Instance details

Defined in GHC.Hs.Expr

Methods

showsPrec :: Int -> SpliceDecoration -> ShowS #

show :: SpliceDecoration -> String #

showList :: [SpliceDecoration] -> ShowS #

Outputable SpliceDecoration 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: SpliceDecoration -> SDoc #

pprPrec :: Rational -> SpliceDecoration -> SDoc #

newtype ThModFinalizers #

Finalizers produced by a splice with addModFinalizer

See Note [Delaying modFinalizers in untyped splices] in RnSplice. For how this is used.

Constructors

ThModFinalizers [ForeignRef (Q ())] 

Instances

Instances details
Data ThModFinalizers 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: ThModFinalizers -> Constr #

dataTypeOf :: ThModFinalizers -> DataType #

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

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

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

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

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

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

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

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

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

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

data DelayedSplice #

Constructors

DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTcId) 

Instances

Instances details
Data DelayedSplice 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: DelayedSplice -> Constr #

dataTypeOf :: DelayedSplice -> DataType #

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

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

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

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

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

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

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

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

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

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

data HsSplicedThing id #

Haskell Spliced Thing

Values that can result from running a splice.

Constructors

HsSplicedExpr (HsExpr id)

Haskell Spliced Expression

HsSplicedTy (HsType id)

Haskell Spliced Type

HsSplicedPat (Pat id)

Haskell Spliced Pattern

Instances

Instances details
OutputableBndrId p => Outputable (HsSplicedThing (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplicedThing (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsSplicedThing (GhcPass p) -> SDoc #

type SplicePointName = Name #

data PendingRnSplice #

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn) 

Instances

Instances details
Outputable PendingRnSplice 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: PendingRnSplice -> SDoc #

pprPrec :: Rational -> PendingRnSplice -> SDoc #

ToHie PendingRnSplice 
Instance details

Defined in Compat.HieAst

Methods

toHie :: PendingRnSplice -> HieM [HieAST Type]

data UntypedSpliceFlavour #

Constructors

UntypedExpSplice 
UntypedPatSplice 
UntypedTypeSplice 
UntypedDeclSplice 

Instances

Instances details
Data UntypedSpliceFlavour 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: UntypedSpliceFlavour -> Constr #

dataTypeOf :: UntypedSpliceFlavour -> DataType #

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

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

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

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

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

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

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

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

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

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

data PendingTcSplice #

Pending Type-checker Splice

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc) 

Instances

Instances details
Outputable PendingTcSplice 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: PendingTcSplice -> SDoc #

pprPrec :: Rational -> PendingTcSplice -> SDoc #

ToHie PendingTcSplice 
Instance details

Defined in Compat.HieAst

Methods

toHie :: PendingTcSplice -> HieM [HieAST Type]

data HsBracket p #

Haskell Bracket

Constructors

ExpBr (XExpBr p) (LHsExpr p) 
PatBr (XPatBr p) (LPat p) 
DecBrL (XDecBrL p) [LHsDecl p] 
DecBrG (XDecBrG p) (HsGroup p) 
TypBr (XTypBr p) (LHsType p) 
VarBr (XVarBr p) Bool (IdP p) 
TExpBr (XTExpBr p) (LHsExpr p) 
XBracket (XXBracket p) 

Instances

Instances details
OutputableBndrId p => Outputable (HsBracket (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsBracket (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsBracket (GhcPass p) -> SDoc #

ToHie (HsBracket a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsBracket a -> HieM [HieAST Type]

data ArithSeqInfo id #

Arithmetic Sequence Information

Constructors

From (LHsExpr id) 
FromThen (LHsExpr id) (LHsExpr id) 
FromTo (LHsExpr id) (LHsExpr id) 
FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id) 

Instances

Instances details
OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: ArithSeqInfo (GhcPass p) -> SDoc #

pprPrec :: Rational -> ArithSeqInfo (GhcPass p) -> SDoc #

ToHie (LHsExpr a) => ToHie (ArithSeqInfo a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: ArithSeqInfo a -> HieM [HieAST Type]

data HsMatchContext id #

Haskell Match Context

Context of a pattern match. This is more subtle than it would seem. See Note [Varieties of pattern matches].

Constructors

FunRhs

A pattern matching on an argument of a function binding

Fields

LambdaExpr

Patterns of a lambda

CaseAlt

Patterns and guards on a case alternative

IfAlt

Guards of a multi-way if alternative

ProcExpr

Patterns of a proc

PatBindRhs

A pattern binding eg [y] <- e = e

PatBindGuards

Guards of pattern bindings, e.g., (Just b) | Just _ <- x = e | otherwise = e'

RecUpd

Record update [used only in DsExpr to tell matchWrapper what sort of runtime error message to generate]

StmtCtxt (HsStmtContext id)

Pattern of a do-stmt, list comprehension, pattern guard, etc

ThPatSplice

A Template Haskell pattern splice

ThPatQuote

A Template Haskell pattern quotation [p| (a,b) |]

PatSyn

A pattern synonym declaration

Instances

Instances details
Functor HsMatchContext 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

Data id => Data (HsMatchContext id) 
Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMatchContext id -> c (HsMatchContext id) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMatchContext id) #

toConstr :: HsMatchContext id -> Constr #

dataTypeOf :: HsMatchContext id -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsMatchContext id -> HsMatchContext id #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMatchContext id -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMatchContext id -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMatchContext id -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMatchContext id -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id) #

OutputableBndr id => Outputable (HsMatchContext id) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsMatchContext id -> SDoc #

pprPrec :: Rational -> HsMatchContext id -> SDoc #

ToHie (Context (Located a)) => ToHie (HsMatchContext a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsMatchContext a -> HieM [HieAST Type]

data HsStmtContext id #

Haskell Statement Context. It expects to be parameterised with one of RdrName, Name or Id

Constructors

ListComp 
MonadComp 
DoExpr

do { ... }

MDoExpr

mdo { ... } ie recursive do-expression

ArrowExpr

do-notation in an arrow-command context

GhciStmtCtxt

A command-line Stmt in GHCi pat <- rhs

PatGuard (HsMatchContext id)

Pattern guard for specified thing

ParStmtCtxt (HsStmtContext id)

A branch of a parallel stmt

TransStmtCtxt (HsStmtContext id)

A branch of a transform stmt

Instances

Instances details
Functor HsStmtContext 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

Data id => Data (HsStmtContext id) 
Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsStmtContext id -> c (HsStmtContext id) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsStmtContext id) #

toConstr :: HsStmtContext id -> Constr #

dataTypeOf :: HsStmtContext id -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsStmtContext id -> HsStmtContext id #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmtContext id -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmtContext id -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsStmtContext id -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsStmtContext id -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id) #

(Outputable (GhcPass p), Outputable (NameOrRdrName (GhcPass p))) => Outputable (HsStmtContext (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsStmtContext (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsStmtContext (GhcPass p) -> SDoc #

ToHie (HsMatchContext a) => ToHie (HsStmtContext a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsStmtContext a -> HieM [HieAST Type]

roleAnnotDeclName :: forall (p :: Pass). RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p) #

annProvenanceName_maybe :: AnnProvenance name -> Maybe name #

docDeclDoc :: DocDecl -> HsDocString #

pprFullRuleName :: Located (SourceText, RuleName) -> SDoc #

collectRuleBndrSigTys :: [RuleBndr pass] -> [LHsSigWcType pass] #

flattenRuleDecls :: [LRuleDecls pass] -> [LRuleDecl pass] #

mapDerivStrategy :: forall p (pass :: Pass). p ~ GhcPass pass => (XViaStrategy p -> XViaStrategy p) -> DerivStrategy p -> DerivStrategy p #

Map over the via type if dealing with ViaStrategy. Otherwise, return the DerivStrategy unchanged.

foldDerivStrategy :: forall p (pass :: Pass) r. p ~ GhcPass pass => r -> (XViaStrategy p -> r) -> DerivStrategy p -> r #

Eliminate a DerivStrategy.

derivStrategyName :: DerivStrategy a -> SDoc #

A short description of a DerivStrategy'.

instDeclDataFamInsts :: forall (p :: Pass). [LInstDecl (GhcPass p)] -> [DataFamInstDecl (GhcPass p)] #

pprHsFamInstLHS :: forall (p :: Pass). OutputableBndrId p => IdP (GhcPass p) -> Maybe [LHsTyVarBndr (GhcPass p)] -> HsTyPats (GhcPass p) -> LexicalFixity -> LHsContext (GhcPass p) -> SDoc #

pprDataFamInstFlavour :: forall (p :: Pass). DataFamInstDecl (GhcPass p) -> SDoc #

pprTyFamInstDecl :: forall (p :: Pass). OutputableBndrId p => TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc #

hsConDeclTheta :: Maybe (LHsContext pass) -> [LHsType pass] #

hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass] #

getConArgs :: ConDecl pass -> HsConDeclDetails pass #

getConNames :: forall (p :: Pass). ConDecl (GhcPass p) -> [Located (IdP (GhcPass p))] #

newOrDataToFlavour :: NewOrData -> TyConFlavour #

Convert a NewOrData to a TyConFlavour

standaloneKindSigName :: forall (p :: Pass). StandaloneKindSig (GhcPass p) -> IdP (GhcPass p) #

resultVariableName :: forall (a :: Pass). FamilyResultSig (GhcPass a) -> Maybe (IdP (GhcPass a)) #

Maybe return name of the result type variable

famResultKindSignature :: forall (p :: Pass). FamilyResultSig (GhcPass p) -> Maybe (LHsKind (GhcPass p)) #

familyDeclName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> IdP (GhcPass p) #

familyDeclLName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> Located (IdP (GhcPass p)) #

tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass] #

tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass] #

tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass] #

tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass] #

pprTyClDeclFlavour :: forall (p :: Pass). TyClDecl (GhcPass p) -> SDoc #

hsDeclHasCusk :: TyClDecl GhcRn -> Bool #

Does this declaration have a complete, user-supplied kind signature? See Note [CUSKs: complete user-supplied kind signatures]

countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int) #

tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass #

tcdName :: forall (p :: Pass). TyClDecl (GhcPass p) -> IdP (GhcPass p) #

tyClDeclLName :: forall (p :: Pass). TyClDecl (GhcPass p) -> Located (IdP (GhcPass p)) #

tyFamInstDeclLName :: forall (p :: Pass). TyFamInstDecl (GhcPass p) -> Located (IdP (GhcPass p)) #

tyFamInstDeclName :: forall (p :: Pass). TyFamInstDecl (GhcPass p) -> IdP (GhcPass p) #

isDataFamilyDecl :: TyClDecl pass -> Bool #

data family declaration

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool #

closed type family info

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool #

open type family info

isTypeFamilyDecl :: TyClDecl pass -> Bool #

type family declaration

isFamilyDecl :: TyClDecl pass -> Bool #

type/data family declaration

isClassDecl :: TyClDecl pass -> Bool #

type class

isSynDecl :: TyClDecl pass -> Bool #

type or type instance declaration

isDataDecl :: TyClDecl pass -> Bool #

True = argument is a data/newtype declaration.

appendGroups :: forall (p :: Pass). HsGroup (GhcPass p) -> HsGroup (GhcPass p) -> HsGroup (GhcPass p) #

hsGroupInstDecls :: HsGroup id -> [LInstDecl id] #

emptyRnGroup :: forall (p :: Pass). HsGroup (GhcPass p) #

emptyRdrGroup :: forall (p :: Pass). HsGroup (GhcPass p) #

type LHsDecl p #

Arguments

 = Located (HsDecl p)

When in a list this may have

data HsDecl p #

A Haskell Declaration

Constructors

TyClD (XTyClD p) (TyClDecl p)

Type or Class Declaration

InstD (XInstD p) (InstDecl p)

Instance declaration

DerivD (XDerivD p) (DerivDecl p)

Deriving declaration

ValD (XValD p) (HsBind p)

Value declaration

SigD (XSigD p) (Sig p)

Signature declaration

KindSigD (XKindSigD p) (StandaloneKindSig p)

Standalone kind signature

DefD (XDefD p) (DefaultDecl p)

'default' declaration

ForD (XForD p) (ForeignDecl p)

Foreign declaration

WarningD (XWarningD p) (WarnDecls p)

Warning declaration

AnnD (XAnnD p) (AnnDecl p)

Annotation declaration

RuleD (XRuleD p) (RuleDecls p)

Rule declaration

SpliceD (XSpliceD p) (SpliceDecl p)

Splice declaration (Includes quasi-quotes)

DocD (XDocD p) DocDecl

Documentation comment declaration

RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)

Role annotation declaration

XHsDecl (XXHsDecl p) 

Instances

Instances details
OutputableBndrId p => Outputable (HsDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsDecl (GhcPass p) -> SDoc #

data HsGroup p #

Haskell Group

A HsDecl is categorised into a HsGroup before being fed to the renamer.

Constructors

HsGroup 

Fields

XHsGroup (XXHsGroup p) 

Instances

Instances details
OutputableBndrId p => Outputable (HsGroup (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsGroup (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsGroup (GhcPass p) -> SDoc #

type LSpliceDecl pass = Located (SpliceDecl pass) #

Located Splice Declaration

data SpliceDecl p #

Splice Declaration

Constructors

SpliceDecl (XSpliceDecl p) (Located (HsSplice p)) SpliceExplicitFlag 
XSpliceDecl (XXSpliceDecl p) 

Instances

Instances details
OutputableBndrId p => Outputable (SpliceDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: SpliceDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> SpliceDecl (GhcPass p) -> SDoc #

ToHie (LSpliceDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LSpliceDecl GhcRn -> HieM [HieAST Type]

type LTyClDecl pass = Located (TyClDecl pass) #

Located Declaration of a Type or Class

data TyClDecl pass #

A type or class declaration.

Constructors

FamDecl
type/data family T :: *->*

Fields

SynDecl

type declaration

Fields

DataDecl

data declaration

Fields

ClassDecl

Fields

XTyClDecl (XXTyClDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (TyClDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: TyClDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> TyClDecl (GhcPass p) -> SDoc #

ToHie (LTyClDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LTyClDecl GhcRn -> HieM [HieAST Type]

type LHsFunDep pass = Located (FunDep (Located (IdP pass))) #

data DataDeclRn #

Constructors

DataDeclRn 

Fields

Instances

Instances details
Data DataDeclRn 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: DataDeclRn -> Constr #

dataTypeOf :: DataDeclRn -> DataType #

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

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

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

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

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

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

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

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

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

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

data TyClGroup pass #

Type or Class Group

Constructors

TyClGroup 

Fields

XTyClGroup (XXTyClGroup pass) 

Instances

Instances details
OutputableBndrId p => Outputable (TyClGroup (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: TyClGroup (GhcPass p) -> SDoc #

pprPrec :: Rational -> TyClGroup (GhcPass p) -> SDoc #

ToHie (TyClGroup GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TyClGroup GhcRn -> HieM [HieAST Type]

type LFamilyResultSig pass = Located (FamilyResultSig pass) #

Located type Family Result Signature

data FamilyResultSig pass #

type Family Result Signature

Constructors

NoSig (XNoSig pass)
KindSig (XCKindSig pass) (LHsKind pass)
TyVarSig (XTyVarSig pass) (LHsTyVarBndr pass)
XFamilyResultSig (XXFamilyResultSig pass) 

Instances

Instances details
ToHie (RScoped (LFamilyResultSig GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LFamilyResultSig GhcRn) -> HieM [HieAST Type]

type LFamilyDecl pass = Located (FamilyDecl pass) #

Located type Family Declaration

data FamilyDecl pass #

type Family Declaration

Constructors

FamilyDecl 

Fields

XFamilyDecl (XXFamilyDecl pass)

Instances

Instances details
OutputableBndrId p => Outputable (FamilyDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> FamilyDecl (GhcPass p) -> SDoc #

ToHie (LFamilyDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LFamilyDecl GhcRn -> HieM [HieAST Type]

type LInjectivityAnn pass = Located (InjectivityAnn pass) #

Located Injectivity Annotation

data InjectivityAnn pass #

If the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:

type family Foo a b c = r | r -> a c where ...

This will be represented as "InjectivityAnn r [a, c]"

Constructors

InjectivityAnn (Located (IdP pass)) [Located (IdP pass)]

Instances

Instances details
ToHie (LInjectivityAnn GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LInjectivityAnn GhcRn -> HieM [HieAST Type]

data FamilyInfo pass #

Constructors

DataFamily 
OpenTypeFamily 
ClosedTypeFamily (Maybe [LTyFamInstEqn pass])

Nothing if we're in an hs-boot file and the user said "type family Foo x where .."

Instances

Instances details
Outputable (FamilyInfo pass) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyInfo pass -> SDoc #

pprPrec :: Rational -> FamilyInfo pass -> SDoc #

ToHie (FamilyInfo GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: FamilyInfo GhcRn -> HieM [HieAST Type]

data HsDataDefn pass #

Haskell Data type Definition

Constructors

HsDataDefn

Declares a data type or newtype, giving its constructors data/newtype T a = constrs data/newtype instance T [a] = constrs

Fields

XHsDataDefn (XXHsDataDefn pass) 

Instances

Instances details
OutputableBndrId p => Outputable (HsDataDefn (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsDataDefn (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsDataDefn (GhcPass p) -> SDoc #

HasLoc (HsDataDefn GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

loc :: HsDataDefn GhcRn -> SrcSpan

ToHie (HsDataDefn GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsDataDefn GhcRn -> HieM [HieAST Type]

type HsDeriving pass #

Arguments

 = Located [LHsDerivingClause pass]

The optional deriving clauses of a data declaration. Clauses is plural because one can specify multiple deriving clauses using the -XDerivingStrategies language extension.

The list of LHsDerivingClauses corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.

Haskell Deriving clause

type LHsDerivingClause pass = Located (HsDerivingClause pass) #

data HsDerivingClause pass #

A single deriving clause of a data declaration.

Constructors

HsDerivingClause 

Fields

XHsDerivingClause (XXHsDerivingClause pass) 

Instances

Instances details
OutputableBndrId p => Outputable (HsDerivingClause (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsDerivingClause (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsDerivingClause (GhcPass p) -> SDoc #

ToHie (HsDeriving GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsDeriving GhcRn -> HieM [HieAST Type]

ToHie (LHsDerivingClause GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsDerivingClause GhcRn -> HieM [HieAST Type]

type LStandaloneKindSig pass = Located (StandaloneKindSig pass) #

Located Standalone Kind Signature

data StandaloneKindSig pass #

Constructors

StandaloneKindSig (XStandaloneKindSig pass) (Located (IdP pass)) (LHsSigType pass) 
XStandaloneKindSig (XXStandaloneKindSig pass) 

Instances

Instances details
OutputableBndrId p => Outputable (StandaloneKindSig (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: StandaloneKindSig (GhcPass p) -> SDoc #

pprPrec :: Rational -> StandaloneKindSig (GhcPass p) -> SDoc #

ToHie (LStandaloneKindSig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LStandaloneKindSig GhcRn -> HieM [HieAST Type]

ToHie (StandaloneKindSig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: StandaloneKindSig GhcRn -> HieM [HieAST Type]

data NewOrData #

Constructors

NewType
newtype Blah ...
DataType
data Blah ...

Instances

Instances details
Eq NewOrData 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

Data NewOrData 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: NewOrData -> Constr #

dataTypeOf :: NewOrData -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable NewOrData 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: NewOrData -> SDoc #

pprPrec :: Rational -> NewOrData -> SDoc #

type LConDecl pass #

Arguments

 = Located (ConDecl pass)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

Located data Constructor Declaration

data ConDecl pass #

data T b = forall a. Eq a => MkT a b
  MkT :: forall b a. Eq a => MkT a b

data T b where
     MkT1 :: Int -> T Int

data T = Int MkT Int
       | MkT2

data T a where
     Int MkT Int :: T Int

data Constructor Declaration

Constructors

ConDeclGADT 

Fields

ConDeclH98 

Fields

XConDecl (XXConDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (ConDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ConDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> ConDecl (GhcPass p) -> SDoc #

ToHie (LConDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LConDecl GhcRn -> HieM [HieAST Type]

type HsConDeclDetails pass = HsConDetails (LBangType pass) (Located [LConDeclField pass]) #

Haskell data Constructor Declaration Details

type LTyFamInstEqn pass #

Arguments

 = Located (TyFamInstEqn pass)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type HsTyPats pass = [LHsTypeArg pass] #

Haskell Type Patterns

type TyFamInstEqn pass = FamInstEqn pass (LHsType pass) #

Type Family Instance Equation

type TyFamDefltDecl = TyFamInstDecl #

Type family default declarations. A convenient synonym for TyFamInstDecl. See Note [Type family instance declarations in HsSyn].

type LTyFamDefltDecl pass = Located (TyFamDefltDecl pass) #

Located type family default declarations.

type LTyFamInstDecl pass = Located (TyFamInstDecl pass) #

Located Type Family Instance Declaration

newtype TyFamInstDecl pass #

Type Family Instance Declaration

Constructors

TyFamInstDecl

Fields

Instances

Instances details
OutputableBndrId p => Outputable (TyFamInstDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: TyFamInstDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> TyFamInstDecl (GhcPass p) -> SDoc #

ToHie (LTyFamInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LTyFamInstDecl GhcRn -> HieM [HieAST Type]

type LDataFamInstDecl pass = Located (DataFamInstDecl pass) #

Located Data Family Instance Declaration

newtype DataFamInstDecl pass #

Data Family Instance Declaration

Constructors

DataFamInstDecl

Fields

Instances

Instances details
OutputableBndrId p => Outputable (DataFamInstDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DataFamInstDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> DataFamInstDecl (GhcPass p) -> SDoc #

ToHie (LDataFamInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDataFamInstDecl GhcRn -> HieM [HieAST Type]

type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs) #

Located Family Instance Equation

type FamInstEqn pass rhs #

Arguments

 = HsImplicitBndrs pass (FamEqn pass rhs)

Here, the pats are type patterns (with kind and type bndrs). See Note [Family instance declaration binders]

Family Instance Equation

data FamEqn pass rhs #

Family Equation

One equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]

Constructors

FamEqn

Fields

XFamEqn (XXFamEqn pass rhs) 

Instances

Instances details
(ToHie rhs, HasLoc rhs) => ToHie (TScoped (FamEqn GhcRn rhs)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (FamEqn GhcRn rhs) -> HieM [HieAST Type]

HasLoc a => HasLoc (FamEqn s a) 
Instance details

Defined in Compat.HieAst

Methods

loc :: FamEqn s a -> SrcSpan

(ToHie rhs, HasLoc rhs) => ToHie (FamEqn GhcRn rhs) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: FamEqn GhcRn rhs -> HieM [HieAST Type]

type LClsInstDecl pass = Located (ClsInstDecl pass) #

Located Class Instance Declaration

data ClsInstDecl pass #

Class Instance Declaration

Constructors

ClsInstDecl

Fields

XClsInstDecl (XXClsInstDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (ClsInstDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ClsInstDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> ClsInstDecl (GhcPass p) -> SDoc #

ToHie (LClsInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LClsInstDecl GhcRn -> HieM [HieAST Type]

type LInstDecl pass = Located (InstDecl pass) #

Located Instance Declaration

data InstDecl pass #

Instance Declaration

Constructors

ClsInstD 

Fields

DataFamInstD 

Fields

TyFamInstD 

Fields

XInstDecl (XXInstDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (InstDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: InstDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> InstDecl (GhcPass p) -> SDoc #

ToHie (LInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LInstDecl GhcRn -> HieM [HieAST Type]

type LDerivDecl pass = Located (DerivDecl pass) #

Located stand-alone 'deriving instance' declaration

data DerivDecl pass #

Stand-alone 'deriving instance' declaration

Constructors

DerivDecl 

Fields

XDerivDecl (XXDerivDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (DerivDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DerivDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> DerivDecl (GhcPass p) -> SDoc #

ToHie (LDerivDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDerivDecl GhcRn -> HieM [HieAST Type]

type LDerivStrategy pass = Located (DerivStrategy pass) #

A Located DerivStrategy.

data DerivStrategy pass #

Which technique the user explicitly requested when deriving an instance.

Constructors

StockStrategy

GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., Eq, Show, Functor when -XDeriveFunctor is enabled, etc.)

AnyclassStrategy
-XDeriveAnyClass
NewtypeStrategy
-XGeneralizedNewtypeDeriving
ViaStrategy (XViaStrategy pass)
-XDerivingVia

Instances

Instances details
OutputableBndrId p => Outputable (DerivStrategy (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DerivStrategy (GhcPass p) -> SDoc #

pprPrec :: Rational -> DerivStrategy (GhcPass p) -> SDoc #

ToHie (Located (DerivStrategy GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (DerivStrategy GhcRn) -> HieM [HieAST Type]

type LDefaultDecl pass = Located (DefaultDecl pass) #

Located Default Declaration

data DefaultDecl pass #

Default Declaration

Constructors

DefaultDecl (XCDefaultDecl pass) [LHsType pass]
XDefaultDecl (XXDefaultDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (DefaultDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DefaultDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> DefaultDecl (GhcPass p) -> SDoc #

ToHie (LDefaultDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDefaultDecl GhcRn -> HieM [HieAST Type]

type LForeignDecl pass = Located (ForeignDecl pass) #

Located Foreign Declaration

data ForeignDecl pass #

Foreign Declaration

Constructors

ForeignImport 

Fields

ForeignExport

Fields

XForeignDecl (XXForeignDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (ForeignDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> ForeignDecl (GhcPass p) -> SDoc #

ToHie (LForeignDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LForeignDecl GhcRn -> HieM [HieAST Type]

data ForeignImport #

Constructors

CImport (Located CCallConv) (Located Safety) (Maybe Header) CImportSpec (Located SourceText) 

Instances

Instances details
Data ForeignImport 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: ForeignImport -> Constr #

dataTypeOf :: ForeignImport -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable ForeignImport 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignImport -> SDoc #

pprPrec :: Rational -> ForeignImport -> SDoc #

ToHie ForeignImport 
Instance details

Defined in Compat.HieAst

Methods

toHie :: ForeignImport -> HieM [HieAST Type]

data CImportSpec #

Constructors

CLabel CLabelString 
CFunction CCallTarget 
CWrapper 

Instances

Instances details
Data CImportSpec 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: CImportSpec -> Constr #

dataTypeOf :: CImportSpec -> DataType #

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

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

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

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

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

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

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

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

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

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

data ForeignExport #

Constructors

CExport (Located CExportSpec) (Located SourceText) 

Instances

Instances details
Data ForeignExport 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: ForeignExport -> Constr #

dataTypeOf :: ForeignExport -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable ForeignExport 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignExport -> SDoc #

pprPrec :: Rational -> ForeignExport -> SDoc #

ToHie ForeignExport 
Instance details

Defined in Compat.HieAst

Methods

toHie :: ForeignExport -> HieM [HieAST Type]

type LRuleDecls pass = Located (RuleDecls pass) #

Located Rule Declarations

data RuleDecls pass #

Rule Declarations

Constructors

HsRules 

Fields

XRuleDecls (XXRuleDecls pass) 

Instances

Instances details
OutputableBndrId p => Outputable (RuleDecls (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecls (GhcPass p) -> SDoc #

pprPrec :: Rational -> RuleDecls (GhcPass p) -> SDoc #

ToHie (LRuleDecls GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRuleDecls GhcRn -> HieM [HieAST Type]

type LRuleDecl pass = Located (RuleDecl pass) #

Located Rule Declaration

data RuleDecl pass #

Rule Declaration

Constructors

HsRule

Fields

XRuleDecl (XXRuleDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (RuleDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> RuleDecl (GhcPass p) -> SDoc #

ToHie (LRuleDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRuleDecl GhcRn -> HieM [HieAST Type]

data HsRuleRn #

Constructors

HsRuleRn NameSet NameSet 

Instances

Instances details
Data HsRuleRn 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: HsRuleRn -> Constr #

dataTypeOf :: HsRuleRn -> DataType #

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

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

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

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

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

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

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

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

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

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

type LRuleBndr pass = Located (RuleBndr pass) #

Located Rule Binder

data RuleBndr pass #

Rule Binder

Constructors

RuleBndr (XCRuleBndr pass) (Located (IdP pass)) 
RuleBndrSig (XRuleBndrSig pass) (Located (IdP pass)) (LHsSigWcType pass) 
XRuleBndr (XXRuleBndr pass)

Instances

Instances details
OutputableBndrId p => Outputable (RuleBndr (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleBndr (GhcPass p) -> SDoc #

pprPrec :: Rational -> RuleBndr (GhcPass p) -> SDoc #

ToHie (RScoped (LRuleBndr GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LRuleBndr GhcRn) -> HieM [HieAST Type]

type LDocDecl = Located DocDecl #

Located Documentation comment Declaration

data DocDecl #

Documentation comment Declaration

Constructors

DocCommentNext HsDocString 
DocCommentPrev HsDocString 
DocCommentNamed String HsDocString 
DocGroup Int HsDocString 

Instances

Instances details
Data DocDecl 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: DocDecl -> Constr #

dataTypeOf :: DocDecl -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable DocDecl 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DocDecl -> SDoc #

pprPrec :: Rational -> DocDecl -> SDoc #

type LWarnDecls pass = Located (WarnDecls pass) #

Located Warning Declarations

data WarnDecls pass #

Warning pragma Declarations

Constructors

Warnings 

Fields

XWarnDecls (XXWarnDecls pass) 

Instances

Instances details
OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecls (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecls (GhcPass p) -> SDoc #

pprPrec :: Rational -> WarnDecls (GhcPass p) -> SDoc #

ToHie (LWarnDecls GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LWarnDecls GhcRn -> HieM [HieAST Type]

type LWarnDecl pass = Located (WarnDecl pass) #

Located Warning pragma Declaration

data WarnDecl pass #

Warning pragma Declaration

Constructors

Warning (XWarning pass) [Located (IdP pass)] WarningTxt 
XWarnDecl (XXWarnDecl pass) 

Instances

Instances details
OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> WarnDecl (GhcPass p) -> SDoc #

ToHie (LWarnDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LWarnDecl GhcRn -> HieM [HieAST Type]

type LAnnDecl pass = Located (AnnDecl pass) #

Located Annotation Declaration

data AnnDecl pass #

Annotation Declaration

Constructors

HsAnnotation (XHsAnnotation pass) SourceText (AnnProvenance (IdP pass)) (Located (HsExpr pass))
XAnnDecl (XXAnnDecl pass) 

Instances

Instances details
OutputableBndrId p => Outputable (AnnDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: AnnDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> AnnDecl (GhcPass p) -> SDoc #

ToHie (LAnnDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LAnnDecl GhcRn -> HieM [HieAST Type]

data AnnProvenance name #

Annotation Provenance

Constructors

ValueAnnProvenance (Located name) 
TypeAnnProvenance (Located name) 
ModuleAnnProvenance 

Instances

Instances details
Functor AnnProvenance 
Instance details

Defined in GHC.Hs.Decls

Methods

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

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

Foldable AnnProvenance 
Instance details

Defined in GHC.Hs.Decls

Methods

fold :: Monoid m => AnnProvenance m -> m #

foldMap :: Monoid m => (a -> m) -> AnnProvenance a -> m #

foldMap' :: Monoid m => (a -> m) -> AnnProvenance a -> m #

foldr :: (a -> b -> b) -> b -> AnnProvenance a -> b #

foldr' :: (a -> b -> b) -> b -> AnnProvenance a -> b #

foldl :: (b -> a -> b) -> b -> AnnProvenance a -> b #

foldl' :: (b -> a -> b) -> b -> AnnProvenance a -> b #

foldr1 :: (a -> a -> a) -> AnnProvenance a -> a #

foldl1 :: (a -> a -> a) -> AnnProvenance a -> a #

toList :: AnnProvenance a -> [a] #

null :: AnnProvenance a -> Bool #

length :: AnnProvenance a -> Int #

elem :: Eq a => a -> AnnProvenance a -> Bool #

maximum :: Ord a => AnnProvenance a -> a #

minimum :: Ord a => AnnProvenance a -> a #

sum :: Num a => AnnProvenance a -> a #

product :: Num a => AnnProvenance a -> a #

Traversable AnnProvenance 
Instance details

Defined in GHC.Hs.Decls

Methods

traverse :: Applicative f => (a -> f b) -> AnnProvenance a -> f (AnnProvenance b) #

sequenceA :: Applicative f => AnnProvenance (f a) -> f (AnnProvenance a) #

mapM :: Monad m => (a -> m b) -> AnnProvenance a -> m (AnnProvenance b) #

sequence :: Monad m => AnnProvenance (m a) -> m (AnnProvenance a) #

Data pass => Data (AnnProvenance pass) 
Instance details

Defined in GHC.Hs.Decls

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance pass -> c (AnnProvenance pass) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance pass) #

toConstr :: AnnProvenance pass -> Constr #

dataTypeOf :: AnnProvenance pass -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> AnnProvenance pass -> AnnProvenance pass #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance pass -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance pass -> r #

gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance pass -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance pass -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass) #

ToHie (Context (Located a)) => ToHie (AnnProvenance a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: AnnProvenance a -> HieM [HieAST Type]

type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass) #

Located Role Annotation Declaration

data RoleAnnotDecl pass #

Role Annotation Declaration

Constructors

RoleAnnotDecl (XCRoleAnnotDecl pass) (Located (IdP pass)) [Located (Maybe Role)]
XRoleAnnotDecl (XXRoleAnnotDecl pass) 

Instances

Instances details
OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RoleAnnotDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> RoleAnnotDecl (GhcPass p) -> SDoc #

ToHie (LRoleAnnotDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRoleAnnotDecl GhcRn -> HieM [HieAST Type]

collectEvVarsPat :: Pat GhcTc -> Bag EvVar #

collectEvVarsPats :: [Pat GhcTc] -> Bag EvVar #

parenthesizePat :: forall (p :: Pass). PprPrec -> LPat (GhcPass p) -> LPat (GhcPass p) #

parenthesizePat p pat checks if patNeedsParens p pat is true, and if so, surrounds pat with a ParPat. Otherwise, it simply returns pat.

patNeedsParens :: PprPrec -> Pat p -> Bool #

patNeedsParens p pat returns True if the pattern pat needs parentheses under precedence p.

isIrrefutableHsPat :: forall (p :: Pass). OutputableBndrId p => LPat (GhcPass p) -> Bool #

looksLazyPatBind :: forall (p :: Pass). HsBind (GhcPass p) -> Bool #

isBangedLPat :: forall (p :: Pass). LPat (GhcPass p) -> Bool #

mkCharLitPat :: forall (p :: Pass). SourceText -> Char -> OutPat (GhcPass p) #

mkNilPat :: forall (p :: Pass). Type -> OutPat (GhcPass p) #

mkPrefixConPat :: forall (p :: Pass). DataCon -> [OutPat (GhcPass p)] -> [Type] -> OutPat (GhcPass p) #

pprConArgs :: forall (p :: Pass). OutputableBndrId p => HsConPatDetails (GhcPass p) -> SDoc #

pprParendLPat :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LPat (GhcPass p) -> SDoc #

hsRecUpdFieldOcc :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> LFieldOcc GhcTc #

hsRecUpdFieldId :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> Located Id #

hsRecUpdFieldRdr :: forall (p :: Pass). HsRecUpdField (GhcPass p) -> Located RdrName #

hsRecFieldId :: HsRecField GhcTc arg -> Located Id #

hsRecFieldSel :: HsRecField pass arg -> Located (XCFieldOcc pass) #

hsRecFieldsArgs :: HsRecFields p arg -> [arg] #

hsRecFields :: HsRecFields p arg -> [XCFieldOcc p] #

hsConPatArgs :: HsConPatDetails p -> [LPat p] #

type InPat p = LPat p #

type OutPat p = LPat p #

data ListPatTc #

Constructors

ListPatTc Type (Maybe (Type, SyntaxExpr GhcTc)) 

type HsConPatDetails p = HsConDetails (LPat p) (HsRecFields p (LPat p)) #

Haskell Constructor Pattern Details

data HsRecFields p arg #

Haskell Record Fields

HsRecFields is used only for patterns and expressions (not data type declarations)

Constructors

HsRecFields 

Fields

Instances

Instances details
Functor (HsRecFields p) 
Instance details

Defined in GHC.Hs.Pat

Methods

fmap :: (a -> b) -> HsRecFields p a -> HsRecFields p b #

(<$) :: a -> HsRecFields p b -> HsRecFields p a #

Foldable (HsRecFields p) 
Instance details

Defined in GHC.Hs.Pat

Methods

fold :: Monoid m => HsRecFields p m -> m #

foldMap :: Monoid m => (a -> m) -> HsRecFields p a -> m #

foldMap' :: Monoid m => (a -> m) -> HsRecFields p a -> m #

foldr :: (a -> b -> b) -> b -> HsRecFields p a -> b #

foldr' :: (a -> b -> b) -> b -> HsRecFields p a -> b #

foldl :: (b -> a -> b) -> b -> HsRecFields p a -> b #

foldl' :: (b -> a -> b) -> b -> HsRecFields p a -> b #

foldr1 :: (a -> a -> a) -> HsRecFields p a -> a #

foldl1 :: (a -> a -> a) -> HsRecFields p a -> a #

toList :: HsRecFields p a -> [a] #

null :: HsRecFields p a -> Bool #

length :: HsRecFields p a -> Int #

elem :: Eq a => a -> HsRecFields p a -> Bool #

maximum :: Ord a => HsRecFields p a -> a #

minimum :: Ord a => HsRecFields p a -> a #

sum :: Num a => HsRecFields p a -> a #

product :: Num a => HsRecFields p a -> a #

Traversable (HsRecFields p) 
Instance details

Defined in GHC.Hs.Pat

Methods

traverse :: Applicative f => (a -> f b) -> HsRecFields p a -> f (HsRecFields p b) #

sequenceA :: Applicative f => HsRecFields p (f a) -> f (HsRecFields p a) #

mapM :: Monad m => (a -> m b) -> HsRecFields p a -> m (HsRecFields p b) #

sequence :: Monad m => HsRecFields p (m a) -> m (HsRecFields p a) #

ToHie (RContext (LHsRecField a arg)) => ToHie (RContext (HsRecFields a arg)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RContext (HsRecFields a arg) -> HieM [HieAST Type]

Outputable arg => Outputable (HsRecFields p arg) 
Instance details

Defined in GHC.Hs.Pat

Methods

ppr :: HsRecFields p arg -> SDoc #

pprPrec :: Rational -> HsRecFields p arg -> SDoc #

type LHsRecField' p arg = Located (HsRecField' p arg) #

Located Haskell Record Field

type LHsRecField p arg = Located (HsRecField p arg) #

Located Haskell Record Field

type LHsRecUpdField p = Located (HsRecUpdField p) #

Located Haskell Record Update Field

type HsRecField p arg = HsRecField' (FieldOcc p) arg #

Haskell Record Field

type HsRecUpdField p = HsRecField' (AmbiguousFieldOcc p) (LHsExpr p) #

Haskell Record Update Field

data HsRecField' id arg #

Haskell Record Field

For details on above see note [Api annotations] in ApiAnnotation

Constructors

HsRecField 

Fields

Instances

Instances details
Functor (HsRecField' id) 
Instance details

Defined in GHC.Hs.Pat

Methods

fmap :: (a -> b) -> HsRecField' id a -> HsRecField' id b #

(<$) :: a -> HsRecField' id b -> HsRecField' id a #

Foldable (HsRecField' id) 
Instance details

Defined in GHC.Hs.Pat

Methods

fold :: Monoid m => HsRecField' id m -> m #

foldMap :: Monoid m => (a -> m) -> HsRecField' id a -> m #

foldMap' :: Monoid m => (a -> m) -> HsRecField' id a -> m #

foldr :: (a -> b -> b) -> b -> HsRecField' id a -> b #

foldr' :: (a -> b -> b) -> b -> HsRecField' id a -> b #

foldl :: (b -> a -> b) -> b -> HsRecField' id a -> b #

foldl' :: (b -> a -> b) -> b -> HsRecField' id a -> b #

foldr1 :: (a -> a -> a) -> HsRecField' id a -> a #

foldl1 :: (a -> a -> a) -> HsRecField' id a -> a #

toList :: HsRecField' id a -> [a] #

null :: HsRecField' id a -> Bool #

length :: HsRecField' id a -> Int #

elem :: Eq a => a -> HsRecField' id a -> Bool #

maximum :: Ord a => HsRecField' id a -> a #

minimum :: Ord a => HsRecField' id a -> a #

sum :: Num a => HsRecField' id a -> a #

product :: Num a => HsRecField' id a -> a #

Traversable (HsRecField' id) 
Instance details

Defined in GHC.Hs.Pat

Methods

traverse :: Applicative f => (a -> f b) -> HsRecField' id a -> f (HsRecField' id b) #

sequenceA :: Applicative f => HsRecField' id (f a) -> f (HsRecField' id a) #

mapM :: Monad m => (a -> m b) -> HsRecField' id a -> m (HsRecField' id b) #

sequence :: Monad m => HsRecField' id (m a) -> m (HsRecField' id a) #

(ToHie (RFContext (Located label)), ToHie arg, HasLoc arg, Data label, Data arg) => ToHie (RContext (LHsRecField' label arg)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RContext (LHsRecField' label arg) -> HieM [HieAST Type]

(Data id, Data arg) => Data (HsRecField' id arg) 
Instance details

Defined in GHC.Hs.Pat

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRecField' id arg -> c (HsRecField' id arg) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsRecField' id arg) #

toConstr :: HsRecField' id arg -> Constr #

dataTypeOf :: HsRecField' id arg -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecField' id arg)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsRecField' id arg)) #

gmapT :: (forall b. Data b => b -> b) -> HsRecField' id arg -> HsRecField' id arg #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRecField' id arg -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRecField' id arg -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsRecField' id arg -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRecField' id arg -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) #

(Outputable p, Outputable arg) => Outputable (HsRecField' p arg) 
Instance details

Defined in GHC.Hs.Pat

Methods

ppr :: HsRecField' p arg -> SDoc #

pprPrec :: Rational -> HsRecField' p arg -> SDoc #

pprMinimalSig :: OutputableBndr name => LBooleanFormula (Located name) -> SDoc #

pprTcSpecPrags :: TcSpecPrags -> SDoc #

pprSpec :: OutputableBndr id => id -> SDoc -> InlinePragma -> SDoc #

pprVarSig :: OutputableBndr id => [id] -> SDoc -> SDoc #

pragSrcBrackets :: SourceText -> String -> SDoc -> SDoc #

Using SourceText in case the pragma was spelled differently or used mixed case

pragBrackets :: SDoc -> SDoc #

ppr_sig :: forall (p :: Pass). OutputableBndrId p => Sig (GhcPass p) -> SDoc #

hsSigDoc :: Sig name -> SDoc #

isCompleteMatchSig :: LSig name -> Bool #

isSCCFunSig :: LSig name -> Bool #

isMinimalLSig :: LSig name -> Bool #

isInlineLSig :: LSig name -> Bool #

isPragLSig :: LSig name -> Bool #

isSpecInstLSig :: LSig name -> Bool #

isSpecLSig :: LSig name -> Bool #

isTypeLSig :: LSig name -> Bool #

isFixityLSig :: LSig name -> Bool #

isDefaultMethod :: TcSpecPrags -> Bool #

hasSpecPrags :: TcSpecPrags -> Bool #

noSpecPrags :: TcSpecPrags #

isEmptyIPBindsTc :: HsIPBinds GhcTc -> Bool #

isEmptyIPBindsPR :: forall (p :: Pass). HsIPBinds (GhcPass p) -> Bool #

pprTicks :: SDoc -> SDoc -> SDoc #

ppr_monobind :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsBindLR (GhcPass idL) (GhcPass idR) -> SDoc #

plusHsValBinds :: forall (a :: Pass). HsValBinds (GhcPass a) -> HsValBinds (GhcPass a) -> HsValBinds (GhcPass a) #

isEmptyLHsBinds :: LHsBindsLR idL idR -> Bool #

emptyLHsBinds :: LHsBindsLR idL idR #

emptyValBindsOut :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b) #

emptyValBindsIn :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b) #

isEmptyValBinds :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b) -> Bool #

eqEmptyLocalBinds :: HsLocalBindsLR a b -> Bool #

isEmptyLocalBindsPR :: forall (a :: Pass) (b :: Pass). HsLocalBindsLR (GhcPass a) (GhcPass b) -> Bool #

isEmptyLocalBindsTc :: forall (a :: Pass). HsLocalBindsLR (GhcPass a) GhcTc -> Bool #

emptyLocalBinds :: forall (a :: Pass) (b :: Pass). HsLocalBindsLR (GhcPass a) (GhcPass b) #

pprDeclList :: [SDoc] -> SDoc #

pprLHsBindsForUser :: forall (idL :: Pass) (idR :: Pass) (id2 :: Pass). (OutputableBndrId idL, OutputableBndrId idR, OutputableBndrId id2) => LHsBindsLR (GhcPass idL) (GhcPass idR) -> [LSig (GhcPass id2)] -> [SDoc] #

pprLHsBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => LHsBindsLR (GhcPass idL) (GhcPass idR) -> SDoc #

type HsLocalBinds id = HsLocalBindsLR id id #

Haskell Local Bindings

type LHsLocalBinds id = Located (HsLocalBinds id) #

Located Haskell local bindings

data HsLocalBindsLR idL idR #

Haskell Local Bindings with separate Left and Right identifier types

Bindings in a 'let' expression or a 'where' clause

Constructors

HsValBinds (XHsValBinds idL idR) (HsValBindsLR idL idR)

Haskell Value Bindings

HsIPBinds (XHsIPBinds idL idR) (HsIPBinds idR)

Haskell Implicit Parameter Bindings

EmptyLocalBinds (XEmptyLocalBinds idL idR)

Empty Local Bindings

XHsLocalBindsLR (XXHsLocalBindsLR idL idR) 

Instances

Instances details
(ToHie (LHsExpr a), ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (HsLocalBinds a)) => ToHie (RScoped (LHsLocalBinds a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LHsLocalBinds a) -> HieM [HieAST Type]

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsLocalBindsLR (GhcPass pl) (GhcPass pr)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

pprPrec :: Rational -> HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

type LHsLocalBindsLR idL idR = Located (HsLocalBindsLR idL idR) #

type HsValBinds id = HsValBindsLR id id #

Haskell Value Bindings

data HsValBindsLR idL idR #

Haskell Value bindings with separate Left and Right identifier types (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindings

Constructors

ValBinds (XValBinds idL idR) (LHsBindsLR idL idR) [LSig idR]

Value Bindings In

Before renaming RHS; idR is always RdrName Not dependency analysed Recursive by default

XValBindsLR (XXValBindsLR idL idR)

Value Bindings Out

After renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones.

Instances

Instances details
(ToHie (BindContext (LHsBind a)), ToHie (SigContext (LSig a)), ToHie (RScoped (XXValBindsLR a a))) => ToHie (RScoped (HsValBindsLR a a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (HsValBindsLR a a) -> HieM [HieAST Type]

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsValBindsLR (GhcPass pl) (GhcPass pr)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

pprPrec :: Rational -> HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

data NHsValBindsLR idL #

Constructors

NValBinds [(RecFlag, LHsBinds idL)] [LSig GhcRn] 

Instances

Instances details
ToHie (RScoped (NHsValBindsLR GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (NHsValBindsLR GhcRn) -> HieM [HieAST Type]

ToHie (RScoped (NHsValBindsLR GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (NHsValBindsLR GhcTc) -> HieM [HieAST Type]

type LHsBind id = LHsBindLR id id #

Located Haskell Binding

type LHsBinds id = LHsBindsLR id id #

Located Haskell Bindings

type HsBind id = HsBindLR id id #

Haskell Binding

type LHsBindsLR idL idR = Bag (LHsBindLR idL idR) #

Located Haskell Bindings with separate Left and Right identifier types

type LHsBindLR idL idR = Located (HsBindLR idL idR) #

Located Haskell Binding with separate Left and Right identifier types

data HsBindLR idL idR #

Haskell Binding with separate Left and Right id's

Constructors

FunBind

Function-like Binding

FunBind is used for both functions f x = e and variables f = x -> e and strict variables !x = x + 1

Reason 1: Special case for type inference: see tcMonoBinds.

Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds

But note that the form f :: a->a = ... parses as a pattern binding, just like (f :: a -> a) = ...

Strict bindings have their strictness recorded in the SrcStrictness of their MatchContext. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.

AnnKeywordIds

Fields

  • fun_ext :: XFunBind idL idR

    After the renamer, this contains the locally-bound free variables of this defn. See Note [Bind free vars]

  • fun_id :: Located (IdP idL)
     
  • fun_matches :: MatchGroup idR (LHsExpr idR)

    The payload

  • fun_co_fn :: HsWrapper

    Coercion from the type of the MatchGroup to the type of the Id. Example:

         f :: Int -> forall a. a -> a
     f x y = y

    Then the MatchGroup will have type (Int -> a' -> a') (with a free type variable a'). The coercion will take a CoreExpr of this type and convert it to a CoreExpr of type Int -> forall a'. a' -> a' Notice that the coercion captures the free a'.

  • fun_tick :: [Tickish Id]

    Ticks to put on the rhs, if any

PatBind

Pattern Binding

The pattern is never a simple variable; That case is done by FunBind. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.

Fields

VarBind

Variable Binding

Dictionary binding and suchlike. All VarBinds are introduced by the type checker

Fields

AbsBinds

Abstraction Bindings

Fields

PatSynBind (XPatSynBind idL idR) (PatSynBind idL idR)
XHsBindsLR (XXHsBindsLR idL idR) 

Instances

Instances details
HasType (LHsBind GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsBind GhcRn -> HieM [HieAST Type]

HasType (LHsBind GhcTc) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsBind GhcTc -> HieM [HieAST Type]

(ToHie (Context (Located (IdP a))), ToHie (MatchGroup a (LHsExpr a)), ToHie (PScoped (LPat a)), ToHie (GRHSs a (LHsExpr a)), ToHie (LHsExpr a), ToHie (Located (PatSynBind a a)), HasType (LHsBind a), ModifyState (IdP a), Data (HsBind a)) => ToHie (BindContext (LHsBind a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: BindContext (LHsBind a) -> HieM [HieAST Type]

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsBindLR (GhcPass pl) (GhcPass pr)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc #

pprPrec :: Rational -> HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc #

data NPatBindTc #

Constructors

NPatBindTc 

Fields

Instances

Instances details
Data NPatBindTc 
Instance details

Defined in GHC.Hs.Binds

Methods

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

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

toConstr :: NPatBindTc -> Constr #

dataTypeOf :: NPatBindTc -> DataType #

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

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

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

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

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

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

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

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

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

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

data ABExport p #

Abtraction Bindings Export

Constructors

ABE 

Fields

XABExport (XXABExport p) 

Instances

Instances details
OutputableBndrId p => Outputable (ABExport (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: ABExport (GhcPass p) -> SDoc #

pprPrec :: Rational -> ABExport (GhcPass p) -> SDoc #

data PatSynBind idL idR #

Pattern Synonym binding

Constructors

PSB 

Fields

XPatSynBind (XXPatSynBind idL idR) 

Instances

Instances details
(ToHie (Context (Located (IdP a))), ToHie (PScoped (LPat a)), ToHie (HsPatSynDir a)) => ToHie (Located (PatSynBind a a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (PatSynBind a a) -> HieM [HieAST Type]

(OutputableBndrId l, OutputableBndrId r, Outputable (XXPatSynBind (GhcPass l) (GhcPass r))) => Outputable (PatSynBind (GhcPass l) (GhcPass r)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: PatSynBind (GhcPass l) (GhcPass r) -> SDoc #

pprPrec :: Rational -> PatSynBind (GhcPass l) (GhcPass r) -> SDoc #

data HsIPBinds id #

Haskell Implicit Parameter Bindings

Constructors

IPBinds (XIPBinds id) [LIPBind id] 
XHsIPBinds (XXHsIPBinds id) 

Instances

Instances details
OutputableBndrId p => Outputable (HsIPBinds (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: HsIPBinds (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsIPBinds (GhcPass p) -> SDoc #

type LIPBind id = Located (IPBind id) #

Located Implicit Parameter Binding

May have AnnKeywordId : AnnSemi when in a list

data IPBind id #

Implicit parameter bindings.

These bindings start off as (Left "x") in the parser and stay that way until after type-checking when they are replaced with (Right d), where "d" is the name of the dictionary holding the evidence for the implicit parameter.

Constructors

IPBind (XCIPBind id) (Either (Located HsIPName) (IdP id)) (LHsExpr id) 
XIPBind (XXIPBind id) 

Instances

Instances details
OutputableBndrId p => Outputable (IPBind (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: IPBind (GhcPass p) -> SDoc #

pprPrec :: Rational -> IPBind (GhcPass p) -> SDoc #

type LSig pass = Located (Sig pass) #

Located Signature

data Sig pass #

Signatures and pragmas

Constructors

TypeSig (XTypeSig pass) [Located (IdP pass)] (LHsSigWcType pass)

An ordinary type signature

f :: Num a => a -> a

After renaming, this list of Names contains the named wildcards brought into scope by this signature. For a signature _ -> _a -> Bool, the renamer will leave the unnamed wildcard _ untouched, and the named wildcard _a is then replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific.

PatSynSig (XPatSynSig pass) [Located (IdP pass)] (LHsSigType pass)

A pattern synonym type signature

pattern Single :: () => (Show a) => a -> [a]
ClassOpSig (XClassOpSig pass) Bool [Located (IdP pass)] (LHsSigType pass)

A signature for a class method False: ordinary class-method signature True: generic-default class method signature e.g. class C a where op :: a -> a -- Ordinary default op :: Eq a => a -> a -- Generic default No wildcards allowed here

IdSig (XIdSig pass) Id

A type signature in generated code, notably the code generated for record selectors. We simply record the desired Id itself, replete with its name, type and IdDetails. Otherwise it's just like a type signature: there should be an accompanying binding

FixSig (XFixSig pass) (FixitySig pass)

An ordinary fixity declaration

    infixl 8 ***
InlineSig (XInlineSig pass) (Located (IdP pass)) InlinePragma

An inline pragma

{#- INLINE f #-}
SpecSig (XSpecSig pass) (Located (IdP pass)) [LHsSigType pass] InlinePragma

A specialisation pragma

{-# SPECIALISE f :: Int -> Int #-}
SpecInstSig (XSpecInstSig pass) SourceText (LHsSigType pass)

A specialisation pragma for instance declarations only

{-# SPECIALISE instance Eq [Int] #-}

(Class tys); should be a specialisation of the current instance declaration

MinimalSig (XMinimalSig pass) SourceText (LBooleanFormula (Located (IdP pass)))

A minimal complete definition pragma

{-# MINIMAL a | (b, c | (d | e)) #-}
SCCFunSig (XSCCFunSig pass) SourceText (Located (IdP pass)) (Maybe (Located StringLiteral))

A "set cost centre" pragma for declarations

{-# SCC funName #-}

or

{-# SCC funName "cost_centre_name" #-}
CompleteMatchSig (XCompleteMatchSig pass) SourceText (Located [Located (IdP pass)]) (Maybe (Located (IdP pass)))

A complete match pragma

{-# COMPLETE C, D [:: T] #-}

Used to inform the pattern match checker about additional complete matchings which, for example, arise from pattern synonym definitions.

XSig (XXSig pass) 

Instances

Instances details
OutputableBndrId p => Outputable (Sig (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: Sig (GhcPass p) -> SDoc #

pprPrec :: Rational -> Sig (GhcPass p) -> SDoc #

ToHie (SigContext (LSig GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: SigContext (LSig GhcRn) -> HieM [HieAST Type]

ToHie (SigContext (LSig GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: SigContext (LSig GhcTc) -> HieM [HieAST Type]

type LFixitySig pass = Located (FixitySig pass) #

Located Fixity Signature

data FixitySig pass #

Fixity Signature

Constructors

FixitySig (XFixitySig pass) [Located (IdP pass)] Fixity 
XFixitySig (XXFixitySig pass) 

Instances

Instances details
OutputableBndrId p => Outputable (FixitySig (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: FixitySig (GhcPass p) -> SDoc #

pprPrec :: Rational -> FixitySig (GhcPass p) -> SDoc #

ToHie (LFixitySig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LFixitySig GhcRn -> HieM [HieAST Type]

data TcSpecPrags #

Type checker Specialisation Pragmas

TcSpecPrags conveys SPECIALISE pragmas from the type checker to the desugarer

Constructors

IsDefaultMethod

Super-specialised: a default method should be macro-expanded at every call site

SpecPrags [LTcSpecPrag] 

Instances

Instances details
Data TcSpecPrags 
Instance details

Defined in GHC.Hs.Binds

Methods

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

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

toConstr :: TcSpecPrags -> Constr #

dataTypeOf :: TcSpecPrags -> DataType #

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

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

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

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

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

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

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

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

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

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

type LTcSpecPrag = Located TcSpecPrag #

Located Type checker Specification Pragmas

data TcSpecPrag #

Type checker Specification Pragma

Constructors

SpecPrag Id HsWrapper InlinePragma

The Id to be specialised, a wrapper that specialises the polymorphic function, and inlining spec for the specialised function

Instances

Instances details
Data TcSpecPrag 
Instance details

Defined in GHC.Hs.Binds

Methods

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

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

toConstr :: TcSpecPrag -> Constr #

dataTypeOf :: TcSpecPrag -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable TcSpecPrag 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: TcSpecPrag -> SDoc #

pprPrec :: Rational -> TcSpecPrag -> SDoc #

type HsPatSynDetails arg = HsConDetails arg [RecordPatSynField arg] #

Haskell Pattern Synonym Details

data RecordPatSynField a #

Record Pattern Synonym Field

Constructors

RecordPatSynField 

Fields

Instances

Instances details
Functor RecordPatSynField 
Instance details

Defined in GHC.Hs.Binds

Methods

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

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

Foldable RecordPatSynField 
Instance details

Defined in GHC.Hs.Binds

Methods

fold :: Monoid m => RecordPatSynField m -> m #

foldMap :: Monoid m => (a -> m) -> RecordPatSynField a -> m #

foldMap' :: Monoid m => (a -> m) -> RecordPatSynField a -> m #

foldr :: (a -> b -> b) -> b -> RecordPatSynField a -> b #

foldr' :: (a -> b -> b) -> b -> RecordPatSynField a -> b #

foldl :: (b -> a -> b) -> b -> RecordPatSynField a -> b #

foldl' :: (b -> a -> b) -> b -> RecordPatSynField a -> b #

foldr1 :: (a -> a -> a) -> RecordPatSynField a -> a #

foldl1 :: (a -> a -> a) -> RecordPatSynField a -> a #

toList :: RecordPatSynField a -> [a] #

null :: RecordPatSynField a -> Bool #

length :: RecordPatSynField a -> Int #

elem :: Eq a => a -> RecordPatSynField a -> Bool #

maximum :: Ord a => RecordPatSynField a -> a #

minimum :: Ord a => RecordPatSynField a -> a #

sum :: Num a => RecordPatSynField a -> a #

product :: Num a => RecordPatSynField a -> a #

Traversable RecordPatSynField 
Instance details

Defined in GHC.Hs.Binds

Methods

traverse :: Applicative f => (a -> f b) -> RecordPatSynField a -> f (RecordPatSynField b) #

sequenceA :: Applicative f => RecordPatSynField (f a) -> f (RecordPatSynField a) #

mapM :: Monad m => (a -> m b) -> RecordPatSynField a -> m (RecordPatSynField b) #

sequence :: Monad m => RecordPatSynField (m a) -> m (RecordPatSynField a) #

Data a => Data (RecordPatSynField a) 
Instance details

Defined in GHC.Hs.Binds

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RecordPatSynField a -> c (RecordPatSynField a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RecordPatSynField a) #

toConstr :: RecordPatSynField a -> Constr #

dataTypeOf :: RecordPatSynField a -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> RecordPatSynField a -> RecordPatSynField a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RecordPatSynField a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RecordPatSynField a -> r #

gmapQ :: (forall d. Data d => d -> u) -> RecordPatSynField a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RecordPatSynField a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) #

Outputable a => Outputable (RecordPatSynField a) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: RecordPatSynField a -> SDoc #

pprPrec :: Rational -> RecordPatSynField a -> SDoc #

ToHie (Context a) => ToHie (PatSynFieldContext (RecordPatSynField a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: PatSynFieldContext (RecordPatSynField a) -> HieM [HieAST Type]

data HsPatSynDir id #

Haskell Pattern Synonym Direction

Constructors

Unidirectional 
ImplicitBidirectional 
ExplicitBidirectional (MatchGroup id (LHsExpr id)) 

Instances

Instances details
ToHie (MatchGroup a (LHsExpr a)) => ToHie (HsPatSynDir a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsPatSynDir a -> HieM [HieAST Type]

pprInstanceHdr :: ClsInst -> SDoc #

pprInstance :: ClsInst -> SDoc #

instanceDFunId :: ClsInst -> DFunId #

data ClsInst #

A type-class instance. Note that there is some tricky laziness at work here. See Note [ClsInst laziness and the rough-match fields] for more details.

Instances

Instances details
Data ClsInst 
Instance details

Defined in InstEnv

Methods

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

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

toConstr :: ClsInst -> Constr #

dataTypeOf :: ClsInst -> DataType #

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

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

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

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

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

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

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

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

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

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

NamedThing ClsInst 
Instance details

Defined in InstEnv

Methods

getOccName :: ClsInst -> OccName #

getName :: ClsInst -> Name #

Outputable ClsInst 
Instance details

Defined in InstEnv

Methods

ppr :: ClsInst -> SDoc #

pprPrec :: Rational -> ClsInst -> SDoc #

data FamInst #

Instances

Instances details
NamedThing FamInst 
Instance details

Defined in FamInstEnv

Methods

getOccName :: FamInst -> OccName #

getName :: FamInst -> Name #

Outputable FamInst 
Instance details

Defined in FamInstEnv

Methods

ppr :: FamInst -> SDoc #

pprPrec :: Rational -> FamInst -> SDoc #

type BreakIndex = Int #

Breakpoint index

data ModBreaks #

All the information about the breakpoints for a module

Constructors

ModBreaks 

Fields

parenthesizeHsContext :: forall (p :: Pass). PprPrec -> LHsContext (GhcPass p) -> LHsContext (GhcPass p) #

parenthesizeHsContext p ctxt checks if ctxt is a single constraint c such that hsTypeNeedsParens p c is true, and if so, surrounds c with an HsParTy to form a parenthesized ctxt. Otherwise, it simply returns ctxt unchanged.

parenthesizeHsType :: forall (p :: Pass). PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

parenthesizeHsType p ty checks if hsTypeNeedsParens p ty is true, and if so, surrounds ty with an HsParTy. Otherwise, it simply returns ty.

hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool #

hsTypeNeedsParens p t returns True if the type t needs parentheses under precedence p.

pprHsType :: forall (p :: Pass). OutputableBndrId p => HsType (GhcPass p) -> SDoc #

pprConDeclFields :: forall (p :: Pass). OutputableBndrId p => [LConDeclField (GhcPass p)] -> SDoc #

pprLHsContext :: forall (p :: Pass). OutputableBndrId p => LHsContext (GhcPass p) -> SDoc #

pprHsExplicitForAll :: forall (p :: Pass). OutputableBndrId p => ForallVisFlag -> Maybe [LHsTyVarBndr (GhcPass p)] -> SDoc #

Version of pprHsForAll or pprHsForAllExtra that will always print forall. when passed Just []. Prints nothing if passed Nothing

pprHsForAllExtra :: forall (p :: Pass). OutputableBndrId p => Maybe SrcSpan -> ForallVisFlag -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc #

Version of pprHsForAll that can also print an extra-constraints wildcard, e.g. _ => a -> Bool or (Show a, _) => a -> String. This underscore will be printed when the 'Maybe SrcSpan' argument is a Just containing the location of the extra-constraints wildcard. A special function for this is needed, as the extra-constraints wildcard is removed from the actual context and type, and stored in a separate field, thus just printing the type will not print the extra-constraints wildcard.

pprHsForAll :: forall (p :: Pass). OutputableBndrId p => ForallVisFlag -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc #

Prints a forall; When passed an empty list, prints forall ./forall -> only when -dppr-debug is enabled.

pprAnonWildCard :: SDoc #

ambiguousFieldOcc :: FieldOcc GhcTc -> AmbiguousFieldOcc GhcTc #

unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc #

selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id #

rdrNameAmbiguousFieldOcc :: forall (p :: Pass). AmbiguousFieldOcc (GhcPass p) -> RdrName #

mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs #

mkFieldOcc :: Located RdrName -> FieldOcc GhcPs #

getLHsInstDeclClass_maybe :: forall (p :: Pass). LHsSigType (GhcPass p) -> Maybe (Located (IdP (GhcPass p))) #

getLHsInstDeclHead :: forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p) #

splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn) #

Decompose a type class instance type (of the form forall tvs. context => instance_head) into its constituent parts.

Note that this function looks through parentheses, so it will work on types such as (forall tvs. ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass) #

Decompose a type of the form context => body into its constituent parts.

Note that this function looks through parentheses, so it will work on types such as (context => ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsForAllTyInvis :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass) #

Decompose a type of the form forall tvs. body into its constituent parts. Note that only invisible foralls (i.e., forall a., with a dot) are split apart; visible foralls (i.e., forall a ->, with an arrow) are left untouched.

This function is used to split apart certain types, such as instance declaration types, which disallow visible foralls. For instance, if GHC split apart the forall in instance forall a -> Show (Blah a), then that declaration would mistakenly be accepted!

Note that this function looks through parentheses, so it will work on types such as (forall a. ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsSigmaTyInvis :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass) #

Decompose a sigma type (of the form forall tvs. context => body) into its constituent parts. Note that only invisible foralls (i.e., forall a., with a dot) are split apart; visible foralls (i.e., forall a ->, with an arrow) are left untouched.

This function is used to split apart certain types, such as instance declaration types, which disallow visible foralls. For instance, if GHC split apart the forall in instance forall a -> Show (Blah a), then that declaration would mistakenly be accepted!

Note that this function looks through parentheses, so it will work on types such as (forall a. ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsPatSynTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, [LHsTyVarBndr pass], LHsContext pass, LHsType pass) #

Decompose a pattern synonym type signature into its constituent parts.

Note that this function looks through parentheses, so it will work on types such as (forall a. ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

numVisibleArgs :: [HsArg tm ty] -> Arity #

hsTyGetAppHead_maybe :: forall (p :: Pass). LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p))) #

splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn) #

mkHsAppKindTy :: forall (p :: Pass). XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

mkHsAppTys :: forall (p :: Pass). LHsType (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p) #

mkHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

mkHsOpTy :: forall (p :: Pass). LHsType (GhcPass p) -> Located (IdP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p) #

mkAnonWildCardTy :: HsType GhcPs #

isLHsForAllTy :: LHsType p -> Bool #

ignoreParens :: LHsType pass -> LHsType pass #

hsTyKindSig :: LHsType pass -> Maybe (LHsKind pass) #

Get the kind signature of a type, ignoring parentheses:

hsTyKindSig `Maybe ` = Nothing hsTyKindSig `Maybe :: Type -> Type ` = Just `Type -> Type` hsTyKindSig `Maybe :: ((Type -> Type))` = Just `Type -> Type`

This is used to extract the result kind of type synonyms with a CUSK:

type S = (F :: res_kind) ^^^^^^^^

hsLTyVarBndrsToTypes :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> [LHsType (GhcPass p)] #

Convert a LHsTyVarBndrs to a list of types. Works on *type* variable only, no kind vars.

hsLTyVarBndrToType :: forall (p :: Pass). LHsTyVarBndr (GhcPass p) -> LHsType (GhcPass p) #

Convert a LHsTyVarBndr to an equivalent LHsType.

hsLTyVarLocNames :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> [Located (IdP (GhcPass p))] #

hsLTyVarLocName :: forall (p :: Pass). LHsTyVarBndr (GhcPass p) -> Located (IdP (GhcPass p)) #

hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name] #

hsExplicitLTyVarNames :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> [IdP (GhcPass p)] #

hsLTyVarNames :: forall (p :: Pass). [LHsTyVarBndr (GhcPass p)] -> [IdP (GhcPass p)] #

hsLTyVarName :: forall (p :: Pass). LHsTyVarBndr (GhcPass p) -> IdP (GhcPass p) #

hsTyVarName :: forall (p :: Pass). HsTyVarBndr (GhcPass p) -> IdP (GhcPass p) #

hsScopedTvs :: LHsSigType GhcRn -> [Name] #

hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name] #

hsConDetailsArgs :: HsConDetails (LHsType a) (Located [LConDeclField a]) -> [LHsType a] #

hsTvbAllKinded :: LHsQTyVars pass -> Bool #

Do all type variables in this LHsQTyVars come with kind annotations?

isHsKindedTyVar :: HsTyVarBndr pass -> Bool #

Does this HsTyVarBndr come with an explicit kind annotation?

hsIPNameFS :: HsIPName -> FastString #

mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing #

mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs GhcRn thing #

mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing #

mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing #

dropWildCards :: LHsSigWcType pass -> LHsSigType pass #

hsSigWcType :: LHsSigWcType pass -> LHsType pass #

hsSigType :: forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p) #

hsImplicitBody :: forall (p :: Pass) thing. HsImplicitBndrs (GhcPass p) thing -> thing #

isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool #

emptyLHsQTvs :: LHsQTyVars GhcRn #

hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass] #

mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs #

noLHsContext :: LHsContext pass #

getBangStrictness :: LHsType a -> HsSrcBang #

getBangType :: LHsType a -> LHsType a #

type LBangType pass = Located (BangType pass) #

Located Bang Type

type BangType pass = HsType pass #

Bang Type

In the parser, strictness and packedness annotations bind more tightly than docstrings. This means that when consuming a BangType (and looking for HsBangTy) we must be ready to peer behind a potential layer of HsDocTy. See #15206 for motivation and getBangType for an example.

type LHsContext pass #

Arguments

 = Located (HsContext pass)

AnnKeywordId : AnnUnit For details on above see note [Api annotations] in ApiAnnotation

Located Haskell Context

type HsContext pass = [LHsType pass] #

Haskell Context

type LHsType pass #

Arguments

 = Located (HsType pass)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Type

type HsKind pass = HsType pass #

Haskell Kind

type LHsKind pass #

Arguments

 = Located (HsKind pass)

AnnKeywordId : AnnDcolon

Located Haskell Kind

type LHsTyVarBndr pass = Located (HsTyVarBndr pass) #

Located Haskell Type Variable Binder

data LHsQTyVars pass #

Located Haskell Quantified Type Variables

Constructors

HsQTvs 

Fields

XLHsQTyVars (XXLHsQTyVars pass) 

Instances

Instances details
OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: LHsQTyVars (GhcPass p) -> SDoc #

pprPrec :: Rational -> LHsQTyVars (GhcPass p) -> SDoc #

HasLoc (LHsQTyVars GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

loc :: LHsQTyVars GhcRn -> SrcSpan

ToHie (TScoped (LHsQTyVars GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsQTyVars GhcRn) -> HieM [HieAST Type]

data HsImplicitBndrs pass thing #

Haskell Implicit Binders

Constructors

HsIB 

Fields

XHsImplicitBndrs (XXHsImplicitBndrs pass thing) 

Instances

Instances details
(HasLoc thing, ToHie (TScoped thing)) => ToHie (TScoped (HsImplicitBndrs GhcRn thing)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (HsImplicitBndrs GhcRn thing) -> HieM [HieAST Type]

ToHie (TScoped (LHsSigWcType GhcTc))

Dummy instances - never called

Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsSigWcType GhcTc) -> HieM [HieAST Type]

Outputable thing => Outputable (HsImplicitBndrs (GhcPass p) thing) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsImplicitBndrs (GhcPass p) thing -> SDoc #

pprPrec :: Rational -> HsImplicitBndrs (GhcPass p) thing -> SDoc #

HasLoc thing => HasLoc (HsImplicitBndrs a thing) 
Instance details

Defined in Compat.HieAst

Methods

loc :: HsImplicitBndrs a thing -> SrcSpan

data HsWildCardBndrs pass thing #

Haskell Wildcard Binders

Constructors

HsWC 

Fields

XHsWildCardBndrs (XXHsWildCardBndrs pass thing) 

Instances

Instances details
(HasLoc thing, ToHie (TScoped thing)) => ToHie (TScoped (HsWildCardBndrs GhcRn thing)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (HsWildCardBndrs GhcRn thing) -> HieM [HieAST Type]

ToHie (TScoped (LHsWcType GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsWcType GhcTc) -> HieM [HieAST Type]

ToHie (TScoped (LHsSigWcType GhcTc))

Dummy instances - never called

Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsSigWcType GhcTc) -> HieM [HieAST Type]

Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc #

pprPrec :: Rational -> HsWildCardBndrs (GhcPass p) thing -> SDoc #

HasLoc thing => HasLoc (HsWildCardBndrs a thing) 
Instance details

Defined in Compat.HieAst

Methods

loc :: HsWildCardBndrs a thing -> SrcSpan

type LHsSigType pass = HsImplicitBndrs pass (LHsType pass) #

Located Haskell Signature Type

type LHsWcType pass = HsWildCardBndrs pass (LHsType pass) #

Located Haskell Wildcard Type

type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass) #

Located Haskell Signature Wildcard Type

newtype HsIPName #

These names are used early on to store the names of implicit parameters. They completely disappear after type-checking.

Constructors

HsIPName FastString 

Instances

Instances details
Eq HsIPName 
Instance details

Defined in GHC.Hs.Types

Methods

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

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

Data HsIPName 
Instance details

Defined in GHC.Hs.Types

Methods

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

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

toConstr :: HsIPName -> Constr #

dataTypeOf :: HsIPName -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsIPName 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsIPName -> SDoc #

pprPrec :: Rational -> HsIPName -> SDoc #

OutputableBndr HsIPName 
Instance details

Defined in GHC.Hs.Types

Methods

pprBndr :: BindingSite -> HsIPName -> SDoc #

pprPrefixOcc :: HsIPName -> SDoc #

pprInfixOcc :: HsIPName -> SDoc #

bndrIsJoin_maybe :: HsIPName -> Maybe Int #

ToHie (Located HsIPName) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located HsIPName -> HieM [HieAST Type]

data HsTyVarBndr pass #

Haskell Type Variable Binder

Constructors

UserTyVar (XUserTyVar pass) (Located (IdP pass)) 
KindedTyVar (XKindedTyVar pass) (Located (IdP pass)) (LHsKind pass)
XTyVarBndr (XXTyVarBndr pass) 

Instances

Instances details
NamedThing (HsTyVarBndr GhcRn) 
Instance details

Defined in GHC.Hs.Types

Methods

getOccName :: HsTyVarBndr GhcRn -> OccName #

getName :: HsTyVarBndr GhcRn -> Name #

OutputableBndrId p => Outputable (HsTyVarBndr (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsTyVarBndr (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsTyVarBndr (GhcPass p) -> SDoc #

ToHie (TVScoped (LHsTyVarBndr GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TVScoped (LHsTyVarBndr GhcRn) -> HieM [HieAST Type]

data HsType pass #

Haskell Type

Constructors

HsForAllTy

Fields

HsQualTy 

Fields

HsTyVar (XTyVar pass) PromotionFlag (Located (IdP pass))
HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)
HsAppKindTy (XAppKindTy pass) (LHsType pass) (LHsKind pass) 
HsFunTy (XFunTy pass) (LHsType pass) (LHsType pass)
HsListTy (XListTy pass) (LHsType pass)
HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]
HsSumTy (XSumTy pass) [LHsType pass]
HsOpTy (XOpTy pass) (LHsType pass) (Located (IdP pass)) (LHsType pass)
HsParTy (XParTy pass) (LHsType pass)
HsIParamTy (XIParamTy pass) (Located HsIPName) (LHsType pass)
(?x :: ty)
HsStarTy (XStarTy pass) Bool
HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)
(ty :: kind)
HsSpliceTy (XSpliceTy pass) (HsSplice pass)
HsDocTy (XDocTy pass) (LHsType pass) LHsDocString
HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)
HsRecTy (XRecTy pass) [LConDeclField pass]
HsExplicitListTy (XExplicitListTy pass) PromotionFlag [LHsType pass]
HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]
HsTyLit (XTyLit pass) HsTyLit
HsWildCardTy (XWildCardTy pass)
XHsType (XXType pass) 

Instances

Instances details
OutputableBndrId p => Outputable (HsType (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsType (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsType (GhcPass p) -> SDoc #

ToHie (LHsContext GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsContext GhcRn -> HieM [HieAST Type]

ToHie (LHsType GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsType GhcRn -> HieM [HieAST Type]

ToHie (TScoped (LHsType GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsType GhcRn) -> HieM [HieAST Type]

ToHie (TScoped (LHsWcType GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsWcType GhcTc) -> HieM [HieAST Type]

ToHie (TScoped (LHsSigWcType GhcTc))

Dummy instances - never called

Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsSigWcType GhcTc) -> HieM [HieAST Type]

data NewHsTypeX #

Constructors

NHsCoreTy Type 

Instances

Instances details
Data NewHsTypeX
Instance details

Defined in GHC.Hs.Types

Methods

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

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

toConstr :: NewHsTypeX -> Constr #

dataTypeOf :: NewHsTypeX -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable NewHsTypeX 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: NewHsTypeX -> SDoc #

pprPrec :: Rational -> NewHsTypeX -> SDoc #

data HsTyLit #

Haskell Type Literal

Constructors

HsNumTy SourceText Integer 
HsStrTy SourceText FastString 

Instances

Instances details
Data HsTyLit 
Instance details

Defined in GHC.Hs.Types

Methods

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

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

toConstr :: HsTyLit -> Constr #

dataTypeOf :: HsTyLit -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsTyLit 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsTyLit -> SDoc #

pprPrec :: Rational -> HsTyLit -> SDoc #

data HsTupleSort #

Haskell Tuple Sort

Constructors

HsUnboxedTuple 
HsBoxedTuple 
HsConstraintTuple 
HsBoxedOrConstraintTuple 

Instances

Instances details
Data HsTupleSort 
Instance details

Defined in GHC.Hs.Types

Methods

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

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

toConstr :: HsTupleSort -> Constr #

dataTypeOf :: HsTupleSort -> DataType #

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

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

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

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

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

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

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

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

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

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

type LConDeclField pass #

Arguments

 = Located (ConDeclField pass)

May have AnnKeywordId : AnnComma when in a list

Located Constructor Declaration Field

data ConDeclField pass #

Constructor Declaration Field

Constructors

ConDeclField

Fields

XConDeclField (XXConDeclField pass) 

Instances

Instances details
OutputableBndrId p => Outputable (ConDeclField (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: ConDeclField (GhcPass p) -> SDoc #

pprPrec :: Rational -> ConDeclField (GhcPass p) -> SDoc #

ToHie (LConDeclField GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LConDeclField GhcRn -> HieM [HieAST Type]

ToHie (Located [LConDeclField GhcRn]) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located [LConDeclField GhcRn] -> HieM [HieAST Type]

data HsConDetails arg rec #

Haskell Constructor Details

Constructors

PrefixCon [arg] 
RecCon rec 
InfixCon arg arg 

Instances

Instances details
(Data arg, Data rec) => Data (HsConDetails arg rec) 
Instance details

Defined in GHC.Hs.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDetails arg rec -> c (HsConDetails arg rec) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails arg rec) #

toConstr :: HsConDetails arg rec -> Constr #

dataTypeOf :: HsConDetails arg rec -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDetails arg rec)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDetails arg rec)) #

gmapT :: (forall b. Data b => b -> b) -> HsConDetails arg rec -> HsConDetails arg rec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDetails arg rec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails arg rec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsConDetails arg rec -> SDoc #

pprPrec :: Rational -> HsConDetails arg rec -> SDoc #

(ToHie arg, ToHie rec) => ToHie (HsConDetails arg rec) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsConDetails arg rec -> HieM [HieAST Type]

data HsArg tm ty #

Constructors

HsValArg tm 
HsTypeArg SrcSpan ty 
HsArgPar SrcSpan 

Instances

Instances details
(Outputable tm, Outputable ty) => Outputable (HsArg tm ty) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsArg tm ty -> SDoc #

pprPrec :: Rational -> HsArg tm ty -> SDoc #

(HasLoc tm, HasLoc ty) => HasLoc (HsArg tm ty) 
Instance details

Defined in Compat.HieAst

Methods

loc :: HsArg tm ty -> SrcSpan

(ToHie tm, ToHie ty) => ToHie (HsArg tm ty) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsArg tm ty -> HieM [HieAST Type]

type LHsTypeArg p = HsArg (LHsType p) (LHsKind p) #

type LFieldOcc pass = Located (FieldOcc pass) #

Located Field Occurrence

data FieldOcc pass #

Field Occurrence

Represents an *occurrence* of an unambiguous field. We store both the RdrName the user originally wrote, and after the renamer, the selector function.

Constructors

FieldOcc 

Fields

XFieldOcc (XXFieldOcc pass) 

Instances

Instances details
Eq (XCFieldOcc (GhcPass p)) => Eq (FieldOcc (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

(==) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

(/=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

Ord (XCFieldOcc (GhcPass p)) => Ord (FieldOcc (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

compare :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Ordering #

(<) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

(<=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

(>) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

(>=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

max :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) #

min :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) #

Outputable (FieldOcc pass) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: FieldOcc pass -> SDoc #

pprPrec :: Rational -> FieldOcc pass -> SDoc #

ToHie (RFContext (LFieldOcc GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (LFieldOcc GhcRn) -> HieM [HieAST Type]

ToHie (RFContext (LFieldOcc GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (LFieldOcc GhcTc) -> HieM [HieAST Type]

data AmbiguousFieldOcc pass #

Ambiguous Field Occurrence

Represents an *occurrence* of a field that is potentially ambiguous after the renamer, with the ambiguity resolved by the typechecker. We always store the RdrName that the user originally wrote, and store the selector function after the renamer (for unambiguous occurrences) or the typechecker (for ambiguous occurrences).

See Note [HsRecField and HsRecUpdField] in GHC.Hs.Pat and Note [Disambiguating record fields] in TcExpr. See Note [Located RdrNames] in GHC.Hs.Expr

Constructors

Unambiguous (XUnambiguous pass) (Located RdrName) 
Ambiguous (XAmbiguous pass) (Located RdrName) 
XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass) 

Instances

Instances details
Outputable (AmbiguousFieldOcc (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: AmbiguousFieldOcc (GhcPass p) -> SDoc #

pprPrec :: Rational -> AmbiguousFieldOcc (GhcPass p) -> SDoc #

OutputableBndr (AmbiguousFieldOcc (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

pprBndr :: BindingSite -> AmbiguousFieldOcc (GhcPass p) -> SDoc #

pprPrefixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc #

pprInfixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc #

bndrIsJoin_maybe :: AmbiguousFieldOcc (GhcPass p) -> Maybe Int #

ToHie (RFContext (Located (AmbiguousFieldOcc GhcRn))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (Located (AmbiguousFieldOcc GhcRn)) -> HieM [HieAST Type]

ToHie (RFContext (Located (AmbiguousFieldOcc GhcTc))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (Located (AmbiguousFieldOcc GhcTc)) -> HieM [HieAST Type]

data ExecOptions #

Constructors

ExecOptions 

Fields

data SingleStep #

Constructors

RunToCompletion 
SingleStep 
RunAndLogSteps 

data ExecResult #

Constructors

ExecComplete 

Fields

ExecBreak 

Fields

data BreakInfo #

data Resume #

Constructors

Resume 

Fields

data History #

isBottomingId :: Var -> Bool #

Returns true if an application to n args would diverge

isDeadBinder :: Id -> Bool #

isImplicitId :: Id -> Bool #

isImplicitId tells whether an Ids info is implied by other declarations, so we don't need to put its signature in an interface file, even if it's mentioned in some other interface unfolding.

idDataCon :: Id -> DataCon #

Get from either the worker or the wrapper Id to the DataCon. Currently used only in the desugarer.

INVARIANT: idDataCon (dataConWrapId d) = d: remember, dataConWrapId can return either the wrapper or the worker

isDataConWorkId :: Id -> Bool #

isFCallId :: Id -> Bool #

isPrimOpId :: Id -> Bool #

isClassOpId_maybe :: Id -> Maybe Class #

isRecordSelector :: Id -> Bool #

recordSelectorTyCon :: Id -> RecSelParent #

If the Id is that for a record selector, extract the sel_tycon. Panic otherwise.

idType :: Id -> Kind #

isVanillaDataCon :: DataCon -> Bool #

Vanilla DataCons are those that are nice boring Haskell 98 constructors

dataConUserType :: DataCon -> Type #

The user-declared type of the data constructor in the nice-to-read form:

T :: forall a b. a -> b -> T [a]

rather than:

T :: forall a c. forall b. (c~[a]) => a -> b -> T c

The type variables are quantified in the order that the user wrote them. See Note [DataCon user type variable binders].

NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.

dataConSig :: DataCon -> ([TyCoVar], ThetaType, [Type], Type) #

The "signature" of the DataCon returns, in order:

1) The result of dataConUnivAndExTyCoVars,

2) All the ThetaTypes relating to the DataCon (coercion, dictionary, implicit parameter - whatever), including dependent GADT equalities. Dependent GADT equalities are *also* listed in return value (1), so be careful!

3) The type arguments to the constructor

4) The original result type of the DataCon

dataConSrcBangs :: DataCon -> [HsSrcBang] #

Strictness/unpack annotations, from user; or, for imported DataCons, from the interface file The list is in one-to-one correspondence with the arity of the DataCon

dataConIsInfix :: DataCon -> Bool #

Should the DataCon be presented infix?

isMarkedStrict :: StrictnessMark -> Bool #

data HsSrcBang #

Haskell Source Bang

Bangs on data constructor arguments as the user wrote them in the source code.

(HsSrcBang _ SrcUnpack SrcLazy) and (HsSrcBang _ SrcUnpack NoSrcStrict) (without StrictData) makes no sense, we emit a warning (in checkValidDataCon) and treat it like (HsSrcBang _ NoSrcUnpack SrcLazy)

Constructors

HsSrcBang SourceText SrcUnpackedness SrcStrictness 

Instances

Instances details
Data HsSrcBang 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: HsSrcBang -> Constr #

dataTypeOf :: HsSrcBang -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsSrcBang 
Instance details

Defined in DataCon

Methods

ppr :: HsSrcBang -> SDoc #

pprPrec :: Rational -> HsSrcBang -> SDoc #

data HsImplBang #

Haskell Implementation Bang

Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.

Constructors

HsLazy

Lazy field, or one with an unlifted type

HsStrict

Strict but not unpacked field

HsUnpack (Maybe Coercion)

Strict and unpacked field co :: arg-ty ~ product-ty HsBang

Instances

Instances details
Data HsImplBang 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: HsImplBang -> Constr #

dataTypeOf :: HsImplBang -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsImplBang 
Instance details

Defined in DataCon

Methods

ppr :: HsImplBang -> SDoc #

pprPrec :: Rational -> HsImplBang -> SDoc #

data SrcStrictness #

Source Strictness

What strictness annotation the user wrote

Constructors

SrcLazy

Lazy, ie '~'

SrcStrict

Strict, ie !

NoSrcStrict

no strictness annotation

Instances

Instances details
Eq SrcStrictness 
Instance details

Defined in DataCon

Methods

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

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

Data SrcStrictness 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: SrcStrictness -> Constr #

dataTypeOf :: SrcStrictness -> DataType #

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

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

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

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

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

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

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

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

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

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

Binary SrcStrictness 
Instance details

Defined in DataCon

Methods

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

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

get :: BinHandle -> IO SrcStrictness #

Outputable SrcStrictness 
Instance details

Defined in DataCon

Methods

ppr :: SrcStrictness -> SDoc #

pprPrec :: Rational -> SrcStrictness -> SDoc #

data SrcUnpackedness #

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack

{--} specified

SrcNoUnpack

{--} specified

NoSrcUnpack

no unpack pragma

Instances

Instances details
Eq SrcUnpackedness 
Instance details

Defined in DataCon

Methods

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

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

Data SrcUnpackedness 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: SrcUnpackedness -> Constr #

dataTypeOf :: SrcUnpackedness -> DataType #

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

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

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

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

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

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

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

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

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

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

Binary SrcUnpackedness 
Instance details

Defined in DataCon

Methods

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

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

get :: BinHandle -> IO SrcUnpackedness #

Outputable SrcUnpackedness 
Instance details

Defined in DataCon

Methods

ppr :: SrcUnpackedness -> SDoc #

pprPrec :: Rational -> SrcUnpackedness -> SDoc #

data StrictnessMark #

Constructors

MarkedStrict 
NotMarkedStrict 

Instances

Instances details
Outputable StrictnessMark 
Instance details

Defined in DataCon

Methods

ppr :: StrictnessMark -> SDoc #

pprPrec :: Rational -> StrictnessMark -> SDoc #

hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool #

hsOverLitNeedsParens p ol returns True if an overloaded literal ol needs to be parenthesized under precedence p.

hsLitNeedsParens :: PprPrec -> HsLit x -> Bool #

hsLitNeedsParens p l returns True if a literal l needs to be parenthesized under precedence p.

pmPprHsLit :: forall (x :: Pass). HsLit (GhcPass x) -> SDoc #

pmPprHsLit pretty prints literals and is used when pretty printing pattern match warnings. All are printed the same (i.e., without hashes if they are primitive and not wrapped in constructors if they are boxed). This happens mainly for too reasons: * We do not want to expose their internal representation * The warnings become too messy

pp_st_suffix :: SourceText -> SDoc -> SDoc -> SDoc #

convertLit :: ConvertIdX a b => HsLit a -> HsLit b #

Convert a literal from one index type to another, updating the annotations according to the relevant Convertable instance

overLitType :: HsOverLit GhcTc -> Type #

negateOverLitVal :: OverLitVal -> OverLitVal #

data HsLit x #

Haskell Literal

Constructors

HsChar (XHsChar x) Char

Character

HsCharPrim (XHsCharPrim x) Char

Unboxed character

HsString (XHsString x) FastString

String

HsStringPrim (XHsStringPrim x) ByteString

Packed bytes

HsInt (XHsInt x) IntegralLit

Genuinely an Int; arises from TcGenDeriv, and from TRANSLATION

HsIntPrim (XHsIntPrim x) Integer

literal Int#

HsWordPrim (XHsWordPrim x) Integer

literal Word#

HsInt64Prim (XHsInt64Prim x) Integer

literal Int64#

HsWord64Prim (XHsWord64Prim x) Integer

literal Word64#

HsInteger (XHsInteger x) Integer Type

Genuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit)

HsRat (XHsRat x) FractionalLit Type

Genuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit)

HsFloatPrim (XHsFloatPrim x) FractionalLit

Unboxed Float

HsDoublePrim (XHsDoublePrim x) FractionalLit

Unboxed Double

XLit (XXLit x) 

Instances

Instances details
Eq (HsLit x) 
Instance details

Defined in GHC.Hs.Lit

Methods

(==) :: HsLit x -> HsLit x -> Bool #

(/=) :: HsLit x -> HsLit x -> Bool #

Outputable (HsLit (GhcPass p)) 
Instance details

Defined in GHC.Hs.Lit

Methods

ppr :: HsLit (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsLit (GhcPass p) -> SDoc #

data HsOverLit p #

Haskell Overloaded Literal

Constructors

OverLit 

Fields

XOverLit (XXOverLit p) 

Instances

Instances details
Eq (XXOverLit p) => Eq (HsOverLit p) 
Instance details

Defined in GHC.Hs.Lit

Methods

(==) :: HsOverLit p -> HsOverLit p -> Bool #

(/=) :: HsOverLit p -> HsOverLit p -> Bool #

Ord (XXOverLit p) => Ord (HsOverLit p) 
Instance details

Defined in GHC.Hs.Lit

Methods

compare :: HsOverLit p -> HsOverLit p -> Ordering #

(<) :: HsOverLit p -> HsOverLit p -> Bool #

(<=) :: HsOverLit p -> HsOverLit p -> Bool #

(>) :: HsOverLit p -> HsOverLit p -> Bool #

(>=) :: HsOverLit p -> HsOverLit p -> Bool #

max :: HsOverLit p -> HsOverLit p -> HsOverLit p #

min :: HsOverLit p -> HsOverLit p -> HsOverLit p #

OutputableBndrId p => Outputable (HsOverLit (GhcPass p)) 
Instance details

Defined in GHC.Hs.Lit

Methods

ppr :: HsOverLit (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsOverLit (GhcPass p) -> SDoc #

data OverLitTc #

Constructors

OverLitTc 

Fields

Instances

Instances details
Data OverLitTc 
Instance details

Defined in GHC.Hs.Lit

Methods

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

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

toConstr :: OverLitTc -> Constr #

dataTypeOf :: OverLitTc -> DataType #

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

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

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

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

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

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

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

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

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

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

data OverLitVal #

Overloaded Literal Value

Constructors

HsIntegral !IntegralLit

Integer-looking literals;

HsFractional !FractionalLit

Frac-looking literals

HsIsString !SourceText !FastString

String-looking literals

Instances

Instances details
Eq OverLitVal 
Instance details

Defined in GHC.Hs.Lit

Methods

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

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

Data OverLitVal 
Instance details

Defined in GHC.Hs.Lit

Methods

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

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

toConstr :: OverLitVal -> Constr #

dataTypeOf :: OverLitVal -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord OverLitVal 
Instance details

Defined in GHC.Hs.Lit

Methods

compare :: OverLitVal -> OverLitVal -> Ordering #

(<) :: OverLitVal -> OverLitVal -> Bool #

(<=) :: OverLitVal -> OverLitVal -> Bool #

(>) :: OverLitVal -> OverLitVal -> Bool #

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

max :: OverLitVal -> OverLitVal -> OverLitVal #

min :: OverLitVal -> OverLitVal -> OverLitVal #

Outputable OverLitVal 
Instance details

Defined in GHC.Hs.Lit

Methods

ppr :: OverLitVal -> SDoc #

pprPrec :: Rational -> OverLitVal -> SDoc #

splitForAllTys :: Type -> ([TyCoVar], Type) #

Take a ForAllTy apart, returning the list of tycovars and the result type. This always succeeds, even if it returns only an empty list. Note that the result type returned may have free variables that were bound by a forall.

funResultTy :: Type -> Type #

Extract the function result type and panic if that is not possible

pprTypeApp :: TyCon -> [Type] -> SDoc #

pprForAll :: [TyCoVarBinder] -> SDoc #

pprThetaArrowTy :: ThetaType -> SDoc #

pprParendType :: Type -> SDoc #

alphaTyVars :: [TyVar] #

tyConClass_maybe :: TyCon -> Maybe Class #

If this TyCon is that for a class instance, return the class it is for. Otherwise returns Nothing

isClassTyCon :: TyCon -> Bool #

Is this TyCon that for a class instance?

synTyConRhs_maybe :: TyCon -> Maybe Type #

Extract the information pertaining to the right hand side of a type synonym (type) declaration.

synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type) #

Extract the TyVars bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

tyConDataCons :: TyCon -> [DataCon] #

As tyConDataCons_maybe, but returns the empty list of constructors if no constructors could be found

isOpenTypeFamilyTyCon :: TyCon -> Bool #

Is this an open type family TyCon?

isTypeFamilyTyCon :: TyCon -> Bool #

Is this a synonym TyCon that can have may have further instances appear?

isOpenFamilyTyCon :: TyCon -> Bool #

Is this a TyCon, synonym or otherwise, that defines a family with instances?

isFamilyTyCon :: TyCon -> Bool #

Is this a TyCon, synonym or otherwise, that defines a family?

isTypeSynonymTyCon :: TyCon -> Bool #

Is this a TyCon representing a regular H98 type synonym (type)?

isNewTyCon :: TyCon -> Bool #

Is this TyCon that for a newtype

isPrimTyCon :: TyCon -> Bool #

Does this TyCon represent something that cannot be defined in Haskell?

pprFundeps :: Outputable a => [FunDep a] -> SDoc #

classTvsFds :: Class -> ([TyVar], [FunDep TyVar]) #

classSCTheta :: Class -> [PredType] #

classATs :: Class -> [TyCon] #

classMethods :: Class -> [Id] #

data Class #

Instances

Instances details
Eq Class 
Instance details

Defined in Class

Methods

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

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

Data Class 
Instance details

Defined in Class

Methods

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

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

toConstr :: Class -> Constr #

dataTypeOf :: Class -> DataType #

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

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

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

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

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

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

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

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

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

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

NamedThing Class 
Instance details

Defined in Class

Methods

getOccName :: Class -> OccName #

getName :: Class -> Name #

Uniquable Class 
Instance details

Defined in Class

Methods

getUnique :: Class -> Unique #

Outputable Class 
Instance details

Defined in Class

Methods

ppr :: Class -> SDoc #

pprPrec :: Rational -> Class -> SDoc #

dataConTyCon :: DataCon -> TyCon #

The type constructor that we are building via this data constructor

dataConFieldLabels :: DataCon -> [FieldLabel] #

The labels for the fields of this particular DataCon

data DataCon #

A data constructor

Instances

Instances details
Eq DataCon 
Instance details

Defined in DataCon

Methods

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

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

Data DataCon 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: DataCon -> Constr #

dataTypeOf :: DataCon -> DataType #

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

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

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

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

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

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

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

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

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

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

NamedThing DataCon 
Instance details

Defined in DataCon

Methods

getOccName :: DataCon -> OccName #

getName :: DataCon -> Name #

Uniquable DataCon 
Instance details

Defined in DataCon

Methods

getUnique :: DataCon -> Unique #

Outputable DataCon 
Instance details

Defined in DataCon

Methods

ppr :: DataCon -> SDoc #

pprPrec :: Rational -> DataCon -> SDoc #

OutputableBndr DataCon 
Instance details

Defined in DataCon

Methods

pprBndr :: BindingSite -> DataCon -> SDoc #

pprPrefixOcc :: DataCon -> SDoc #

pprInfixOcc :: DataCon -> SDoc #

bndrIsJoin_maybe :: DataCon -> Maybe Int #

pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc #

pprExpr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc #

pprSplice :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SDoc #

pprSpliceDecl :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SpliceExplicitFlag -> SDoc #

pprPatBind :: forall (bndr :: Pass) (p :: Pass) body. (OutputableBndrId bndr, OutputableBndrId p, Outputable body) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) body -> SDoc #

pprFunBind :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc #

data HsExpr p #

A Haskell expression.

Constructors

HsVar (XVar p) (Located (IdP p))

Variable

HsUnboundVar (XUnboundVar p) UnboundVar

Unbound variable; also used for "holes" (_ or _x). Turned from HsVar to HsUnboundVar by the renamer, when it finds an out-of-scope variable or hole. Turned into HsVar by type checker, to support deferred type errors.

HsConLikeOut (XConLikeOut p) ConLike

After typechecker only; must be different HsVar for pretty printing

HsRecFld (XRecFld p) (AmbiguousFieldOcc p)

Variable pointing to record selector Not in use after typechecking

HsOverLabel (XOverLabel p) (Maybe (IdP p)) FastString

Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels) Just id means RebindableSyntax is in use, and gives the id of the in-scope fromLabel. NB: Not in use after typechecking

HsIPVar (XIPVar p) HsIPName

Implicit parameter (not in use after typechecking)

HsOverLit (XOverLitE p) (HsOverLit p)

Overloaded literals

HsLit (XLitE p) (HsLit p)

Simple (non-overloaded) literals

HsLam (XLam p) (MatchGroup p (LHsExpr p))

Lambda abstraction. Currently always a single match

HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p))

Lambda-case

HsApp (XApp p) (LHsExpr p) (LHsExpr p)

Application

HsAppType (XAppTypeE p) (LHsExpr p) (LHsWcType (NoGhcTc p))

Visible type application

Explicit type argument; e.g f @Int x y NB: Has wildcards, but no implicit quantification

OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)

Operator applications: NB Bracketed ops such as (+) come out as Vars.

NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)

Negation operator. Contains the negated expression and the name of negate

HsPar (XPar p) (LHsExpr p)

Parenthesised expr; see Note [Parens in HsSyn]

SectionL (XSectionL p) (LHsExpr p) (LHsExpr p) 
SectionR (XSectionR p) (LHsExpr p) (LHsExpr p) 
ExplicitTuple (XExplicitTuple p) [LHsTupArg p] Boxity

Used for explicit tuples and sections thereof

ExplicitSum (XExplicitSum p) ConTag Arity (LHsExpr p)

Used for unboxed sum types

There will be multiple AnnVbar, (1 - alternative) before the expression, (arity - alternative) after it

HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))
HsIf (XIf p) (Maybe (SyntaxExpr p)) (LHsExpr p) (LHsExpr p) (LHsExpr p)
HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]

Multi-way if

HsLet (XLet p) (LHsLocalBinds p) (LHsExpr p)

let(rec)

HsDo (XDo p) (HsStmtContext Name) (Located [ExprLStmt p])
ExplicitList (XExplicitList p) (Maybe (SyntaxExpr p)) [LHsExpr p]

Syntactic list: [a,b,c,...]

RecordCon

Record construction

Fields

RecordUpd

Record update

Fields

ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))

Expression with an explicit type signature. e :: type

ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)

Arithmetic sequence

HsSCC (XSCC p) SourceText StringLiteral (LHsExpr p) 
HsCoreAnn (XCoreAnn p) SourceText StringLiteral (LHsExpr p)
HsBracket (XBracket p) (HsBracket p)
HsRnBracketOut (XRnBracketOut p) (HsBracket GhcRn) [PendingRnSplice] 
HsTcBracketOut (XTcBracketOut p) (HsBracket GhcRn) [PendingTcSplice] 
HsSpliceE (XSpliceE p) (HsSplice p)
HsProc (XProc p) (LPat p) (LHsCmdTop p)

proc notation for Arrows

HsStatic (XStatic p) (LHsExpr p)
HsTick (XTick p) (Tickish (IdP p)) (LHsExpr p) 
HsBinTick (XBinTick p) Int Int (LHsExpr p) 
HsTickPragma (XTickPragma p) SourceText (StringLiteral, (Int, Int), (Int, Int)) ((SourceText, SourceText), (SourceText, SourceText)) (LHsExpr p)
HsWrap (XWrap p) HsWrapper (HsExpr p) 
XExpr (XXExpr p) 

Instances

Instances details
p ~ GhcPs => DisambInfixOp (HsExpr p) 
Instance details

Defined in RdrHsSyn

Methods

mkHsVarOpPV :: Located RdrName -> PV (Located (HsExpr p)) #

mkHsConOpPV :: Located RdrName -> PV (Located (HsExpr p)) #

mkHsInfixHolePV :: SrcSpan -> PV (Located (HsExpr p)) #

p ~ GhcPs => DisambECP (HsExpr p) 
Instance details

Defined in RdrHsSyn

Associated Types

type Body (HsExpr p) :: Type -> Type #

type InfixOp (HsExpr p) #

type FunArg (HsExpr p) #

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsExpr p)) #

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsExpr p)) #

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsExpr p)) -> PV (Located (HsExpr p)) #

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

superInfixOp :: (DisambInfixOp (InfixOp (HsExpr p)) => PV (Located (HsExpr p))) -> PV (Located (HsExpr p)) #

mkHsOpAppPV :: SrcSpan -> Located (HsExpr p) -> Located (InfixOp (HsExpr p)) -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsExpr p)) -> PV (Located (HsExpr p)) #

superFunArg :: (DisambECP (FunArg (HsExpr p)) => PV (Located (HsExpr p))) -> PV (Located (HsExpr p)) #

mkHsAppPV :: SrcSpan -> Located (HsExpr p) -> Located (FunArg (HsExpr p)) -> PV (Located (HsExpr p)) #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsExpr p) -> Bool -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (HsExpr p))] -> PV (Located (HsExpr p)) #

mkHsParPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

mkHsVarPV :: Located RdrName -> PV (Located (HsExpr p)) #

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr p)) #

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsExpr p)) #

mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr p)) #

mkHsTySigPV :: SrcSpan -> Located (HsExpr p) -> LHsType GhcPs -> PV (Located (HsExpr p)) #

mkHsExplicitListPV :: SrcSpan -> [Located (HsExpr p)] -> PV (Located (HsExpr p)) #

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsExpr p)) #

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsExpr p) -> ([LHsRecField GhcPs (Located (HsExpr p))], Maybe SrcSpan) -> PV (Located (HsExpr p)) #

mkHsNegAppPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsExpr p)) -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

mkHsLazyPatPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p)) #

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsExpr p) -> PV (Located (HsExpr p)) #

OutputableBndrId p => Outputable (HsExpr (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsExpr (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsExpr (GhcPass p) -> SDoc #

HasType (LHsExpr GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsExpr GhcRn -> HieM [HieAST Type]

HasType (LHsExpr GhcTc)

This instance tries to construct HieAST nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs.

HsApp, for example, doesn't have any type information available directly on the node. Our next recourse would be to desugar it into a CoreExpr then query the type of that. Yet both the desugaring call and the type query both involve recursive calls to the function and argument! This is particularly problematic when you realize that the HIE traversal will eventually visit those nodes too and ask for their types again.

Since the above is quite costly, we just skip cases where computing the expression's type is going to be expensive.

See #16233

Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsExpr GhcTc -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (Context (Located (IdP a))), HasType (LHsExpr a), ToHie (PScoped (LPat a)), ToHie (MatchGroup a (LHsExpr a)), ToHie (LGRHS a (LHsExpr a)), ToHie (RContext (HsRecordBinds a)), ToHie (RFContext (Located (AmbiguousFieldOcc a))), ToHie (ArithSeqInfo a), ToHie (LHsCmdTop a), ToHie (RScoped (GuardLStmt a)), ToHie (RScoped (LHsLocalBinds a)), ToHie (TScoped (LHsWcType (NoGhcTc a))), ToHie (TScoped (LHsSigWcType (NoGhcTc a))), Data (HsExpr a), Data (HsSplice a), Data (HsTupArg a), Data (AmbiguousFieldOcc a), HasRealDataConName a) => ToHie (LHsExpr (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsExpr (GhcPass p) -> HieM [HieAST Type]

type FunArg (HsExpr p) 
Instance details

Defined in RdrHsSyn

type FunArg (HsExpr p) = HsExpr p
type InfixOp (HsExpr p) 
Instance details

Defined in RdrHsSyn

type InfixOp (HsExpr p) = HsExpr p
type Body (HsExpr p) 
Instance details

Defined in RdrHsSyn

type Body (HsExpr p) = HsExpr

data HsCmd id #

Haskell Command (e.g. a "statement" in an Arrow proc block)

Constructors

HsCmdArrApp (XCmdArrApp id) (LHsExpr id) (LHsExpr id) HsArrAppType Bool
HsCmdArrForm (XCmdArrForm id) (LHsExpr id) LexicalFixity (Maybe Fixity) [LHsCmdTop id]
HsCmdApp (XCmdApp id) (LHsCmd id) (LHsExpr id) 
HsCmdLam (XCmdLam id) (MatchGroup id (LHsCmd id))
HsCmdPar (XCmdPar id) (LHsCmd id)
HsCmdCase (XCmdCase id) (LHsExpr id) (MatchGroup id (LHsCmd id))
HsCmdIf (XCmdIf id) (Maybe (SyntaxExpr id)) (LHsExpr id) (LHsCmd id) (LHsCmd id)
HsCmdLet (XCmdLet id) (LHsLocalBinds id) (LHsCmd id)
HsCmdDo (XCmdDo id) (Located [CmdLStmt id])
HsCmdWrap (XCmdWrap id) HsWrapper (HsCmd id) 
XCmd (XXCmd id) 

Instances

Instances details
p ~ GhcPs => DisambECP (HsCmd p) 
Instance details

Defined in RdrHsSyn

Associated Types

type Body (HsCmd p) :: Type -> Type #

type InfixOp (HsCmd p) #

type FunArg (HsCmd p) #

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsCmd p)) #

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsCmd p)) #

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsCmd p)) -> PV (Located (HsCmd p)) #

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

superInfixOp :: (DisambInfixOp (InfixOp (HsCmd p)) => PV (Located (HsCmd p))) -> PV (Located (HsCmd p)) #

mkHsOpAppPV :: SrcSpan -> Located (HsCmd p) -> Located (InfixOp (HsCmd p)) -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsCmd p)) -> PV (Located (HsCmd p)) #

superFunArg :: (DisambECP (FunArg (HsCmd p)) => PV (Located (HsCmd p))) -> PV (Located (HsCmd p)) #

mkHsAppPV :: SrcSpan -> Located (HsCmd p) -> Located (FunArg (HsCmd p)) -> PV (Located (HsCmd p)) #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsCmd p) -> Bool -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (HsCmd p))] -> PV (Located (HsCmd p)) #

mkHsParPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

mkHsVarPV :: Located RdrName -> PV (Located (HsCmd p)) #

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd p)) #

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsCmd p)) #

mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd p)) #

mkHsTySigPV :: SrcSpan -> Located (HsCmd p) -> LHsType GhcPs -> PV (Located (HsCmd p)) #

mkHsExplicitListPV :: SrcSpan -> [Located (HsCmd p)] -> PV (Located (HsCmd p)) #

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsCmd p)) #

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsCmd p) -> ([LHsRecField GhcPs (Located (HsCmd p))], Maybe SrcSpan) -> PV (Located (HsCmd p)) #

mkHsNegAppPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsCmd p)) -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

mkHsLazyPatPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p)) #

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsCmd p) -> PV (Located (HsCmd p)) #

OutputableBndrId p => Outputable (HsCmd (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmd (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsCmd (GhcPass p) -> SDoc #

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (LHsExpr a), ToHie (MatchGroup a (LHsCmd a)), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (HsCmd a), Data (HsCmdTop a), Data (StmtLR a a (Located (HsCmd a))), Data (HsLocalBinds a), Data (StmtLR a a (Located (HsExpr a)))) => ToHie (LHsCmd (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsCmd (GhcPass p) -> HieM [HieAST Type]

type FunArg (HsCmd p) 
Instance details

Defined in RdrHsSyn

type FunArg (HsCmd p) = HsExpr p
type InfixOp (HsCmd p) 
Instance details

Defined in RdrHsSyn

type InfixOp (HsCmd p) = HsExpr p
type Body (HsCmd p) 
Instance details

Defined in RdrHsSyn

type Body (HsCmd p) = HsCmd

data HsSplice id #

Haskell Splice

Constructors

HsTypedSplice (XTypedSplice id) SpliceDecoration (IdP id) (LHsExpr id) 
HsUntypedSplice (XUntypedSplice id) SpliceDecoration (IdP id) (LHsExpr id) 
HsQuasiQuote (XQuasiQuote id) (IdP id) (IdP id) SrcSpan FastString 
HsSpliced (XSpliced id) ThModFinalizers (HsSplicedThing id) 
HsSplicedT DelayedSplice 
XSplice (XXSplice id) 

Instances

Instances details
OutputableBndrId p => Outputable (HsSplice (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplice (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsSplice (GhcPass p) -> SDoc #

(ToHie (LHsExpr a), Data (HsSplice a)) => ToHie (Located (HsSplice a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (HsSplice a) -> HieM [HieAST Type]

data MatchGroup p body #

Constructors

MG 

Fields

XMatchGroup (XXMatchGroup p body) 

Instances

Instances details
ToHie (LMatch a body) => ToHie (MatchGroup a body) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: MatchGroup a body -> HieM [HieAST Type]

data GRHSs p body #

Guarded Right-Hand Sides

GRHSs are used both for pattern bindings and for Matches

Constructors

GRHSs 

Fields

XGRHSs (XXGRHSs p body) 

Instances

Instances details
(ToHie body, ToHie (LGRHS a body), ToHie (RScoped (LHsLocalBinds a))) => ToHie (GRHSs a body) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: GRHSs a body -> HieM [HieAST Type]

data SyntaxExpr p #

Syntax Expression

SyntaxExpr is like PostTcExpr, but it's filled in a little earlier, by the renamer. It's used for rebindable syntax.

E.g. (>>=) is filled in before the renamer by the appropriate Name for (>>=), and then instantiated by the type checker with its type args etc

This should desugar to

syn_res_wrap $ syn_expr (syn_arg_wraps[0] arg0)
                        (syn_arg_wraps[1] arg1) ...

where the actual arguments come from elsewhere in the AST. This could be defined using GhcPass p and such, but it's harder to get it all to work out that way. (noSyntaxExpr is hard to write, for example.)

Constructors

SyntaxExpr 

Fields

Instances

Instances details
OutputableBndrId p => Outputable (SyntaxExpr (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExpr (GhcPass p) -> SDoc #

pprPrec :: Rational -> SyntaxExpr (GhcPass p) -> SDoc #

type LHsExpr p #

Arguments

 = Located (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Expression

pprImpExp :: (HasOccName name, OutputableBndr name) => name -> SDoc #

replaceLWrappedName :: LIEWrappedName name1 -> name2 -> LIEWrappedName name2 #

replaceWrappedName :: IEWrappedName name1 -> name2 -> IEWrappedName name2 #

ieLWrappedName :: LIEWrappedName name -> Located name #

lieWrappedName :: LIEWrappedName name -> name #

ieWrappedName :: IEWrappedName name -> name #

ieNames :: forall (p :: Pass). IE (GhcPass p) -> [IdP (GhcPass p)] #

ieName :: forall (p :: Pass). IE (GhcPass p) -> IdP (GhcPass p) #

simpleImportDecl :: forall (p :: Pass). ModuleName -> ImportDecl (GhcPass p) #

isImportDeclQualified :: ImportDeclQualifiedStyle -> Bool #

Convenience function to answer the question if an import decl. is qualified.

importDeclQualifiedStyle :: Maybe (Located a) -> Maybe (Located a) -> ImportDeclQualifiedStyle #

Given two possible located qualified tokens, compute a style (in a conforming Haskell program only one of the two can be not Nothing). This is called from y.

type LImportDecl pass #

Arguments

 = Located (ImportDecl pass)

When in a list this may have

Located Import Declaration

data ImportDeclQualifiedStyle #

If/how an import is qualified.

Constructors

QualifiedPre

qualified appears in prepositive position.

QualifiedPost

qualified appears in postpositive position.

NotQualified

Not qualified.

Instances

Instances details
Eq ImportDeclQualifiedStyle 
Instance details

Defined in GHC.Hs.ImpExp

Methods

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

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

Data ImportDeclQualifiedStyle 
Instance details

Defined in GHC.Hs.ImpExp

Methods

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

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

toConstr :: ImportDeclQualifiedStyle -> Constr #

dataTypeOf :: ImportDeclQualifiedStyle -> DataType #

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

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

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

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

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

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

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

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

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

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

data ImportDecl pass #

Import Declaration

A single Haskell import declaration.

Constructors

ImportDecl 

Fields

XImportDecl (XXImportDecl pass)

AnnKeywordIds

Instances

Instances details
NFData (ImportDecl GhcPs) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: ImportDecl GhcPs -> () #

OutputableBndrId p => Outputable (ImportDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> ImportDecl (GhcPass p) -> SDoc #

ToHie (LImportDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LImportDecl GhcRn -> HieM [HieAST Type]

data IEWrappedName name #

A name in an import or export specification which may have adornments. Used primarily for accurate pretty printing of ParsedSource, and API Annotation placement.

Constructors

IEName (Located name)

no extra

IEPattern (Located name)

pattern X

IEType (Located name)

type (:+:)

Instances

Instances details
Eq name => Eq (IEWrappedName name) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

(==) :: IEWrappedName name -> IEWrappedName name -> Bool #

(/=) :: IEWrappedName name -> IEWrappedName name -> Bool #

Data name => Data (IEWrappedName name) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IEWrappedName name -> c (IEWrappedName name) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IEWrappedName name) #

toConstr :: IEWrappedName name -> Constr #

dataTypeOf :: IEWrappedName name -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> IEWrappedName name -> IEWrappedName name #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IEWrappedName name -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IEWrappedName name -> r #

gmapQ :: (forall d. Data d => d -> u) -> IEWrappedName name -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IEWrappedName name -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name) #

HasOccName name => HasOccName (IEWrappedName name) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

occName :: IEWrappedName name -> OccName #

OutputableBndr name => Outputable (IEWrappedName name) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

ppr :: IEWrappedName name -> SDoc #

pprPrec :: Rational -> IEWrappedName name -> SDoc #

OutputableBndr name => OutputableBndr (IEWrappedName name) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

pprBndr :: BindingSite -> IEWrappedName name -> SDoc #

pprPrefixOcc :: IEWrappedName name -> SDoc #

pprInfixOcc :: IEWrappedName name -> SDoc #

bndrIsJoin_maybe :: IEWrappedName name -> Maybe Int #

ToHie (IEContext (LIEWrappedName Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (LIEWrappedName Name) -> HieM [HieAST Type]

type LIEWrappedName name = Located (IEWrappedName name) #

Located name with possible adornment - AnnKeywordIds : AnnType, AnnPattern

type LIE pass #

Arguments

 = Located (IE pass)

When in a list this may have

Located Import or Export

data IE pass #

Imported or exported entity.

Constructors

IEVar (XIEVar pass) (LIEWrappedName (IdP pass))

Imported or Exported Variable

IEThingAbs (XIEThingAbs pass) (LIEWrappedName (IdP pass))

Imported or exported Thing with Absent list

The thing is a Class/Type (can't tell) - AnnKeywordIds : AnnPattern, AnnType,AnnVal

IEThingAll (XIEThingAll pass) (LIEWrappedName (IdP pass))

Imported or exported Thing with All imported or exported

The thing is a ClassType and the All refers to methodsconstructors

IEThingWith (XIEThingWith pass) (LIEWrappedName (IdP pass)) IEWildcard [LIEWrappedName (IdP pass)] [Located (FieldLbl (IdP pass))]

Imported or exported Thing With given imported or exported

The thing is a Class/Type and the imported or exported things are methods/constructors and record fields; see Note [IEThingWith] - AnnKeywordIds : AnnOpen, AnnClose, AnnComma, AnnType

IEModuleContents (XIEModuleContents pass) (Located ModuleName)

Imported or exported module contents

(Export Only)

IEGroup (XIEGroup pass) Int HsDocString

Doc section heading

IEDoc (XIEDoc pass) HsDocString

Some documentation

IEDocNamed (XIEDocNamed pass) String

Reference to named doc

XIE (XXIE pass) 

Instances

Instances details
OutputableBndrId p => Outputable (IE (GhcPass p)) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc #

pprPrec :: Rational -> IE (GhcPass p) -> SDoc #

ToHie (IEContext (LIE GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (LIE GhcRn) -> HieM [HieAST Type]

data IEWildcard #

Imported or Exported Wildcard

Constructors

NoIEWildcard 
IEWildcard Int 

Instances

Instances details
Eq IEWildcard 
Instance details

Defined in GHC.Hs.ImpExp

Methods

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

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

Data IEWildcard 
Instance details

Defined in GHC.Hs.ImpExp

Methods

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

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

toConstr :: IEWildcard -> Constr #

dataTypeOf :: IEWildcard -> DataType #

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

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

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

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

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

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

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

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

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

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

data Pat p #

Pattern

Constructors

WildPat (XWildPat p)

Wildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> Type

VarPat (XVarPat p) (Located (IdP p))

Variable Pattern

LazyPat (XLazyPat p) (LPat p)

Lazy Pattern ^ - AnnKeywordId : AnnTilde

AsPat (XAsPat p) (Located (IdP p)) (LPat p)

As pattern ^ - AnnKeywordId : AnnAt

ParPat (XParPat p) (LPat p)

Parenthesised pattern See Note [Parens in HsSyn] in GHC.Hs.Expr ^ - AnnKeywordId : AnnOpen '(', AnnClose ')'

BangPat (XBangPat p) (LPat p)

Bang pattern ^ - AnnKeywordId : AnnBang

ListPat (XListPat p) [LPat p]

Syntactic List

TuplePat (XTuplePat p) [LPat p] Boxity

Tuple sub-patterns

SumPat (XSumPat p) (LPat p) ConTag Arity

Anonymous sum pattern

ConPatIn (Located (IdP p)) (HsConPatDetails p)

Constructor Pattern In

ConPatOut

Constructor Pattern Out

Fields

ViewPat (XViewPat p) (LHsExpr p) (LPat p)

View Pattern

SplicePat (XSplicePat p) (HsSplice p)

Splice Pattern (Includes quasi-quotes)

LitPat (XLitPat p) (HsLit p)

Literal Pattern Used for *non-overloaded* literal patterns: Int, Int, Char, String, etc.

NPat (XNPat p) (Located (HsOverLit p)) (Maybe (SyntaxExpr p)) (SyntaxExpr p)

Natural Pattern

NPlusKPat (XNPlusKPat p) (Located (IdP p)) (Located (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p)

n+k pattern

SigPat (XSigPat p) (LPat p) (LHsSigWcType (NoGhcTc p))

Pattern with a type signature

CoPat (XCoPat p) HsWrapper (Pat p) Type

Coercion Pattern

XPat (XXPat p)

Trees that Grow extension point for new constructors

Instances

Instances details
OutputableBndrId p => Outputable (Pat (GhcPass p)) 
Instance details

Defined in GHC.Hs.Pat

Methods

ppr :: Pat (GhcPass p) -> SDoc #

pprPrec :: Rational -> Pat (GhcPass p) -> SDoc #

HasType (Located (Pat GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: Located (Pat GhcRn) -> HieM [HieAST Type]

HasType (Located (Pat GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: Located (Pat GhcTc) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (Context (Located (IdP a))), ToHie (RContext (HsRecFields a (PScoped (LPat a)))), ToHie (LHsExpr a), ToHie (TScoped (LHsSigWcType a)), ProtectSig a, ToHie (TScoped (ProtectedSig a)), HasType (LPat a), Data (HsSplice a)) => ToHie (PScoped (Located (Pat (GhcPass p)))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: PScoped (Located (Pat (GhcPass p))) -> HieM [HieAST Type]

type LPat p = XRec p Pat #

noExtCon :: NoExtCon -> a #

Eliminate a NoExtCon. Much like absurd.

noExtField :: NoExtField #

Used when constructing a term with an unused extension point.

data NoExtField #

A placeholder type for TTG extension points that are not currently unused to represent any particular value.

This should not be confused with NoExtCon, which are found in unused extension constructors and therefore should never be inhabited. In contrast, NoExtField is used in extension points (e.g., as the field of some constructor), so it must have an inhabitant to construct AST passes that manipulate fields with that extension point as their type.

Constructors

NoExtField 

Instances

Instances details
Eq NoExtField 
Instance details

Defined in GHC.Hs.Extension

Methods

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

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

Data NoExtField 
Instance details

Defined in GHC.Hs.Extension

Methods

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

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

toConstr :: NoExtField -> Constr #

dataTypeOf :: NoExtField -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord NoExtField 
Instance details

Defined in GHC.Hs.Extension

Methods

compare :: NoExtField -> NoExtField -> Ordering #

(<) :: NoExtField -> NoExtField -> Bool #

(<=) :: NoExtField -> NoExtField -> Bool #

(>) :: NoExtField -> NoExtField -> Bool #

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

max :: NoExtField -> NoExtField -> NoExtField #

min :: NoExtField -> NoExtField -> NoExtField #

Outputable NoExtField 
Instance details

Defined in GHC.Hs.Extension

Methods

ppr :: NoExtField -> SDoc #

pprPrec :: Rational -> NoExtField -> SDoc #

ToHie (TScoped NoExtField) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped NoExtField -> HieM [HieAST Type]

ToHie (Context (Located NoExtField)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Context (Located NoExtField) -> HieM [HieAST Type]

data NoExtCon #

Used in TTG extension constructors that have yet to be extended with anything. If an extension constructor has NoExtCon as its field, it is not intended to ever be constructed anywhere, and any function that consumes the extension constructor can eliminate it by way of noExtCon.

This should not be confused with NoExtField, which are found in unused extension points (not constructors) and therefore can be inhabited.

Instances

Instances details
Eq NoExtCon 
Instance details

Defined in GHC.Hs.Extension

Methods

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

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

Data NoExtCon 
Instance details

Defined in GHC.Hs.Extension

Methods

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

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

toConstr :: NoExtCon -> Constr #

dataTypeOf :: NoExtCon -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord NoExtCon 
Instance details

Defined in GHC.Hs.Extension

Methods

compare :: NoExtCon -> NoExtCon -> Ordering #

(<) :: NoExtCon -> NoExtCon -> Bool #

(<=) :: NoExtCon -> NoExtCon -> Bool #

(>) :: NoExtCon -> NoExtCon -> Bool #

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

max :: NoExtCon -> NoExtCon -> NoExtCon #

min :: NoExtCon -> NoExtCon -> NoExtCon #

Outputable NoExtCon 
Instance details

Defined in GHC.Hs.Extension

Methods

ppr :: NoExtCon -> SDoc #

pprPrec :: Rational -> NoExtCon -> SDoc #

data GhcPass (c :: Pass) #

Used as a data type index for the hsSyn AST

Instances

Instances details
HasRealDataConName GhcRn 
Instance details

Defined in Compat.HieAst

Methods

getRealDataCon :: XRecordCon GhcRn -> Located (IdP GhcRn) -> Located (IdP GhcRn)

HasRealDataConName GhcTc 
Instance details

Defined in Compat.HieAst

Methods

getRealDataCon :: XRecordCon GhcTc -> Located (IdP GhcTc) -> Located (IdP GhcTc)

ProtectSig GhcRn 
Instance details

Defined in Compat.HieAst

Methods

protectSig :: Scope -> LHsSigWcType (NoGhcTc GhcRn) -> ProtectedSig GhcRn

ProtectSig GhcTc 
Instance details

Defined in Compat.HieAst

Methods

protectSig :: Scope -> LHsSigWcType (NoGhcTc GhcTc) -> ProtectedSig GhcTc

Eq (XCFieldOcc (GhcPass p)) => Eq (FieldOcc (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

(==) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

(/=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

Eq (GhcPass c) 
Instance details

Defined in GHC.Hs.Extension

Methods

(==) :: GhcPass c -> GhcPass c -> Bool #

(/=) :: GhcPass c -> GhcPass c -> Bool #

Data (HsModule GhcPs) 
Instance details

Defined in GHC.Hs

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 :: forall r r'. (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 GHC.Hs

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 :: forall r r'. (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 GHC.Hs

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 :: forall r r'. (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) #

Typeable c => Data (GhcPass c) 
Instance details

Defined in GHC.Hs.Extension

Methods

gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> GhcPass c -> c0 (GhcPass c) #

gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (GhcPass c) #

toConstr :: GhcPass c -> Constr #

dataTypeOf :: GhcPass c -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> GhcPass c -> GhcPass c #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GhcPass c -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GhcPass c -> r #

gmapQ :: (forall d. Data d => d -> u) -> GhcPass c -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GhcPass c -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c) #

Ord (XCFieldOcc (GhcPass p)) => Ord (FieldOcc (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

compare :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Ordering #

(<) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

(<=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

(>) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

(>=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #

max :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) #

min :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) #

NFData (ImportDecl GhcPs) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: ImportDecl GhcPs -> () #

DisambECP (PatBuilder GhcPs) 
Instance details

Defined in RdrHsSyn

Associated Types

type Body (PatBuilder GhcPs) :: Type -> Type #

type InfixOp (PatBuilder GhcPs) #

type FunArg (PatBuilder GhcPs) #

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (PatBuilder GhcPs)) #

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (PatBuilder GhcPs)) #

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs)) #

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

superInfixOp :: (DisambInfixOp (InfixOp (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs)) #

mkHsOpAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs)) #

superFunArg :: (DisambECP (FunArg (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs)) #

mkHsAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (FunArg (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs)) #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (PatBuilder GhcPs) -> Bool -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (PatBuilder GhcPs))] -> PV (Located (PatBuilder GhcPs)) #

mkHsParPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsVarPV :: Located RdrName -> PV (Located (PatBuilder GhcPs)) #

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsWildCardPV :: SrcSpan -> PV (Located (PatBuilder GhcPs)) #

mkHsTySigPV :: SrcSpan -> Located (PatBuilder GhcPs) -> LHsType GhcPs -> PV (Located (PatBuilder GhcPs)) #

mkHsExplicitListPV :: SrcSpan -> [Located (PatBuilder GhcPs)] -> PV (Located (PatBuilder GhcPs)) #

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (PatBuilder GhcPs) -> ([LHsRecField GhcPs (Located (PatBuilder GhcPs))], Maybe SrcSpan) -> PV (Located (PatBuilder GhcPs)) #

mkHsNegAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkHsLazyPatPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #

NamedThing (HsTyVarBndr GhcRn) 
Instance details

Defined in GHC.Hs.Types

Methods

getOccName :: HsTyVarBndr GhcRn -> OccName #

getName :: HsTyVarBndr GhcRn -> Name #

OutputableBndrId a => Outputable (InstInfo (GhcPass a)) 
Instance details

Defined in TcEnv

Methods

ppr :: InstInfo (GhcPass a) -> SDoc #

pprPrec :: Rational -> InstInfo (GhcPass a) -> SDoc #

Outputable (PatBuilder GhcPs) 
Instance details

Defined in RdrHsSyn

Methods

ppr :: PatBuilder GhcPs -> SDoc #

pprPrec :: Rational -> PatBuilder GhcPs -> SDoc #

OutputableBndrId p => Outputable (HsModule (GhcPass p)) 
Instance details

Defined in GHC.Hs

Methods

ppr :: HsModule (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsModule (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsCmdTop (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmdTop (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsCmdTop (GhcPass p) -> SDoc #

OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: ApplicativeArg (GhcPass idL) -> SDoc #

pprPrec :: Rational -> ApplicativeArg (GhcPass idL) -> SDoc #

OutputableBndrId p => Outputable (HsSplicedThing (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplicedThing (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsSplicedThing (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsBracket (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsBracket (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsBracket (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: ArithSeqInfo (GhcPass p) -> SDoc #

pprPrec :: Rational -> ArithSeqInfo (GhcPass p) -> SDoc #

(Outputable (GhcPass p), Outputable (NameOrRdrName (GhcPass p))) => Outputable (HsStmtContext (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsStmtContext (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsStmtContext (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsGroup (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsGroup (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsGroup (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (SpliceDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: SpliceDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> SpliceDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (TyClDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: TyClDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> TyClDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (TyClGroup (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: TyClGroup (GhcPass p) -> SDoc #

pprPrec :: Rational -> TyClGroup (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (FamilyDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> FamilyDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsDataDefn (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsDataDefn (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsDataDefn (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsDerivingClause (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: HsDerivingClause (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsDerivingClause (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (StandaloneKindSig (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: StandaloneKindSig (GhcPass p) -> SDoc #

pprPrec :: Rational -> StandaloneKindSig (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (ConDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ConDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> ConDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (TyFamInstDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: TyFamInstDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> TyFamInstDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (DataFamInstDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DataFamInstDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> DataFamInstDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (ClsInstDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ClsInstDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> ClsInstDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (InstDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: InstDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> InstDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (DerivDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DerivDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> DerivDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (DerivStrategy (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DerivStrategy (GhcPass p) -> SDoc #

pprPrec :: Rational -> DerivStrategy (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (DefaultDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: DefaultDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> DefaultDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (ForeignDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> ForeignDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (RuleDecls (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecls (GhcPass p) -> SDoc #

pprPrec :: Rational -> RuleDecls (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (RuleDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> RuleDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (RuleBndr (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RuleBndr (GhcPass p) -> SDoc #

pprPrec :: Rational -> RuleBndr (GhcPass p) -> SDoc #

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecls (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecls (GhcPass p) -> SDoc #

pprPrec :: Rational -> WarnDecls (GhcPass p) -> SDoc #

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> WarnDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (AnnDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: AnnDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> AnnDecl (GhcPass p) -> SDoc #

OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.Decls

Methods

ppr :: RoleAnnotDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> RoleAnnotDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (ABExport (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: ABExport (GhcPass p) -> SDoc #

pprPrec :: Rational -> ABExport (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsIPBinds (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: HsIPBinds (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsIPBinds (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (IPBind (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: IPBind (GhcPass p) -> SDoc #

pprPrec :: Rational -> IPBind (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (Sig (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: Sig (GhcPass p) -> SDoc #

pprPrec :: Rational -> Sig (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (FixitySig (GhcPass p)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: FixitySig (GhcPass p) -> SDoc #

pprPrec :: Rational -> FixitySig (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: LHsQTyVars (GhcPass p) -> SDoc #

pprPrec :: Rational -> LHsQTyVars (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsTyVarBndr (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsTyVarBndr (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsTyVarBndr (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsType (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsType (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsType (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (ConDeclField (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: ConDeclField (GhcPass p) -> SDoc #

pprPrec :: Rational -> ConDeclField (GhcPass p) -> SDoc #

Outputable (AmbiguousFieldOcc (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: AmbiguousFieldOcc (GhcPass p) -> SDoc #

pprPrec :: Rational -> AmbiguousFieldOcc (GhcPass p) -> SDoc #

Outputable (HsLit (GhcPass p)) 
Instance details

Defined in GHC.Hs.Lit

Methods

ppr :: HsLit (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsLit (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsOverLit (GhcPass p)) 
Instance details

Defined in GHC.Hs.Lit

Methods

ppr :: HsOverLit (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsOverLit (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsExpr (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsExpr (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsExpr (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsCmd (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmd (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsCmd (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (HsSplice (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplice (GhcPass p) -> SDoc #

pprPrec :: Rational -> HsSplice (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (SyntaxExpr (GhcPass p)) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExpr (GhcPass p) -> SDoc #

pprPrec :: Rational -> SyntaxExpr (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (ImportDecl (GhcPass p)) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc #

pprPrec :: Rational -> ImportDecl (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (IE (GhcPass p)) 
Instance details

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc #

pprPrec :: Rational -> IE (GhcPass p) -> SDoc #

OutputableBndrId p => Outputable (Pat (GhcPass p)) 
Instance details

Defined in GHC.Hs.Pat

Methods

ppr :: Pat (GhcPass p) -> SDoc #

pprPrec :: Rational -> Pat (GhcPass p) -> SDoc #

OutputableBndr (AmbiguousFieldOcc (GhcPass p)) 
Instance details

Defined in GHC.Hs.Types

Methods

pprBndr :: BindingSite -> AmbiguousFieldOcc (GhcPass p) -> SDoc #

pprPrefixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc #

pprInfixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc #

bndrIsJoin_maybe :: AmbiguousFieldOcc (GhcPass p) -> Maybe Int #

HasLoc (HsDataDefn GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

loc :: HsDataDefn GhcRn -> SrcSpan

HasLoc (LHsQTyVars GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

loc :: LHsQTyVars GhcRn -> SrcSpan

HasType (LHsBind GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsBind GhcRn -> HieM [HieAST Type]

HasType (LHsBind GhcTc) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsBind GhcTc -> HieM [HieAST Type]

HasType (LHsExpr GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsExpr GhcRn -> HieM [HieAST Type]

HasType (LHsExpr GhcTc)

This instance tries to construct HieAST nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs.

HsApp, for example, doesn't have any type information available directly on the node. Our next recourse would be to desugar it into a CoreExpr then query the type of that. Yet both the desugaring call and the type query both involve recursive calls to the function and argument! This is particularly problematic when you realize that the HIE traversal will eventually visit those nodes too and ask for their types again.

Since the above is quite costly, we just skip cases where computing the expression's type is going to be expensive.

See #16233

Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsExpr GhcTc -> HieM [HieAST Type]

HasType (Located (Pat GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: Located (Pat GhcRn) -> HieM [HieAST Type]

HasType (Located (Pat GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: Located (Pat GhcTc) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (LHsExpr a), Data (HsTupArg a)) => ToHie (LHsTupArg (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsTupArg (GhcPass p) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (LHsExpr a), ToHie (MatchGroup a (LHsCmd a)), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (HsCmd a), Data (HsCmdTop a), Data (StmtLR a a (Located (HsCmd a))), Data (HsLocalBinds a), Data (StmtLR a a (Located (HsExpr a)))) => ToHie (LHsCmd (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsCmd (GhcPass p) -> HieM [HieAST Type]

ToHie (LSpliceDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LSpliceDecl GhcRn -> HieM [HieAST Type]

ToHie (LTyClDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LTyClDecl GhcRn -> HieM [HieAST Type]

ToHie (TyClGroup GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TyClGroup GhcRn -> HieM [HieAST Type]

ToHie (LFamilyDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LFamilyDecl GhcRn -> HieM [HieAST Type]

ToHie (LInjectivityAnn GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LInjectivityAnn GhcRn -> HieM [HieAST Type]

ToHie (FamilyInfo GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: FamilyInfo GhcRn -> HieM [HieAST Type]

ToHie (HsDataDefn GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsDataDefn GhcRn -> HieM [HieAST Type]

ToHie (HsDeriving GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsDeriving GhcRn -> HieM [HieAST Type]

ToHie (LHsDerivingClause GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsDerivingClause GhcRn -> HieM [HieAST Type]

ToHie (LStandaloneKindSig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LStandaloneKindSig GhcRn -> HieM [HieAST Type]

ToHie (StandaloneKindSig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: StandaloneKindSig GhcRn -> HieM [HieAST Type]

ToHie (LConDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LConDecl GhcRn -> HieM [HieAST Type]

ToHie (LTyFamInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LTyFamInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LDataFamInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDataFamInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LClsInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LClsInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LDerivDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDerivDecl GhcRn -> HieM [HieAST Type]

ToHie (LDefaultDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDefaultDecl GhcRn -> HieM [HieAST Type]

ToHie (LForeignDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LForeignDecl GhcRn -> HieM [HieAST Type]

ToHie (LRuleDecls GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRuleDecls GhcRn -> HieM [HieAST Type]

ToHie (LRuleDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRuleDecl GhcRn -> HieM [HieAST Type]

ToHie (LWarnDecls GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LWarnDecls GhcRn -> HieM [HieAST Type]

ToHie (LWarnDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LWarnDecl GhcRn -> HieM [HieAST Type]

ToHie (LAnnDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LAnnDecl GhcRn -> HieM [HieAST Type]

ToHie (LRoleAnnotDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRoleAnnotDecl GhcRn -> HieM [HieAST Type]

ToHie (LFixitySig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LFixitySig GhcRn -> HieM [HieAST Type]

ToHie (LHsContext GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsContext GhcRn -> HieM [HieAST Type]

ToHie (LHsType GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsType GhcRn -> HieM [HieAST Type]

ToHie (LConDeclField GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LConDeclField GhcRn -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (Context (Located (IdP a))), HasType (LHsExpr a), ToHie (PScoped (LPat a)), ToHie (MatchGroup a (LHsExpr a)), ToHie (LGRHS a (LHsExpr a)), ToHie (RContext (HsRecordBinds a)), ToHie (RFContext (Located (AmbiguousFieldOcc a))), ToHie (ArithSeqInfo a), ToHie (LHsCmdTop a), ToHie (RScoped (GuardLStmt a)), ToHie (RScoped (LHsLocalBinds a)), ToHie (TScoped (LHsWcType (NoGhcTc a))), ToHie (TScoped (LHsSigWcType (NoGhcTc a))), Data (HsExpr a), Data (HsSplice a), Data (HsTupArg a), Data (AmbiguousFieldOcc a), HasRealDataConName a) => ToHie (LHsExpr (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsExpr (GhcPass p) -> HieM [HieAST Type]

ToHie (LImportDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LImportDecl GhcRn -> HieM [HieAST Type]

ToHie (Located [LConDeclField GhcRn]) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located [LConDeclField GhcRn] -> HieM [HieAST Type]

ToHie (Located (DerivStrategy GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (DerivStrategy GhcRn) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (Context (Located (IdP a))), ToHie (RContext (HsRecFields a (PScoped (LPat a)))), ToHie (LHsExpr a), ToHie (TScoped (LHsSigWcType a)), ProtectSig a, ToHie (TScoped (ProtectedSig a)), HasType (LPat a), Data (HsSplice a)) => ToHie (PScoped (Located (Pat (GhcPass p)))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: PScoped (Located (Pat (GhcPass p))) -> HieM [HieAST Type]

(ToHie rhs, HasLoc rhs) => ToHie (TScoped (FamEqn GhcRn rhs)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (FamEqn GhcRn rhs) -> HieM [HieAST Type]

ToHie (TScoped (LHsType GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsType GhcRn) -> HieM [HieAST Type]

ToHie (TScoped (LHsQTyVars GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsQTyVars GhcRn) -> HieM [HieAST Type]

(HasLoc thing, ToHie (TScoped thing)) => ToHie (TScoped (HsImplicitBndrs GhcRn thing)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (HsImplicitBndrs GhcRn thing) -> HieM [HieAST Type]

(HasLoc thing, ToHie (TScoped thing)) => ToHie (TScoped (HsWildCardBndrs GhcRn thing)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (HsWildCardBndrs GhcRn thing) -> HieM [HieAST Type]

ToHie (TScoped (LHsWcType GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsWcType GhcTc) -> HieM [HieAST Type]

ToHie (TScoped (LHsSigWcType GhcTc))

Dummy instances - never called

Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsSigWcType GhcTc) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (LHsExpr a), ToHie (SigContext (LSig a)), ToHie (RScoped (LHsLocalBinds a)), ToHie (RScoped (ApplicativeArg a)), ToHie (Located body), Data (StmtLR a a (Located body)), Data (StmtLR a a (Located (HsExpr a)))) => ToHie (RScoped (LStmt (GhcPass p) (Located body))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LStmt (GhcPass p) (Located body)) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (LHsExpr a), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (StmtLR a a (Located (HsExpr a))), Data (HsLocalBinds a)) => ToHie (RScoped (ApplicativeArg (GhcPass p))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (ApplicativeArg (GhcPass p)) -> HieM [HieAST Type]

ToHie (RScoped (LFamilyResultSig GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LFamilyResultSig GhcRn) -> HieM [HieAST Type]

ToHie (RScoped (LRuleBndr GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LRuleBndr GhcRn) -> HieM [HieAST Type]

ToHie (RScoped (NHsValBindsLR GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (NHsValBindsLR GhcRn) -> HieM [HieAST Type]

ToHie (RScoped (NHsValBindsLR GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (NHsValBindsLR GhcTc) -> HieM [HieAST Type]

ToHie (SigContext (LSig GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: SigContext (LSig GhcRn) -> HieM [HieAST Type]

ToHie (SigContext (LSig GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: SigContext (LSig GhcTc) -> HieM [HieAST Type]

ToHie (RFContext (LFieldOcc GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (LFieldOcc GhcRn) -> HieM [HieAST Type]

ToHie (RFContext (LFieldOcc GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (LFieldOcc GhcTc) -> HieM [HieAST Type]

ToHie (RFContext (Located (AmbiguousFieldOcc GhcRn))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (Located (AmbiguousFieldOcc GhcRn)) -> HieM [HieAST Type]

ToHie (RFContext (Located (AmbiguousFieldOcc GhcTc))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (Located (AmbiguousFieldOcc GhcTc)) -> HieM [HieAST Type]

ToHie (IEContext (LIE GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (LIE GhcRn) -> HieM [HieAST Type]

ToHie (TVScoped (LHsTyVarBndr GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TVScoped (LHsTyVarBndr GhcRn) -> HieM [HieAST Type]

(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: Match (GhcPass pr) body -> SDoc #

pprPrec :: Rational -> Match (GhcPass pr) body -> SDoc #

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsLocalBindsLR (GhcPass pl) (GhcPass pr)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

pprPrec :: Rational -> HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsValBindsLR (GhcPass pl) (GhcPass pr)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

pprPrec :: Rational -> HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsBindLR (GhcPass pl) (GhcPass pr)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc #

pprPrec :: Rational -> HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc #

(OutputableBndrId l, OutputableBndrId r, Outputable (XXPatSynBind (GhcPass l) (GhcPass r))) => Outputable (PatSynBind (GhcPass l) (GhcPass r)) 
Instance details

Defined in GHC.Hs.Binds

Methods

ppr :: PatSynBind (GhcPass l) (GhcPass r) -> SDoc #

pprPrec :: Rational -> PatSynBind (GhcPass l) (GhcPass r) -> SDoc #

Outputable thing => Outputable (HsImplicitBndrs (GhcPass p) thing) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsImplicitBndrs (GhcPass p) thing -> SDoc #

pprPrec :: Rational -> HsImplicitBndrs (GhcPass p) thing -> SDoc #

Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing) 
Instance details

Defined in GHC.Hs.Types

Methods

ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc #

pprPrec :: Rational -> HsWildCardBndrs (GhcPass p) thing -> SDoc #

(a ~ GhcPass p, ToHie body, ToHie (HsMatchContext (NameOrRdrName (IdP a))), ToHie (PScoped (LPat a)), ToHie (GRHSs a body), Data (Match a body)) => ToHie (LMatch (GhcPass p) body) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LMatch (GhcPass p) body -> HieM [HieAST Type]

(ToHie rhs, HasLoc rhs) => ToHie (FamEqn GhcRn rhs) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: FamEqn GhcRn rhs -> HieM [HieAST Type]

(OutputableBndrId pl, OutputableBndrId pr, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body) 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc #

pprPrec :: Rational -> StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc #

type IdP GhcPs 
Instance details

Defined in GHC.Hs.Extension

type IdP GhcPs = RdrName
type IdP GhcRn 
Instance details

Defined in GHC.Hs.Extension

type IdP GhcRn = Name
type IdP GhcTc 
Instance details

Defined in GHC.Hs.Extension

type IdP GhcTc = Id
type XIPBinds GhcPs 
Instance details

Defined in GHC.Hs.Binds

type XIPBinds GhcPs = NoExtField
type XIPBinds GhcRn 
Instance details

Defined in GHC.Hs.Binds

type XIPBinds GhcRn = NoExtField
type XIPBinds GhcTc 
Instance details

Defined in GHC.Hs.Binds

type XIPBinds GhcTc = TcEvBinds
type XSynDecl GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XSynDecl GhcPs = NoExtField
type XSynDecl GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XSynDecl GhcRn = NameSet
type XSynDecl GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XSynDecl GhcTc = NameSet
type XDataDecl GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XDataDecl GhcPs = NoExtField
type XDataDecl GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XDataDecl GhcRn = DataDeclRn
type XDataDecl GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XDataDecl GhcTc = DataDeclRn
type XClassDecl GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XClassDecl GhcPs = NoExtField
type XClassDecl GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XClassDecl GhcRn = NameSet
type XClassDecl GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XClassDecl GhcTc = NameSet
type XViaStrategy GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XViaStrategy GhcPs = LHsSigType GhcPs
type XViaStrategy GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XViaStrategy GhcRn = LHsSigType GhcRn
type XViaStrategy GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XViaStrategy GhcTc = Type
type XForeignImport GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XForeignImport GhcPs = NoExtField
type XForeignImport GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XForeignImport GhcRn = NoExtField
type XForeignImport GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XForeignImport GhcTc = Coercion
type XForeignExport GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XForeignExport GhcPs = NoExtField
type XForeignExport GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XForeignExport GhcRn = NoExtField
type XForeignExport GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XForeignExport GhcTc = Coercion
type XHsRule GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XHsRule GhcPs = NoExtField
type XHsRule GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XHsRule GhcRn = HsRuleRn
type XHsRule GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XHsRule GhcTc = HsRuleRn
type XOpApp GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XOpApp GhcPs = NoExtField
type XOpApp GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XOpApp GhcRn = Fixity
type XOpApp GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XOpApp GhcTc = Fixity
type XExplicitSum GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XExplicitSum GhcPs = NoExtField
type XExplicitSum GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XExplicitSum GhcRn = NoExtField
type XExplicitSum GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XExplicitSum GhcTc = [Type]
type XMultiIf GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XMultiIf GhcPs = NoExtField
type XMultiIf GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XMultiIf GhcRn = NoExtField
type XMultiIf GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XMultiIf GhcTc = Type
type XDo GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XDo GhcPs = NoExtField
type XDo GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XDo GhcRn = NoExtField
type XDo GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XDo GhcTc = Type
type XExplicitList GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XExplicitList GhcPs = NoExtField
type XExplicitList GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XExplicitList GhcRn = NoExtField
type XExplicitList GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XExplicitList GhcTc = Type
type XRecordCon GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XRecordCon GhcPs = NoExtField
type XRecordCon GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XRecordCon GhcRn = NoExtField
type XRecordCon GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XRecordCon GhcTc = RecordConTc
type XRecordUpd GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XRecordUpd GhcPs = NoExtField
type XRecordUpd GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XRecordUpd GhcRn = NoExtField
type XRecordUpd GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XRecordUpd GhcTc = RecordUpdTc
type XArithSeq GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XArithSeq GhcPs = NoExtField
type XArithSeq GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XArithSeq GhcRn = NoExtField
type XArithSeq GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XArithSeq GhcTc = PostTcExpr
type XStatic GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XStatic GhcPs = NoExtField
type XStatic GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XStatic GhcRn = NameSet
type XStatic GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XStatic GhcTc = NameSet
type XUnambiguous GhcPs 
Instance details

Defined in GHC.Hs.Types

type XUnambiguous GhcPs = NoExtField
type XUnambiguous GhcRn 
Instance details

Defined in GHC.Hs.Types

type XUnambiguous GhcRn = Name
type XUnambiguous GhcTc 
Instance details

Defined in GHC.Hs.Types

type XUnambiguous GhcTc = Id
type XAmbiguous GhcPs 
Instance details

Defined in GHC.Hs.Types

type XAmbiguous GhcPs = NoExtField
type XAmbiguous GhcRn 
Instance details

Defined in GHC.Hs.Types

type XAmbiguous GhcRn = NoExtField
type XAmbiguous GhcTc 
Instance details

Defined in GHC.Hs.Types

type XAmbiguous GhcTc = Id
type XMissing GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XMissing GhcPs = NoExtField
type XMissing GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XMissing GhcRn = NoExtField
type XMissing GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XMissing GhcTc = Type
type XCmdTop GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XCmdTop GhcPs = NoExtField
type XCmdTop GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XCmdTop GhcRn = CmdSyntaxTable GhcRn
type XCmdTop GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XCmdTop GhcTc = CmdTopTc
type XCmdArrApp GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XCmdArrApp GhcPs = NoExtField
type XCmdArrApp GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XCmdArrApp GhcRn = NoExtField
type XCmdArrApp GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XCmdArrApp GhcTc = Type
type XCmdDo GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XCmdDo GhcPs = NoExtField
type XCmdDo GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XCmdDo GhcRn = NoExtField
type XCmdDo GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XCmdDo GhcTc = Type
type XOverLit GhcPs 
Instance details

Defined in GHC.Hs.Lit

type XOverLit GhcPs = NoExtField
type XOverLit GhcRn 
Instance details

Defined in GHC.Hs.Lit

type XOverLit GhcRn = Bool
type XOverLit GhcTc 
Instance details

Defined in GHC.Hs.Lit

type XOverLit GhcTc = OverLitTc
type XWildPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XWildPat GhcPs = NoExtField
type XWildPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XWildPat GhcRn = NoExtField
type XWildPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XWildPat GhcTc = Type
type XListPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XListPat GhcPs = NoExtField
type XListPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)
type XListPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XListPat GhcTc = ListPatTc
type XTuplePat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XTuplePat GhcPs = NoExtField
type XTuplePat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XTuplePat GhcRn = NoExtField
type XTuplePat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XTuplePat GhcTc = [Type]
type XSumPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XSumPat GhcPs = NoExtField
type XSumPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XSumPat GhcRn = NoExtField
type XSumPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XSumPat GhcTc = [Type]
type XViewPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XViewPat GhcPs = NoExtField
type XViewPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XViewPat GhcRn = NoExtField
type XViewPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XViewPat GhcTc = Type
type XNPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XNPat GhcPs = NoExtField
type XNPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XNPat GhcRn = NoExtField
type XNPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XNPat GhcTc = Type
type XNPlusKPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XNPlusKPat GhcPs = NoExtField
type XNPlusKPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XNPlusKPat GhcRn = NoExtField
type XNPlusKPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XNPlusKPat GhcTc = Type
type XSigPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XSigPat GhcPs = NoExtField
type XSigPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XSigPat GhcRn = NoExtField
type XSigPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XSigPat GhcTc = Type
type XHsQTvs GhcPs 
Instance details

Defined in GHC.Hs.Types

type XHsQTvs GhcPs = NoExtField
type XHsQTvs GhcRn 
Instance details

Defined in GHC.Hs.Types

type XHsQTvs GhcRn = HsQTvsRn
type XHsQTvs GhcTc 
Instance details

Defined in GHC.Hs.Types

type XHsQTvs GhcTc = HsQTvsRn
type XSpliceTy GhcPs 
Instance details

Defined in GHC.Hs.Types

type XSpliceTy GhcPs = NoExtField
type XSpliceTy GhcRn 
Instance details

Defined in GHC.Hs.Types

type XSpliceTy GhcRn = NoExtField
type XSpliceTy GhcTc 
Instance details

Defined in GHC.Hs.Types

type XSpliceTy GhcTc = Kind
type XExplicitListTy GhcPs 
Instance details

Defined in GHC.Hs.Types

type XExplicitListTy GhcPs = NoExtField
type XExplicitListTy GhcRn 
Instance details

Defined in GHC.Hs.Types

type XExplicitListTy GhcRn = NoExtField
type XExplicitListTy GhcTc 
Instance details

Defined in GHC.Hs.Types

type XExplicitListTy GhcTc = Kind
type XExplicitTupleTy GhcPs 
Instance details

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcPs = NoExtField
type XExplicitTupleTy GhcRn 
Instance details

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcRn = NoExtField
type XExplicitTupleTy GhcTc 
Instance details

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcTc = [Kind]
type XCFieldOcc GhcPs 
Instance details

Defined in GHC.Hs.Types

type XCFieldOcc GhcPs = NoExtField
type XCFieldOcc GhcRn 
Instance details

Defined in GHC.Hs.Types

type XCFieldOcc GhcRn = Name
type XCFieldOcc GhcTc 
Instance details

Defined in GHC.Hs.Types

type XCFieldOcc GhcTc = Id
type XMG GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XMG GhcPs b = NoExtField
type XMG GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XMG GhcRn b = NoExtField
type XMG GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XMG GhcTc b = MatchGroupTc
type XHsIB GhcPs _1 
Instance details

Defined in GHC.Hs.Types

type XHsIB GhcPs _1 = NoExtField
type XHsIB GhcRn _1 
Instance details

Defined in GHC.Hs.Types

type XHsIB GhcRn _1 = [Name]
type XHsIB GhcTc _1 
Instance details

Defined in GHC.Hs.Types

type XHsIB GhcTc _1 = [Name]
type XHsWC GhcPs b 
Instance details

Defined in GHC.Hs.Types

type XHsWC GhcPs b = NoExtField
type XHsWC GhcRn b 
Instance details

Defined in GHC.Hs.Types

type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b 
Instance details

Defined in GHC.Hs.Types

type XHsWC GhcTc b = [Name]
type XPatBind GhcPs (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XPatBind GhcPs (GhcPass pR) = NoExtField
type XPatBind GhcRn (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XPatBind GhcRn (GhcPass pR) = NameSet
type XPatBind GhcTc (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XPatBind GhcTc (GhcPass pR) = NPatBindTc
type FunArg (PatBuilder GhcPs) 
Instance details

Defined in RdrHsSyn

type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs
type InfixOp (PatBuilder GhcPs) 
Instance details

Defined in RdrHsSyn

type InfixOp (PatBuilder GhcPs) = RdrName
type Body (PatBuilder GhcPs) 
Instance details

Defined in RdrHsSyn

type Body (PatBuilder GhcPs) = PatBuilder
type XABE (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XABE (GhcPass p) = NoExtField
type XXABExport (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXABExport (GhcPass p) = NoExtCon
type XXHsIPBinds (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXHsIPBinds (GhcPass p) = NoExtCon
type XCIPBind (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XCIPBind (GhcPass p) = NoExtField
type XXIPBind (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXIPBind (GhcPass p) = NoExtCon
type XTypeSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XTypeSig (GhcPass p) = NoExtField
type XPatSynSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XPatSynSig (GhcPass p) = NoExtField
type XClassOpSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XClassOpSig (GhcPass p) = NoExtField
type XIdSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XIdSig (GhcPass p) = NoExtField
type XFixSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XFixSig (GhcPass p) = NoExtField
type XInlineSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XInlineSig (GhcPass p) = NoExtField
type XSpecSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XSpecSig (GhcPass p) = NoExtField
type XSpecInstSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XSpecInstSig (GhcPass p) = NoExtField
type XMinimalSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XMinimalSig (GhcPass p) = NoExtField
type XSCCFunSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XSCCFunSig (GhcPass p) = NoExtField
type XCompleteMatchSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XCompleteMatchSig (GhcPass p) = NoExtField
type XXSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXSig (GhcPass p) = NoExtCon
type XFixitySig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XFixitySig (GhcPass p) = NoExtField
type XXFixitySig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXFixitySig (GhcPass p) = NoExtCon
type XStandaloneKindSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Decls

type XStandaloneKindSig (GhcPass p) = NoExtField
type XXStandaloneKindSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Decls

type XXStandaloneKindSig (GhcPass p) = NoExtCon
type XTyClD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XTyClD (GhcPass _1) = NoExtField
type XInstD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XInstD (GhcPass _1) = NoExtField
type XDerivD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XDerivD (GhcPass _1) = NoExtField
type XValD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XValD (GhcPass _1) = NoExtField
type XSigD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XSigD (GhcPass _1) = NoExtField
type XKindSigD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XKindSigD (GhcPass _1) = NoExtField
type XDefD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XDefD (GhcPass _1) = NoExtField
type XForD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XForD (GhcPass _1) = NoExtField
type XWarningD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XWarningD (GhcPass _1) = NoExtField
type XAnnD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XAnnD (GhcPass _1) = NoExtField
type XRuleD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XRuleD (GhcPass _1) = NoExtField
type XSpliceD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XSpliceD (GhcPass _1) = NoExtField
type XDocD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XDocD (GhcPass _1) = NoExtField
type XRoleAnnotD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XRoleAnnotD (GhcPass _1) = NoExtField
type XXHsDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXHsDecl (GhcPass _1) = NoExtCon
type XCHsGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCHsGroup (GhcPass _1) = NoExtField
type XXHsGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXHsGroup (GhcPass _1) = NoExtCon
type XSpliceDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XSpliceDecl (GhcPass _1) = NoExtField
type XXSpliceDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXSpliceDecl (GhcPass _1) = NoExtCon
type XFamDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XFamDecl (GhcPass _1) = NoExtField
type XXTyClDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXTyClDecl (GhcPass _1) = NoExtCon
type XCTyClGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCTyClGroup (GhcPass _1) = NoExtField
type XXTyClGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXTyClGroup (GhcPass _1) = NoExtCon
type XNoSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XNoSig (GhcPass _1) = NoExtField
type XCKindSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCKindSig (GhcPass _1) = NoExtField
type XTyVarSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XTyVarSig (GhcPass _1) = NoExtField
type XXFamilyResultSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXFamilyResultSig (GhcPass _1) = NoExtCon
type XCFamilyDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCFamilyDecl (GhcPass _1) = NoExtField
type XXFamilyDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXFamilyDecl (GhcPass _1) = NoExtCon
type XCHsDataDefn (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCHsDataDefn (GhcPass _1) = NoExtField
type XXHsDataDefn (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXHsDataDefn (GhcPass _1) = NoExtCon
type XCHsDerivingClause (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCHsDerivingClause (GhcPass _1) = NoExtField
type XXHsDerivingClause (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXHsDerivingClause (GhcPass _1) = NoExtCon
type XConDeclGADT (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XConDeclGADT (GhcPass _1) = NoExtField
type XConDeclH98 (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XConDeclH98 (GhcPass _1) = NoExtField
type XXConDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXConDecl (GhcPass _1) = NoExtCon
type XCClsInstDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCClsInstDecl (GhcPass _1) = NoExtField
type XXClsInstDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXClsInstDecl (GhcPass _1) = NoExtCon
type XClsInstD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XClsInstD (GhcPass _1) = NoExtField
type XDataFamInstD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XDataFamInstD (GhcPass _1) = NoExtField
type XTyFamInstD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XTyFamInstD (GhcPass _1) = NoExtField
type XXInstDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXInstDecl (GhcPass _1) = NoExtCon
type XCDerivDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCDerivDecl (GhcPass _1) = NoExtField
type XXDerivDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXDerivDecl (GhcPass _1) = NoExtCon
type XCDefaultDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCDefaultDecl (GhcPass _1) = NoExtField
type XXDefaultDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXDefaultDecl (GhcPass _1) = NoExtCon
type XXForeignDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXForeignDecl (GhcPass _1) = NoExtCon
type XCRuleDecls (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCRuleDecls (GhcPass _1) = NoExtField
type XXRuleDecls (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXRuleDecls (GhcPass _1) = NoExtCon
type XXRuleDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXRuleDecl (GhcPass _1) = NoExtCon
type XCRuleBndr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCRuleBndr (GhcPass _1) = NoExtField
type XRuleBndrSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XRuleBndrSig (GhcPass _1) = NoExtField
type XXRuleBndr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXRuleBndr (GhcPass _1) = NoExtCon
type XWarnings (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XWarnings (GhcPass _1) = NoExtField
type XXWarnDecls (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXWarnDecls (GhcPass _1) = NoExtCon
type XWarning (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XWarning (GhcPass _1) = NoExtField
type XXWarnDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXWarnDecl (GhcPass _1) = NoExtCon
type XHsAnnotation (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XHsAnnotation (GhcPass _1) = NoExtField
type XXAnnDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXAnnDecl (GhcPass _1) = NoExtCon
type XCRoleAnnotDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl (GhcPass _1) = NoExtField
type XXRoleAnnotDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXRoleAnnotDecl (GhcPass _1) = NoExtCon
type XVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XVar (GhcPass _1) = NoExtField
type XUnboundVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XUnboundVar (GhcPass _1) = NoExtField
type XConLikeOut (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XConLikeOut (GhcPass _1) = NoExtField
type XRecFld (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XRecFld (GhcPass _1) = NoExtField
type XOverLabel (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XOverLabel (GhcPass _1) = NoExtField
type XIPVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XIPVar (GhcPass _1) = NoExtField
type XOverLitE (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XOverLitE (GhcPass _1) = NoExtField
type XLitE (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XLitE (GhcPass _1) = NoExtField
type XLam (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XLam (GhcPass _1) = NoExtField
type XLamCase (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XLamCase (GhcPass _1) = NoExtField
type XApp (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XApp (GhcPass _1) = NoExtField
type XAppTypeE (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XAppTypeE (GhcPass _1) = NoExtField
type XNegApp (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XNegApp (GhcPass _1) = NoExtField
type XPar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XPar (GhcPass _1) = NoExtField
type XSectionL (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSectionL (GhcPass _1) = NoExtField
type XSectionR (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSectionR (GhcPass _1) = NoExtField
type XExplicitTuple (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XExplicitTuple (GhcPass _1) = NoExtField
type XCase (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCase (GhcPass _1) = NoExtField
type XIf (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XIf (GhcPass _1) = NoExtField
type XLet (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XLet (GhcPass _1) = NoExtField
type XExprWithTySig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XExprWithTySig (GhcPass _1) = NoExtField
type XSCC (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSCC (GhcPass _1) = NoExtField
type XCoreAnn (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCoreAnn (GhcPass _1) = NoExtField
type XBracket (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XBracket (GhcPass _1) = NoExtField
type XRnBracketOut (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XRnBracketOut (GhcPass _1) = NoExtField
type XTcBracketOut (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTcBracketOut (GhcPass _1) = NoExtField
type XSpliceE (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSpliceE (GhcPass _1) = NoExtField
type XProc (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XProc (GhcPass _1) = NoExtField
type XTick (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTick (GhcPass _1) = NoExtField
type XBinTick (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XBinTick (GhcPass _1) = NoExtField
type XTickPragma (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTickPragma (GhcPass _1) = NoExtField
type XWrap (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XWrap (GhcPass _1) = NoExtField
type XXExpr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXExpr (GhcPass _1) = NoExtCon
type XXAmbiguousFieldOcc (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXAmbiguousFieldOcc (GhcPass _1) = NoExtCon
type XPresent (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XPresent (GhcPass _1) = NoExtField
type XXTupArg (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXTupArg (GhcPass _1) = NoExtCon
type XTypedSplice (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTypedSplice (GhcPass _1) = NoExtField
type XUntypedSplice (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XUntypedSplice (GhcPass _1) = NoExtField
type XQuasiQuote (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XQuasiQuote (GhcPass _1) = NoExtField
type XSpliced (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSpliced (GhcPass _1) = NoExtField
type XXSplice (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXSplice (GhcPass _1) = NoExtCon
type XExpBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XExpBr (GhcPass _1) = NoExtField
type XPatBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XPatBr (GhcPass _1) = NoExtField
type XDecBrL (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XDecBrL (GhcPass _1) = NoExtField
type XDecBrG (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XDecBrG (GhcPass _1) = NoExtField
type XTypBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTypBr (GhcPass _1) = NoExtField
type XVarBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XVarBr (GhcPass _1) = NoExtField
type XTExpBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTExpBr (GhcPass _1) = NoExtField
type XXBracket (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXBracket (GhcPass _1) = NoExtCon
type XXCmdTop (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXCmdTop (GhcPass _1) = NoExtCon
type XCmdArrForm (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdArrForm (GhcPass _1) = NoExtField
type XCmdApp (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdApp (GhcPass _1) = NoExtField
type XCmdLam (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdLam (GhcPass _1) = NoExtField
type XCmdPar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdPar (GhcPass _1) = NoExtField
type XCmdCase (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdCase (GhcPass _1) = NoExtField
type XCmdIf (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdIf (GhcPass _1) = NoExtField
type XCmdLet (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdLet (GhcPass _1) = NoExtField
type XCmdWrap (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdWrap (GhcPass _1) = NoExtField
type XXCmd (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXCmd (GhcPass _1) = NoExtCon
type XApplicativeArgOne (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeArgOne (GhcPass _1) = NoExtField
type XApplicativeArgMany (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeArgMany (GhcPass _1) = NoExtField
type XXApplicativeArg (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXApplicativeArg (GhcPass _1) = NoExtCon
type XHsChar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsChar (GhcPass _1) = SourceText
type XHsCharPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsCharPrim (GhcPass _1) = SourceText
type XHsString (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsString (GhcPass _1) = SourceText
type XHsStringPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsStringPrim (GhcPass _1) = SourceText
type XHsInt (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsInt (GhcPass _1) = NoExtField
type XHsIntPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsIntPrim (GhcPass _1) = SourceText
type XHsWordPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsWordPrim (GhcPass _1) = SourceText
type XHsInt64Prim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsInt64Prim (GhcPass _1) = SourceText
type XHsWord64Prim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsWord64Prim (GhcPass _1) = SourceText
type XHsInteger (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsInteger (GhcPass _1) = SourceText
type XHsRat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsRat (GhcPass _1) = NoExtField
type XHsFloatPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsFloatPrim (GhcPass _1) = NoExtField
type XHsDoublePrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsDoublePrim (GhcPass _1) = NoExtField
type XXLit (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XXLit (GhcPass _1) = NoExtCon
type XXOverLit (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XXOverLit (GhcPass _1) = NoExtCon
type XVarPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XVarPat (GhcPass _1) = NoExtField
type XLazyPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XLazyPat (GhcPass _1) = NoExtField
type XAsPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XAsPat (GhcPass _1) = NoExtField
type XParPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XParPat (GhcPass _1) = NoExtField
type XBangPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XBangPat (GhcPass _1) = NoExtField
type XSplicePat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XSplicePat (GhcPass _1) = NoExtField
type XLitPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XLitPat (GhcPass _1) = NoExtField
type XCoPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XCoPat (GhcPass _1) = NoExtField
type XXPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XXPat (GhcPass _1) = NoExtCon
type XXLHsQTyVars (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXLHsQTyVars (GhcPass _1) = NoExtCon
type XForAllTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XForAllTy (GhcPass _1) = NoExtField
type XQualTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XQualTy (GhcPass _1) = NoExtField
type XTyVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XTyVar (GhcPass _1) = NoExtField
type XAppTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XAppTy (GhcPass _1) = NoExtField
type XAppKindTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XAppKindTy (GhcPass _1) = SrcSpan
type XFunTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XFunTy (GhcPass _1) = NoExtField
type XListTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XListTy (GhcPass _1) = NoExtField
type XTupleTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XTupleTy (GhcPass _1) = NoExtField
type XSumTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XSumTy (GhcPass _1) = NoExtField
type XOpTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XOpTy (GhcPass _1) = NoExtField
type XParTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XParTy (GhcPass _1) = NoExtField
type XIParamTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XIParamTy (GhcPass _1) = NoExtField
type XStarTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XStarTy (GhcPass _1) = NoExtField
type XKindSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XKindSig (GhcPass _1) = NoExtField
type XDocTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XDocTy (GhcPass _1) = NoExtField
type XBangTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XBangTy (GhcPass _1) = NoExtField
type XRecTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XRecTy (GhcPass _1) = NoExtField
type XTyLit (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XTyLit (GhcPass _1) = NoExtField
type XWildCardTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XWildCardTy (GhcPass _1) = NoExtField
type XXType (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXType (GhcPass _1) = NewHsTypeX
type XUserTyVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XUserTyVar (GhcPass _1) = NoExtField
type XKindedTyVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XKindedTyVar (GhcPass _1) = NoExtField
type XXTyVarBndr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXTyVarBndr (GhcPass _1) = NoExtCon
type XConDeclField (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XConDeclField (GhcPass _1) = NoExtField
type XXConDeclField (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXConDeclField (GhcPass _1) = NoExtCon
type XXFieldOcc (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXFieldOcc (GhcPass _1) = NoExtCon
type XCImportDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XCImportDecl (GhcPass _1) = NoExtField
type XXImportDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XXImportDecl (GhcPass _1) = NoExtCon
type XIEVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEVar (GhcPass _1) = NoExtField
type XIEThingAbs (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEThingAbs (GhcPass _1) = NoExtField
type XIEThingAll (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEThingAll (GhcPass _1) = NoExtField
type XIEThingWith (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass _1) = NoExtField
type XIEModuleContents (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEModuleContents (GhcPass _1) = NoExtField
type XIEGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEGroup (GhcPass _1) = NoExtField
type XIEDoc (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEDoc (GhcPass _1) = NoExtField
type XIEDocNamed (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEDocNamed (GhcPass _1) = NoExtField
type XXIE (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XXIE (GhcPass _1) = NoExtCon
type XRec (GhcPass p) f 
Instance details

Defined in GHC.Hs.Extension

type XRec (GhcPass p) f = Located (f (GhcPass p))
type XFunBind (GhcPass pL) GhcTc 
Instance details

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcTc = NameSet
type XFunBind (GhcPass pL) GhcRn 
Instance details

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcRn = NameSet
type XFunBind (GhcPass pL) GhcPs 
Instance details

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcPs = NoExtField
type XPSB (GhcPass idL) GhcTc 
Instance details

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcTc = NameSet
type XPSB (GhcPass idL) GhcRn 
Instance details

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcPs 
Instance details

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcPs = NoExtField
type XCFamEqn (GhcPass _1) r 
Instance details

Defined in GHC.Hs.Decls

type XCFamEqn (GhcPass _1) r = NoExtField
type XXFamEqn (GhcPass _1) r 
Instance details

Defined in GHC.Hs.Decls

type XXFamEqn (GhcPass _1) r = NoExtCon
type XXMatchGroup (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XXMatchGroup (GhcPass _1) b = NoExtCon
type XCMatch (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XCMatch (GhcPass _1) b = NoExtField
type XXMatch (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XXMatch (GhcPass _1) b = NoExtCon
type XCGRHSs (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XCGRHSs (GhcPass _1) b = NoExtField
type XXGRHSs (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XXGRHSs (GhcPass _1) b = NoExtCon
type XCGRHS (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XCGRHS (GhcPass _1) b = NoExtField
type XXGRHS (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XXGRHS (GhcPass _1) b = NoExtCon
type XXHsImplicitBndrs (GhcPass _1) _2 
Instance details

Defined in GHC.Hs.Types

type XXHsImplicitBndrs (GhcPass _1) _2 = NoExtCon
type XXHsWildCardBndrs (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Types

type XXHsWildCardBndrs (GhcPass _1) b = NoExtCon
type XBindStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcTc b = Type
type XBindStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcRn b = NoExtField
type XBindStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcPs b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcTc b = Type
type XApplicativeStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField
type XBodyStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcTc b = Type
type XBodyStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcRn b = NoExtField
type XBodyStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcPs b = NoExtField
type XParStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcTc b = Type
type XParStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcRn b = NoExtField
type XParStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcPs b = NoExtField
type XTransStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcTc b = Type
type XTransStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcRn b = NoExtField
type XTransStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcPs b = NoExtField
type XRecStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcRn b = NoExtField
type XRecStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcPs b = NoExtField
type XRecStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc
type XHsValBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XHsIPBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon
type XValBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XValBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XXValBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)
type XVarBind (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField
type XAbsBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XPatSynBind (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField
type XXHsBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon
type XXPatSynBind (GhcPass idL) (GhcPass idR) 
Instance details

Defined in GHC.Hs.Binds

type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExtCon
type XParStmtBlock (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Expr

type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField
type XXParStmtBlock (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Expr

type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon
type XLastStmt (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in GHC.Hs.Expr

type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField
type XLetStmt (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in GHC.Hs.Expr

type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExtField
type XXStmtLR (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in GHC.Hs.Expr

type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExtCon

data Pass #

Constructors

Parsed 
Renamed 
Typechecked 

Instances

Instances details
Data Pass 
Instance details

Defined in GHC.Hs.Extension

Methods

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

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

toConstr :: Pass -> Constr #

dataTypeOf :: Pass -> DataType #

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

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

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

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

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

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

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

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

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

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

type GhcPs = GhcPass 'Parsed #

type GhcRn = GhcPass 'Renamed #

type GhcTc = GhcPass 'Typechecked #

type GhcTcId = GhcTc #

type family XRec p (f :: Type -> Type) = (r :: Type) | r -> p f #

GHC's L prefixed variants wrap their vanilla variant in this type family, to add SrcLoc info via Located. Other passes than GhcPass not interested in location information can define this instance as f p.

Instances

Instances details
type XRec (GhcPass p) f 
Instance details

Defined in GHC.Hs.Extension

type XRec (GhcPass p) f = Located (f (GhcPass p))

type family IdP p #

Maps the "normal" id type for a given pass

Instances

Instances details
type IdP GhcPs 
Instance details

Defined in GHC.Hs.Extension

type IdP GhcPs = RdrName
type IdP GhcRn 
Instance details

Defined in GHC.Hs.Extension

type IdP GhcRn = Name
type IdP GhcTc 
Instance details

Defined in GHC.Hs.Extension

type IdP GhcTc = Id

type LIdP p = Located (IdP p) #

type family NoGhcTc p where ... #

Marks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because HsType GhcTc should never occur.

Equations

NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass) 
NoGhcTc other = other 

type family NoGhcTcPass (p :: Pass) :: Pass where ... #

Equations

NoGhcTcPass 'Typechecked = 'Renamed 
NoGhcTcPass other = other 

type family XHsValBinds x x' #

Instances

Instances details
type XHsValBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XHsIPBinds x x' #

Instances

Instances details
type XHsIPBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XEmptyLocalBinds x x' #

Instances

Instances details
type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XXHsLocalBindsLR x x' #

Instances

Instances details
type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXHsLocalBindsLR (c :: Type -> Constraint) x x' = (c (XHsValBinds x x'), c (XHsIPBinds x x'), c (XEmptyLocalBinds x x'), c (XXHsLocalBindsLR x x')) #

type family XValBinds x x' #

Instances

Instances details
type XValBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XValBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XXValBindsLR x x' #

Instances

Instances details
type XXValBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)

type ForallXValBindsLR (c :: Type -> Constraint) x x' = (c (XValBinds x x'), c (XXValBindsLR x x')) #

type family XFunBind x x' #

Instances

Instances details
type XFunBind (GhcPass pL) GhcTc 
Instance details

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcTc = NameSet
type XFunBind (GhcPass pL) GhcRn 
Instance details

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcRn = NameSet
type XFunBind (GhcPass pL) GhcPs 
Instance details

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcPs = NoExtField

type family XPatBind x x' #

Instances

Instances details
type XPatBind GhcPs (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XPatBind GhcPs (GhcPass pR) = NoExtField
type XPatBind GhcRn (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XPatBind GhcRn (GhcPass pR) = NameSet
type XPatBind GhcTc (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XPatBind GhcTc (GhcPass pR) = NPatBindTc

type family XVarBind x x' #

Instances

Instances details
type XVarBind (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField

type family XAbsBinds x x' #

Instances

Instances details
type XAbsBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XPatSynBind x x' #

Instances

Instances details
type XPatSynBind (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField

type family XXHsBindsLR x x' #

Instances

Instances details
type XXHsBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Binds

type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXHsBindsLR (c :: Type -> Constraint) x x' = (c (XFunBind x x'), c (XPatBind x x'), c (XVarBind x x'), c (XAbsBinds x x'), c (XPatSynBind x x'), c (XXHsBindsLR x x')) #

type family XABE x #

Instances

Instances details
type XABE (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XABE (GhcPass p) = NoExtField

type family XXABExport x #

Instances

Instances details
type XXABExport (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXABExport (GhcPass p) = NoExtCon

type ForallXABExport (c :: Type -> Constraint) x = (c (XABE x), c (XXABExport x)) #

type family XPSB x x' #

Instances

Instances details
type XPSB (GhcPass idL) GhcTc 
Instance details

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcTc = NameSet
type XPSB (GhcPass idL) GhcRn 
Instance details

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcPs 
Instance details

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcPs = NoExtField

type family XXPatSynBind x x' #

Instances

Instances details
type XXPatSynBind (GhcPass idL) (GhcPass idR) 
Instance details

Defined in GHC.Hs.Binds

type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExtCon

type ForallXPatSynBind (c :: Type -> Constraint) x x' = (c (XPSB x x'), c (XXPatSynBind x x')) #

type family XIPBinds x #

Instances

Instances details
type XIPBinds GhcPs 
Instance details

Defined in GHC.Hs.Binds

type XIPBinds GhcPs = NoExtField
type XIPBinds GhcRn 
Instance details

Defined in GHC.Hs.Binds

type XIPBinds GhcRn = NoExtField
type XIPBinds GhcTc 
Instance details

Defined in GHC.Hs.Binds

type XIPBinds GhcTc = TcEvBinds

type family XXHsIPBinds x #

Instances

Instances details
type XXHsIPBinds (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXHsIPBinds (GhcPass p) = NoExtCon

type ForallXHsIPBinds (c :: Type -> Constraint) x = (c (XIPBinds x), c (XXHsIPBinds x)) #

type family XCIPBind x #

Instances

Instances details
type XCIPBind (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XCIPBind (GhcPass p) = NoExtField

type family XXIPBind x #

Instances

Instances details
type XXIPBind (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXIPBind (GhcPass p) = NoExtCon

type ForallXIPBind (c :: Type -> Constraint) x = (c (XCIPBind x), c (XXIPBind x)) #

type family XTypeSig x #

Instances

Instances details
type XTypeSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XTypeSig (GhcPass p) = NoExtField

type family XPatSynSig x #

Instances

Instances details
type XPatSynSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XPatSynSig (GhcPass p) = NoExtField

type family XClassOpSig x #

Instances

Instances details
type XClassOpSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XClassOpSig (GhcPass p) = NoExtField

type family XIdSig x #

Instances

Instances details
type XIdSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XIdSig (GhcPass p) = NoExtField

type family XFixSig x #

Instances

Instances details
type XFixSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XFixSig (GhcPass p) = NoExtField

type family XInlineSig x #

Instances

Instances details
type XInlineSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XInlineSig (GhcPass p) = NoExtField

type family XSpecSig x #

Instances

Instances details
type XSpecSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XSpecSig (GhcPass p) = NoExtField

type family XSpecInstSig x #

Instances

Instances details
type XSpecInstSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XSpecInstSig (GhcPass p) = NoExtField

type family XMinimalSig x #

Instances

Instances details
type XMinimalSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XMinimalSig (GhcPass p) = NoExtField

type family XSCCFunSig x #

Instances

Instances details
type XSCCFunSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XSCCFunSig (GhcPass p) = NoExtField

type family XCompleteMatchSig x #

Instances

Instances details
type XCompleteMatchSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XCompleteMatchSig (GhcPass p) = NoExtField

type family XXSig x #

Instances

Instances details
type XXSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXSig (GhcPass p) = NoExtCon

type ForallXSig (c :: Type -> Constraint) x = (c (XTypeSig x), c (XPatSynSig x), c (XClassOpSig x), c (XIdSig x), c (XFixSig x), c (XInlineSig x), c (XSpecSig x), c (XSpecInstSig x), c (XMinimalSig x), c (XSCCFunSig x), c (XCompleteMatchSig x), c (XXSig x)) #

type family XFixitySig x #

Instances

Instances details
type XFixitySig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XFixitySig (GhcPass p) = NoExtField

type family XXFixitySig x #

Instances

Instances details
type XXFixitySig (GhcPass p) 
Instance details

Defined in GHC.Hs.Binds

type XXFixitySig (GhcPass p) = NoExtCon

type ForallXFixitySig (c :: Type -> Constraint) x = (c (XFixitySig x), c (XXFixitySig x)) #

type family XStandaloneKindSig x #

Instances

Instances details
type XStandaloneKindSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Decls

type XStandaloneKindSig (GhcPass p) = NoExtField

type family XXStandaloneKindSig x #

Instances

Instances details
type XXStandaloneKindSig (GhcPass p) 
Instance details

Defined in GHC.Hs.Decls

type XXStandaloneKindSig (GhcPass p) = NoExtCon

type family XTyClD x #

Instances

Instances details
type XTyClD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XTyClD (GhcPass _1) = NoExtField

type family XInstD x #

Instances

Instances details
type XInstD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XInstD (GhcPass _1) = NoExtField

type family XDerivD x #

Instances

Instances details
type XDerivD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XDerivD (GhcPass _1) = NoExtField

type family XValD x #

Instances

Instances details
type XValD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XValD (GhcPass _1) = NoExtField

type family XSigD x #

Instances

Instances details
type XSigD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XSigD (GhcPass _1) = NoExtField

type family XKindSigD x #

Instances

Instances details
type XKindSigD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XKindSigD (GhcPass _1) = NoExtField

type family XDefD x #

Instances

Instances details
type XDefD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XDefD (GhcPass _1) = NoExtField

type family XForD x #

Instances

Instances details
type XForD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XForD (GhcPass _1) = NoExtField

type family XWarningD x #

Instances

Instances details
type XWarningD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XWarningD (GhcPass _1) = NoExtField

type family XAnnD x #

Instances

Instances details
type XAnnD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XAnnD (GhcPass _1) = NoExtField

type family XRuleD x #

Instances

Instances details
type XRuleD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XRuleD (GhcPass _1) = NoExtField

type family XSpliceD x #

Instances

Instances details
type XSpliceD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XSpliceD (GhcPass _1) = NoExtField

type family XDocD x #

Instances

Instances details
type XDocD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XDocD (GhcPass _1) = NoExtField

type family XRoleAnnotD x #

Instances

Instances details
type XRoleAnnotD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XRoleAnnotD (GhcPass _1) = NoExtField

type family XXHsDecl x #

Instances

Instances details
type XXHsDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXHsDecl (GhcPass _1) = NoExtCon

type ForallXHsDecl (c :: Type -> Constraint) x = (c (XTyClD x), c (XInstD x), c (XDerivD x), c (XValD x), c (XSigD x), c (XKindSigD x), c (XDefD x), c (XForD x), c (XWarningD x), c (XAnnD x), c (XRuleD x), c (XSpliceD x), c (XDocD x), c (XRoleAnnotD x), c (XXHsDecl x)) #

type family XCHsGroup x #

Instances

Instances details
type XCHsGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCHsGroup (GhcPass _1) = NoExtField

type family XXHsGroup x #

Instances

Instances details
type XXHsGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXHsGroup (GhcPass _1) = NoExtCon

type ForallXHsGroup (c :: Type -> Constraint) x = (c (XCHsGroup x), c (XXHsGroup x)) #

type family XSpliceDecl x #

Instances

Instances details
type XSpliceDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XSpliceDecl (GhcPass _1) = NoExtField

type family XXSpliceDecl x #

Instances

Instances details
type XXSpliceDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXSpliceDecl (GhcPass _1) = NoExtCon

type ForallXSpliceDecl (c :: Type -> Constraint) x = (c (XSpliceDecl x), c (XXSpliceDecl x)) #

type family XFamDecl x #

Instances

Instances details
type XFamDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XFamDecl (GhcPass _1) = NoExtField

type family XSynDecl x #

Instances

Instances details
type XSynDecl GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XSynDecl GhcPs = NoExtField
type XSynDecl GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XSynDecl GhcRn = NameSet
type XSynDecl GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XSynDecl GhcTc = NameSet

type family XDataDecl x #

Instances

Instances details
type XDataDecl GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XDataDecl GhcPs = NoExtField
type XDataDecl GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XDataDecl GhcRn = DataDeclRn
type XDataDecl GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XDataDecl GhcTc = DataDeclRn

type family XClassDecl x #

Instances

Instances details
type XClassDecl GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XClassDecl GhcPs = NoExtField
type XClassDecl GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XClassDecl GhcRn = NameSet
type XClassDecl GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XClassDecl GhcTc = NameSet

type family XXTyClDecl x #

Instances

Instances details
type XXTyClDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXTyClDecl (GhcPass _1) = NoExtCon

type ForallXTyClDecl (c :: Type -> Constraint) x = (c (XFamDecl x), c (XSynDecl x), c (XDataDecl x), c (XClassDecl x), c (XXTyClDecl x)) #

type family XCTyClGroup x #

Instances

Instances details
type XCTyClGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCTyClGroup (GhcPass _1) = NoExtField

type family XXTyClGroup x #

Instances

Instances details
type XXTyClGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXTyClGroup (GhcPass _1) = NoExtCon

type ForallXTyClGroup (c :: Type -> Constraint) x = (c (XCTyClGroup x), c (XXTyClGroup x)) #

type family XNoSig x #

Instances

Instances details
type XNoSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XNoSig (GhcPass _1) = NoExtField

type family XCKindSig x #

Instances

Instances details
type XCKindSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCKindSig (GhcPass _1) = NoExtField

type family XTyVarSig x #

Instances

Instances details
type XTyVarSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XTyVarSig (GhcPass _1) = NoExtField

type family XXFamilyResultSig x #

Instances

Instances details
type XXFamilyResultSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXFamilyResultSig (GhcPass _1) = NoExtCon

type ForallXFamilyResultSig (c :: Type -> Constraint) x = (c (XNoSig x), c (XCKindSig x), c (XTyVarSig x), c (XXFamilyResultSig x)) #

type family XCFamilyDecl x #

Instances

Instances details
type XCFamilyDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCFamilyDecl (GhcPass _1) = NoExtField

type family XXFamilyDecl x #

Instances

Instances details
type XXFamilyDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXFamilyDecl (GhcPass _1) = NoExtCon

type ForallXFamilyDecl (c :: Type -> Constraint) x = (c (XCFamilyDecl x), c (XXFamilyDecl x)) #

type family XCHsDataDefn x #

Instances

Instances details
type XCHsDataDefn (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCHsDataDefn (GhcPass _1) = NoExtField

type family XXHsDataDefn x #

Instances

Instances details
type XXHsDataDefn (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXHsDataDefn (GhcPass _1) = NoExtCon

type ForallXHsDataDefn (c :: Type -> Constraint) x = (c (XCHsDataDefn x), c (XXHsDataDefn x)) #

type family XCHsDerivingClause x #

Instances

Instances details
type XCHsDerivingClause (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCHsDerivingClause (GhcPass _1) = NoExtField

type family XXHsDerivingClause x #

Instances

Instances details
type XXHsDerivingClause (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXHsDerivingClause (GhcPass _1) = NoExtCon

type ForallXHsDerivingClause (c :: Type -> Constraint) x = (c (XCHsDerivingClause x), c (XXHsDerivingClause x)) #

type family XConDeclGADT x #

Instances

Instances details
type XConDeclGADT (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XConDeclGADT (GhcPass _1) = NoExtField

type family XConDeclH98 x #

Instances

Instances details
type XConDeclH98 (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XConDeclH98 (GhcPass _1) = NoExtField

type family XXConDecl x #

Instances

Instances details
type XXConDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXConDecl (GhcPass _1) = NoExtCon

type ForallXConDecl (c :: Type -> Constraint) x = (c (XConDeclGADT x), c (XConDeclH98 x), c (XXConDecl x)) #

type family XCFamEqn x r #

Instances

Instances details
type XCFamEqn (GhcPass _1) r 
Instance details

Defined in GHC.Hs.Decls

type XCFamEqn (GhcPass _1) r = NoExtField

type family XXFamEqn x r #

Instances

Instances details
type XXFamEqn (GhcPass _1) r 
Instance details

Defined in GHC.Hs.Decls

type XXFamEqn (GhcPass _1) r = NoExtCon

type ForallXFamEqn (c :: Type -> Constraint) x r = (c (XCFamEqn x r), c (XXFamEqn x r)) #

type family XCClsInstDecl x #

Instances

Instances details
type XCClsInstDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCClsInstDecl (GhcPass _1) = NoExtField

type family XXClsInstDecl x #

Instances

Instances details
type XXClsInstDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXClsInstDecl (GhcPass _1) = NoExtCon

type ForallXClsInstDecl (c :: Type -> Constraint) x = (c (XCClsInstDecl x), c (XXClsInstDecl x)) #

type family XClsInstD x #

Instances

Instances details
type XClsInstD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XClsInstD (GhcPass _1) = NoExtField

type family XDataFamInstD x #

Instances

Instances details
type XDataFamInstD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XDataFamInstD (GhcPass _1) = NoExtField

type family XTyFamInstD x #

Instances

Instances details
type XTyFamInstD (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XTyFamInstD (GhcPass _1) = NoExtField

type family XXInstDecl x #

Instances

Instances details
type XXInstDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXInstDecl (GhcPass _1) = NoExtCon

type ForallXInstDecl (c :: Type -> Constraint) x = (c (XClsInstD x), c (XDataFamInstD x), c (XTyFamInstD x), c (XXInstDecl x)) #

type family XCDerivDecl x #

Instances

Instances details
type XCDerivDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCDerivDecl (GhcPass _1) = NoExtField

type family XXDerivDecl x #

Instances

Instances details
type XXDerivDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXDerivDecl (GhcPass _1) = NoExtCon

type ForallXDerivDecl (c :: Type -> Constraint) x = (c (XCDerivDecl x), c (XXDerivDecl x)) #

type family XViaStrategy x #

Instances

Instances details
type XViaStrategy GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XViaStrategy GhcPs = LHsSigType GhcPs
type XViaStrategy GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XViaStrategy GhcRn = LHsSigType GhcRn
type XViaStrategy GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XViaStrategy GhcTc = Type

type family XCDefaultDecl x #

Instances

Instances details
type XCDefaultDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCDefaultDecl (GhcPass _1) = NoExtField

type family XXDefaultDecl x #

Instances

Instances details
type XXDefaultDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXDefaultDecl (GhcPass _1) = NoExtCon

type ForallXDefaultDecl (c :: Type -> Constraint) x = (c (XCDefaultDecl x), c (XXDefaultDecl x)) #

type family XForeignImport x #

Instances

Instances details
type XForeignImport GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XForeignImport GhcPs = NoExtField
type XForeignImport GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XForeignImport GhcRn = NoExtField
type XForeignImport GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XForeignImport GhcTc = Coercion

type family XForeignExport x #

Instances

Instances details
type XForeignExport GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XForeignExport GhcPs = NoExtField
type XForeignExport GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XForeignExport GhcRn = NoExtField
type XForeignExport GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XForeignExport GhcTc = Coercion

type family XXForeignDecl x #

Instances

Instances details
type XXForeignDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXForeignDecl (GhcPass _1) = NoExtCon

type ForallXForeignDecl (c :: Type -> Constraint) x = (c (XForeignImport x), c (XForeignExport x), c (XXForeignDecl x)) #

type family XCRuleDecls x #

Instances

Instances details
type XCRuleDecls (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCRuleDecls (GhcPass _1) = NoExtField

type family XXRuleDecls x #

Instances

Instances details
type XXRuleDecls (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXRuleDecls (GhcPass _1) = NoExtCon

type ForallXRuleDecls (c :: Type -> Constraint) x = (c (XCRuleDecls x), c (XXRuleDecls x)) #

type family XHsRule x #

Instances

Instances details
type XHsRule GhcPs 
Instance details

Defined in GHC.Hs.Decls

type XHsRule GhcPs = NoExtField
type XHsRule GhcRn 
Instance details

Defined in GHC.Hs.Decls

type XHsRule GhcRn = HsRuleRn
type XHsRule GhcTc 
Instance details

Defined in GHC.Hs.Decls

type XHsRule GhcTc = HsRuleRn

type family XXRuleDecl x #

Instances

Instances details
type XXRuleDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXRuleDecl (GhcPass _1) = NoExtCon

type ForallXRuleDecl (c :: Type -> Constraint) x = (c (XHsRule x), c (XXRuleDecl x)) #

type family XCRuleBndr x #

Instances

Instances details
type XCRuleBndr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCRuleBndr (GhcPass _1) = NoExtField

type family XRuleBndrSig x #

Instances

Instances details
type XRuleBndrSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XRuleBndrSig (GhcPass _1) = NoExtField

type family XXRuleBndr x #

Instances

Instances details
type XXRuleBndr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXRuleBndr (GhcPass _1) = NoExtCon

type ForallXRuleBndr (c :: Type -> Constraint) x = (c (XCRuleBndr x), c (XRuleBndrSig x), c (XXRuleBndr x)) #

type family XWarnings x #

Instances

Instances details
type XWarnings (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XWarnings (GhcPass _1) = NoExtField

type family XXWarnDecls x #

Instances

Instances details
type XXWarnDecls (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXWarnDecls (GhcPass _1) = NoExtCon

type ForallXWarnDecls (c :: Type -> Constraint) x = (c (XWarnings x), c (XXWarnDecls x)) #

type family XWarning x #

Instances

Instances details
type XWarning (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XWarning (GhcPass _1) = NoExtField

type family XXWarnDecl x #

Instances

Instances details
type XXWarnDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXWarnDecl (GhcPass _1) = NoExtCon

type ForallXWarnDecl (c :: Type -> Constraint) x = (c (XWarning x), c (XXWarnDecl x)) #

type family XHsAnnotation x #

Instances

Instances details
type XHsAnnotation (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XHsAnnotation (GhcPass _1) = NoExtField

type family XXAnnDecl x #

Instances

Instances details
type XXAnnDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXAnnDecl (GhcPass _1) = NoExtCon

type ForallXAnnDecl (c :: Type -> Constraint) x = (c (XHsAnnotation x), c (XXAnnDecl x)) #

type family XCRoleAnnotDecl x #

Instances

Instances details
type XCRoleAnnotDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl (GhcPass _1) = NoExtField

type family XXRoleAnnotDecl x #

Instances

Instances details
type XXRoleAnnotDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.Decls

type XXRoleAnnotDecl (GhcPass _1) = NoExtCon

type ForallXRoleAnnotDecl (c :: Type -> Constraint) x = (c (XCRoleAnnotDecl x), c (XXRoleAnnotDecl x)) #

type family XVar x #

Instances

Instances details
type XVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XVar (GhcPass _1) = NoExtField

type family XUnboundVar x #

Instances

Instances details
type XUnboundVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XUnboundVar (GhcPass _1) = NoExtField

type family XConLikeOut x #

Instances

Instances details
type XConLikeOut (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XConLikeOut (GhcPass _1) = NoExtField

type family XRecFld x #

Instances

Instances details
type XRecFld (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XRecFld (GhcPass _1) = NoExtField

type family XOverLabel x #

Instances

Instances details
type XOverLabel (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XOverLabel (GhcPass _1) = NoExtField

type family XIPVar x #

Instances

Instances details
type XIPVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XIPVar (GhcPass _1) = NoExtField

type family XOverLitE x #

Instances

Instances details
type XOverLitE (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XOverLitE (GhcPass _1) = NoExtField

type family XLitE x #

Instances

Instances details
type XLitE (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XLitE (GhcPass _1) = NoExtField

type family XLam x #

Instances

Instances details
type XLam (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XLam (GhcPass _1) = NoExtField

type family XLamCase x #

Instances

Instances details
type XLamCase (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XLamCase (GhcPass _1) = NoExtField

type family XApp x #

Instances

Instances details
type XApp (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XApp (GhcPass _1) = NoExtField

type family XAppTypeE x #

Instances

Instances details
type XAppTypeE (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XAppTypeE (GhcPass _1) = NoExtField

type family XOpApp x #

Instances

Instances details
type XOpApp GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XOpApp GhcPs = NoExtField
type XOpApp GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XOpApp GhcRn = Fixity
type XOpApp GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XOpApp GhcTc = Fixity

type family XNegApp x #

Instances

Instances details
type XNegApp (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XNegApp (GhcPass _1) = NoExtField

type family XPar x #

Instances

Instances details
type XPar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XPar (GhcPass _1) = NoExtField

type family XSectionL x #

Instances

Instances details
type XSectionL (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSectionL (GhcPass _1) = NoExtField

type family XSectionR x #

Instances

Instances details
type XSectionR (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSectionR (GhcPass _1) = NoExtField

type family XExplicitTuple x #

Instances

Instances details
type XExplicitTuple (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XExplicitTuple (GhcPass _1) = NoExtField

type family XExplicitSum x #

Instances

Instances details
type XExplicitSum GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XExplicitSum GhcPs = NoExtField
type XExplicitSum GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XExplicitSum GhcRn = NoExtField
type XExplicitSum GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XExplicitSum GhcTc = [Type]

type family XCase x #

Instances

Instances details
type XCase (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCase (GhcPass _1) = NoExtField

type family XIf x #

Instances

Instances details
type XIf (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XIf (GhcPass _1) = NoExtField

type family XMultiIf x #

Instances

Instances details
type XMultiIf GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XMultiIf GhcPs = NoExtField
type XMultiIf GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XMultiIf GhcRn = NoExtField
type XMultiIf GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XMultiIf GhcTc = Type

type family XLet x #

Instances

Instances details
type XLet (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XLet (GhcPass _1) = NoExtField

type family XDo x #

Instances

Instances details
type XDo GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XDo GhcPs = NoExtField
type XDo GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XDo GhcRn = NoExtField
type XDo GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XDo GhcTc = Type

type family XExplicitList x #

Instances

Instances details
type XExplicitList GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XExplicitList GhcPs = NoExtField
type XExplicitList GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XExplicitList GhcRn = NoExtField
type XExplicitList GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XExplicitList GhcTc = Type

type family XRecordCon x #

Instances

Instances details
type XRecordCon GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XRecordCon GhcPs = NoExtField
type XRecordCon GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XRecordCon GhcRn = NoExtField
type XRecordCon GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XRecordCon GhcTc = RecordConTc

type family XRecordUpd x #

Instances

Instances details
type XRecordUpd GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XRecordUpd GhcPs = NoExtField
type XRecordUpd GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XRecordUpd GhcRn = NoExtField
type XRecordUpd GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XRecordUpd GhcTc = RecordUpdTc

type family XExprWithTySig x #

Instances

Instances details
type XExprWithTySig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XExprWithTySig (GhcPass _1) = NoExtField

type family XArithSeq x #

Instances

Instances details
type XArithSeq GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XArithSeq GhcPs = NoExtField
type XArithSeq GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XArithSeq GhcRn = NoExtField
type XArithSeq GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XArithSeq GhcTc = PostTcExpr

type family XSCC x #

Instances

Instances details
type XSCC (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSCC (GhcPass _1) = NoExtField

type family XCoreAnn x #

Instances

Instances details
type XCoreAnn (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCoreAnn (GhcPass _1) = NoExtField

type family XBracket x #

Instances

Instances details
type XBracket (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XBracket (GhcPass _1) = NoExtField

type family XRnBracketOut x #

Instances

Instances details
type XRnBracketOut (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XRnBracketOut (GhcPass _1) = NoExtField

type family XTcBracketOut x #

Instances

Instances details
type XTcBracketOut (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTcBracketOut (GhcPass _1) = NoExtField

type family XSpliceE x #

Instances

Instances details
type XSpliceE (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSpliceE (GhcPass _1) = NoExtField

type family XProc x #

Instances

Instances details
type XProc (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XProc (GhcPass _1) = NoExtField

type family XStatic x #

Instances

Instances details
type XStatic GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XStatic GhcPs = NoExtField
type XStatic GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XStatic GhcRn = NameSet
type XStatic GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XStatic GhcTc = NameSet

type family XTick x #

Instances

Instances details
type XTick (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTick (GhcPass _1) = NoExtField

type family XBinTick x #

Instances

Instances details
type XBinTick (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XBinTick (GhcPass _1) = NoExtField

type family XTickPragma x #

Instances

Instances details
type XTickPragma (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTickPragma (GhcPass _1) = NoExtField

type family XWrap x #

Instances

Instances details
type XWrap (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XWrap (GhcPass _1) = NoExtField

type family XXExpr x #

Instances

Instances details
type XXExpr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXExpr (GhcPass _1) = NoExtCon

type ForallXExpr (c :: Type -> Constraint) x = (c (XVar x), c (XUnboundVar x), c (XConLikeOut x), c (XRecFld x), c (XOverLabel x), c (XIPVar x), c (XOverLitE x), c (XLitE x), c (XLam x), c (XLamCase x), c (XApp x), c (XAppTypeE x), c (XOpApp x), c (XNegApp x), c (XPar x), c (XSectionL x), c (XSectionR x), c (XExplicitTuple x), c (XExplicitSum x), c (XCase x), c (XIf x), c (XMultiIf x), c (XLet x), c (XDo x), c (XExplicitList x), c (XRecordCon x), c (XRecordUpd x), c (XExprWithTySig x), c (XArithSeq x), c (XSCC x), c (XCoreAnn x), c (XBracket x), c (XRnBracketOut x), c (XTcBracketOut x), c (XSpliceE x), c (XProc x), c (XStatic x), c (XTick x), c (XBinTick x), c (XTickPragma x), c (XWrap x), c (XXExpr x)) #

type family XUnambiguous x #

Instances

Instances details
type XUnambiguous GhcPs 
Instance details

Defined in GHC.Hs.Types

type XUnambiguous GhcPs = NoExtField
type XUnambiguous GhcRn 
Instance details

Defined in GHC.Hs.Types

type XUnambiguous GhcRn = Name
type XUnambiguous GhcTc 
Instance details

Defined in GHC.Hs.Types

type XUnambiguous GhcTc = Id

type family XAmbiguous x #

Instances

Instances details
type XAmbiguous GhcPs 
Instance details

Defined in GHC.Hs.Types

type XAmbiguous GhcPs = NoExtField
type XAmbiguous GhcRn 
Instance details

Defined in GHC.Hs.Types

type XAmbiguous GhcRn = NoExtField
type XAmbiguous GhcTc 
Instance details

Defined in GHC.Hs.Types

type XAmbiguous GhcTc = Id

type family XXAmbiguousFieldOcc x #

Instances

Instances details
type XXAmbiguousFieldOcc (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXAmbiguousFieldOcc (GhcPass _1) = NoExtCon

type ForallXAmbiguousFieldOcc (c :: Type -> Constraint) x = (c (XUnambiguous x), c (XAmbiguous x), c (XXAmbiguousFieldOcc x)) #

type family XPresent x #

Instances

Instances details
type XPresent (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XPresent (GhcPass _1) = NoExtField

type family XMissing x #

Instances

Instances details
type XMissing GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XMissing GhcPs = NoExtField
type XMissing GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XMissing GhcRn = NoExtField
type XMissing GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XMissing GhcTc = Type

type family XXTupArg x #

Instances

Instances details
type XXTupArg (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXTupArg (GhcPass _1) = NoExtCon

type ForallXTupArg (c :: Type -> Constraint) x = (c (XPresent x), c (XMissing x), c (XXTupArg x)) #

type family XTypedSplice x #

Instances

Instances details
type XTypedSplice (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTypedSplice (GhcPass _1) = NoExtField

type family XUntypedSplice x #

Instances

Instances details
type XUntypedSplice (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XUntypedSplice (GhcPass _1) = NoExtField

type family XQuasiQuote x #

Instances

Instances details
type XQuasiQuote (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XQuasiQuote (GhcPass _1) = NoExtField

type family XSpliced x #

Instances

Instances details
type XSpliced (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XSpliced (GhcPass _1) = NoExtField

type family XXSplice x #

Instances

Instances details
type XXSplice (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXSplice (GhcPass _1) = NoExtCon

type ForallXSplice (c :: Type -> Constraint) x = (c (XTypedSplice x), c (XUntypedSplice x), c (XQuasiQuote x), c (XSpliced x), c (XXSplice x)) #

type family XExpBr x #

Instances

Instances details
type XExpBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XExpBr (GhcPass _1) = NoExtField

type family XPatBr x #

Instances

Instances details
type XPatBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XPatBr (GhcPass _1) = NoExtField

type family XDecBrL x #

Instances

Instances details
type XDecBrL (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XDecBrL (GhcPass _1) = NoExtField

type family XDecBrG x #

Instances

Instances details
type XDecBrG (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XDecBrG (GhcPass _1) = NoExtField

type family XTypBr x #

Instances

Instances details
type XTypBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTypBr (GhcPass _1) = NoExtField

type family XVarBr x #

Instances

Instances details
type XVarBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XVarBr (GhcPass _1) = NoExtField

type family XTExpBr x #

Instances

Instances details
type XTExpBr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XTExpBr (GhcPass _1) = NoExtField

type family XXBracket x #

Instances

Instances details
type XXBracket (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXBracket (GhcPass _1) = NoExtCon

type ForallXBracket (c :: Type -> Constraint) x = (c (XExpBr x), c (XPatBr x), c (XDecBrL x), c (XDecBrG x), c (XTypBr x), c (XVarBr x), c (XTExpBr x), c (XXBracket x)) #

type family XCmdTop x #

Instances

Instances details
type XCmdTop GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XCmdTop GhcPs = NoExtField
type XCmdTop GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XCmdTop GhcRn = CmdSyntaxTable GhcRn
type XCmdTop GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XCmdTop GhcTc = CmdTopTc

type family XXCmdTop x #

Instances

Instances details
type XXCmdTop (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXCmdTop (GhcPass _1) = NoExtCon

type ForallXCmdTop (c :: Type -> Constraint) x = (c (XCmdTop x), c (XXCmdTop x)) #

type family XMG x b #

Instances

Instances details
type XMG GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XMG GhcPs b = NoExtField
type XMG GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XMG GhcRn b = NoExtField
type XMG GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XMG GhcTc b = MatchGroupTc

type family XXMatchGroup x b #

Instances

Instances details
type XXMatchGroup (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XXMatchGroup (GhcPass _1) b = NoExtCon

type ForallXMatchGroup (c :: Type -> Constraint) x b = (c (XMG x b), c (XXMatchGroup x b)) #

type family XCMatch x b #

Instances

Instances details
type XCMatch (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XCMatch (GhcPass _1) b = NoExtField

type family XXMatch x b #

Instances

Instances details
type XXMatch (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XXMatch (GhcPass _1) b = NoExtCon

type ForallXMatch (c :: Type -> Constraint) x b = (c (XCMatch x b), c (XXMatch x b)) #

type family XCGRHSs x b #

Instances

Instances details
type XCGRHSs (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XCGRHSs (GhcPass _1) b = NoExtField

type family XXGRHSs x b #

Instances

Instances details
type XXGRHSs (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XXGRHSs (GhcPass _1) b = NoExtCon

type ForallXGRHSs (c :: Type -> Constraint) x b = (c (XCGRHSs x b), c (XXGRHSs x b)) #

type family XCGRHS x b #

Instances

Instances details
type XCGRHS (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XCGRHS (GhcPass _1) b = NoExtField

type family XXGRHS x b #

Instances

Instances details
type XXGRHS (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Expr

type XXGRHS (GhcPass _1) b = NoExtCon

type ForallXGRHS (c :: Type -> Constraint) x b = (c (XCGRHS x b), c (XXGRHS x b)) #

type family XLastStmt x x' b #

Instances

Instances details
type XLastStmt (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in GHC.Hs.Expr

type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type family XBindStmt x x' b #

Instances

Instances details
type XBindStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcTc b = Type
type XBindStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcRn b = NoExtField
type XBindStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcPs b = NoExtField

type family XApplicativeStmt x x' b #

Instances

Instances details
type XApplicativeStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcTc b = Type
type XApplicativeStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField

type family XBodyStmt x x' b #

Instances

Instances details
type XBodyStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcTc b = Type
type XBodyStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcRn b = NoExtField
type XBodyStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcPs b = NoExtField

type family XLetStmt x x' b #

Instances

Instances details
type XLetStmt (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in GHC.Hs.Expr

type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type family XParStmt x x' b #

Instances

Instances details
type XParStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcTc b = Type
type XParStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcRn b = NoExtField
type XParStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcPs b = NoExtField

type family XTransStmt x x' b #

Instances

Instances details
type XTransStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcTc b = Type
type XTransStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcRn b = NoExtField
type XTransStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcPs b = NoExtField

type family XRecStmt x x' b #

Instances

Instances details
type XRecStmt (GhcPass _1) GhcRn b 
Instance details

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcRn b = NoExtField
type XRecStmt (GhcPass _1) GhcPs b 
Instance details

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcPs b = NoExtField
type XRecStmt (GhcPass _1) GhcTc b 
Instance details

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc

type family XXStmtLR x x' b #

Instances

Instances details
type XXStmtLR (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in GHC.Hs.Expr

type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExtCon

type ForallXStmtLR (c :: Type -> Constraint) x x' b = (c (XLastStmt x x' b), c (XBindStmt x x' b), c (XApplicativeStmt x x' b), c (XBodyStmt x x' b), c (XLetStmt x x' b), c (XParStmt x x' b), c (XTransStmt x x' b), c (XRecStmt x x' b), c (XXStmtLR x x' b)) #

type family XCmdArrApp x #

Instances

Instances details
type XCmdArrApp GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XCmdArrApp GhcPs = NoExtField
type XCmdArrApp GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XCmdArrApp GhcRn = NoExtField
type XCmdArrApp GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XCmdArrApp GhcTc = Type

type family XCmdArrForm x #

Instances

Instances details
type XCmdArrForm (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdArrForm (GhcPass _1) = NoExtField

type family XCmdApp x #

Instances

Instances details
type XCmdApp (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdApp (GhcPass _1) = NoExtField

type family XCmdLam x #

Instances

Instances details
type XCmdLam (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdLam (GhcPass _1) = NoExtField

type family XCmdPar x #

Instances

Instances details
type XCmdPar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdPar (GhcPass _1) = NoExtField

type family XCmdCase x #

Instances

Instances details
type XCmdCase (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdCase (GhcPass _1) = NoExtField

type family XCmdIf x #

Instances

Instances details
type XCmdIf (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdIf (GhcPass _1) = NoExtField

type family XCmdLet x #

Instances

Instances details
type XCmdLet (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdLet (GhcPass _1) = NoExtField

type family XCmdDo x #

Instances

Instances details
type XCmdDo GhcPs 
Instance details

Defined in GHC.Hs.Expr

type XCmdDo GhcPs = NoExtField
type XCmdDo GhcRn 
Instance details

Defined in GHC.Hs.Expr

type XCmdDo GhcRn = NoExtField
type XCmdDo GhcTc 
Instance details

Defined in GHC.Hs.Expr

type XCmdDo GhcTc = Type

type family XCmdWrap x #

Instances

Instances details
type XCmdWrap (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XCmdWrap (GhcPass _1) = NoExtField

type family XXCmd x #

Instances

Instances details
type XXCmd (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXCmd (GhcPass _1) = NoExtCon

type ForallXCmd (c :: Type -> Constraint) x = (c (XCmdArrApp x), c (XCmdArrForm x), c (XCmdApp x), c (XCmdLam x), c (XCmdPar x), c (XCmdCase x), c (XCmdIf x), c (XCmdLet x), c (XCmdDo x), c (XCmdWrap x), c (XXCmd x)) #

type family XParStmtBlock x x' #

Instances

Instances details
type XParStmtBlock (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Expr

type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField

type family XXParStmtBlock x x' #

Instances

Instances details
type XXParStmtBlock (GhcPass pL) (GhcPass pR) 
Instance details

Defined in GHC.Hs.Expr

type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXParStmtBlock (c :: Type -> Constraint) x x' = (c (XParStmtBlock x x'), c (XXParStmtBlock x x')) #

type family XApplicativeArgOne x #

Instances

Instances details
type XApplicativeArgOne (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeArgOne (GhcPass _1) = NoExtField

type family XApplicativeArgMany x #

Instances

Instances details
type XApplicativeArgMany (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XApplicativeArgMany (GhcPass _1) = NoExtField

type family XXApplicativeArg x #

Instances

Instances details
type XXApplicativeArg (GhcPass _1) 
Instance details

Defined in GHC.Hs.Expr

type XXApplicativeArg (GhcPass _1) = NoExtCon

type ForallXApplicativeArg (c :: Type -> Constraint) x = (c (XApplicativeArgOne x), c (XApplicativeArgMany x), c (XXApplicativeArg x)) #

type family XHsChar x #

Instances

Instances details
type XHsChar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsChar (GhcPass _1) = SourceText

type family XHsCharPrim x #

Instances

Instances details
type XHsCharPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsCharPrim (GhcPass _1) = SourceText

type family XHsString x #

Instances

Instances details
type XHsString (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsString (GhcPass _1) = SourceText

type family XHsStringPrim x #

Instances

Instances details
type XHsStringPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsStringPrim (GhcPass _1) = SourceText

type family XHsInt x #

Instances

Instances details
type XHsInt (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsInt (GhcPass _1) = NoExtField

type family XHsIntPrim x #

Instances

Instances details
type XHsIntPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsIntPrim (GhcPass _1) = SourceText

type family XHsWordPrim x #

Instances

Instances details
type XHsWordPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsWordPrim (GhcPass _1) = SourceText

type family XHsInt64Prim x #

Instances

Instances details
type XHsInt64Prim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsInt64Prim (GhcPass _1) = SourceText

type family XHsWord64Prim x #

Instances

Instances details
type XHsWord64Prim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsWord64Prim (GhcPass _1) = SourceText

type family XHsInteger x #

Instances

Instances details
type XHsInteger (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsInteger (GhcPass _1) = SourceText

type family XHsRat x #

Instances

Instances details
type XHsRat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsRat (GhcPass _1) = NoExtField

type family XHsFloatPrim x #

Instances

Instances details
type XHsFloatPrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsFloatPrim (GhcPass _1) = NoExtField

type family XHsDoublePrim x #

Instances

Instances details
type XHsDoublePrim (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XHsDoublePrim (GhcPass _1) = NoExtField

type family XXLit x #

Instances

Instances details
type XXLit (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XXLit (GhcPass _1) = NoExtCon

type ForallXHsLit (c :: Type -> Constraint) x = (c (XHsChar x), c (XHsCharPrim x), c (XHsDoublePrim x), c (XHsFloatPrim x), c (XHsInt x), c (XHsInt64Prim x), c (XHsIntPrim x), c (XHsInteger x), c (XHsRat x), c (XHsString x), c (XHsStringPrim x), c (XHsWord64Prim x), c (XHsWordPrim x), c (XXLit x)) #

Helper to apply a constraint to all extension points. It has one entry per extension point type family.

type family XOverLit x #

Instances

Instances details
type XOverLit GhcPs 
Instance details

Defined in GHC.Hs.Lit

type XOverLit GhcPs = NoExtField
type XOverLit GhcRn 
Instance details

Defined in GHC.Hs.Lit

type XOverLit GhcRn = Bool
type XOverLit GhcTc 
Instance details

Defined in GHC.Hs.Lit

type XOverLit GhcTc = OverLitTc

type family XXOverLit x #

Instances

Instances details
type XXOverLit (GhcPass _1) 
Instance details

Defined in GHC.Hs.Lit

type XXOverLit (GhcPass _1) = NoExtCon

type ForallXOverLit (c :: Type -> Constraint) x = (c (XOverLit x), c (XXOverLit x)) #

type family XWildPat x #

Instances

Instances details
type XWildPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XWildPat GhcPs = NoExtField
type XWildPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XWildPat GhcRn = NoExtField
type XWildPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XWildPat GhcTc = Type

type family XVarPat x #

Instances

Instances details
type XVarPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XVarPat (GhcPass _1) = NoExtField

type family XLazyPat x #

Instances

Instances details
type XLazyPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XLazyPat (GhcPass _1) = NoExtField

type family XAsPat x #

Instances

Instances details
type XAsPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XAsPat (GhcPass _1) = NoExtField

type family XParPat x #

Instances

Instances details
type XParPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XParPat (GhcPass _1) = NoExtField

type family XBangPat x #

Instances

Instances details
type XBangPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XBangPat (GhcPass _1) = NoExtField

type family XListPat x #

Instances

Instances details
type XListPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XListPat GhcPs = NoExtField
type XListPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)
type XListPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XListPat GhcTc = ListPatTc

type family XTuplePat x #

Instances

Instances details
type XTuplePat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XTuplePat GhcPs = NoExtField
type XTuplePat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XTuplePat GhcRn = NoExtField
type XTuplePat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XTuplePat GhcTc = [Type]

type family XSumPat x #

Instances

Instances details
type XSumPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XSumPat GhcPs = NoExtField
type XSumPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XSumPat GhcRn = NoExtField
type XSumPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XSumPat GhcTc = [Type]

type family XConPat x #

type family XViewPat x #

Instances

Instances details
type XViewPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XViewPat GhcPs = NoExtField
type XViewPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XViewPat GhcRn = NoExtField
type XViewPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XViewPat GhcTc = Type

type family XSplicePat x #

Instances

Instances details
type XSplicePat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XSplicePat (GhcPass _1) = NoExtField

type family XLitPat x #

Instances

Instances details
type XLitPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XLitPat (GhcPass _1) = NoExtField

type family XNPat x #

Instances

Instances details
type XNPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XNPat GhcPs = NoExtField
type XNPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XNPat GhcRn = NoExtField
type XNPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XNPat GhcTc = Type

type family XNPlusKPat x #

Instances

Instances details
type XNPlusKPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XNPlusKPat GhcPs = NoExtField
type XNPlusKPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XNPlusKPat GhcRn = NoExtField
type XNPlusKPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XNPlusKPat GhcTc = Type

type family XSigPat x #

Instances

Instances details
type XSigPat GhcPs 
Instance details

Defined in GHC.Hs.Pat

type XSigPat GhcPs = NoExtField
type XSigPat GhcRn 
Instance details

Defined in GHC.Hs.Pat

type XSigPat GhcRn = NoExtField
type XSigPat GhcTc 
Instance details

Defined in GHC.Hs.Pat

type XSigPat GhcTc = Type

type family XCoPat x #

Instances

Instances details
type XCoPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XCoPat (GhcPass _1) = NoExtField

type family XXPat x #

Instances

Instances details
type XXPat (GhcPass _1) 
Instance details

Defined in GHC.Hs.Pat

type XXPat (GhcPass _1) = NoExtCon

type ForallXPat (c :: Type -> Constraint) x = (c (XWildPat x), c (XVarPat x), c (XLazyPat x), c (XAsPat x), c (XParPat x), c (XBangPat x), c (XListPat x), c (XTuplePat x), c (XSumPat x), c (XViewPat x), c (XSplicePat x), c (XLitPat x), c (XNPat x), c (XNPlusKPat x), c (XSigPat x), c (XCoPat x), c (XXPat x)) #

type family XHsQTvs x #

Instances

Instances details
type XHsQTvs GhcPs 
Instance details

Defined in GHC.Hs.Types

type XHsQTvs GhcPs = NoExtField
type XHsQTvs GhcRn 
Instance details

Defined in GHC.Hs.Types

type XHsQTvs GhcRn = HsQTvsRn
type XHsQTvs GhcTc 
Instance details

Defined in GHC.Hs.Types

type XHsQTvs GhcTc = HsQTvsRn

type family XXLHsQTyVars x #

Instances

Instances details
type XXLHsQTyVars (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXLHsQTyVars (GhcPass _1) = NoExtCon

type ForallXLHsQTyVars (c :: Type -> Constraint) x = (c (XHsQTvs x), c (XXLHsQTyVars x)) #

type family XHsIB x b #

Instances

Instances details
type XHsIB GhcPs _1 
Instance details

Defined in GHC.Hs.Types

type XHsIB GhcPs _1 = NoExtField
type XHsIB GhcRn _1 
Instance details

Defined in GHC.Hs.Types

type XHsIB GhcRn _1 = [Name]
type XHsIB GhcTc _1 
Instance details

Defined in GHC.Hs.Types

type XHsIB GhcTc _1 = [Name]

type family XXHsImplicitBndrs x b #

Instances

Instances details
type XXHsImplicitBndrs (GhcPass _1) _2 
Instance details

Defined in GHC.Hs.Types

type XXHsImplicitBndrs (GhcPass _1) _2 = NoExtCon

type ForallXHsImplicitBndrs (c :: Type -> Constraint) x b = (c (XHsIB x b), c (XXHsImplicitBndrs x b)) #

type family XHsWC x b #

Instances

Instances details
type XHsWC GhcPs b 
Instance details

Defined in GHC.Hs.Types

type XHsWC GhcPs b = NoExtField
type XHsWC GhcRn b 
Instance details

Defined in GHC.Hs.Types

type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b 
Instance details

Defined in GHC.Hs.Types

type XHsWC GhcTc b = [Name]

type family XXHsWildCardBndrs x b #

Instances

Instances details
type XXHsWildCardBndrs (GhcPass _1) b 
Instance details

Defined in GHC.Hs.Types

type XXHsWildCardBndrs (GhcPass _1) b = NoExtCon

type ForallXHsWildCardBndrs (c :: Type -> Constraint) x b = (c (XHsWC x b), c (XXHsWildCardBndrs x b)) #

type family XForAllTy x #

Instances

Instances details
type XForAllTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XForAllTy (GhcPass _1) = NoExtField

type family XQualTy x #

Instances

Instances details
type XQualTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XQualTy (GhcPass _1) = NoExtField

type family XTyVar x #

Instances

Instances details
type XTyVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XTyVar (GhcPass _1) = NoExtField

type family XAppTy x #

Instances

Instances details
type XAppTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XAppTy (GhcPass _1) = NoExtField

type family XAppKindTy x #

Instances

Instances details
type XAppKindTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XAppKindTy (GhcPass _1) = SrcSpan

type family XFunTy x #

Instances

Instances details
type XFunTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XFunTy (GhcPass _1) = NoExtField

type family XListTy x #

Instances

Instances details
type XListTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XListTy (GhcPass _1) = NoExtField

type family XTupleTy x #

Instances

Instances details
type XTupleTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XTupleTy (GhcPass _1) = NoExtField

type family XSumTy x #

Instances

Instances details
type XSumTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XSumTy (GhcPass _1) = NoExtField

type family XOpTy x #

Instances

Instances details
type XOpTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XOpTy (GhcPass _1) = NoExtField

type family XParTy x #

Instances

Instances details
type XParTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XParTy (GhcPass _1) = NoExtField

type family XIParamTy x #

Instances

Instances details
type XIParamTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XIParamTy (GhcPass _1) = NoExtField

type family XStarTy x #

Instances

Instances details
type XStarTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XStarTy (GhcPass _1) = NoExtField

type family XKindSig x #

Instances

Instances details
type XKindSig (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XKindSig (GhcPass _1) = NoExtField

type family XSpliceTy x #

Instances

Instances details
type XSpliceTy GhcPs 
Instance details

Defined in GHC.Hs.Types

type XSpliceTy GhcPs = NoExtField
type XSpliceTy GhcRn 
Instance details

Defined in GHC.Hs.Types

type XSpliceTy GhcRn = NoExtField
type XSpliceTy GhcTc 
Instance details

Defined in GHC.Hs.Types

type XSpliceTy GhcTc = Kind

type family XDocTy x #

Instances

Instances details
type XDocTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XDocTy (GhcPass _1) = NoExtField

type family XBangTy x #

Instances

Instances details
type XBangTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XBangTy (GhcPass _1) = NoExtField

type family XRecTy x #

Instances

Instances details
type XRecTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XRecTy (GhcPass _1) = NoExtField

type family XExplicitListTy x #

Instances

Instances details
type XExplicitListTy GhcPs 
Instance details

Defined in GHC.Hs.Types

type XExplicitListTy GhcPs = NoExtField
type XExplicitListTy GhcRn 
Instance details

Defined in GHC.Hs.Types

type XExplicitListTy GhcRn = NoExtField
type XExplicitListTy GhcTc 
Instance details

Defined in GHC.Hs.Types

type XExplicitListTy GhcTc = Kind

type family XExplicitTupleTy x #

Instances

Instances details
type XExplicitTupleTy GhcPs 
Instance details

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcPs = NoExtField
type XExplicitTupleTy GhcRn 
Instance details

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcRn = NoExtField
type XExplicitTupleTy GhcTc 
Instance details

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcTc = [Kind]

type family XTyLit x #

Instances

Instances details
type XTyLit (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XTyLit (GhcPass _1) = NoExtField

type family XWildCardTy x #

Instances

Instances details
type XWildCardTy (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XWildCardTy (GhcPass _1) = NoExtField

type family XXType x #

Instances

Instances details
type XXType (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXType (GhcPass _1) = NewHsTypeX

type ForallXType (c :: Type -> Constraint) x = (c (XForAllTy x), c (XQualTy x), c (XTyVar x), c (XAppTy x), c (XAppKindTy x), c (XFunTy x), c (XListTy x), c (XTupleTy x), c (XSumTy x), c (XOpTy x), c (XParTy x), c (XIParamTy x), c (XStarTy x), c (XKindSig x), c (XSpliceTy x), c (XDocTy x), c (XBangTy x), c (XRecTy x), c (XExplicitListTy x), c (XExplicitTupleTy x), c (XTyLit x), c (XWildCardTy x), c (XXType x)) #

Helper to apply a constraint to all extension points. It has one entry per extension point type family.

type family XUserTyVar x #

Instances

Instances details
type XUserTyVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XUserTyVar (GhcPass _1) = NoExtField

type family XKindedTyVar x #

Instances

Instances details
type XKindedTyVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XKindedTyVar (GhcPass _1) = NoExtField

type family XXTyVarBndr x #

Instances

Instances details
type XXTyVarBndr (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXTyVarBndr (GhcPass _1) = NoExtCon

type ForallXTyVarBndr (c :: Type -> Constraint) x = (c (XUserTyVar x), c (XKindedTyVar x), c (XXTyVarBndr x)) #

type family XConDeclField x #

Instances

Instances details
type XConDeclField (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XConDeclField (GhcPass _1) = NoExtField

type family XXConDeclField x #

Instances

Instances details
type XXConDeclField (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXConDeclField (GhcPass _1) = NoExtCon

type ForallXConDeclField (c :: Type -> Constraint) x = (c (XConDeclField x), c (XXConDeclField x)) #

type family XCFieldOcc x #

Instances

Instances details
type XCFieldOcc GhcPs 
Instance details

Defined in GHC.Hs.Types

type XCFieldOcc GhcPs = NoExtField
type XCFieldOcc GhcRn 
Instance details

Defined in GHC.Hs.Types

type XCFieldOcc GhcRn = Name
type XCFieldOcc GhcTc 
Instance details

Defined in GHC.Hs.Types

type XCFieldOcc GhcTc = Id

type family XXFieldOcc x #

Instances

Instances details
type XXFieldOcc (GhcPass _1) 
Instance details

Defined in GHC.Hs.Types

type XXFieldOcc (GhcPass _1) = NoExtCon

type ForallXFieldOcc (c :: Type -> Constraint) x = (c (XCFieldOcc x), c (XXFieldOcc x)) #

type family XCImportDecl x #

Instances

Instances details
type XCImportDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XCImportDecl (GhcPass _1) = NoExtField

type family XXImportDecl x #

Instances

Instances details
type XXImportDecl (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XXImportDecl (GhcPass _1) = NoExtCon

type ForallXImportDecl (c :: Type -> Constraint) x = (c (XCImportDecl x), c (XXImportDecl x)) #

type family XIEVar x #

Instances

Instances details
type XIEVar (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEVar (GhcPass _1) = NoExtField

type family XIEThingAbs x #

Instances

Instances details
type XIEThingAbs (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEThingAbs (GhcPass _1) = NoExtField

type family XIEThingAll x #

Instances

Instances details
type XIEThingAll (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEThingAll (GhcPass _1) = NoExtField

type family XIEThingWith x #

Instances

Instances details
type XIEThingWith (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass _1) = NoExtField

type family XIEModuleContents x #

Instances

Instances details
type XIEModuleContents (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEModuleContents (GhcPass _1) = NoExtField

type family XIEGroup x #

Instances

Instances details
type XIEGroup (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEGroup (GhcPass _1) = NoExtField

type family XIEDoc x #

Instances

Instances details
type XIEDoc (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEDoc (GhcPass _1) = NoExtField

type family XIEDocNamed x #

Instances

Instances details
type XIEDocNamed (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XIEDocNamed (GhcPass _1) = NoExtField

type family XXIE x #

Instances

Instances details
type XXIE (GhcPass _1) 
Instance details

Defined in GHC.Hs.ImpExp

type XXIE (GhcPass _1) = NoExtCon

type ForallXIE (c :: Type -> Constraint) x = (c (XIEVar x), c (XIEThingAbs x), c (XIEThingAll x), c (XIEThingWith x), c (XIEModuleContents x), c (XIEGroup x), c (XIEDoc x), c (XIEDocNamed x), c (XXIE x)) #

class Convertable a b | a -> b where #

Conversion of annotations from one type index to another. This is required where the AST is converted from one pass to another, and the extension values need to be brought along if possible. So for example a SourceText is converted via id, but needs a type signature to keep the type checker happy.

Methods

convert :: a -> b #

Instances

Instances details
Convertable a a 
Instance details

Defined in GHC.Hs.Extension

Methods

convert :: a -> a #

type ConvertIdX a b = (XHsDoublePrim a ~ XHsDoublePrim b, XHsFloatPrim a ~ XHsFloatPrim b, XHsRat a ~ XHsRat b, XHsInteger a ~ XHsInteger b, XHsWord64Prim a ~ XHsWord64Prim b, XHsInt64Prim a ~ XHsInt64Prim b, XHsWordPrim a ~ XHsWordPrim b, XHsIntPrim a ~ XHsIntPrim b, XHsInt a ~ XHsInt b, XHsStringPrim a ~ XHsStringPrim b, XHsString a ~ XHsString b, XHsCharPrim a ~ XHsCharPrim b, XHsChar a ~ XHsChar b, XXLit a ~ XXLit b) #

A constraint capturing all the extension points that can be converted via instance Convertable a a

type OutputableX p = (Outputable (XIPBinds p), Outputable (XViaStrategy p), Outputable (XViaStrategy GhcRn)) #

Provide a summary constraint that gives all am Outputable constraint to extension points needing one

type OutputableBndrId (pass :: Pass) = (OutputableBndr (NameOrRdrName (IdP (GhcPass pass))), OutputableBndr (IdP (GhcPass pass)), OutputableBndr (NameOrRdrName (IdP (NoGhcTc (GhcPass pass)))), OutputableBndr (IdP (NoGhcTc (GhcPass pass))), NoGhcTc (GhcPass pass) ~ NoGhcTc (NoGhcTc (GhcPass pass)), OutputableX (GhcPass pass), OutputableX (NoGhcTc (GhcPass pass))) #

Constraint type to bundle up the requirement for OutputableBndr on both the p and the NameOrRdrName type for it

placeHolderNamesTc :: NameSet #

type family NameOrRdrName id where ... #

Follow the id, but never beyond Name. This is used in a HsMatchContext, for printing messages related to a Match

Equations

NameOrRdrName Id = Name 
NameOrRdrName Name = Name 
NameOrRdrName RdrName = RdrName 

isExportedId :: Var -> Bool #

isExportedIdVar means "don't throw this away"

isGlobalId :: Var -> Bool #

isLocalId :: Var -> Bool #

type Id = Var #

Identifier

type TyVar = Var #

Type or kind Variable

data ForallVisFlag #

Is a forall invisible (e.g., forall a b. {...}, with a dot) or visible (e.g., forall a b -> {...}, with an arrow)?

Constructors

ForallVis

A visible forall (with an arrow)

ForallInvis

An invisible forall (with a dot)

Instances

Instances details
Eq ForallVisFlag 
Instance details

Defined in Var

Methods

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

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

Data ForallVisFlag 
Instance details

Defined in Var

Methods

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

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

toConstr :: ForallVisFlag -> Constr #

dataTypeOf :: ForallVisFlag -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ForallVisFlag 
Instance details

Defined in Var

Methods

compare :: ForallVisFlag -> ForallVisFlag -> Ordering #

(<) :: ForallVisFlag -> ForallVisFlag -> Bool #

(<=) :: ForallVisFlag -> ForallVisFlag -> Bool #

(>) :: ForallVisFlag -> ForallVisFlag -> Bool #

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

max :: ForallVisFlag -> ForallVisFlag -> ForallVisFlag #

min :: ForallVisFlag -> ForallVisFlag -> ForallVisFlag #

Outputable ForallVisFlag 
Instance details

Defined in Var

Methods

ppr :: ForallVisFlag -> SDoc #

pprPrec :: Rational -> ForallVisFlag -> SDoc #

data Token #

Instances

Instances details
Show Token 
Instance details

Defined in Lexer

Methods

showsPrec :: Int -> Token -> ShowS #

show :: Token -> String #

showList :: [Token] -> ShowS #

Outputable Token 
Instance details

Defined in Lexer

Methods

ppr :: Token -> SDoc #

pprPrec :: Rational -> Token -> SDoc #

unicodeAnn :: AnnKeywordId -> AnnKeywordId #

Convert a normal annotation into its unicode equivalent one

getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns) #

Retrieve the comments allocated to the current SrcSpan, and remove them from the annotations

getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment] #

Retrieve the comments allocated to the current SrcSpan

Note: A given SrcSpan may appear in multiple AST elements, beware of duplicates

getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns) #

Retrieve a list of annotation SrcSpans based on the SrcSpan of the annotated AST element, and the known type of the annotation. The list is removed from the annotations.

getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan] #

Retrieve a list of annotation SrcSpans based on the SrcSpan of the annotated AST element, and the known type of the annotation.

type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment]) #

data AnnKeywordId #

API Annotations exist so that tools can perform source to source conversions of Haskell code. They are used to keep track of the various syntactic keywords that are not captured in the existing AST.

The annotations, together with original source comments are made available in the pm_annotations field of ParsedModule. Comments are only retained if Opt_KeepRawTokenStream is set in DynFlags before parsing.

The wiki page describing this feature is https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations

Note: in general the names of these are taken from the corresponding token, unless otherwise noted See note [Api annotations] above for details of the usage

Constructors

AnnAnyclass 
AnnAs 
AnnAt 
AnnBang

!

AnnBackquote

'`'

AnnBy 
AnnCase

case or lambda case

AnnClass 
AnnClose

'#)' or '#-}' etc

AnnCloseB

'|)'

AnnCloseBU

'|)', unicode variant

AnnCloseC

'}'

AnnCloseQ

'|]'

AnnCloseQU

'|]', unicode variant

AnnCloseP

')'

AnnCloseS

']'

AnnColon 
AnnComma

as a list separator

AnnCommaTuple

in a RdrName for a tuple

AnnDarrow

'=>'

AnnDarrowU

'=>', unicode variant

AnnData 
AnnDcolon

'::'

AnnDcolonU

'::', unicode variant

AnnDefault 
AnnDeriving 
AnnDo 
AnnDot

.

AnnDotdot

'..'

AnnElse 
AnnEqual 
AnnExport 
AnnFamily 
AnnForall 
AnnForallU

Unicode variant

AnnForeign 
AnnFunId

for function name in matches where there are multiple equations for the function.

AnnGroup 
AnnHeader

for CType

AnnHiding 
AnnIf 
AnnImport 
AnnIn 
AnnInfix

'infix' or 'infixl' or 'infixr'

AnnInstance 
AnnLam 
AnnLarrow

'<-'

AnnLarrowU

'<-', unicode variant

AnnLet 
AnnMdo 
AnnMinus

-

AnnModule 
AnnNewtype 
AnnName

where a name loses its location in the AST, this carries it

AnnOf 
AnnOpen

'(#' or '{-# LANGUAGE' etc

AnnOpenB

'(|'

AnnOpenBU

'(|', unicode variant

AnnOpenC

'{'

AnnOpenE

'[e|' or '[e||'

AnnOpenEQ

'[|'

AnnOpenEQU

'[|', unicode variant

AnnOpenP

'('

AnnOpenPE

'$('

AnnOpenPTE

'$$('

AnnOpenS

'['

AnnPackageName 
AnnPattern 
AnnProc 
AnnQualified 
AnnRarrow

->

AnnRarrowU

->, unicode variant

AnnRec 
AnnRole 
AnnSafe 
AnnSemi

';'

AnnSimpleQuote

'''

AnnSignature 
AnnStatic

static

AnnStock 
AnnThen 
AnnThIdSplice

$

AnnThIdTySplice

$$

AnnThTyQuote

double '''

AnnTilde

'~'

AnnType 
AnnUnit

() for types

AnnUsing 
AnnVal

e.g. INTEGER

AnnValStr

String value, will need quotes when output

AnnVbar

'|'

AnnVia

via

AnnWhere 
Annlarrowtail

-<

AnnlarrowtailU

-<, unicode variant

Annrarrowtail

->

AnnrarrowtailU

->, unicode variant

AnnLarrowtail

-<<

AnnLarrowtailU

-<<, unicode variant

AnnRarrowtail

>>-

AnnRarrowtailU

>>-, unicode variant

AnnEofPos 

Instances

Instances details
Eq AnnKeywordId 
Instance details

Defined in ApiAnnotation

Methods

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

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

Data AnnKeywordId 
Instance details

Defined in ApiAnnotation

Methods

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

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

toConstr :: AnnKeywordId -> Constr #

dataTypeOf :: AnnKeywordId -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord AnnKeywordId 
Instance details

Defined in ApiAnnotation

Methods

compare :: AnnKeywordId -> AnnKeywordId -> Ordering #

(<) :: AnnKeywordId -> AnnKeywordId -> Bool #

(<=) :: AnnKeywordId -> AnnKeywordId -> Bool #

(>) :: AnnKeywordId -> AnnKeywordId -> Bool #

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

max :: AnnKeywordId -> AnnKeywordId -> AnnKeywordId #

min :: AnnKeywordId -> AnnKeywordId -> AnnKeywordId #

Show AnnKeywordId 
Instance details

Defined in ApiAnnotation

Methods

showsPrec :: Int -> AnnKeywordId -> ShowS #

show :: AnnKeywordId -> String #

showList :: [AnnKeywordId] -> ShowS #

Outputable AnnKeywordId 
Instance details

Defined in ApiAnnotation

Methods

ppr :: AnnKeywordId -> SDoc #

pprPrec :: Rational -> AnnKeywordId -> SDoc #

data AnnotationComment #

Constructors

AnnDocCommentNext String

something beginning '-- |'

AnnDocCommentPrev String

something beginning '-- ^'

AnnDocCommentNamed String

something beginning '-- $'

AnnDocSection Int String

a section heading

AnnDocOptions String

doc options (prune, ignore-exports, etc)

AnnLineComment String

comment starting by "--"

AnnBlockComment String

comment in {- -}

Instances

Instances details
Eq AnnotationComment 
Instance details

Defined in ApiAnnotation

Methods

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

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

Data AnnotationComment 
Instance details

Defined in ApiAnnotation

Methods

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

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

toConstr :: AnnotationComment -> Constr #

dataTypeOf :: AnnotationComment -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord AnnotationComment 
Instance details

Defined in ApiAnnotation

Methods

compare :: AnnotationComment -> AnnotationComment -> Ordering #

(<) :: AnnotationComment -> AnnotationComment -> Bool #

(<=) :: AnnotationComment -> AnnotationComment -> Bool #

(>) :: AnnotationComment -> AnnotationComment -> Bool #

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

max :: AnnotationComment -> AnnotationComment -> AnnotationComment #

min :: AnnotationComment -> AnnotationComment -> AnnotationComment #

Show AnnotationComment 
Instance details

Defined in ApiAnnotation

Methods

showsPrec :: Int -> AnnotationComment -> ShowS #

show :: AnnotationComment -> String #

showList :: [AnnotationComment] -> ShowS #

Outputable AnnotationComment 
Instance details

Defined in ApiAnnotation

Methods

ppr :: AnnotationComment -> SDoc #

pprPrec :: Rational -> AnnotationComment -> SDoc #

data RdrName #

Reader Name

Do not use the data constructors of RdrName directly: prefer the family of functions that creates them, such as mkRdrUnqual

  • Note: A Located RdrName will only have API Annotations if it is a compound one, e.g.
`bar`
( ~ )

Constructors

Unqual OccName

Unqualified name

Used for ordinary, unqualified occurrences, e.g. x, y or Foo. Create such a RdrName with mkRdrUnqual

Qual ModuleName OccName

Qualified name

A qualified name written by the user in source code. The module isn't necessarily the module where the thing is defined; just the one from which it is imported. Examples are Bar.x, Bar.y or Bar.Foo. Create such a RdrName with mkRdrQual

Instances

Instances details
Eq RdrName 
Instance details

Defined in RdrName

Methods

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

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

Data RdrName 
Instance details

Defined in RdrName

Methods

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

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

toConstr :: RdrName -> Constr #

dataTypeOf :: RdrName -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord RdrName 
Instance details

Defined in RdrName

Methods

compare :: RdrName -> RdrName -> Ordering #

(<) :: RdrName -> RdrName -> Bool #

(<=) :: RdrName -> RdrName -> Bool #

(>) :: RdrName -> RdrName -> Bool #

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

max :: RdrName -> RdrName -> RdrName #

min :: RdrName -> RdrName -> RdrName #

DisambInfixOp RdrName 
Instance details

Defined in RdrHsSyn

Methods

mkHsVarOpPV :: Located RdrName -> PV (Located RdrName) #

mkHsConOpPV :: Located RdrName -> PV (Located RdrName) #

mkHsInfixHolePV :: SrcSpan -> PV (Located RdrName) #

HasOccName RdrName 
Instance details

Defined in RdrName

Methods

occName :: RdrName -> OccName #

Outputable RdrName 
Instance details

Defined in RdrName

Methods

ppr :: RdrName -> SDoc #

pprPrec :: Rational -> RdrName -> SDoc #

OutputableBndr RdrName 
Instance details

Defined in RdrName

Methods

pprBndr :: BindingSite -> RdrName -> SDoc #

pprPrefixOcc :: RdrName -> SDoc #

pprInfixOcc :: RdrName -> SDoc #

bndrIsJoin_maybe :: RdrName -> Maybe Int #

emptyArgDocMap :: ArgDocMap #

emptyDeclDocMap :: DeclDocMap #

concatDocs :: [HsDocString] -> Maybe HsDocString #

Concat docstrings with two newlines in between.

Empty docstrings are skipped.

If all inputs are empty, Nothing is returned.

appendDocs :: HsDocString -> HsDocString -> HsDocString #

Join two docstrings.

Non-empty docstrings are joined with two newlines in between, resulting in separate paragraphs.

ppr_mbDoc :: Maybe LHsDocString -> SDoc #

hsDocStringToByteString :: HsDocString -> ByteString #

Return the contents of a HsDocString as a UTF8-encoded ByteString.

unpackHDS :: HsDocString -> String #

mkHsDocStringUtf8ByteString :: ByteString -> HsDocString #

Create a HsDocString from a UTF8-encoded ByteString.

mkHsDocString :: String -> HsDocString #

data HsDocString #

Haskell Documentation String

Internally this is a UTF8-Encoded ByteString.

Instances

Instances details
Eq HsDocString 
Instance details

Defined in GHC.Hs.Doc

Methods

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

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

Data HsDocString 
Instance details

Defined in GHC.Hs.Doc

Methods

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

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

toConstr :: HsDocString -> Constr #

dataTypeOf :: HsDocString -> DataType #

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

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

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

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

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

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

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

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

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

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

Show HsDocString 
Instance details

Defined in GHC.Hs.Doc

Methods

showsPrec :: Int -> HsDocString -> ShowS #

show :: HsDocString -> String #

showList :: [HsDocString] -> ShowS #

NFData HsDocString Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: HsDocString -> () #

Binary HsDocString 
Instance details

Defined in GHC.Hs.Doc

Methods

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

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

get :: BinHandle -> IO HsDocString #

Outputable HsDocString 
Instance details

Defined in GHC.Hs.Doc

Methods

ppr :: HsDocString -> SDoc #

pprPrec :: Rational -> HsDocString -> SDoc #

type LHsDocString = Located HsDocString #

Located Haskell Documentation String

newtype DeclDocMap #

Docs for declarations: functions, data types, instances, methods etc.

Constructors

DeclDocMap (Map Name HsDocString) 

Instances

Instances details
Binary DeclDocMap 
Instance details

Defined in GHC.Hs.Doc

Methods

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

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

get :: BinHandle -> IO DeclDocMap #

Outputable DeclDocMap 
Instance details

Defined in GHC.Hs.Doc

Methods

ppr :: DeclDocMap -> SDoc #

pprPrec :: Rational -> DeclDocMap -> SDoc #

newtype ArgDocMap #

Docs for arguments. E.g. function arguments, method arguments.

Constructors

ArgDocMap (Map Name (Map Int HsDocString)) 

Instances

Instances details
Binary ArgDocMap 
Instance details

Defined in GHC.Hs.Doc

Methods

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

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

get :: BinHandle -> IO ArgDocMap #

Outputable ArgDocMap 
Instance details

Defined in GHC.Hs.Doc

Methods

ppr :: ArgDocMap -> SDoc #

pprPrec :: Rational -> ArgDocMap -> SDoc #

nameModule :: HasDebugCallStack => Name -> Module #

isExternalName :: Name -> Bool #

nameSrcSpan :: Name -> SrcSpan #

class NamedThing a where #

A class allowing convenient access to the Name of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName #

getName :: a -> Name #

Instances

Instances details
NamedThing HoleFitCandidate 
Instance details

Defined in TcHoleFitTypes

Methods

getOccName :: HoleFitCandidate -> OccName #

getName :: HoleFitCandidate -> Name #

NamedThing ClsInst 
Instance details

Defined in InstEnv

Methods

getOccName :: ClsInst -> OccName #

getName :: ClsInst -> Name #

NamedThing FamInst 
Instance details

Defined in FamInstEnv

Methods

getOccName :: FamInst -> OccName #

getName :: FamInst -> Name #

NamedThing IfaceDecl 
Instance details

Defined in IfaceSyn

Methods

getOccName :: IfaceDecl -> OccName #

getName :: IfaceDecl -> Name #

NamedThing IfaceClassOp 
Instance details

Defined in IfaceSyn

Methods

getOccName :: IfaceClassOp -> OccName #

getName :: IfaceClassOp -> Name #

NamedThing IfaceConDecl 
Instance details

Defined in IfaceSyn

Methods

getOccName :: IfaceConDecl -> OccName #

getName :: IfaceConDecl -> Name #

NamedThing Class 
Instance details

Defined in Class

Methods

getOccName :: Class -> OccName #

getName :: Class -> Name #

NamedThing ConLike 
Instance details

Defined in ConLike

Methods

getOccName :: ConLike -> OccName #

getName :: ConLike -> Name #

NamedThing DataCon 
Instance details

Defined in DataCon

Methods

getOccName :: DataCon -> OccName #

getName :: DataCon -> Name #

NamedThing PatSyn 
Instance details

Defined in PatSyn

Methods

getOccName :: PatSyn -> OccName #

getName :: PatSyn -> Name #

NamedThing TyThing 
Instance details

Defined in TyCoRep

Methods

getOccName :: TyThing -> OccName #

getName :: TyThing -> Name #

NamedThing Var 
Instance details

Defined in Var

Methods

getOccName :: Var -> OccName #

getName :: Var -> Name #

NamedThing TyCon 
Instance details

Defined in TyCon

Methods

getOccName :: TyCon -> OccName #

getName :: TyCon -> Name #

NamedThing Name 
Instance details

Defined in Name

Methods

getOccName :: Name -> OccName #

getName :: Name -> Name #

NamedThing (HsTyVarBndr GhcRn) 
Instance details

Defined in GHC.Hs.Types

Methods

getOccName :: HsTyVarBndr GhcRn -> OccName #

getName :: HsTyVarBndr GhcRn -> Name #

NamedThing (CoAxiom br) 
Instance details

Defined in CoAxiom

Methods

getOccName :: CoAxiom br -> OccName #

getName :: CoAxiom br -> Name #

NamedThing e => NamedThing (Located e) 
Instance details

Defined in Name

Methods

getOccName :: Located e -> OccName #

getName :: Located e -> Name #

NamedThing tv => NamedThing (VarBndr tv flag) 
Instance details

Defined in Var

Methods

getOccName :: VarBndr tv flag -> OccName #

getName :: VarBndr tv flag -> Name #

data Type #

Instances

Instances details
Data Type 
Instance details

Defined in TyCoRep

Methods

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

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

toConstr :: Type -> Constr #

dataTypeOf :: Type -> DataType #

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

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

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

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

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

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

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

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

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

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

NFData Type Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: Type -> () #

Outputable Type 
Instance details

Defined in TyCoRep

Methods

ppr :: Type -> SDoc #

pprPrec :: Rational -> Type -> SDoc #

Eq (DeBruijn Type) 
Instance details

Defined in CoreMap

Methods

(==) :: DeBruijn Type -> DeBruijn Type -> Bool #

(/=) :: DeBruijn Type -> DeBruijn Type -> Bool #

ToHie (TScoped Type) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped Type -> HieM [HieAST Type]

data TyThing #

A global typecheckable-thing, essentially anything that has a name. Not to be confused with a TcTyThing, which is also a typecheckable thing but in the *local* context. See TcEnv for how to retrieve a TyThing given a Name.

Constructors

AnId Id 
AConLike ConLike 
ATyCon TyCon 
ACoAxiom (CoAxiom Branched) 

Instances

Instances details
NamedThing TyThing 
Instance details

Defined in TyCoRep

Methods

getOccName :: TyThing -> OccName #

getName :: TyThing -> Name #

Outputable TyThing 
Instance details

Defined in TyCoRep

Methods

ppr :: TyThing -> SDoc #

pprPrec :: Rational -> TyThing -> SDoc #

type PredType = Type #

A type of the form p of constraint kind represents a value whose type is the Haskell predicate p, where a predicate is what occurs before the => in a Haskell type.

We use PredType as documentation to mark those types that we guarantee to have this kind.

It can be expanded into its representation, but:

  • The type checker must treat it as opaque
  • The rest of the compiler treats it as transparent

Consider these examples:

f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}

Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"

type Kind = Type #

The key type representing kinds in the compiler.

type ThetaType = [PredType] #

A collection of PredTypes

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

gopt :: GeneralFlag -> DynFlags -> Bool #

Test whether a GeneralFlag is set

defaultObjectTarget :: DynFlags -> HscTarget #

data SafeHaskellMode #

The various Safe Haskell modes

Constructors

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

Instances

Instances details
Eq SafeHaskellMode 
Instance details

Defined in DynFlags

Methods

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

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

Show SafeHaskellMode 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> SafeHaskellMode -> ShowS #

show :: SafeHaskellMode -> String #

showList :: [SafeHaskellMode] -> ShowS #

NFData SafeHaskellMode Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: SafeHaskellMode -> () #

Outputable SafeHaskellMode 
Instance details

Defined in DynFlags

Methods

ppr :: SafeHaskellMode -> SDoc #

pprPrec :: Rational -> SafeHaskellMode -> SDoc #

data HscTarget #

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

Constructors

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.

Instances

Instances details
Eq HscTarget 
Instance details

Defined in DynFlags

Methods

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

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

Show HscTarget 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> HscTarget -> ShowS #

show :: HscTarget -> String #

showList :: [HscTarget] -> ShowS #

data GhcMode #

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.

Constructors

CompManager

--make, GHCi, etc.

OneShot
ghc -c Foo.hs
MkDepend

ghc -M, see Finder for why we need this

Instances

Instances details
Eq GhcMode 
Instance details

Defined in DynFlags

Methods

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

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

Outputable GhcMode 
Instance details

Defined in DynFlags

Methods

ppr :: GhcMode -> SDoc #

pprPrec :: Rational -> GhcMode -> SDoc #

data GhcLink #

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

Constructors

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

Instances

data Phase #

Instances

Instances details
Eq Phase 
Instance details

Defined in DriverPhases

Methods

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

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

Show Phase 
Instance details

Defined in DriverPhases

Methods

showsPrec :: Int -> Phase -> ShowS #

show :: Phase -> String #

showList :: [Phase] -> ShowS #

Outputable Phase 
Instance details

Defined in DriverPhases

Methods

ppr :: Phase -> SDoc #

pprPrec :: Rational -> Phase -> SDoc #

pprModule :: Module -> SDoc #

mkModule :: UnitId -> ModuleName -> Module #

mkModuleName :: String -> ModuleName #

moduleNameString :: ModuleName -> String #

ml_hie_file :: ModLocation -> FilePath #

ml_obj_file :: ModLocation -> FilePath #

ml_hs_file :: ModLocation -> Maybe FilePath #

ml_hi_file :: ModLocation -> FilePath #

failed :: SuccessFlag -> Bool #

succeeded :: SuccessFlag -> Bool #

compareFixity :: Fixity -> Fixity -> (Bool, Bool) #

negateFixity :: Fixity #

defaultFixity :: Fixity #

maxPrecedence :: Int #

data Fixity #

Instances

Instances details
Eq Fixity 
Instance details

Defined in BasicTypes

Methods

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

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

Data Fixity 
Instance details

Defined in BasicTypes

Methods

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

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

toConstr :: Fixity -> Constr #

dataTypeOf :: Fixity -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable Fixity 
Instance details

Defined in BasicTypes

Methods

ppr :: Fixity -> SDoc #

pprPrec :: Rational -> Fixity -> SDoc #

data FixityDirection #

Constructors

InfixL 
InfixR 
InfixN 

Instances

Instances details
Eq FixityDirection 
Instance details

Defined in BasicTypes

Methods

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

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

Data FixityDirection 
Instance details

Defined in BasicTypes

Methods

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

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

toConstr :: FixityDirection -> Constr #

dataTypeOf :: FixityDirection -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable FixityDirection 
Instance details

Defined in BasicTypes

Methods

ppr :: FixityDirection -> SDoc #

pprPrec :: Rational -> FixityDirection -> SDoc #

data LexicalFixity #

Captures the fixity of declarations as they are parsed. This is not necessarily the same as the fixity declaration, as the normal fixity may be overridden using parens or backticks.

Constructors

Prefix 
Infix 

Instances

Instances details
Eq LexicalFixity 
Instance details

Defined in BasicTypes

Methods

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

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

Data LexicalFixity 
Instance details

Defined in BasicTypes

Methods

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

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

toConstr :: LexicalFixity -> Constr #

dataTypeOf :: LexicalFixity -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable LexicalFixity 
Instance details

Defined in BasicTypes

Methods

ppr :: LexicalFixity -> SDoc #

pprPrec :: Rational -> LexicalFixity -> SDoc #

data SuccessFlag #

Constructors

Succeeded 
Failed 

Instances

Instances details
Outputable SuccessFlag 
Instance details

Defined in BasicTypes

Methods

ppr :: SuccessFlag -> SDoc #

pprPrec :: Rational -> SuccessFlag -> SDoc #

data SpliceExplicitFlag #

Constructors

ExplicitSplice

= $(f x y)

ImplicitSplice

= f x y, i.e. a naked top level expression

Instances

Instances details
Data SpliceExplicitFlag 
Instance details

Defined in BasicTypes

Methods

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

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

toConstr :: SpliceExplicitFlag -> Constr #

dataTypeOf :: SpliceExplicitFlag -> DataType #

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

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

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

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

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

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

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

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

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

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

data Severity #

Constructors

SevOutput 
SevFatal 
SevInteractive 
SevDump

Log message intended for compiler developers No filelinecolumn stuff

SevInfo

Log messages intended for end users. No filelinecolumn stuff.

SevWarning 
SevError

SevWarning and SevError are used for warnings and errors o The message has a filelinecolumn heading, plus "warning:" or "error:", added by mkLocMessags o Output is intended for end users

Instances

Instances details
Show Severity 
Instance details

Defined in ErrUtils

Methods

showsPrec :: Int -> Severity -> ShowS #

show :: Severity -> String #

showList :: [Severity] -> ShowS #

ToJson Severity 
Instance details

Defined in ErrUtils

Methods

json :: Severity -> JsonDoc #

unRealSrcSpan :: RealLocated a -> a #

getRealSrcSpan :: RealLocated a -> RealSrcSpan #

cL :: HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a #

An abbreviated form of composeSrcSpan, mainly to replace the hardcoded L

dL :: HasSrcSpan a => a -> Located (SrcSpanLess a) #

An abbreviated form of decomposeSrcSpan, mainly to be used in ViewPatterns

isSubspanOf #

Arguments

:: SrcSpan

The span that may be enclosed by the other

-> SrcSpan

The span it may be enclosed by

-> Bool 

Determines whether a span is enclosed by another one

spans :: SrcSpan -> (Int, Int) -> Bool #

Determines whether a span encloses a given line and column index

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

rightmost :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

cmpLocated :: (HasSrcSpan a, Ord (SrcSpanLess a)) => a -> a -> Ordering #

Tests the ordering of the two located things

eqLocated :: (HasSrcSpan a, Eq (SrcSpanLess a)) => a -> a -> Bool #

Tests whether the two located things are equal

addCLoc :: (HasSrcSpan a, HasSrcSpan b, HasSrcSpan c) => a -> b -> SrcSpanLess c -> c #

Combine locations from two Located things and add them to a third thing

combineLocs :: (HasSrcSpan a, HasSrcSpan b) => a -> b -> SrcSpan #

mkGeneralLocated :: HasSrcSpan e => String -> SrcSpanLess e -> e #

noLoc :: HasSrcSpan a => SrcSpanLess a -> a #

unLoc :: HasSrcSpan a => a -> SrcSpanLess a #

srcSpanEnd :: SrcSpan -> SrcLoc #

Returns the location at the end of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanStart :: SrcSpan -> SrcLoc #

Returns the location at the start of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanEndCol :: RealSrcSpan -> Int #

srcSpanStartCol :: RealSrcSpan -> Int #

srcSpanEndLine :: RealSrcSpan -> Int #

srcSpanStartLine :: RealSrcSpan -> Int #

isGoodSrcSpan :: SrcSpan -> Bool #

Test if a SrcSpan is "good", i.e. has precise location information

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan #

Create a SrcSpan between two points in a file

srcLocSpan :: SrcLoc -> SrcSpan #

Create a SrcSpan corresponding to a single point

noSrcSpan :: SrcSpan #

Built-in "bad" SrcSpans for common sources of location uncertainty

srcLocCol :: RealSrcLoc -> Int #

Raises an error when used on a "bad" SrcLoc

srcLocLine :: RealSrcLoc -> Int #

Raises an error when used on a "bad" SrcLoc

srcLocFile :: RealSrcLoc -> FastString #

Gives the filename of the RealSrcLoc

noSrcLoc :: SrcLoc #

Built-in "bad" SrcLoc values for particular locations

mkSrcLoc :: FastString -> Int -> Int -> SrcLoc #

data RealSrcLoc #

Real Source Location

Represents a single point within a file

Instances

Instances details
Eq RealSrcLoc 
Instance details

Defined in SrcLoc

Methods

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

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

Ord RealSrcLoc 
Instance details

Defined in SrcLoc

Methods

compare :: RealSrcLoc -> RealSrcLoc -> Ordering #

(<) :: RealSrcLoc -> RealSrcLoc -> Bool #

(<=) :: RealSrcLoc -> RealSrcLoc -> Bool #

(>) :: RealSrcLoc -> RealSrcLoc -> Bool #

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

max :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc #

min :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc #

Show RealSrcLoc 
Instance details

Defined in SrcLoc

Methods

showsPrec :: Int -> RealSrcLoc -> ShowS #

show :: RealSrcLoc -> String #

showList :: [RealSrcLoc] -> ShowS #

Outputable RealSrcLoc 
Instance details

Defined in SrcLoc

Methods

ppr :: RealSrcLoc -> SDoc #

pprPrec :: Rational -> RealSrcLoc -> SDoc #

data SrcLoc #

Source Location

Constructors

RealSrcLoc !RealSrcLoc 
UnhelpfulLoc FastString 

Instances

Instances details
Eq SrcLoc 
Instance details

Defined in SrcLoc

Methods

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

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

Ord SrcLoc 
Instance details

Defined in SrcLoc

Methods

compare :: SrcLoc -> SrcLoc -> Ordering #

(<) :: SrcLoc -> SrcLoc -> Bool #

(<=) :: SrcLoc -> SrcLoc -> Bool #

(>) :: SrcLoc -> SrcLoc -> Bool #

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

max :: SrcLoc -> SrcLoc -> SrcLoc #

min :: SrcLoc -> SrcLoc -> SrcLoc #

Show SrcLoc 
Instance details

Defined in SrcLoc

Methods

showsPrec :: Int -> SrcLoc -> ShowS #

show :: SrcLoc -> String #

showList :: [SrcLoc] -> ShowS #

Outputable SrcLoc 
Instance details

Defined in SrcLoc

Methods

ppr :: SrcLoc -> SDoc #

pprPrec :: Rational -> SrcLoc -> SDoc #

data RealSrcSpan #

A RealSrcSpan delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.

The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.

Real Source Span

Instances

Instances details
Eq RealSrcSpan 
Instance details

Defined in SrcLoc

Methods

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

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

Data RealSrcSpan 
Instance details

Defined in SrcLoc

Methods

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

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

toConstr :: RealSrcSpan -> Constr #

dataTypeOf :: RealSrcSpan -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord RealSrcSpan 
Instance details

Defined in SrcLoc

Methods

compare :: RealSrcSpan -> RealSrcSpan -> Ordering #

(<) :: RealSrcSpan -> RealSrcSpan -> Bool #

(<=) :: RealSrcSpan -> RealSrcSpan -> Bool #

(>) :: RealSrcSpan -> RealSrcSpan -> Bool #

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

max :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan #

min :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan #

Show RealSrcSpan 
Instance details

Defined in SrcLoc

Methods

showsPrec :: Int -> RealSrcSpan -> ShowS #

show :: RealSrcSpan -> String #

showList :: [RealSrcSpan] -> ShowS #

NFData RealSrcSpan Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: RealSrcSpan -> () #

ToJson RealSrcSpan 
Instance details

Defined in SrcLoc

Methods

json :: RealSrcSpan -> JsonDoc #

Outputable RealSrcSpan 
Instance details

Defined in SrcLoc

Methods

ppr :: RealSrcSpan -> SDoc #

pprPrec :: Rational -> RealSrcSpan -> SDoc #

data SrcSpan #

Source Span

A SrcSpan identifies either a specific portion of a text file or a human-readable description of a location.

Constructors

RealSrcSpan !RealSrcSpan 
UnhelpfulSpan !FastString 

Instances

Instances details
Eq SrcSpan 
Instance details

Defined in SrcLoc

Methods

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

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

Data SrcSpan 
Instance details

Defined in SrcLoc

Methods

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

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

toConstr :: SrcSpan -> Constr #

dataTypeOf :: SrcSpan -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord SrcSpan 
Instance details

Defined in SrcLoc

Methods

compare :: SrcSpan -> SrcSpan -> Ordering #

(<) :: SrcSpan -> SrcSpan -> Bool #

(<=) :: SrcSpan -> SrcSpan -> Bool #

(>) :: SrcSpan -> SrcSpan -> Bool #

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

max :: SrcSpan -> SrcSpan -> SrcSpan #

min :: SrcSpan -> SrcSpan -> SrcSpan #

Show SrcSpan 
Instance details

Defined in SrcLoc

Methods

showsPrec :: Int -> SrcSpan -> ShowS #

show :: SrcSpan -> String #

showList :: [SrcSpan] -> ShowS #

NFData SrcSpan 
Instance details

Defined in SrcLoc

Methods

rnf :: SrcSpan -> () #

ToJson SrcSpan 
Instance details

Defined in SrcLoc

Methods

json :: SrcSpan -> JsonDoc #

Outputable SrcSpan 
Instance details

Defined in SrcLoc

Methods

ppr :: SrcSpan -> SDoc #

pprPrec :: Rational -> SrcSpan -> SDoc #

NamedThing e => NamedThing (Located e) 
Instance details

Defined in Name

Methods

getOccName :: Located e -> OccName #

getName :: Located e -> Name #

HasSrcSpan (Located a) 
Instance details

Defined in SrcLoc

Methods

composeSrcSpan :: Located (SrcSpanLess (Located a)) -> Located a #

decomposeSrcSpan :: Located a -> Located (SrcSpanLess (Located a)) #

HasLoc (Located a) 
Instance details

Defined in Compat.HieAst

Methods

loc :: Located a -> SrcSpan

HasType (LHsBind GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsBind GhcRn -> HieM [HieAST Type]

HasType (LHsBind GhcTc) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsBind GhcTc -> HieM [HieAST Type]

HasType (LHsExpr GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsExpr GhcRn -> HieM [HieAST Type]

HasType (LHsExpr GhcTc)

This instance tries to construct HieAST nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs.

HsApp, for example, doesn't have any type information available directly on the node. Our next recourse would be to desugar it into a CoreExpr then query the type of that. Yet both the desugaring call and the type query both involve recursive calls to the function and argument! This is particularly problematic when you realize that the HIE traversal will eventually visit those nodes too and ask for their types again.

Since the above is quite costly, we just skip cases where computing the expression's type is going to be expensive.

See #16233

Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsExpr GhcTc -> HieM [HieAST Type]

HasType (Located (Pat GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: Located (Pat GhcRn) -> HieM [HieAST Type]

HasType (Located (Pat GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: Located (Pat GhcTc) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (LHsExpr a), Data (HsTupArg a)) => ToHie (LHsTupArg (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsTupArg (GhcPass p) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (LHsExpr a), ToHie (MatchGroup a (LHsCmd a)), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (HsCmd a), Data (HsCmdTop a), Data (StmtLR a a (Located (HsCmd a))), Data (HsLocalBinds a), Data (StmtLR a a (Located (HsExpr a)))) => ToHie (LHsCmd (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsCmd (GhcPass p) -> HieM [HieAST Type]

(ToHie (LHsCmd a), Data (HsCmdTop a)) => ToHie (LHsCmdTop a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsCmdTop a -> HieM [HieAST Type]

ToHie (LSpliceDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LSpliceDecl GhcRn -> HieM [HieAST Type]

ToHie (LTyClDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LTyClDecl GhcRn -> HieM [HieAST Type]

ToHie (LFamilyDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LFamilyDecl GhcRn -> HieM [HieAST Type]

ToHie (LInjectivityAnn GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LInjectivityAnn GhcRn -> HieM [HieAST Type]

ToHie (HsDeriving GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsDeriving GhcRn -> HieM [HieAST Type]

ToHie (LHsDerivingClause GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsDerivingClause GhcRn -> HieM [HieAST Type]

ToHie (LStandaloneKindSig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LStandaloneKindSig GhcRn -> HieM [HieAST Type]

ToHie (LConDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LConDecl GhcRn -> HieM [HieAST Type]

ToHie (LTyFamInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LTyFamInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LDataFamInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDataFamInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LClsInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LClsInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LDerivDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDerivDecl GhcRn -> HieM [HieAST Type]

ToHie (LDefaultDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDefaultDecl GhcRn -> HieM [HieAST Type]

ToHie (LForeignDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LForeignDecl GhcRn -> HieM [HieAST Type]

ToHie (LRuleDecls GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRuleDecls GhcRn -> HieM [HieAST Type]

ToHie (LRuleDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRuleDecl GhcRn -> HieM [HieAST Type]

ToHie (LWarnDecls GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LWarnDecls GhcRn -> HieM [HieAST Type]

ToHie (LWarnDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LWarnDecl GhcRn -> HieM [HieAST Type]

ToHie (LAnnDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LAnnDecl GhcRn -> HieM [HieAST Type]

ToHie (LRoleAnnotDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRoleAnnotDecl GhcRn -> HieM [HieAST Type]

ToHie (LFixitySig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LFixitySig GhcRn -> HieM [HieAST Type]

ToHie (LHsContext GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsContext GhcRn -> HieM [HieAST Type]

ToHie (LHsType GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsType GhcRn -> HieM [HieAST Type]

ToHie (LConDeclField GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LConDeclField GhcRn -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (Context (Located (IdP a))), HasType (LHsExpr a), ToHie (PScoped (LPat a)), ToHie (MatchGroup a (LHsExpr a)), ToHie (LGRHS a (LHsExpr a)), ToHie (RContext (HsRecordBinds a)), ToHie (RFContext (Located (AmbiguousFieldOcc a))), ToHie (ArithSeqInfo a), ToHie (LHsCmdTop a), ToHie (RScoped (GuardLStmt a)), ToHie (RScoped (LHsLocalBinds a)), ToHie (TScoped (LHsWcType (NoGhcTc a))), ToHie (TScoped (LHsSigWcType (NoGhcTc a))), Data (HsExpr a), Data (HsSplice a), Data (HsTupArg a), Data (AmbiguousFieldOcc a), HasRealDataConName a) => ToHie (LHsExpr (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsExpr (GhcPass p) -> HieM [HieAST Type]

ToHie (LImportDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LImportDecl GhcRn -> HieM [HieAST Type]

ToHie (LBooleanFormula (Located Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LBooleanFormula (Located Name) -> HieM [HieAST Type]

ToHie (Located [LConDeclField GhcRn]) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located [LConDeclField GhcRn] -> HieM [HieAST Type]

ToHie (Located (DerivStrategy GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (DerivStrategy GhcRn) -> HieM [HieAST Type]

(ToHie (Context (Located (IdP a))), ToHie (PScoped (LPat a)), ToHie (HsPatSynDir a)) => ToHie (Located (PatSynBind a a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (PatSynBind a a) -> HieM [HieAST Type]

ToHie (Located HsIPName) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located HsIPName -> HieM [HieAST Type]

ToHie (Located (FunDep (Located Name))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (FunDep (Located Name)) -> HieM [HieAST Type]

(ToHie (LHsExpr a), Data (HsSplice a)) => ToHie (Located (HsSplice a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (HsSplice a) -> HieM [HieAST Type]

ToHie (Located OverlapMode) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located OverlapMode -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (Context (Located (IdP a))), ToHie (RContext (HsRecFields a (PScoped (LPat a)))), ToHie (LHsExpr a), ToHie (TScoped (LHsSigWcType a)), ProtectSig a, ToHie (TScoped (ProtectedSig a)), HasType (LPat a), Data (HsSplice a)) => ToHie (PScoped (Located (Pat (GhcPass p)))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: PScoped (Located (Pat (GhcPass p))) -> HieM [HieAST Type]

ToHie (TScoped (LHsType GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsType GhcRn) -> HieM [HieAST Type]

ToHie (TScoped (LHsWcType GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsWcType GhcTc) -> HieM [HieAST Type]

ToHie (TScoped (LHsSigWcType GhcTc))

Dummy instances - never called

Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsSigWcType GhcTc) -> HieM [HieAST Type]

ToHie (Context (Located NoExtField)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Context (Located NoExtField) -> HieM [HieAST Type]

ToHie (Context (Located Var)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Context (Located Var) -> HieM [HieAST Type]

ToHie (Context (Located Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Context (Located Name) -> HieM [HieAST Type]

(ToHie (Context (Located (IdP a))), ToHie (MatchGroup a (LHsExpr a)), ToHie (PScoped (LPat a)), ToHie (GRHSs a (LHsExpr a)), ToHie (LHsExpr a), ToHie (Located (PatSynBind a a)), HasType (LHsBind a), ModifyState (IdP a), Data (HsBind a)) => ToHie (BindContext (LHsBind a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: BindContext (LHsBind a) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (LHsExpr a), ToHie (SigContext (LSig a)), ToHie (RScoped (LHsLocalBinds a)), ToHie (RScoped (ApplicativeArg a)), ToHie (Located body), Data (StmtLR a a (Located body)), Data (StmtLR a a (Located (HsExpr a)))) => ToHie (RScoped (LStmt (GhcPass p) (Located body))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LStmt (GhcPass p) (Located body)) -> HieM [HieAST Type]

ToHie (RScoped (LFamilyResultSig GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LFamilyResultSig GhcRn) -> HieM [HieAST Type]

ToHie (RScoped (LRuleBndr GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LRuleBndr GhcRn) -> HieM [HieAST Type]

(ToHie (LHsExpr a), ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (HsLocalBinds a)) => ToHie (RScoped (LHsLocalBinds a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LHsLocalBinds a) -> HieM [HieAST Type]

ToHie (SigContext (LSig GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: SigContext (LSig GhcRn) -> HieM [HieAST Type]

ToHie (SigContext (LSig GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: SigContext (LSig GhcTc) -> HieM [HieAST Type]

(ToHie (RFContext (Located label)), ToHie arg, HasLoc arg, Data label, Data arg) => ToHie (RContext (LHsRecField' label arg)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RContext (LHsRecField' label arg) -> HieM [HieAST Type]

ToHie (RFContext (LFieldOcc GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (LFieldOcc GhcRn) -> HieM [HieAST Type]

ToHie (RFContext (LFieldOcc GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (LFieldOcc GhcTc) -> HieM [HieAST Type]

ToHie (RFContext (Located (AmbiguousFieldOcc GhcRn))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (Located (AmbiguousFieldOcc GhcRn)) -> HieM [HieAST Type]

ToHie (RFContext (Located (AmbiguousFieldOcc GhcTc))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (Located (AmbiguousFieldOcc GhcTc)) -> HieM [HieAST Type]

ToHie (IEContext (LIEWrappedName Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (LIEWrappedName Name) -> HieM [HieAST Type]

ToHie (IEContext (LIE GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (LIE GhcRn) -> HieM [HieAST Type]

ToHie (IEContext (Located (FieldLbl Name))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (Located (FieldLbl Name)) -> HieM [HieAST Type]

ToHie (IEContext (Located ModuleName)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (Located ModuleName) -> HieM [HieAST Type]

ToHie (TVScoped (LHsTyVarBndr GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TVScoped (LHsTyVarBndr GhcRn) -> HieM [HieAST Type]

Outputable a => Show (GenLocated SrcSpan a) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> GenLocated SrcSpan a -> ShowS #

show :: GenLocated SrcSpan a -> String #

showList :: [GenLocated SrcSpan a] -> ShowS #

(a ~ GhcPass p, ToHie body, ToHie (HsMatchContext (NameOrRdrName (IdP a))), ToHie (PScoped (LPat a)), ToHie (GRHSs a body), Data (Match a body)) => ToHie (LMatch (GhcPass p) body) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LMatch (GhcPass p) body -> HieM [HieAST Type]

(ToHie (Located body), ToHie (RScoped (GuardLStmt a)), Data (GRHS a (Located body))) => ToHie (LGRHS a (Located body)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LGRHS a (Located body) -> HieM [HieAST Type]

data GenLocated l e #

We attach SrcSpans to lots of things, so let's have a datatype for it.

Constructors

L l e 

Instances

Instances details
Functor (GenLocated l) 
Instance details

Defined in SrcLoc

Methods

fmap :: (a -> b) -> GenLocated l a -> GenLocated l b #

(<$) :: a -> GenLocated l b -> GenLocated l a #

Foldable (GenLocated l) 
Instance details

Defined in SrcLoc

Methods

fold :: Monoid m => GenLocated l m -> m #

foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m #

foldMap' :: Monoid m => (a -> m) -> GenLocated l a -> m #

foldr :: (a -> b -> b) -> b -> GenLocated l a -> b #

foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b #

foldl :: (b -> a -> b) -> b -> GenLocated l a -> b #

foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b #

foldr1 :: (a -> a -> a) -> GenLocated l a -> a #

foldl1 :: (a -> a -> a) -> GenLocated l a -> a #

toList :: GenLocated l a -> [a] #

null :: GenLocated l a -> Bool #

length :: GenLocated l a -> Int #

elem :: Eq a => a -> GenLocated l a -> Bool #

maximum :: Ord a => GenLocated l a -> a #

minimum :: Ord a => GenLocated l a -> a #

sum :: Num a => GenLocated l a -> a #

product :: Num a => GenLocated l a -> a #

Traversable (GenLocated l) 
Instance details

Defined in SrcLoc

Methods

traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b) #

sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a) #

mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b) #

sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a) #

NamedThing e => NamedThing (Located e) 
Instance details

Defined in Name

Methods

getOccName :: Located e -> OccName #

getName :: Located e -> Name #

HasSrcSpan (Located a) 
Instance details

Defined in SrcLoc

Methods

composeSrcSpan :: Located (SrcSpanLess (Located a)) -> Located a #

decomposeSrcSpan :: Located a -> Located (SrcSpanLess (Located a)) #

HasLoc (Located a) 
Instance details

Defined in Compat.HieAst

Methods

loc :: Located a -> SrcSpan

HasType (LHsBind GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsBind GhcRn -> HieM [HieAST Type]

HasType (LHsBind GhcTc) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsBind GhcTc -> HieM [HieAST Type]

HasType (LHsExpr GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsExpr GhcRn -> HieM [HieAST Type]

HasType (LHsExpr GhcTc)

This instance tries to construct HieAST nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs.

HsApp, for example, doesn't have any type information available directly on the node. Our next recourse would be to desugar it into a CoreExpr then query the type of that. Yet both the desugaring call and the type query both involve recursive calls to the function and argument! This is particularly problematic when you realize that the HIE traversal will eventually visit those nodes too and ask for their types again.

Since the above is quite costly, we just skip cases where computing the expression's type is going to be expensive.

See #16233

Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: LHsExpr GhcTc -> HieM [HieAST Type]

HasType (Located (Pat GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: Located (Pat GhcRn) -> HieM [HieAST Type]

HasType (Located (Pat GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

getTypeNode :: Located (Pat GhcTc) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (LHsExpr a), Data (HsTupArg a)) => ToHie (LHsTupArg (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsTupArg (GhcPass p) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (LHsExpr a), ToHie (MatchGroup a (LHsCmd a)), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (HsCmd a), Data (HsCmdTop a), Data (StmtLR a a (Located (HsCmd a))), Data (HsLocalBinds a), Data (StmtLR a a (Located (HsExpr a)))) => ToHie (LHsCmd (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsCmd (GhcPass p) -> HieM [HieAST Type]

(ToHie (LHsCmd a), Data (HsCmdTop a)) => ToHie (LHsCmdTop a) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsCmdTop a -> HieM [HieAST Type]

ToHie (LSpliceDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LSpliceDecl GhcRn -> HieM [HieAST Type]

ToHie (LTyClDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LTyClDecl GhcRn -> HieM [HieAST Type]

ToHie (LFamilyDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LFamilyDecl GhcRn -> HieM [HieAST Type]

ToHie (LInjectivityAnn GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LInjectivityAnn GhcRn -> HieM [HieAST Type]

ToHie (HsDeriving GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: HsDeriving GhcRn -> HieM [HieAST Type]

ToHie (LHsDerivingClause GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsDerivingClause GhcRn -> HieM [HieAST Type]

ToHie (LStandaloneKindSig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LStandaloneKindSig GhcRn -> HieM [HieAST Type]

ToHie (LConDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LConDecl GhcRn -> HieM [HieAST Type]

ToHie (LTyFamInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LTyFamInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LDataFamInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDataFamInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LClsInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LClsInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LInstDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LInstDecl GhcRn -> HieM [HieAST Type]

ToHie (LDerivDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDerivDecl GhcRn -> HieM [HieAST Type]

ToHie (LDefaultDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LDefaultDecl GhcRn -> HieM [HieAST Type]

ToHie (LForeignDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LForeignDecl GhcRn -> HieM [HieAST Type]

ToHie (LRuleDecls GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRuleDecls GhcRn -> HieM [HieAST Type]

ToHie (LRuleDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRuleDecl GhcRn -> HieM [HieAST Type]

ToHie (LWarnDecls GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LWarnDecls GhcRn -> HieM [HieAST Type]

ToHie (LWarnDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LWarnDecl GhcRn -> HieM [HieAST Type]

ToHie (LAnnDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LAnnDecl GhcRn -> HieM [HieAST Type]

ToHie (LRoleAnnotDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LRoleAnnotDecl GhcRn -> HieM [HieAST Type]

ToHie (LFixitySig GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LFixitySig GhcRn -> HieM [HieAST Type]

ToHie (LHsContext GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsContext GhcRn -> HieM [HieAST Type]

ToHie (LHsType GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsType GhcRn -> HieM [HieAST Type]

ToHie (LConDeclField GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LConDeclField GhcRn -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (Context (Located (IdP a))), HasType (LHsExpr a), ToHie (PScoped (LPat a)), ToHie (MatchGroup a (LHsExpr a)), ToHie (LGRHS a (LHsExpr a)), ToHie (RContext (HsRecordBinds a)), ToHie (RFContext (Located (AmbiguousFieldOcc a))), ToHie (ArithSeqInfo a), ToHie (LHsCmdTop a), ToHie (RScoped (GuardLStmt a)), ToHie (RScoped (LHsLocalBinds a)), ToHie (TScoped (LHsWcType (NoGhcTc a))), ToHie (TScoped (LHsSigWcType (NoGhcTc a))), Data (HsExpr a), Data (HsSplice a), Data (HsTupArg a), Data (AmbiguousFieldOcc a), HasRealDataConName a) => ToHie (LHsExpr (GhcPass p)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LHsExpr (GhcPass p) -> HieM [HieAST Type]

ToHie (LImportDecl GhcRn) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LImportDecl GhcRn -> HieM [HieAST Type]

ToHie (LBooleanFormula (Located Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LBooleanFormula (Located Name) -> HieM [HieAST Type]

ToHie (Located [LConDeclField GhcRn]) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located [LConDeclField GhcRn] -> HieM [HieAST Type]

ToHie (Located (DerivStrategy GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (DerivStrategy GhcRn) -> HieM [HieAST Type]

(ToHie (Context (Located (IdP a))), ToHie (PScoped (LPat a)), ToHie (HsPatSynDir a)) => ToHie (Located (PatSynBind a a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (PatSynBind a a) -> HieM [HieAST Type]

ToHie (Located HsIPName) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located HsIPName -> HieM [HieAST Type]

ToHie (Located (FunDep (Located Name))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (FunDep (Located Name)) -> HieM [HieAST Type]

(ToHie (LHsExpr a), Data (HsSplice a)) => ToHie (Located (HsSplice a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (HsSplice a) -> HieM [HieAST Type]

ToHie (Located OverlapMode) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located OverlapMode -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (Context (Located (IdP a))), ToHie (RContext (HsRecFields a (PScoped (LPat a)))), ToHie (LHsExpr a), ToHie (TScoped (LHsSigWcType a)), ProtectSig a, ToHie (TScoped (ProtectedSig a)), HasType (LPat a), Data (HsSplice a)) => ToHie (PScoped (Located (Pat (GhcPass p)))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: PScoped (Located (Pat (GhcPass p))) -> HieM [HieAST Type]

ToHie (TScoped (LHsType GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsType GhcRn) -> HieM [HieAST Type]

ToHie (TScoped (LHsWcType GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsWcType GhcTc) -> HieM [HieAST Type]

ToHie (TScoped (LHsSigWcType GhcTc))

Dummy instances - never called

Instance details

Defined in Compat.HieAst

Methods

toHie :: TScoped (LHsSigWcType GhcTc) -> HieM [HieAST Type]

ToHie (Context (Located NoExtField)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Context (Located NoExtField) -> HieM [HieAST Type]

ToHie (Context (Located Var)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Context (Located Var) -> HieM [HieAST Type]

ToHie (Context (Located Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Context (Located Name) -> HieM [HieAST Type]

(ToHie (Context (Located (IdP a))), ToHie (MatchGroup a (LHsExpr a)), ToHie (PScoped (LPat a)), ToHie (GRHSs a (LHsExpr a)), ToHie (LHsExpr a), ToHie (Located (PatSynBind a a)), HasType (LHsBind a), ModifyState (IdP a), Data (HsBind a)) => ToHie (BindContext (LHsBind a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: BindContext (LHsBind a) -> HieM [HieAST Type]

(a ~ GhcPass p, ToHie (PScoped (LPat a)), ToHie (LHsExpr a), ToHie (SigContext (LSig a)), ToHie (RScoped (LHsLocalBinds a)), ToHie (RScoped (ApplicativeArg a)), ToHie (Located body), Data (StmtLR a a (Located body)), Data (StmtLR a a (Located (HsExpr a)))) => ToHie (RScoped (LStmt (GhcPass p) (Located body))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LStmt (GhcPass p) (Located body)) -> HieM [HieAST Type]

ToHie (RScoped (LFamilyResultSig GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LFamilyResultSig GhcRn) -> HieM [HieAST Type]

ToHie (RScoped (LRuleBndr GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LRuleBndr GhcRn) -> HieM [HieAST Type]

(ToHie (LHsExpr a), ToHie (PScoped (LPat a)), ToHie (BindContext (LHsBind a)), ToHie (SigContext (LSig a)), ToHie (RScoped (HsValBindsLR a a)), Data (HsLocalBinds a)) => ToHie (RScoped (LHsLocalBinds a)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RScoped (LHsLocalBinds a) -> HieM [HieAST Type]

ToHie (SigContext (LSig GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: SigContext (LSig GhcRn) -> HieM [HieAST Type]

ToHie (SigContext (LSig GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: SigContext (LSig GhcTc) -> HieM [HieAST Type]

(ToHie (RFContext (Located label)), ToHie arg, HasLoc arg, Data label, Data arg) => ToHie (RContext (LHsRecField' label arg)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RContext (LHsRecField' label arg) -> HieM [HieAST Type]

ToHie (RFContext (LFieldOcc GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (LFieldOcc GhcRn) -> HieM [HieAST Type]

ToHie (RFContext (LFieldOcc GhcTc)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (LFieldOcc GhcTc) -> HieM [HieAST Type]

ToHie (RFContext (Located (AmbiguousFieldOcc GhcRn))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (Located (AmbiguousFieldOcc GhcRn)) -> HieM [HieAST Type]

ToHie (RFContext (Located (AmbiguousFieldOcc GhcTc))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: RFContext (Located (AmbiguousFieldOcc GhcTc)) -> HieM [HieAST Type]

ToHie (IEContext (LIEWrappedName Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (LIEWrappedName Name) -> HieM [HieAST Type]

ToHie (IEContext (LIE GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (LIE GhcRn) -> HieM [HieAST Type]

ToHie (IEContext (Located (FieldLbl Name))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (Located (FieldLbl Name)) -> HieM [HieAST Type]

ToHie (IEContext (Located ModuleName)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (Located ModuleName) -> HieM [HieAST Type]

ToHie (TVScoped (LHsTyVarBndr GhcRn)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: TVScoped (LHsTyVarBndr GhcRn) -> HieM [HieAST Type]

(Eq l, Eq e) => Eq (GenLocated l e) 
Instance details

Defined in SrcLoc

Methods

(==) :: GenLocated l e -> GenLocated l e -> Bool #

(/=) :: GenLocated l e -> GenLocated l e -> Bool #

(Data l, Data e) => Data (GenLocated l e) 
Instance details

Defined in SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e) #

toConstr :: GenLocated l e -> Constr #

dataTypeOf :: GenLocated l e -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e)) #

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (GenLocated l e)) #

gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r #

gmapQ :: (forall d. Data d => d -> u) -> GenLocated l e -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #

(Ord l, Ord e) => Ord (GenLocated l e) 
Instance details

Defined in SrcLoc

Methods

compare :: GenLocated l e -> GenLocated l e -> Ordering #

(<) :: GenLocated l e -> GenLocated l e -> Bool #

(<=) :: GenLocated l e -> GenLocated l e -> Bool #

(>) :: GenLocated l e -> GenLocated l e -> Bool #

(>=) :: GenLocated l e -> GenLocated l e -> Bool #

max :: GenLocated l e -> GenLocated l e -> GenLocated l e #

min :: GenLocated l e -> GenLocated l e -> GenLocated l e #

Outputable a => Show (GenLocated SrcSpan a) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> GenLocated SrcSpan a -> ShowS #

show :: GenLocated SrcSpan a -> String #

showList :: [GenLocated SrcSpan a] -> ShowS #

(NFData l, NFData e) => NFData (GenLocated l e) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: GenLocated l e -> () #

(Outputable l, Outputable e) => Outputable (GenLocated l e) 
Instance details

Defined in SrcLoc

Methods

ppr :: GenLocated l e -> SDoc #

pprPrec :: Rational -> GenLocated l e -> SDoc #

(a ~ GhcPass p, ToHie body, ToHie (HsMatchContext (NameOrRdrName (IdP a))), ToHie (PScoped (LPat a)), ToHie (GRHSs a body), Data (Match a body)) => ToHie (LMatch (GhcPass p) body) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LMatch (GhcPass p) body -> HieM [HieAST Type]

(ToHie (Located body), ToHie (RScoped (GuardLStmt a)), Data (GRHS a (Located body))) => ToHie (LGRHS a (Located body)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LGRHS a (Located body) -> HieM [HieAST Type]

type SrcSpanLess (GenLocated l e) 
Instance details

Defined in SrcLoc

type SrcSpanLess (GenLocated l e) = e

type Located = GenLocated SrcSpan #

type family SrcSpanLess a #

Determines the type of undecorated syntactic entities For most syntactic entities E, where source location spans are introduced by a wrapper construtor of the same syntactic entity, we have `SrcSpanLess E = E`. However, some syntactic entities have a different type compared to a syntactic entity `e :: E` may have the type `Located E` when decorated by wrapping it with `L sp e` for a source span sp.

Instances

Instances details
type SrcSpanLess Name 
Instance details

Defined in Name

type SrcSpanLess Name = Name
type SrcSpanLess (GenLocated l e) 
Instance details

Defined in SrcLoc

type SrcSpanLess (GenLocated l e) = e

composeSrcSpan :: HasSrcSpan a => Located (SrcSpanLess a) -> a #

Composes a SrcSpan decoration with an undecorated syntactic entity to form its decorated variant

decomposeSrcSpan :: HasSrcSpan a => a -> Located (SrcSpanLess a) #

Decomposes a decorated syntactic entity into its SrcSpan decoration and its undecorated variant

alwaysQualify :: PrintUnqualified #

data PrintUnqualified #

When printing code that contains original names, we need to map the original names back to something the user understands. This is the purpose of the triple of functions that gets passed around when rendering SDoc.

data Module #

A Module is a pair of a UnitId and a ModuleName.

Module variables (i.e. H) which can be instantiated to a specific module at some later point in time are represented with moduleUnitId set to holeUnitId (this allows us to avoid having to make moduleUnitId a partial operation.)

Instances

Instances details
Eq Module 
Instance details

Defined in Module

Methods

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

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

Data Module 
Instance details

Defined in Module

Methods

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

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

toConstr :: Module -> Constr #

dataTypeOf :: Module -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Module 
Instance details

Defined in Module

Methods

compare :: Module -> Module -> Ordering #

(<) :: Module -> Module -> Bool #

(<=) :: Module -> Module -> Bool #

(>) :: Module -> Module -> Bool #

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

max :: Module -> Module -> Module #

min :: Module -> Module -> Module #

Show Module Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> Module -> ShowS #

show :: Module -> String #

showList :: [Module] -> ShowS #

NFData Module 
Instance details

Defined in Module

Methods

rnf :: Module -> () #

Binary Module 
Instance details

Defined in Module

Methods

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

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

get :: BinHandle -> IO Module #

Uniquable Module 
Instance details

Defined in Module

Methods

getUnique :: Module -> Unique #

Outputable Module 
Instance details

Defined in Module

Methods

ppr :: Module -> SDoc #

pprPrec :: Rational -> Module -> SDoc #

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module 
Instance details

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module #

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module #

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId #

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module #

data ModuleName #

A ModuleName is essentially a simple string, e.g. Data.List.

Instances

Instances details
Eq ModuleName 
Instance details

Defined in Module

Methods

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

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

Data ModuleName 
Instance details

Defined in Module

Methods

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

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

toConstr :: ModuleName -> Constr #

dataTypeOf :: ModuleName -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord ModuleName 
Instance details

Defined in Module

Methods

compare :: ModuleName -> ModuleName -> Ordering #

(<) :: ModuleName -> ModuleName -> Bool #

(<=) :: ModuleName -> ModuleName -> Bool #

(>) :: ModuleName -> ModuleName -> Bool #

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

max :: ModuleName -> ModuleName -> ModuleName #

min :: ModuleName -> ModuleName -> ModuleName #

Show ModuleName Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> ModuleName -> ShowS #

show :: ModuleName -> String #

showList :: [ModuleName] -> ShowS #

Hashable ModuleName Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

hashWithSalt :: Int -> ModuleName -> Int #

hash :: ModuleName -> Int #

NFData ModuleName 
Instance details

Defined in Module

Methods

rnf :: ModuleName -> () #

Binary ModuleName 
Instance details

Defined in Module

Methods

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

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

get :: BinHandle -> IO ModuleName #

Uniquable ModuleName 
Instance details

Defined in Module

Methods

getUnique :: ModuleName -> Unique #

Outputable ModuleName 
Instance details

Defined in Module

Methods

ppr :: ModuleName -> SDoc #

pprPrec :: Rational -> ModuleName -> SDoc #

BinaryStringRep ModuleName 
Instance details

Defined in Module

Methods

fromStringRep :: ByteString -> ModuleName #

toStringRep :: ModuleName -> ByteString #

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module 
Instance details

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module #

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module #

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId #

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module #

ToHie (IEContext (Located ModuleName)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (Located ModuleName) -> HieM [HieAST Type]

data UnitId #

A unit identifier identifies a (possibly partially) instantiated library. It is primarily used as part of Module, which in turn is used in Name, which is used to give names to entities when typechecking.

There are two possible forms for a UnitId. It can be a DefiniteUnitId, in which case we just have a string that uniquely identifies some fully compiled, installed library we have on disk. However, when we are typechecking a library with missing holes, we may need to instantiate a library on the fly (in which case we don't have any on-disk representation.) In that case, you have an IndefiniteUnitId, which explicitly records the instantiation, so that we can substitute over it.

Instances

Instances details
Eq UnitId 
Instance details

Defined in Module

Methods

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

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

Data UnitId 
Instance details

Defined in Module

Methods

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

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

toConstr :: UnitId -> Constr #

dataTypeOf :: UnitId -> DataType #

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

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId) #

gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r #

gmapQ :: (forall d. Data d => d -> u) -> UnitId -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnitId -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #

Ord UnitId 
Instance details

Defined in Module

Methods

compare :: UnitId -> UnitId -> Ordering #

(<) :: UnitId -> UnitId -> Bool #

(<=) :: UnitId -> UnitId -> Bool #

(>) :: UnitId -> UnitId -> Bool #

(>=) :: UnitId -> UnitId -> Bool #

max :: UnitId -> UnitId -> UnitId #

min :: UnitId -> UnitId -> UnitId #

Show UnitId 
Instance details

Defined in Module

Methods

showsPrec :: Int -> UnitId -> ShowS #

show :: UnitId -> String #

showList :: [UnitId] -> ShowS #

NFData UnitId 
Instance details

Defined in Module

Methods

rnf :: UnitId -> () #

Binary UnitId 
Instance details

Defined in Module

Methods

put_ :: BinHandle -> UnitId -> IO () #

put :: BinHandle -> UnitId -> IO (Bin UnitId) #

get :: BinHandle -> IO UnitId #

Uniquable UnitId 
Instance details

Defined in Module

Methods

getUnique :: UnitId -> Unique #

Outputable UnitId 
Instance details

Defined in Module

Methods

ppr :: UnitId -> SDoc #

pprPrec :: Rational -> UnitId -> SDoc #

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module 
Instance details

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module #

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module #

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId #

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module #

isFunTyCon :: TyCon -> Bool #

data TyCon #

TyCons represent type constructors. Type constructors are introduced by things such as:

1) Data declarations: data Foo = ... creates the Foo type constructor of kind *

2) Type synonyms: type Foo = ... creates the Foo type constructor

3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind * -> *

4) Class declarations: class Foo where creates the Foo type constructor of kind *

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

Instances

Instances details
Eq TyCon 
Instance details

Defined in TyCon

Methods

(==) :: TyCon -> TyCon -> Bool #

(/=) :: TyCon -> TyCon -> Bool #

Data TyCon 
Instance details

Defined in TyCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCon -> c TyCon #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCon #

toConstr :: TyCon -> Constr #

dataTypeOf :: TyCon -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCon) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCon) #

gmapT :: (forall b. Data b => b -> b) -> TyCon -> TyCon #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r #

gmapQ :: (forall d. Data d => d -> u) -> TyCon -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCon -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon #

NamedThing TyCon 
Instance details

Defined in TyCon

Methods

getOccName :: TyCon -> OccName #

getName :: TyCon -> Name #

Uniquable TyCon 
Instance details

Defined in TyCon

Methods

getUnique :: TyCon -> Unique #

Outputable TyCon 
Instance details

Defined in TyCon

Methods

ppr :: TyCon -> SDoc #

pprPrec :: Rational -> TyCon -> SDoc #

withSignalHandlers :: (ExceptionMonad m, MonadIO m) => m a -> m a #

Temporarily install standard signal handlers for catching ^C, which just throw an exception in the current thread.

showGhcException :: GhcException -> ShowS #

Append a description of the given exception to this string.

Note that this uses unsafeGlobalDynFlags, which may have some uninitialized fields if invoked before initGhcMonad has been called. If the error message to be printed includes a pretty-printer document which forces one of these fields this call may bottom.

data GhcException #

GHC's own exception type error messages all take the form:

     location: error

If the location is on the command line, or in GHC itself, then location="ghc". All of the error types below correspond to a location of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).

Constructors

Signal Int

Some other fatal signal (SIGHUP,SIGTERM)

UsageError String

Prints the short usage msg after the error

CmdLineError String

A problem with the command line arguments, but don't print usage.

Panic String

The impossible happened.

PprPanic String SDoc 
Sorry String

The user tickled something that's known not to work yet, but we're not counting it as a bug.

PprSorry String SDoc 
InstallationError String

An installation problem.

ProgramError String

An error in the user's code, probably.

PprProgramError String SDoc 

Instances

Instances details
Show GhcException 
Instance details

Defined in Panic

Methods

showsPrec :: Int -> GhcException -> ShowS #

show :: GhcException -> String #

showList :: [GhcException] -> ShowS #

Exception GhcException 
Instance details

Defined in Panic

Methods

toException :: GhcException -> SomeException #

fromException :: SomeException -> Maybe GhcException #

displayException :: GhcException -> String #

data Name #

A unique, unambiguous name for something, containing information about where that thing originated.

Instances

Instances details
Eq Name

The same comments as for Name's Ord instance apply.

Instance details

Defined in Name

Methods

(==) :: Name -> Name -> Bool #

(/=) :: Name -> Name -> Bool #

Data Name 
Instance details

Defined in Name

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name #

toConstr :: Name -> Constr #

dataTypeOf :: Name -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) #

gmapT :: (forall b. Data b => b -> b) -> Name -> Name #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

Ord Name

Caution: This instance is implemented via nonDetCmpUnique, which means that the ordering is not stable across deserialization or rebuilds.

See nonDetCmpUnique for further information, and trac #15240 for a bug caused by improper use of this instance.

Instance details

Defined in Name

Methods

compare :: Name -> Name -> Ordering #

(<) :: Name -> Name -> Bool #

(<=) :: Name -> Name -> Bool #

(>) :: Name -> Name -> Bool #

(>=) :: Name -> Name -> Bool #

max :: Name -> Name -> Name #

min :: Name -> Name -> Name #

NFData Name 
Instance details

Defined in Name

Methods

rnf :: Name -> () #

NamedThing Name 
Instance details

Defined in Name

Methods

getOccName :: Name -> OccName #

getName :: Name -> Name #

HasOccName Name 
Instance details

Defined in Name

Methods

occName :: Name -> OccName #

Binary Name

Assumes that the Name is a non-binding one. See putIfaceTopBndr and getIfaceTopBndr for serializing binding Names. See UserData for the rationale for this distinction.

Instance details

Defined in Name

Methods

put_ :: BinHandle -> Name -> IO () #

put :: BinHandle -> Name -> IO (Bin Name) #

get :: BinHandle -> IO Name #

Uniquable Name 
Instance details

Defined in Name

Methods

getUnique :: Name -> Unique #

HasSrcSpan Name 
Instance details

Defined in Name

Methods

composeSrcSpan :: Located (SrcSpanLess Name) -> Name #

decomposeSrcSpan :: Name -> Located (SrcSpanLess Name) #

Outputable Name 
Instance details

Defined in Name

Methods

ppr :: Name -> SDoc #

pprPrec :: Rational -> Name -> SDoc #

OutputableBndr Name 
Instance details

Defined in Name

Methods

pprBndr :: BindingSite -> Name -> SDoc #

pprPrefixOcc :: Name -> SDoc #

pprInfixOcc :: Name -> SDoc #

bndrIsJoin_maybe :: Name -> Maybe Int #

ModifyState Name 
Instance details

Defined in Compat.HieAst

Methods

addSubstitution :: Name -> Name -> HieState -> HieState

ToHie (LBooleanFormula (Located Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: LBooleanFormula (Located Name) -> HieM [HieAST Type]

ToHie (Located (FunDep (Located Name))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Located (FunDep (Located Name)) -> HieM [HieAST Type]

ToHie (Context (Located Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: Context (Located Name) -> HieM [HieAST Type]

ToHie (IEContext (LIEWrappedName Name)) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (LIEWrappedName Name) -> HieM [HieAST Type]

ToHie (IEContext (Located (FieldLbl Name))) 
Instance details

Defined in Compat.HieAst

Methods

toHie :: IEContext (Located (FieldLbl Name)) -> HieM [HieAST Type]

type SrcSpanLess Name 
Instance details

Defined in Name

type SrcSpanLess Name = Name

data DynFlags #

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

Constructors

DynFlags 

Fields

data GeneralFlag #

Enumerates the simple on-or-off dynamic flags

Constructors

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 
Opt_FastLlvm 
Opt_NoTypeableBinds 
Opt_WarnIsError 
Opt_ShowWarnGroups 
Opt_HideSourcePaths 
Opt_PrintExplicitForalls 
Opt_PrintExplicitKinds 
Opt_PrintExplicitCoercions 
Opt_PrintExplicitRuntimeReps 
Opt_PrintEqualityRelations 
Opt_PrintAxiomIncomps 
Opt_PrintUnicodeSyntax 
Opt_PrintExpandedSynonyms 
Opt_PrintPotentialInstances 
Opt_PrintTypecheckerElaboration 
Opt_CallArity 
Opt_Exitification 
Opt_Strictness 
Opt_LateDmdAnal 
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 
Opt_UnboxStrictFields 
Opt_UnboxSmallStrictFields 
Opt_DictsCheap 
Opt_EnableRewriteRules 
Opt_EnableThSpliceWarnings 
Opt_RegsGraph 
Opt_RegsIterative 
Opt_PedanticBottoms 
Opt_LlvmTBAA 
Opt_LlvmFillUndefWithGarbage 
Opt_IrrefutableTuples 
Opt_CmmSink 
Opt_CmmElimCommonBlocks 
Opt_AsmShortcutting 
Opt_OmitYields 
Opt_FunToThunk 
Opt_DictsStrict 
Opt_DmdTxDictSel 
Opt_Loopification 
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 
Opt_SimplPreInlining 
Opt_IgnoreInterfacePragmas 
Opt_OmitInterfacePragmas 
Opt_ExposeAllUnfoldings 
Opt_WriteInterface 
Opt_WriteHie 
Opt_AutoSccsOnIndividualCafs 
Opt_ProfCountEntries 
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 
Opt_SingleLibFolder 
Opt_KeepCAFs 
Opt_KeepGoing 
Opt_ByteCode 
Opt_ErrorSpans 
Opt_DeferDiagnostics 
Opt_DiagnosticsShowCaret 
Opt_PprCaseAsLet 
Opt_PprShowTicks 
Opt_ShowHoleConstraints 
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 
Opt_SuppressCoercions 
Opt_SuppressVarKinds 
Opt_SuppressModulePrefixes 
Opt_SuppressTypeApplications 
Opt_SuppressIdInfo 
Opt_SuppressUnfoldings 
Opt_SuppressTypeSignatures 
Opt_SuppressUniques 
Opt_SuppressStgExts 
Opt_SuppressTicks 
Opt_SuppressTimestamps

Suppress timestamps in dumps

Opt_AutoLinkPackages 
Opt_ImplicitImportQualified 
Opt_KeepHscppFiles 
Opt_KeepHiDiffs 
Opt_KeepHcFiles 
Opt_KeepSFiles 
Opt_KeepTmpFiles 
Opt_KeepRawTokenStream 
Opt_KeepLlvmFiles 
Opt_KeepHiFiles 
Opt_KeepOFiles 
Opt_BuildDynamicToo 
Opt_DistrustAllPackages 
Opt_PackageTrust 
Opt_PluginTrustworthy 
Opt_G_NoStateHack 
Opt_G_NoOptCoercion 

Instances

Instances details
Enum GeneralFlag 
Instance details

Defined in DynFlags

Methods

succ :: GeneralFlag -> GeneralFlag #

pred :: GeneralFlag -> GeneralFlag #

toEnum :: Int -> GeneralFlag #

fromEnum :: GeneralFlag -> Int #

enumFrom :: GeneralFlag -> [GeneralFlag] #

enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag] #

enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag] #

enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag] #

Eq GeneralFlag 
Instance details

Defined in DynFlags

Methods

(==) :: GeneralFlag -> GeneralFlag -> Bool #

(/=) :: GeneralFlag -> GeneralFlag -> Bool #

Show GeneralFlag 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> GeneralFlag -> ShowS #

show :: GeneralFlag -> String #

showList :: [GeneralFlag] -> ShowS #

gfinally :: ExceptionMonad m => m a -> m b -> m a #

Generalised version of finally, allowing an arbitrary exception handling monad instead of just IO.

gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a #

Generalised version of catch, allowing an arbitrary exception handling monad instead of just IO.

gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c #

Generalised version of bracket, allowing an arbitrary exception handling monad instead of just IO.

type ForeignHValue = ForeignRef HValue #

data HValue #

Instances

Instances details
Show HValue 
Instance details

Defined in GHCi.RemoteTypes

Methods

showsPrec :: Int -> HValue -> ShowS #

show :: HValue -> String #

showList :: [HValue] -> ShowS #

coreModule :: DesugaredMod m => m -> ModGuts #

emptyFilesToClean :: FilesToClean #

An empty FilesToClean

isBmi2Enabled :: DynFlags -> Bool #

isBmiEnabled :: DynFlags -> Bool #

isAvx512pfEnabled :: DynFlags -> Bool #

isAvx512fEnabled :: DynFlags -> Bool #

isAvx512erEnabled :: DynFlags -> Bool #

isAvx512cdEnabled :: DynFlags -> Bool #

isAvx2Enabled :: DynFlags -> Bool #

isAvxEnabled :: DynFlags -> Bool #

isSse4_2Enabled :: DynFlags -> Bool #

isSse2Enabled :: DynFlags -> Bool #

isSseEnabled :: DynFlags -> Bool #

setUnsafeGlobalDynFlags :: DynFlags -> IO () #

makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String]) #

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.

tARGET_MAX_WORD :: DynFlags -> Integer #

tARGET_MAX_INT :: DynFlags -> Integer #

tARGET_MIN_INT :: DynFlags -> Integer #

mAX_PTR_TAG :: DynFlags -> Int #

tAG_MASK :: DynFlags -> Int #

wordAlignment :: DynFlags -> Alignment #

wORD_SIZE_IN_BITS :: DynFlags -> Int #

bLOCK_SIZE_W :: DynFlags -> Int #

iLDV_STATE_USE :: DynFlags -> Integer #

iLDV_STATE_CREATE :: DynFlags -> Integer #

iLDV_CREATE_MASK :: DynFlags -> Integer #

lDV_SHIFT :: DynFlags -> Int #

dYNAMIC_BY_DEFAULT :: DynFlags -> Bool #

wORDS_BIGENDIAN :: DynFlags -> Bool #

tAG_BITS :: DynFlags -> Int #

bITMAP_BITS_SHIFT :: DynFlags -> Int #

cLONG_LONG_SIZE :: DynFlags -> Int #

cLONG_SIZE :: DynFlags -> Int #

cINT_SIZE :: DynFlags -> Int #

dOUBLE_SIZE :: DynFlags -> Int #

wORD_SIZE :: DynFlags -> Int #

aP_STACK_SPLIM :: DynFlags -> Int #

rESERVED_STACK_WORDS :: DynFlags -> Int #

rESERVED_C_STACK_BYTES :: DynFlags -> Int #

mAX_Real_Long_REG :: DynFlags -> Int #

mAX_Real_XMM_REG :: DynFlags -> Int #

mAX_Real_Double_REG :: DynFlags -> Int #

mAX_Real_Float_REG :: DynFlags -> Int #

mAX_Real_Vanilla_REG :: DynFlags -> Int #

mAX_XMM_REG :: DynFlags -> Int #

mAX_Long_REG :: DynFlags -> Int #

mAX_Double_REG :: DynFlags -> Int #

mAX_Float_REG :: DynFlags -> Int #

mAX_Vanilla_REG :: DynFlags -> Int #

mUT_ARR_PTRS_CARD_BITS :: DynFlags -> Int #

mAX_CHARLIKE :: DynFlags -> Int #

mIN_CHARLIKE :: DynFlags -> Int #

mAX_INTLIKE :: DynFlags -> Int #

mIN_INTLIKE :: DynFlags -> Int #

mIN_PAYLOAD_SIZE :: DynFlags -> Int #

mAX_SPEC_AP_SIZE :: DynFlags -> Int #

mAX_SPEC_SELECTEE_SIZE :: DynFlags -> Int #

oFFSET_StgFunInfoExtraRev_arity :: DynFlags -> Int #

sIZEOF_StgFunInfoExtraRev :: DynFlags -> Int #

oFFSET_StgFunInfoExtraFwd_arity :: DynFlags -> Int #

oFFSET_StgUpdateFrame_updatee :: DynFlags -> Int #

oFFSET_StgStack_stack :: DynFlags -> Int #

oFFSET_StgStack_sp :: DynFlags -> Int #

oFFSET_StgTSO_stackobj :: DynFlags -> Int #

oFFSET_StgTSO_cccs :: DynFlags -> Int #

oFFSET_StgTSO_alloc_limit :: DynFlags -> Int #

oFFSET_StgArrBytes_bytes :: DynFlags -> Int #

sIZEOF_StgArrBytes_NoHdr :: DynFlags -> Int #

oFFSET_StgSmallMutArrPtrs_ptrs :: DynFlags -> Int #

sIZEOF_StgSmallMutArrPtrs_NoHdr :: DynFlags -> Int #

oFFSET_StgMutArrPtrs_size :: DynFlags -> Int #

oFFSET_StgMutArrPtrs_ptrs :: DynFlags -> Int #

sIZEOF_StgMutArrPtrs_NoHdr :: DynFlags -> Int #

sIZEOF_StgUpdateFrame_NoHdr :: DynFlags -> Int #

oFFSET_StgEntCounter_entry_count :: DynFlags -> Int #

oFFSET_StgEntCounter_link :: DynFlags -> Int #

oFFSET_StgEntCounter_registeredp :: DynFlags -> Int #

oFFSET_StgEntCounter_allocd :: DynFlags -> Int #

oFFSET_StgEntCounter_allocs :: DynFlags -> Int #

sIZEOF_StgSMPThunkHeader :: DynFlags -> Int #

oFFSET_StgHeader_ldvw :: DynFlags -> Int #

oFFSET_StgHeader_ccs :: DynFlags -> Int #

oFFSET_CostCentreStack_scc_count :: DynFlags -> Int #

oFFSET_CostCentreStack_mem_alloc :: DynFlags -> Int #

sIZEOF_CostCentreStack :: DynFlags -> Int #

oFFSET_bdescr_flags :: DynFlags -> Int #

oFFSET_bdescr_blocks :: DynFlags -> Int #

oFFSET_bdescr_free :: DynFlags -> Int #

oFFSET_bdescr_start :: DynFlags -> Int #

oFFSET_Capability_r :: DynFlags -> Int #

oFFSET_stgGCFun :: DynFlags -> Int #

oFFSET_stgGCEnter1 :: DynFlags -> Int #

oFFSET_stgEagerBlackholeInfo :: DynFlags -> Int #

oFFSET_StgRegTable_rHpAlloc :: DynFlags -> Int #

oFFSET_StgRegTable_rCurrentNursery :: DynFlags -> Int #

oFFSET_StgRegTable_rCurrentTSO :: DynFlags -> Int #

oFFSET_StgRegTable_rCCCS :: DynFlags -> Int #

oFFSET_StgRegTable_rHpLim :: DynFlags -> Int #

oFFSET_StgRegTable_rHp :: DynFlags -> Int #

oFFSET_StgRegTable_rSpLim :: DynFlags -> Int #

oFFSET_StgRegTable_rSp :: DynFlags -> Int #

oFFSET_StgRegTable_rL1 :: DynFlags -> Int #

oFFSET_StgRegTable_rZMM6 :: DynFlags -> Int #

oFFSET_StgRegTable_rZMM5 :: DynFlags -> Int #

oFFSET_StgRegTable_rZMM4 :: DynFlags -> Int #

oFFSET_StgRegTable_rZMM3 :: DynFlags -> Int #

oFFSET_StgRegTable_rZMM2 :: DynFlags -> Int #

oFFSET_StgRegTable_rZMM1 :: DynFlags -> Int #

oFFSET_StgRegTable_rYMM6 :: DynFlags -> Int #

oFFSET_StgRegTable_rYMM5 :: DynFlags -> Int #

oFFSET_StgRegTable_rYMM4 :: DynFlags -> Int #

oFFSET_StgRegTable_rYMM3 :: DynFlags -> Int #

oFFSET_StgRegTable_rYMM2 :: DynFlags -> Int #

oFFSET_StgRegTable_rYMM1 :: DynFlags -> Int #

oFFSET_StgRegTable_rXMM6 :: DynFlags -> Int #

oFFSET_StgRegTable_rXMM5 :: DynFlags -> Int #

oFFSET_StgRegTable_rXMM4 :: DynFlags -> Int #

oFFSET_StgRegTable_rXMM3 :: DynFlags -> Int #

oFFSET_StgRegTable_rXMM2 :: DynFlags -> Int #

oFFSET_StgRegTable_rXMM1 :: DynFlags -> Int #

oFFSET_StgRegTable_rD6 :: DynFlags -> Int #

oFFSET_StgRegTable_rD5 :: DynFlags -> Int #

oFFSET_StgRegTable_rD4 :: DynFlags -> Int #

oFFSET_StgRegTable_rD3 :: DynFlags -> Int #

oFFSET_StgRegTable_rD2 :: DynFlags -> Int #

oFFSET_StgRegTable_rD1 :: DynFlags -> Int #

oFFSET_StgRegTable_rF6 :: DynFlags -> Int #

oFFSET_StgRegTable_rF5 :: DynFlags -> Int #

oFFSET_StgRegTable_rF4 :: DynFlags -> Int #

oFFSET_StgRegTable_rF3 :: DynFlags -> Int #

oFFSET_StgRegTable_rF2 :: DynFlags -> Int #

oFFSET_StgRegTable_rF1 :: DynFlags -> Int #

oFFSET_StgRegTable_rR10 :: DynFlags -> Int #

oFFSET_StgRegTable_rR9 :: DynFlags -> Int #

oFFSET_StgRegTable_rR8 :: DynFlags -> Int #

oFFSET_StgRegTable_rR7 :: DynFlags -> Int #

oFFSET_StgRegTable_rR6 :: DynFlags -> Int #

oFFSET_StgRegTable_rR5 :: DynFlags -> Int #

oFFSET_StgRegTable_rR4 :: DynFlags -> Int #

oFFSET_StgRegTable_rR3 :: DynFlags -> Int #

oFFSET_StgRegTable_rR2 :: DynFlags -> Int #

oFFSET_StgRegTable_rR1 :: DynFlags -> Int #

tICKY_BIN_COUNT :: DynFlags -> Int #

bLOCKS_PER_MBLOCK :: DynFlags -> Int #

bLOCK_SIZE :: DynFlags -> Int #

pROF_HDR_SIZE :: DynFlags -> Int #

sTD_HDR_SIZE :: DynFlags -> Int #

cONTROL_GROUP_CONST_291 :: DynFlags -> Int #

compilerInfo :: DynFlags -> [(String, String)] #

picPOpts :: DynFlags -> [String] #

picCCOpts :: DynFlags -> [String] #

setTmpDir :: FilePath -> DynFlags -> DynFlags #

setFlagsFromEnvFile :: FilePath -> String -> DynP () #

canonicalizeModuleIfHome :: DynFlags -> Module -> Module #

canonicalizeHomeModule :: DynFlags -> ModuleName -> Module #

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.

setUnitId :: String -> DynFlags -> DynFlags #

unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags #

setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags #

addWay' :: Way -> DynFlags -> DynFlags #

dynamicGhc :: Bool #

rtsIsProfiled :: Bool #

Was the runtime system built with profiling enabled?

glasgowExtsFlags :: [Extension] #

warningHierarchies :: [[String]] #

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.

warningGroups :: [(String, [WarningFlag])] #

Warning groups.

As all warnings are in the Weverything set, it is ignored when displaying to the user which group a warning is in.

xFlags :: [FlagSpec Extension] #

These -Xblah flags can all be reversed with -XNoblah

supportedLanguagesAndExtensions :: PlatformMini -> [String] #

fLangFlags :: [FlagSpec Extension] #

These -f<blah> flags can all be reversed with -fno-<blah>

fFlags :: [FlagSpec GeneralFlag] #

These -f<blah> flags can all be reversed with -fno-<blah>

wWarningFlags :: [FlagSpec WarningFlag] #

These -W<blah> flags can all be reversed with -Wno-<blah>

flagsForCompletion :: Bool -> [String] #

Make a list of flags for shell completion. Filter all available flags into two groups, for interactive GHC vs all other.

flagsPackage :: [Flag (CmdLineP DynFlags)] #

flagsDynamic :: [Flag (CmdLineP DynFlags)] #

flagsAll :: [Flag (CmdLineP DynFlags)] #

allNonDeprecatedFlags :: [String] #

All dynamic flags option strings without the deprecated ones. These are the user facing strings for enabling and disabling options.

updateWays :: DynFlags -> DynFlags #

putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO () #

Write an error or warning to the LogOutput.

parseDynamicFlagsFull #

Arguments

:: 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]) 

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.

parseDynamicFilePragma #

Arguments

:: MonadIO m 
=> DynFlags 
-> [Located String] 
-> m (DynFlags, [Located String], [Warn])

Updated DynFlags, left-over arguments, and list of warnings.

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.

parseDynamicFlagsCmdLine #

Arguments

:: MonadIO m 
=> DynFlags 
-> [Located String] 
-> m (DynFlags, [Located String], [Warn])

Updated DynFlags, left-over arguments, and list of warnings.

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).

updOptLevel :: Int -> DynFlags -> DynFlags #

Sets the DynFlags to be appropriate to the optimisation level

addPluginModuleName :: String -> DynFlags -> DynFlags #

thisPackage :: DynFlags -> UnitId #

thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)] #

thisComponentId :: DynFlags -> ComponentId #

getVerbFlags :: DynFlags -> [String] #

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

getOpts #

Arguments

:: DynFlags

DynFlags to retrieve the options from

-> (DynFlags -> [a])

Relevant record accessor: one of the opt_* accessors

-> [a]

Correctly ordered extracted options

Retrieve the options corresponding to a particular opt_* field in the correct order

unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)] #

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 :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)] #

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

safeImplicitImpsReq :: DynFlags -> Bool #

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.

safeDirectImpsReq :: DynFlags -> Bool #

Are all direct imports required to be safe for this Safe Haskell mode? Direct imports are when the code explicitly imports a module

safeImportsOn :: DynFlags -> Bool #

Test if Safe Imports are on in some form

safeInferOn :: DynFlags -> Bool #

Is the Safe Haskell safe inference mode active

safeLanguageOn :: DynFlags -> Bool #

Is the Safe Haskell safe language in use

safeHaskellModeEnabled :: DynFlags -> Bool #

safeHaskellOn :: DynFlags -> Bool #

Is Safe Haskell on in some way (including inference mode)

packageTrustOn :: DynFlags -> Bool #

Is the -fpackage-trust mode on

dynFlagDependencies :: DynFlags -> [ModuleName] #

Some modules have dependencies on others through the DynFlags rather than textual imports

lang_set :: DynFlags -> Maybe Language -> DynFlags #

xopt_set_unlessExplSpec :: Extension -> (DynFlags -> Extension -> DynFlags) -> DynFlags -> DynFlags #

Set or unset a Extension, unless it has been explicitly set or unset before.

xopt_unset :: DynFlags -> Extension -> DynFlags #

Unset a Extension

xopt_set :: DynFlags -> Extension -> DynFlags #

Set a Extension

xopt :: Extension -> DynFlags -> Bool #

Test whether a Extension is set

wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags #

Mark a WarningFlag as not fatal

wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags #

Mark a WarningFlag as fatal (do not set the flag)

wopt_fatal :: WarningFlag -> DynFlags -> Bool #

Test whether a WarningFlag is set as fatal

wopt_unset :: DynFlags -> WarningFlag -> DynFlags #

Unset a WarningFlag

wopt_set :: DynFlags -> WarningFlag -> DynFlags #

Set a WarningFlag

wopt :: WarningFlag -> DynFlags -> Bool #

Test whether a WarningFlag is set

gopt_unset :: DynFlags -> GeneralFlag -> DynFlags #

Unset a GeneralFlag

gopt_set :: DynFlags -> GeneralFlag -> DynFlags #

Set a GeneralFlag

gopt :: GeneralFlag -> DynFlags -> Bool #

Test whether a GeneralFlag is set

dopt_unset :: DynFlags -> DumpFlag -> DynFlags #

Unset a DumpFlag

dopt_set :: DynFlags -> DumpFlag -> DynFlags #

Set a DumpFlag

dopt :: DumpFlag -> DynFlags -> Bool #

Test whether a DumpFlag is set

hasNoOptCoercion :: DynFlags -> Bool #

hasNoStateHack :: DynFlags -> Bool #

languageExtensions :: Maybe Language -> [Extension] #

The language extensions implied by the various language variants. When updating this be sure to update the flag documentation in docsusers-guideglasgow_exts.rst.

defaultFlushErr :: FlushErr #

defaultFlushOut :: FlushOut #

defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO () #

defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO () #

Like defaultLogActionHPutStrDoc but appends an extra newline.

defaultLogAction :: LogAction #

defaultFatalMessager :: FatalMessager #

interpreterDynamic :: DynFlags -> Bool #

interpreterProfiled :: DynFlags -> Bool #

interpWays :: [Way] #

defaultWays :: Settings -> [Way] #

defaultDynFlags :: Settings -> LlvmConfig -> DynFlags #

The normal DynFlags. Note that they are not suitable for use in this form and must be fully initialized by runGhc first.

initDynFlags :: DynFlags -> IO DynFlags #

Used by runGhc to partially initialize a new DynFlags value

dynamicOutputFile :: DynFlags -> FilePath -> FilePath #

Compute the path of the dynamic object corresponding to an object file.

dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags #

whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m () #

ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a #

whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m () #

wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag] #

wayGeneralFlags :: Platform -> Way -> [GeneralFlag] #

wayRTSOnly :: Way -> Bool #

mkBuildTag :: [Way] -> String #

positionIndependent :: DynFlags -> Bool #

Are we building with -fPIE or -fPIC enabled?

defaultObjectTarget :: DynFlags -> HscTarget #

packageFlagsChanged :: DynFlags -> DynFlags -> Bool #

isNoLink :: GhcLink -> Bool #

isOneShot :: GhcMode -> Bool #

targetRetainsAllBindings :: HscTarget -> Bool #

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.

isObjectTarget :: HscTarget -> Bool #

Will this target result in an object file on the disk?

versionedFilePath :: DynFlags -> FilePath #

versionedAppDir :: DynFlags -> MaybeT IO FilePath #

The directory for this version of ghc in the user's app directory (typically something like ~.ghcx86_64-linux-7.6.3)

tablesNextToCode :: DynFlags -> Bool #

opt_i :: DynFlags -> [String] #

opt_lc :: DynFlags -> [String] #

opt_lo :: DynFlags -> [String] #

opt_lcc :: DynFlags -> [String] #

opt_windres :: DynFlags -> [String] #

opt_lm :: DynFlags -> [String] #

opt_l :: DynFlags -> [String] #

opt_a :: DynFlags -> [String] #

opt_cxx :: DynFlags -> [String] #

opt_c :: DynFlags -> [String] #

opt_F :: DynFlags -> [String] #

opt_P_signature :: DynFlags -> ([String], Fingerprint) #

opt_P :: DynFlags -> [String] #

opt_L :: DynFlags -> [String] #

pgm_i :: DynFlags -> String #

pgm_lc :: DynFlags -> (String, [Option]) #

pgm_lo :: DynFlags -> (String, [Option]) #

pgm_ranlib :: DynFlags -> String #

pgm_ar :: DynFlags -> String #

pgm_lcc :: DynFlags -> (String, [Option]) #

pgm_libtool :: DynFlags -> String #

pgm_windres :: DynFlags -> String #

pgm_T :: DynFlags -> String #

pgm_dll :: DynFlags -> (String, [Option]) #

pgm_lm :: DynFlags -> (String, [Option]) #

pgm_l :: DynFlags -> (String, [Option]) #

pgm_a :: DynFlags -> (String, [Option]) #

pgm_c :: DynFlags -> String #

pgm_F :: DynFlags -> String #

pgm_P :: DynFlags -> (String, [Option]) #

pgm_L :: DynFlags -> String #

systemPackageConfig :: DynFlags -> FilePath #

extraGccViaCFlags :: DynFlags -> [String] #

tmpDir :: DynFlags -> String #

topDir :: DynFlags -> FilePath #

ghciUsagePath :: DynFlags -> FilePath #

ghcUsagePath :: DynFlags -> FilePath #

projectVersion :: DynFlags -> String #

programName :: DynFlags -> String #

settings :: DynFlags -> Settings #

"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.

backendMaintainsCfg :: DynFlags -> Bool #

flattenIncludes :: IncludeSpecs -> [String] #

Concatenate and flatten the list of global and quoted includes returning just a flat list of paths.

addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs #

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"

addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs #

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.

optimisationFlags :: EnumSet GeneralFlag #

data WarnReason #

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.

Constructors

NoReason 
Reason !WarningFlag

Warning was enabled with the flag

ErrReason !(Maybe WarningFlag)

Warning was made an error because of -Werror or -Werror=WarningFlag

Instances

Instances details
Show WarnReason 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> WarnReason -> ShowS #

show :: WarnReason -> String #

showList :: [WarnReason] -> ShowS #

ToJson WarnReason 
Instance details

Defined in DynFlags

Methods

json :: WarnReason -> JsonDoc #

Outputable WarnReason 
Instance details

Defined in DynFlags

Methods

ppr :: WarnReason -> SDoc #

pprPrec :: Rational -> WarnReason -> SDoc #

data IncludeSpecs #

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.

Constructors

IncludeSpecs 

Fields

Instances

Instances details
Show IncludeSpecs 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> IncludeSpecs -> ShowS #

show :: IncludeSpecs -> String #

showList :: [IncludeSpecs] -> ShowS #

data WarningFlag #

Constructors

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 
Opt_WarnSemigroup 
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 
Opt_WarnNonCanonicalMonadFailInstances 
Opt_WarnNonCanonicalMonoidInstances 
Opt_WarnMissingPatternSynonymSignatures 
Opt_WarnUnrecognisedWarningFlags 
Opt_WarnSimplifiableClassConstraints 
Opt_WarnCPPUndef 
Opt_WarnUnbangedStrictPatterns 
Opt_WarnMissingHomeModules 
Opt_WarnPartialFields 
Opt_WarnMissingExportList 
Opt_WarnInaccessibleCode 
Opt_WarnStarIsType 
Opt_WarnStarBinder 
Opt_WarnImplicitKindVars 
Opt_WarnSpaceAfterBang 
Opt_WarnMissingDerivingStrategies 
Opt_WarnPrepositiveQualifiedModule 
Opt_WarnUnusedPackages 
Opt_WarnInferredSafeImports 
Opt_WarnMissingSafeHaskellMode 
Opt_WarnCompatUnqualifiedImports 
Opt_WarnDerivingDefaults 

Instances

Instances details
Enum WarningFlag 
Instance details

Defined in DynFlags

Methods

succ :: WarningFlag -> WarningFlag #

pred :: WarningFlag -> WarningFlag #

toEnum :: Int -> WarningFlag #

fromEnum :: WarningFlag -> Int #

enumFrom :: WarningFlag -> [WarningFlag] #

enumFromThen :: WarningFlag -> WarningFlag -> [WarningFlag] #

enumFromTo :: WarningFlag -> WarningFlag -> [WarningFlag] #

enumFromThenTo :: WarningFlag -> WarningFlag -> WarningFlag -> [WarningFlag] #

Eq WarningFlag 
Instance details

Defined in DynFlags

Methods

(==) :: WarningFlag -> WarningFlag -> Bool #

(/=) :: WarningFlag -> WarningFlag -> Bool #

Show WarningFlag 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> WarningFlag -> ShowS #

show :: WarningFlag -> String #

showList :: [WarningFlag] -> ShowS #

data Language #

Constructors

Haskell98 
Haskell2010 

Instances

Instances details
Enum Language 
Instance details

Defined in DynFlags

Methods

succ :: Language -> Language #

pred :: Language -> Language #

toEnum :: Int -> Language #

fromEnum :: Language -> Int #

enumFrom :: Language -> [Language] #

enumFromThen :: Language -> Language -> [Language] #

enumFromTo :: Language -> Language -> [Language] #

enumFromThenTo :: Language -> Language -> Language -> [Language] #

Eq Language 
Instance details

Defined in DynFlags

Methods

(==) :: Language -> Language -> Bool #

(/=) :: Language -> Language -> Bool #

Show Language 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> Language -> ShowS #

show :: Language -> String #

showList :: [Language] -> ShowS #

Outputable Language 
Instance details

Defined in DynFlags

Methods

ppr :: Language -> SDoc #

pprPrec :: Rational -> Language -> SDoc #

data SafeHaskellMode #

The various Safe Haskell modes

Constructors

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

Instances

Instances details
Eq SafeHaskellMode 
Instance details

Defined in DynFlags

Methods

(==) :: SafeHaskellMode -> SafeHaskellMode -> Bool #

(/=) :: SafeHaskellMode -> SafeHaskellMode -> Bool #

Show SafeHaskellMode 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> SafeHaskellMode -> ShowS #

show :: SafeHaskellMode -> String #

showList :: [SafeHaskellMode] -> ShowS #

NFData SafeHaskellMode Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: SafeHaskellMode -> () #

Outputable SafeHaskellMode 
Instance details

Defined in DynFlags

Methods

ppr :: SafeHaskellMode -> SDoc #

pprPrec :: Rational -> SafeHaskellMode -> SDoc #

data CfgWeights #

Edge weights to use when generating a CFG from CMM

Constructors

CFGWeights 

Fields

class HasDynFlags (m :: Type -> Type) where #

Methods

getDynFlags :: m DynFlags #

Instances

Instances details
HasDynFlags Ghc 
Instance details

Defined in GhcMonad

Methods

getDynFlags :: Ghc DynFlags #

HasDynFlags CompPipeline 
Instance details

Defined in PipelineMonad

Methods

getDynFlags :: CompPipeline DynFlags #

HasDynFlags Hsc 
Instance details

Defined in HscTypes

Methods

getDynFlags :: Hsc DynFlags #

HasDynFlags LlvmM 
Instance details

Defined in LlvmCodeGen.Base

Methods

getDynFlags :: LlvmM DynFlags #

HasDynFlags CoreM 
Instance details

Defined in CoreMonad

Methods

getDynFlags :: CoreM DynFlags #

(Monad m, HasDynFlags m) => HasDynFlags (MaybeT m) 
Instance details

Defined in DynFlags

Methods

getDynFlags :: MaybeT m DynFlags #

MonadIO m => HasDynFlags (GhcT m) 
Instance details

Defined in GhcMonad

Methods

getDynFlags :: GhcT m DynFlags #

ContainsDynFlags env => HasDynFlags (IOEnv env) 
Instance details

Defined in IOEnv

Methods

getDynFlags :: IOEnv env DynFlags #

(Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m) 
Instance details

Defined in DynFlags

Methods

getDynFlags :: WriterT a m DynFlags #

(Monad m, HasDynFlags m) => HasDynFlags (ReaderT a m) 
Instance details

Defined in DynFlags

Methods

getDynFlags :: ReaderT a m DynFlags #

(Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m) 
Instance details

Defined in DynFlags

Methods

getDynFlags :: ExceptT e m DynFlags #

class ContainsDynFlags t where #

Methods

extractDynFlags :: t -> DynFlags #

Instances

Instances details
ContainsDynFlags (Env gbl lcl) 
Instance details

Defined in TcRnTypes

Methods

extractDynFlags :: Env gbl lcl -> DynFlags #

data ProfAuto #

Constructors

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

Instances

Instances details
Enum ProfAuto 
Instance details

Defined in DynFlags

Methods

succ :: ProfAuto -> ProfAuto #

pred :: ProfAuto -> ProfAuto #

toEnum :: Int -> ProfAuto #

fromEnum :: ProfAuto -> Int #

enumFrom :: ProfAuto -> [ProfAuto] #

enumFromThen :: ProfAuto -> ProfAuto -> [ProfAuto] #

enumFromTo :: ProfAuto -> ProfAuto -> [ProfAuto] #

enumFromThenTo :: ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto] #

Eq ProfAuto 
Instance details

Defined in DynFlags

Methods

(==) :: ProfAuto -> ProfAuto -> Bool #

(/=) :: ProfAuto -> ProfAuto -> Bool #

data LlvmTarget #

Constructors

LlvmTarget 

Fields

data LlvmConfig #

See Note [LLVM Configuration] in SysTools.

Constructors

LlvmConfig 

Fields

data HscTarget #

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].

Constructors

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.

Instances

Instances details
Eq HscTarget 
Instance details

Defined in DynFlags

Methods

(==) :: HscTarget -> HscTarget -> Bool #

(/=) :: HscTarget -> HscTarget -> Bool #

Show HscTarget 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> HscTarget -> ShowS #

show :: HscTarget -> String #

showList :: [HscTarget] -> ShowS #

data GhcMode #

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.

Constructors

CompManager

--make, GHCi, etc.

OneShot
ghc -c Foo.hs
MkDepend

ghc -M, see Finder for why we need this

Instances

Instances details
Eq GhcMode 
Instance details

Defined in DynFlags

Methods

(==) :: GhcMode -> GhcMode -> Bool #

(/=) :: GhcMode -> GhcMode -> Bool #

Outputable GhcMode 
Instance details

Defined in DynFlags

Methods

ppr :: GhcMode -> SDoc #

pprPrec :: Rational -> GhcMode -> SDoc #

data GhcLink #

What to do in the link step, if there is one.

Constructors

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

Instances

data PackageArg #

We accept flags which make packages visible, but how they select the package varies; this data type reflects what selection criterion is used.

Constructors

PackageArg String

-package, by PackageName

UnitIdArg UnitId

-package-id, by UnitId

Instances

Instances details
Eq PackageArg 
Instance details

Defined in DynFlags

Methods

(==) :: PackageArg -> PackageArg -> Bool #

(/=) :: PackageArg -> PackageArg -> Bool #

Show PackageArg 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> PackageArg -> ShowS #

show :: PackageArg -> String #

showList :: [PackageArg] -> ShowS #

Outputable PackageArg 
Instance details

Defined in DynFlags

Methods

ppr :: PackageArg -> SDoc #

pprPrec :: Rational -> PackageArg -> SDoc #

data ModRenaming #

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)]

Constructors

ModRenaming 

Fields

Instances

Instances details
Eq ModRenaming 
Instance details

Defined in DynFlags

Methods

(==) :: ModRenaming -> ModRenaming -> Bool #

(/=) :: ModRenaming -> ModRenaming -> Bool #

Outputable ModRenaming 
Instance details

Defined in DynFlags

Methods

ppr :: ModRenaming -> SDoc #

pprPrec :: Rational -> ModRenaming -> SDoc #

newtype IgnorePackageFlag #

Flags for manipulating the set of non-broken packages.

Constructors

IgnorePackage String
-ignore-package

Instances

Instances details
Eq IgnorePackageFlag 
Instance details

Defined in DynFlags

Methods

(==) :: IgnorePackageFlag -> IgnorePackageFlag -> Bool #

(/=) :: IgnorePackageFlag -> IgnorePackageFlag -> Bool #

data TrustFlag #

Flags for manipulating package trust.

Constructors

TrustPackage String
-trust
DistrustPackage String
-distrust

Instances

Instances details
Eq TrustFlag 
Instance details

Defined in DynFlags

Methods

(==) :: TrustFlag -> TrustFlag -> Bool #

(/=) :: TrustFlag -> TrustFlag -> Bool #

data PackageFlag #

Flags for manipulating packages visibility.

Constructors

HidePackage String
-hide-package

Instances

Instances details
Eq PackageFlag 
Instance details

Defined in DynFlags

Methods

(==) :: PackageFlag -> PackageFlag -> Bool #

(/=) :: PackageFlag -> PackageFlag -> Bool #

Show PackageFlag Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> PackageFlag -> ShowS #

show :: PackageFlag -> String #

showList :: [PackageFlag] -> ShowS #

Outputable PackageFlag 
Instance details

Defined in DynFlags

Methods

ppr :: PackageFlag -> SDoc #

pprPrec :: Rational -> PackageFlag -> SDoc #

data PackageDBFlag #

Constructors

PackageDB PkgConfRef 
NoUserPackageDB 
NoGlobalPackageDB 
ClearPackageDBs 

Instances

Instances details
Eq PackageDBFlag 
Instance details

Defined in DynFlags

Methods

(==) :: PackageDBFlag -> PackageDBFlag -> Bool #

(/=) :: PackageDBFlag -> PackageDBFlag -> Bool #

data DynLibLoader #

Constructors

Deployable 
SystemDependent 

Instances

Instances details
Eq DynLibLoader 
Instance details

Defined in DynFlags

Methods

(==) :: DynLibLoader -> DynLibLoader -> Bool #

(/=) :: DynLibLoader -> DynLibLoader -> Bool #

data RtsOptsEnabled #

Constructors

RtsOptsNone 
RtsOptsIgnore 
RtsOptsIgnoreAll 
RtsOptsSafeOnly 
RtsOptsAll 

Instances

Instances details
Show RtsOptsEnabled 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> RtsOptsEnabled -> ShowS #

show :: RtsOptsEnabled -> String #

showList :: [RtsOptsEnabled] -> ShowS #

data Way #

Constructors

WayCustom String 
WayThreaded 
WayDebug 
WayProf 
WayEventLog 
WayDyn 

Instances

Instances details
Eq Way 
Instance details

Defined in DynFlags

Methods

(==) :: Way -> Way -> Bool #

(/=) :: Way -> Way -> Bool #

Ord Way 
Instance details

Defined in DynFlags

Methods

compare :: Way -> Way -> Ordering #

(<) :: Way -> Way -> Bool #

(<=) :: Way -> Way -> Bool #

(>) :: Way -> Way -> Bool #

(>=) :: Way -> Way -> Bool #

max :: Way -> Way -> Way #

min :: Way -> Way -> Way #

Show Way 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> Way -> ShowS #

show :: Way -> String #

showList :: [Way] -> ShowS #

type FatalMessager = String -> IO () #

type LogAction = DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO () #

newtype FlushOut #

Constructors

FlushOut (IO ()) 

newtype FlushErr #

Constructors

FlushErr (IO ()) 

data FlagSpec flag #

Constructors

FlagSpec 

Fields

data PkgConfRef #

Constructors

GlobalPkgConf 
UserPkgConf 
PkgConfFile FilePath 

Instances

Instances details
Eq PkgConfRef 
Instance details

Defined in DynFlags

Methods

(==) :: PkgConfRef -> PkgConfRef -> Bool #

(/=) :: PkgConfRef -> PkgConfRef -> Bool #

data LinkerInfo #

Constructors

GnuLD [Option] 
GnuGold [Option] 
LlvmLLD [Option] 
DarwinLD [Option] 
SolarisLD [Option] 
AixLD [Option] 
UnknownLD 

Instances

Instances details
Eq LinkerInfo 
Instance details

Defined in DynFlags

Methods

(==) :: LinkerInfo -> LinkerInfo -> Bool #

(/=) :: LinkerInfo -> LinkerInfo -> Bool #

data CompilerInfo #

Constructors

GCC 
Clang 
AppleClang 
AppleClang51 
UnknownCC 

Instances

Instances details
Eq CompilerInfo 
Instance details

Defined in DynFlags

Methods

(==) :: CompilerInfo -> CompilerInfo -> Bool #

(/=) :: CompilerInfo -> CompilerInfo -> Bool #

data FilesToClean #

A collection of files that must be deleted before ghc exits. The current collection is stored in an IORef in DynFlags, filesToClean.

Constructors

FilesToClean 

Fields

sGhcRtsWithLibdw :: Settings -> Bool #

sGhcDebugged :: Settings -> Bool #

sGhcThreaded :: Settings -> Bool #

sLibFFI :: Settings -> Bool #

sLeadingUnderscore :: Settings -> Bool #

sTablesNextToCode :: Settings -> Bool #

sGhcRTSWays :: Settings -> String #

sGhcWithSMP :: Settings -> Bool #

sGhcWithNativeCodeGen :: Settings -> Bool #

sGhcWithInterpreter :: Settings -> Bool #

sIntegerLibraryType :: Settings -> IntegerLibrary #

sIntegerLibrary :: Settings -> String #

sTargetPlatformString :: Settings -> String #

sExtraGccViaCFlags :: Settings -> [String] #

sOpt_i :: Settings -> [String] #

sOpt_lcc :: Settings -> [String] #

sOpt_lc :: Settings -> [String] #

sOpt_lo :: Settings -> [String] #

sOpt_windres :: Settings -> [String] #

sOpt_lm :: Settings -> [String] #

sOpt_l :: Settings -> [String] #

sOpt_a :: Settings -> [String] #

sOpt_cxx :: Settings -> [String] #

sOpt_c :: Settings -> [String] #

sOpt_F :: Settings -> [String] #

sOpt_P_fingerprint :: Settings -> Fingerprint #

sOpt_P :: Settings -> [String] #

sOpt_L :: Settings -> [String] #

sPgm_i :: Settings -> String #

sPgm_lcc :: Settings -> (String, [Option]) #

sPgm_lc :: Settings -> (String, [Option]) #

sPgm_lo :: Settings -> (String, [Option]) #

sPgm_ranlib :: Settings -> String #

sPgm_ar :: Settings -> String #

sPgm_libtool :: Settings -> String #

sPgm_windres :: Settings -> String #

sPgm_T :: Settings -> String #

sPgm_dll :: Settings -> (String, [Option]) #

sPgm_lm :: Settings -> (String, [Option]) #

sPgm_l :: Settings -> (String, [Option]) #

sPgm_a :: Settings -> (String, [Option]) #

sPgm_c :: Settings -> String #

sPgm_F :: Settings -> String #

sPgm_P :: Settings -> (String, [Option]) #

sPgm_L :: Settings -> String #

sGccSupportsNoPie :: Settings -> Bool #

sLdIsGnuLd :: Settings -> Bool #

sLdSupportsFilelist :: Settings -> Bool #

sLdSupportsBuildId :: Settings -> Bool #

sLdSupportsCompactUnwind :: Settings -> Bool #

sSystemPackageConfig :: Settings -> FilePath #

sTmpDir :: Settings -> String #

sTopDir :: Settings -> FilePath #

sToolDir :: Settings -> Maybe FilePath #

sGhciUsagePath :: Settings -> FilePath #

sGhcUsagePath :: Settings -> FilePath #

sProjectVersion :: Settings -> String #

sProgramName :: Settings -> String #

data Settings #

Constructors

Settings 

Fields

data PlatformConstants #

Constructors

PlatformConstants 

Fields

Instances

Instances details
Read PlatformConstants 
Instance details

Defined in PlatformConstants

Methods

readsPrec :: Int -> ReadS PlatformConstants #

readList :: ReadS [PlatformConstants] #

readPrec :: ReadPrec PlatformConstants #

readListPrec :: ReadPrec [PlatformConstants] #

showOpt :: Option -> String #

data Option #

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.

Constructors

FileOption String String 
Option String 

Instances

Instances details
Eq Option 
Instance details

Defined in CliOption

Methods

(==) :: Option -> Option -> Bool #

(/=) :: Option -> Option -> Bool #

unsafeGlobalDynFlags :: DynFlags #

useUnicodeSyntax :: DynFlags -> Bool #

An internal helper to check whether to use unicode syntax for output.

Note: You should very likely be using unicodeSyntax instead of this function.

useStarIsType :: DynFlags -> Bool #

shouldUseColor :: DynFlags -> Bool #

shouldUseHexWordLiterals :: DynFlags -> Bool #

hasPprDebug :: DynFlags -> Bool #

hasNoDebugOutput :: DynFlags -> Bool #

data DynFlags #

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

Constructors

DynFlags 

Fields

data DumpFlag #

Constructors

Opt_D_dump_cmm 
Opt_D_dump_cmm_from_stg 
Opt_D_dump_cmm_raw 
Opt_D_dump_cmm_verbose_by_proc 
Opt_D_dump_cmm_verbose 
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 
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 
Opt_D_dump_stg_unarised 
Opt_D_dump_stg_final 
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 
Opt_D_dump_tc_trace 
Opt_D_dump_ec_trace 
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 

Instances

Instances details
Enum DumpFlag 
Instance details

Defined in DynFlags

Methods

succ :: DumpFlag -> DumpFlag #

pred :: DumpFlag -> DumpFlag #

toEnum :: Int -> DumpFlag #

fromEnum :: DumpFlag -> Int #

enumFrom :: DumpFlag -> [DumpFlag] #

enumFromThen :: DumpFlag -> DumpFlag -> [DumpFlag] #

enumFromTo :: DumpFlag -> DumpFlag -> [DumpFlag] #

enumFromThenTo :: DumpFlag -> DumpFlag -> DumpFlag -> [DumpFlag] #

Eq DumpFlag 
Instance details

Defined in DynFlags

Methods

(==) :: DumpFlag -> DumpFlag -> Bool #

(/=) :: DumpFlag -> DumpFlag -> Bool #

Show DumpFlag 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> DumpFlag -> ShowS #

show :: DumpFlag -> String #

showList :: [DumpFlag] -> ShowS #

data GeneralFlag #

Enumerates the simple on-or-off dynamic flags

Constructors

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 
Opt_FastLlvm 
Opt_NoTypeableBinds 
Opt_WarnIsError 
Opt_ShowWarnGroups 
Opt_HideSourcePaths 
Opt_PrintExplicitForalls 
Opt_PrintExplicitKinds 
Opt_PrintExplicitCoercions 
Opt_PrintExplicitRuntimeReps 
Opt_PrintEqualityRelations 
Opt_PrintAxiomIncomps 
Opt_PrintUnicodeSyntax 
Opt_PrintExpandedSynonyms 
Opt_PrintPotentialInstances 
Opt_PrintTypecheckerElaboration 
Opt_CallArity 
Opt_Exitification 
Opt_Strictness 
Opt_LateDmdAnal 
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 
Opt_UnboxStrictFields 
Opt_UnboxSmallStrictFields 
Opt_DictsCheap 
Opt_EnableRewriteRules 
Opt_EnableThSpliceWarnings 
Opt_RegsGraph 
Opt_RegsIterative 
Opt_PedanticBottoms 
Opt_LlvmTBAA 
Opt_LlvmFillUndefWithGarbage 
Opt_IrrefutableTuples 
Opt_CmmSink 
Opt_CmmElimCommonBlocks 
Opt_AsmShortcutting 
Opt_OmitYields 
Opt_FunToThunk 
Opt_DictsStrict 
Opt_DmdTxDictSel 
Opt_Loopification 
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 
Opt_SimplPreInlining 
Opt_IgnoreInterfacePragmas 
Opt_OmitInterfacePragmas 
Opt_ExposeAllUnfoldings 
Opt_WriteInterface 
Opt_WriteHie 
Opt_AutoSccsOnIndividualCafs 
Opt_ProfCountEntries 
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 
Opt_SingleLibFolder 
Opt_KeepCAFs 
Opt_KeepGoing 
Opt_ByteCode 
Opt_ErrorSpans 
Opt_DeferDiagnostics 
Opt_DiagnosticsShowCaret 
Opt_PprCaseAsLet 
Opt_PprShowTicks 
Opt_ShowHoleConstraints 
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 
Opt_SuppressCoercions 
Opt_SuppressVarKinds 
Opt_SuppressModulePrefixes 
Opt_SuppressTypeApplications 
Opt_SuppressIdInfo 
Opt_SuppressUnfoldings 
Opt_SuppressTypeSignatures 
Opt_SuppressUniques 
Opt_SuppressStgExts 
Opt_SuppressTicks 
Opt_SuppressTimestamps

Suppress timestamps in dumps

Opt_AutoLinkPackages 
Opt_ImplicitImportQualified 
Opt_KeepHscppFiles 
Opt_KeepHiDiffs 
Opt_KeepHcFiles 
Opt_KeepSFiles 
Opt_KeepTmpFiles 
Opt_KeepRawTokenStream 
Opt_KeepLlvmFiles 
Opt_KeepHiFiles 
Opt_KeepOFiles 
Opt_BuildDynamicToo 
Opt_DistrustAllPackages 
Opt_PackageTrust 
Opt_PluginTrustworthy 
Opt_G_NoStateHack 
Opt_G_NoOptCoercion 

Instances

Instances details
Enum GeneralFlag 
Instance details

Defined in DynFlags

Methods

succ :: GeneralFlag -> GeneralFlag #

pred :: GeneralFlag -> GeneralFlag #

toEnum :: Int -> GeneralFlag #

fromEnum :: GeneralFlag -> Int #

enumFrom :: GeneralFlag -> [GeneralFlag] #

enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag] #

enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag] #

enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag] #

Eq GeneralFlag 
Instance details

Defined in DynFlags

Methods

(==) :: GeneralFlag -> GeneralFlag -> Bool #

(/=) :: GeneralFlag -> GeneralFlag -> Bool #

Show GeneralFlag 
Instance details

Defined in DynFlags

Methods

showsPrec :: Int -> GeneralFlag -> ShowS #

show :: GeneralFlag -> String #

showList :: [GeneralFlag] -> ShowS #

data FileSettings #

Paths to various files and directories used by GHC, including those that provide more settings.

Constructors

FileSettings 

Fields

data GhcNameVersion #

Settings for what GHC this is.

Constructors

GhcNameVersion 

Fields

data IntegerLibrary #

Constructors

IntegerGMP 
IntegerSimple 

Instances

Instances details
Eq IntegerLibrary 
Instance details

Defined in GHC.Platform

Methods

(==) :: IntegerLibrary -> IntegerLibrary -> Bool #

(/=) :: IntegerLibrary -> IntegerLibrary -> Bool #

Read IntegerLibrary 
Instance details

Defined in GHC.Platform

Methods

readsPrec :: Int -> ReadS IntegerLibrary #

readList :: ReadS [IntegerLibrary] #

readPrec :: ReadPrec IntegerLibrary #

readListPrec :: ReadPrec [IntegerLibrary] #

Show IntegerLibrary 
Instance details

Defined in GHC.Platform

Methods

showsPrec :: Int -> IntegerLibrary -> ShowS #

show :: IntegerLibrary -> String #

showList :: [IntegerLibrary] -> ShowS #

data PlatformMisc #

Platform-specific settings formerly hard-coded in Config.hs.

These should probably be all be triaged whether they can be computed from other settings or belong in another another place (like Platform above).

Constructors

PlatformMisc 

Fields

initializePlugins :: HscEnv -> DynFlags -> IO DynFlags #

Loads the plugins specified in the pluginModNames field of the dynamic flags. Should be called after command line arguments are parsed, but before actual compilation starts. Idempotent operation. Should be re-called if pluginModNames or pluginModNameOpts changes.

applyPluginsParsedResultAction :: HscEnv -> DynFlags -> ModSummary -> ApiAnns -> ParsedSource -> IO ParsedSource Source #

module Compat.HieTypes

module Compat.HieUtils