ghc-7.0.4: The GHC API

GHC

Contents

- Initialisation
- GHC Monad
- Flags and settings
- Targets
- Loading/compiling the program
- Inspecting the module structure of the program
- Inspecting modules
- Querying the environment
- Printing
- Interactive evaluation
- 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
- Miscellaneous

Synopsis

- defaultErrorHandler :: (ExceptionMonad m, MonadIO m) => DynFlags -> m a -> m a
- defaultCleanupHandler :: (ExceptionMonad m, MonadIO m) => DynFlags -> m a -> m a
- data Ghc a
- data GhcT m a
- class (Functor m, MonadIO m, WarnLogMonad m, ExceptionMonad m) => GhcMonad m where
  - getSession :: m HscEnv
  - setSession :: HscEnv -> m ()
- runGhc :: Maybe FilePath -> Ghc a -> IO a
- runGhcT :: (ExceptionMonad m, Functor m, MonadIO 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
- clearWarnings :: WarnLogMonad m => m ()
- getWarnings :: WarnLogMonad m => m WarningMessages
- hasWarnings :: WarnLogMonad m => m Bool
- printExceptionAndWarnings :: GhcMonad m => SourceError -> m ()
- printWarnings :: GhcMonad m => m ()
- handleSourceError :: ExceptionMonad m => (SourceError -> m a) -> m a -> m a
- defaultCallbacks :: GhcApiCallbacks
- data GhcApiCallbacks = GhcApiCallbacks {
  - reportModuleCompilationResult :: GhcMonad m => ModSummary -> Maybe SourceError -> m ()
  }
- needsTemplateHaskell :: ModuleGraph -> Bool
- data DynFlags = DynFlags {
  - ghcMode :: GhcMode
  - ghcLink :: GhcLink
  - hscTarget :: HscTarget
  - hscOutName :: String
  - extCoreName :: String
  - verbosity :: Int
  - optLevel :: Int
  - simplPhases :: Int
  - maxSimplIterations :: Int
  - shouldDumpSimplPhase :: Maybe String
  - ruleCheck :: Maybe String
  - strictnessBefore :: [Int]
  - specConstrThreshold :: Maybe Int
  - specConstrCount :: Maybe Int
  - liberateCaseThreshold :: Maybe Int
  - floatLamArgs :: Maybe Int
  - targetPlatform :: Platform
  - stolen_x86_regs :: Int
  - cmdlineHcIncludes :: [String]
  - importPaths :: [FilePath]
  - mainModIs :: Module
  - mainFunIs :: Maybe String
  - ctxtStkDepth :: Int
  - dphBackend :: DPHBackend
  - thisPackage :: PackageId
  - ways :: [Way]
  - buildTag :: String
  - rtsBuildTag :: String
  - splitInfo :: Maybe (String, Int)
  - objectDir :: Maybe String
  - dylibInstallName :: Maybe String
  - hiDir :: Maybe String
  - stubDir :: Maybe String
  - objectSuf :: String
  - hcSuf :: String
  - hiSuf :: String
  - outputFile :: Maybe String
  - outputHi :: Maybe String
  - dynLibLoader :: DynLibLoader
  - dumpPrefix :: Maybe FilePath
  - dumpPrefixForce :: Maybe FilePath
  - includePaths :: [String]
  - libraryPaths :: [String]
  - frameworkPaths :: [String]
  - cmdlineFrameworks :: [String]
  - tmpDir :: String
  - ghcUsagePath :: FilePath
  - ghciUsagePath :: FilePath
  - rtsOpts :: Maybe String
  - rtsOptsEnabled :: RtsOptsEnabled
  - hpcDir :: String
  - opt_L :: [String]
  - opt_P :: [String]
  - opt_F :: [String]
  - opt_c :: [String]
  - opt_m :: [String]
  - opt_a :: [String]
  - opt_l :: [String]
  - opt_windres :: [String]
  - opt_lo :: [String]
  - opt_lc :: [String]
  - pgm_L :: String
  - pgm_P :: (String, [Option])
  - pgm_F :: String
  - pgm_c :: (String, [Option])
  - pgm_m :: (String, [Option])
  - pgm_s :: (String, [Option])
  - pgm_a :: (String, [Option])
  - pgm_l :: (String, [Option])
  - pgm_dll :: (String, [Option])
  - pgm_T :: String
  - pgm_sysman :: String
  - pgm_windres :: String
  - pgm_lo :: (String, [Option])
  - pgm_lc :: (String, [Option])
  - depMakefile :: FilePath
  - depIncludePkgDeps :: Bool
  - depExcludeMods :: [ModuleName]
  - depSuffixes :: [String]
  - extraPkgConfs :: [FilePath]
  - topDir :: FilePath
  - systemPackageConfig :: FilePath
  - packageFlags :: [PackageFlag]
  - pkgDatabase :: Maybe [PackageConfig]
  - pkgState :: PackageState
  - filesToClean :: IORef [FilePath]
  - dirsToClean :: IORef (Map FilePath FilePath)
  - flags :: [DynFlag]
  - language :: Maybe Language
  - extensions :: [OnOff ExtensionFlag]
  - extensionFlags :: [ExtensionFlag]
  - log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO ()
  - haddockOptions :: Maybe String
  }
- data DynFlag
  - = Opt_D_dump_cmm
  - | Opt_D_dump_cmmz
  - | Opt_D_dump_cmmz_pretty
  - | Opt_D_dump_cps_cmm
  - | Opt_D_dump_cvt_cmm
  - | Opt_D_dump_asm
  - | Opt_D_dump_asm_native
  - | Opt_D_dump_asm_liveness
  - | Opt_D_dump_asm_coalesce
  - | Opt_D_dump_asm_regalloc
  - | Opt_D_dump_asm_regalloc_stages
  - | Opt_D_dump_asm_conflicts
  - | Opt_D_dump_asm_stats
  - | Opt_D_dump_asm_expanded
  - | Opt_D_dump_llvm
  - | Opt_D_dump_cpranal
  - | Opt_D_dump_deriv
  - | Opt_D_dump_ds
  - | Opt_D_dump_flatC
  - | Opt_D_dump_foreign
  - | Opt_D_dump_inlinings
  - | Opt_D_dump_rule_firings
  - | Opt_D_dump_occur_anal
  - | Opt_D_dump_parsed
  - | Opt_D_dump_rn
  - | Opt_D_dump_simpl
  - | Opt_D_dump_simpl_iterations
  - | Opt_D_dump_simpl_phases
  - | Opt_D_dump_spec
  - | Opt_D_dump_prep
  - | Opt_D_dump_stg
  - | Opt_D_dump_stranal
  - | Opt_D_dump_tc
  - | Opt_D_dump_types
  - | Opt_D_dump_rules
  - | Opt_D_dump_cse
  - | Opt_D_dump_worker_wrapper
  - | Opt_D_dump_rn_trace
  - | Opt_D_dump_rn_stats
  - | Opt_D_dump_opt_cmm
  - | Opt_D_dump_simpl_stats
  - | Opt_D_dump_cs_trace
  - | Opt_D_dump_tc_trace
  - | Opt_D_dump_if_trace
  - | Opt_D_dump_splices
  - | Opt_D_dump_BCOs
  - | Opt_D_dump_vect
  - | Opt_D_dump_hpc
  - | Opt_D_dump_rtti
  - | Opt_D_source_stats
  - | Opt_D_verbose_core2core
  - | Opt_D_verbose_stg2stg
  - | Opt_D_dump_hi
  - | Opt_D_dump_hi_diffs
  - | Opt_D_dump_minimal_imports
  - | Opt_D_dump_mod_cycles
  - | Opt_D_dump_view_pattern_commoning
  - | Opt_D_faststring_stats
  - | Opt_DumpToFile
  - | Opt_D_no_debug_output
  - | Opt_DoCoreLinting
  - | Opt_DoStgLinting
  - | Opt_DoCmmLinting
  - | Opt_DoAsmLinting
  - | Opt_WarnIsError
  - | Opt_WarnDuplicateExports
  - | Opt_WarnHiShadows
  - | Opt_WarnImplicitPrelude
  - | Opt_WarnIncompletePatterns
  - | Opt_WarnIncompletePatternsRecUpd
  - | Opt_WarnMissingFields
  - | Opt_WarnMissingImportList
  - | Opt_WarnMissingMethods
  - | Opt_WarnMissingSigs
  - | Opt_WarnMissingLocalSigs
  - | Opt_WarnNameShadowing
  - | Opt_WarnOverlappingPatterns
  - | Opt_WarnTypeDefaults
  - | Opt_WarnMonomorphism
  - | Opt_WarnUnusedBinds
  - | Opt_WarnUnusedImports
  - | Opt_WarnUnusedMatches
  - | Opt_WarnWarningsDeprecations
  - | Opt_WarnDeprecatedFlags
  - | Opt_WarnDodgyExports
  - | Opt_WarnDodgyImports
  - | Opt_WarnOrphans
  - | Opt_WarnAutoOrphans
  - | Opt_WarnTabs
  - | Opt_WarnUnrecognisedPragmas
  - | Opt_WarnDodgyForeignImports
  - | Opt_WarnLazyUnliftedBindings
  - | Opt_WarnUnusedDoBind
  - | Opt_WarnWrongDoBind
  - | Opt_WarnAlternativeLayoutRuleTransitional
  - | Opt_PrintExplicitForalls
  - | Opt_Strictness
  - | Opt_FullLaziness
  - | Opt_FloatIn
  - | Opt_Specialise
  - | Opt_StaticArgumentTransformation
  - | Opt_CSE
  - | Opt_LiberateCase
  - | Opt_SpecConstr
  - | Opt_DoLambdaEtaExpansion
  - | Opt_IgnoreAsserts
  - | Opt_DoEtaReduction
  - | Opt_CaseMerge
  - | Opt_UnboxStrictFields
  - | Opt_MethodSharing
  - | Opt_DictsCheap
  - | Opt_EnableRewriteRules
  - | Opt_Vectorise
  - | Opt_RegsGraph
  - | Opt_RegsIterative
  - | Opt_IgnoreInterfacePragmas
  - | Opt_OmitInterfacePragmas
  - | Opt_ExposeAllUnfoldings
  - | Opt_AutoSccsOnAllToplevs
  - | Opt_AutoSccsOnExportedToplevs
  - | Opt_AutoSccsOnIndividualCafs
  - | Opt_Pp
  - | Opt_ForceRecomp
  - | Opt_DryRun
  - | Opt_DoAsmMangling
  - | Opt_ExcessPrecision
  - | Opt_EagerBlackHoling
  - | Opt_ReadUserPackageConf
  - | Opt_NoHsMain
  - | Opt_SplitObjs
  - | Opt_StgStats
  - | Opt_HideAllPackages
  - | Opt_PrintBindResult
  - | Opt_Haddock
  - | Opt_HaddockOptions
  - | Opt_Hpc_No_Auto
  - | Opt_BreakOnException
  - | Opt_BreakOnError
  - | Opt_PrintEvldWithShow
  - | Opt_PrintBindContents
  - | Opt_GenManifest
  - | Opt_EmbedManifest
  - | Opt_EmitExternalCore
  - | Opt_SharedImplib
  - | Opt_BuildingCabalPackage
  - | Opt_SSE2
  - | Opt_GhciSandbox
  - | Opt_RunCPS
  - | Opt_RunCPSZ
  - | Opt_ConvertToZipCfgAndBack
  - | Opt_AutoLinkPackages
  - | Opt_ImplicitImportQualified
  - | Opt_TryNewCodeGen
  - | Opt_KeepHiDiffs
  - | Opt_KeepHcFiles
  - | Opt_KeepSFiles
  - | Opt_KeepRawSFiles
  - | Opt_KeepTmpFiles
  - | Opt_KeepRawTokenStream
  - | Opt_KeepLlvmFiles
- data Severity
  - = SevOutput
  - | SevInfo
  - | SevWarning
  - | SevError
  - | SevFatal
- data HscTarget
  - = HscC
  - | HscAsm
  - | HscLlvm
  - | HscJava
  - | HscInterpreted
  - | HscNothing
- dopt :: DynFlag -> DynFlags -> Bool
- data GhcMode
  - = CompManager
  - | OneShot
  - | MkDepend
- data GhcLink
  - = NoLink
  - | LinkBinary
  - | LinkInMemory
  - | LinkDynLib
- defaultObjectTarget :: HscTarget
- parseDynamicFlags :: Monad m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])
- getSessionDynFlags :: GhcMonad m => m DynFlags
- setSessionDynFlags :: GhcMonad m => DynFlags -> m [PackageId]
- parseStaticFlags :: [Located String] -> IO ([Located String], [Located String])
- data Target = Target {
  - targetId :: TargetId
  - targetAllowObjCode :: Bool
  - targetContents :: Maybe (StringBuffer, ClockTime)
  }
- 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
- loadWithLogger :: GhcMonad m => WarnErrLogger -> LoadHowMuch -> m SuccessFlag
- data LoadHowMuch
  - = LoadAllTargets
  - | LoadUpTo ModuleName
  - | LoadDependenciesOf ModuleName
- data SuccessFlag
  - = Succeeded
  - | Failed
- succeeded :: SuccessFlag -> Bool
- failed :: SuccessFlag -> Bool
- defaultWarnErrLogger :: WarnErrLogger
- type WarnErrLogger = 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
  }
- 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
  - renamedSource :: m -> Maybe RenamedSource
  - typecheckedSource :: m -> TypecheckedSource
  - moduleInfo :: m -> ModuleInfo
- class ParsedMod m where
  - parsedSource :: m -> ParsedSource
- coreModule :: DesugaredMod m => m -> ModGuts
- compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule
- compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule
- compileCoreToObj :: GhcMonad m => Bool -> CoreModule -> m ()
- getModSummary :: GhcMonad m => ModuleName -> m ModSummary
- type ModuleGraph = [ModSummary]
- data ModSummary = ModSummary {
  - ms_mod :: Module
  - ms_hsc_src :: HscSource
  - ms_location :: ModLocation
  - ms_hs_date :: ClockTime
  - ms_obj_date :: Maybe ClockTime
  - ms_srcimps :: [Located (ImportDecl RdrName)]
  - ms_imps :: [Located (ImportDecl RdrName)]
  - 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
  }
- 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]
- modInfoInstances :: ModuleInfo -> [Instance]
- modInfoIsExportedName :: ModuleInfo -> Name -> Bool
- modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing)
- 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)
- packageDbModules :: GhcMonad m => Bool -> m [Module]
- type PrintUnqualified = (QueryQualifyName, QueryQualifyModule)
- alwaysQualify :: PrintUnqualified
- getBindings :: GhcMonad m => m [TyThing]
- getPrintUnqual :: GhcMonad m => m PrintUnqualified
- findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
- lookupModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
- setContext :: GhcMonad m => [Module] -> [(Module, Maybe (ImportDecl RdrName))] -> m ()
- getContext :: GhcMonad m => m ([Module], [(Module, Maybe (ImportDecl RdrName))])
- getNamesInScope :: GhcMonad m => m [Name]
- getRdrNamesInScope :: GhcMonad m => m [RdrName]
- getGRE :: GhcMonad m => m GlobalRdrEnv
- moduleIsInterpreted :: GhcMonad m => Module -> m Bool
- getInfo :: GhcMonad m => Name -> m (Maybe (TyThing, Fixity, [Instance]))
- exprType :: GhcMonad m => String -> m Type
- typeKind :: GhcMonad m => String -> m Kind
- parseName :: GhcMonad m => String -> m [Name]
- data RunResult
  - = RunOk [Name]
  - | RunFailed
  - | RunException SomeException
  - | RunBreak ThreadId [Name] (Maybe BreakInfo)
- runStmt :: GhcMonad m => String -> SingleStep -> m RunResult
- parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
- data SingleStep
  - = RunToCompletion
  - | SingleStep
  - | RunAndLogSteps
- resume :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> m RunResult
- data Resume
- data History
- getHistorySpan :: GhcMonad m => History -> m SrcSpan
- getHistoryModule :: History -> Module
- getResumeContext :: GhcMonad m => m [Resume]
- abandon :: GhcMonad m => m Bool
- abandonAll :: GhcMonad m => m Bool
- back :: GhcMonad m => m ([Name], Int, SrcSpan)
- forward :: GhcMonad m => m ([Name], Int, SrcSpan)
- showModule :: GhcMonad m => ModSummary -> m String
- isModuleInterpreted :: GhcMonad m => ModSummary -> m Bool
- compileExpr :: GhcMonad m => String -> m HValue
- data HValue
- dynCompileExpr :: GhcMonad m => String -> m Dynamic
- 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 :: BreakArray
  - modBreaks_locs :: !(Array BreakIndex SrcSpan)
  - modBreaks_vars :: !(Array BreakIndex [OccName])
  }
- type BreakIndex = Int
- data BreakInfo
- data BreakArray
- setBreakOn :: BreakArray -> Int -> IO Bool
- setBreakOff :: BreakArray -> Int -> IO Bool
- getBreak :: BreakArray -> Int -> IO (Maybe Word)
- lookupName :: GhcMonad m => Name -> m (Maybe TyThing)
- data PackageId
- data Module
- mkModule :: PackageId -> ModuleName -> Module
- pprModule :: Module -> SDoc
- moduleName :: Module -> ModuleName
- modulePackageId :: Module -> PackageId
- 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
  - getOccName :: a -> OccName
  - getName :: a -> Name
- 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 :: Id -> Bool
- isDictonaryId :: Id -> Bool
- recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)
- data TyCon
- tyConTyVars :: TyCon -> [TyVar]
- tyConDataCons :: TyCon -> [DataCon]
- tyConArity :: TyCon -> Arity
- isClassTyCon :: TyCon -> Bool
- isSynTyCon :: TyCon -> Bool
- isNewTyCon :: TyCon -> Bool
- isPrimTyCon :: TyCon -> Bool
- isFunTyCon :: TyCon -> Bool
- isFamilyTyCon :: TyCon -> Bool
- synTyConDefn :: TyCon -> ([TyVar], Type)
- synTyConType :: TyCon -> Type
- synTyConResKind :: 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
- dataConStrictMarks :: DataCon -> [HsBang]
- data StrictnessMark
  - = MarkedStrict
  - | NotMarkedStrict
- isMarkedStrict :: StrictnessMark -> Bool
- data Class
- classMethods :: Class -> [Id]
- classSCTheta :: Class -> [PredType]
- classTvsFds :: Class -> ([TyVar], [FunDep TyVar])
- pprFundeps :: Outputable a => [FunDep a] -> SDoc
- data Instance
- instanceDFunId :: Instance -> DFunId
- pprInstance :: Instance -> SDoc
- pprInstanceHdr :: Instance -> SDoc
- data Type
- splitForAllTys :: Type -> ([TyVar], Type)
- funResultTy :: Type -> Type
- pprParendType :: Type -> SDoc
- pprTypeApp :: NamedThing a => a -> [Type] -> SDoc
- type Kind = Type
- data PredType
- type ThetaType = [PredType]
- pprForAll :: [TyVar] -> SDoc
- pprThetaArrow :: ThetaType -> SDoc
- data TyThing
  - = AnId Id
  - | ADataCon DataCon
  - | ATyCon TyCon
  - | AClass Class
- module HsSyn
- data FixityDirection
  - = InfixL
  - | InfixR
  - | InfixN
- defaultFixity :: Fixity
- maxPrecedence :: Int
- negateFixity :: Fixity
- compareFixity :: Fixity -> Fixity -> (Bool, Bool)
- data SrcLoc
- pprDefnLoc :: SrcSpan -> SDoc
- mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
- isGoodSrcLoc :: SrcLoc -> Bool
- noSrcLoc :: SrcLoc
- srcLocFile :: SrcLoc -> FastString
- srcLocLine :: SrcLoc -> Int
- srcLocCol :: SrcLoc -> Int
- data SrcSpan
- mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
- srcLocSpan :: SrcLoc -> SrcSpan
- isGoodSrcSpan :: SrcSpan -> Bool
- noSrcSpan :: SrcSpan
- srcSpanStart :: SrcSpan -> SrcLoc
- srcSpanEnd :: SrcSpan -> SrcLoc
- srcSpanFile :: SrcSpan -> FastString
- srcSpanStartLine :: SrcSpan -> Int
- srcSpanEndLine :: SrcSpan -> Int
- srcSpanStartCol :: SrcSpan -> Int
- srcSpanEndCol :: SrcSpan -> Int
- data Located e = L SrcSpan e
- noLoc :: e -> Located e
- mkGeneralLocated :: String -> e -> Located e
- getLoc :: Located e -> SrcSpan
- unLoc :: Located 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
  - = PhaseFailed String ExitCode
  - | Signal Int
  - | UsageError String
  - | CmdLineError String
  - | Panic String
  - | Sorry String
  - | InstallationError String
  - | ProgramError String
- showGhcException :: GhcException -> String -> String
- data Token
- getTokenStream :: GhcMonad m => Module -> m [Located Token]
- getRichTokenStream :: GhcMonad m => Module -> m [(Located Token, String)]
- showRichTokenStream :: [(Located Token, String)] -> String
- addSourceToTokens :: SrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)]
- cyclicModuleErr :: [ModSummary] -> SDoc

# Initialisation

defaultErrorHandler :: (ExceptionMonad m, MonadIO m) => DynFlags -> m a -> m aSource

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, MonadIO m) => DynFlags -> m a -> m aSource

Install a default cleanup handler to remove temporary files deposited by a GHC run. This is seperate from `defaultErrorHandler`, because you might want to override the error handling, but still get the ordinary cleanup behaviour.

# GHC Monad

data Ghc a Source

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 |
Functor Ghc |
ExceptionMonad Ghc |
MonadIO Ghc |
GhcMonad Ghc |
WarnLogMonad Ghc |

data GhcT m a Source

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) |
Functor m => Functor (GhcT m) |
ExceptionMonad m => ExceptionMonad (GhcT m) |
MonadIO m => MonadIO (GhcT m) |
(Functor m, ExceptionMonad m, MonadIO m) => GhcMonad (GhcT m) |
MonadIO m => WarnLogMonad (GhcT m) |

class (Functor m, MonadIO m, WarnLogMonad m, ExceptionMonad m) => GhcMonad m where Source

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 `GHC.initGhcMonad` before any call to the GHC API functions can occur.

Methods

getSession :: m HscEnv Source

setSession :: HscEnv -> m ()Source

Instances

GhcMonad Ghc |
(Functor m, ExceptionMonad m, MonadIO m) => GhcMonad (GhcT m) |

runGhcSource

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.

runGhcTSource

Arguments

:: (ExceptionMonad m, Functor m, MonadIO 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 ()Source

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/cgi-bin/hackage-scripts/package/ghc-paths.

gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m aSource

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 cSource

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

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

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

clearWarnings :: WarnLogMonad m => m ()Source

Clear the log of `Warnings`.

getWarnings :: WarnLogMonad m => m WarningMessages Source

hasWarnings :: WarnLogMonad m => m Bool Source

Returns true if there were any warnings.

printExceptionAndWarnings :: GhcMonad m => SourceError -> m ()Source

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

printWarnings :: GhcMonad m => m ()Source

Print all accumulated warnings using `log_action`.

handleSourceErrorSource

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.

defaultCallbacks :: GhcApiCallbacks Source

data GhcApiCallbacks Source

These functions are called in various places of the GHC API.

API clients can override any of these callbacks to change GHC's default behaviour.

Constructors

GhcApiCallbacks |

Fields

reportModuleCompilationResult :: GhcMonad m => ModSummary -> Maybe SourceError -> m ()

  Called by `load` after the compilating of each module.

  The default implementation simply prints all warnings and errors to `stderr`. Don't forget to call `clearWarnings` when implementing your own call.

  The first argument is the module that was compiled.

  The second argument is `Nothing` if no errors occured, but there may have been warnings. If it is `Just err` at least one error has occured. If `srcErrorMessages` is empty, compilation failed due to `-Werror`.

needsTemplateHaskell :: ModuleGraph -> Bool Source

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 Source

Contains not only a collection of `DynFlag`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
hscOutName :: String

  Name of the output file

extCoreName :: String

  Name of the .hcr output file

verbosity :: Int

  Verbosity level: see Note [Verbosity levels]

optLevel :: Int

  Optimisation level

simplPhases :: Int

  Number of simplifier phases

maxSimplIterations :: Int

  Max simplifier iterations

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

  Additional demand analysis

specConstrThreshold :: Maybe Int

  Threshold for SpecConstr

specConstrCount :: Maybe Int

  Max number of specialisations for any one function

liberateCaseThreshold :: Maybe Int

  Threshold for LiberateCase

floatLamArgs :: Maybe Int

  Arg count for lambda floating See CoreMonad.FloatOutSwitches

targetPlatform :: Platform

  The platform we're compiling for. Used by the NCG.

stolen_x86_regs :: Int
cmdlineHcIncludes :: [String]

      -#includes

importPaths :: [FilePath]
mainModIs :: Module
mainFunIs :: Maybe String
ctxtStkDepth :: Int

  Typechecker context stack depth

dphBackend :: DPHBackend
thisPackage :: PackageId

  name of package currently being compiled

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
objectSuf :: String
hcSuf :: String
hiSuf :: String
outputFile :: Maybe String
outputHi :: Maybe String
dynLibLoader :: DynLibLoader
dumpPrefix :: Maybe FilePath

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

dumpPrefixForce :: Maybe FilePath

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

includePaths :: [String]
libraryPaths :: [String]
frameworkPaths :: [String]
cmdlineFrameworks :: [String]
tmpDir :: String
ghcUsagePath :: FilePath
ghciUsagePath :: FilePath
rtsOpts :: Maybe String
rtsOptsEnabled :: RtsOptsEnabled
hpcDir :: String

  Path to store the .mix files

opt_L :: [String]
opt_P :: [String]
opt_F :: [String]
opt_c :: [String]
opt_m :: [String]
opt_a :: [String]
opt_l :: [String]
opt_windres :: [String]
opt_lo :: [String]
opt_lc :: [String]
pgm_L :: String
pgm_P :: (String, [Option])
pgm_F :: String
pgm_c :: (String, [Option])
pgm_m :: (String, [Option])
pgm_s :: (String, [Option])
pgm_a :: (String, [Option])
pgm_l :: (String, [Option])
pgm_dll :: (String, [Option])
pgm_T :: String
pgm_sysman :: String
pgm_windres :: String
pgm_lo :: (String, [Option])
pgm_lc :: (String, [Option])
depMakefile :: FilePath
depIncludePkgDeps :: Bool
depExcludeMods :: [ModuleName]
depSuffixes :: [String]
extraPkgConfs :: [FilePath]
topDir :: FilePath
systemPackageConfig :: FilePath

  The `-package-conf` flags given on the command line, in the order they appeared.

packageFlags :: [PackageFlag]

  The `-package` and `-hide-package` flags from the command-line

pkgDatabase :: Maybe [PackageConfig]
pkgState :: PackageState
filesToClean :: IORef [FilePath]
dirsToClean :: IORef (Map FilePath FilePath)
flags :: [DynFlag]
language :: Maybe Language
extensions :: [OnOff ExtensionFlag]
extensionFlags :: [ExtensionFlag]
log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO ()

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

haddockOptions :: Maybe String

data DynFlag Source

Enumerates the simple on-or-off dynamic flags

Constructors

Opt_D_dump_cmm |
Opt_D_dump_cmmz |
Opt_D_dump_cmmz_pretty |
Opt_D_dump_cps_cmm |
Opt_D_dump_cvt_cmm |
Opt_D_dump_asm |
Opt_D_dump_asm_native |
Opt_D_dump_asm_liveness |
Opt_D_dump_asm_coalesce |
Opt_D_dump_asm_regalloc |
Opt_D_dump_asm_regalloc_stages |
Opt_D_dump_asm_conflicts |
Opt_D_dump_asm_stats |
Opt_D_dump_asm_expanded |
Opt_D_dump_llvm |
Opt_D_dump_cpranal |
Opt_D_dump_deriv |
Opt_D_dump_ds |
Opt_D_dump_flatC |
Opt_D_dump_foreign |
Opt_D_dump_inlinings |
Opt_D_dump_rule_firings |
Opt_D_dump_occur_anal |
Opt_D_dump_parsed |
Opt_D_dump_rn |
Opt_D_dump_simpl |
Opt_D_dump_simpl_iterations |
Opt_D_dump_simpl_phases |
Opt_D_dump_spec |
Opt_D_dump_prep |
Opt_D_dump_stg |
Opt_D_dump_stranal |
Opt_D_dump_tc |
Opt_D_dump_types |
Opt_D_dump_rules |
Opt_D_dump_cse |
Opt_D_dump_worker_wrapper |
Opt_D_dump_rn_trace |
Opt_D_dump_rn_stats |
Opt_D_dump_opt_cmm |
Opt_D_dump_simpl_stats |
Opt_D_dump_cs_trace |
Opt_D_dump_tc_trace |
Opt_D_dump_if_trace |
Opt_D_dump_splices |
Opt_D_dump_BCOs |
Opt_D_dump_vect |
Opt_D_dump_hpc |
Opt_D_dump_rtti |
Opt_D_source_stats |
Opt_D_verbose_core2core |
Opt_D_verbose_stg2stg |
Opt_D_dump_hi |
Opt_D_dump_hi_diffs |
Opt_D_dump_minimal_imports |
Opt_D_dump_mod_cycles |
Opt_D_dump_view_pattern_commoning |
Opt_D_faststring_stats |
Opt_DumpToFile | Append dump output to files instead of stdout.
Opt_D_no_debug_output |
Opt_DoCoreLinting |
Opt_DoStgLinting |
Opt_DoCmmLinting |
Opt_DoAsmLinting |
Opt_WarnIsError |
Opt_WarnDuplicateExports |
Opt_WarnHiShadows |
Opt_WarnImplicitPrelude |
Opt_WarnIncompletePatterns |
Opt_WarnIncompletePatternsRecUpd |
Opt_WarnMissingFields |
Opt_WarnMissingImportList |
Opt_WarnMissingMethods |
Opt_WarnMissingSigs |
Opt_WarnMissingLocalSigs |
Opt_WarnNameShadowing |
Opt_WarnOverlappingPatterns |
Opt_WarnTypeDefaults |
Opt_WarnMonomorphism |
Opt_WarnUnusedBinds |
Opt_WarnUnusedImports |
Opt_WarnUnusedMatches |
Opt_WarnWarningsDeprecations |
Opt_WarnDeprecatedFlags |
Opt_WarnDodgyExports |
Opt_WarnDodgyImports |
Opt_WarnOrphans |
Opt_WarnAutoOrphans |
Opt_WarnTabs |
Opt_WarnUnrecognisedPragmas |
Opt_WarnDodgyForeignImports |
Opt_WarnLazyUnliftedBindings |
Opt_WarnUnusedDoBind |
Opt_WarnWrongDoBind |
Opt_WarnAlternativeLayoutRuleTransitional |
Opt_PrintExplicitForalls |
Opt_Strictness |
Opt_FullLaziness |
Opt_FloatIn |
Opt_Specialise |
Opt_StaticArgumentTransformation |
Opt_CSE |
Opt_LiberateCase |
Opt_SpecConstr |
Opt_DoLambdaEtaExpansion |
Opt_IgnoreAsserts |
Opt_DoEtaReduction |
Opt_CaseMerge |
Opt_UnboxStrictFields |
Opt_MethodSharing |
Opt_DictsCheap |
Opt_EnableRewriteRules |
Opt_Vectorise |
Opt_RegsGraph |
Opt_RegsIterative |
Opt_IgnoreInterfacePragmas |
Opt_OmitInterfacePragmas |
Opt_ExposeAllUnfoldings |
Opt_AutoSccsOnAllToplevs |
Opt_AutoSccsOnExportedToplevs |
Opt_AutoSccsOnIndividualCafs |
Opt_Pp |
Opt_ForceRecomp |
Opt_DryRun |
Opt_DoAsmMangling |
Opt_ExcessPrecision |
Opt_EagerBlackHoling |
Opt_ReadUserPackageConf |
Opt_NoHsMain |
Opt_SplitObjs |
Opt_StgStats |
Opt_HideAllPackages |
Opt_PrintBindResult |
Opt_Haddock |
Opt_HaddockOptions |
Opt_Hpc_No_Auto |
Opt_BreakOnException |
Opt_BreakOnError |
Opt_PrintEvldWithShow |
Opt_PrintBindContents |
Opt_GenManifest |
Opt_EmbedManifest |
Opt_EmitExternalCore |
Opt_SharedImplib |
Opt_BuildingCabalPackage |
Opt_SSE2 |
Opt_GhciSandbox |
Opt_RunCPS |
Opt_RunCPSZ |
Opt_ConvertToZipCfgAndBack |
Opt_AutoLinkPackages |
Opt_ImplicitImportQualified |
Opt_TryNewCodeGen |
Opt_KeepHiDiffs |
Opt_KeepHcFiles |
Opt_KeepSFiles |
Opt_KeepRawSFiles |
Opt_KeepTmpFiles |
Opt_KeepRawTokenStream |
Opt_KeepLlvmFiles |

Instances

Eq DynFlag |
Show DynFlag |

data Severity Source

Constructors

SevOutput |
SevInfo |
SevWarning |
SevError |
SevFatal |

data HscTarget Source

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:

- This will not run the desugaring step, thus no warnings generated in this step will be output. In particular, this includes warnings related to pattern matching. You can run the desugarer manually using `GHC.desugarModule`.
- 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 `GHC.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 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.
HscJava | Generate Java bytecode.
HscInterpreted | Generate bytecode. (Requires `LinkInMemory`)
HscNothing | Don't generate any code. See notes above.

Instances

Eq HscTarget |
Show HscTarget |

dopt :: DynFlag -> DynFlags -> Bool Source

Test whether a `DynFlag` is set

data GhcMode Source

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 |
Outputable GhcMode |

data GhcLink Source

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)

Instances

Eq GhcLink |
Show GhcLink |

defaultObjectTarget :: HscTarget Source

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

parseDynamicFlagsSource

Arguments

:: Monad m |
=> DynFlags |
-> [Located String] |
-> m (DynFlags, [Located String], [Located String]) | Updated `DynFlags`, left-over arguments, and list of warnings.

Parse dynamic flags from a list of command line arguments. Returns the the parsed `DynFlags`, the left-over arguments, and a list of warnings. Throws a `UsageError` if errors occurred during parsing (such as unknown flags or missing arguments).

getSessionDynFlags :: GhcMonad m => m DynFlags Source

Grabs the DynFlags from the Session

setSessionDynFlags :: GhcMonad m => DynFlags -> m [PackageId]Source

Updates the 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.

parseStaticFlags :: [Located String] -> IO ([Located String], [Located String])Source

Parses GHC's static flags from a list of command line arguments.

These flags are static in the sense that they can be set only once and they are global, meaning that they affect every instance of GHC running; multiple GHC threads will use the same flags.

This function must be called before any session is started, i.e., before the first call to `GHC.withGhc`.

Static flags are more of a hack and are static for more or less historical reasons. In the long run, most static flags should eventually become dynamic flags.

XXX: can we add an auto-generated list of static flags here?

# Targets

data Target Source

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, ClockTime)

  in-memory text buffer?

Instances

Outputable Target |

data TargetId Source

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 |
Outputable TargetId |

data Phase Source

Instances

Eq Phase |
Show Phase |
Outputable Phase |

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

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

Returns the current set of targets

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

Add another target.

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

Remove a target

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

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

depanalSource

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 to changes to the `DynFlags` to take effect you need to call this function again.

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

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`) compilating and loading may result in files being created on disk.

Calls the `reportModuleCompilationResult` callback 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 callback.

loadWithLogger :: GhcMonad m => WarnErrLogger -> LoadHowMuch -> m SuccessFlag Source

Try to load the program. If a Module is supplied, then just attempt to load up to this target. If no Module is supplied, then try to load all targets.

The first argument is a function that is called after compiling each module to print wanrings and errors.

While compiling a module, all `SourceError`s are caught and passed to the logger, however, this function may still throw a `SourceError` if dependency analysis failed (e.g., due to a parse error).

data LoadHowMuch Source

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 SuccessFlag Source

Constructors

Succeeded |
Failed |

Instances

Outputable SuccessFlag |

succeeded :: SuccessFlag -> Bool Source

failed :: SuccessFlag -> Bool Source

defaultWarnErrLogger :: WarnErrLogger Source

type WarnErrLogger = GhcMonad m => Maybe SourceError -> m ()Source

A function called to log warnings and errors.

workingDirectoryChanged :: GhcMonad m => m ()Source

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 Source

Parse a module.

Throws a `SourceError` on parse error.

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

Typecheck and rename a parsed module.

Throws a `SourceError` if either fails.

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

Desugar a typechecked module.

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

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 Source

The result of successful parsing.

Constructors

ParsedModule |

Fields

pm_mod_summary :: ModSummary
pm_parsed_source :: ParsedSource

Instances

ParsedMod ParsedModule |

data TypecheckedModule Source

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 |
ParsedMod TypecheckedModule |

data DesugaredModule Source

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

DesugaredMod DesugaredModule |
TypecheckedMod DesugaredModule |
ParsedMod DesugaredModule |

type TypecheckedSource = LHsBinds Id Source

type ParsedSource = Located (HsModule RdrName)Source

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

class ParsedMod m => TypecheckedMod m where Source

Methods

renamedSource :: m -> Maybe RenamedSource Source

typecheckedSource :: m -> TypecheckedSource Source

moduleInfo :: m -> ModuleInfo Source

Instances

TypecheckedMod DesugaredModule |
TypecheckedMod TypecheckedModule |

class ParsedMod m where Source

Methods

parsedSource :: m -> ParsedSource Source

Instances

ParsedMod DesugaredModule |
ParsedMod TypecheckedModule |
ParsedMod ParsedModule |

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

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

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 Source

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

compileCoreToObj :: GhcMonad m => Bool -> CoreModule -> m ()Source

Takes a CoreModule and compiles the bindings therein to object code. The first argument is a bool flag indicating whether to run the simplifier. The resulting .o, .hi, and executable files, if any, are stored in the current directory, and named according to the module name. This has only so far been tested with a single self-contained module.

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

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.

# Inspecting the module structure of the program

type ModuleGraph = [ModSummary]Source

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 `GHC.topSortModuleGraph` and `Digraph.flattenSCC` to achieve this.

data ModSummary Source

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
- An external-core source module

Constructors

ModSummary |

Fields

ms_mod :: Module

  Identity of the module

ms_hsc_src :: HscSource

  The module source either plain Haskell, hs-boot or external core

ms_location :: ModLocation

  Location of the various files belonging to the module

ms_hs_date :: ClockTime

  Timestamp of source file

ms_obj_date :: Maybe ClockTime

  Timestamp of object, if we have one

ms_srcimps :: [Located (ImportDecl RdrName)]

  Source imports of the module

ms_imps :: [Located (ImportDecl RdrName)]

  Non-source imports of the module

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 |

ms_mod_name :: ModSummary -> ModuleName Source

data ModLocation Source

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 |
Outputable ModLocation |

getModuleGraph :: GhcMonad m => m ModuleGraph Source

Get the module dependency graph.

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

Return `True` == module is loaded.

topSortModuleGraphSource

Arguments

:: Bool | Drop hi-boot nodes? (see below)
-> [ModSummary] |
-> Maybe ModuleName | Root module name. If `Nothing`, use the full graph.
-> [SCC ModSummary] |

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 Source

Container for information about a `Module`.

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

Request information about a loaded `Module`

modInfoTyThings :: ModuleInfo -> [TyThing]Source

The list of top-level entities defined in a module

modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]Source

modInfoExports :: ModuleInfo -> [Name]Source

modInfoInstances :: ModuleInfo -> [Instance]Source

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

modInfoIsExportedName :: ModuleInfo -> Name -> Bool Source

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

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

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

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

# Querying the environment

packageDbModulesSource

Arguments

:: GhcMonad m |
=> Bool | Only consider exposed packages.
-> m [Module] |

Return all external modules available in the package database. Modules from the current session (i.e., from the `HomePackageTable`) are not included.

# Printing

type PrintUnqualified = (QueryQualifyName, QueryQualifyModule)Source

alwaysQualify :: PrintUnqualified Source

# Interactive evaluation

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

Return the bindings for the current interactive session.

getPrintUnqual :: GhcMonad m => m PrintUnqualified Source

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

Takes a `ModuleName` and possibly a `PackageId`, 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 Source

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.

setContextSource

Arguments

:: GhcMonad m |
=> [Module] | entire top level scope of these modules
-> [(Module, Maybe (ImportDecl RdrName))] | exports of these modules
-> m () |

Set the interactive evaluation context.

Setting the context doesn't throw away any bindings; the bindings we've built up in the InteractiveContext simply move to the new module. They always shadow anything in scope in the current context.

getContext :: GhcMonad m => m ([Module], [(Module, Maybe (ImportDecl RdrName))])Source

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.

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

Returns all names in scope in the current interactive context

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

getGRE :: GhcMonad m => m GlobalRdrEnv Source

get the GlobalRdrEnv for a session

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

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

getInfo :: GhcMonad m => Name -> m (Maybe (TyThing, Fixity, [Instance]))Source

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)

exprType :: GhcMonad m => String -> m Type Source

Get the type of an expression

typeKind :: GhcMonad m => String -> m Kind Source

Get the kind of a type

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

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

data RunResult Source

Constructors

RunOk [Name] | names bound by this evaluation
RunFailed | statement failed compilation
RunException SomeException | statement raised an exception
RunBreak ThreadId [Name] (Maybe BreakInfo) |

runStmt :: GhcMonad m => String -> SingleStep -> m RunResult Source

Run a statement in the current interactive context. Statement may bind multple values.

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

data SingleStep Source

Constructors

RunToCompletion |
SingleStep |
RunAndLogSteps |

resume :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> m RunResult Source

data Resume Source

data History Source

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

getHistoryModule :: History -> Module Source

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

abandon :: GhcMonad m => m Bool Source

abandonAll :: GhcMonad m => m Bool Source

back :: GhcMonad m => m ([Name], Int, SrcSpan)Source

forward :: GhcMonad m => m ([Name], Int, SrcSpan)Source

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

isModuleInterpreted :: GhcMonad m => ModSummary -> m Bool Source

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

data HValue Source

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

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

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

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

modInfoModBreaks :: ModuleInfo -> ModBreaks Source

data ModBreaks Source

All the information about the breakpoints for a given module

Constructors

ModBreaks |

Fields

modBreaks_flags :: 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.

type BreakIndex = Int Source

Breakpoint index

data BreakInfo Source

Instances

Outputable BreakInfo |

data BreakArray Source

setBreakOn :: BreakArray -> Int -> IO Bool Source

setBreakOff :: BreakArray -> Int -> IO Bool Source

getBreak :: BreakArray -> Int -> IO (Maybe Word)Source

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

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

# Abstract syntax elements

## Packages

data PackageId Source

Essentially just a string identifying a package, including the version: e.g. parsec-1.0

Instances

Eq PackageId |
Data PackageId |
Ord PackageId |
Typeable PackageId |
Outputable PackageId |
Uniquable PackageId |
Binary PackageId |

## Modules

data Module Source

A Module is a pair of a `PackageId` and a `ModuleName`.

Instances

Eq Module |
Data Module |
Ord Module |
Typeable Module |
Outputable Module |
Uniquable Module |
Binary Module |

mkModule :: PackageId -> ModuleName -> Module Source

pprModule :: Module -> SDoc Source

moduleName :: Module -> ModuleName Source

modulePackageId :: Module -> PackageId Source

data ModuleName Source

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

Instances

Eq ModuleName |
Data ModuleName |
Ord ModuleName |
Typeable ModuleName |
Outputable ModuleName |
Uniquable ModuleName |
Binary ModuleName |

mkModuleName :: String -> ModuleName Source

moduleNameString :: ModuleName -> String Source

## Names

data Name Source

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

Instances

Eq Name |
Data Name |
Data NameSet |
Ord Name |
Typeable Name |
Typeable NameSet |
OutputableBndr Name |
Outputable Name |
Uniquable Name |
Binary Name |
NamedThing Name |

isExternalName :: Name -> Bool Source

nameModule :: Name -> Module Source

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

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

nameSrcSpan :: Name -> SrcSpan Source

class NamedThing a where Source

A class allowing convenient access to the `Name` of various datatypes

Methods

getOccName :: a -> OccName Source

getName :: a -> Name Source

Instances

NamedThing TyCon |
NamedThing TyThing |
NamedThing Name |
NamedThing Var |
NamedThing Class |
NamedThing DataCon |
NamedThing Instance |
NamedThing FamInst |

data RdrName Source

Do not use the data constructors of RdrName directly: prefer the family of functions that creates them, such as `mkRdrUnqual`

Constructors

Unqual OccName | Used for ordinary, unqualified occurrences, e.g. `x`, `y` or `Foo`. Create such a `RdrName` with `mkRdrUnqual`
Qual ModuleName OccName | 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 |
Data RdrName |
Ord RdrName |
Typeable RdrName |
OutputableBndr RdrName |
Outputable RdrName |

## Identifiers

type Id = Var Source

idType :: Id -> Kind Source

isImplicitId :: Id -> Bool Source

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

isExportedId :: Var -> Bool Source

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

isLocalId :: Var -> Bool Source

isGlobalId :: Var -> Bool Source

isRecordSelector :: Id -> Bool Source

isPrimOpId :: Id -> Bool Source

isFCallId :: Id -> Bool Source

isClassOpId_maybe :: Id -> Maybe Class Source

isDataConWorkId :: Id -> Bool Source

idDataCon :: Id -> DataCon Source

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 :: Id -> Bool Source

Returns true if an application to n args would diverge

isDictonaryId :: Id -> Bool Source

recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)Source

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

## Type constructors

data TyCon Source

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

5) Type coercions! This is because we represent a coercion from `t1` to `t2` as a `Type`, where that type has kind `t1 ~ t2`. See Coercion for more on this

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

Instances

Eq TyCon |
Data TyCon |
Ord TyCon |
Typeable TyCon |
Outputable TyCon |
Uniquable TyCon |
NamedThing TyCon |

tyConTyVars :: TyCon -> [TyVar]Source

tyConDataCons :: TyCon -> [DataCon]Source

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

tyConArity :: TyCon -> Arity Source

isClassTyCon :: TyCon -> Bool Source

Is this `TyCon` that for a class instance?

isSynTyCon :: TyCon -> Bool Source

A product `TyCon` must both:

1. Have one constructor
2. Not be existential

However other than this there are few restrictions: they may be `data` or `newtype` `TyCon`s of any boxity and may even be recursive.

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

isNewTyCon :: TyCon -> Bool Source

Is this `TyCon` that for a `newtype`

isPrimTyCon :: TyCon -> Bool Source

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

isFunTyCon :: TyCon -> Bool Source

isFamilyTyCon :: TyCon -> Bool Source

Is this a `TyCon`, synonym or otherwise, that may have further instances appear?

synTyConDefn :: TyCon -> ([TyVar], Type)Source

Extract the `TyVar`s bound by a type synonym and the corresponding (unsubstituted) right hand side. If the given `TyCon` is not a type synonym, panics

synTyConType :: TyCon -> Type Source

Find the expansion of the type synonym represented by the given `TyCon`. The free variables of this type will typically include those `TyVar`s bound by the `TyCon`. Panics if the `TyCon` is not that of a type synonym

synTyConResKind :: TyCon -> Kind Source

Find the result `Kind` of a type synonym, after applying it to its `arity` number of type variables Actually this function works fine on data types too, but they'd always return `*`, so we never need to ask

## Type variables

type TyVar = Var Source

alphaTyVars :: [TyVar]Source

## Data constructors

data DataCon Source

A data constructor

Instances

Eq DataCon |
Data DataCon |
Ord DataCon |
Show DataCon |
Typeable DataCon |
Outputable DataCon |
Uniquable DataCon |
NamedThing DataCon |

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

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 Source

dataConTyCon :: DataCon -> TyCon Source

The type constructor that we are building via this data constructor

dataConFieldLabels :: DataCon -> [FieldLabel]Source

The labels for the fields of this particular `DataCon`

dataConIsInfix :: DataCon -> Bool Source

Should the `DataCon` be presented infix?

isVanillaDataCon :: DataCon -> Bool Source

Vanilla `DataCon`s are those that are nice boring Haskell 98 constructors

dataConUserType :: DataCon -> Type Source

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.

dataConStrictMarks :: DataCon -> [HsBang]Source

The strictness markings decided on by the compiler. Does not include those for existential dictionaries. The list is in one-to-one correspondence with the arity of the `DataCon`

data StrictnessMark Source

Constructors

MarkedStrict |
NotMarkedStrict |

Instances

Outputable StrictnessMark |

isMarkedStrict :: StrictnessMark -> Bool Source

## Classes

data Class Source

Instances

Eq Class |
Data Class |
Ord Class |
Show Class |
Typeable Class |
Outputable Class |
Uniquable Class |
NamedThing Class |

classMethods :: Class -> [Id]Source

classSCTheta :: Class -> [PredType]Source

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

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

## Instances

data Instance Source

Instances

Outputable Instance |
NamedThing Instance |

instanceDFunId :: Instance -> DFunId Source

pprInstance :: Instance -> SDoc Source

pprInstanceHdr :: Instance -> SDoc Source

## Types and Kinds

data Type Source

The key representation of types within the compiler

Instances

Data Type |
Typeable Type |
Outputable Type |

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

Attempts to take a forall type apart, returning all the immediate such bound type variables and the remainder of the type. Always suceeds, even if that means returning an empty list of `TyVar`s

funResultTy :: Type -> Type Source

Extract the function result type and panic if that is not possible

pprParendType :: Type -> SDoc Source

pprTypeApp :: NamedThing a => a -> [Type] -> SDoc Source

type Kind = Type Source

The key type representing kinds in the compiler. Invariant: a kind is always in one of these forms:

     FunTy k1 k2
     TyConApp PrimTyCon [...]
     TyVar kv   -- (during inference only)
     ForAll ... -- (for top-level coercions)

data PredType Source

A type of the form `PredTy p` represents a value whose type is the Haskell predicate `p`, where a predicate is what occurs before the `=>` in a Haskell type. 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"

Instances

Eq PredType |
Data PredType |
Ord PredType |
Typeable PredType |
Outputable PredType |

type ThetaType = [PredType]Source

A collection of `PredType`s

pprForAll :: [TyVar] -> SDoc Source

pprThetaArrow :: ThetaType -> SDoc Source

## Entities

data TyThing Source

A typecheckable-thing, essentially anything that has a name

Constructors

AnId Id |
ADataCon DataCon |
ATyCon TyCon |
AClass Class |

Instances

Outputable TyThing |
NamedThing TyThing |

## Syntax

module HsSyn

## Fixities

data FixityDirection Source

Constructors

InfixL |
InfixR |
InfixN |

Instances

Eq FixityDirection |
Data FixityDirection |
Typeable FixityDirection |
Outputable FixityDirection |
Binary FixityDirection |

defaultFixity :: Fixity Source

maxPrecedence :: Int Source

negateFixity :: Fixity Source

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

## Source locations

data SrcLoc Source

Represents a single point within a file

Instances

Eq SrcLoc |
Ord SrcLoc |
Outputable SrcLoc |

pprDefnLoc :: SrcSpan -> SDoc Source

Pretty prints information about the `SrcSpan` in the style defined at ...

mkSrcLoc :: FastString -> Int -> Int -> SrcLoc Source

isGoodSrcLoc :: SrcLoc -> Bool Source

Good `SrcLoc`s have precise information about their location

noSrcLoc :: SrcLoc Source

srcLocFile :: SrcLoc -> FastString Source

Gives the filename of the `SrcLoc` if it is available, otherwise returns a dummy value

srcLocLine :: SrcLoc -> Int Source

Raises an error when used on a bad `SrcLoc`

srcLocCol :: SrcLoc -> Int Source

Raises an error when used on a bad `SrcLoc`

data SrcSpan Source

A SrcSpan 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.

Instances

Eq SrcSpan |
Data SrcSpan |
Ord SrcSpan |
Typeable SrcSpan |
Outputable SrcSpan |

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan Source

Create a `SrcSpan` between two points in a file

srcLocSpan :: SrcLoc -> SrcSpan Source

Create a `SrcSpan` corresponding to a single point

isGoodSrcSpan :: SrcSpan -> Bool Source

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

noSrcSpan :: SrcSpan Source

srcSpanStart :: SrcSpan -> SrcLoc Source

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

srcSpanEnd :: SrcSpan -> SrcLoc Source

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

srcSpanFile :: SrcSpan -> FastString Source

srcSpanStartLine :: SrcSpan -> Int Source

Raises an error when used on a bad `SrcSpan`

srcSpanEndLine :: SrcSpan -> Int Source

Raises an error when used on a bad `SrcSpan`

srcSpanStartCol :: SrcSpan -> Int Source

Raises an error when used on a bad `SrcSpan`

srcSpanEndCol :: SrcSpan -> Int Source

Raises an error when used on a bad `SrcSpan`

## Located

data Located e Source

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

Constructors

L SrcSpan e |

Instances

Functor Located |
Typeable1 Located |
Eq e => Eq (Located e) |
Data e => Data (Located e) |
Ord e => Ord (Located e) |
Outputable e => Outputable (Located e) |

### Constructing Located

noLoc :: e -> Located eSource

mkGeneralLocated :: String -> e -> Located eSource

### Deconstructing Located

getLoc :: Located e -> SrcSpan Source

unLoc :: Located e -> eSource

### Combining and comparing Located values

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

Tests whether the two located things are equal

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

Tests the ordering of the two located things

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

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

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

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering Source

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering Source

Alternative strategies for ordering `SrcSpan`s

rightmost :: SrcSpan -> SrcSpan -> Ordering Source

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

Determines whether a span encloses a given line and column index

isSubspanOfSource

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 Source

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

PhaseFailed String ExitCode |
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.
Sorry String | The user tickled something that's known not to work yet, but we're not counting it as a bug.
InstallationError String | An installation problem.
ProgramError String | An error in the user's code, probably.

Instances

Eq GhcException |
Show GhcException |
Typeable GhcException |
Exception GhcException |

showGhcException :: GhcException -> String -> String Source

Append a description of the given exception to this string.

# Token stream manipulations

data Token Source

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

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

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

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

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 :: SrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)]Source

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

# Miscellaneous

cyclicModuleErr :: [ModSummary] -> SDoc Source