ghc-8.2.2: The GHC API

Safe Haskell | None
Language | Haskell2010

GHC

Contents

- Initialisation
- GHC Monad
- Flags and settings
- Targets
- Loading/compiling the program
  - Compiling to Core
- Inspecting the module structure of the program
- Inspecting modules
- Querying the environment
- Printing
- Interactive evaluation
  - Executing statements
  - Adding new declarations
  - Get/set the current context
  - Inspecting the current context
  - Inspecting types and kinds
  - Looking up a Name
  - Compiling expressions
  - Other
  - The debugger
- Abstract syntax elements
  - Packages
  - Modules
  - Names
  - Identifiers
  - Type constructors
  - Type variables
  - Data constructors
  - Classes
  - Instances
  - Types and Kinds
  - Entities
  - Syntax
  - Fixities
  - Source locations
  - Located
    - Constructing Located
    - Deconstructing Located
    - Combining and comparing Located values
- Exceptions
- Token stream manipulations
- Pure interface to the parser
- API Annotations
- Miscellaneous

Synopsis

- defaultErrorHandler :: ExceptionMonad m => FatalMessager -> FlushOut -> m a -> m a
- defaultCleanupHandler :: ExceptionMonad m => DynFlags -> m a -> m a
- prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a
- withSignalHandlers :: (ExceptionMonad m, MonadIO m) => m a -> m a
- withCleanupSession :: GhcMonad m => m a -> m a
- data Ghc a
- data GhcT m a
- class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m where
- data HscEnv
- runGhc :: Maybe FilePath -> Ghc a -> IO a
- runGhcT :: ExceptionMonad m => Maybe FilePath -> GhcT m a -> m a
- initGhcMonad :: GhcMonad m => Maybe FilePath -> m ()
- gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a
- gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c
- gfinally :: ExceptionMonad m => m a -> m b -> m a
- printException :: GhcMonad m => SourceError -> m ()
- handleSourceError :: ExceptionMonad m => (SourceError -> m a) -> m a -> m a
- needsTemplateHaskell :: ModuleGraph -> Bool
- data DynFlags = DynFlags {
  - ghcMode :: GhcMode
  - ghcLink :: GhcLink
  - hscTarget :: HscTarget
  - settings :: Settings
  - verbosity :: Int
  - optLevel :: Int
  - debugLevel :: Int
  - simplPhases :: Int
  - maxSimplIterations :: Int
  - maxPmCheckIterations :: Int
  - ruleCheck :: Maybe String
  - strictnessBefore :: [Int]
  - parMakeCount :: Maybe Int
  - enableTimeStats :: Bool
  - ghcHeapSize :: Maybe Int
  - maxRelevantBinds :: Maybe Int
  - maxUncoveredPatterns :: Int
  - simplTickFactor :: Int
  - specConstrThreshold :: Maybe Int
  - specConstrCount :: Maybe Int
  - specConstrRecursive :: Int
  - liberateCaseThreshold :: Maybe Int
  - floatLamArgs :: Maybe Int
  - historySize :: Int
  - importPaths :: [FilePath]
  - mainModIs :: Module
  - mainFunIs :: Maybe String
  - reductionDepth :: IntWithInf
  - solverIterations :: IntWithInf
  - thisInstalledUnitId :: InstalledUnitId
  - thisComponentId_ :: Maybe ComponentId
  - thisUnitIdInsts_ :: Maybe [(ModuleName, Module)]
  - ways :: [Way]
  - buildTag :: String
  - rtsBuildTag :: String
  - splitInfo :: Maybe (String, Int)
  - objectDir :: Maybe String
  - dylibInstallName :: Maybe String
  - hiDir :: Maybe String
  - stubDir :: Maybe String
  - dumpDir :: Maybe String
  - objectSuf :: String
  - hcSuf :: String
  - hiSuf :: String
  - canGenerateDynamicToo :: IORef Bool
  - dynObjectSuf :: String
  - dynHiSuf :: String
  - dllSplitFile :: Maybe FilePath
  - dllSplit :: Maybe [Set String]
  - outputFile :: Maybe String
  - dynOutputFile :: Maybe String
  - outputHi :: Maybe String
  - dynLibLoader :: DynLibLoader
  - dumpPrefix :: Maybe FilePath
  - dumpPrefixForce :: Maybe FilePath
  - ldInputs :: [Option]
  - includePaths :: [String]
  - libraryPaths :: [String]
  - frameworkPaths :: [String]
  - cmdlineFrameworks :: [String]
  - rtsOpts :: Maybe String
  - rtsOptsEnabled :: RtsOptsEnabled
  - rtsOptsSuggestions :: Bool
  - hpcDir :: String
  - pluginModNames :: [ModuleName]
  - pluginModNameOpts :: [(ModuleName, String)]
  - frontendPluginOpts :: [String]
  - hooks :: Hooks
  - depMakefile :: FilePath
  - depIncludePkgDeps :: Bool
  - depExcludeMods :: [ModuleName]
  - depSuffixes :: [String]
  - packageDBFlags :: [PackageDBFlag]
  - ignorePackageFlags :: [IgnorePackageFlag]
  - packageFlags :: [PackageFlag]
  - pluginPackageFlags :: [PackageFlag]
  - trustFlags :: [TrustFlag]
  - packageEnv :: Maybe FilePath
  - pkgDatabase :: Maybe [(FilePath, [PackageConfig])]
  - pkgState :: PackageState
  - filesToClean :: IORef [FilePath]
  - dirsToClean :: IORef (Map FilePath FilePath)
  - filesToNotIntermediateClean :: IORef [FilePath]
  - nextTempSuffix :: IORef Int
  - generatedDumps :: IORef (Set FilePath)
  - dumpFlags :: IntSet
  - generalFlags :: IntSet
  - warningFlags :: IntSet
  - fatalWarningFlags :: IntSet
  - language :: Maybe Language
  - safeHaskell :: SafeHaskellMode
  - safeInfer :: Bool
  - safeInferred :: Bool
  - thOnLoc :: SrcSpan
  - newDerivOnLoc :: SrcSpan
  - overlapInstLoc :: SrcSpan
  - incoherentOnLoc :: SrcSpan
  - pkgTrustOnLoc :: SrcSpan
  - warnSafeOnLoc :: SrcSpan
  - warnUnsafeOnLoc :: SrcSpan
  - trustworthyOnLoc :: SrcSpan
  - extensions :: [OnOff Extension]
  - extensionFlags :: IntSet
  - ufCreationThreshold :: Int
  - ufUseThreshold :: Int
  - ufFunAppDiscount :: Int
  - ufDictDiscount :: Int
  - ufKeenessFactor :: Float
  - ufDearOp :: Int
  - ufVeryAggressive :: Bool
  - maxWorkerArgs :: Int
  - ghciHistSize :: Int
  - initLogAction :: IO (Maybe LogOutput)
  - log_action :: LogAction
  - log_finaliser :: LogFinaliser
  - flushOut :: FlushOut
  - flushErr :: FlushErr
  - haddockOptions :: Maybe String
  - ghciScripts :: [String]
  - pprUserLength :: Int
  - pprCols :: Int
  - useUnicode :: Bool
  - useColor :: OverridingBool
  - canUseColor :: Bool
  - colScheme :: Scheme
  - profAuto :: ProfAuto
  - interactivePrint :: Maybe String
  - nextWrapperNum :: IORef (ModuleEnv Int)
  - sseVersion :: Maybe SseVersion
  - avx :: Bool
  - avx2 :: Bool
  - avx512cd :: Bool
  - avx512er :: Bool
  - avx512f :: Bool
  - avx512pf :: Bool
  - rtldInfo :: IORef (Maybe LinkerInfo)
  - rtccInfo :: IORef (Maybe CompilerInfo)
  - maxInlineAllocSize :: Int
  - maxInlineMemcpyInsns :: Int
  - maxInlineMemsetInsns :: Int
  - reverseErrors :: Bool
  - maxErrors :: Maybe Int
  - initialUnique :: Int
  - uniqueIncrement :: Int
  }
- data GeneralFlag
  - = Opt_DumpToFile
  - | Opt_D_faststring_stats
  - | Opt_D_dump_minimal_imports
  - | Opt_DoCoreLinting
  - | Opt_DoStgLinting
  - | Opt_DoCmmLinting
  - | Opt_DoAsmLinting
  - | Opt_DoAnnotationLinting
  - | Opt_NoLlvmMangler
  - | Opt_WarnIsError
  - | Opt_ShowWarnGroups
  - | Opt_HideSourcePaths
  - | Opt_PrintExplicitForalls
  - | Opt_PrintExplicitKinds
  - | Opt_PrintExplicitCoercions
  - | Opt_PrintExplicitRuntimeReps
  - | Opt_PrintEqualityRelations
  - | Opt_PrintUnicodeSyntax
  - | Opt_PrintExpandedSynonyms
  - | Opt_PrintPotentialInstances
  - | Opt_PrintTypecheckerElaboration
  - | Opt_CallArity
  - | Opt_Strictness
  - | Opt_LateDmdAnal
  - | Opt_KillAbsence
  - | Opt_KillOneShot
  - | Opt_FullLaziness
  - | Opt_FloatIn
  - | Opt_Specialise
  - | Opt_SpecialiseAggressively
  - | Opt_CrossModuleSpecialise
  - | Opt_StaticArgumentTransformation
  - | Opt_CSE
  - | Opt_StgCSE
  - | 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_Vectorise
  - | Opt_VectorisationAvoidance
  - | Opt_RegsGraph
  - | Opt_RegsIterative
  - | Opt_PedanticBottoms
  - | Opt_LlvmTBAA
  - | Opt_LlvmPassVectorsInRegisters
  - | Opt_LlvmFillUndefWithGarbage
  - | Opt_IrrefutableTuples
  - | Opt_CmmSink
  - | Opt_CmmElimCommonBlocks
  - | Opt_OmitYields
  - | Opt_FunToThunk
  - | Opt_DictsStrict
  - | Opt_DmdTxDictSel
  - | Opt_Loopification
  - | Opt_CprAnal
  - | Opt_WorkerWrapper
  - | Opt_SolveConstantDicts
  - | Opt_IgnoreInterfacePragmas
  - | Opt_OmitInterfacePragmas
  - | Opt_ExposeAllUnfoldings
  - | Opt_WriteInterface
  - | Opt_AutoSccsOnIndividualCafs
  - | Opt_ProfCountEntries
  - | Opt_Pp
  - | Opt_ForceRecomp
  - | Opt_ExcessPrecision
  - | Opt_EagerBlackHoling
  - | Opt_NoHsMain
  - | Opt_SplitObjs
  - | 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_LocalGhciHistory
  - | Opt_HelpfulErrors
  - | Opt_DeferTypeErrors
  - | Opt_DeferTypedHoles
  - | Opt_DeferOutOfScopeVariables
  - | Opt_PIC
  - | Opt_PIE
  - | Opt_PICExecutable
  - | 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_SimplPreInlining
  - | Opt_ErrorSpans
  - | Opt_DiagnosticsShowCaret
  - | Opt_PprCaseAsLet
  - | Opt_PprShowTicks
  - | Opt_ShowHoleConstraints
  - | Opt_ShowLoadedModules
  - | Opt_SuppressCoercions
  - | Opt_SuppressVarKinds
  - | Opt_SuppressModulePrefixes
  - | Opt_SuppressTypeApplications
  - | Opt_SuppressIdInfo
  - | Opt_SuppressUnfoldings
  - | Opt_SuppressTypeSignatures
  - | Opt_SuppressUniques
  - | Opt_SuppressTicks
  - | Opt_AutoLinkPackages
  - | Opt_ImplicitImportQualified
  - | Opt_KeepHiDiffs
  - | Opt_KeepHcFiles
  - | Opt_KeepSFiles
  - | Opt_KeepTmpFiles
  - | Opt_KeepRawTokenStream
  - | Opt_KeepLlvmFiles
  - | Opt_KeepHiFiles
  - | Opt_KeepOFiles
  - | Opt_BuildDynamicToo
  - | Opt_DistrustAllPackages
  - | Opt_PackageTrust
  - | Opt_G_NoStateHack
  - | Opt_G_NoOptCoercion
- data Severity
  - = SevOutput
  - | SevFatal
  - | SevInteractive
  - | SevDump
  - | SevInfo
  - | SevWarning
  - | SevError
- data HscTarget
  - = HscC
  - | HscAsm
  - | HscLlvm
  - | HscInterpreted
  - | HscNothing
- gopt :: GeneralFlag -> DynFlags -> Bool
- data GhcMode
  - = CompManager
  - | OneShot
  - | MkDepend
- data GhcLink
  - = NoLink
  - | LinkBinary
  - | LinkInMemory
  - | LinkDynLib
  - | LinkStaticLib
- defaultObjectTarget :: Platform -> HscTarget
- parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])
- getSessionDynFlags :: GhcMonad m => m DynFlags
- setSessionDynFlags :: GhcMonad m => DynFlags -> m [InstalledUnitId]
- getProgramDynFlags :: GhcMonad m => m DynFlags
- setProgramDynFlags :: GhcMonad m => DynFlags -> m [InstalledUnitId]
- setLogAction :: GhcMonad m => LogAction -> LogFinaliser -> m ()
- getInteractiveDynFlags :: GhcMonad m => m DynFlags
- setInteractiveDynFlags :: GhcMonad m => DynFlags -> m ()
- data Target = Target {
  - targetId :: TargetId
  - targetAllowObjCode :: Bool
  - targetContents :: Maybe (StringBuffer, UTCTime)
  }
- data TargetId
  - = TargetModule ModuleName
  - | TargetFile FilePath (Maybe Phase)
- data Phase
- setTargets :: GhcMonad m => [Target] -> m ()
- getTargets :: GhcMonad m => m [Target]
- addTarget :: GhcMonad m => Target -> m ()
- removeTarget :: GhcMonad m => TargetId -> m ()
- guessTarget :: GhcMonad m => String -> Maybe Phase -> m Target
- depanal :: GhcMonad m => [ModuleName] -> Bool -> m ModuleGraph
- load :: GhcMonad m => LoadHowMuch -> m SuccessFlag
- data LoadHowMuch
  - = LoadAllTargets
  - | LoadUpTo ModuleName
  - | LoadDependenciesOf ModuleName
- data InteractiveImport
  - = IIDecl (ImportDecl RdrName)
  - | IIModule ModuleName
- data SuccessFlag
  - = Succeeded
  - | Failed
- succeeded :: SuccessFlag -> Bool
- failed :: SuccessFlag -> Bool
- defaultWarnErrLogger :: WarnErrLogger
- type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> m ()
- workingDirectoryChanged :: GhcMonad m => m ()
- parseModule :: GhcMonad m => ModSummary -> m ParsedModule
- typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule
- desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule
- loadModule :: (TypecheckedMod mod, GhcMonad m) => mod -> m mod
- data ParsedModule = ParsedModule {
  - pm_mod_summary :: ModSummary
  - pm_parsed_source :: ParsedSource
  - pm_extra_src_files :: [FilePath]
  - pm_annotations :: ApiAnns
  }
- data TypecheckedModule = TypecheckedModule {
  - tm_parsed_module :: ParsedModule
  - tm_renamed_source :: Maybe RenamedSource
  - tm_typechecked_source :: TypecheckedSource
  - tm_checked_module_info :: ModuleInfo
  - tm_internals_ :: (TcGblEnv, ModDetails)
  }
- data DesugaredModule = DesugaredModule {
  - dm_typechecked_module :: TypecheckedModule
  - dm_core_module :: ModGuts
  }
- type TypecheckedSource = LHsBinds Id
- type ParsedSource = Located (HsModule RdrName)
- type RenamedSource = (HsGroup Name, [LImportDecl Name], Maybe [LIE Name], Maybe LHsDocString)
- class ParsedMod m => TypecheckedMod m where
- class ParsedMod m where
- moduleInfo :: TypecheckedMod m => m -> ModuleInfo
- renamedSource :: TypecheckedMod m => m -> Maybe RenamedSource
- typecheckedSource :: TypecheckedMod m => m -> TypecheckedSource
- parsedSource :: ParsedMod m => m -> ParsedSource
- coreModule :: DesugaredMod m => m -> ModGuts
- data CoreModule = CoreModule {
  - cm_module :: !Module
  - cm_types :: !TypeEnv
  - cm_binds :: CoreProgram
  - cm_safe :: SafeHaskellMode
  }
- compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule
- compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule
- type ModuleGraph = [ModSummary]
- data ModSummary = ModSummary {
  - ms_mod :: Module
  - ms_hsc_src :: HscSource
  - ms_location :: ModLocation
  - ms_hs_date :: UTCTime
  - ms_obj_date :: Maybe UTCTime
  - ms_iface_date :: Maybe UTCTime
  - ms_srcimps :: [(Maybe FastString, Located ModuleName)]
  - ms_textual_imps :: [(Maybe FastString, Located ModuleName)]
  - ms_parsed_mod :: Maybe HsParsedModule
  - ms_hspp_file :: FilePath
  - ms_hspp_opts :: DynFlags
  - ms_hspp_buf :: Maybe StringBuffer
  }
- ms_mod_name :: ModSummary -> ModuleName
- data ModLocation = ModLocation {
  - ml_hs_file :: Maybe FilePath
  - ml_hi_file :: FilePath
  - ml_obj_file :: FilePath
  }
- getModSummary :: GhcMonad m => ModuleName -> m ModSummary
- getModuleGraph :: GhcMonad m => m ModuleGraph
- isLoaded :: GhcMonad m => ModuleName -> m Bool
- topSortModuleGraph :: Bool -> [ModSummary] -> Maybe ModuleName -> [SCC ModSummary]
- data ModuleInfo
- getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo)
- modInfoTyThings :: ModuleInfo -> [TyThing]
- modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]
- modInfoExports :: ModuleInfo -> [Name]
- modInfoExportsWithSelectors :: ModuleInfo -> [Name]
- modInfoInstances :: ModuleInfo -> [ClsInst]
- modInfoIsExportedName :: ModuleInfo -> Name -> Bool
- modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing)
- modInfoIface :: ModuleInfo -> Maybe ModIface
- modInfoSafe :: ModuleInfo -> SafeHaskellMode
- lookupGlobalName :: GhcMonad m => Name -> m (Maybe TyThing)
- findGlobalAnns :: (GhcMonad m, Typeable a) => ([Word8] -> a) -> AnnTarget Name -> m [a]
- mkPrintUnqualifiedForModule :: GhcMonad m => ModuleInfo -> m (Maybe PrintUnqualified)
- data ModIface = ModIface {
  - mi_module :: !Module
  - mi_sig_of :: !(Maybe Module)
  - mi_iface_hash :: !Fingerprint
  - mi_mod_hash :: !Fingerprint
  - mi_flag_hash :: !Fingerprint
  - mi_orphan :: !WhetherHasOrphans
  - mi_finsts :: !WhetherHasFamInst
  - mi_hsc_src :: !HscSource
  - mi_deps :: Dependencies
  - mi_usages :: [Usage]
  - mi_exports :: ![IfaceExport]
  - mi_exp_hash :: !Fingerprint
  - mi_used_th :: !Bool
  - mi_fixities :: [(OccName, Fixity)]
  - mi_warns :: Warnings
  - mi_anns :: [IfaceAnnotation]
  - mi_decls :: [(Fingerprint, IfaceDecl)]
  - mi_globals :: !(Maybe GlobalRdrEnv)
  - mi_insts :: [IfaceClsInst]
  - mi_fam_insts :: [IfaceFamInst]
  - mi_rules :: [IfaceRule]
  - mi_orphan_hash :: !Fingerprint
  - mi_vect_info :: !IfaceVectInfo
  - mi_warn_fn :: OccName -> Maybe WarningTxt
  - mi_fix_fn :: OccName -> Maybe Fixity
  - mi_hash_fn :: OccName -> Maybe (OccName, Fingerprint)
  - mi_hpc :: !AnyHpcUsage
  - mi_trust :: !IfaceTrustInfo
  - mi_trust_pkg :: !Bool
  - mi_complete_sigs :: [IfaceCompleteMatch]
  }
- data SafeHaskellMode
  - = Sf_None
  - | Sf_Unsafe
  - | Sf_Trustworthy
  - | Sf_Safe
- data PrintUnqualified
- alwaysQualify :: PrintUnqualified
- execStmt :: GhcMonad m => String -> ExecOptions -> m ExecResult
- data ExecOptions = ExecOptions {
  - execSingleStep :: SingleStep
  - execSourceFile :: String
  - execLineNumber :: Int
  - execWrap :: ForeignHValue -> EvalExpr ForeignHValue
  }
- execOptions :: ExecOptions
- data ExecResult
  - = ExecComplete {
    - execResult :: Either SomeException [Name]
    - execAllocation :: Word64
    }
  - | ExecBreak {
    - breakNames :: [Name]
    - breakInfo :: Maybe BreakInfo
    }
- resumeExec :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> m ExecResult
- runDecls :: GhcMonad m => String -> m [Name]
- runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name]
- parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
- setContext :: GhcMonad m => [InteractiveImport] -> m ()
- getContext :: GhcMonad m => m [InteractiveImport]
- setGHCiMonad :: GhcMonad m => String -> m ()
- getGHCiMonad :: GhcMonad m => m Name
- getBindings :: GhcMonad m => m [TyThing]
- getInsts :: GhcMonad m => m ([ClsInst], [FamInst])
- getPrintUnqual :: GhcMonad m => m PrintUnqualified
- findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
- lookupModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
- isModuleTrusted :: GhcMonad m => Module -> m Bool
- moduleTrustReqs :: GhcMonad m => Module -> m (Bool, Set InstalledUnitId)
- getNamesInScope :: GhcMonad m => m [Name]
- getRdrNamesInScope :: GhcMonad m => m [RdrName]
- getGRE :: GhcMonad m => m GlobalRdrEnv
- moduleIsInterpreted :: GhcMonad m => Module -> m Bool
- getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
- showModule :: GhcMonad m => ModSummary -> m String
- moduleIsBootOrNotObjectLinkable :: GhcMonad m => ModSummary -> m Bool
- getNameToInstancesIndex :: GhcMonad m => m (Messages, Maybe (NameEnv ([ClsInst], [FamInst])))
- exprType :: GhcMonad m => TcRnExprMode -> String -> m Type
- data TcRnExprMode
  - = TM_Inst
  - | TM_NoInst
  - | TM_Default
- typeKind :: GhcMonad m => Bool -> String -> m (Type, Kind)
- parseName :: GhcMonad m => String -> m [Name]
- lookupName :: GhcMonad m => Name -> m (Maybe TyThing)
- data HValue :: *
- parseExpr :: GhcMonad m => String -> m (LHsExpr RdrName)
- compileParsedExpr :: GhcMonad m => LHsExpr RdrName -> m HValue
- compileExpr :: GhcMonad m => String -> m HValue
- dynCompileExpr :: GhcMonad m => String -> m Dynamic
- type ForeignHValue = ForeignRef HValue
- compileExprRemote :: GhcMonad m => String -> m ForeignHValue
- compileParsedExprRemote :: GhcMonad m => LHsExpr RdrName -> m ForeignHValue
- runTcInteractive :: HscEnv -> TcRn a -> IO (Messages, Maybe a)
- isStmt :: DynFlags -> String -> Bool
- hasImport :: DynFlags -> String -> Bool
- isImport :: DynFlags -> String -> Bool
- isDecl :: DynFlags -> String -> Bool
- data SingleStep
  - = RunToCompletion
  - | SingleStep
  - | RunAndLogSteps
- data Resume = Resume {
  - resumeStmt :: String
  - resumeContext :: ForeignRef (ResumeContext [HValueRef])
  - resumeBindings :: ([TyThing], GlobalRdrEnv)
  - resumeFinalIds :: [Id]
  - resumeApStack :: ForeignHValue
  - resumeBreakInfo :: Maybe BreakInfo
  - resumeSpan :: SrcSpan
  - resumeDecl :: String
  - resumeCCS :: RemotePtr CostCentreStack
  - resumeHistory :: [History]
  - resumeHistoryIx :: Int
  }
- data History
- getHistorySpan :: GhcMonad m => History -> m SrcSpan
- getHistoryModule :: History -> Module
- abandon :: GhcMonad m => m Bool
- abandonAll :: GhcMonad m => m Bool
- getResumeContext :: GhcMonad m => m [Resume]
- obtainTermFromId :: GhcMonad m => Int -> Bool -> Id -> m Term
- obtainTermFromVal :: GhcMonad m => Int -> Bool -> Type -> a -> m Term
- reconstructType :: HscEnv -> Int -> Id -> IO (Maybe Type)
- modInfoModBreaks :: ModuleInfo -> ModBreaks
- data ModBreaks = ModBreaks {
  - modBreaks_flags :: ForeignRef BreakArray
  - modBreaks_locs :: !(Array BreakIndex SrcSpan)
  - modBreaks_vars :: !(Array BreakIndex [OccName])
  - modBreaks_decls :: !(Array BreakIndex [String])
  - modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))
  - modBreaks_breakInfo :: IntMap CgBreakInfo
  }
- type BreakIndex = Int
- data BreakInfo
- back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String)
- forward :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String)
- data UnitId
- data Module
- mkModule :: UnitId -> ModuleName -> Module
- pprModule :: Module -> SDoc
- moduleName :: Module -> ModuleName
- moduleUnitId :: Module -> UnitId
- data ModuleName
- mkModuleName :: String -> ModuleName
- moduleNameString :: ModuleName -> String
- data Name
- isExternalName :: Name -> Bool
- nameModule :: Name -> Module
- pprParenSymName :: NamedThing a => a -> SDoc
- nameSrcSpan :: Name -> SrcSpan
- class NamedThing a where
- data RdrName
  - = Unqual OccName
  - | Qual ModuleName OccName
- type Id = Var
- idType :: Id -> Kind
- isImplicitId :: Id -> Bool
- isDeadBinder :: Id -> Bool
- isExportedId :: Var -> Bool
- isLocalId :: Var -> Bool
- isGlobalId :: Var -> Bool
- isRecordSelector :: Id -> Bool
- isPrimOpId :: Id -> Bool
- isFCallId :: Id -> Bool
- isClassOpId_maybe :: Id -> Maybe Class
- isDataConWorkId :: Id -> Bool
- idDataCon :: Id -> DataCon
- isBottomingId :: Var -> Bool
- isDictonaryId :: Id -> Bool
- recordSelectorTyCon :: Id -> RecSelParent
- data TyCon
- tyConTyVars :: TyCon -> [TyVar]
- tyConDataCons :: TyCon -> [DataCon]
- tyConArity :: TyCon -> Arity
- isClassTyCon :: TyCon -> Bool
- isTypeSynonymTyCon :: TyCon -> Bool
- isTypeFamilyTyCon :: TyCon -> Bool
- isNewTyCon :: TyCon -> Bool
- isPrimTyCon :: TyCon -> Bool
- isFunTyCon :: TyCon -> Bool
- isFamilyTyCon :: TyCon -> Bool
- isOpenFamilyTyCon :: TyCon -> Bool
- isOpenTypeFamilyTyCon :: TyCon -> Bool
- tyConClass_maybe :: TyCon -> Maybe Class
- synTyConRhs_maybe :: TyCon -> Maybe Type
- synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
- tyConKind :: TyCon -> Kind
- type TyVar = Var
- alphaTyVars :: [TyVar]
- data DataCon
- dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
- dataConType :: DataCon -> Type
- dataConTyCon :: DataCon -> TyCon
- dataConFieldLabels :: DataCon -> [FieldLabel]
- dataConIsInfix :: DataCon -> Bool
- isVanillaDataCon :: DataCon -> Bool
- dataConUserType :: DataCon -> Type
- dataConSrcBangs :: DataCon -> [HsSrcBang]
- data StrictnessMark
  - = MarkedStrict
  - | NotMarkedStrict
- isMarkedStrict :: StrictnessMark -> Bool
- data Class
- classMethods :: Class -> [Id]
- classSCTheta :: Class -> [PredType]
- classTvsFds :: Class -> ([TyVar], [FunDep TyVar])
- classATs :: Class -> [TyCon]
- pprFundeps :: Outputable a => [FunDep a] -> SDoc
- data ClsInst
- instanceDFunId :: ClsInst -> DFunId
- pprInstance :: ClsInst -> SDoc
- pprInstanceHdr :: ClsInst -> SDoc
- pprFamInst :: FamInst -> SDoc
- data FamInst
- data Type
- splitForAllTys :: Type -> ([TyVar], Type)
- funResultTy :: Type -> Type
- pprParendType :: Type -> SDoc
- pprTypeApp :: TyCon -> [Type] -> SDoc
- type Kind = Type
- type PredType = Type
- type ThetaType = [PredType]
- pprForAll :: [TyVarBinder] -> SDoc
- pprThetaArrowTy :: ThetaType -> SDoc
- data TyThing
  - = AnId Id
  - | AConLike ConLike
  - | ATyCon TyCon
  - | ACoAxiom (CoAxiom Branched)
- module HsSyn
- data FixityDirection
  - = InfixL
  - | InfixR
  - | InfixN
- defaultFixity :: Fixity
- maxPrecedence :: Int
- negateFixity :: Fixity
- compareFixity :: Fixity -> Fixity -> (Bool, Bool)
- data LexicalFixity
  - = Prefix
  - | Infix
- data SrcLoc
  - = RealSrcLoc !RealSrcLoc
  - | UnhelpfulLoc FastString
- data RealSrcLoc
- mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
- noSrcLoc :: SrcLoc
- srcLocFile :: RealSrcLoc -> FastString
- srcLocLine :: RealSrcLoc -> Int
- srcLocCol :: RealSrcLoc -> Int
- data SrcSpan
  - = RealSrcSpan !RealSrcSpan
  - | UnhelpfulSpan !FastString
- data RealSrcSpan
- mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
- srcLocSpan :: SrcLoc -> SrcSpan
- isGoodSrcSpan :: SrcSpan -> Bool
- noSrcSpan :: SrcSpan
- srcSpanStart :: SrcSpan -> SrcLoc
- srcSpanEnd :: SrcSpan -> SrcLoc
- srcSpanFile :: RealSrcSpan -> FastString
- srcSpanStartLine :: RealSrcSpan -> Int
- srcSpanEndLine :: RealSrcSpan -> Int
- srcSpanStartCol :: RealSrcSpan -> Int
- srcSpanEndCol :: RealSrcSpan -> Int
- data GenLocated l e = L l e
- type Located e = GenLocated SrcSpan e
- noLoc :: e -> Located e
- mkGeneralLocated :: String -> e -> Located e
- getLoc :: GenLocated l e -> l
- unLoc :: GenLocated l e -> e
- eqLocated :: Eq a => Located a -> Located a -> Bool
- cmpLocated :: Ord a => Located a -> Located a -> Ordering
- combineLocs :: Located a -> Located b -> SrcSpan
- addCLoc :: Located a -> Located b -> c -> Located c
- leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering
- leftmost_largest :: SrcSpan -> SrcSpan -> Ordering
- rightmost :: SrcSpan -> SrcSpan -> Ordering
- spans :: SrcSpan -> (Int, Int) -> Bool
- isSubspanOf :: SrcSpan -> SrcSpan -> Bool
- data GhcException
  - = Signal Int
  - | UsageError String
  - | CmdLineError String
  - | Panic String
  - | PprPanic String SDoc
  - | Sorry String
  - | PprSorry String SDoc
  - | InstallationError String
  - | ProgramError String
  - | PprProgramError String SDoc
- showGhcException :: GhcException -> ShowS
- data Token
- getTokenStream :: GhcMonad m => Module -> m [Located Token]
- getRichTokenStream :: GhcMonad m => Module -> m [(Located Token, String)]
- showRichTokenStream :: [(Located Token, String)] -> String
- addSourceToTokens :: RealSrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)]
- parser :: String -> DynFlags -> FilePath -> Either ErrorMessages (WarningMessages, Located (HsModule RdrName))
- type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment])
- data AnnKeywordId
  - = AnnAnyclass
  - | AnnAs
  - | AnnAt
  - | AnnBang
  - | AnnBackquote
  - | AnnBy
  - | AnnCase
  - | AnnClass
  - | AnnClose
  - | AnnCloseB
  - | AnnCloseBU
  - | AnnCloseC
  - | AnnCloseQ
  - | AnnCloseQU
  - | AnnCloseP
  - | AnnCloseS
  - | AnnColon
  - | AnnComma
  - | AnnCommaTuple
  - | AnnDarrow
  - | AnnDarrowU
  - | AnnData
  - | AnnDcolon
  - | AnnDcolonU
  - | AnnDefault
  - | AnnDeriving
  - | AnnDo
  - | AnnDot
  - | AnnDotdot
  - | AnnElse
  - | AnnEqual
  - | AnnExport
  - | AnnFamily
  - | AnnForall
  - | AnnForallU
  - | AnnForeign
  - | AnnFunId
  - | AnnGroup
  - | AnnHeader
  - | AnnHiding
  - | AnnIf
  - | AnnImport
  - | AnnIn
  - | AnnInfix
  - | AnnInstance
  - | AnnLam
  - | AnnLarrow
  - | AnnLarrowU
  - | AnnLet
  - | AnnMdo
  - | AnnMinus
  - | AnnModule
  - | AnnNewtype
  - | AnnName
  - | AnnOf
  - | AnnOpen
  - | AnnOpenB
  - | AnnOpenBU
  - | AnnOpenC
  - | AnnOpenE
  - | AnnOpenEQ
  - | AnnOpenEQU
  - | AnnOpenP
  - | AnnOpenPE
  - | AnnOpenPTE
  - | AnnOpenS
  - | AnnPackageName
  - | AnnPattern
  - | AnnProc
  - | AnnQualified
  - | AnnRarrow
  - | AnnRarrowU
  - | AnnRec
  - | AnnRole
  - | AnnSafe
  - | AnnSemi
  - | AnnSimpleQuote
  - | AnnSignature
  - | AnnStatic
  - | AnnStock
  - | AnnThen
  - | AnnThIdSplice
  - | AnnThIdTySplice
  - | AnnThTyQuote
  - | AnnTilde
  - | AnnTildehsh
  - | AnnType
  - | AnnUnit
  - | AnnUsing
  - | AnnVal
  - | AnnValStr
  - | AnnVbar
  - | AnnWhere
  - | Annlarrowtail
  - | AnnlarrowtailU
  - | Annrarrowtail
  - | AnnrarrowtailU
  - | AnnLarrowtail
  - | AnnLarrowtailU
  - | AnnRarrowtail
  - | AnnRarrowtailU
  - | AnnEofPos
- data AnnotationComment
  - = AnnDocCommentNext String
  - | AnnDocCommentPrev String
  - | AnnDocCommentNamed String
  - | AnnDocSection Int String
  - | AnnDocOptions String
  - | AnnLineComment String
  - | AnnBlockComment String
- getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]
- getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns)
- getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]
- getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns)
- unicodeAnn :: AnnKeywordId -> AnnKeywordId
- cyclicModuleErr :: [ModSummary] -> SDoc

# Initialisation

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.

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

Deprecated: Cleanup is now done by runGhc/runGhcT

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

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

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.

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

# GHC Monad

data Ghc a #

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

Instances

Monad Ghc # |
Methods (>>=) :: Ghc a -> (a -> Ghc b) -> Ghc b Source # (>>) :: Ghc a -> Ghc b -> Ghc b Source # return :: a -> Ghc a Source # fail :: String -> Ghc a Source #
Functor Ghc # |
Methods fmap :: (a -> b) -> Ghc a -> Ghc b Source # (<$) :: a -> Ghc b -> Ghc a Source #
MonadFix Ghc # |
Methods mfix :: (a -> Ghc a) -> Ghc a Source #
Applicative Ghc # |
Methods pure :: a -> Ghc a Source # (<*>) :: Ghc (a -> b) -> Ghc a -> Ghc b Source # liftA2 :: (a -> b -> c) -> Ghc a -> Ghc b -> Ghc c Source # (*>) :: Ghc a -> Ghc b -> Ghc b Source # (<*) :: Ghc a -> Ghc b -> Ghc a Source #
MonadIO Ghc # |
Methods liftIO :: IO a -> Ghc a Source #
ExceptionMonad Ghc # |
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 #
HasDynFlags Ghc # |
Methods getDynFlags :: Ghc DynFlags #
GhcMonad Ghc # |
Methods getSession :: Ghc HscEnv # setSession :: HscEnv -> Ghc () #

data GhcT m a #

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

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

Instances

Monad m => Monad (GhcT m) # |
Methods (>>=) :: GhcT m a -> (a -> GhcT m b) -> GhcT m b Source # (>>) :: GhcT m a -> GhcT m b -> GhcT m b Source # return :: a -> GhcT m a Source # fail :: String -> GhcT m a Source #
Functor m => Functor (GhcT m) # |
Methods fmap :: (a -> b) -> GhcT m a -> GhcT m b Source # (<$) :: a -> GhcT m b -> GhcT m a Source #
Applicative m => Applicative (GhcT m) # |
Methods pure :: a -> GhcT m a Source # (<*>) :: GhcT m (a -> b) -> GhcT m a -> GhcT m b Source # liftA2 :: (a -> b -> c) -> GhcT m a -> GhcT m b -> GhcT m c Source # (*>) :: GhcT m a -> GhcT m b -> GhcT m b Source # (<*) :: GhcT m a -> GhcT m b -> GhcT m a Source #
MonadIO m => MonadIO (GhcT m) # |
Methods liftIO :: IO a -> GhcT m a Source #
ExceptionMonad m => ExceptionMonad (GhcT m) # |
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 #
MonadIO m => HasDynFlags (GhcT m) # |
Methods getDynFlags :: GhcT m DynFlags #
ExceptionMonad m => GhcMonad (GhcT m) # |
Methods getSession :: GhcT m HscEnv # setSession :: HscEnv -> GhcT m () #

class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m 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.

Minimal complete definition

getSession, setSession

Methods

getSession :: m HscEnv #

setSession :: HscEnv -> m () #

Instances

GhcMonad Ghc # |
Methods getSession :: Ghc HscEnv # setSession :: HscEnv -> Ghc () #
ExceptionMonad m => GhcMonad (GhcT m) # |
Methods getSession :: GhcT m HscEnv # setSession :: HscEnv -> GhcT m () #

data HscEnv #

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

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

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.

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.

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.

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

gfinally :: ExceptionMonad m => m a -> m b -> m a #

Generalised version of `finally`, allowing an arbitrary exception handling monad instead of just `IO`.

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

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

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.

needsTemplateHaskell :: ModuleGraph -> Bool #

Determines whether a set of modules requires Template Haskell.

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.

# Flags and settings

data DynFlags #

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

Constructors

DynFlags |

Fields

- ghcMode :: GhcMode
- ghcLink :: GhcLink
- hscTarget :: HscTarget
- settings :: Settings
- verbosity :: Int

  Verbosity level: see Note [Verbosity levels]

- optLevel :: Int

  Optimisation level

- debugLevel :: Int

  How much debug information to produce

- simplPhases :: Int

  Number of simplifier phases

- maxSimplIterations :: Int

  Max simplifier iterations

- maxPmCheckIterations :: Int

  Max no iterations for pm checking

- ruleCheck :: Maybe String
- strictnessBefore :: [Int]

  Additional demand analysis

- parMakeCount :: Maybe Int

  The number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.

- enableTimeStats :: Bool

  Enable RTS timing statistics?

- ghcHeapSize :: Maybe Int

  The heap size to set.

- maxRelevantBinds :: Maybe Int

  Maximum number of bindings from the type envt to show in type error messages

- maxUncoveredPatterns :: Int

  Maximum number of unmatched patterns to show in non-exhaustiveness warnings

- simplTickFactor :: Int

  Multiplier for simplifier ticks

- specConstrThreshold :: Maybe Int

  Threshold for SpecConstr

- specConstrCount :: Maybe Int

  Max number of specialisations for any one function

- specConstrRecursive :: Int

  Max number of specialisations for recursive types Not optional; otherwise ForceSpecConstr can diverge.

- liberateCaseThreshold :: Maybe Int

  Threshold for LiberateCase

- floatLamArgs :: Maybe Int

  Arg count for lambda floating See CoreMonad.FloatOutSwitches

- historySize :: Int

  Simplification history size

- importPaths :: [FilePath]
- mainModIs :: Module
- mainFunIs :: Maybe String
- reductionDepth :: IntWithInf

  Typechecker maximum stack depth

- solverIterations :: IntWithInf

  Number of iterations in the constraints solver Typically only 1 is needed

- thisInstalledUnitId :: InstalledUnitId
- thisComponentId_ :: Maybe ComponentId
- thisUnitIdInsts_ :: Maybe [(ModuleName, Module)]
- ways :: [Way]

  Way flags from the command line

- buildTag :: String

  The global "way" (e.g. "p" for prof)

- rtsBuildTag :: String

  The RTS "way"

- splitInfo :: Maybe (String, Int)
- objectDir :: Maybe String
- dylibInstallName :: Maybe String
- hiDir :: Maybe String
- stubDir :: Maybe String
- dumpDir :: Maybe String
- objectSuf :: String
- hcSuf :: String
- hiSuf :: String
- canGenerateDynamicToo :: IORef Bool
- dynObjectSuf :: String
- dynHiSuf :: String
- dllSplitFile :: Maybe FilePath
- dllSplit :: Maybe [Set String]
- outputFile :: Maybe String
- dynOutputFile :: Maybe String
- outputHi :: Maybe String
- dynLibLoader :: DynLibLoader
- dumpPrefix :: Maybe FilePath

  This is set by `runPipeline` based on where its output is going.

- dumpPrefixForce :: Maybe FilePath

  Override the `dumpPrefix` set by `runPipeline`. Set by `-ddump-file-prefix`

- ldInputs :: [Option]
- includePaths :: [String]
- libraryPaths :: [String]
- frameworkPaths :: [String]
- cmdlineFrameworks :: [String]
- rtsOpts :: Maybe String
- rtsOptsEnabled :: RtsOptsEnabled
- rtsOptsSuggestions :: Bool
- hpcDir :: String

  Path to store the .mix files

- pluginModNames :: [ModuleName]
- pluginModNameOpts :: [(ModuleName, String)]
- frontendPluginOpts :: [String]

  the `-ffrontend-opt` flags given on the command line, in *reverse* order that they're specified on the command line.

- hooks :: Hooks
- depMakefile :: FilePath
- depIncludePkgDeps :: Bool
- depExcludeMods :: [ModuleName]
- depSuffixes :: [String]
- packageDBFlags :: [PackageDBFlag]

  The `-package-db` flags given on the command line, In *reverse* order that they're specified on the command line. This is intended to be applied with the list of "initial" package databases derived from `GHC_PACKAGE_PATH`; see `getPackageConfRefs`.

- ignorePackageFlags :: [IgnorePackageFlag]

  The `-ignore-package` flags from the command line. In *reverse* order that they're specified on the command line.

- packageFlags :: [PackageFlag]

  The `-package` and `-hide-package` flags from the command-line. In *reverse* order that they're specified on the command line.

- pluginPackageFlags :: [PackageFlag]

  The `-plugin-package-id` flags from command line. In *reverse* order that they're specified on the command line.

- trustFlags :: [TrustFlag]

  The `-trust` and `-distrust` flags. In *reverse* order that they're specified on the command line.

- packageEnv :: Maybe FilePath

  Filepath to the package environment file (if overriding default)

- pkgDatabase :: Maybe [(FilePath, [PackageConfig])]
- pkgState :: PackageState
- filesToClean :: IORef [FilePath]
- dirsToClean :: IORef (Map FilePath FilePath)
- filesToNotIntermediateClean :: IORef [FilePath]
- nextTempSuffix :: IORef Int
- generatedDumps :: IORef (Set FilePath)
- dumpFlags :: IntSet
- generalFlags :: IntSet
- warningFlags :: IntSet
- fatalWarningFlags :: IntSet
- language :: Maybe Language
- safeHaskell :: SafeHaskellMode

  Safe Haskell mode

- safeInfer :: Bool
- safeInferred :: Bool
- thOnLoc :: SrcSpan
- newDerivOnLoc :: SrcSpan
- overlapInstLoc :: SrcSpan
- incoherentOnLoc :: SrcSpan
- pkgTrustOnLoc :: SrcSpan
- warnSafeOnLoc :: SrcSpan
- warnUnsafeOnLoc :: SrcSpan
- trustworthyOnLoc :: SrcSpan
- extensions :: [OnOff Extension]
- extensionFlags :: IntSet
- ufCreationThreshold :: Int
- ufUseThreshold :: Int
- ufFunAppDiscount :: Int
- ufDictDiscount :: Int
- ufKeenessFactor :: Float
- ufDearOp :: Int
- ufVeryAggressive :: Bool
- maxWorkerArgs :: Int
- ghciHistSize :: Int
- initLogAction :: IO (Maybe LogOutput)

  MsgDoc output action: use ErrUtils instead of this if you can

- log_action :: LogAction
- log_finaliser :: LogFinaliser
- flushOut :: FlushOut
- flushErr :: FlushErr
- haddockOptions :: Maybe String
- ghciScripts :: [String]

  GHCi scripts specified by -ghci-script, in reverse order

- pprUserLength :: Int
- pprCols :: Int
- useUnicode :: Bool
- useColor :: OverridingBool
- canUseColor :: Bool
- colScheme :: Scheme
- profAuto :: ProfAuto

  what kind of {--} to add automatically

- interactivePrint :: Maybe String
- nextWrapperNum :: IORef (ModuleEnv Int)
- sseVersion :: Maybe SseVersion

  Machine dependent flags (-mblah stuff)

- avx :: Bool
- avx2 :: Bool
- avx512cd :: Bool
- avx512er :: Bool
- avx512f :: Bool
- avx512pf :: Bool
- rtldInfo :: IORef (Maybe LinkerInfo)

  Run-time linker information (what options we need, etc.)

- rtccInfo :: IORef (Maybe CompilerInfo)

  Run-time compiler information

- maxInlineAllocSize :: Int

  Max size, in bytes, of inline array allocations.

- maxInlineMemcpyInsns :: Int

  Only inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.

- maxInlineMemsetInsns :: Int

  Only inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.

- reverseErrors :: Bool

  Reverse the order of error messages in GHC/GHCi

- maxErrors :: Maybe Int

  Limit the maximum number of errors to show

- initialUnique :: Int

  Unique supply configuration for testing build determinism

- uniqueIncrement :: Int

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_WarnIsError |
Opt_ShowWarnGroups |
Opt_HideSourcePaths |
Opt_PrintExplicitForalls |
Opt_PrintExplicitKinds |
Opt_PrintExplicitCoercions |
Opt_PrintExplicitRuntimeReps |
Opt_PrintEqualityRelations |
Opt_PrintUnicodeSyntax |
Opt_PrintExpandedSynonyms |
Opt_PrintPotentialInstances |
Opt_PrintTypecheckerElaboration |
Opt_CallArity |
Opt_Strictness |
Opt_LateDmdAnal |
Opt_KillAbsence |
Opt_KillOneShot |
Opt_FullLaziness |
Opt_FloatIn |
Opt_Specialise |
Opt_SpecialiseAggressively |
Opt_CrossModuleSpecialise |
Opt_StaticArgumentTransformation |
Opt_CSE |
Opt_StgCSE |
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_Vectorise |
Opt_VectorisationAvoidance |
Opt_RegsGraph |
Opt_RegsIterative |
Opt_PedanticBottoms |
Opt_LlvmTBAA |
Opt_LlvmPassVectorsInRegisters |
Opt_LlvmFillUndefWithGarbage |
Opt_IrrefutableTuples |
Opt_CmmSink |
Opt_CmmElimCommonBlocks |
Opt_OmitYields |
Opt_FunToThunk |
Opt_DictsStrict |
Opt_DmdTxDictSel |
Opt_Loopification |
Opt_CprAnal |
Opt_WorkerWrapper |
Opt_SolveConstantDicts |
Opt_IgnoreInterfacePragmas |
Opt_OmitInterfacePragmas |
Opt_ExposeAllUnfoldings |
Opt_WriteInterface |
Opt_AutoSccsOnIndividualCafs |
Opt_ProfCountEntries |
Opt_Pp |
Opt_ForceRecomp |
Opt_ExcessPrecision |
Opt_EagerBlackHoling |
Opt_NoHsMain |
Opt_SplitObjs |
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_LocalGhciHistory |
Opt_HelpfulErrors |
Opt_DeferTypeErrors |
Opt_DeferTypedHoles |
Opt_DeferOutOfScopeVariables |

Opt_PIC

    -fPIC

Opt_PIE

    -fPIE

Opt_PICExecutable

    -pie

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_SimplPreInlining |
Opt_ErrorSpans |
Opt_DiagnosticsShowCaret |
Opt_PprCaseAsLet |
Opt_PprShowTicks |
Opt_ShowHoleConstraints |
Opt_ShowLoadedModules |
Opt_SuppressCoercions |
Opt_SuppressVarKinds |
Opt_SuppressModulePrefixes |
Opt_SuppressTypeApplications |
Opt_SuppressIdInfo |
Opt_SuppressUnfoldings |
Opt_SuppressTypeSignatures |
Opt_SuppressUniques |
Opt_SuppressTicks |
Opt_AutoLinkPackages |
Opt_ImplicitImportQualified |
Opt_KeepHiDiffs |
Opt_KeepHcFiles |
Opt_KeepSFiles |
Opt_KeepTmpFiles |
Opt_KeepRawTokenStream |
Opt_KeepLlvmFiles |
Opt_KeepHiFiles |
Opt_KeepOFiles |
Opt_BuildDynamicToo |
Opt_DistrustAllPackages |
Opt_PackageTrust |
Opt_G_NoStateHack |
Opt_G_NoOptCoercion |

Instances

Enum GeneralFlag # |

Methods

succ :: GeneralFlag -> GeneralFlag Source #

pred :: GeneralFlag -> GeneralFlag Source #

toEnum :: Int -> GeneralFlag Source #

fromEnum :: GeneralFlag -> Int Source #

enumFrom :: GeneralFlag -> [GeneralFlag] Source #

enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag] Source #

enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag] Source #

enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag] Source #

Eq GeneralFlag # |
Methods (==) :: GeneralFlag -> GeneralFlag -> Bool # (/=) :: GeneralFlag -> GeneralFlag -> Bool #
Show GeneralFlag # |
Methods showsPrec :: Int -> GeneralFlag -> ShowS Source # show :: GeneralFlag -> String Source # showList :: [GeneralFlag] -> ShowS Source #

data Severity #

Constructors

SevOutput |
SevFatal |
SevInteractive |
SevDump | Log messagse 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

Show Severity # |
Methods showsPrec :: Int -> Severity -> ShowS Source # show :: Severity -> String Source # showList :: [Severity] -> ShowS Source #
ToJson Severity # |
Methods json :: Severity -> JsonDoc #

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

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

Eq HscTarget # |
Methods (==) :: HscTarget -> HscTarget -> Bool # (/=) :: HscTarget -> HscTarget -> Bool #
Show HscTarget # |
Methods showsPrec :: Int -> HscTarget -> ShowS Source # show :: HscTarget -> String Source # showList :: [HscTarget] -> ShowS Source #

gopt :: GeneralFlag -> DynFlags -> Bool #

Test whether a `GeneralFlag` is set

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

Eq GhcMode # |
Methods (==) :: GhcMode -> GhcMode -> Bool # (/=) :: GhcMode -> GhcMode -> Bool #
Outputable GhcMode # |
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

Eq GhcLink # |
Methods (==) :: GhcLink -> GhcLink -> Bool # (/=) :: GhcLink -> GhcLink -> Bool #
Show GhcLink # |
Methods showsPrec :: Int -> GhcLink -> ShowS Source # show :: GhcLink -> String Source # showList :: [GhcLink] -> ShowS Source #

defaultObjectTarget :: Platform -> HscTarget #

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

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

getSessionDynFlags :: GhcMonad m => m DynFlags #

Grabs the DynFlags from the Session

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.

getProgramDynFlags :: GhcMonad m => m DynFlags #

Returns the program `DynFlags`.

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.

setLogAction :: GhcMonad m => LogAction -> LogFinaliser -> 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.

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

# Targets

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 (StringBuffer, UTCTime)

  in-memory text buffer?

Instances

Outputable Target # |
Methods ppr :: Target -> SDoc # pprPrec :: Rational -> Target -> SDoc #

data TargetId #

Constructors

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

Instances

Eq TargetId # |
Methods (==) :: TargetId -> TargetId -> Bool # (/=) :: TargetId -> TargetId -> Bool #
Outputable TargetId # |
Methods ppr :: TargetId -> SDoc # pprPrec :: Rational -> TargetId -> SDoc #

data Phase #

Instances

Eq Phase # |
Methods (==) :: Phase -> Phase -> Bool # (/=) :: Phase -> Phase -> Bool #
Show Phase # |
Methods showsPrec :: Int -> Phase -> ShowS Source # show :: Phase -> String Source # showList :: [Phase] -> ShowS Source #
Outputable Phase # |
Methods ppr :: Phase -> SDoc # pprPrec :: Rational -> Phase -> SDoc #

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

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

Returns the current set of targets

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

Add another target.

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

Remove a target

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

# Loading/compiling the program

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.

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

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.

data InteractiveImport #

Constructors

IIDecl (ImportDecl RdrName) | Bring the exports of a particular module (filtered by an import decl) into scope
IIModule ModuleName | Bring into scope the entire top-level envt of of this module, including the things imported into it.

Instances

Outputable InteractiveImport # |
Methods ppr :: InteractiveImport -> SDoc # pprPrec :: Rational -> InteractiveImport -> SDoc #

data SuccessFlag #

Constructors

Succeeded |
Failed |

Instances

Outputable SuccessFlag # |
Methods ppr :: SuccessFlag -> SDoc # pprPrec :: Rational -> SuccessFlag -> SDoc #

succeeded :: SuccessFlag -> Bool #

failed :: SuccessFlag -> Bool #

defaultWarnErrLogger :: WarnErrLogger #

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

A function called to log warnings and errors.

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

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

Parse a module.

Throws a `SourceError` on parse error.

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

Typecheck and rename a parsed module.

Throws a `SourceError` if either fails.

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

Desugar a typechecked module.

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

data ParsedModule #

The result of successful parsing.

Constructors

ParsedModule |

Fields

- pm_mod_summary :: ModSummary
- pm_parsed_source :: ParsedSource
- pm_extra_src_files :: [FilePath]
- pm_annotations :: ApiAnns

Instances

ParsedMod ParsedModule # |
Methods modSummary :: ParsedModule -> ModSummary parsedSource :: ParsedModule -> ParsedSource #

data TypecheckedModule #

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

Constructors

TypecheckedModule |

Fields

- tm_parsed_module :: ParsedModule
- tm_renamed_source :: Maybe RenamedSource
- tm_typechecked_source :: TypecheckedSource
- tm_checked_module_info :: ModuleInfo
- tm_internals_ :: (TcGblEnv, ModDetails)

Instances

TypecheckedMod TypecheckedModule # |
Methods renamedSource :: TypecheckedModule -> Maybe RenamedSource # typecheckedSource :: TypecheckedModule -> TypecheckedSource # moduleInfo :: TypecheckedModule -> ModuleInfo # tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)
ParsedMod TypecheckedModule # |
Methods modSummary :: TypecheckedModule -> ModSummary parsedSource :: TypecheckedModule -> ParsedSource #

data DesugaredModule #

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

Constructors

DesugaredModule |

Fields

- dm_typechecked_module :: TypecheckedModule
- dm_core_module :: ModGuts

Instances

TypecheckedMod DesugaredModule # |
Methods renamedSource :: DesugaredModule -> Maybe RenamedSource # typecheckedSource :: DesugaredModule -> TypecheckedSource # moduleInfo :: DesugaredModule -> ModuleInfo # tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)
ParsedMod DesugaredModule # |
Methods modSummary :: DesugaredModule -> ModSummary parsedSource :: DesugaredModule -> ParsedSource #

type TypecheckedSource = LHsBinds Id #

type ParsedSource = Located (HsModule RdrName) #

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

class ParsedMod m => TypecheckedMod m where #

Minimal complete definition

renamedSource, typecheckedSource, moduleInfo, tm_internals

Methods

renamedSource :: m -> Maybe RenamedSource #

typecheckedSource :: m -> TypecheckedSource #

moduleInfo :: m -> ModuleInfo #

Instances

TypecheckedMod DesugaredModule # |
Methods renamedSource :: DesugaredModule -> Maybe RenamedSource # typecheckedSource :: DesugaredModule -> TypecheckedSource # moduleInfo :: DesugaredModule -> ModuleInfo # tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)
TypecheckedMod TypecheckedModule # |
Methods renamedSource :: TypecheckedModule -> Maybe RenamedSource # typecheckedSource :: TypecheckedModule -> TypecheckedSource # moduleInfo :: TypecheckedModule -> ModuleInfo # tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

class ParsedMod m where #

Minimal complete definition

modSummary, parsedSource

Methods

parsedSource :: m -> ParsedSource #

Instances

ParsedMod DesugaredModule # |
Methods modSummary :: DesugaredModule -> ModSummary parsedSource :: DesugaredModule -> ParsedSource #
ParsedMod TypecheckedModule # |
Methods modSummary :: TypecheckedModule -> ModSummary parsedSource :: TypecheckedModule -> ParsedSource #
ParsedMod ParsedModule # |
Methods modSummary :: ParsedModule -> ModSummary parsedSource :: ParsedModule -> ParsedSource #

moduleInfo :: TypecheckedMod m => m -> ModuleInfo #

renamedSource :: TypecheckedMod m => m -> Maybe RenamedSource #

typecheckedSource :: TypecheckedMod m => m -> TypecheckedSource #

parsedSource :: ParsedMod m => m -> ParsedSource #

coreModule :: DesugaredMod m => m -> ModGuts #

## Compiling to Core

data CoreModule #

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

Constructors

CoreModule |

Fields

- cm_module :: !Module

  Module name

- cm_types :: !TypeEnv

  Type environment for types declared in this module

- cm_binds :: CoreProgram

  Declarations

- cm_safe :: SafeHaskellMode

  Safe Haskell mode

Instances

Outputable CoreModule # |
Methods ppr :: CoreModule -> SDoc # pprPrec :: Rational -> CoreModule -> SDoc #

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.

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

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

# Inspecting the module structure of the program

type ModuleGraph = [ModSummary] #

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

- ms_mod :: Module

  Identity of the module

- ms_hsc_src :: HscSource

  The module source either plain Haskell or hs-boot

- ms_location :: ModLocation

  Location of the various files belonging to the module

- ms_hs_date :: UTCTime

  Timestamp of source file

- ms_obj_date :: Maybe UTCTime

  Timestamp of object, if we have one

- ms_iface_date :: Maybe UTCTime

  Timestamp of hi file, if we *only* are typechecking (it is `Nothing` otherwise. See Note [Recompilation checking when typechecking only] and #9243

- ms_srcimps :: [(Maybe FastString, Located ModuleName)]

  Source imports of the module

- ms_textual_imps :: [(Maybe FastString, Located ModuleName)]

  Non-source imports of the module from the module *text*

- ms_parsed_mod :: Maybe HsParsedModule

  The parsed, nonrenamed source, if we have it. This is also used to support "inline module syntax" in Backpack files.

- ms_hspp_file :: FilePath

  Filename of preprocessed source file

- ms_hspp_opts :: DynFlags

  Cached flags from `OPTIONS`, `INCLUDE` and `LANGUAGE` pragmas in the modules source code

- ms_hspp_buf :: Maybe StringBuffer

  The actual preprocessed source, if we have it

Instances

Outputable ModSummary # |
Methods ppr :: ModSummary -> SDoc # pprPrec :: Rational -> ModSummary -> SDoc #

ms_mod_name :: ModSummary -> ModuleName #

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

Constructors

ModLocation |

Fields

- ml_hs_file :: Maybe FilePath
- ml_hi_file :: FilePath
- ml_obj_file :: FilePath

Instances

Show ModLocation # |
Methods showsPrec :: Int -> ModLocation -> ShowS Source # show :: ModLocation -> String Source # showList :: [ModLocation] -> ShowS Source #
Outputable ModLocation # |
Methods ppr :: ModLocation -> SDoc # pprPrec :: Rational -> ModLocation -> SDoc #

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.

getModuleGraph :: GhcMonad m => m ModuleGraph #

Get the module dependency graph.

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

Return `True` == module is loaded.

topSortModuleGraph #

Arguments

:: Bool | Drop hi-boot nodes? (see below)
-> [ModSummary] |
-> 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

# Inspecting modules

data ModuleInfo #

Container for information about a `Module`.

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

Request information about a loaded `Module`

modInfoTyThings :: ModuleInfo -> [TyThing] #

The list of top-level entities defined in a module

modInfoTopLevelScope :: ModuleInfo -> Maybe [Name] #

modInfoExports :: ModuleInfo -> [Name] #

modInfoExportsWithSelectors :: ModuleInfo -> [Name] #

modInfoInstances :: ModuleInfo -> [ClsInst] #

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

modInfoIsExportedName :: ModuleInfo -> Name -> Bool #

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

modInfoIface :: ModuleInfo -> Maybe ModIface #

modInfoSafe :: ModuleInfo -> SafeHaskellMode #

Retrieve module safe haskell mode

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

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

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

data ModIface #

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

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

Constructors

ModIface |

Fields

- mi_module :: !Module

  Name of the module we are for

- mi_sig_of :: !(Maybe Module)

  Are we a sig of another mod?

- mi_iface_hash :: !Fingerprint

  Hash of the whole interface

- mi_mod_hash :: !Fingerprint

  Hash of the ABI only

- mi_flag_hash :: !Fingerprint

  Hash of the important flags used when compiling this module

- mi_orphan :: !WhetherHasOrphans

  Whether this module has orphans

- mi_finsts :: !WhetherHasFamInst

  Whether this module has family instances. See Note [The type family instance consistency story].

- 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 `OccName`s of those things

- mi_exp_hash :: !Fingerprint

  Hash of export list

- 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 :: [(Fingerprint, IfaceDecl)]

  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_orphan_hash :: !Fingerprint

  Hash for orphan rules, class and family instances, and vectorise pragmas combined

- mi_vect_info :: !IfaceVectInfo

  Vectorisation information

- mi_warn_fn :: OccName -> Maybe WarningTxt

  Cached lookup for `mi_warns`

- mi_fix_fn :: OccName -> Maybe Fixity

  Cached lookup for `mi_fixities`

- mi_hash_fn :: OccName -> Maybe (OccName, Fingerprint)

  Cached lookup for `mi_decls`. The `Nothing` in `mi_hash_fn` means that the thing isn't in decls. It's useful to know that when seeing if we are up to date wrt. the old interface. The `OccName` is the parent of the name, if it has one.

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

Instances

Binary ModIface # |
Methods put_ :: BinHandle -> ModIface -> IO () # put :: BinHandle -> ModIface -> IO (Bin * ModIface) # get :: BinHandle -> IO ModIface #

data SafeHaskellMode #

The various Safe Haskell modes

Constructors

Sf_None |
Sf_Unsafe |
Sf_Trustworthy |
Sf_Safe |

Instances

Eq SafeHaskellMode # |
Methods (==) :: SafeHaskellMode -> SafeHaskellMode -> Bool # (/=) :: SafeHaskellMode -> SafeHaskellMode -> Bool #
Show SafeHaskellMode # |
Methods showsPrec :: Int -> SafeHaskellMode -> ShowS Source # show :: SafeHaskellMode -> String Source # showList :: [SafeHaskellMode] -> ShowS Source #
Outputable SafeHaskellMode # |
Methods ppr :: SafeHaskellMode -> SDoc # pprPrec :: Rational -> SafeHaskellMode -> SDoc #

# Querying the environment

# Printing

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

alwaysQualify :: PrintUnqualified #

# Interactive evaluation

## Executing statements

execStmt #

Arguments

:: GhcMonad m |
=> String | a statement (bind or expression)
-> ExecOptions |
-> m ExecResult |

Run a statement in the current interactive context.

data ExecOptions #

Constructors

ExecOptions |

Fields

- execSingleStep :: SingleStep

  stepping mode

- execSourceFile :: String

  filename (for errors)

- execLineNumber :: Int

  line number (for errors)

- execWrap :: ForeignHValue -> EvalExpr ForeignHValue

execOptions :: ExecOptions #

default ExecOptions

data ExecResult #

Constructors

ExecComplete |

Fields

- execResult :: Either SomeException [Name]
- execAllocation :: Word64

ExecBreak |

Fields

- breakNames :: [Name]
- breakInfo :: Maybe BreakInfo

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

## Adding new declarations

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

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

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

## Get/set the current context

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

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

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.

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.

getGHCiMonad :: GhcMonad m => m Name #

Get the monad GHCi lifts user statements into.

## Inspecting the current context

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

Return the bindings for the current interactive session.

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

Return the instances for the current interactive session.

getPrintUnqual :: GhcMonad m => m PrintUnqualified #

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.

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.

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.

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

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

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

Returns all names in scope in the current interactive context

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

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

getGRE :: GhcMonad m => m GlobalRdrEnv #

get the GlobalRdrEnv for a session

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

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

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

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

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

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

getNameToInstancesIndex :: GhcMonad m => 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.

## Inspecting types and kinds

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

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

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)

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

Get the kind of a type

## Looking up a Name

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

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

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

Returns the `TyThing` for a `Name`. The `Name` may refer to any entity known to GHC, including `Name`s defined using `runStmt`.

## Compiling expressions

data HValue :: * Source #

Instances

Show HValue |
Methods showsPrec :: Int -> HValue -> ShowS Source # show :: HValue -> String Source # showList :: [HValue] -> ShowS Source #

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

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

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

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

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

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

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

type ForeignHValue = ForeignRef HValue Source #

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

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

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

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

## Other

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

isStmt :: DynFlags -> String -> Bool #

Returns `True` if passed string is a statement.

hasImport :: DynFlags -> String -> Bool #

Returns `True` if passed string has an import declaration.

isImport :: DynFlags -> String -> Bool #

Returns `True` if passed string is an import declaration.

isDecl :: DynFlags -> String -> Bool #

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

## The debugger

data SingleStep #

Constructors

RunToCompletion |
SingleStep |
RunAndLogSteps |

data Resume #

Constructors

Resume |

Fields

- resumeStmt :: String
- resumeContext :: ForeignRef (ResumeContext [HValueRef])
- resumeBindings :: ([TyThing], GlobalRdrEnv)
- resumeFinalIds :: [Id]
- resumeApStack :: ForeignHValue
- resumeBreakInfo :: Maybe BreakInfo
- resumeSpan :: SrcSpan
- resumeDecl :: String
- resumeCCS :: RemotePtr CostCentreStack
- resumeHistory :: [History]
- resumeHistoryIx :: Int

data History #

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

getHistoryModule :: History -> Module #

abandon :: GhcMonad m => m Bool #

abandonAll :: GhcMonad m => m Bool #

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

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

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

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

modInfoModBreaks :: ModuleInfo -> ModBreaks #

data ModBreaks #

All the information about the breakpoints for a module

Constructors

ModBreaks |

Fields

- modBreaks_flags :: ForeignRef BreakArray

  The array of flags, one per breakpoint, indicating which breakpoints are enabled.

- modBreaks_locs :: !(Array BreakIndex SrcSpan)

  An array giving the source span of each breakpoint.

- modBreaks_vars :: !(Array BreakIndex [OccName])

  An array giving the names of the free variables at each breakpoint.

- modBreaks_decls :: !(Array BreakIndex [String])

  An array giving the names of the declarations enclosing each breakpoint.

- modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))

  Array pointing to cost centre for each breakpoint

- modBreaks_breakInfo :: IntMap CgBreakInfo

  info about each breakpoint from the bytecode generator

type BreakIndex = Int #

Breakpoint index

data BreakInfo #

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

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

# Abstract syntax elements

## Packages

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

Eq UnitId # |
Methods (==) :: UnitId -> UnitId -> Bool # (/=) :: UnitId -> UnitId -> Bool #
Data UnitId # |

Methods

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

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

toConstr :: UnitId -> Constr Source #

dataTypeOf :: UnitId -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord UnitId # |
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 # |
Methods showsPrec :: Int -> UnitId -> ShowS Source # show :: UnitId -> String Source # showList :: [UnitId] -> ShowS Source #
NFData UnitId # |
Methods rnf :: UnitId -> () Source #
Outputable UnitId # |
Methods ppr :: UnitId -> SDoc # pprPrec :: Rational -> UnitId -> SDoc #
Uniquable UnitId # |
Methods getUnique :: UnitId -> Unique #
Binary UnitId # |
Methods put_ :: BinHandle -> UnitId -> IO () # put :: BinHandle -> UnitId -> IO (Bin * UnitId) # get :: BinHandle -> IO UnitId #
DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module # |
Methods fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module Source # toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module Source # fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId Source # toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module Source #

## Modules

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

Eq Module # |
Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Data Module # |

Methods

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

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

toConstr :: Module -> Constr Source #

dataTypeOf :: Module -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord 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 #
NFData Module # |
Methods rnf :: Module -> () Source #
Outputable Module # |
Methods ppr :: Module -> SDoc # pprPrec :: Rational -> Module -> SDoc #
Uniquable Module # |
Methods getUnique :: Module -> Unique #
Binary Module # |
Methods put_ :: BinHandle -> Module -> IO () # put :: BinHandle -> Module -> IO (Bin * Module) # get :: BinHandle -> IO Module #
DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module # |
Methods fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module Source # toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module Source # fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId Source # toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module Source #

mkModule :: UnitId -> ModuleName -> Module #

pprModule :: Module -> SDoc #

moduleName :: Module -> ModuleName #

moduleUnitId :: Module -> UnitId #

data ModuleName #

A ModuleName is essentially a simple string, e.g. `Data.List`.

Instances

Eq ModuleName # |
Methods (==) :: ModuleName -> ModuleName -> Bool # (/=) :: ModuleName -> ModuleName -> Bool #
Data ModuleName # |

Methods

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

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

toConstr :: ModuleName -> Constr Source #

dataTypeOf :: ModuleName -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord ModuleName # |
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 #
NFData ModuleName # |
Methods rnf :: ModuleName -> () Source #
BinaryStringRep ModuleName # |
Methods fromStringRep :: ByteString -> ModuleName Source # toStringRep :: ModuleName -> ByteString Source #
Outputable ModuleName # |
Methods ppr :: ModuleName -> SDoc # pprPrec :: Rational -> ModuleName -> SDoc #
Uniquable ModuleName # |
Methods getUnique :: ModuleName -> Unique #
Binary ModuleName # |
Methods put_ :: BinHandle -> ModuleName -> IO () # put :: BinHandle -> ModuleName -> IO (Bin * ModuleName) # get :: BinHandle -> IO ModuleName #
DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module # |
Methods fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module Source # toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module Source # fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId Source # toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module Source #

mkModuleName :: String -> ModuleName #

moduleNameString :: ModuleName -> String #

## Names

data Name #

A unique, unambiguous name for something, containing information about where that thing originated.

Instances

Eq Name # |
Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Data Name # |

Methods

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

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

toConstr :: Name -> Constr Source #

dataTypeOf :: Name -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord 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 # |
Methods rnf :: Name -> () Source #
OutputableBndr Name # |
Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> Maybe Int #
Outputable Name # |
Methods ppr :: Name -> SDoc # pprPrec :: Rational -> Name -> SDoc #
Uniquable Name # |
Methods getUnique :: Name -> Unique #
Binary Name # | Assumes that the `Name` is a non-binding one. See `putIfaceTopBndr` and `getIfaceTopBndr` for serializing binding `Name`s. See `UserData` for the rationale for this distinction.
Methods put_ :: BinHandle -> Name -> IO () # put :: BinHandle -> Name -> IO (Bin * Name) # get :: BinHandle -> IO Name #
HasOccName Name # |
Methods occName :: Name -> OccName #
NamedThing Name # |
Methods getOccName :: Name -> OccName # getName :: Name -> Name #
type PostRn Name ty # |
type PostRn Name ty = ty
type PostTc Name ty # |
type PostTc Name ty = PlaceHolder

isExternalName :: Name -> Bool #

nameModule :: Name -> Module #

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

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

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

NamedThing Name # |
Methods getOccName :: Name -> OccName # getName :: Name -> Name #
NamedThing TyCon # |
Methods getOccName :: TyCon -> OccName # getName :: TyCon -> Name #
NamedThing TyThing # |
Methods getOccName :: TyThing -> OccName # getName :: TyThing -> Name #
NamedThing Var # |
Methods getOccName :: Var -> OccName # getName :: Var -> Name #
NamedThing PatSyn # |
Methods getOccName :: PatSyn -> OccName # getName :: PatSyn -> Name #
NamedThing DataCon # |
Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #
NamedThing ConLike # |
Methods getOccName :: ConLike -> OccName # getName :: ConLike -> Name #
NamedThing Class # |
Methods getOccName :: Class -> OccName # getName :: Class -> Name #
NamedThing FamInst # |
Methods getOccName :: FamInst -> OccName # getName :: FamInst -> Name #
NamedThing IfaceConDecl # |
Methods getOccName :: IfaceConDecl -> OccName # getName :: IfaceConDecl -> Name #
NamedThing IfaceClassOp # |
Methods getOccName :: IfaceClassOp -> OccName # getName :: IfaceClassOp -> Name #
NamedThing IfaceDecl # |
Methods getOccName :: IfaceDecl -> OccName # getName :: IfaceDecl -> Name #
NamedThing ClsInst # |
Methods getOccName :: ClsInst -> OccName # getName :: ClsInst -> Name #
NamedThing (CoAxiom br) # |
Methods getOccName :: CoAxiom br -> OccName # getName :: CoAxiom br -> Name #
NamedThing e => NamedThing (GenLocated l e) # |
Methods getOccName :: GenLocated l e -> OccName # getName :: GenLocated l e -> Name #

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`
    ( ~ )

- `AnnKeywordId` : `AnnType`, `AnnOpen` `'('` or `'['` or `'[:'`, `AnnClose` `')'` or `']'` or `':]'`,, `AnnBackquote` `'`'`, `AnnVal`,`AnnTildehsh`, `AnnTilde`,

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

Eq RdrName # |
Methods (==) :: RdrName -> RdrName -> Bool # (/=) :: RdrName -> RdrName -> Bool #
Data RdrName # |

Methods

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

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

toConstr :: RdrName -> Constr Source #

dataTypeOf :: RdrName -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord 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 #
OutputableBndr RdrName # |
Methods pprBndr :: BindingSite -> RdrName -> SDoc # pprPrefixOcc :: RdrName -> SDoc # pprInfixOcc :: RdrName -> SDoc # bndrIsJoin_maybe :: RdrName -> Maybe Int #
Outputable RdrName # |
Methods ppr :: RdrName -> SDoc # pprPrec :: Rational -> RdrName -> SDoc #
HasOccName RdrName # |
Methods occName :: RdrName -> OccName #
type PostRn RdrName ty # |
type PostRn RdrName ty = PlaceHolder
type PostTc RdrName ty # |
type PostTc RdrName ty = PlaceHolder

## Identifiers

type Id = Var #

Identifier

idType :: Id -> Kind #

isImplicitId :: Id -> Bool #

`isImplicitId` tells whether an `Id`s 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.

isDeadBinder :: Id -> Bool #

isExportedId :: Var -> Bool #

`isExportedIdVar` means "don't throw this away"

isLocalId :: Var -> Bool #

isGlobalId :: Var -> Bool #

isRecordSelector :: Id -> Bool #

isPrimOpId :: Id -> Bool #

isFCallId :: Id -> Bool #

isClassOpId_maybe :: Id -> Maybe Class #

isDataConWorkId :: Id -> Bool #

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

isBottomingId :: Var -> Bool #

Returns true if an application to n args would diverge

isDictonaryId :: Id -> Bool #

recordSelectorTyCon :: Id -> RecSelParent #

If the `Id` is that for a record selector, extract the `sel_tycon`. Panic otherwise.

## Type constructors

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

Eq TyCon # |
Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Data TyCon # |

Methods

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

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

toConstr :: TyCon -> Constr Source #

dataTypeOf :: TyCon -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable TyCon # |
Methods ppr :: TyCon -> SDoc # pprPrec :: Rational -> TyCon -> SDoc #
Uniquable TyCon # |
Methods getUnique :: TyCon -> Unique #
NamedThing TyCon # |
Methods getOccName :: TyCon -> OccName # getName :: TyCon -> Name #

tyConTyVars :: TyCon -> [TyVar] #

TyVar binders

tyConDataCons :: TyCon -> [DataCon] #

As `tyConDataCons_maybe`, but returns the empty list of constructors if no constructors could be found

tyConArity :: TyCon -> Arity #

Arity

isClassTyCon :: TyCon -> Bool #

Is this `TyCon` that for a class instance?

isTypeSynonymTyCon :: TyCon -> Bool #

Is this a `TyCon` representing a regular H98 type synonym (`type`)?

isTypeFamilyTyCon :: TyCon -> Bool #

Is this a synonym `TyCon` that can have may have further instances appear?

isNewTyCon :: TyCon -> Bool #

Is this `TyCon` that for a `newtype`

isPrimTyCon :: TyCon -> Bool #

Does this `TyCon` represent something that cannot be defined in Haskell?

isFunTyCon :: TyCon -> Bool #

isFamilyTyCon :: TyCon -> Bool #

Is this a `TyCon`, synonym or otherwise, that defines a family?

isOpenFamilyTyCon :: TyCon -> Bool #

Is this a `TyCon`, synonym or otherwise, that defines a family with instances?

isOpenTypeFamilyTyCon :: TyCon -> Bool #

Is this an open type family TyCon?

tyConClass_maybe :: TyCon -> Maybe Class #

If this `TyCon` is that for a class instance, return the class it is for. Otherwise returns `Nothing`

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 `TyVar`s bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

tyConKind :: TyCon -> Kind #

Kind of this TyCon

## Type variables

type TyVar = Var #

Type or kind Variable

alphaTyVars :: [TyVar] #

## Data constructors

data DataCon #

A data constructor

- `AnnKeywordId` : `AnnOpen`, `AnnClose`,`AnnComma`

Instances

Eq DataCon # |
Methods (==) :: DataCon -> DataCon -> Bool # (/=) :: DataCon -> DataCon -> Bool #
Data DataCon # |

Methods

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

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

toConstr :: DataCon -> Constr Source #

dataTypeOf :: DataCon -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndr DataCon # |
Methods pprBndr :: BindingSite -> DataCon -> SDoc # pprPrefixOcc :: DataCon -> SDoc # pprInfixOcc :: DataCon -> SDoc # bndrIsJoin_maybe :: DataCon -> Maybe Int #
Outputable DataCon # |
Methods ppr :: DataCon -> SDoc # pprPrec :: Rational -> DataCon -> SDoc #
Uniquable DataCon # |
Methods getUnique :: DataCon -> Unique #
NamedThing DataCon # |
Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #

dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type) #

The "signature" of the `DataCon` returns, in order:

1) The result of `dataConAllTyVars`,

2) All the `ThetaType`s relating to the `DataCon` (coercion, dictionary, implicit parameter - whatever)

3) The type arguments to the constructor

4) The original result type of the `DataCon`

dataConType :: DataCon -> Type #

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`

dataConIsInfix :: DataCon -> Bool #

Should the `DataCon` be presented infix?

isVanillaDataCon :: DataCon -> Bool #

Vanilla `DataCon`s 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

NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.

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`

data StrictnessMark #

Constructors

MarkedStrict |
NotMarkedStrict |

Instances

Outputable StrictnessMark # |
Methods ppr :: StrictnessMark -> SDoc # pprPrec :: Rational -> StrictnessMark -> SDoc #

isMarkedStrict :: StrictnessMark -> Bool #

## Classes

data Class #

Instances

Eq Class # |
Methods (==) :: Class -> Class -> Bool # (/=) :: Class -> Class -> Bool #
Data Class # |

Methods

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

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

toConstr :: Class -> Constr Source #

dataTypeOf :: Class -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable Class # |
Methods ppr :: Class -> SDoc # pprPrec :: Rational -> Class -> SDoc #
Uniquable Class # |
Methods getUnique :: Class -> Unique #
NamedThing Class # |
Methods getOccName :: Class -> OccName # getName :: Class -> Name #

classMethods :: Class -> [Id] #

classSCTheta :: Class -> [PredType] #

classTvsFds :: Class -> ([TyVar], [FunDep TyVar]) #

classATs :: Class -> [TyCon] #

pprFundeps :: Outputable a => [FunDep a] -> SDoc #

## Instances

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

Data ClsInst # |

Methods

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

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

toConstr :: ClsInst -> Constr Source #

dataTypeOf :: ClsInst -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable ClsInst # |
Methods ppr :: ClsInst -> SDoc # pprPrec :: Rational -> ClsInst -> SDoc #
NamedThing ClsInst # |
Methods getOccName :: ClsInst -> OccName # getName :: ClsInst -> Name #

instanceDFunId :: ClsInst -> DFunId #

pprInstance :: ClsInst -> SDoc #

pprInstanceHdr :: ClsInst -> SDoc #

pprFamInst :: FamInst -> SDoc #

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

data FamInst #

Instances

Outputable FamInst # |
Methods ppr :: FamInst -> SDoc # pprPrec :: Rational -> FamInst -> SDoc #
NamedThing FamInst # |
Methods getOccName :: FamInst -> OccName # getName :: FamInst -> Name #

## Types and Kinds

data Type #

Instances

Data Type # |

Methods

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

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

toConstr :: Type -> Constr Source #

dataTypeOf :: Type -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable Type # |
Methods ppr :: Type -> SDoc # pprPrec :: Rational -> Type -> SDoc #

splitForAllTys :: Type -> ([TyVar], Type) #

Take a ForAllTy apart, returning the list of tyvars 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

pprParendType :: Type -> SDoc #

pprTypeApp :: TyCon -> [Type] -> SDoc #

type Kind = Type #

The key type representing kinds in the compiler.

type PredType = Type #

A type of the form `p` of kind `Constraint` 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 ThetaType = [PredType] #

A collection of `PredType`s

pprForAll :: [TyVarBinder] -> SDoc #

pprThetaArrowTy :: ThetaType -> SDoc #

## Entities

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

Outputable TyThing # |
Methods ppr :: TyThing -> SDoc # pprPrec :: Rational -> TyThing -> SDoc #
NamedThing TyThing # |
Methods getOccName :: TyThing -> OccName # getName :: TyThing -> Name #

## Syntax

module HsSyn

## Fixities

data FixityDirection #

Constructors

InfixL |
InfixR |
InfixN |

Instances

Eq FixityDirection # |
Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Data FixityDirection # |

Methods

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

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

toConstr :: FixityDirection -> Constr Source #

dataTypeOf :: FixityDirection -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable FixityDirection # |
Methods ppr :: FixityDirection -> SDoc # pprPrec :: Rational -> FixityDirection -> SDoc #
Binary FixityDirection # |
Methods put_ :: BinHandle -> FixityDirection -> IO () # put :: BinHandle -> FixityDirection -> IO (Bin * FixityDirection) # get :: BinHandle -> IO FixityDirection #

defaultFixity :: Fixity #

maxPrecedence :: Int #

negateFixity :: Fixity #

compareFixity :: Fixity -> Fixity -> (Bool, Bool) #

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

Eq LexicalFixity # |
Methods (==) :: LexicalFixity -> LexicalFixity -> Bool # (/=) :: LexicalFixity -> LexicalFixity -> Bool #
Data LexicalFixity # |

Methods

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

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

toConstr :: LexicalFixity -> Constr Source #

dataTypeOf :: LexicalFixity -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable LexicalFixity # |
Methods ppr :: LexicalFixity -> SDoc # pprPrec :: Rational -> LexicalFixity -> SDoc #

## Source locations

data SrcLoc #

Source Location

Constructors

RealSrcLoc !RealSrcLoc |
UnhelpfulLoc FastString |

Instances

Eq SrcLoc # |
Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Ord 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 # |
Methods showsPrec :: Int -> SrcLoc -> ShowS Source # show :: SrcLoc -> String Source # showList :: [SrcLoc] -> ShowS Source #
Outputable SrcLoc # |
Methods ppr :: SrcLoc -> SDoc # pprPrec :: Rational -> SrcLoc -> SDoc #

data RealSrcLoc #

Real Source Location

Represents a single point within a file

Instances

Eq RealSrcLoc # |
Methods (==) :: RealSrcLoc -> RealSrcLoc -> Bool # (/=) :: RealSrcLoc -> RealSrcLoc -> Bool #
Ord RealSrcLoc # |
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 # |
Methods showsPrec :: Int -> RealSrcLoc -> ShowS Source # show :: RealSrcLoc -> String Source # showList :: [RealSrcLoc] -> ShowS Source #
Outputable RealSrcLoc # |
Methods ppr :: RealSrcLoc -> SDoc # pprPrec :: Rational -> RealSrcLoc -> SDoc #

mkSrcLoc :: FastString -> Int -> Int -> SrcLoc #

noSrcLoc :: SrcLoc #

Built-in "bad" `SrcLoc` values for particular locations

srcLocFile :: RealSrcLoc -> FastString #

Gives the filename of the `RealSrcLoc`

srcLocLine :: RealSrcLoc -> Int #

Raises an error when used on a "bad" `SrcLoc`

srcLocCol :: RealSrcLoc -> Int #

Raises an error when used on a "bad" `SrcLoc`

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

Eq SrcSpan # |
Methods (==) :: SrcSpan -> SrcSpan -> Bool # (/=) :: SrcSpan -> SrcSpan -> Bool #
Data SrcSpan # |

Methods

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

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

toConstr :: SrcSpan -> Constr Source #

dataTypeOf :: SrcSpan -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord SrcSpan # |
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 # |
Methods showsPrec :: Int -> SrcSpan -> ShowS Source # show :: SrcSpan -> String Source # showList :: [SrcSpan] -> ShowS Source #
NFData SrcSpan # |
Methods rnf :: SrcSpan -> () Source #
Outputable SrcSpan # |
Methods ppr :: SrcSpan -> SDoc # pprPrec :: Rational -> SrcSpan -> SDoc #
ToJson SrcSpan # |
Methods json :: SrcSpan -> JsonDoc #
Binary SrcSpan # |
Methods put_ :: BinHandle -> SrcSpan -> IO () # put :: BinHandle -> SrcSpan -> IO (Bin * SrcSpan) # get :: BinHandle -> IO SrcSpan #
Binary a => Binary (GenLocated SrcSpan a) # |
Methods put_ :: BinHandle -> GenLocated SrcSpan a -> IO () # put :: BinHandle -> GenLocated SrcSpan a -> IO (Bin * (GenLocated SrcSpan a)) # get :: BinHandle -> IO (GenLocated SrcSpan a) #

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

Eq RealSrcSpan # |
Methods (==) :: RealSrcSpan -> RealSrcSpan -> Bool # (/=) :: RealSrcSpan -> RealSrcSpan -> Bool #
Data RealSrcSpan # |

Methods

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

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

toConstr :: RealSrcSpan -> Constr Source #

dataTypeOf :: RealSrcSpan -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord RealSrcSpan # |
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 # |
Methods showsPrec :: Int -> RealSrcSpan -> ShowS Source # show :: RealSrcSpan -> String Source # showList :: [RealSrcSpan] -> ShowS Source #
Outputable RealSrcSpan # |
Methods ppr :: RealSrcSpan -> SDoc # pprPrec :: Rational -> RealSrcSpan -> SDoc #
ToJson RealSrcSpan # |
Methods json :: RealSrcSpan -> JsonDoc #

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan #

Create a `SrcSpan` between two points in a file

srcLocSpan :: SrcLoc -> SrcSpan #

Create a `SrcSpan` corresponding to a single point

isGoodSrcSpan :: SrcSpan -> Bool #

Test if a `SrcSpan` is "good", i.e. has precise location information

noSrcSpan :: SrcSpan #

Built-in "bad" `SrcSpan`s for common sources of location uncertainty

srcSpanStart :: SrcSpan -> SrcLoc #

Returns the location at the start of the `SrcSpan` or a "bad" `SrcSpan` if that is unavailable

srcSpanEnd :: SrcSpan -> SrcLoc #

Returns the location at the end of the `SrcSpan` or a "bad" `SrcSpan` if that is unavailable

srcSpanFile :: RealSrcSpan -> FastString #

srcSpanStartLine :: RealSrcSpan -> Int #

srcSpanEndLine :: RealSrcSpan -> Int #

srcSpanStartCol :: RealSrcSpan -> Int #

srcSpanEndCol :: RealSrcSpan -> Int #

## Located

data GenLocated l e #

We attach SrcSpans to lots of things, so let's have a datatype for it.

Constructors

L l e |

Instances

Functor (GenLocated l) # |
Methods fmap :: (a -> b) -> GenLocated l a -> GenLocated l b Source # (<$) :: a -> GenLocated l b -> GenLocated l a Source #
Foldable (GenLocated l) # |

Methods

fold :: Monoid m => GenLocated l m -> m Source #

foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m Source #

foldr :: (a -> b -> b) -> b -> GenLocated l a -> b Source #

foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b Source #

foldl :: (b -> a -> b) -> b -> GenLocated l a -> b Source #

foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b Source #

foldr1 :: (a -> a -> a) -> GenLocated l a -> a Source #

foldl1 :: (a -> a -> a) -> GenLocated l a -> a Source #

toList :: GenLocated l a -> [a] Source #

null :: GenLocated l a -> Bool Source #

length :: GenLocated l a -> Int Source #

elem :: Eq a => a -> GenLocated l a -> Bool Source #

maximum :: Ord a => GenLocated l a -> a Source #

minimum :: Ord a => GenLocated l a -> a Source #

sum :: Num a => GenLocated l a -> a Source #

product :: Num a => GenLocated l a -> a Source #

Traversable (GenLocated l) # |
Methods traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b) Source # sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a) Source # mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b) Source # sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a) Source #
(Eq e, Eq l) => Eq (GenLocated l e) # |
Methods (==) :: GenLocated l e -> GenLocated l e -> Bool # (/=) :: GenLocated l e -> GenLocated l e -> Bool #
(Data e, Data l) => Data (GenLocated l e) # |

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e) Source #

toConstr :: GenLocated l e -> Constr Source #

dataTypeOf :: GenLocated l e -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d a. (Data d, Data a) => c (t d a)) -> Maybe (c (GenLocated l e)) Source #

gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> GenLocated l e -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) Source #

(Ord e, Ord l) => Ord (GenLocated l e) # |
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 l, Outputable e) => Outputable (GenLocated l e) # |
Methods ppr :: GenLocated l e -> SDoc # pprPrec :: Rational -> GenLocated l e -> SDoc #
Binary a => Binary (GenLocated SrcSpan a) # |
Methods put_ :: BinHandle -> GenLocated SrcSpan a -> IO () # put :: BinHandle -> GenLocated SrcSpan a -> IO (Bin * (GenLocated SrcSpan a)) # get :: BinHandle -> IO (GenLocated SrcSpan a) #
NamedThing e => NamedThing (GenLocated l e) # |
Methods getOccName :: GenLocated l e -> OccName # getName :: GenLocated l e -> Name #

type Located e = GenLocated SrcSpan e #

### Constructing Located

noLoc :: e -> Located e #

mkGeneralLocated :: String -> e -> Located e #

### Deconstructing Located

getLoc :: GenLocated l e -> l #

unLoc :: GenLocated l e -> e #

### Combining and comparing Located values

eqLocated :: Eq a => Located a -> Located a -> Bool #

Tests whether the two located things are equal

cmpLocated :: Ord a => Located a -> Located a -> Ordering #

Tests the ordering of the two located things

combineLocs :: Located a -> Located b -> SrcSpan #

addCLoc :: Located a -> Located b -> c -> Located c #

Combine locations from two `Located` things and add them to a third thing

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering `SrcSpan`s

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering `SrcSpan`s

rightmost :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering `SrcSpan`s

spans :: SrcSpan -> (Int, Int) -> Bool #

Determines whether a span encloses a given line and column index

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

# Exceptions

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

Show GhcException # |
Methods showsPrec :: Int -> GhcException -> ShowS Source # show :: GhcException -> String Source # showList :: [GhcException] -> ShowS Source #
Exception GhcException # |
Methods toException :: GhcException -> SomeException Source # fromException :: SomeException -> Maybe GhcException Source # displayException :: GhcException -> String Source #

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.

# Token stream manipulations

data Token #

Instances

Show Token # |
Methods showsPrec :: Int -> Token -> ShowS Source # show :: Token -> String Source # showList :: [Token] -> ShowS Source #
Outputable Token # |
Methods ppr :: Token -> SDoc # pprPrec :: Rational -> Token -> SDoc #

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.

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

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.

# Pure interface to the parser

parser #

Arguments

:: String | Haskell module source text (full Unicode is supported)
-> DynFlags | the flags
-> FilePath | the filename (for source locations)
-> Either ErrorMessages (WarningMessages, Located (HsModule RdrName)) |

A pure interface to the module parser.

# API Annotations

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://ghc.haskell.org/trac/ghc/wiki/ApiAnnotations

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 | '~'
AnnTildehsh | `~#`
AnnType |
AnnUnit | '()' for types
AnnUsing |
AnnVal | e.g. INTEGER
AnnValStr | String value, will need quotes when output
AnnVbar | '|'
AnnWhere |
Annlarrowtail | `-<`
AnnlarrowtailU | `-<`, unicode variant
Annrarrowtail | '->'
AnnrarrowtailU | '->', unicode variant
AnnLarrowtail | `-<<`
AnnLarrowtailU | `-<<`, unicode variant
AnnRarrowtail | `>>-`
AnnRarrowtailU | `>>-`, unicode variant
AnnEofPos |

Instances

Eq AnnKeywordId # |
Methods (==) :: AnnKeywordId -> AnnKeywordId -> Bool # (/=) :: AnnKeywordId -> AnnKeywordId -> Bool #
Data AnnKeywordId # |

Methods

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

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

toConstr :: AnnKeywordId -> Constr Source #

dataTypeOf :: AnnKeywordId -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord AnnKeywordId # |
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 # |
Methods showsPrec :: Int -> AnnKeywordId -> ShowS Source # show :: AnnKeywordId -> String Source # showList :: [AnnKeywordId] -> ShowS Source #
Outputable AnnKeywordId # |
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

Eq AnnotationComment # |
Methods (==) :: AnnotationComment -> AnnotationComment -> Bool # (/=) :: AnnotationComment -> AnnotationComment -> Bool #
Data AnnotationComment # |

Methods

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

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

toConstr :: AnnotationComment -> Constr Source #

dataTypeOf :: AnnotationComment -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord AnnotationComment # |

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 # |
Methods showsPrec :: Int -> AnnotationComment -> ShowS Source # show :: AnnotationComment -> String Source # showList :: [AnnotationComment] -> ShowS Source #
Outputable AnnotationComment # |
Methods ppr :: AnnotationComment -> SDoc # pprPrec :: Rational -> AnnotationComment -> SDoc #

getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan] #

Retrieve a list of annotation `SrcSpan`s based on the `SrcSpan` of the annotated AST element, and the known type of the annotation.

getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns) #

Retrieve a list of annotation `SrcSpan`s based on the `SrcSpan` of the annotated AST element, and the known type of the annotation. The list is removed 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

getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns) #

Retrieve the comments allocated to the current `SrcSpan`, and remove them from the annotations

unicodeAnn :: AnnKeywordId -> AnnKeywordId #

Convert a normal annotation into its unicode equivalent one

# Miscellaneous

cyclicModuleErr :: [ModSummary] -> SDoc #