-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | The GHC API
--   
--   GHC's functionality can be useful for more things than just compiling
--   Haskell programs. Important use cases are programs that analyse (and
--   perhaps transform) Haskell code. Others include loading Haskell code
--   dynamically in a GHCi-like manner. For this reason, a lot of GHC's
--   functionality is made available through this package.
@package ghc
@version 7.10.1

module SPARC.Cond

-- | Branch condition codes.
data Cond
[ALWAYS] :: Cond
[EQQ] :: Cond
[GE] :: Cond
[GEU] :: Cond
[GTT] :: Cond
[GU] :: Cond
[LE] :: Cond
[LEU] :: Cond
[LTT] :: Cond
[LU] :: Cond
[NE] :: Cond
[NEG] :: Cond
[NEVER] :: Cond
[POS] :: Cond
[VC] :: Cond
[VS] :: Cond
condUnsigned :: Cond -> Bool
condToSigned :: Cond -> Cond
condToUnsigned :: Cond -> Cond
instance Eq Cond

module X86.Cond
data Cond
[ALWAYS] :: Cond
[EQQ] :: Cond
[GE] :: Cond
[GEU] :: Cond
[GTT] :: Cond
[GU] :: Cond
[LE] :: Cond
[LEU] :: Cond
[LTT] :: Cond
[LU] :: Cond
[NE] :: Cond
[NEG] :: Cond
[POS] :: Cond
[CARRY] :: Cond
[OFLO] :: Cond
[PARITY] :: Cond
[NOTPARITY] :: Cond
condUnsigned :: Cond -> Bool
condToSigned :: Cond -> Cond
condToUnsigned :: Cond -> Cond

-- | <tt>maybeFlipCond c</tt> returns <tt>Just c'</tt> if it is possible to
--   flip the arguments to the conditional <tt>c</tt>, and the new
--   condition should be <tt>c'</tt>.
maybeFlipCond :: Cond -> Maybe Cond
instance Eq Cond


-- | Platform constants
--   
--   (c) The University of Glasgow 2013
module PlatformConstants
data PlatformConstants
[PlatformConstants] :: () -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Bool -> Bool -> Int -> Integer -> Integer -> Integer -> PlatformConstants
[pc_platformConstants] :: PlatformConstants -> ()
[pc_STD_HDR_SIZE] :: PlatformConstants -> Int
[pc_PROF_HDR_SIZE] :: PlatformConstants -> Int
[pc_BLOCK_SIZE] :: PlatformConstants -> Int
[pc_BLOCKS_PER_MBLOCK] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR7] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR8] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR9] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR10] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rL1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rSp] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rSpLim] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rHp] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rHpLim] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rCCCS] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rCurrentTSO] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rCurrentNursery] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rHpAlloc] :: PlatformConstants -> Int
[pc_OFFSET_stgEagerBlackholeInfo] :: PlatformConstants -> Int
[pc_OFFSET_stgGCEnter1] :: PlatformConstants -> Int
[pc_OFFSET_stgGCFun] :: PlatformConstants -> Int
[pc_OFFSET_Capability_r] :: PlatformConstants -> Int
[pc_OFFSET_bdescr_start] :: PlatformConstants -> Int
[pc_OFFSET_bdescr_free] :: PlatformConstants -> Int
[pc_OFFSET_bdescr_blocks] :: PlatformConstants -> Int
[pc_SIZEOF_CostCentreStack] :: PlatformConstants -> Int
[pc_OFFSET_CostCentreStack_mem_alloc] :: PlatformConstants -> Int
[pc_REP_CostCentreStack_mem_alloc] :: PlatformConstants -> Int
[pc_OFFSET_CostCentreStack_scc_count] :: PlatformConstants -> Int
[pc_REP_CostCentreStack_scc_count] :: PlatformConstants -> Int
[pc_OFFSET_StgHeader_ccs] :: PlatformConstants -> Int
[pc_OFFSET_StgHeader_ldvw] :: PlatformConstants -> Int
[pc_SIZEOF_StgSMPThunkHeader] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_allocs] :: PlatformConstants -> Int
[pc_REP_StgEntCounter_allocs] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_allocd] :: PlatformConstants -> Int
[pc_REP_StgEntCounter_allocd] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_registeredp] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_link] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_entry_count] :: PlatformConstants -> Int
[pc_SIZEOF_StgUpdateFrame_NoHdr] :: PlatformConstants -> Int
[pc_SIZEOF_StgMutArrPtrs_NoHdr] :: PlatformConstants -> Int
[pc_OFFSET_StgMutArrPtrs_ptrs] :: PlatformConstants -> Int
[pc_OFFSET_StgMutArrPtrs_size] :: PlatformConstants -> Int
[pc_SIZEOF_StgSmallMutArrPtrs_NoHdr] :: PlatformConstants -> Int
[pc_OFFSET_StgSmallMutArrPtrs_ptrs] :: PlatformConstants -> Int
[pc_SIZEOF_StgArrWords_NoHdr] :: PlatformConstants -> Int
[pc_OFFSET_StgArrWords_bytes] :: PlatformConstants -> Int
[pc_OFFSET_StgTSO_alloc_limit] :: PlatformConstants -> Int
[pc_OFFSET_StgTSO_cccs] :: PlatformConstants -> Int
[pc_OFFSET_StgTSO_stackobj] :: PlatformConstants -> Int
[pc_OFFSET_StgStack_sp] :: PlatformConstants -> Int
[pc_OFFSET_StgStack_stack] :: PlatformConstants -> Int
[pc_OFFSET_StgUpdateFrame_updatee] :: PlatformConstants -> Int
[pc_OFFSET_StgFunInfoExtraFwd_arity] :: PlatformConstants -> Int
[pc_REP_StgFunInfoExtraFwd_arity] :: PlatformConstants -> Int
[pc_SIZEOF_StgFunInfoExtraRev] :: PlatformConstants -> Int
[pc_OFFSET_StgFunInfoExtraRev_arity] :: PlatformConstants -> Int
[pc_REP_StgFunInfoExtraRev_arity] :: PlatformConstants -> Int
[pc_MAX_SPEC_SELECTEE_SIZE] :: PlatformConstants -> Int
[pc_MAX_SPEC_AP_SIZE] :: PlatformConstants -> Int
[pc_MIN_PAYLOAD_SIZE] :: PlatformConstants -> Int
[pc_MIN_INTLIKE] :: PlatformConstants -> Int
[pc_MAX_INTLIKE] :: PlatformConstants -> Int
[pc_MIN_CHARLIKE] :: PlatformConstants -> Int
[pc_MAX_CHARLIKE] :: PlatformConstants -> Int
[pc_MUT_ARR_PTRS_CARD_BITS] :: PlatformConstants -> Int
[pc_MAX_Vanilla_REG] :: PlatformConstants -> Int
[pc_MAX_Float_REG] :: PlatformConstants -> Int
[pc_MAX_Double_REG] :: PlatformConstants -> Int
[pc_MAX_Long_REG] :: PlatformConstants -> Int
[pc_MAX_XMM_REG] :: PlatformConstants -> Int
[pc_MAX_Real_Vanilla_REG] :: PlatformConstants -> Int
[pc_MAX_Real_Float_REG] :: PlatformConstants -> Int
[pc_MAX_Real_Double_REG] :: PlatformConstants -> Int
[pc_MAX_Real_XMM_REG] :: PlatformConstants -> Int
[pc_MAX_Real_Long_REG] :: PlatformConstants -> Int
[pc_RESERVED_C_STACK_BYTES] :: PlatformConstants -> Int
[pc_RESERVED_STACK_WORDS] :: PlatformConstants -> Int
[pc_AP_STACK_SPLIM] :: PlatformConstants -> Int
[pc_WORD_SIZE] :: PlatformConstants -> Int
[pc_DOUBLE_SIZE] :: PlatformConstants -> Int
[pc_CINT_SIZE] :: PlatformConstants -> Int
[pc_CLONG_SIZE] :: PlatformConstants -> Int
[pc_CLONG_LONG_SIZE] :: PlatformConstants -> Int
[pc_BITMAP_BITS_SHIFT] :: PlatformConstants -> Int
[pc_TAG_BITS] :: PlatformConstants -> Int
[pc_WORDS_BIGENDIAN] :: PlatformConstants -> Bool
[pc_DYNAMIC_BY_DEFAULT] :: PlatformConstants -> Bool
[pc_LDV_SHIFT] :: PlatformConstants -> Int
[pc_ILDV_CREATE_MASK] :: PlatformConstants -> Integer
[pc_ILDV_STATE_CREATE] :: PlatformConstants -> Integer
[pc_ILDV_STATE_USE] :: PlatformConstants -> Integer
instance Read PlatformConstants


-- | Compatibility module to encapsulate primops API change between GHC 7.6
--   GHC 7.8.
--   
--   In GHC we use comparison primops in a couple of modules, but that
--   primops have different type signature in GHC 7.6 (where they return
--   Bool) than in GHC 7.8 (where they return Int#). As long as we allow
--   bootstrapping with GHC 7.6 or earlier we need to have this
--   compatibility module, so that we can compile stage1 compiler using the
--   old API and then continue with stage2 using the new API. When we set
--   GHC 7.8 as the minimum version required for bootstrapping, we should
--   remove this module.
module ExtsCompat46
gtChar# :: Char# -> Char# -> Bool
geChar# :: Char# -> Char# -> Bool
eqChar# :: Char# -> Char# -> Bool
neChar# :: Char# -> Char# -> Bool
ltChar# :: Char# -> Char# -> Bool
leChar# :: Char# -> Char# -> Bool
(>#) :: Int# -> Int# -> Bool
(>=#) :: Int# -> Int# -> Bool
(==#) :: Int# -> Int# -> Bool
(/=#) :: Int# -> Int# -> Bool
(<#) :: Int# -> Int# -> Bool
(<=#) :: Int# -> Int# -> Bool
gtWord# :: Word# -> Word# -> Bool
geWord# :: Word# -> Word# -> Bool
eqWord# :: Word# -> Word# -> Bool
neWord# :: Word# -> Word# -> Bool
ltWord# :: Word# -> Word# -> Bool
leWord# :: Word# -> Word# -> Bool
(>##) :: Double# -> Double# -> Bool
(>=##) :: Double# -> Double# -> Bool
(==##) :: Double# -> Double# -> Bool
(/=##) :: Double# -> Double# -> Bool
(<##) :: Double# -> Double# -> Bool
(<=##) :: Double# -> Double# -> Bool
gtFloat# :: Float# -> Float# -> Bool
geFloat# :: Float# -> Float# -> Bool
eqFloat# :: Float# -> Float# -> Bool
neFloat# :: Float# -> Float# -> Bool
ltFloat# :: Float# -> Float# -> Bool
leFloat# :: Float# -> Float# -> Bool
gtAddr# :: Addr# -> Addr# -> Bool
geAddr# :: Addr# -> Addr# -> Bool
eqAddr# :: Addr# -> Addr# -> Bool
neAddr# :: Addr# -> Addr# -> Bool
ltAddr# :: Addr# -> Addr# -> Bool
leAddr# :: Addr# -> Addr# -> Bool
sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Bool
sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Bool
sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Bool
sameMutVar# :: MutVar# s a -> MutVar# s a -> Bool
sameTVar# :: TVar# s a -> TVar# s a -> Bool
sameMVar# :: MVar# s a -> MVar# s a -> Bool

module Encoding
utf8DecodeChar# :: Addr# -> (# Char#, Int# #)
utf8PrevChar :: Ptr Word8 -> IO (Ptr Word8)
utf8CharStart :: Ptr Word8 -> IO (Ptr Word8)
utf8DecodeChar :: Ptr Word8 -> (Char, Int)
utf8DecodeString :: Ptr Word8 -> Int -> IO [Char]
utf8EncodeChar :: Char -> Ptr Word8 -> IO (Ptr Word8)
utf8EncodeString :: Ptr Word8 -> String -> IO ()
utf8EncodedLength :: String -> Int
countUTF8Chars :: Ptr Word8 -> Int -> IO Int
zEncodeString :: UserString -> EncodedString
zDecodeString :: EncodedString -> UserString

module FastMutInt
data FastMutInt
newFastMutInt :: IO FastMutInt
readFastMutInt :: FastMutInt -> IO Int
writeFastMutInt :: FastMutInt -> Int -> IO ()
data FastMutPtr
newFastMutPtr :: IO FastMutPtr
readFastMutPtr :: FastMutPtr -> IO (Ptr a)
writeFastMutPtr :: FastMutPtr -> Ptr a -> IO ()

module FastBool
type FastBool = Int#
fastBool :: Bool -> FastBool
isFastTrue :: FastBool -> Bool
fastOr :: FastBool -> FastBool -> FastBool
fastAnd :: FastBool -> FastBool -> FastBool

module FiniteMap
insertList :: Ord key => [(key, elt)] -> Map key elt -> Map key elt
insertListWith :: Ord key => (elt -> elt -> elt) -> [(key, elt)] -> Map key elt -> Map key elt
deleteList :: Ord key => [key] -> Map key elt -> Map key elt
foldRight :: (elt -> a -> a) -> a -> Map key elt -> a
foldRightWithKey :: (key -> elt -> a -> a) -> a -> Map key elt -> a

module Config
data IntegerLibrary
[IntegerGMP] :: IntegerLibrary
[IntegerGMP2] :: IntegerLibrary
[IntegerSimple] :: IntegerLibrary
cBuildPlatformString :: String
cHostPlatformString :: String
cTargetPlatformString :: String
cProjectName :: String
cProjectGitCommitId :: String
cProjectVersion :: String
cProjectVersionInt :: String
cProjectPatchLevel :: String
cProjectPatchLevel1 :: String
cProjectPatchLevel2 :: String
cBooterVersion :: String
cStage :: String
cIntegerLibrary :: String
cIntegerLibraryType :: IntegerLibrary
cSupportsSplitObjs :: String
cGhcWithInterpreter :: String
cGhcWithNativeCodeGen :: String
cGhcWithSMP :: String
cGhcRTSWays :: String
cGhcEnableTablesNextToCode :: String
cLeadingUnderscore :: String
cGHC_UNLIT_PGM :: String
cGHC_SPLIT_PGM :: String
cLibFFI :: Bool
cGhcThreaded :: Bool
cGhcDebugged :: Bool
instance Eq IntegerLibrary


-- | A description of the platform we're compiling for.
module Platform

-- | Contains enough information for the native code generator to emit code
--   for this platform.
data Platform
[Platform] :: Arch -> OS -> {-# UNPACK #-} !Int -> Bool -> Bool -> Bool -> Bool -> Platform
[platformArch] :: Platform -> Arch
[platformOS] :: Platform -> OS
[platformWordSize] :: Platform -> {-# UNPACK #-} !Int
[platformUnregisterised] :: Platform -> Bool
[platformHasGnuNonexecStack] :: Platform -> Bool
[platformHasIdentDirective] :: Platform -> Bool
[platformHasSubsectionsViaSymbols] :: Platform -> Bool

-- | Architectures that the native code generator knows about. TODO: It
--   might be nice to extend these constructors with information about what
--   instruction set extensions an architecture might support.
data Arch
[ArchUnknown] :: Arch
[ArchX86] :: Arch
[ArchX86_64] :: Arch
[ArchPPC] :: Arch
[ArchPPC_64] :: Arch
[ArchSPARC] :: Arch
[ArchARM] :: ArmISA -> [ArmISAExt] -> ArmABI -> Arch
[armISA] :: Arch -> ArmISA
[armISAExt] :: Arch -> [ArmISAExt]
[armABI] :: Arch -> ArmABI
[ArchARM64] :: Arch
[ArchAlpha] :: Arch
[ArchMipseb] :: Arch
[ArchMipsel] :: Arch
[ArchJavaScript] :: Arch

-- | Operating systems that the native code generator knows about. Having
--   OSUnknown should produce a sensible default, but no promises.
data OS
[OSUnknown] :: OS
[OSLinux] :: OS
[OSDarwin] :: OS
[OSiOS] :: OS
[OSSolaris2] :: OS
[OSMinGW32] :: OS
[OSFreeBSD] :: OS
[OSDragonFly] :: OS
[OSOpenBSD] :: OS
[OSNetBSD] :: OS
[OSKFreeBSD] :: OS
[OSHaiku] :: OS
[OSOsf3] :: OS
[OSQNXNTO] :: OS
[OSAndroid] :: OS

-- | ARM Instruction Set Architecture, Extensions and ABI
data ArmISA
[ARMv5] :: ArmISA
[ARMv6] :: ArmISA
[ARMv7] :: ArmISA
data ArmISAExt
[VFPv2] :: ArmISAExt
[VFPv3] :: ArmISAExt
[VFPv3D16] :: ArmISAExt
[NEON] :: ArmISAExt
[IWMMX2] :: ArmISAExt
data ArmABI
[SOFT] :: ArmABI
[SOFTFP] :: ArmABI
[HARD] :: ArmABI
target32Bit :: Platform -> Bool
isARM :: Arch -> Bool

-- | This predicates tells us whether the OS supports ELF-like shared
--   libraries.
osElfTarget :: OS -> Bool

-- | This predicate tells us whether the OS support Mach-O shared
--   libraries.
osMachOTarget :: OS -> Bool
platformUsesFrameworks :: Platform -> Bool
platformBinariesAreStaticLibs :: Platform -> Bool
instance Eq Platform
instance Show Platform
instance Read Platform
instance Eq Arch
instance Show Arch
instance Read Arch
instance Eq ArmABI
instance Show ArmABI
instance Read ArmABI
instance Eq ArmISAExt
instance Show ArmISAExt
instance Read ArmISAExt
instance Eq ArmISA
instance Show ArmISA
instance Read ArmISA
instance Eq OS
instance Show OS
instance Read OS

module PprBase
castFloatToWord8Array :: STUArray s Int Float -> ST s (STUArray s Int Word8)
castDoubleToWord8Array :: STUArray s Int Double -> ST s (STUArray s Int Word8)
floatToBytes :: Float -> [Int]
doubleToBytes :: Double -> [Int]

module Constants
hiVersion :: Integer
mAX_TUPLE_SIZE :: Int
mAX_CONTEXT_REDUCTION_DEPTH :: Int
mAX_TYPE_FUNCTION_REDUCTION_DEPTH :: Int
wORD64_SIZE :: Int
tARGET_MAX_CHAR :: Int


-- | Fast integers, characters and pointer types for use in many parts of
--   GHC
module FastTypes
type FastInt = Int#
_ILIT :: Int -> FastInt
iBox :: FastInt -> Int
iUnbox :: Int -> FastInt
(+#) :: Int# -> Int# -> Int#
(-#) :: Int# -> Int# -> Int#
(*#) :: Int# -> Int# -> Int#
quotFastInt :: FastInt -> FastInt -> FastInt
negateFastInt :: FastInt -> FastInt
(==#) :: Int# -> Int# -> Bool
(/=#) :: Int# -> Int# -> Bool
(<#) :: Int# -> Int# -> Bool
(<=#) :: Int# -> Int# -> Bool
(>=#) :: Int# -> Int# -> Bool
(>#) :: Int# -> Int# -> Bool
minFastInt :: FastInt -> FastInt -> FastInt
maxFastInt :: FastInt -> FastInt -> FastInt
shiftLFastInt :: FastInt -> FastInt -> FastInt
shiftR_FastInt :: FastInt -> FastInt -> FastInt
shiftRLFastInt :: FastInt -> FastInt -> FastInt
shiftRAFastInt :: FastInt -> FastInt -> FastInt
bitAndFastInt :: FastInt -> FastInt -> FastInt
bitOrFastInt :: FastInt -> FastInt -> FastInt
type FastChar = Char#
_CLIT :: Char -> FastChar
cBox :: FastChar -> Char
cUnbox :: Char -> FastChar
fastOrd :: FastChar -> FastInt
fastChr :: FastInt -> FastChar
eqFastChar :: FastChar -> FastChar -> Bool
type FastPtr a = Addr#
pBox :: FastPtr a -> Ptr a
pUnbox :: Ptr a -> FastPtr a
castFastPtr :: FastPtr a -> FastPtr b

module FastFunctions
unsafeChr :: Int -> Char
inlinePerformIO :: IO a -> a
unsafeDupableInterleaveIO :: IO a -> IO a
indexWord8OffFastPtr :: FastPtr Word8 -> FastInt -> Word8
indexWord8OffFastPtrAsFastChar :: FastPtr Word8 -> FastInt -> FastChar
indexWord8OffFastPtrAsFastInt :: FastPtr Word8 -> FastInt -> FastInt
global :: a -> Global a
type Global a = IORef a

module Maybes
data MaybeErr err val
[Succeeded] :: val -> MaybeErr err val
[Failed] :: err -> MaybeErr err val
failME :: err -> MaybeErr err val
isSuccess :: MaybeErr err val -> Bool

-- | Flipped version of <tt>fromMaybe</tt>, useful for chaining.
orElse :: Maybe a -> a -> a
firstJust :: Maybe a -> Maybe a -> Maybe a

-- | Takes a list of <tt>Maybes</tt> and returns the first <tt>Just</tt> if
--   there is one, or <tt>Nothing</tt> otherwise.
firstJusts :: [Maybe a] -> Maybe a
whenIsJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
expectJust :: String -> Maybe a -> a
newtype MaybeT m a
[MaybeT] :: m (Maybe a) -> MaybeT m a
[runMaybeT] :: MaybeT m a -> m (Maybe a)
liftMaybeT :: Monad m => m a -> MaybeT m a
instance Functor m => Functor (MaybeT m)
instance (Monad m, Functor m) => Applicative (MaybeT m)
instance Monad m => Monad (MaybeT m)
instance Monad m => Alternative (MaybeT m)
instance Monad m => MonadPlus (MaybeT m)
instance Functor (MaybeErr err)
instance Applicative (MaybeErr err)
instance Monad (MaybeErr err)


-- | Utilities related to Monad and Applicative classes Mostly for
--   backwards compatability.
module MonadUtils

-- | A functor with application, providing operations to
--   
--   <ul>
--   <li>embed pure expressions (<a>pure</a>), and</li>
--   <li>sequence computations and combine their results
--   (<a>&lt;*&gt;</a>).</li>
--   </ul>
--   
--   A minimal complete definition must include implementations of these
--   functions satisfying the following laws:
--   
--   <ul>
--   <li><i><i>identity</i></i> <pre><a>pure</a> <a>id</a> <a>&lt;*&gt;</a>
--   v = v</pre></li>
--   <li><i><i>composition</i></i> <pre><a>pure</a> (.) <a>&lt;*&gt;</a> u
--   <a>&lt;*&gt;</a> v <a>&lt;*&gt;</a> w = u <a>&lt;*&gt;</a> (v
--   <a>&lt;*&gt;</a> w)</pre></li>
--   <li><i><i>homomorphism</i></i> <pre><a>pure</a> f <a>&lt;*&gt;</a>
--   <a>pure</a> x = <a>pure</a> (f x)</pre></li>
--   <li><i><i>interchange</i></i> <pre>u <a>&lt;*&gt;</a> <a>pure</a> y =
--   <a>pure</a> (<a>$</a> y) <a>&lt;*&gt;</a> u</pre></li>
--   </ul>
--   
--   The other methods have the following default definitions, which may be
--   overridden with equivalent specialized implementations:
--   
--   <ul>
--   <li><pre>u <a>*&gt;</a> v = <a>pure</a> (<a>const</a> <a>id</a>)
--   <a>&lt;*&gt;</a> u <a>&lt;*&gt;</a> v</pre></li>
--   <li><pre>u <a>&lt;*</a> v = <a>pure</a> <a>const</a> <a>&lt;*&gt;</a>
--   u <a>&lt;*&gt;</a> v</pre></li>
--   </ul>
--   
--   As a consequence of these laws, the <a>Functor</a> instance for
--   <tt>f</tt> will satisfy
--   
--   <ul>
--   <li><pre><a>fmap</a> f x = <a>pure</a> f <a>&lt;*&gt;</a> x</pre></li>
--   </ul>
--   
--   If <tt>f</tt> is also a <a>Monad</a>, it should satisfy
--   
--   <ul>
--   <li><pre><a>pure</a> = <a>return</a></pre></li>
--   <li><pre>(<a>&lt;*&gt;</a>) = <a>ap</a></pre></li>
--   </ul>
--   
--   (which implies that <a>pure</a> and <a>&lt;*&gt;</a> satisfy the
--   applicative functor laws).
class Functor f => Applicative (f :: * -> *)
pure :: Applicative f => a -> f a
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
(*>) :: Applicative f => f a -> f b -> f b
(<*) :: Applicative f => f a -> f b -> f a

-- | An infix synonym for <a>fmap</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Convert from a <tt><tt>Maybe</tt> <tt>Int</tt></tt> to a
--   <tt><tt>Maybe</tt> <tt>String</tt></tt> using <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Nothing
--   Nothing
--   
--   &gt;&gt;&gt; show &lt;$&gt; Just 3
--   Just "3"
--   </pre>
--   
--   Convert from an <tt><tt>Either</tt> <tt>Int</tt> <tt>Int</tt></tt> to
--   an <tt><tt>Either</tt> <tt>Int</tt></tt> <tt>String</tt> using
--   <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Left 17
--   Left 17
--   
--   &gt;&gt;&gt; show &lt;$&gt; Right 17
--   Right "17"
--   </pre>
--   
--   Double each element of a list:
--   
--   <pre>
--   &gt;&gt;&gt; (*2) &lt;$&gt; [1,2,3]
--   [2,4,6]
--   </pre>
--   
--   Apply <tt>even</tt> to the second element of a pair:
--   
--   <pre>
--   &gt;&gt;&gt; even &lt;$&gt; (2,2)
--   (2,True)
--   </pre>
(<$>) :: Functor f => (a -> b) -> f a -> f b

-- | Monads having fixed points with a 'knot-tying' semantics. Instances of
--   <a>MonadFix</a> should satisfy the following laws:
--   
--   <ul>
--   <li><i><i>purity</i></i> <tt><a>mfix</a> (<tt>return</tt> . h) =
--   <tt>return</tt> (<a>fix</a> h)</tt></li>
--   <li><i><i>left shrinking</i> (or <i>tightening</i>)</i>
--   <tt><a>mfix</a> (\x -&gt; a &gt;&gt;= \y -&gt; f x y) = a &gt;&gt;= \y
--   -&gt; <a>mfix</a> (\x -&gt; f x y)</tt></li>
--   <li><i><i>sliding</i></i> <tt><a>mfix</a> (<a>liftM</a> h . f) =
--   <a>liftM</a> h (<a>mfix</a> (f . h))</tt>, for strict <tt>h</tt>.</li>
--   <li><i><i>nesting</i></i> <tt><a>mfix</a> (\x -&gt; <a>mfix</a> (\y
--   -&gt; f x y)) = <a>mfix</a> (\x -&gt; f x x)</tt></li>
--   </ul>
--   
--   This class is used in the translation of the recursive <tt>do</tt>
--   notation supported by GHC and Hugs.
class Monad m => MonadFix (m :: * -> *)
mfix :: MonadFix m => (a -> m a) -> m a

-- | Monads in which <a>IO</a> computations may be embedded. Any monad
--   built by applying a sequence of monad transformers to the <a>IO</a>
--   monad will be an instance of this class.
--   
--   Instances should satisfy the following laws, which state that
--   <a>liftIO</a> is a transformer of monads:
--   
--   <ul>
--   <li><pre><a>liftIO</a> . <a>return</a> = <a>return</a></pre></li>
--   <li><pre><a>liftIO</a> (m &gt;&gt;= f) = <a>liftIO</a> m &gt;&gt;=
--   (<a>liftIO</a> . f)</pre></li>
--   </ul>
class Monad m => MonadIO (m :: * -> *)
liftIO :: MonadIO m => IO a -> m a

-- | Lift an <a>IO</a> operation with 1 argument into another monad
liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b

-- | Lift an <a>IO</a> operation with 2 arguments into another monad
liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c

-- | Lift an <a>IO</a> operation with 3 arguments into another monad
liftIO3 :: MonadIO m => (a -> b -> c -> IO d) -> a -> b -> c -> m d

-- | Lift an <a>IO</a> operation with 4 arguments into another monad
liftIO4 :: MonadIO m => (a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> m e
zipWith3M :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m [d]
zipWith3M_ :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m ()
zipWithAndUnzipM :: Monad m => (a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])

-- | The <a>mapAndUnzipM</a> function maps its first argument over a list,
--   returning the result as a pair of lists. This function is mainly used
--   with complicated data structures or a state-transforming monad.
mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c])

-- | mapAndUnzipM for triples
mapAndUnzip3M :: Monad m => (a -> m (b, c, d)) -> [a] -> m ([b], [c], [d])
mapAndUnzip4M :: Monad m => (a -> m (b, c, d, e)) -> [a] -> m ([b], [c], [d], [e])

-- | Monadic version of mapAccumL
mapAccumLM :: Monad m => (acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y])

-- | Monadic version of mapSnd
mapSndM :: Monad m => (b -> m c) -> [(a, b)] -> m [(a, c)]

-- | Monadic version of concatMap
concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]

-- | Monadic version of mapMaybe
mapMaybeM :: (Monad m) => (a -> m (Maybe b)) -> [a] -> m [b]

-- | Monadic version of fmap
fmapMaybeM :: (Monad m) => (a -> m b) -> Maybe a -> m (Maybe b)

-- | Monadic version of fmap
fmapEitherM :: Monad m => (a -> m b) -> (c -> m d) -> Either a c -> m (Either b d)

-- | Monadic version of <a>any</a>, aborts the computation at the first
--   <tt>True</tt> value
anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool

-- | Monad version of <a>all</a>, aborts the computation at the first
--   <tt>False</tt> value
allM :: Monad m => (a -> m Bool) -> [a] -> m Bool

-- | Monadic version of foldl
foldlM :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a

-- | Monadic version of foldl that discards its result
foldlM_ :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m ()

-- | Monadic version of foldr
foldrM :: (Monad m) => (b -> a -> m a) -> a -> [b] -> m a

-- | Monadic version of fmap specialised for Maybe
maybeMapM :: Monad m => (a -> m b) -> (Maybe a -> m (Maybe b))

-- | Monadic version of <tt>when</tt>, taking the condition in the monad
whenM :: Monad m => m Bool -> m () -> m ()

module State
newtype State s a
[State] :: (s -> (# a, s #)) -> State s a
[runState'] :: State s a -> s -> (# a, s #)
get :: State s s
gets :: (s -> a) -> State s a
put :: s -> State s ()
modify :: (s -> s) -> State s ()
evalState :: State s a -> s -> a
execState :: State s a -> s -> s
runState :: State s a -> s -> (a, s)
instance Functor (State s)
instance Applicative (State s)
instance Monad (State s)

module Stream

-- | <tt>Stream m a b</tt> is a computation in some Monad <tt>m</tt> that
--   delivers a sequence of elements of type <tt>a</tt> followed by a
--   result of type <tt>b</tt>.
--   
--   More concretely, a value of type <tt>Stream m a b</tt> can be run
--   using <tt>runStream</tt> in the Monad <tt>m</tt>, and it delivers
--   either
--   
--   <ul>
--   <li>the final result: <tt>Left b</tt>, or</li>
--   <li><tt>Right (a,str)</tt>, where <tt>a</tt> is the next element in
--   the stream, and <tt>str</tt> is a computation to get the rest of the
--   stream.</li>
--   </ul>
--   
--   Stream is itself a Monad, and provides an operation <a>yield</a> that
--   produces a new element of the stream. This makes it convenient to turn
--   existing monadic computations into streams.
--   
--   The idea is that Stream is useful for making a monadic computation
--   that produces values from time to time. This can be used for knitting
--   together two complex monadic operations, so that the producer does not
--   have to produce all its values before the consumer starts consuming
--   them. We make the producer into a Stream, and the consumer pulls on
--   the stream each time it wants a new value.
newtype Stream m a b
[Stream] :: m (Either b (a, Stream m a b)) -> Stream m a b
[runStream] :: Stream m a b -> m (Either b (a, Stream m a b))
yield :: Monad m => a -> Stream m a ()
liftIO :: IO a -> Stream IO b a

-- | Turn a Stream into an ordinary list, by demanding all the elements.
collect :: Monad m => Stream m a () -> m [a]

-- | Turn a list into a <a>Stream</a>, by yielding each element in turn.
fromList :: Monad m => [a] -> Stream m a ()

-- | Apply a function to each element of a <a>Stream</a>, lazily
map :: Monad m => (a -> b) -> Stream m a x -> Stream m b x

-- | Apply a monadic operation to each element of a <a>Stream</a>, lazily
mapM :: Monad m => (a -> m b) -> Stream m a x -> Stream m b x

-- | analog of the list-based <a>mapAccumL</a> on Streams. This is a simple
--   way to map over a Stream while carrying some state around.
mapAccumL :: Monad m => (c -> a -> m (c, b)) -> c -> Stream m a () -> Stream m b c
instance Monad f => Functor (Stream f a)
instance Monad m => Applicative (Stream m a)
instance Monad m => Monad (Stream m a)

module Exception
catchIO :: IO a -> (IOException -> IO a) -> IO a
handleIO :: (IOException -> IO a) -> IO a -> IO a
tryIO :: IO a -> IO (Either IOException a)

-- | A monad that can catch exceptions. A minimal definition requires a
--   definition of <a>gcatch</a>.
--   
--   Implementations on top of <a>IO</a> should implement <a>gmask</a> to
--   eventually call the primitive <a>mask</a>. These are used for
--   implementations that support asynchronous exceptions. The default
--   implementations of <a>gbracket</a> and <a>gfinally</a> use
--   <a>gmask</a> thus rarely require overriding.
class MonadIO m => ExceptionMonad m where gbracket before after thing = gmask $ \ restore -> do { a <- before; r <- restore (thing a) `gonException` after a; _ <- after a; return r } a `gfinally` sequel = gmask $ \ restore -> do { r <- restore a `gonException` sequel; _ <- sequel; return r }
gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a
gmask :: ExceptionMonad m => ((m a -> m a) -> m b) -> m b
gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c
gfinally :: ExceptionMonad m => m a -> m b -> m a
gtry :: (ExceptionMonad m, Exception e) => m a -> m (Either e a)

-- | Generalised version of <a>handle</a>, allowing an arbitrary exception
--   handling monad instead of just <a>IO</a>.
ghandle :: (ExceptionMonad m, Exception e) => (e -> m a) -> m a -> m a

-- | Always executes the first argument. If this throws an exception the
--   second argument is executed and the exception is raised again.
gonException :: (ExceptionMonad m) => m a -> m b -> m a
instance ExceptionMonad IO

module Panic

-- | GHC's own exception type error messages all take the form:
--   
--   <pre>
--   <a>location</a>: <a>error</a>
--   
--   </pre>
--   
--   If the location is on the command line, or in GHC itself, then
--   <a>location</a>="ghc". All of the error types below correspond to a
--   <a>location</a> of "ghc", except for ProgramError (where the string is
--   assumed to contain a location already, so we don't print one).
data GhcException
[PhaseFailed] :: String -> ExitCode -> GhcException

-- | Some other fatal signal (SIGHUP,SIGTERM)
[Signal] :: Int -> GhcException

-- | Prints the short usage msg after the error
[UsageError] :: String -> GhcException

-- | A problem with the command line arguments, but don't print usage.
[CmdLineError] :: String -> GhcException

-- | The <tt>impossible</tt> happened.
[Panic] :: String -> GhcException
[PprPanic] :: String -> SDoc -> GhcException

-- | The user tickled something that's known not to work yet, but we're not
--   counting it as a bug.
[Sorry] :: String -> GhcException
[PprSorry] :: String -> SDoc -> GhcException

-- | An installation problem.
[InstallationError] :: String -> GhcException

-- | An error in the user's code, probably.
[ProgramError] :: String -> GhcException
[PprProgramError] :: String -> SDoc -> GhcException

-- | Append a description of the given exception to this string.
showGhcException :: GhcException -> String -> String
throwGhcException :: GhcException -> a
throwGhcExceptionIO :: GhcException -> IO a
handleGhcException :: ExceptionMonad m => (GhcException -> m a) -> m a -> m a

-- | The name of this GHC.
progName :: String

-- | Panics and asserts.
pgmError :: String -> a

-- | Panics and asserts.
panic :: String -> a

-- | Panics and asserts.
sorry :: String -> a

-- | Panic while pretending to return an unboxed int. You can't use the
--   regular panic functions in expressions producing unboxed ints because
--   they have the wrong kind.
panicFastInt :: String -> FastInt

-- | Throw an failed assertion exception for a given filename and line
--   number.
assertPanic :: String -> Int -> a

-- | The <a>trace</a> function outputs the trace message given as its first
--   argument, before returning the second argument as its result.
--   
--   For example, this returns the value of <tt>f x</tt> but first outputs
--   the message.
--   
--   <pre>
--   trace ("calling f with x = " ++ show x) (f x)
--   </pre>
--   
--   The <a>trace</a> function should <i>only</i> be used for debugging, or
--   for monitoring execution. The function is not referentially
--   transparent: its type indicates that it is a pure function but it has
--   the side effect of outputting the trace message.
trace :: String -> a -> a
panicDoc :: String -> SDoc -> a
sorryDoc :: String -> SDoc -> a
panicDocFastInt :: String -> SDoc -> FastInt
pgmErrorDoc :: String -> SDoc -> a

-- | Any type that you wish to throw or catch as an exception must be an
--   instance of the <tt>Exception</tt> class. The simplest case is a new
--   exception type directly below the root:
--   
--   <pre>
--   data MyException = ThisException | ThatException
--       deriving (Show, Typeable)
--   
--   instance Exception MyException
--   </pre>
--   
--   The default method definitions in the <tt>Exception</tt> class do what
--   we need in this case. You can now throw and catch
--   <tt>ThisException</tt> and <tt>ThatException</tt> as exceptions:
--   
--   <pre>
--   *Main&gt; throw ThisException `catch` \e -&gt; putStrLn ("Caught " ++ show (e :: MyException))
--   Caught ThisException
--   </pre>
--   
--   In more complicated examples, you may wish to define a whole hierarchy
--   of exceptions:
--   
--   <pre>
--   ---------------------------------------------------------------------
--   -- Make the root exception type for all the exceptions in a compiler
--   
--   data SomeCompilerException = forall e . Exception e =&gt; SomeCompilerException e
--       deriving Typeable
--   
--   instance Show SomeCompilerException where
--       show (SomeCompilerException e) = show e
--   
--   instance Exception SomeCompilerException
--   
--   compilerExceptionToException :: Exception e =&gt; e -&gt; SomeException
--   compilerExceptionToException = toException . SomeCompilerException
--   
--   compilerExceptionFromException :: Exception e =&gt; SomeException -&gt; Maybe e
--   compilerExceptionFromException x = do
--       SomeCompilerException a &lt;- fromException x
--       cast a
--   
--   ---------------------------------------------------------------------
--   -- Make a subhierarchy for exceptions in the frontend of the compiler
--   
--   data SomeFrontendException = forall e . Exception e =&gt; SomeFrontendException e
--       deriving Typeable
--   
--   instance Show SomeFrontendException where
--       show (SomeFrontendException e) = show e
--   
--   instance Exception SomeFrontendException where
--       toException = compilerExceptionToException
--       fromException = compilerExceptionFromException
--   
--   frontendExceptionToException :: Exception e =&gt; e -&gt; SomeException
--   frontendExceptionToException = toException . SomeFrontendException
--   
--   frontendExceptionFromException :: Exception e =&gt; SomeException -&gt; Maybe e
--   frontendExceptionFromException x = do
--       SomeFrontendException a &lt;- fromException x
--       cast a
--   
--   ---------------------------------------------------------------------
--   -- Make an exception type for a particular frontend compiler exception
--   
--   data MismatchedParentheses = MismatchedParentheses
--       deriving (Typeable, Show)
--   
--   instance Exception MismatchedParentheses where
--       toException   = frontendExceptionToException
--       fromException = frontendExceptionFromException
--   </pre>
--   
--   We can now catch a <tt>MismatchedParentheses</tt> exception as
--   <tt>MismatchedParentheses</tt>, <tt>SomeFrontendException</tt> or
--   <tt>SomeCompilerException</tt>, but not other types, e.g.
--   <tt>IOException</tt>:
--   
--   <pre>
--   *Main&gt; throw MismatchedParentheses <tt>catch</tt> e -&gt; putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses <tt>catch</tt> e -&gt; putStrLn ("Caught " ++ show (e :: SomeFrontendException))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses <tt>catch</tt> e -&gt; putStrLn ("Caught " ++ show (e :: SomeCompilerException))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses <tt>catch</tt> e -&gt; putStrLn ("Caught " ++ show (e :: IOException))
--   *** Exception: MismatchedParentheses
--   </pre>
class (Typeable * e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e
displayException :: Exception e => e -> String

-- | Show an exception as a string.
showException :: Exception e => e -> String

-- | Show an exception which can possibly throw other exceptions. Used when
--   displaying exception thrown within TH code.
safeShowException :: Exception e => e -> IO String

-- | Similar to <a>catch</a>, but returns an <a>Either</a> result which is
--   <tt>(<a>Right</a> a)</tt> if no exception of type <tt>e</tt> was
--   raised, or <tt>(<a>Left</a> ex)</tt> if an exception of type
--   <tt>e</tt> was raised and its value is <tt>ex</tt>. If any other type
--   of exception is raised than it will be propogated up to the next
--   enclosing exception handler.
--   
--   <pre>
--   try a = catch (Right `liftM` a) (return . Left)
--   </pre>
try :: Exception e => IO a -> IO (Either e a)

-- | Like try, but pass through UserInterrupt and Panic exceptions. Used
--   when we want soft failures when reading interface files, for example.
--   TODO: I'm not entirely sure if this is catching what we really want to
--   catch
tryMost :: IO a -> IO (Either SomeException a)

-- | <a>throwTo</a> raises an arbitrary exception in the target thread (GHC
--   only).
--   
--   Exception delivery synchronizes between the source and target thread:
--   <a>throwTo</a> does not return until the exception has been raised in
--   the target thread. The calling thread can thus be certain that the
--   target thread has received the exception. Exception delivery is also
--   atomic with respect to other exceptions. Atomicity is a useful
--   property to have when dealing with race conditions: e.g. if there are
--   two threads that can kill each other, it is guaranteed that only one
--   of the threads will get to kill the other.
--   
--   Whatever work the target thread was doing when the exception was
--   raised is not lost: the computation is suspended until required by
--   another thread.
--   
--   If the target thread is currently making a foreign call, then the
--   exception will not be raised (and hence <a>throwTo</a> will not
--   return) until the call has completed. This is the case regardless of
--   whether the call is inside a <a>mask</a> or not. However, in GHC a
--   foreign call can be annotated as <tt>interruptible</tt>, in which case
--   a <a>throwTo</a> will cause the RTS to attempt to cause the call to
--   return; see the GHC documentation for more details.
--   
--   Important note: the behaviour of <a>throwTo</a> differs from that
--   described in the paper "Asynchronous exceptions in Haskell"
--   (<a>http://research.microsoft.com/~simonpj/Papers/asynch-exns.htm</a>).
--   In the paper, <a>throwTo</a> is non-blocking; but the library
--   implementation adopts a more synchronous design in which
--   <a>throwTo</a> does not return until the exception is received by the
--   target thread. The trade-off is discussed in Section 9 of the paper.
--   Like any blocking operation, <a>throwTo</a> is therefore interruptible
--   (see Section 5.3 of the paper). Unlike other interruptible operations,
--   however, <a>throwTo</a> is <i>always</i> interruptible, even if it
--   does not actually block.
--   
--   There is no guarantee that the exception will be delivered promptly,
--   although the runtime will endeavour to ensure that arbitrary delays
--   don't occur. In GHC, an exception can only be raised when a thread
--   reaches a <i>safe point</i>, where a safe point is where memory
--   allocation occurs. Some loops do not perform any memory allocation
--   inside the loop and therefore cannot be interrupted by a
--   <a>throwTo</a>.
--   
--   If the target of <a>throwTo</a> is the calling thread, then the
--   behaviour is the same as <a>throwIO</a>, except that the exception is
--   thrown as an asynchronous exception. This means that if there is an
--   enclosing pure computation, which would be the case if the current IO
--   operation is inside <a>unsafePerformIO</a> or
--   <a>unsafeInterleaveIO</a>, that computation is not permanently
--   replaced by the exception, but is suspended as if it had received an
--   asynchronous exception.
--   
--   Note that if <a>throwTo</a> is called with the current thread as the
--   target, the exception will be thrown even if the thread is currently
--   inside <a>mask</a> or <a>uninterruptibleMask</a>.
throwTo :: Exception e => ThreadId -> e -> IO ()

-- | Install standard signal handlers for catching ^C, which just throw an
--   exception in the target thread. The current target thread is the
--   thread at the head of the list in the MVar passed to
--   installSignalHandlers.
installSignalHandlers :: IO ()
pushInterruptTargetThread :: ThreadId -> IO ()
popInterruptTargetThread :: IO ()
instance Exception GhcException
instance Show GhcException


-- | Highly random utility functions
module Util
ghciSupported :: Bool
debugIsOn :: Bool
ncgDebugIsOn :: Bool
ghciTablesNextToCode :: Bool
isWindowsHost :: Bool
isDarwinHost :: Bool
zipEqual :: String -> [a] -> [b] -> [(a, b)]
zipWithEqual :: String -> (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3Equal :: String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith4Equal :: String -> (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]

-- | <a>zipLazy</a> is a kind of <a>zip</a> that is lazy in the second list
--   (observe the ~)
zipLazy :: [a] -> [b] -> [(a, b)]

-- | <tt>stretchZipWith p z f xs ys</tt> stretches <tt>ys</tt> by inserting
--   <tt>z</tt> in the places where <tt>p</tt> returns <tt>True</tt>
stretchZipWith :: (a -> Bool) -> b -> (a -> b -> c) -> [a] -> [b] -> [c]
zipWithAndUnzip :: (a -> b -> (c, d)) -> [a] -> [b] -> ([c], [d])

-- | <a>filterByList</a> takes a list of Bools and a list of some elements
--   and filters out these elements for which the corresponding value in
--   the list of Bools is False. This function does not check whether the
--   lists have equal length.
filterByList :: [Bool] -> [a] -> [a]
unzipWith :: (a -> b -> c) -> [(a, b)] -> [c]
mapFst :: (a -> c) -> [(a, b)] -> [(c, b)]
mapSnd :: (b -> c) -> [(a, b)] -> [(a, c)]
chkAppend :: [a] -> [a] -> [a]
mapAndUnzip :: (a -> (b, c)) -> [a] -> ([b], [c])
mapAndUnzip3 :: (a -> (b, c, d)) -> [a] -> ([b], [c], [d])
mapAccumL2 :: (s1 -> s2 -> a -> (s1, s2, b)) -> s1 -> s2 -> [a] -> (s1, s2, [b])
nOfThem :: Int -> a -> [a]

-- | Like filter, only it reverses the sense of the test
filterOut :: (a -> Bool) -> [a] -> [a]

-- | Uses a function to determine which of two output lists an input
--   element should join
partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])

-- | Teases a list of <a>Either</a>s apart into two lists
splitEithers :: [Either a b] -> ([a], [b])
dropWhileEndLE :: (a -> Bool) -> [a] -> [a]

-- | A strict version of <a>foldl1</a>
foldl1' :: (a -> a -> a) -> [a] -> a
foldl2 :: (acc -> a -> b -> acc) -> acc -> [a] -> [b] -> acc
count :: (a -> Bool) -> [a] -> Int
all2 :: (a -> b -> Bool) -> [a] -> [b] -> Bool

-- | <pre>
--   (lengthExceeds xs n) = (length xs &gt; n)
--   </pre>
lengthExceeds :: [a] -> Int -> Bool
lengthIs :: [a] -> Int -> Bool
lengthAtLeast :: [a] -> Int -> Bool
listLengthCmp :: [a] -> Int -> Ordering

-- | <tt>atLength atLen atEnd ls n</tt> unravels list <tt>ls</tt> to
--   position <tt>n</tt>. Precisely:
--   
--   <pre>
--   atLength atLenPred atEndPred ls n
--    | n &lt; 0         = atLenPred n
--    | length ls &lt; n = atEndPred (n - length ls)
--    | otherwise     = atLenPred (drop n ls)
--   </pre>
atLength :: ([a] -> b) -> (Int -> b) -> [a] -> Int -> b
equalLength :: [a] -> [b] -> Bool
compareLength :: [a] -> [b] -> Ordering

-- | True if length xs &lt;= length ys
leLength :: [a] -> [b] -> Bool
isSingleton :: [a] -> Bool
only :: [a] -> a
singleton :: a -> [a]
notNull :: [a] -> Bool
snocView :: [a] -> Maybe ([a], a)
isIn :: Eq a => String -> a -> [a] -> Bool
isn'tIn :: Eq a => String -> a -> [a] -> Bool
fstOf3 :: (a, b, c) -> a
sndOf3 :: (a, b, c) -> b
thirdOf3 :: (a, b, c) -> c
firstM :: Monad m => (a -> m c) -> (a, b) -> m (c, b)
first3M :: Monad m => (a -> m d) -> (a, b, c) -> m (d, b, c)
third3 :: (c -> d) -> (a, b, c) -> (a, b, d)
uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
takeList :: [b] -> [a] -> [a]
dropList :: [b] -> [a] -> [a]
splitAtList :: [b] -> [a] -> ([a], [a])
split :: Char -> String -> [String]
dropTail :: Int -> [a] -> [a]

-- | Compose a function with itself n times. (nth rather than twice)
nTimes :: Int -> (a -> a) -> (a -> a)
sortWith :: Ord b => (a -> b) -> [a] -> [a]
minWith :: Ord b => (a -> b) -> [a] -> a
nubSort :: Ord a => [a] -> [a]
isEqual :: Ordering -> Bool
eqListBy :: (a -> a -> Bool) -> [a] -> [a] -> Bool
eqMaybeBy :: (a -> a -> Bool) -> Maybe a -> Maybe a -> Bool
thenCmp :: Ordering -> Ordering -> Ordering
cmpList :: (a -> a -> Ordering) -> [a] -> [a] -> Ordering
removeSpaces :: String -> String
fuzzyMatch :: String -> [String] -> [String]

-- | Search for possible matches to the users input in the given list,
--   returning a small number of ranked results
fuzzyLookup :: String -> [(String, a)] -> [a]
transitiveClosure :: (a -> [a]) -> (a -> a -> Bool) -> [a] -> [a]
seqList :: [a] -> b -> b
looksLikeModuleName :: String -> Bool
getCmd :: String -> Either String (String, String)
toCmdArgs :: String -> Either String (String, [String])
toArgs :: String -> Either String [String]
readRational :: String -> Rational
maybeRead :: Read a => String -> Maybe a
maybeReadFuzzy :: Read a => String -> Maybe a
doesDirNameExist :: FilePath -> IO Bool
getModificationUTCTime :: FilePath -> IO UTCTime
modificationTimeIfExists :: FilePath -> IO (Maybe UTCTime)
global :: a -> IORef a
consIORef :: IORef [a] -> a -> IO ()
globalM :: IO a -> IORef a
type Suffix = String
splitLongestPrefix :: String -> (Char -> Bool) -> (String, String)
escapeSpaces :: String -> String
data Direction
[Forwards] :: Direction
[Backwards] :: Direction
reslash :: Direction -> FilePath -> FilePath
makeRelativeTo :: FilePath -> FilePath -> FilePath
abstractConstr :: String -> Constr
abstractDataType :: String -> DataType

-- | Constructs a non-representation for a non-representable type
mkNoRepType :: String -> DataType
charToC :: Word8 -> String

-- | A sample hash function for Strings. We keep multiplying by the golden
--   ratio and adding. The implementation is:
--   
--   <pre>
--   hashString = foldl' f golden
--     where f m c = fromIntegral (ord c) * magic + hashInt32 m
--           magic = 0xdeadbeef
--   </pre>
--   
--   Where hashInt32 works just as hashInt shown above.
--   
--   Knuth argues that repeated multiplication by the golden ratio will
--   minimize gaps in the hash space, and thus it's a good choice for
--   combining together multiple keys to form one.
--   
--   Here we know that individual characters c are often small, and this
--   produces frequent collisions if we use ord c alone. A particular
--   problem are the shorter low ASCII and ISO-8859-1 character strings. We
--   pre-multiply by a magic twiddle factor to obtain a good distribution.
--   In fact, given the following test:
--   
--   <pre>
--   testp :: Int32 -&gt; Int
--   testp k = (n - ) . length . group . sort . map hs . take n $ ls
--     where ls = [] : [c : l | l &lt;- ls, c &lt;- ['\0'..'\xff']]
--           hs = foldl' f golden
--           f m c = fromIntegral (ord c) * k + hashInt32 m
--           n = 100000
--   </pre>
--   
--   We discover that testp magic = 0.
hashString :: String -> Int32


-- | There are two principal string types used internally by GHC:
--   
--   <ul>
--   <li><i><a>FastString</a></i></li>
--   </ul>
--   
--   <ul>
--   <li>A compact, hash-consed, representation of character strings.</li>
--   <li>Comparison is O(1), and you can get a <a>Unique</a> from
--   them.</li>
--   <li>Generated by <a>fsLit</a>.</li>
--   <li>Turn into <a>SDoc</a> with <a>ftext</a>.</li>
--   </ul>
--   
--   <ul>
--   <li><i><a>LitString</a></i></li>
--   </ul>
--   
--   <ul>
--   <li>Just a wrapper for the <tt>Addr#</tt> of a C string (<tt>Ptr
--   CChar</tt>).</li>
--   <li>Practically no operations.</li>
--   <li>Outputing them is fast.</li>
--   <li>Generated by <a>sLit</a>.</li>
--   <li>Turn into <a>SDoc</a> with <a>ptext</a></li>
--   </ul>
--   
--   Use <a>LitString</a> unless you want the facilities of
--   <a>FastString</a>.
module FastString
fastStringToByteString :: FastString -> ByteString

-- | Create a <a>FastString</a> from an existing <a>ForeignPtr</a>; the
--   difference between this and <a>mkFastStringBytes</a> is that we don't
--   have to copy the bytes if the string is new to the table.
mkFastStringByteString :: ByteString -> FastString
fastZStringToByteString :: FastZString -> ByteString
unsafeMkByteString :: String -> ByteString
hashByteString :: ByteString -> Int
data FastZString
hPutFZS :: Handle -> FastZString -> IO ()
zString :: FastZString -> String
lengthFZS :: FastZString -> Int

-- | A <a>FastString</a> is an array of bytes, hashed to support fast O(1)
--   comparison. It is also associated with a character encoding, so that
--   we know how to convert a <a>FastString</a> to the local encoding, or
--   to the Z-encoding used by the compiler internally.
--   
--   <a>FastString</a>s support a memoized conversion to the Z-encoding via
--   zEncodeFS.
data FastString
[FastString] :: {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !ByteString -> {-# UNPACK #-} !(IORef (Maybe FastZString)) -> FastString
[uniq] :: FastString -> {-# UNPACK #-} !Int
[n_chars] :: FastString -> {-# UNPACK #-} !Int
[fs_bs] :: FastString -> {-# UNPACK #-} !ByteString
[fs_ref] :: FastString -> {-# UNPACK #-} !(IORef (Maybe FastZString))
fsLit :: String -> FastString

-- | Creates a UTF-8 encoded <a>FastString</a> from a <a>String</a>
mkFastString :: String -> FastString
mkFastStringBytes :: Ptr Word8 -> Int -> FastString

-- | Creates a <a>FastString</a> from a UTF-8 encoded <tt>[Word8]</tt>
mkFastStringByteList :: [Word8] -> FastString

-- | Create a <a>FastString</a> from an existing <a>ForeignPtr</a>; the
--   difference between this and <a>mkFastStringBytes</a> is that we don't
--   have to copy the bytes if the string is new to the table.
mkFastStringForeignPtr :: Ptr Word8 -> ForeignPtr Word8 -> Int -> IO FastString
mkFastString# :: Addr# -> FastString

-- | Unpacks and decodes the FastString
unpackFS :: FastString -> String

-- | Gives the UTF-8 encoded bytes corresponding to a <a>FastString</a>
bytesFS :: FastString -> [Word8]

-- | Returns a Z-encoded version of a <a>FastString</a>. This might be the
--   original, if it was already Z-encoded. The first time this function is
--   applied to a particular <a>FastString</a>, the results are memoized.
zEncodeFS :: FastString -> FastZString
uniqueOfFS :: FastString -> FastInt

-- | Returns the length of the <a>FastString</a> in characters
lengthFS :: FastString -> Int

-- | Returns <tt>True</tt> if the <a>FastString</a> is empty
nullFS :: FastString -> Bool
appendFS :: FastString -> FastString -> FastString
headFS :: FastString -> Char
tailFS :: FastString -> FastString
concatFS :: [FastString] -> FastString
consFS :: Char -> FastString -> FastString
nilFS :: FastString

-- | Outputs a <a>FastString</a> with <i>no decoding at all</i>, that is,
--   you get the actual bytes in the <a>FastString</a> written to the
--   <a>Handle</a>.
hPutFS :: Handle -> FastString -> IO ()
getFastStringTable :: IO [[FastString]]

-- | Returns <tt>True</tt> if this <a>FastString</a> is not Z-encoded but
--   already has a Z-encoding cached (used in producing stats).
hasZEncoding :: FastString -> Bool
type LitString = Ptr Word8
sLit :: String -> LitString
mkLitString# :: Addr# -> LitString
mkLitString :: String -> LitString
unpackLitString :: LitString -> String
lengthLS :: LitString -> Int
instance Eq FastString
instance Ord FastString
instance Show FastString
instance Data FastString

module BufWrite
data BufHandle
[BufHandle] :: {-# UNPACK #-} !(Ptr Word8) -> {-# UNPACK #-} !FastMutInt -> Handle -> BufHandle
newBufHandle :: Handle -> IO BufHandle
bPutChar :: BufHandle -> Char -> IO ()
bPutStr :: BufHandle -> String -> IO ()
bPutFS :: BufHandle -> FastString -> IO ()
bPutFZS :: BufHandle -> FastZString -> IO ()
bPutLitString :: BufHandle -> LitString -> FastInt -> IO ()
bFlush :: BufHandle -> IO ()

module Pretty
data Doc
data Mode
[PageMode] :: Mode
[ZigZagMode] :: Mode
[LeftMode] :: Mode
[OneLineMode] :: Mode
data TextDetails
[Chr] :: {-# UNPACK #-} !Char -> TextDetails
[Str] :: String -> TextDetails
[PStr] :: FastString -> TextDetails
[ZStr] :: FastZString -> TextDetails
[LStr] :: {-# UNPACK #-} !LitString -> FastInt -> TextDetails
empty :: Doc
isEmpty :: Doc -> Bool
nest :: Int -> Doc -> Doc
char :: Char -> Doc
text :: String -> Doc
ftext :: FastString -> Doc
ptext :: LitString -> Doc
ztext :: FastZString -> Doc

-- | Some text, but without any width. Use for non-printing text such as a
--   HTML or Latex tags
zeroWidthText :: String -> Doc
int :: Int -> Doc
integer :: Integer -> Doc
float :: Float -> Doc
double :: Double -> Doc
rational :: Rational -> Doc
parens :: Doc -> Doc
brackets :: Doc -> Doc
braces :: Doc -> Doc
quotes :: Doc -> Doc
quote :: Doc -> Doc
doubleQuotes :: Doc -> Doc
semi :: Doc
comma :: Doc
colon :: Doc
space :: Doc
equals :: Doc
lparen :: Doc
rparen :: Doc
lbrack :: Doc
rbrack :: Doc
lbrace :: Doc
rbrace :: Doc
cparen :: Bool -> Doc -> Doc
(<>) :: Doc -> Doc -> Doc
(<+>) :: Doc -> Doc -> Doc
hcat :: [Doc] -> Doc
hsep :: [Doc] -> Doc
($$) :: Doc -> Doc -> Doc
($+$) :: Doc -> Doc -> Doc
vcat :: [Doc] -> Doc
sep :: [Doc] -> Doc
cat :: [Doc] -> Doc
fsep :: [Doc] -> Doc
fcat :: [Doc] -> Doc
hang :: Doc -> Int -> Doc -> Doc
punctuate :: Doc -> [Doc] -> [Doc]
fullRender :: Mode -> Int -> Float -> (TextDetails -> a -> a) -> a -> Doc -> a
printDoc :: Mode -> Int -> Handle -> Doc -> IO ()
printDoc_ :: Mode -> Int -> Handle -> Doc -> IO ()
showDoc :: Mode -> Int -> Doc -> String
bufLeftRender :: BufHandle -> Doc -> IO ()
instance Show Doc


-- | This module defines classes and functions for pretty-printing. It also
--   exports a number of helpful debugging and other utilities such as
--   <a>trace</a> and <a>panic</a>.
--   
--   The interface to this module is very similar to the standard Hughes-PJ
--   pretty printing module, except that it exports a number of additional
--   functions that are rarely used, and works over the <a>SDoc</a> type.
module Outputable

-- | Class designating that some type has an <a>SDoc</a> representation
class Outputable a where ppr = pprPrec 0 pprPrec _ = ppr
ppr :: Outputable a => a -> SDoc
pprPrec :: Outputable a => Rational -> a -> SDoc

-- | When we print a binder, we often want to print its type too. The
--   <tt>OutputableBndr</tt> class encapsulates this idea.
class Outputable a => OutputableBndr a where pprBndr _b x = ppr x
pprBndr :: OutputableBndr a => BindingSite -> a -> SDoc
pprPrefixOcc, pprInfixOcc :: OutputableBndr a => a -> SDoc
data SDoc
runSDoc :: SDoc -> SDocContext -> Doc
initSDocContext :: DynFlags -> PprStyle -> SDocContext
docToSDoc :: Doc -> SDoc

-- | Returns the separated concatenation of the pretty printed things.
interppSP :: Outputable a => [a] -> SDoc

-- | Returns the comma-separated concatenation of the pretty printed
--   things.
interpp'SP :: Outputable a => [a] -> SDoc

-- | Returns the comma-separated concatenation of the quoted pretty printed
--   things.
--   
--   <pre>
--   [x,y,z]  ==&gt;  `x', `y', `z'
--   </pre>
pprQuotedList :: Outputable a => [a] -> SDoc
pprWithCommas :: (a -> SDoc) -> [a] -> SDoc
quotedListWithOr :: [SDoc] -> SDoc
empty :: SDoc

-- | Indent <a>SDoc</a> some specified amount
nest :: Int -> SDoc -> SDoc
char :: Char -> SDoc
text :: String -> SDoc
ftext :: FastString -> SDoc
ptext :: LitString -> SDoc
ztext :: FastZString -> SDoc
int :: Int -> SDoc
intWithCommas :: Integral a => a -> SDoc
integer :: Integer -> SDoc
float :: Float -> SDoc
double :: Double -> SDoc
rational :: Rational -> SDoc
parens :: SDoc -> SDoc
cparen :: Bool -> SDoc -> SDoc
brackets :: SDoc -> SDoc
braces :: SDoc -> SDoc
quotes :: SDoc -> SDoc
quote :: SDoc -> SDoc
doubleQuotes :: SDoc -> SDoc
angleBrackets :: SDoc -> SDoc
paBrackets :: SDoc -> SDoc
semi :: SDoc
comma :: SDoc
colon :: SDoc
dcolon :: SDoc
space :: SDoc
equals :: SDoc
dot :: SDoc
arrow :: SDoc
larrow :: SDoc
darrow :: SDoc
arrowt :: SDoc
larrowt :: SDoc
arrowtt :: SDoc
larrowtt :: SDoc
lparen :: SDoc
rparen :: SDoc
lbrack :: SDoc
rbrack :: SDoc
lbrace :: SDoc
rbrace :: SDoc
underscore :: SDoc
blankLine :: SDoc
forAllLit :: SDoc

-- | Join two <a>SDoc</a> together horizontally without a gap
(<>) :: SDoc -> SDoc -> SDoc

-- | Join two <a>SDoc</a> together horizontally with a gap between them
(<+>) :: SDoc -> SDoc -> SDoc

-- | Concatenate <a>SDoc</a> horizontally
hcat :: [SDoc] -> SDoc

-- | Concatenate <a>SDoc</a> horizontally with a space between each one
hsep :: [SDoc] -> SDoc

-- | Join two <a>SDoc</a> together vertically; if there is no vertical
--   overlap it "dovetails" the two onto one line
($$) :: SDoc -> SDoc -> SDoc

-- | Join two <a>SDoc</a> together vertically
($+$) :: SDoc -> SDoc -> SDoc

-- | Concatenate <a>SDoc</a> vertically with dovetailing
vcat :: [SDoc] -> SDoc

-- | Separate: is either like <a>hsep</a> or like <a>vcat</a>, depending on
--   what fits
sep :: [SDoc] -> SDoc

-- | Catenate: is either like <a>hcat</a> or like <a>vcat</a>, depending on
--   what fits
cat :: [SDoc] -> SDoc

-- | A paragraph-fill combinator. It's much like sep, only it keeps fitting
--   things on one line until it can't fit any more.
fsep :: [SDoc] -> SDoc

-- | This behaves like <a>fsep</a>, but it uses <a>&lt;&gt;</a> for
--   horizontal conposition rather than <a>&lt;+&gt;</a>
fcat :: [SDoc] -> SDoc
hang :: SDoc -> Int -> SDoc -> SDoc
punctuate :: SDoc -> [SDoc] -> [SDoc]
ppWhen :: Bool -> SDoc -> SDoc
ppUnless :: Bool -> SDoc -> SDoc

-- | Converts an integer to a verbal index:
--   
--   <pre>
--   speakNth 1 = text "first"
--   speakNth 5 = text "fifth"
--   speakNth 21 = text "21st"
--   </pre>
speakNth :: Int -> SDoc

-- | Converts a strictly positive integer into a number of times:
--   
--   <pre>
--   speakNTimes 1 = text "once"
--   speakNTimes 2 = text "twice"
--   speakNTimes 4 = text "4 times"
--   </pre>
speakNTimes :: Int -> SDoc

-- | Converts an integer to a verbal multiplicity:
--   
--   <pre>
--   speakN 0 = text "none"
--   speakN 5 = text "five"
--   speakN 10 = text "10"
--   </pre>
speakN :: Int -> SDoc

-- | Converts an integer and object description to a statement about the
--   multiplicity of those objects:
--   
--   <pre>
--   speakNOf 0 (text "melon") = text "no melons"
--   speakNOf 1 (text "melon") = text "one melon"
--   speakNOf 3 (text "melon") = text "three melons"
--   </pre>
speakNOf :: Int -> SDoc -> SDoc

-- | Determines the pluralisation suffix appropriate for the length of a
--   list:
--   
--   <pre>
--   plural [] = char 's'
--   plural ["Hello"] = empty
--   plural ["Hello", "World"] = char 's'
--   </pre>
plural :: [a] -> SDoc

-- | Determines the form of to be appropriate for the length of a list:
--   
--   <pre>
--   isOrAre [] = ptext (sLit "are")
--   isOrAre ["Hello"] = ptext (sLit "is")
--   isOrAre ["Hello", "World"] = ptext (sLit "are")
--   </pre>
isOrAre :: [a] -> SDoc

-- | Apply the given colour/style for the argument.
--   
--   Only takes effect if colours are enabled.
coloured :: PprColour -> SDoc -> SDoc

-- | A colour/style for use with <a>coloured</a>.
data PprColour
colType :: PprColour
colCoerc :: PprColour
colDataCon :: PprColour
colBinder :: PprColour
bold :: SDoc -> SDoc
keyword :: SDoc -> SDoc
printForC :: DynFlags -> Handle -> SDoc -> IO ()
printForAsm :: DynFlags -> Handle -> SDoc -> IO ()
printForUser :: DynFlags -> Handle -> PrintUnqualified -> SDoc -> IO ()
printForUserPartWay :: DynFlags -> Handle -> Int -> PrintUnqualified -> SDoc -> IO ()
pprCode :: CodeStyle -> SDoc -> SDoc
mkCodeStyle :: CodeStyle -> PprStyle
showSDoc :: DynFlags -> SDoc -> String
showSDocUnsafe :: SDoc -> String
showSDocOneLine :: DynFlags -> SDoc -> String
showSDocForUser :: DynFlags -> PrintUnqualified -> SDoc -> String
showSDocDebug :: DynFlags -> SDoc -> String
showSDocDump :: DynFlags -> SDoc -> String
showSDocDumpOneLine :: DynFlags -> SDoc -> String
showSDocUnqual :: DynFlags -> SDoc -> String
showPpr :: Outputable a => DynFlags -> a -> String
renderWithStyle :: DynFlags -> SDoc -> PprStyle -> String
pprInfixVar :: Bool -> SDoc -> SDoc
pprPrefixVar :: Bool -> SDoc -> SDoc

-- | Special combinator for showing character literals.
pprHsChar :: Char -> SDoc

-- | Special combinator for showing string literals.
pprHsString :: FastString -> SDoc

-- | Special combinator for showing string literals.
pprHsBytes :: ByteString -> SDoc
pprFastFilePath :: FastString -> SDoc

-- | <a>BindingSite</a> is used to tell the thing that prints binder what
--   language construct is binding the identifier. This can be used to
--   decide how much info to print.
data BindingSite
[LambdaBind] :: BindingSite
[CaseBind] :: BindingSite
[LetBind] :: BindingSite
data PprStyle
data CodeStyle
[CStyle] :: CodeStyle
[AsmStyle] :: CodeStyle

-- | 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 <a>SDoc</a>.
data PrintUnqualified
[QueryQualify] :: QueryQualifyName -> QueryQualifyModule -> QueryQualifyPackage -> PrintUnqualified
[queryQualifyName] :: PrintUnqualified -> QueryQualifyName
[queryQualifyModule] :: PrintUnqualified -> QueryQualifyModule
[queryQualifyPackage] :: PrintUnqualified -> QueryQualifyPackage

-- | given an <i>original</i> name, this function tells you which module
--   name it should be qualified with when printing for the user, if any.
--   For example, given <tt>Control.Exception.catch</tt>, which is in scope
--   as <tt>Exception.catch</tt>, this fuction will return <tt>Just
--   <a>Exception</a></tt>. Note that the return value is a ModuleName, not
--   a Module, because in source code, names are qualified by ModuleNames.
type QueryQualifyName = Module -> OccName -> QualifyName

-- | For a given module, we need to know whether to print it with a package
--   name to disambiguate it.
type QueryQualifyModule = Module -> Bool

-- | For a given package, we need to know whether to print it with the
--   package key to disambiguate it.
type QueryQualifyPackage = PackageKey -> Bool
reallyAlwaysQualify :: PrintUnqualified
reallyAlwaysQualifyNames :: QueryQualifyName
alwaysQualify :: PrintUnqualified

-- | NB: This won't ever show package IDs
alwaysQualifyNames :: QueryQualifyName
alwaysQualifyModules :: QueryQualifyModule
neverQualify :: PrintUnqualified
neverQualifyNames :: QueryQualifyName
neverQualifyModules :: QueryQualifyModule
data QualifyName
[NameUnqual] :: QualifyName
[NameQual] :: ModuleName -> QualifyName
[NameNotInScope1] :: QualifyName
[NameNotInScope2] :: QualifyName
queryQual :: PprStyle -> PrintUnqualified
sdocWithDynFlags :: (DynFlags -> SDoc) -> SDoc
sdocWithPlatform :: (Platform -> SDoc) -> SDoc
getPprStyle :: (PprStyle -> SDoc) -> SDoc
withPprStyle :: PprStyle -> SDoc -> SDoc
withPprStyleDoc :: DynFlags -> PprStyle -> SDoc -> Doc
pprDeeper :: SDoc -> SDoc
pprDeeperList :: ([SDoc] -> SDoc) -> [SDoc] -> SDoc
pprSetDepth :: Depth -> SDoc -> SDoc
codeStyle :: PprStyle -> Bool
userStyle :: PprStyle -> Bool
debugStyle :: PprStyle -> Bool
dumpStyle :: PprStyle -> Bool
asmStyle :: PprStyle -> Bool
ifPprDebug :: SDoc -> SDoc
qualName :: PprStyle -> QueryQualifyName
qualModule :: PprStyle -> QueryQualifyModule
qualPackage :: PprStyle -> QueryQualifyPackage

-- | Style for printing error messages
mkErrStyle :: DynFlags -> PrintUnqualified -> PprStyle
defaultErrStyle :: DynFlags -> PprStyle
defaultDumpStyle :: PprStyle
mkDumpStyle :: PrintUnqualified -> PprStyle
defaultUserStyle :: PprStyle
mkUserStyle :: PrintUnqualified -> Depth -> PprStyle
cmdlineParserStyle :: PprStyle
data Depth
[AllTheWay] :: Depth
[PartWay] :: Int -> Depth

-- | Throw an exception saying "bug in GHC"
pprPanic :: String -> SDoc -> a

-- | Throw an exception saying "this isn't finished yet"
pprSorry :: String -> SDoc -> a

-- | Panic with an assertation failure, recording the given file and line
--   number. Should typically be accessed with the ASSERT family of macros
assertPprPanic :: String -> Int -> SDoc -> a

-- | Specialization of pprPanic that can be safely used with <a>FastInt</a>
pprPanicFastInt :: String -> SDoc -> FastInt

-- | Throw an exception saying "bug in pgm being compiled" (used for
--   unusual program errors)
pprPgmError :: String -> SDoc -> a

-- | If debug output is on, show some <a>SDoc</a> on the screen
pprTrace :: String -> SDoc -> a -> a

-- | Just warn about an assertion failure, recording the given file and
--   line number. Should typically be accessed with the WARN macros
warnPprTrace :: Bool -> String -> Int -> SDoc -> a -> a

-- | The <a>trace</a> function outputs the trace message given as its first
--   argument, before returning the second argument as its result.
--   
--   For example, this returns the value of <tt>f x</tt> but first outputs
--   the message.
--   
--   <pre>
--   trace ("calling f with x = " ++ show x) (f x)
--   </pre>
--   
--   The <a>trace</a> function should <i>only</i> be used for debugging, or
--   for monitoring execution. The function is not referentially
--   transparent: its type indicates that it is a pure function but it has
--   the side effect of outputting the trace message.
trace :: String -> a -> a

-- | Panics and asserts.
pgmError :: String -> a

-- | Panics and asserts.
panic :: String -> a

-- | Panics and asserts.
sorry :: String -> a

-- | Panic while pretending to return an unboxed int. You can't use the
--   regular panic functions in expressions producing unboxed ints because
--   they have the wrong kind.
panicFastInt :: String -> FastInt

-- | Throw an failed assertion exception for a given filename and line
--   number.
assertPanic :: String -> Int -> a
pprDebugAndThen :: DynFlags -> (String -> a) -> SDoc -> SDoc -> a
instance Outputable Char
instance Outputable Bool
instance Outputable Int32
instance Outputable Int64
instance Outputable Int
instance Outputable Word16
instance Outputable Word32
instance Outputable Word
instance Outputable ()
instance Outputable a => Outputable [a]
instance Outputable a => Outputable (Set a)
instance (Outputable a, Outputable b) => Outputable (a, b)
instance Outputable a => Outputable (Maybe a)
instance (Outputable a, Outputable b) => Outputable (Either a b)
instance (Outputable a, Outputable b, Outputable c) => Outputable (a, b, c)
instance (Outputable a, Outputable b, Outputable c, Outputable d) => Outputable (a, b, c, d)
instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e) => Outputable (a, b, c, d, e)
instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f) => Outputable (a, b, c, d, e, f)
instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f, Outputable g) => Outputable (a, b, c, d, e, f, g)
instance Outputable FastString
instance (Outputable key, Outputable elt) => Outputable (Map key elt)
instance Outputable elt => Outputable (IntMap elt)
instance Outputable Fingerprint

module Pair
data Pair a
[Pair] :: a -> a -> Pair a
[pFst] :: Pair a -> a
[pSnd] :: Pair a -> a
unPair :: Pair a -> (a, a)
toPair :: (a, a) -> Pair a
swap :: Pair a -> Pair a
instance Functor Pair
instance Applicative Pair
instance Foldable Pair
instance Traversable Pair
instance Outputable a => Outputable (Pair a)


-- | This module contains types that relate to the positions of things in
--   source files, and allow tagging of those things with locations
module SrcLoc

-- | Represents a single point within a file
data RealSrcLoc
data SrcLoc
[RealSrcLoc] :: {-# UNPACK #-} !RealSrcLoc -> SrcLoc
[UnhelpfulLoc] :: FastString -> SrcLoc
mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc

-- | Creates a "bad" <a>SrcLoc</a> that has no detailed information about
--   its location
mkGeneralSrcLoc :: FastString -> SrcLoc

-- | Built-in "bad" <a>SrcLoc</a> values for particular locations
noSrcLoc :: SrcLoc

-- | Built-in "bad" <a>SrcLoc</a> values for particular locations
generatedSrcLoc :: SrcLoc

-- | Built-in "bad" <a>SrcLoc</a> values for particular locations
interactiveSrcLoc :: SrcLoc

-- | Move the <a>SrcLoc</a> down by one line if the character is a newline,
--   to the next 8-char tabstop if it is a tab, and across by one character
--   in any other case
advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc

-- | Gives the filename of the <a>RealSrcLoc</a>
srcLocFile :: RealSrcLoc -> FastString

-- | Raises an error when used on a "bad" <a>SrcLoc</a>
srcLocLine :: RealSrcLoc -> Int

-- | Raises an error when used on a "bad" <a>SrcLoc</a>
srcLocCol :: RealSrcLoc -> Int

-- | 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 <i>after</i> 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.
data RealSrcSpan
data SrcSpan
[RealSrcSpan] :: !RealSrcSpan -> SrcSpan
[UnhelpfulSpan] :: !FastString -> SrcSpan

-- | Create a "bad" <a>SrcSpan</a> that has not location information
mkGeneralSrcSpan :: FastString -> SrcSpan

-- | Create a <a>SrcSpan</a> between two points in a file
mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan

-- | Create a <a>SrcSpan</a> between two points in a file
mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan

-- | Built-in "bad" <a>SrcSpan</a>s for common sources of location
--   uncertainty
noSrcSpan :: SrcSpan

-- | Built-in "bad" <a>SrcSpan</a>s for common sources of location
--   uncertainty
wiredInSrcSpan :: SrcSpan

-- | Create a <a>SrcSpan</a> corresponding to a single point
srcLocSpan :: SrcLoc -> SrcSpan
realSrcLocSpan :: RealSrcLoc -> RealSrcSpan

-- | Combines two <a>SrcSpan</a> into one that spans at least all the
--   characters within both spans. Assumes the "file" part is the same in
--   both inputs
combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan

-- | Returns the location at the start of the <a>SrcSpan</a> or a "bad"
--   <a>SrcSpan</a> if that is unavailable
srcSpanStart :: SrcSpan -> SrcLoc

-- | Returns the location at the end of the <a>SrcSpan</a> or a "bad"
--   <a>SrcSpan</a> if that is unavailable
srcSpanEnd :: SrcSpan -> SrcLoc
realSrcSpanStart :: RealSrcSpan -> RealSrcLoc
realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc

-- | Obtains the filename for a <a>SrcSpan</a> if it is "good"
srcSpanFileName_maybe :: SrcSpan -> Maybe FastString
pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc
srcSpanFile :: RealSrcSpan -> FastString
srcSpanStartLine :: RealSrcSpan -> Int
srcSpanEndLine :: RealSrcSpan -> Int
srcSpanStartCol :: RealSrcSpan -> Int
srcSpanEndCol :: RealSrcSpan -> Int

-- | Test if a <a>SrcSpan</a> is "good", i.e. has precise location
--   information
isGoodSrcSpan :: SrcSpan -> Bool

-- | True if the span is known to straddle only one line. For "bad"
--   <a>SrcSpan</a>, it returns False
isOneLineSpan :: SrcSpan -> Bool

-- | Tests whether the first span "contains" the other span, meaning that
--   it covers at least as much source code. True where spans are equal.
containsSpan :: RealSrcSpan -> RealSrcSpan -> Bool
type Located e = GenLocated SrcSpan e
type RealLocated e = GenLocated RealSrcSpan e

-- | We attach SrcSpans to lots of things, so let's have a datatype for it.
data GenLocated l e
[L] :: l -> e -> GenLocated l e
noLoc :: e -> Located e
mkGeneralLocated :: String -> e -> Located e
getLoc :: GenLocated l e -> l
unLoc :: GenLocated l e -> e

-- | Tests whether the two located things are equal
eqLocated :: Eq a => Located a -> Located a -> Bool

-- | Tests the ordering of the two located things
cmpLocated :: Ord a => Located a -> Located a -> Ordering
combineLocs :: Located a -> Located b -> SrcSpan

-- | Combine locations from two <a>Located</a> things and add them to a
--   third thing
addCLoc :: Located a -> Located b -> c -> Located c

-- | Alternative strategies for ordering <a>SrcSpan</a>s
leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering

-- | Alternative strategies for ordering <a>SrcSpan</a>s
leftmost_largest :: SrcSpan -> SrcSpan -> Ordering

-- | Alternative strategies for ordering <a>SrcSpan</a>s
rightmost :: SrcSpan -> SrcSpan -> Ordering

-- | Determines whether a span encloses a given line and column index
spans :: SrcSpan -> (Int, Int) -> Bool

-- | Determines whether a span is enclosed by another one
isSubspanOf :: SrcSpan -> SrcSpan -> Bool
sortLocated :: [Located a] -> [Located a]
instance (Data l, Data e) => Data (GenLocated l e)
instance (Ord l, Ord e) => Ord (GenLocated l e)
instance (Eq l, Eq e) => Eq (GenLocated l e)
instance Show SrcSpan
instance Ord SrcSpan
instance Eq SrcSpan
instance Eq RealSrcSpan
instance Show SrcLoc
instance Foldable (GenLocated l)
instance Traversable (GenLocated l)
instance Eq SrcLoc
instance Eq RealSrcLoc
instance Ord SrcLoc
instance Ord RealSrcLoc
instance Outputable RealSrcLoc
instance Outputable SrcLoc
instance Data RealSrcSpan
instance Data SrcSpan
instance Ord RealSrcSpan
instance Show RealSrcLoc
instance Show RealSrcSpan
instance Outputable RealSrcSpan
instance Outputable SrcSpan
instance Functor (GenLocated l)
instance (Outputable l, Outputable e) => Outputable (GenLocated l e)

module BasicTypes
type Version = Int
bumpVersion :: Version -> Version
initialVersion :: Version

-- | Type of the tags associated with each constructor possibility
type ConTag = Int

-- | Tags are allocated from here for real constructors
fIRST_TAG :: ConTag

-- | The number of value arguments that can be applied to a value before it
--   does "real work". So: fib 100 has arity 0 x -&gt; fib x has arity 1
type Arity = Int

-- | The number of represented arguments that can be applied to a value
--   before it does "real work". So: fib 100 has representation arity 0 x
--   -&gt; fib x has representation arity 1 () -&gt; fib (x + y) has
--   representation arity 2
type RepArity = Int
type Alignment = Int
data FunctionOrData
[IsFunction] :: FunctionOrData
[IsData] :: FunctionOrData
data WarningTxt
[WarningTxt] :: (Located SourceText) -> [Located FastString] -> WarningTxt
[DeprecatedTxt] :: (Located SourceText) -> [Located FastString] -> WarningTxt
data Fixity
[Fixity] :: Int -> FixityDirection -> Fixity
data FixityDirection
[InfixL] :: FixityDirection
[InfixR] :: FixityDirection
[InfixN] :: FixityDirection
defaultFixity :: Fixity
maxPrecedence :: Int
minPrecedence :: Int
negateFixity :: Fixity
funTyFixity :: Fixity
compareFixity :: Fixity -> Fixity -> (Bool, Bool)
data RecFlag
[Recursive] :: RecFlag
[NonRecursive] :: RecFlag
isRec :: RecFlag -> Bool
isNonRec :: RecFlag -> Bool
boolToRecFlag :: Bool -> RecFlag
data Origin
[FromSource] :: Origin
[Generated] :: Origin
isGenerated :: Origin -> Bool
type RuleName = FastString
data TopLevelFlag
[TopLevel] :: TopLevelFlag
[NotTopLevel] :: TopLevelFlag
isTopLevel :: TopLevelFlag -> Bool
isNotTopLevel :: TopLevelFlag -> Bool

-- | The semantics allowed for overlapping instances for a particular
--   instance. See Note [Safe Haskell isSafeOverlap] (in <a>lhs</a>) for a
--   explanation of the <a>isSafeOverlap</a> field.
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{-# OVERLAPPABLE'</tt>
--   or <tt>'{-# OVERLAPPING'</tt> or <tt>'{-# OVERLAPS'</tt> or <tt>'{-#
--   INCOHERENT'</tt>, <a>AnnClose</a> <tt>`#-}`</tt>,</li>
--   </ul>
data OverlapFlag
[OverlapFlag] :: OverlapMode -> Bool -> OverlapFlag
[overlapMode] :: OverlapFlag -> OverlapMode
[isSafeOverlap] :: OverlapFlag -> Bool
data OverlapMode

-- | This instance must not overlap another <a>NoOverlap</a> instance.
--   However, it may be overlapped by <a>Overlapping</a> instances, and it
--   may overlap <a>Overlappable</a> instances.
[NoOverlap] :: SourceText -> OverlapMode

-- | Silently ignore this instance if you find a more specific one that
--   matches the constraint you are trying to resolve
--   
--   Example: constraint (Foo [Int]) instance Foo [Int] instance {--} Foo
--   [a]
--   
--   Since the second instance has the Overlappable flag, the first
--   instance will be chosen (otherwise its ambiguous which to choose)
[Overlappable] :: SourceText -> OverlapMode

-- | Silently ignore any more general instances that may be used to solve
--   the constraint.
--   
--   Example: constraint (Foo [Int]) instance {--} Foo [Int] instance Foo
--   [a]
--   
--   Since the first instance has the Overlapping flag, the second---more
--   general---instance will be ignored (otherwise it is ambiguous which to
--   choose)
[Overlapping] :: SourceText -> OverlapMode

-- | Equivalent to having both <a>Overlapping</a> and <a>Overlappable</a>
--   flags.
[Overlaps] :: SourceText -> OverlapMode

-- | Behave like Overlappable and Overlapping, and in addition pick an an
--   arbitrary one if there are multiple matching candidates, and don't
--   worry about later instantiation
--   
--   Example: constraint (Foo [b]) instance {-# INCOHERENT -} Foo [Int]
--   instance Foo [a] Without the Incoherent flag, we'd complain that
--   instantiating <tt>b</tt> would change which instance was chosen. See
--   also note [Incoherent instances] in InstEnv
[Incoherent] :: SourceText -> OverlapMode
setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag
hasOverlappingFlag :: OverlapMode -> Bool
hasOverlappableFlag :: OverlapMode -> Bool
data Boxity
[Boxed] :: Boxity
[Unboxed] :: Boxity
isBoxed :: Boxity -> Bool
data TupleSort
[BoxedTuple] :: TupleSort
[UnboxedTuple] :: TupleSort
[ConstraintTuple] :: TupleSort
tupleSortBoxity :: TupleSort -> Boxity
boxityNormalTupleSort :: Boxity -> TupleSort
tupleParens :: TupleSort -> SDoc -> SDoc

-- | If the <tt>Id</tt> is a lambda-bound variable then it may have
--   lambda-bound variable info. Sometimes we know whether the lambda
--   binding this variable is a "one-shot" lambda; that is, whether it is
--   applied at most once.
--   
--   This information may be useful in optimisation, as computations may
--   safely be floated inside such a lambda without risk of duplicating
--   work.
data OneShotInfo

-- | No information
[NoOneShotInfo] :: OneShotInfo

-- | The lambda is probably applied at most once See Note [Computing
--   one-shot info, and ProbOneShot] in OccurAnl
[ProbOneShot] :: OneShotInfo

-- | The lambda is applied at most once.
[OneShotLam] :: OneShotInfo

-- | It is always safe to assume that an <tt>Id</tt> has no lambda-bound
--   variable information
noOneShotInfo :: OneShotInfo
hasNoOneShotInfo :: OneShotInfo -> Bool
isOneShotInfo :: OneShotInfo -> Bool
bestOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo
worstOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo

-- | Identifier occurrence information
data OccInfo

-- | There are many occurrences, or unknown occurrences
[NoOccInfo] :: OccInfo

-- | Marks unused variables. Sometimes useful for lambda and case-bound
--   variables.
[IAmDead] :: OccInfo

-- | Occurs exactly once, not inside a rule
[OneOcc] :: !InsideLam -> !OneBranch -> !InterestingCxt -> OccInfo

-- | This identifier breaks a loop of mutually recursive functions. The
--   field marks whether it is only a loop breaker due to a reference in a
--   rule
[IAmALoopBreaker] :: !RulesOnly -> OccInfo
seqOccInfo :: OccInfo -> ()
zapFragileOcc :: OccInfo -> OccInfo
isOneOcc :: OccInfo -> Bool
isDeadOcc :: OccInfo -> Bool
isStrongLoopBreaker :: OccInfo -> Bool
isWeakLoopBreaker :: OccInfo -> Bool
isNoOcc :: OccInfo -> Bool
strongLoopBreaker :: OccInfo
weakLoopBreaker :: OccInfo
type InsideLam = Bool
insideLam :: InsideLam
notInsideLam :: InsideLam
type OneBranch = Bool
oneBranch :: OneBranch
notOneBranch :: OneBranch
type InterestingCxt = Bool
data EP a
[EP] :: a -> a -> EP a
[fromEP] :: EP a -> a
[toEP] :: EP a -> a
data DefMethSpec
[NoDM] :: DefMethSpec
[VanillaDM] :: DefMethSpec
[GenericDM] :: DefMethSpec
data SwapFlag
[NotSwapped] :: SwapFlag
[IsSwapped] :: SwapFlag
flipSwap :: SwapFlag -> SwapFlag
unSwap :: SwapFlag -> (a -> a -> b) -> a -> a -> b
isSwapped :: SwapFlag -> Bool
data CompilerPhase
[Phase] :: PhaseNum -> CompilerPhase
[InitialPhase] :: CompilerPhase
type PhaseNum = Int
data Activation
[NeverActive] :: Activation
[AlwaysActive] :: Activation
[ActiveBefore] :: PhaseNum -> Activation
[ActiveAfter] :: PhaseNum -> Activation
isActive :: CompilerPhase -> Activation -> Bool
isActiveIn :: PhaseNum -> Activation -> Bool
isNeverActive :: Activation -> Bool
isAlwaysActive :: Activation -> Bool
isEarlyActive :: Activation -> Bool
data RuleMatchInfo
[ConLike] :: RuleMatchInfo
[FunLike] :: RuleMatchInfo
isConLike :: RuleMatchInfo -> Bool
isFunLike :: RuleMatchInfo -> Bool
data InlineSpec
[Inline] :: InlineSpec
[Inlinable] :: InlineSpec
[NoInline] :: InlineSpec
[EmptyInlineSpec] :: InlineSpec
isEmptyInlineSpec :: InlineSpec -> Bool
data InlinePragma
[InlinePragma] :: SourceText -> InlineSpec -> Maybe Arity -> Activation -> RuleMatchInfo -> InlinePragma
[inl_src] :: InlinePragma -> SourceText
[inl_inline] :: InlinePragma -> InlineSpec
[inl_sat] :: InlinePragma -> Maybe Arity
[inl_act] :: InlinePragma -> Activation
[inl_rule] :: InlinePragma -> RuleMatchInfo
defaultInlinePragma :: InlinePragma
alwaysInlinePragma :: InlinePragma
neverInlinePragma :: InlinePragma
dfunInlinePragma :: InlinePragma
isDefaultInlinePragma :: InlinePragma -> Bool
isInlinePragma :: InlinePragma -> Bool
isInlinablePragma :: InlinePragma -> Bool
isAnyInlinePragma :: InlinePragma -> Bool
inlinePragmaSpec :: InlinePragma -> InlineSpec
inlinePragmaSat :: InlinePragma -> Maybe Arity
inlinePragmaActivation :: InlinePragma -> Activation
inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo
setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma
setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma
data SuccessFlag
[Succeeded] :: SuccessFlag
[Failed] :: SuccessFlag
succeeded :: SuccessFlag -> Bool
failed :: SuccessFlag -> Bool
successIf :: Bool -> SuccessFlag
data FractionalLit
[FL] :: String -> Rational -> FractionalLit
[fl_text] :: FractionalLit -> String
[fl_value] :: FractionalLit -> Rational
negateFractionalLit :: FractionalLit -> FractionalLit
integralFractionalLit :: Integer -> FractionalLit
newtype HValue
[HValue] :: Any -> HValue
type SourceText = String
instance Show FractionalLit
instance Data FractionalLit
instance Data InlinePragma
instance Eq InlinePragma
instance Show InlineSpec
instance Data InlineSpec
instance Eq InlineSpec
instance Show RuleMatchInfo
instance Data RuleMatchInfo
instance Eq RuleMatchInfo
instance Data Activation
instance Eq Activation
instance Data WarningTxt
instance Eq WarningTxt
instance Data OverlapFlag
instance Eq OverlapFlag
instance Data OverlapMode
instance Eq OverlapMode
instance Eq DefMethSpec
instance Eq OccInfo
instance Data TupleSort
instance Eq TupleSort
instance Data Origin
instance Eq Origin
instance Data RecFlag
instance Eq RecFlag
instance Data Boxity
instance Eq Boxity
instance Data Fixity
instance Data FixityDirection
instance Eq FixityDirection
instance Data FunctionOrData
instance Ord FunctionOrData
instance Eq FunctionOrData
instance Eq OneShotInfo
instance Outputable OneShotInfo
instance Outputable SwapFlag
instance Outputable FunctionOrData
instance Outputable WarningTxt
instance Outputable Fixity
instance Eq Fixity
instance Outputable FixityDirection
instance Outputable TopLevelFlag
instance Outputable RecFlag
instance Outputable Origin
instance Outputable OverlapFlag
instance Outputable OverlapMode
instance Outputable OccInfo
instance Outputable DefMethSpec
instance Outputable SuccessFlag
instance Outputable CompilerPhase
instance Outputable Activation
instance Outputable RuleMatchInfo
instance Outputable InlineSpec
instance Outputable InlinePragma
instance Eq FractionalLit
instance Ord FractionalLit
instance Outputable FractionalLit

module Unique

-- | The type of unique identifiers that are used in many places in GHC for
--   fast ordering and equality tests. You should generate these with the
--   functions from the <tt>UniqSupply</tt> module
data Unique

-- | Class of things that we can obtain a <a>Unique</a> from
class Uniquable a
getUnique :: Uniquable a => a -> Unique
hasKey :: Uniquable a => a -> Unique -> Bool
pprUnique :: Unique -> SDoc
mkUniqueGrimily :: Int -> Unique
getKey :: Unique -> Int
getKeyFastInt :: Unique -> FastInt
mkUnique :: Char -> Int -> Unique
unpkUnique :: Unique -> (Char, Int)
incrUnique :: Unique -> Unique
deriveUnique :: Unique -> Int -> Unique
newTagUnique :: Unique -> Char -> Unique
initTyVarUnique :: Unique
mkAlphaTyVarUnique :: Int -> Unique
mkPrimOpIdUnique :: Int -> Unique
mkTupleTyConUnique :: TupleSort -> Int -> Unique
mkTupleDataConUnique :: TupleSort -> Int -> Unique
mkPreludeMiscIdUnique :: Int -> Unique
mkPreludeDataConUnique :: Int -> Unique
mkPreludeTyConUnique :: Int -> Unique
mkPreludeClassUnique :: Int -> Unique
mkPArrDataConUnique :: Int -> Unique
mkVarOccUnique :: FastString -> Unique
mkDataOccUnique :: FastString -> Unique
mkTvOccUnique :: FastString -> Unique
mkTcOccUnique :: FastString -> Unique
mkRegSingleUnique :: Int -> Unique
mkRegPairUnique :: Int -> Unique
mkRegClassUnique :: Int -> Unique
mkRegSubUnique :: Int -> Unique
mkCostCentreUnique :: Int -> Unique
mkBuiltinUnique :: Int -> Unique
mkPseudoUniqueD :: Int -> Unique
mkPseudoUniqueE :: Int -> Unique
mkPseudoUniqueH :: Int -> Unique
instance Uniquable FastString
instance Uniquable Int
instance Eq Unique
instance Ord Unique
instance Uniquable Unique
instance Outputable Unique
instance Show Unique

module UniqSupply

-- | A value of type <a>UniqSupply</a> is unique, and it can supply
--   <i>one</i> distinct <a>Unique</a>. Also, from the supply, one can also
--   manufacture an arbitrary number of further <tt>UniqueSupply</tt>
--   values, which will be distinct from the first and from all others.
data UniqSupply

-- | Obtain the <a>Unique</a> from this particular <a>UniqSupply</a>
uniqFromSupply :: UniqSupply -> Unique

-- | Obtain an infinite list of <a>Unique</a> that can be generated by
--   constant splitting of the supply
uniqsFromSupply :: UniqSupply -> [Unique]

-- | Obtain the <a>Unique</a> from this particular <a>UniqSupply</a>, and a
--   new supply
takeUniqFromSupply :: UniqSupply -> (Unique, UniqSupply)

-- | Create a unique supply out of thin air. The character given must be
--   distinct from those of all calls to this function in the compiler for
--   the values generated to be truly unique.
mkSplitUniqSupply :: Char -> IO UniqSupply

-- | Build two <a>UniqSupply</a> from a single one, each of which can
--   supply its own <a>Unique</a>.
splitUniqSupply :: UniqSupply -> (UniqSupply, UniqSupply)

-- | Create an infinite list of <a>UniqSupply</a> from a single one
listSplitUniqSupply :: UniqSupply -> [UniqSupply]

-- | A monad which just gives the ability to obtain <a>Unique</a>s
data UniqSM result

-- | A monad for generating unique identifiers
class Monad m => MonadUnique m where getUniqueM = liftM uniqFromSupply getUniqueSupplyM getUniquesM = liftM uniqsFromSupply getUniqueSupplyM
getUniqueSupplyM :: MonadUnique m => m UniqSupply
getUniqueM :: MonadUnique m => m Unique
getUniquesM :: MonadUnique m => m [Unique]

-- | Run the <a>UniqSM</a> action, returning the final <a>UniqSupply</a>
initUs :: UniqSupply -> UniqSM a -> (a, UniqSupply)

-- | Run the <a>UniqSM</a> action, discarding the final <a>UniqSupply</a>
initUs_ :: UniqSupply -> UniqSM a -> a
lazyThenUs :: UniqSM a -> (a -> UniqSM b) -> UniqSM b
lazyMapUs :: (a -> UniqSM b) -> [a] -> UniqSM [b]
instance Monad UniqSM
instance Functor UniqSM
instance Applicative UniqSM
instance MonadFix UniqSM
instance MonadUnique UniqSM

module Hoopl.Dataflow

-- | A transfer function might want to use the logging flag to control
--   debugging, as in for example, it updates just one element in a big
--   finite map. We don't want Hoopl to show the whole fact, and only the
--   transfer function knows exactly what changed.
data DataflowLattice a :: * -> *
[DataflowLattice] :: String -> a -> JoinFun a -> DataflowLattice a
[fact_name] :: DataflowLattice a -> String
[fact_bot] :: DataflowLattice a -> a
[fact_join] :: DataflowLattice a -> JoinFun a
newtype OldFact a :: * -> *
[OldFact] :: a -> OldFact a
newtype NewFact a :: * -> *
[NewFact] :: a -> NewFact a

-- | <a>mkFactBase</a> creates a <a>FactBase</a> from a list of
--   (<a>Label</a>, fact) pairs. If the same label appears more than once,
--   the relevant facts are joined.
mkFactBase :: DataflowLattice f -> [(Label, f)] -> FactBase f
data ChangeFlag :: *
[NoChange] :: ChangeFlag
[SomeChange] :: ChangeFlag
data FwdPass (m :: * -> *) (n :: * -> * -> *) f :: (* -> *) -> (* -> * -> *) -> * -> *
[FwdPass] :: DataflowLattice f -> FwdTransfer n f -> FwdRewrite m n f -> FwdPass f
[fp_lattice] :: FwdPass f -> DataflowLattice f
[fp_transfer] :: FwdPass f -> FwdTransfer n f
[fp_rewrite] :: FwdPass f -> FwdRewrite m n f
data FwdTransfer (n :: * -> * -> *) f :: (* -> * -> *) -> * -> *
mkFTransfer :: (forall e x. n e x -> f -> Fact x f) -> FwdTransfer n f
mkFTransfer3 :: (n C O -> f -> f) -> (n O O -> f -> f) -> (n O C -> f -> FactBase f) -> FwdTransfer n f
getFTransfer3 :: FwdTransfer n f -> (n C O -> f -> f, n O O -> f -> f, n O C -> f -> FactBase f)
data FwdRewrite (m :: * -> *) (n :: * -> * -> *) f :: (* -> *) -> (* -> * -> *) -> * -> *

-- | Functions passed to <a>mkFRewrite</a> should not be aware of the fuel
--   supply. The result returned by <a>mkFRewrite</a> respects fuel.
mkFRewrite :: FuelMonad m => (forall e x. n e x -> f -> m (Maybe (Graph n e x))) -> FwdRewrite m n f

-- | Functions passed to <a>mkFRewrite3</a> should not be aware of the fuel
--   supply. The result returned by <a>mkFRewrite3</a> respects fuel.
mkFRewrite3 :: (n C O -> f -> UniqSM (Maybe (Graph n C O))) -> (n O O -> f -> UniqSM (Maybe (Graph n O O))) -> (n O C -> f -> UniqSM (Maybe (Graph n O C))) -> FwdRewrite UniqSM n f
getFRewrite3 :: FwdRewrite m n f -> (n C O -> f -> m (Maybe (Graph n C O, FwdRewrite m n f)), n O O -> f -> m (Maybe (Graph n O O, FwdRewrite m n f)), n O C -> f -> m (Maybe (Graph n O C, FwdRewrite m n f)))
noFwdRewrite :: FwdRewrite UniqSM n f
wrapFR :: (forall e x. (n e x -> f -> m (Maybe (Graph n e x, FwdRewrite m n f))) -> n' e x -> f' -> m' (Maybe (Graph n' e x, FwdRewrite m' n' f'))) -> FwdRewrite m n f -> FwdRewrite m' n' f'
wrapFR2 :: (forall e x. (n1 e x -> f1 -> m1 (Maybe (Graph n1 e x, FwdRewrite m1 n1 f1))) -> (n2 e x -> f2 -> m2 (Maybe (Graph n2 e x, FwdRewrite m2 n2 f2))) -> n3 e x -> f3 -> m3 (Maybe (Graph n3 e x, FwdRewrite m3 n3 f3))) -> FwdRewrite m1 n1 f1 -> FwdRewrite m2 n2 f2 -> FwdRewrite m3 n3 f3
data BwdPass (m :: * -> *) (n :: * -> * -> *) f :: (* -> *) -> (* -> * -> *) -> * -> *
[BwdPass] :: DataflowLattice f -> BwdTransfer n f -> BwdRewrite m n f -> BwdPass f
[bp_lattice] :: BwdPass f -> DataflowLattice f
[bp_transfer] :: BwdPass f -> BwdTransfer n f
[bp_rewrite] :: BwdPass f -> BwdRewrite m n f
data BwdTransfer (n :: * -> * -> *) f :: (* -> * -> *) -> * -> *
mkBTransfer :: (forall e x. n e x -> Fact x f -> f) -> BwdTransfer n f
mkBTransfer3 :: (n C O -> f -> f) -> (n O O -> f -> f) -> (n O C -> FactBase f -> f) -> BwdTransfer n f
getBTransfer3 :: BwdTransfer n f -> (n C O -> f -> f, n O O -> f -> f, n O C -> FactBase f -> f)
wrapBR :: (forall e x. Shape x -> (n e x -> Fact x f -> m (Maybe (Graph n e x, BwdRewrite m n f))) -> n' e x -> Fact x f' -> m' (Maybe (Graph n' e x, BwdRewrite m' n' f'))) -> BwdRewrite m n f -> BwdRewrite m' n' f'
wrapBR2 :: (forall e x. Shape x -> (n1 e x -> Fact x f1 -> m1 (Maybe (Graph n1 e x, BwdRewrite m1 n1 f1))) -> (n2 e x -> Fact x f2 -> m2 (Maybe (Graph n2 e x, BwdRewrite m2 n2 f2))) -> n3 e x -> Fact x f3 -> m3 (Maybe (Graph n3 e x, BwdRewrite m3 n3 f3))) -> BwdRewrite m1 n1 f1 -> BwdRewrite m2 n2 f2 -> BwdRewrite m3 n3 f3
data BwdRewrite (m :: * -> *) (n :: * -> * -> *) f :: (* -> *) -> (* -> * -> *) -> * -> *

-- | Functions passed to <a>mkBRewrite</a> should not be aware of the fuel
--   supply. The result returned by <a>mkBRewrite</a> respects fuel.
mkBRewrite :: FuelMonad m => (forall e x. n e x -> Fact x f -> m (Maybe (Graph n e x))) -> BwdRewrite m n f
mkBRewrite3 :: (n C O -> f -> UniqSM (Maybe (Graph n C O))) -> (n O O -> f -> UniqSM (Maybe (Graph n O O))) -> (n O C -> FactBase f -> UniqSM (Maybe (Graph n O C))) -> BwdRewrite UniqSM n f
getBRewrite3 :: BwdRewrite m n f -> (n C O -> f -> m (Maybe (Graph n C O, BwdRewrite m n f)), n O O -> f -> m (Maybe (Graph n O O, BwdRewrite m n f)), n O C -> FactBase f -> m (Maybe (Graph n O C, BwdRewrite m n f)))
noBwdRewrite :: BwdRewrite UniqSM n f

-- | if the graph being analyzed is open at the entry, there must be no
--   other entry point, or all goes horribly wrong...
analyzeAndRewriteFwd :: NonLocal n => FwdPass UniqSM n f -> MaybeC e [Label] -> Graph n e x -> Fact e f -> UniqSM (Graph n e x, FactBase f, MaybeO x f)

-- | if the graph being analyzed is open at the exit, I don't quite
--   understand the implications of possible other exits
analyzeAndRewriteBwd :: NonLocal n => BwdPass UniqSM n f -> MaybeC e [Label] -> Graph n e x -> Fact x f -> UniqSM (Graph n e x, FactBase f, MaybeO e f)

-- | if the graph being analyzed is open at the entry, there must be no
--   other entry point, or all goes horribly wrong...
analyzeFwd :: NonLocal n => FwdPass UniqSM n f -> MaybeC e [Label] -> Graph n e C -> Fact e f -> FactBase f

-- | if the graph being analyzed is open at the entry, there must be no
--   other entry point, or all goes horribly wrong...
analyzeFwdBlocks :: NonLocal n => FwdPass UniqSM n f -> MaybeC e [Label] -> Graph n e C -> Fact e f -> FactBase f

-- | if the graph being analyzed is open at the entry, there must be no
--   other entry point, or all goes horribly wrong...
analyzeBwd :: NonLocal n => BwdPass UniqSM n f -> MaybeC e [Label] -> Graph n e C -> Fact C f -> FactBase f
instance NonLocal n => NonLocal (DBlock f n)
instance ShapeLifter C O
instance ShapeLifter O O
instance ShapeLifter O C

module Hoopl
deepFwdRw :: (forall e x. n e x -> f -> UniqSM (Maybe (Graph n e x))) -> FwdRewrite UniqSM n f
deepFwdRw3 :: (n C O -> f -> UniqSM (Maybe (Graph n C O))) -> (n O O -> f -> UniqSM (Maybe (Graph n O O))) -> (n O C -> f -> UniqSM (Maybe (Graph n O C))) -> (FwdRewrite UniqSM n f)
deepBwdRw :: (forall e x. n e x -> Fact x f -> UniqSM (Maybe (Graph n e x))) -> BwdRewrite UniqSM n f
deepBwdRw3 :: (n C O -> f -> UniqSM (Maybe (Graph n C O))) -> (n O O -> f -> UniqSM (Maybe (Graph n O O))) -> (n O C -> FactBase f -> UniqSM (Maybe (Graph n O C))) -> (BwdRewrite UniqSM n f)
thenFwdRw :: FwdRewrite UniqSM n f -> FwdRewrite UniqSM n f -> FwdRewrite UniqSM n f

module UniqFM
data UniqFM ele
emptyUFM :: UniqFM elt
unitUFM :: Uniquable key => key -> elt -> UniqFM elt
unitDirectlyUFM :: Unique -> elt -> UniqFM elt
listToUFM :: Uniquable key => [(key, elt)] -> UniqFM elt
listToUFM_Directly :: [(Unique, elt)] -> UniqFM elt
listToUFM_C :: Uniquable key => (elt -> elt -> elt) -> [(key, elt)] -> UniqFM elt
addToUFM :: Uniquable key => UniqFM elt -> key -> elt -> UniqFM elt
addToUFM_C :: Uniquable key => (elt -> elt -> elt) -> UniqFM elt -> key -> elt -> UniqFM elt
addToUFM_Acc :: Uniquable key => (elt -> elts -> elts) -> (elt -> elts) -> UniqFM elts -> key -> elt -> UniqFM elts
addListToUFM :: Uniquable key => UniqFM elt -> [(key, elt)] -> UniqFM elt
addListToUFM_C :: Uniquable key => (elt -> elt -> elt) -> UniqFM elt -> [(key, elt)] -> UniqFM elt
addToUFM_Directly :: UniqFM elt -> Unique -> elt -> UniqFM elt
addListToUFM_Directly :: UniqFM elt -> [(Unique, elt)] -> UniqFM elt
adjustUFM :: Uniquable key => (elt -> elt) -> UniqFM elt -> key -> UniqFM elt
alterUFM :: Uniquable key => (Maybe elt -> Maybe elt) -> UniqFM elt -> key -> UniqFM elt
adjustUFM_Directly :: (elt -> elt) -> UniqFM elt -> Unique -> UniqFM elt
delFromUFM :: Uniquable key => UniqFM elt -> key -> UniqFM elt
delFromUFM_Directly :: UniqFM elt -> Unique -> UniqFM elt
delListFromUFM :: Uniquable key => UniqFM elt -> [key] -> UniqFM elt
plusUFM :: UniqFM elt -> UniqFM elt -> UniqFM elt
plusUFM_C :: (elt -> elt -> elt) -> UniqFM elt -> UniqFM elt -> UniqFM elt

-- | `plusUFM_CD f m1 d1 m2 d2` merges the maps using <tt>f</tt> as the
--   combinding function and <tt>d1</tt> resp. <tt>d2</tt> as the default
--   value if there is no entry in <tt>m1</tt> reps. <tt>m2</tt>. The
--   domain is the union of the domains of <tt>m1</tt> and <tt>m2</tt>.
--   
--   Representative example:
--   
--   <pre>
--   plusUFM_CD f {A: 1, B: 2} 23 {B: 3, C: 4} 42
--      == {A: f 1 42, B: f 2 3, C: f 23 4 }
--   </pre>
plusUFM_CD :: (elt -> elt -> elt) -> UniqFM elt -> elt -> UniqFM elt -> elt -> UniqFM elt
minusUFM :: UniqFM elt1 -> UniqFM elt2 -> UniqFM elt1
intersectUFM :: UniqFM elt -> UniqFM elt -> UniqFM elt
intersectUFM_C :: (elt1 -> elt2 -> elt3) -> UniqFM elt1 -> UniqFM elt2 -> UniqFM elt3
foldUFM :: (elt -> a -> a) -> a -> UniqFM elt -> a
foldUFM_Directly :: (Unique -> elt -> a -> a) -> a -> UniqFM elt -> a
mapUFM :: (elt1 -> elt2) -> UniqFM elt1 -> UniqFM elt2
mapUFM_Directly :: (Unique -> elt1 -> elt2) -> UniqFM elt1 -> UniqFM elt2
elemUFM :: Uniquable key => key -> UniqFM elt -> Bool
elemUFM_Directly :: Unique -> UniqFM elt -> Bool
filterUFM :: (elt -> Bool) -> UniqFM elt -> UniqFM elt
filterUFM_Directly :: (Unique -> elt -> Bool) -> UniqFM elt -> UniqFM elt
partitionUFM :: (elt -> Bool) -> UniqFM elt -> (UniqFM elt, UniqFM elt)
sizeUFM :: UniqFM elt -> Int
isNullUFM :: UniqFM elt -> Bool
lookupUFM :: Uniquable key => UniqFM elt -> key -> Maybe elt
lookupUFM_Directly :: UniqFM elt -> Unique -> Maybe elt
lookupWithDefaultUFM :: Uniquable key => UniqFM elt -> elt -> key -> elt
lookupWithDefaultUFM_Directly :: UniqFM elt -> elt -> Unique -> elt
eltsUFM :: UniqFM elt -> [elt]
keysUFM :: UniqFM elt -> [Unique]
splitUFM :: Uniquable key => UniqFM elt -> key -> (UniqFM elt, Maybe elt, UniqFM elt)
ufmToSet_Directly :: UniqFM elt -> IntSet
ufmToList :: UniqFM elt -> [(Unique, elt)]
joinUFM :: JoinFun v -> JoinFun (UniqFM v)
pprUniqFM :: (a -> SDoc) -> UniqFM a -> SDoc
instance Traversable UniqFM
instance Functor UniqFM
instance Eq ele => Eq (UniqFM ele)
instance Data ele => Data (UniqFM ele)
instance Foldable UniqFM
instance Monoid (UniqFM a)
instance Outputable a => Outputable (UniqFM a)

module ListSetOps
unionLists :: (Outputable a, Eq a) => [a] -> [a] -> [a]
minusList :: (Eq a) => [a] -> [a] -> [a]
insertList :: Eq a => a -> [a] -> [a]
type Assoc a b = [(a, b)]
assoc :: (Eq a) => String -> Assoc a b -> a -> b
assocMaybe :: (Eq a) => Assoc a b -> a -> Maybe b
assocUsing :: (a -> a -> Bool) -> String -> Assoc a b -> a -> b
assocDefault :: (Eq a) => b -> Assoc a b -> a -> b
assocDefaultUsing :: (a -> a -> Bool) -> b -> Assoc a b -> a -> b
hasNoDups :: (Eq a) => [a] -> Bool
runs :: (a -> a -> Bool) -> [a] -> [[a]]
removeDups :: (a -> a -> Ordering) -> [a] -> ([a], [[a]])
findDupsEq :: (a -> a -> Bool) -> [a] -> [[a]]
equivClasses :: (a -> a -> Ordering) -> [a] -> [[a]]
equivClassesByUniq :: (a -> Unique) -> [a] -> [[a]]
getNth :: Outputable a => [a] -> Int -> a

module UniqSet
type UniqSet a = UniqFM a
emptyUniqSet :: UniqSet a
unitUniqSet :: Uniquable a => a -> UniqSet a
mkUniqSet :: Uniquable a => [a] -> UniqSet a
addOneToUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a
addOneToUniqSet_C :: Uniquable a => (a -> a -> a) -> UniqSet a -> a -> UniqSet a
addListToUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a
delOneFromUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a
delOneFromUniqSet_Directly :: Uniquable a => UniqSet a -> Unique -> UniqSet a
delListFromUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a
unionUniqSets :: UniqSet a -> UniqSet a -> UniqSet a
unionManyUniqSets :: [UniqSet a] -> UniqSet a
minusUniqSet :: UniqSet a -> UniqSet a -> UniqSet a
intersectUniqSets :: UniqSet a -> UniqSet a -> UniqSet a
foldUniqSet :: (a -> b -> b) -> b -> UniqSet a -> b
mapUniqSet :: (a -> b) -> UniqSet a -> UniqSet b
elementOfUniqSet :: Uniquable a => a -> UniqSet a -> Bool
elemUniqSet_Directly :: Unique -> UniqSet a -> Bool
filterUniqSet :: (a -> Bool) -> UniqSet a -> UniqSet a
sizeUniqSet :: UniqSet a -> Int
isEmptyUniqSet :: UniqSet a -> Bool
lookupUniqSet :: Uniquable a => UniqSet a -> a -> Maybe a
uniqSetToList :: UniqSet a -> [a]
partitionUniqSet :: (a -> Bool) -> UniqSet a -> (UniqSet a, UniqSet a)


-- | Utils for calculating general worst, bound, squeese and free,
--   functions.
--   
--   as per: "A Generalized Algorithm for Graph-Coloring Register
--   Allocation" Michael Smith, Normal Ramsey, Glenn Holloway. PLDI 2004
--   
--   These general versions are not used in GHC proper because they are too
--   slow. Instead, hand written optimised versions are provided for each
--   architecture in MachRegs*.hs
--   
--   This code is here because we can test the architecture specific code
--   against it.
module RegAlloc.Graph.ArchBase
data RegClass
[ClassG32] :: RegClass
[ClassG16] :: RegClass
[ClassG8] :: RegClass
[ClassF64] :: RegClass

-- | A register of some class
data Reg
[Reg] :: RegClass -> Int -> Reg
[RegSub] :: RegSub -> Reg -> Reg

-- | A subcomponent of another register
data RegSub
[SubL16] :: RegSub
[SubL8] :: RegSub
[SubL8H] :: RegSub

-- | Worst case displacement
--   
--   a node N of classN has some number of neighbors, all of which are from
--   classC.
--   
--   (worst neighbors classN classC) is the maximum number of potential
--   colors for N that can be lost by coloring its neighbors.
--   
--   This should be hand coded/cached for each particular architecture,
--   because the compute time is very long..
worst :: (RegClass -> UniqSet Reg) -> (Reg -> UniqSet Reg) -> Int -> RegClass -> RegClass -> Int

-- | For a node N of classN and neighbors of classesC (bound classN
--   classesC) is the maximum number of potential colors for N that can be
--   lost by coloring its neighbors.
bound :: (RegClass -> UniqSet Reg) -> (Reg -> UniqSet Reg) -> RegClass -> [RegClass] -> Int

-- | The total squeese on a particular node with a list of neighbors.
--   
--   A version of this should be constructed for each particular
--   architecture, possibly including uses of bound, so that alised
--   registers don't get counted twice, as per the paper.
squeese :: (RegClass -> UniqSet Reg) -> (Reg -> UniqSet Reg) -> RegClass -> [(Int, RegClass)] -> Int
instance Eq Reg
instance Show Reg
instance Eq RegSub
instance Ord RegSub
instance Enum RegSub
instance Show RegSub
instance Enum RegClass
instance Eq RegClass
instance Show RegClass
instance Uniquable Reg


-- | A description of the register set of the X86.
--   
--   This isn't used directly in GHC proper.
--   
--   See RegArchBase.hs for the reference. See MachRegs.hs for the actual
--   trivColorable function used in GHC.
module RegAlloc.Graph.ArchX86

-- | Determine the class of a register
classOfReg :: Reg -> RegClass

-- | Determine all the regs that make up a certain class.
regsOfClass :: RegClass -> UniqSet Reg

-- | Determine the common name of a reg returns Nothing if this reg is not
--   part of the machine.
regName :: Reg -> Maybe String

-- | Which regs alias what other regs.
regAlias :: Reg -> UniqSet Reg

-- | Optimised versions of RegColorBase.{worst, squeese} specific to x86
worst :: Int -> RegClass -> RegClass -> Int
squeese :: RegClass -> [(Int, RegClass)] -> Int


-- | Types for the general graph colorer.
module GraphBase

-- | A fn to check if a node is trivially colorable For graphs who's color
--   classes are disjoint then a node is 'trivially colorable' when it has
--   less neighbors and exclusions than available colors for that node.
--   
--   For graph's who's color classes overlap, ie some colors alias other
--   colors, then this can be a bit more tricky. There is a general way to
--   calculate this, but it's likely be too slow for use in the code. The
--   coloring algorithm takes a canned function which can be optimised by
--   the user to be specific to the specific graph being colored.
--   
--   for details, see "A Generalised Algorithm for Graph-Coloring Register
--   Allocation" Smith, Ramsey, Holloway - PLDI 2004.
type Triv k cls color = cls -> UniqSet k -> UniqSet color -> Bool

-- | The Interference graph. There used to be more fields, but they were
--   turfed out in a previous revision. maybe we'll want more later..
data Graph k cls color
[Graph] :: UniqFM (Node k cls color) -> Graph k cls color

-- | All active nodes in the graph.
[graphMap] :: Graph k cls color -> UniqFM (Node k cls color)

-- | An empty graph.
initGraph :: Graph k cls color

-- | Modify the finite map holding the nodes in the graph.
graphMapModify :: (UniqFM (Node k cls color) -> UniqFM (Node k cls color)) -> Graph k cls color -> Graph k cls color

-- | Graph nodes. Represents a thing that can conflict with another thing.
--   For the register allocater the nodes represent registers.
data Node k cls color
[Node] :: k -> cls -> Maybe color -> UniqSet k -> UniqSet color -> [color] -> UniqSet k -> Node k cls color

-- | A unique identifier for this node.
[nodeId] :: Node k cls color -> k

-- | The class of this node, determines the set of colors that can be used.
[nodeClass] :: Node k cls color -> cls

-- | The color of this node, if any.
[nodeColor] :: Node k cls color -> Maybe color

-- | Neighbors which must be colored differently to this node.
[nodeConflicts] :: Node k cls color -> UniqSet k

-- | Colors that cannot be used by this node.
[nodeExclusions] :: Node k cls color -> UniqSet color

-- | Colors that this node would prefer to be, in decending order.
[nodePreference] :: Node k cls color -> [color]

-- | Neighbors that this node would like to be colored the same as.
[nodeCoalesce] :: Node k cls color -> UniqSet k

-- | An empty node.
newNode :: k -> cls -> Node k cls color

module OrdList
data OrdList a
nilOL :: OrdList a
isNilOL :: OrdList a -> Bool
unitOL :: a -> OrdList a
appOL :: OrdList a -> OrdList a -> OrdList a
consOL :: a -> OrdList a -> OrdList a
snocOL :: OrdList a -> a -> OrdList a
concatOL :: [OrdList a] -> OrdList a
lastOL :: OrdList a -> a
mapOL :: (a -> b) -> OrdList a -> OrdList b
fromOL :: OrdList a -> [a]
toOL :: [a] -> OrdList a
foldrOL :: (a -> b -> b) -> b -> OrdList a -> b
foldlOL :: (b -> a -> b) -> b -> OrdList a -> b
instance Outputable a => Outputable (OrdList a)
instance Monoid (OrdList a)
instance Functor OrdList

module Bag
data Bag a
emptyBag :: Bag a
unitBag :: a -> Bag a
unionBags :: Bag a -> Bag a -> Bag a
unionManyBags :: [Bag a] -> Bag a
mapBag :: (a -> b) -> Bag a -> Bag b
elemBag :: Eq a => a -> Bag a -> Bool
lengthBag :: Bag a -> Int
filterBag :: (a -> Bool) -> Bag a -> Bag a
partitionBag :: (a -> Bool) -> Bag a -> (Bag a, Bag a)
partitionBagWith :: (a -> Either b c) -> Bag a -> (Bag b, Bag c)
concatBag :: Bag (Bag a) -> Bag a
foldBag :: (r -> r -> r) -> (a -> r) -> r -> Bag a -> r
foldrBag :: (a -> r -> r) -> r -> Bag a -> r
foldlBag :: (r -> a -> r) -> r -> Bag a -> r
isEmptyBag :: Bag a -> Bool
isSingletonBag :: Bag a -> Bool
consBag :: a -> Bag a -> Bag a
snocBag :: Bag a -> a -> Bag a
anyBag :: (a -> Bool) -> Bag a -> Bool
listToBag :: [a] -> Bag a
bagToList :: Bag a -> [a]
foldrBagM :: (Monad m) => (a -> b -> m b) -> b -> Bag a -> m b
foldlBagM :: (Monad m) => (b -> a -> m b) -> b -> Bag a -> m b
mapBagM :: Monad m => (a -> m b) -> Bag a -> m (Bag b)
mapBagM_ :: Monad m => (a -> m b) -> Bag a -> m ()
flatMapBagM :: Monad m => (a -> m (Bag b)) -> Bag a -> m (Bag b)
flatMapBagPairM :: Monad m => (a -> m (Bag b, Bag c)) -> Bag a -> m (Bag b, Bag c)
mapAndUnzipBagM :: Monad m => (a -> m (b, c)) -> Bag a -> m (Bag b, Bag c)
mapAccumBagLM :: Monad m => (acc -> x -> m (acc, y)) -> acc -> Bag x -> m (acc, Bag y)
instance Outputable a => Outputable (Bag a)
instance Data a => Data (Bag a)

module Digraph
data Graph node
graphFromVerticesAndAdjacency :: Ord key => [(node, key)] -> [(key, key)] -> Graph (node, key)
graphFromEdgedVertices :: Ord key => [Node key payload] -> Graph (Node key payload)
data SCC vertex
[AcyclicSCC] :: vertex -> SCC vertex
[CyclicSCC] :: [vertex] -> SCC vertex
type Node key payload = (payload, key, [key])
flattenSCC :: SCC a -> [a]
flattenSCCs :: [SCC a] -> [a]
stronglyConnCompG :: Graph node -> [SCC node]
topologicalSortG :: Graph node -> [node]
dfsTopSortG :: Graph node -> [[node]]
verticesG :: Graph node -> [node]
edgesG :: Graph node -> [Edge node]
hasVertexG :: Graph node -> node -> Bool
reachableG :: Graph node -> node -> [node]
reachablesG :: Graph node -> [node] -> [node]
transposeG :: Graph node -> Graph node
outdegreeG :: Graph node -> node -> Maybe Int
indegreeG :: Graph node -> node -> Maybe Int
vertexGroupsG :: Graph node -> [[node]]
emptyG :: Graph node -> Bool
componentsG :: Graph node -> [[node]]

-- | Find a reasonably short cycle a-&gt;b-&gt;c-&gt;a, in a strongly
--   connected component. The input nodes are presumed to be a SCC, so you
--   can start anywhere.
findCycle :: Ord key => [Node key payload] -> Maybe [payload]
stronglyConnCompFromEdgedVertices :: Ord key => [Node key payload] -> [SCC payload]
stronglyConnCompFromEdgedVerticesR :: Ord key => [Node key payload] -> [SCC (Node key payload)]
tabulate :: Bounds -> [Vertex] -> Table Int
preArr :: Bounds -> Forest Vertex -> Table Int
components :: IntGraph -> Forest Vertex
undirected :: IntGraph -> IntGraph
back :: IntGraph -> Table Int -> IntGraph
cross :: IntGraph -> Table Int -> Table Int -> IntGraph
forward :: IntGraph -> IntGraph -> Table Int -> IntGraph
path :: IntGraph -> Vertex -> Vertex -> Bool
bcc :: IntGraph -> Forest [Vertex]
do_label :: IntGraph -> Table Int -> Tree Vertex -> Tree (Vertex, Int, Int)
bicomps :: Tree (Vertex, Int, Int) -> Forest [Vertex]
collect :: Tree (Vertex, Int, Int) -> (Int, Tree [Vertex])
instance Functor SCC
instance Outputable a => Outputable (SCC a)
instance Outputable node => Outputable (Graph node)
instance Outputable node => Outputable (Edge node)
instance Show a => Show (Tree a)

module StringBuffer

-- | A StringBuffer is an internal pointer to a sized chunk of bytes. The
--   bytes are intended to be *immutable*. There are pure operations to
--   read the contents of a StringBuffer.
--   
--   A StringBuffer may have a finalizer, depending on how it was obtained.
data StringBuffer
[StringBuffer] :: {-# UNPACK #-} !(ForeignPtr Word8) -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> StringBuffer
[buf] :: StringBuffer -> {-# UNPACK #-} !(ForeignPtr Word8)
[len] :: StringBuffer -> {-# UNPACK #-} !Int
[cur] :: StringBuffer -> {-# UNPACK #-} !Int
hGetStringBuffer :: FilePath -> IO StringBuffer
hGetStringBufferBlock :: Handle -> Int -> IO StringBuffer
appendStringBuffers :: StringBuffer -> StringBuffer -> IO StringBuffer
stringToStringBuffer :: String -> StringBuffer
nextChar :: StringBuffer -> (Char, StringBuffer)
currentChar :: StringBuffer -> Char
prevChar :: StringBuffer -> Char -> Char
atEnd :: StringBuffer -> Bool
stepOn :: StringBuffer -> StringBuffer
offsetBytes :: Int -> StringBuffer -> StringBuffer
byteDiff :: StringBuffer -> StringBuffer -> Int
lexemeToString :: StringBuffer -> Int -> String
lexemeToFastString :: StringBuffer -> Int -> FastString

-- | XXX assumes ASCII digits only (by using byteOff)
parseUnsignedInteger :: StringBuffer -> Int -> Integer -> (Char -> Int) -> Integer
instance Show StringBuffer

module HsDoc
newtype HsDocString
[HsDocString] :: FastString -> HsDocString
type LHsDocString = Located HsDocString
ppr_mbDoc :: Maybe LHsDocString -> SDoc
instance Data HsDocString
instance Show HsDocString
instance Eq HsDocString
instance Outputable HsDocString

module DriverPhases
data HscSource
[HsSrcFile] :: HscSource
[HsBootFile] :: HscSource
[HsigFile] :: HscSource
isHsBootOrSig :: HscSource -> Bool
hscSourceString :: HscSource -> String
data Phase
[Unlit] :: HscSource -> Phase
[Cpp] :: HscSource -> Phase
[HsPp] :: HscSource -> Phase
[Hsc] :: HscSource -> Phase
[Ccpp] :: Phase
[Cc] :: Phase
[Cobjc] :: Phase
[Cobjcpp] :: Phase
[HCc] :: Phase
[Splitter] :: Phase
[SplitAs] :: Phase
[As] :: Bool -> Phase
[LlvmOpt] :: Phase
[LlvmLlc] :: Phase
[LlvmMangle] :: Phase
[CmmCpp] :: Phase
[Cmm] :: Phase
[MergeStub] :: Phase
[StopLn] :: Phase
happensBefore :: DynFlags -> Phase -> Phase -> Bool
eqPhase :: Phase -> Phase -> Bool
anyHsc :: Phase
isStopLn :: Phase -> Bool
startPhase :: String -> Phase
phaseInputExt :: Phase -> String
isHaskellishSuffix :: String -> Bool
isHaskellSrcSuffix :: String -> Bool
isObjectSuffix :: Platform -> String -> Bool
isCishSuffix :: String -> Bool
isDynLibSuffix :: Platform -> String -> Bool
isHaskellUserSrcSuffix :: String -> Bool
isHaskellSigSuffix :: String -> Bool
isSourceSuffix :: String -> Bool
isHaskellishFilename :: FilePath -> Bool
isHaskellSrcFilename :: FilePath -> Bool
isHaskellSigFilename :: FilePath -> Bool
isObjectFilename :: Platform -> FilePath -> Bool
isCishFilename :: FilePath -> Bool
isDynLibFilename :: Platform -> FilePath -> Bool
isHaskellUserSrcFilename :: FilePath -> Bool
isSourceFilename :: FilePath -> Bool
instance Show Phase
instance Eq Phase
instance Show HscSource
instance Ord HscSource
instance Eq HscSource
instance Outputable Phase


-- | Basic operations on graphs.
module GraphOps

-- | Add a node to the graph, linking up its edges
addNode :: Uniquable k => k -> Node k cls color -> Graph k cls color -> Graph k cls color

-- | Delete a node and all its edges from the graph.
delNode :: (Uniquable k, Outputable k) => k -> Graph k cls color -> Maybe (Graph k cls color)

-- | Get a node from the graph, throwing an error if it's not there
getNode :: Uniquable k => Graph k cls color -> k -> Node k cls color

-- | Lookup a node from the graph.
lookupNode :: Uniquable k => Graph k cls color -> k -> Maybe (Node k cls color)

-- | Modify a node in the graph. returns Nothing if the node isn't present.
modNode :: Uniquable k => (Node k cls color -> Node k cls color) -> k -> Graph k cls color -> Maybe (Graph k cls color)

-- | Get the size of the graph, O(n)
size :: Uniquable k => Graph k cls color -> Int

-- | Union two graphs together.
union :: Uniquable k => Graph k cls color -> Graph k cls color -> Graph k cls color

-- | Add a conflict between nodes to the graph, creating the nodes
--   required. Conflicts are virtual regs which need to be colored
--   differently.
addConflict :: Uniquable k => (k, cls) -> (k, cls) -> Graph k cls color -> Graph k cls color

-- | Delete a conflict edge. k1 -&gt; k2 returns Nothing if the node isn't
--   in the graph
delConflict :: Uniquable k => k -> k -> Graph k cls color -> Maybe (Graph k cls color)

-- | Add some conflicts to the graph, creating nodes if required. All the
--   nodes in the set are taken to conflict with each other.
addConflicts :: Uniquable k => UniqSet k -> (k -> cls) -> Graph k cls color -> Graph k cls color

-- | Add a coalescence edge to the graph, creating nodes if requried. It is
--   considered adventageous to assign the same color to nodes in a
--   coalesence.
addCoalesce :: Uniquable k => (k, cls) -> (k, cls) -> Graph k cls color -> Graph k cls color

-- | Delete a coalescence edge (k1 -&gt; k2) from the graph.
delCoalesce :: Uniquable k => k -> k -> Graph k cls color -> Maybe (Graph k cls color)

-- | Add an exclusion to the graph, creating nodes if required. These are
--   extra colors that the node cannot use.
addExclusion :: (Uniquable k, Uniquable color) => k -> (k -> cls) -> color -> Graph k cls color -> Graph k cls color
addExclusions :: (Uniquable k, Uniquable color) => k -> (k -> cls) -> [color] -> Graph k cls color -> Graph k cls color

-- | Add a color preference to the graph, creating nodes if required. The
--   most recently added preference is the most prefered. The algorithm
--   tries to assign a node it's prefered color if possible.
addPreference :: Uniquable k => (k, cls) -> color -> Graph k cls color -> Graph k cls color

-- | Coalesce this pair of nodes unconditionally / agressively. The
--   resulting node is the one with the least key.
--   
--   returns: Just the pair of keys if the nodes were coalesced the second
--   element of the pair being the least one
--   
--   Nothing if either of the nodes weren't in the graph
coalesceNodes :: (Uniquable k, Ord k, Eq cls, Outputable k) => Bool -> Triv k cls color -> Graph k cls color -> (k, k) -> (Graph k cls color, Maybe (k, k))

-- | Do agressive coalescing on this graph. returns the new graph and the
--   list of pairs of nodes that got coaleced together. for each pair, the
--   resulting node will have the least key and be second in the pair.
coalesceGraph :: (Uniquable k, Ord k, Eq cls, Outputable k) => Bool -> Triv k cls color -> Graph k cls color -> (Graph k cls color, [(k, k)])

-- | Freeze a node This is for the iterative coalescer. By freezing a node
--   we give up on ever coalescing it. Move all its coalesce edges into the
--   frozen set - and update back edges from other nodes.
freezeNode :: Uniquable k => k -> Graph k cls color -> Graph k cls color

-- | Freeze one node in the graph This if for the iterative coalescer. Look
--   for a move related node of low degree and freeze it.
--   
--   We probably don't need to scan the whole graph looking for the node of
--   absolute lowest degree. Just sample the first few and choose the one
--   with the lowest degree out of those. Also, we don't make any
--   distinction between conflicts of different classes.. this is just a
--   heuristic, after all.
--   
--   IDEA: freezing a node might free it up for Simplify.. would be good to
--   check for triv right here, and add it to a worklist if known
--   triv/non-move nodes.
freezeOneInGraph :: (Uniquable k, Outputable k) => Graph k cls color -> (Graph k cls color, Bool)

-- | Freeze all the nodes in the graph for debugging the iterative
--   allocator.
freezeAllInGraph :: (Uniquable k, Outputable k) => Graph k cls color -> Graph k cls color

-- | Find all the nodes in the graph that meet some criteria
scanGraph :: Uniquable k => (Node k cls color -> Bool) -> Graph k cls color -> [Node k cls color]

-- | Set the color of a certain node
setColor :: Uniquable k => k -> color -> Graph k cls color -> Graph k cls color

-- | validate the internal structure of a graph all its edges should point
--   to valid nodes If they don't then throw an error
validateGraph :: (Uniquable k, Outputable k, Eq color) => SDoc -> Bool -> Graph k cls color -> Graph k cls color

-- | Slurp out a map of how many nodes had a certain number of conflict
--   neighbours
slurpNodeConflictCount :: Uniquable k => Graph k cls color -> UniqFM (Int, Int)


-- | Pretty printing of graphs.
module GraphPpr

-- | Pretty print a graph in a somewhat human readable format.
dumpGraph :: (Outputable k, Outputable cls, Outputable color) => Graph k cls color -> SDoc

-- | Pretty print a graph in graphviz .dot format. Conflicts get solid
--   edges. Coalescences get dashed edges.
dotGraph :: (Uniquable k, Outputable k, Outputable cls, Outputable color) => (color -> SDoc) -> Triv k cls color -> Graph k cls color -> SDoc


-- | Graph Coloring. This is a generic graph coloring library, abstracted
--   over the type of the node keys, nodes and colors.
module GraphColor

-- | Try to color a graph with this set of colors. Uses Chaitin's algorithm
--   to color the graph. The graph is scanned for nodes which are deamed
--   'trivially colorable'. These nodes are pushed onto a stack and removed
--   from the graph. Once this process is complete the graph can be colored
--   by removing nodes from the stack (ie in reverse order) and assigning
--   them colors different to their neighbors.
colorGraph :: (Uniquable k, Uniquable cls, Uniquable color, Eq color, Eq cls, Ord k, Outputable k, Outputable cls, Outputable color) => Bool -> Int -> UniqFM (UniqSet color) -> Triv k cls color -> (Graph k cls color -> k) -> Graph k cls color -> (Graph k cls color, UniqSet k, UniqFM k)


-- | An architecture independent description of a register's class.
module RegClass

-- | The class of a register. Used in the register allocator. We treat all
--   registers in a class as being interchangable.
data RegClass
[RcInteger] :: RegClass
[RcFloat] :: RegClass
[RcDouble] :: RegClass
[RcDoubleSSE] :: RegClass
instance Eq RegClass
instance Uniquable RegClass
instance Outputable RegClass


-- | An architecture independent description of a register. This needs to
--   stay architecture independent because it is used by NCGMonad and the
--   register allocators, which are shared by all architectures.
module Reg

-- | An identifier for a primitive real machine register.
type RegNo = Int

-- | A register, either virtual or real
data Reg
[RegVirtual] :: !VirtualReg -> Reg
[RegReal] :: !RealReg -> Reg
regPair :: RegNo -> RegNo -> Reg
regSingle :: RegNo -> Reg
isRealReg :: Reg -> Bool
takeRealReg :: Reg -> Maybe RealReg
isVirtualReg :: Reg -> Bool
takeVirtualReg :: Reg -> Maybe VirtualReg
data VirtualReg
[VirtualRegI] :: {-# UNPACK #-} !Unique -> VirtualReg
[VirtualRegHi] :: {-# UNPACK #-} !Unique -> VirtualReg
[VirtualRegF] :: {-# UNPACK #-} !Unique -> VirtualReg
[VirtualRegD] :: {-# UNPACK #-} !Unique -> VirtualReg
[VirtualRegSSE] :: {-# UNPACK #-} !Unique -> VirtualReg
renameVirtualReg :: Unique -> VirtualReg -> VirtualReg
classOfVirtualReg :: VirtualReg -> RegClass
getHiVirtualRegFromLo :: VirtualReg -> VirtualReg
getHiVRegFromLo :: Reg -> Reg

-- | RealRegs are machine regs which are available for allocation, in the
--   usual way. We know what class they are, because that's part of the
--   processor's architecture.
--   
--   RealRegPairs are pairs of real registers that are allocated together
--   to hold a larger value, such as with Double regs on SPARC.
data RealReg
[RealRegSingle] :: {-# UNPACK #-} !RegNo -> RealReg
[RealRegPair] :: {-# UNPACK #-} !RegNo -> {-# UNPACK #-} !RegNo -> RealReg
regNosOfRealReg :: RealReg -> [RegNo]
realRegsAlias :: RealReg -> RealReg -> Bool

-- | The patch function supplied by the allocator maps VirtualReg to
--   RealReg regs, but sometimes we want to apply it to plain old Reg.
liftPatchFnToRegReg :: (VirtualReg -> RealReg) -> (Reg -> Reg)
instance Ord Reg
instance Eq Reg
instance Ord RealReg
instance Show RealReg
instance Eq RealReg
instance Ord VirtualReg
instance Show VirtualReg
instance Eq VirtualReg
instance Uniquable VirtualReg
instance Outputable VirtualReg
instance Uniquable RealReg
instance Outputable RealReg
instance Uniquable Reg
instance Outputable Reg

module Ctype
is_ident :: Char -> Bool
is_symbol :: Char -> Bool
is_any :: Char -> Bool
is_space :: Char -> Bool
is_lower :: Char -> Bool
is_upper :: Char -> Bool
is_digit :: Char -> Bool
is_alphanum :: Char -> Bool
is_decdigit :: Char -> Bool
is_hexdigit :: Char -> Bool
is_octdigit :: Char -> Bool
is_bindigit :: Char -> Bool
hexDigit :: Char -> Int
octDecDigit :: Char -> Int


-- | Command-line parser
--   
--   This is an abstract command-line parser used by both StaticFlags and
--   DynFlags.
--   
--   (c) The University of Glasgow 2005
module CmdLineParser
processArgs :: Monad m => [Flag m] -> [Located String] -> m ([Located String], [Located String], [Located String])
data OptKind m
[NoArg] :: (EwM m ()) -> OptKind m
[HasArg] :: (String -> EwM m ()) -> OptKind m
[SepArg] :: (String -> EwM m ()) -> OptKind m
[Prefix] :: (String -> EwM m ()) -> OptKind m
[OptPrefix] :: (String -> EwM m ()) -> OptKind m
[OptIntSuffix] :: (Maybe Int -> EwM m ()) -> OptKind m
[IntSuffix] :: (Int -> EwM m ()) -> OptKind m
[FloatSuffix] :: (Float -> EwM m ()) -> OptKind m
[PassFlag] :: (String -> EwM m ()) -> OptKind m
[AnySuffix] :: (String -> EwM m ()) -> OptKind m
[PrefixPred] :: (String -> Bool) -> (String -> EwM m ()) -> OptKind m
[AnySuffixPred] :: (String -> Bool) -> (String -> EwM m ()) -> OptKind m

-- | GHC flag modes describing when a flag has an effect.
data GhcFlagMode

-- | The flag only affects the non-interactive GHC
[OnlyGhc] :: GhcFlagMode

-- | The flag only affects the interactive GHC
[OnlyGhci] :: GhcFlagMode

-- | The flag affects multiple ghc modes
[AllModes] :: GhcFlagMode

-- | This flag should not be seen in cli completion
[HiddenFlag] :: GhcFlagMode
newtype CmdLineP s a
[CmdLineP] :: (s -> (a, s)) -> CmdLineP s a
[runCmdLine] :: CmdLineP s a -> s -> (a, s)
getCmdLineState :: CmdLineP s s
putCmdLineState :: s -> CmdLineP s ()
data Flag m
[Flag] :: String -> OptKind m -> GhcFlagMode -> Flag m
[flagName] :: Flag m -> String
[flagOptKind] :: Flag m -> OptKind m
[flagGhcMode] :: Flag m -> GhcFlagMode
defFlag :: String -> OptKind m -> Flag m
defGhcFlag :: String -> OptKind m -> Flag m
defGhciFlag :: String -> OptKind m -> Flag m
defHiddenFlag :: String -> OptKind m -> Flag m
errorsToGhcException :: [(String, String)] -> GhcException
data EwM m a
runEwM :: EwM m a -> m (Errs, Warns, a)
addErr :: Monad m => String -> EwM m ()
addWarn :: Monad m => String -> EwM m ()
getArg :: Monad m => EwM m String
getCurLoc :: Monad m => EwM m SrcSpan
liftEwM :: Monad m => m a -> EwM m a
deprecate :: Monad m => String -> EwM m ()
instance Monad m => Functor (EwM m)
instance Monad m => Applicative (EwM m)
instance Monad m => Monad (EwM m)
instance Functor (CmdLineP s)
instance Applicative (CmdLineP s)
instance Monad (CmdLineP s)

module StaticFlags

-- | 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 <a>withGhc</a>.
--   
--   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?
parseStaticFlags :: [Located String] -> IO ([Located String], [Located String])
staticFlags :: [String]
initStaticOpts :: IO ()
discardStaticFlags :: [String] -> [String]
opt_PprStyle_Debug :: Bool
opt_NoDebugOutput :: Bool
opt_NoStateHack :: Bool
opt_CprOff :: Bool
opt_NoOptCoercion :: Bool
addOpt :: String -> IO ()
removeOpt :: String -> IO ()
v_opt_C_ready :: IORef (Bool)
flagsStatic :: [Flag IO]
flagsStaticNames :: [String]

module RegAlloc.Graph.TrivColorable
trivColorable :: Platform -> (RegClass -> VirtualReg -> FastInt) -> (RegClass -> RealReg -> FastInt) -> Triv VirtualReg RegClass RealReg

module PPC.Cond
data Cond
[ALWAYS] :: Cond
[EQQ] :: Cond
[GE] :: Cond
[GEU] :: Cond
[GTT] :: Cond
[GU] :: Cond
[LE] :: Cond
[LEU] :: Cond
[LTT] :: Cond
[LU] :: Cond
[NE] :: Cond
condNegate :: Cond -> Cond
condUnsigned :: Cond -> Bool
condToSigned :: Cond -> Cond
condToUnsigned :: Cond -> Cond
instance Eq Cond


-- | Primarily, this module consists of an interface to the C-land dynamic
--   linker.
module ObjLink
initObjLinker :: IO ()

-- | loadDLL loads a dynamic library using the OS's native linker (i.e.
--   dlopen() on Unix, LoadLibrary() on Windows). It takes either an
--   absolute pathname to the file, or a relative filename (e.g.
--   "libfoo.so" or "foo.dll"). In the latter case, loadDLL searches the
--   standard locations for the appropriate library.
loadDLL :: String -> IO (Maybe String)
loadArchive :: String -> IO ()
loadObj :: String -> IO ()
unloadObj :: String -> IO ()
insertSymbol :: String -> String -> Ptr a -> IO ()
lookupSymbol :: String -> IO (Maybe (Ptr a))
resolveObjs :: IO SuccessFlag

module Lexeme
isLexCon :: FastString -> Bool
isLexVar :: FastString -> Bool
isLexId :: FastString -> Bool
isLexSym :: FastString -> Bool
isLexConId :: FastString -> Bool
isLexConSym :: FastString -> Bool
isLexVarId :: FastString -> Bool
isLexVarSym :: FastString -> Bool
startsVarSym :: Char -> Bool
startsVarId :: Char -> Bool
startsConSym :: Char -> Bool
startsConId :: Char -> Bool

-- | Is this an acceptable variable name?
okVarOcc :: String -> Bool

-- | Is this an acceptable constructor name?
okConOcc :: String -> Bool

-- | Is this an acceptable type name?
okTcOcc :: String -> Bool

-- | Is this an acceptable alphanumeric variable name, assuming it starts
--   with an acceptable letter?
okVarIdOcc :: String -> Bool

-- | Is this an acceptable symbolic variable name, assuming it starts with
--   an acceptable character?
okVarSymOcc :: String -> Bool

-- | Is this an acceptable alphanumeric constructor name, assuming it
--   starts with an acceptable letter?
okConIdOcc :: String -> Bool

-- | Is this an acceptable symbolic constructor name, assuming it starts
--   with an acceptable character?
okConSymOcc :: String -> Bool

module Fingerprint
data Fingerprint :: *
[Fingerprint] :: UnpkWord64 -> UnpkWord64 -> Fingerprint
fingerprint0 :: Fingerprint
readHexFingerprint :: String -> Fingerprint
fingerprintData :: Ptr Word8 -> Int -> IO Fingerprint
fingerprintString :: String -> Fingerprint

-- | Computes the hash of a given file. This function loops over the
--   handle, running in constant memory.
getFileHash :: FilePath -> IO Fingerprint

module Binary
data Bin a
class Binary a where put_ bh a = do { _ <- put bh a; return () } put bh a = do { p <- tellBin bh; put_ bh a; return p }
put_ :: Binary a => BinHandle -> a -> IO ()
put :: Binary a => BinHandle -> a -> IO (Bin a)
get :: Binary a => BinHandle -> IO a
data BinHandle
type SymbolTable = Array Int Name
type Dictionary = Array Int FastString
openBinMem :: Int -> IO BinHandle
seekBin :: BinHandle -> Bin a -> IO ()
seekBy :: BinHandle -> Int -> IO ()
tellBin :: BinHandle -> IO (Bin a)
castBin :: Bin a -> Bin b
writeBinMem :: BinHandle -> FilePath -> IO ()
readBinMem :: FilePath -> IO BinHandle
fingerprintBinMem :: BinHandle -> IO Fingerprint
computeFingerprint :: Binary a => (BinHandle -> Name -> IO ()) -> a -> IO Fingerprint
isEOFBin :: BinHandle -> IO Bool
putAt :: Binary a => BinHandle -> Bin a -> a -> IO ()
getAt :: Binary a => BinHandle -> Bin a -> IO a
putByte :: BinHandle -> Word8 -> IO ()
getByte :: BinHandle -> IO Word8
lazyGet :: Binary a => BinHandle -> IO a
lazyPut :: Binary a => BinHandle -> a -> IO ()
data ByteArray
[BA] :: ByteArray# -> ByteArray
getByteArray :: BinHandle -> Int -> IO ByteArray
putByteArray :: BinHandle -> ByteArray# -> Int# -> IO ()
data UserData
[UserData] :: (BinHandle -> IO Name) -> (BinHandle -> IO FastString) -> (BinHandle -> Name -> IO ()) -> (BinHandle -> FastString -> IO ()) -> UserData
[ud_get_name] :: UserData -> BinHandle -> IO Name
[ud_get_fs] :: UserData -> BinHandle -> IO FastString
[ud_put_name] :: UserData -> BinHandle -> Name -> IO ()
[ud_put_fs] :: UserData -> BinHandle -> FastString -> IO ()
getUserData :: BinHandle -> UserData
setUserData :: BinHandle -> UserData -> BinHandle
newReadState :: (BinHandle -> IO Name) -> (BinHandle -> IO FastString) -> UserData
newWriteState :: (BinHandle -> Name -> IO ()) -> (BinHandle -> FastString -> IO ()) -> UserData
putDictionary :: BinHandle -> Int -> UniqFM (Int, FastString) -> IO ()
getDictionary :: BinHandle -> IO Dictionary
putFS :: BinHandle -> FastString -> IO ()
instance Bounded (Bin a)
instance Show (Bin a)
instance Ord (Bin a)
instance Eq (Bin a)
instance Binary Word8
instance Binary Word16
instance Binary Word32
instance Binary Word64
instance Binary Int8
instance Binary Int16
instance Binary Int32
instance Binary Int64
instance Binary ()
instance Binary Bool
instance Binary Char
instance Binary Int
instance Binary a => Binary [a]
instance (Binary a, Binary b) => Binary (a, b)
instance (Binary a, Binary b, Binary c) => Binary (a, b, c)
instance (Binary a, Binary b, Binary c, Binary d) => Binary (a, b, c, d)
instance (Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a, b, c, d, e)
instance (Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a, b, c, d, e, f)
instance Binary a => Binary (Maybe a)
instance (Binary a, Binary b) => Binary (Either a b)
instance Binary UTCTime
instance Binary Day
instance Binary DiffTime
instance Binary Integer
instance (Integral a, Binary a) => Binary (Ratio a)
instance Binary (Bin a)
instance Binary TyCon
instance Binary TypeRep
instance Binary ByteString
instance Binary FastString
instance Binary Fingerprint
instance Binary FunctionOrData
instance Binary TupleSort
instance Binary Activation
instance Binary InlinePragma
instance Binary RuleMatchInfo
instance Binary InlineSpec
instance Binary DefMethSpec
instance Binary RecFlag
instance Binary OverlapMode
instance Binary OverlapFlag
instance Binary FixityDirection
instance Binary Fixity
instance Binary WarningTxt
instance Binary a => Binary (GenLocated SrcSpan a)
instance Binary SrcSpan

module Module

-- | A ModuleName is essentially a simple string, e.g. <tt>Data.List</tt>.
data ModuleName
pprModuleName :: ModuleName -> SDoc
moduleNameFS :: ModuleName -> FastString
moduleNameString :: ModuleName -> String

-- | Returns the string version of the module name, with dots replaced by
--   slashes.
moduleNameSlashes :: ModuleName -> String

-- | Returns the string version of the module name, with dots replaced by
--   underscores.
moduleNameColons :: ModuleName -> String
mkModuleName :: String -> ModuleName
mkModuleNameFS :: FastString -> ModuleName

-- | Compares module names lexically, rather than by their <a>Unique</a>s
stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering

-- | A string which uniquely identifies a package. For wired-in packages,
--   it is just the package name, but for user compiled packages, it is a
--   hash. ToDo: when the key is a hash, we can do more clever things than
--   store the hex representation and hash-cons those strings.
data PackageKey
fsToPackageKey :: FastString -> PackageKey
packageKeyFS :: PackageKey -> FastString
stringToPackageKey :: String -> PackageKey
packageKeyString :: PackageKey -> String

-- | Compares package ids lexically, rather than by their <a>Unique</a>s
stablePackageKeyCmp :: PackageKey -> PackageKey -> Ordering
primPackageKey :: PackageKey
integerPackageKey :: PackageKey
basePackageKey :: PackageKey
rtsPackageKey :: PackageKey
thPackageKey :: PackageKey
dphSeqPackageKey :: PackageKey
dphParPackageKey :: PackageKey

-- | This is the package Id for the current program. It is the default
--   package Id if you don't specify a package name. We don't add this
--   prefix to symbol names, since there can be only one main package per
--   program.
mainPackageKey :: PackageKey
thisGhcPackageKey :: PackageKey
interactivePackageKey :: PackageKey
isInteractiveModule :: Module -> Bool
wiredInPackageKeys :: [PackageKey]

-- | A Module is a pair of a <a>PackageKey</a> and a <a>ModuleName</a>.
data Module
[Module] :: !PackageKey -> !ModuleName -> Module
[modulePackageKey] :: Module -> !PackageKey
[moduleName] :: Module -> !ModuleName
pprModule :: Module -> SDoc
mkModule :: PackageKey -> ModuleName -> Module

-- | This gives a stable ordering, as opposed to the Ord instance which
--   gives an ordering based on the <a>Unique</a>s of the components, which
--   may not be stable from run to run of the compiler.
stableModuleCmp :: Module -> Module -> Ordering
class HasModule m
getModule :: HasModule m => m Module
class ContainsModule t
extractModule :: ContainsModule t => t -> Module

-- | Where a module lives on the file system: the actual locations of the
--   .hs, .hi and .o files, if we have them
data ModLocation
[ModLocation] :: Maybe FilePath -> FilePath -> FilePath -> ModLocation
[ml_hs_file] :: ModLocation -> Maybe FilePath
[ml_hi_file] :: ModLocation -> FilePath
[ml_obj_file] :: ModLocation -> FilePath

-- | Add the <tt>-boot</tt> suffix to .hs, .hi and .o files
addBootSuffix :: FilePath -> FilePath

-- | Add the <tt>-boot</tt> suffix if the <tt>Bool</tt> argument is
--   <tt>True</tt>
addBootSuffix_maybe :: Bool -> FilePath -> FilePath

-- | Add the <tt>-boot</tt> suffix to all file paths associated with the
--   module
addBootSuffixLocn :: ModLocation -> ModLocation

-- | A map keyed off of <a>Module</a>s
data ModuleEnv elt
elemModuleEnv :: Module -> ModuleEnv a -> Bool
extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a
extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)] -> ModuleEnv a
plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a
delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a
plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b
mkModuleEnv :: [(Module, a)] -> ModuleEnv a
emptyModuleEnv :: ModuleEnv a
moduleEnvKeys :: ModuleEnv a -> [Module]
moduleEnvElts :: ModuleEnv a -> [a]
moduleEnvToList :: ModuleEnv a -> [(Module, a)]
unitModuleEnv :: Module -> a -> ModuleEnv a
isEmptyModuleEnv :: ModuleEnv a -> Bool
foldModuleEnv :: (a -> b -> b) -> b -> ModuleEnv a -> b
extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
filterModuleEnv :: (Module -> a -> Bool) -> ModuleEnv a -> ModuleEnv a

-- | A map keyed off of <a>ModuleName</a>s (actually, their <a>Unique</a>s)
type ModuleNameEnv elt = UniqFM elt

-- | A set of <a>Module</a>s
type ModuleSet = Map Module ()
emptyModuleSet :: ModuleSet
mkModuleSet :: [Module] -> ModuleSet
moduleSetElts :: ModuleSet -> [Module]
extendModuleSet :: ModuleSet -> Module -> ModuleSet
elemModuleSet :: Module -> ModuleSet -> Bool
instance Ord Module
instance Eq Module
instance Eq PackageKey
instance Show ModLocation
instance Outputable ModLocation
instance Uniquable ModuleName
instance Eq ModuleName
instance Ord ModuleName
instance Outputable ModuleName
instance Binary ModuleName
instance BinaryStringRep ModuleName
instance Data ModuleName
instance Uniquable Module
instance Outputable Module
instance Binary Module
instance Data Module
instance Uniquable PackageKey
instance Ord PackageKey
instance Data PackageKey
instance Outputable PackageKey
instance Binary PackageKey
instance BinaryStringRep PackageKey


-- | Package configuration information: essentially the interface to Cabal,
--   with some utilities
--   
--   (c) The University of Glasgow, 2004
module PackageConfig

-- | Get the GHC <a>PackageKey</a> right out of a Cabalish
--   <a>PackageConfig</a>
packageConfigId :: PackageConfig -> PackageKey
type PackageConfig = InstalledPackageInfo InstalledPackageId SourcePackageId PackageName PackageKey ModuleName

-- | This is a subset of Cabal's <a>InstalledPackageInfo</a>, with just the
--   bits that GHC is interested in.
data InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename :: * -> * -> * -> * -> * -> *
[InstalledPackageInfo] :: instpkgid -> srcpkgid -> srcpkgname -> Version -> pkgkey -> [instpkgid] -> [FilePath] -> [String] -> [String] -> [String] -> [FilePath] -> [String] -> [FilePath] -> [String] -> [String] -> [String] -> [FilePath] -> [FilePath] -> [FilePath] -> [ExposedModule instpkgid modulename] -> [modulename] -> [(modulename, OriginalModule instpkgid modulename)] -> Bool -> Bool -> InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename
[installedPackageId] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> instpkgid
[sourcePackageId] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> srcpkgid
[packageName] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> srcpkgname
[packageVersion] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> Version
[packageKey] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> pkgkey
[depends] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [instpkgid]
[importDirs] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [FilePath]
[hsLibraries] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [String]
[extraLibraries] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [String]
[extraGHCiLibraries] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [String]
[libraryDirs] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [FilePath]
[frameworks] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [String]
[frameworkDirs] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [FilePath]
[ldOptions] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [String]
[ccOptions] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [String]
[includes] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [String]
[includeDirs] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [FilePath]
[haddockInterfaces] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [FilePath]
[haddockHTMLs] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [FilePath]
[exposedModules] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [ExposedModule instpkgid modulename]
[hiddenModules] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [modulename]
[instantiatedWith] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> [(modulename, OriginalModule instpkgid modulename)]
[exposed] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> Bool
[trusted] :: InstalledPackageInfo instpkgid srcpkgid srcpkgname pkgkey modulename -> Bool
newtype InstalledPackageId
[InstalledPackageId] :: FastString -> InstalledPackageId
newtype SourcePackageId
[SourcePackageId] :: FastString -> SourcePackageId
newtype PackageName
[PackageName] :: FastString -> PackageName

-- | A <a>Version</a> represents the version of a software entity.
--   
--   An instance of <a>Eq</a> is provided, which implements exact equality
--   modulo reordering of the tags in the <a>versionTags</a> field.
--   
--   An instance of <a>Ord</a> is also provided, which gives lexicographic
--   ordering on the <a>versionBranch</a> fields (i.e. 2.1 &gt; 2.0, 1.2.3
--   &gt; 1.2.2, etc.). This is expected to be sufficient for many uses,
--   but note that you may need to use a more specific ordering for your
--   versioning scheme. For example, some versioning schemes may include
--   pre-releases which have tags <tt>"pre1"</tt>, <tt>"pre2"</tt>, and so
--   on, and these would need to be taken into account when determining
--   ordering. In some cases, date ordering may be more appropriate, so the
--   application would have to look for <tt>date</tt> tags in the
--   <a>versionTags</a> field and compare those. The bottom line is, don't
--   always assume that <a>compare</a> and other <a>Ord</a> operations are
--   the right thing for every <a>Version</a>.
--   
--   Similarly, concrete representations of versions may differ. One
--   possible concrete representation is provided (see <a>showVersion</a>
--   and <a>parseVersion</a>), but depending on the application a different
--   concrete representation may be more appropriate.
data Version :: *
[Version] :: [Int] -> [String] -> Version

-- | The numeric branch for this version. This reflects the fact that most
--   software versions are tree-structured; there is a main trunk which is
--   tagged with versions at various points (1,2,3...), and the first
--   branch off the trunk after version 3 is 3.1, the second branch off the
--   trunk after version 3 is 3.2, and so on. The tree can be branched
--   arbitrarily, just by adding more digits.
--   
--   We represent the branch as a list of <a>Int</a>, so version 3.2.1
--   becomes [3,2,1]. Lexicographic ordering (i.e. the default instance of
--   <a>Ord</a> for <tt>[Int]</tt>) gives the natural ordering of branches.
[versionBranch] :: Version -> [Int]

-- | A version can be tagged with an arbitrary list of strings. The
--   interpretation of the list of tags is entirely dependent on the entity
--   that this version applies to.
[versionTags] :: Version -> [String]
defaultPackageConfig :: PackageConfig
installedPackageIdString :: PackageConfig -> String
sourcePackageIdString :: PackageConfig -> String
packageNameString :: PackageConfig -> String
pprPackageConfig :: PackageConfig -> SDoc
instance Ord PackageName
instance Eq PackageName
instance Ord SourcePackageId
instance Eq SourcePackageId
instance Ord InstalledPackageId
instance Eq InstalledPackageId
instance BinaryStringRep InstalledPackageId
instance BinaryStringRep SourcePackageId
instance BinaryStringRep PackageName
instance Outputable InstalledPackageId
instance Outputable SourcePackageId
instance Outputable PackageName


-- | Dynamic flags
--   
--   Most flags are dynamic flags, which means they can change from
--   compilation to compilation using <tt>OPTIONS_GHC</tt> pragmas, and in
--   a multi-session GHC each session can be using different dynamic flags.
--   Dynamic flags can also be set at the prompt in GHCi.
--   
--   (c) The University of Glasgow 2005
module DynFlags
data DumpFlag
[Opt_D_dump_cmm] :: DumpFlag
[Opt_D_dump_cmm_raw] :: DumpFlag
[Opt_D_dump_cmm_cfg] :: DumpFlag
[Opt_D_dump_cmm_cbe] :: DumpFlag
[Opt_D_dump_cmm_proc] :: DumpFlag
[Opt_D_dump_cmm_sink] :: DumpFlag
[Opt_D_dump_cmm_sp] :: DumpFlag
[Opt_D_dump_cmm_procmap] :: DumpFlag
[Opt_D_dump_cmm_split] :: DumpFlag
[Opt_D_dump_cmm_info] :: DumpFlag
[Opt_D_dump_cmm_cps] :: DumpFlag
[Opt_D_dump_asm] :: DumpFlag
[Opt_D_dump_asm_native] :: DumpFlag
[Opt_D_dump_asm_liveness] :: DumpFlag
[Opt_D_dump_asm_regalloc] :: DumpFlag
[Opt_D_dump_asm_regalloc_stages] :: DumpFlag
[Opt_D_dump_asm_conflicts] :: DumpFlag
[Opt_D_dump_asm_stats] :: DumpFlag
[Opt_D_dump_asm_expanded] :: DumpFlag
[Opt_D_dump_llvm] :: DumpFlag
[Opt_D_dump_core_stats] :: DumpFlag
[Opt_D_dump_deriv] :: DumpFlag
[Opt_D_dump_ds] :: DumpFlag
[Opt_D_dump_foreign] :: DumpFlag
[Opt_D_dump_inlinings] :: DumpFlag
[Opt_D_dump_rule_firings] :: DumpFlag
[Opt_D_dump_rule_rewrites] :: DumpFlag
[Opt_D_dump_simpl_trace] :: DumpFlag
[Opt_D_dump_occur_anal] :: DumpFlag
[Opt_D_dump_parsed] :: DumpFlag
[Opt_D_dump_rn] :: DumpFlag
[Opt_D_dump_simpl] :: DumpFlag
[Opt_D_dump_simpl_iterations] :: DumpFlag
[Opt_D_dump_spec] :: DumpFlag
[Opt_D_dump_prep] :: DumpFlag
[Opt_D_dump_stg] :: DumpFlag
[Opt_D_dump_call_arity] :: DumpFlag
[Opt_D_dump_stranal] :: DumpFlag
[Opt_D_dump_strsigs] :: DumpFlag
[Opt_D_dump_tc] :: DumpFlag
[Opt_D_dump_types] :: DumpFlag
[Opt_D_dump_rules] :: DumpFlag
[Opt_D_dump_cse] :: DumpFlag
[Opt_D_dump_worker_wrapper] :: DumpFlag
[Opt_D_dump_rn_trace] :: DumpFlag
[Opt_D_dump_rn_stats] :: DumpFlag
[Opt_D_dump_opt_cmm] :: DumpFlag
[Opt_D_dump_simpl_stats] :: DumpFlag
[Opt_D_dump_cs_trace] :: DumpFlag
[Opt_D_dump_tc_trace] :: DumpFlag
[Opt_D_dump_if_trace] :: DumpFlag
[Opt_D_dump_vt_trace] :: DumpFlag
[Opt_D_dump_splices] :: DumpFlag
[Opt_D_th_dec_file] :: DumpFlag
[Opt_D_dump_BCOs] :: DumpFlag
[Opt_D_dump_vect] :: DumpFlag
[Opt_D_dump_ticked] :: DumpFlag
[Opt_D_dump_rtti] :: DumpFlag
[Opt_D_source_stats] :: DumpFlag
[Opt_D_verbose_stg2stg] :: DumpFlag
[Opt_D_dump_hi] :: DumpFlag
[Opt_D_dump_hi_diffs] :: DumpFlag
[Opt_D_dump_mod_cycles] :: DumpFlag
[Opt_D_dump_mod_map] :: DumpFlag
[Opt_D_dump_view_pattern_commoning] :: DumpFlag
[Opt_D_verbose_core2core] :: DumpFlag
[Opt_D_dump_debug] :: DumpFlag

-- | Enumerates the simple on-or-off dynamic flags
data GeneralFlag

-- | Append dump output to files instead of stdout.
[Opt_DumpToFile] :: GeneralFlag
[Opt_D_faststring_stats] :: GeneralFlag
[Opt_D_dump_minimal_imports] :: GeneralFlag
[Opt_DoCoreLinting] :: GeneralFlag
[Opt_DoStgLinting] :: GeneralFlag
[Opt_DoCmmLinting] :: GeneralFlag
[Opt_DoAsmLinting] :: GeneralFlag
[Opt_DoAnnotationLinting] :: GeneralFlag
[Opt_NoLlvmMangler] :: GeneralFlag
[Opt_WarnIsError] :: GeneralFlag
[Opt_PrintExplicitForalls] :: GeneralFlag
[Opt_PrintExplicitKinds] :: GeneralFlag
[Opt_CallArity] :: GeneralFlag
[Opt_Strictness] :: GeneralFlag
[Opt_LateDmdAnal] :: GeneralFlag
[Opt_KillAbsence] :: GeneralFlag
[Opt_KillOneShot] :: GeneralFlag
[Opt_FullLaziness] :: GeneralFlag
[Opt_FloatIn] :: GeneralFlag
[Opt_Specialise] :: GeneralFlag
[Opt_SpecialiseAggressively] :: GeneralFlag
[Opt_StaticArgumentTransformation] :: GeneralFlag
[Opt_CSE] :: GeneralFlag
[Opt_LiberateCase] :: GeneralFlag
[Opt_SpecConstr] :: GeneralFlag
[Opt_DoLambdaEtaExpansion] :: GeneralFlag
[Opt_IgnoreAsserts] :: GeneralFlag
[Opt_DoEtaReduction] :: GeneralFlag
[Opt_CaseMerge] :: GeneralFlag
[Opt_UnboxStrictFields] :: GeneralFlag
[Opt_UnboxSmallStrictFields] :: GeneralFlag
[Opt_DictsCheap] :: GeneralFlag
[Opt_EnableRewriteRules] :: GeneralFlag
[Opt_Vectorise] :: GeneralFlag
[Opt_VectorisationAvoidance] :: GeneralFlag
[Opt_RegsGraph] :: GeneralFlag
[Opt_RegsIterative] :: GeneralFlag
[Opt_PedanticBottoms] :: GeneralFlag
[Opt_LlvmTBAA] :: GeneralFlag
[Opt_LlvmPassVectorsInRegisters] :: GeneralFlag
[Opt_IrrefutableTuples] :: GeneralFlag
[Opt_CmmSink] :: GeneralFlag
[Opt_CmmElimCommonBlocks] :: GeneralFlag
[Opt_OmitYields] :: GeneralFlag
[Opt_SimpleListLiterals] :: GeneralFlag
[Opt_FunToThunk] :: GeneralFlag
[Opt_DictsStrict] :: GeneralFlag
[Opt_DmdTxDictSel] :: GeneralFlag
[Opt_Loopification] :: GeneralFlag
[Opt_IgnoreInterfacePragmas] :: GeneralFlag
[Opt_OmitInterfacePragmas] :: GeneralFlag
[Opt_ExposeAllUnfoldings] :: GeneralFlag
[Opt_WriteInterface] :: GeneralFlag
[Opt_AutoSccsOnIndividualCafs] :: GeneralFlag
[Opt_ProfCountEntries] :: GeneralFlag
[Opt_Pp] :: GeneralFlag
[Opt_ForceRecomp] :: GeneralFlag
[Opt_ExcessPrecision] :: GeneralFlag
[Opt_EagerBlackHoling] :: GeneralFlag
[Opt_NoHsMain] :: GeneralFlag
[Opt_SplitObjs] :: GeneralFlag
[Opt_StgStats] :: GeneralFlag
[Opt_HideAllPackages] :: GeneralFlag
[Opt_PrintBindResult] :: GeneralFlag
[Opt_Haddock] :: GeneralFlag
[Opt_HaddockOptions] :: GeneralFlag
[Opt_Hpc_No_Auto] :: GeneralFlag
[Opt_BreakOnException] :: GeneralFlag
[Opt_BreakOnError] :: GeneralFlag
[Opt_PrintEvldWithShow] :: GeneralFlag
[Opt_PrintBindContents] :: GeneralFlag
[Opt_GenManifest] :: GeneralFlag
[Opt_EmbedManifest] :: GeneralFlag
[Opt_EmitExternalCore] :: GeneralFlag
[Opt_SharedImplib] :: GeneralFlag
[Opt_BuildingCabalPackage] :: GeneralFlag
[Opt_IgnoreDotGhci] :: GeneralFlag
[Opt_GhciSandbox] :: GeneralFlag
[Opt_GhciHistory] :: GeneralFlag
[Opt_HelpfulErrors] :: GeneralFlag
[Opt_DeferTypeErrors] :: GeneralFlag
[Opt_DeferTypedHoles] :: GeneralFlag
[Opt_Parallel] :: GeneralFlag
[Opt_GranMacros] :: GeneralFlag
[Opt_PIC] :: GeneralFlag
[Opt_SccProfilingOn] :: GeneralFlag
[Opt_Ticky] :: GeneralFlag
[Opt_Ticky_Allocd] :: GeneralFlag
[Opt_Ticky_LNE] :: GeneralFlag
[Opt_Ticky_Dyn_Thunk] :: GeneralFlag
[Opt_Static] :: GeneralFlag
[Opt_RPath] :: GeneralFlag
[Opt_RelativeDynlibPaths] :: GeneralFlag
[Opt_Hpc] :: GeneralFlag
[Opt_FlatCache] :: GeneralFlag
[Opt_SimplPreInlining] :: GeneralFlag
[Opt_ErrorSpans] :: GeneralFlag
[Opt_PprCaseAsLet] :: GeneralFlag
[Opt_PprShowTicks] :: GeneralFlag
[Opt_SuppressCoercions] :: GeneralFlag
[Opt_SuppressVarKinds] :: GeneralFlag
[Opt_SuppressModulePrefixes] :: GeneralFlag
[Opt_SuppressTypeApplications] :: GeneralFlag
[Opt_SuppressIdInfo] :: GeneralFlag
[Opt_SuppressTypeSignatures] :: GeneralFlag
[Opt_SuppressUniques] :: GeneralFlag
[Opt_AutoLinkPackages] :: GeneralFlag
[Opt_ImplicitImportQualified] :: GeneralFlag
[Opt_KeepHiDiffs] :: GeneralFlag
[Opt_KeepHcFiles] :: GeneralFlag
[Opt_KeepSFiles] :: GeneralFlag
[Opt_KeepTmpFiles] :: GeneralFlag
[Opt_KeepRawTokenStream] :: GeneralFlag
[Opt_KeepLlvmFiles] :: GeneralFlag
[Opt_BuildDynamicToo] :: GeneralFlag
[Opt_DistrustAllPackages] :: GeneralFlag
[Opt_PackageTrust] :: GeneralFlag
[Opt_Debug] :: GeneralFlag
data WarningFlag
[Opt_WarnDuplicateExports] :: WarningFlag
[Opt_WarnDuplicateConstraints] :: WarningFlag
[Opt_WarnHiShadows] :: WarningFlag
[Opt_WarnImplicitPrelude] :: WarningFlag
[Opt_WarnIncompletePatterns] :: WarningFlag
[Opt_WarnIncompleteUniPatterns] :: WarningFlag
[Opt_WarnIncompletePatternsRecUpd] :: WarningFlag
[Opt_WarnOverflowedLiterals] :: WarningFlag
[Opt_WarnEmptyEnumerations] :: WarningFlag
[Opt_WarnMissingFields] :: WarningFlag
[Opt_WarnMissingImportList] :: WarningFlag
[Opt_WarnMissingMethods] :: WarningFlag
[Opt_WarnMissingSigs] :: WarningFlag
[Opt_WarnMissingLocalSigs] :: WarningFlag
[Opt_WarnNameShadowing] :: WarningFlag
[Opt_WarnOverlappingPatterns] :: WarningFlag
[Opt_WarnTypeDefaults] :: WarningFlag
[Opt_WarnMonomorphism] :: WarningFlag
[Opt_WarnUnusedBinds] :: WarningFlag
[Opt_WarnUnusedImports] :: WarningFlag
[Opt_WarnUnusedMatches] :: WarningFlag
[Opt_WarnContextQuantification] :: WarningFlag
[Opt_WarnWarningsDeprecations] :: WarningFlag
[Opt_WarnDeprecatedFlags] :: WarningFlag
[Opt_WarnAMP] :: WarningFlag
[Opt_WarnDodgyExports] :: WarningFlag
[Opt_WarnDodgyImports] :: WarningFlag
[Opt_WarnOrphans] :: WarningFlag
[Opt_WarnAutoOrphans] :: WarningFlag
[Opt_WarnIdentities] :: WarningFlag
[Opt_WarnTabs] :: WarningFlag
[Opt_WarnUnrecognisedPragmas] :: WarningFlag
[Opt_WarnDodgyForeignImports] :: WarningFlag
[Opt_WarnUnusedDoBind] :: WarningFlag
[Opt_WarnWrongDoBind] :: WarningFlag
[Opt_WarnAlternativeLayoutRuleTransitional] :: WarningFlag
[Opt_WarnUnsafe] :: WarningFlag
[Opt_WarnSafe] :: WarningFlag
[Opt_WarnTrustworthySafe] :: WarningFlag
[Opt_WarnPointlessPragmas] :: WarningFlag
[Opt_WarnUnsupportedCallingConventions] :: WarningFlag
[Opt_WarnUnsupportedLlvmVersion] :: WarningFlag
[Opt_WarnInlineRuleShadowing] :: WarningFlag
[Opt_WarnTypedHoles] :: WarningFlag
[Opt_WarnPartialTypeSignatures] :: WarningFlag
[Opt_WarnMissingExportedSigs] :: WarningFlag
[Opt_WarnUntickedPromotedConstructors] :: WarningFlag
[Opt_WarnDerivingTypeable] :: WarningFlag
data ExtensionFlag
[Opt_Cpp] :: ExtensionFlag
[Opt_OverlappingInstances] :: ExtensionFlag
[Opt_UndecidableInstances] :: ExtensionFlag
[Opt_IncoherentInstances] :: ExtensionFlag
[Opt_MonomorphismRestriction] :: ExtensionFlag
[Opt_MonoPatBinds] :: ExtensionFlag
[Opt_MonoLocalBinds] :: ExtensionFlag
[Opt_RelaxedPolyRec] :: ExtensionFlag
[Opt_ExtendedDefaultRules] :: ExtensionFlag
[Opt_ForeignFunctionInterface] :: ExtensionFlag
[Opt_UnliftedFFITypes] :: ExtensionFlag
[Opt_InterruptibleFFI] :: ExtensionFlag
[Opt_CApiFFI] :: ExtensionFlag
[Opt_GHCForeignImportPrim] :: ExtensionFlag
[Opt_JavaScriptFFI] :: ExtensionFlag
[Opt_ParallelArrays] :: ExtensionFlag
[Opt_Arrows] :: ExtensionFlag
[Opt_TemplateHaskell] :: ExtensionFlag
[Opt_QuasiQuotes] :: ExtensionFlag
[Opt_ImplicitParams] :: ExtensionFlag
[Opt_ImplicitPrelude] :: ExtensionFlag
[Opt_ScopedTypeVariables] :: ExtensionFlag
[Opt_AllowAmbiguousTypes] :: ExtensionFlag
[Opt_UnboxedTuples] :: ExtensionFlag
[Opt_BangPatterns] :: ExtensionFlag
[Opt_TypeFamilies] :: ExtensionFlag
[Opt_OverloadedStrings] :: ExtensionFlag
[Opt_OverloadedLists] :: ExtensionFlag
[Opt_NumDecimals] :: ExtensionFlag
[Opt_DisambiguateRecordFields] :: ExtensionFlag
[Opt_RecordWildCards] :: ExtensionFlag
[Opt_RecordPuns] :: ExtensionFlag
[Opt_ViewPatterns] :: ExtensionFlag
[Opt_GADTs] :: ExtensionFlag
[Opt_GADTSyntax] :: ExtensionFlag
[Opt_NPlusKPatterns] :: ExtensionFlag
[Opt_DoAndIfThenElse] :: ExtensionFlag
[Opt_RebindableSyntax] :: ExtensionFlag
[Opt_ConstraintKinds] :: ExtensionFlag
[Opt_PolyKinds] :: ExtensionFlag
[Opt_DataKinds] :: ExtensionFlag
[Opt_InstanceSigs] :: ExtensionFlag
[Opt_StandaloneDeriving] :: ExtensionFlag
[Opt_DeriveDataTypeable] :: ExtensionFlag
[Opt_AutoDeriveTypeable] :: ExtensionFlag
[Opt_DeriveFunctor] :: ExtensionFlag
[Opt_DeriveTraversable] :: ExtensionFlag
[Opt_DeriveFoldable] :: ExtensionFlag
[Opt_DeriveGeneric] :: ExtensionFlag
[Opt_DefaultSignatures] :: ExtensionFlag
[Opt_DeriveAnyClass] :: ExtensionFlag
[Opt_TypeSynonymInstances] :: ExtensionFlag
[Opt_FlexibleContexts] :: ExtensionFlag
[Opt_FlexibleInstances] :: ExtensionFlag
[Opt_ConstrainedClassMethods] :: ExtensionFlag
[Opt_MultiParamTypeClasses] :: ExtensionFlag
[Opt_NullaryTypeClasses] :: ExtensionFlag
[Opt_FunctionalDependencies] :: ExtensionFlag
[Opt_UnicodeSyntax] :: ExtensionFlag
[Opt_ExistentialQuantification] :: ExtensionFlag
[Opt_MagicHash] :: ExtensionFlag
[Opt_EmptyDataDecls] :: ExtensionFlag
[Opt_KindSignatures] :: ExtensionFlag
[Opt_RoleAnnotations] :: ExtensionFlag
[Opt_ParallelListComp] :: ExtensionFlag
[Opt_TransformListComp] :: ExtensionFlag
[Opt_MonadComprehensions] :: ExtensionFlag
[Opt_GeneralizedNewtypeDeriving] :: ExtensionFlag
[Opt_RecursiveDo] :: ExtensionFlag
[Opt_PostfixOperators] :: ExtensionFlag
[Opt_TupleSections] :: ExtensionFlag
[Opt_PatternGuards] :: ExtensionFlag
[Opt_LiberalTypeSynonyms] :: ExtensionFlag
[Opt_RankNTypes] :: ExtensionFlag
[Opt_ImpredicativeTypes] :: ExtensionFlag
[Opt_TypeOperators] :: ExtensionFlag
[Opt_ExplicitNamespaces] :: ExtensionFlag
[Opt_PackageImports] :: ExtensionFlag
[Opt_ExplicitForAll] :: ExtensionFlag
[Opt_AlternativeLayoutRule] :: ExtensionFlag
[Opt_AlternativeLayoutRuleTransitional] :: ExtensionFlag
[Opt_DatatypeContexts] :: ExtensionFlag
[Opt_NondecreasingIndentation] :: ExtensionFlag
[Opt_RelaxedLayout] :: ExtensionFlag
[Opt_TraditionalRecordSyntax] :: ExtensionFlag
[Opt_LambdaCase] :: ExtensionFlag
[Opt_MultiWayIf] :: ExtensionFlag
[Opt_BinaryLiterals] :: ExtensionFlag
[Opt_NegativeLiterals] :: ExtensionFlag
[Opt_EmptyCase] :: ExtensionFlag
[Opt_PatternSynonyms] :: ExtensionFlag
[Opt_PartialTypeSignatures] :: ExtensionFlag
[Opt_NamedWildCards] :: ExtensionFlag
[Opt_StaticPointers] :: ExtensionFlag
data Language
[Haskell98] :: Language
[Haskell2010] :: Language
data PlatformConstants
[PlatformConstants] :: () -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Bool -> Bool -> Int -> Integer -> Integer -> Integer -> PlatformConstants
[pc_platformConstants] :: PlatformConstants -> ()
[pc_STD_HDR_SIZE] :: PlatformConstants -> Int
[pc_PROF_HDR_SIZE] :: PlatformConstants -> Int
[pc_BLOCK_SIZE] :: PlatformConstants -> Int
[pc_BLOCKS_PER_MBLOCK] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR7] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR8] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR9] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rR10] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rF6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rD6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rXMM6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rYMM6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM2] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM3] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM4] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM5] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rZMM6] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rL1] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rSp] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rSpLim] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rHp] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rHpLim] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rCCCS] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rCurrentTSO] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rCurrentNursery] :: PlatformConstants -> Int
[pc_OFFSET_StgRegTable_rHpAlloc] :: PlatformConstants -> Int
[pc_OFFSET_stgEagerBlackholeInfo] :: PlatformConstants -> Int
[pc_OFFSET_stgGCEnter1] :: PlatformConstants -> Int
[pc_OFFSET_stgGCFun] :: PlatformConstants -> Int
[pc_OFFSET_Capability_r] :: PlatformConstants -> Int
[pc_OFFSET_bdescr_start] :: PlatformConstants -> Int
[pc_OFFSET_bdescr_free] :: PlatformConstants -> Int
[pc_OFFSET_bdescr_blocks] :: PlatformConstants -> Int
[pc_SIZEOF_CostCentreStack] :: PlatformConstants -> Int
[pc_OFFSET_CostCentreStack_mem_alloc] :: PlatformConstants -> Int
[pc_REP_CostCentreStack_mem_alloc] :: PlatformConstants -> Int
[pc_OFFSET_CostCentreStack_scc_count] :: PlatformConstants -> Int
[pc_REP_CostCentreStack_scc_count] :: PlatformConstants -> Int
[pc_OFFSET_StgHeader_ccs] :: PlatformConstants -> Int
[pc_OFFSET_StgHeader_ldvw] :: PlatformConstants -> Int
[pc_SIZEOF_StgSMPThunkHeader] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_allocs] :: PlatformConstants -> Int
[pc_REP_StgEntCounter_allocs] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_allocd] :: PlatformConstants -> Int
[pc_REP_StgEntCounter_allocd] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_registeredp] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_link] :: PlatformConstants -> Int
[pc_OFFSET_StgEntCounter_entry_count] :: PlatformConstants -> Int
[pc_SIZEOF_StgUpdateFrame_NoHdr] :: PlatformConstants -> Int
[pc_SIZEOF_StgMutArrPtrs_NoHdr] :: PlatformConstants -> Int
[pc_OFFSET_StgMutArrPtrs_ptrs] :: PlatformConstants -> Int
[pc_OFFSET_StgMutArrPtrs_size] :: PlatformConstants -> Int
[pc_SIZEOF_StgSmallMutArrPtrs_NoHdr] :: PlatformConstants -> Int
[pc_OFFSET_StgSmallMutArrPtrs_ptrs] :: PlatformConstants -> Int
[pc_SIZEOF_StgArrWords_NoHdr] :: PlatformConstants -> Int
[pc_OFFSET_StgArrWords_bytes] :: PlatformConstants -> Int
[pc_OFFSET_StgTSO_alloc_limit] :: PlatformConstants -> Int
[pc_OFFSET_StgTSO_cccs] :: PlatformConstants -> Int
[pc_OFFSET_StgTSO_stackobj] :: PlatformConstants -> Int
[pc_OFFSET_StgStack_sp] :: PlatformConstants -> Int
[pc_OFFSET_StgStack_stack] :: PlatformConstants -> Int
[pc_OFFSET_StgUpdateFrame_updatee] :: PlatformConstants -> Int
[pc_OFFSET_StgFunInfoExtraFwd_arity] :: PlatformConstants -> Int
[pc_REP_StgFunInfoExtraFwd_arity] :: PlatformConstants -> Int
[pc_SIZEOF_StgFunInfoExtraRev] :: PlatformConstants -> Int
[pc_OFFSET_StgFunInfoExtraRev_arity] :: PlatformConstants -> Int
[pc_REP_StgFunInfoExtraRev_arity] :: PlatformConstants -> Int
[pc_MAX_SPEC_SELECTEE_SIZE] :: PlatformConstants -> Int
[pc_MAX_SPEC_AP_SIZE] :: PlatformConstants -> Int
[pc_MIN_PAYLOAD_SIZE] :: PlatformConstants -> Int
[pc_MIN_INTLIKE] :: PlatformConstants -> Int
[pc_MAX_INTLIKE] :: PlatformConstants -> Int
[pc_MIN_CHARLIKE] :: PlatformConstants -> Int
[pc_MAX_CHARLIKE] :: PlatformConstants -> Int
[pc_MUT_ARR_PTRS_CARD_BITS] :: PlatformConstants -> Int
[pc_MAX_Vanilla_REG] :: PlatformConstants -> Int
[pc_MAX_Float_REG] :: PlatformConstants -> Int
[pc_MAX_Double_REG] :: PlatformConstants -> Int
[pc_MAX_Long_REG] :: PlatformConstants -> Int
[pc_MAX_XMM_REG] :: PlatformConstants -> Int
[pc_MAX_Real_Vanilla_REG] :: PlatformConstants -> Int
[pc_MAX_Real_Float_REG] :: PlatformConstants -> Int
[pc_MAX_Real_Double_REG] :: PlatformConstants -> Int
[pc_MAX_Real_XMM_REG] :: PlatformConstants -> Int
[pc_MAX_Real_Long_REG] :: PlatformConstants -> Int
[pc_RESERVED_C_STACK_BYTES] :: PlatformConstants -> Int
[pc_RESERVED_STACK_WORDS] :: PlatformConstants -> Int
[pc_AP_STACK_SPLIM] :: PlatformConstants -> Int
[pc_WORD_SIZE] :: PlatformConstants -> Int
[pc_DOUBLE_SIZE] :: PlatformConstants -> Int
[pc_CINT_SIZE] :: PlatformConstants -> Int
[pc_CLONG_SIZE] :: PlatformConstants -> Int
[pc_CLONG_LONG_SIZE] :: PlatformConstants -> Int
[pc_BITMAP_BITS_SHIFT] :: PlatformConstants -> Int
[pc_TAG_BITS] :: PlatformConstants -> Int
[pc_WORDS_BIGENDIAN] :: PlatformConstants -> Bool
[pc_DYNAMIC_BY_DEFAULT] :: PlatformConstants -> Bool
[pc_LDV_SHIFT] :: PlatformConstants -> Int
[pc_ILDV_CREATE_MASK] :: PlatformConstants -> Integer
[pc_ILDV_STATE_CREATE] :: PlatformConstants -> Integer
[pc_ILDV_STATE_USE] :: PlatformConstants -> Integer
type FatalMessager = String -> IO ()
type LogAction = DynFlags -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()
newtype FlushOut
[FlushOut] :: (IO ()) -> FlushOut
newtype FlushErr
[FlushErr] :: (IO ()) -> FlushErr
data ProfAuto

-- | no SCC annotations added
[NoProfAuto] :: ProfAuto

-- | top-level and nested functions are annotated
[ProfAutoAll] :: ProfAuto

-- | top-level functions annotated only
[ProfAutoTop] :: ProfAuto

-- | exported functions annotated only
[ProfAutoExports] :: ProfAuto

-- | annotate call-sites
[ProfAutoCalls] :: ProfAuto
glasgowExtsFlags :: [ExtensionFlag]

-- | Test whether a <a>DumpFlag</a> is set
dopt :: DumpFlag -> DynFlags -> Bool

-- | Set a <a>DumpFlag</a>
dopt_set :: DynFlags -> DumpFlag -> DynFlags

-- | Unset a <a>DumpFlag</a>
dopt_unset :: DynFlags -> DumpFlag -> DynFlags

-- | Test whether a <a>GeneralFlag</a> is set
gopt :: GeneralFlag -> DynFlags -> Bool

-- | Set a <a>GeneralFlag</a>
gopt_set :: DynFlags -> GeneralFlag -> DynFlags

-- | Unset a <a>GeneralFlag</a>
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags

-- | Test whether a <a>WarningFlag</a> is set
wopt :: WarningFlag -> DynFlags -> Bool

-- | Set a <a>WarningFlag</a>
wopt_set :: DynFlags -> WarningFlag -> DynFlags

-- | Unset a <a>WarningFlag</a>
wopt_unset :: DynFlags -> WarningFlag -> DynFlags

-- | Test whether a <a>ExtensionFlag</a> is set
xopt :: ExtensionFlag -> DynFlags -> Bool

-- | Set a <a>ExtensionFlag</a>
xopt_set :: DynFlags -> ExtensionFlag -> DynFlags

-- | Unset a <a>ExtensionFlag</a>
xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
lang_set :: DynFlags -> Maybe Language -> DynFlags
useUnicodeSyntax :: DynFlags -> Bool
whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a
whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags

-- | Contains not only a collection of <a>GeneralFlag</a>s but also a
--   plethora of information relating to the compilation of a single file
--   or GHC session
data DynFlags
[DynFlags] :: GhcMode -> GhcLink -> HscTarget -> Settings -> SigOf -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe Int -> Bool -> Maybe Int -> Maybe Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Int -> Maybe Int -> Int -> [String] -> [FilePath] -> Module -> Maybe String -> Int -> Int -> PackageKey -> [Way] -> String -> String -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> IORef Bool -> String -> String -> Maybe FilePath -> Maybe [Set String] -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Maybe FilePath -> Maybe FilePath -> [Option] -> [String] -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> String -> [ModuleName] -> [(ModuleName, String)] -> Hooks -> FilePath -> Bool -> [ModuleName] -> [String] -> ([PkgConfRef] -> [PkgConfRef]) -> [PackageFlag] -> Maybe FilePath -> Maybe [PackageConfig] -> PackageState -> IORef [FilePath] -> IORef (Map FilePath FilePath) -> IORef [FilePath] -> IORef Int -> IORef (Set FilePath) -> IntSet -> IntSet -> IntSet -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff ExtensionFlag] -> IntSet -> Int -> Int -> Int -> Int -> Float -> Int -> Int -> Int -> LogAction -> FlushOut -> FlushErr -> Maybe String -> [String] -> Int -> Int -> Int -> Bool -> ProfAuto -> Maybe String -> IORef Int -> IORef (ModuleEnv Int) -> Maybe SseVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IORef (Maybe LinkerInfo) -> IORef (Maybe CompilerInfo) -> Int -> Int -> Int -> DynFlags
[ghcMode] :: DynFlags -> GhcMode
[ghcLink] :: DynFlags -> GhcLink
[hscTarget] :: DynFlags -> HscTarget
[settings] :: DynFlags -> Settings

-- | Compiling an hs-boot against impl.
[sigOf] :: DynFlags -> SigOf

-- | Verbosity level: see Note [Verbosity levels]
[verbosity] :: DynFlags -> Int

-- | Optimisation level
[optLevel] :: DynFlags -> Int

-- | Number of simplifier phases
[simplPhases] :: DynFlags -> Int

-- | Max simplifier iterations
[maxSimplIterations] :: DynFlags -> Int
[ruleCheck] :: DynFlags -> Maybe String

-- | Additional demand analysis
[strictnessBefore] :: DynFlags -> [Int]

-- | The number of modules to compile in parallel in --make mode, where
--   Nothing ==&gt; compile as many in parallel as there are CPUs.
[parMakeCount] :: DynFlags -> Maybe Int

-- | Enable RTS timing statistics?
[enableTimeStats] :: DynFlags -> Bool

-- | The heap size to set.
[ghcHeapSize] :: DynFlags -> Maybe Int

-- | Maximum number of bindings from the type envt to show in type error
--   messages
[maxRelevantBinds] :: DynFlags -> Maybe Int

-- | Multiplier for simplifier ticks
[simplTickFactor] :: DynFlags -> Int

-- | Threshold for SpecConstr
[specConstrThreshold] :: DynFlags -> Maybe Int

-- | Max number of specialisations for any one function
[specConstrCount] :: DynFlags -> Maybe Int

-- | Max number of specialisations for recursive types Not optional;
--   otherwise ForceSpecConstr can diverge.
[specConstrRecursive] :: DynFlags -> Int

-- | Threshold for LiberateCase
[liberateCaseThreshold] :: DynFlags -> Maybe Int

-- | Arg count for lambda floating See CoreMonad.FloatOutSwitches
[floatLamArgs] :: DynFlags -> Maybe Int
[historySize] :: DynFlags -> Int

-- | <pre>
--   -#includes
--   </pre>
[cmdlineHcIncludes] :: DynFlags -> [String]
[importPaths] :: DynFlags -> [FilePath]
[mainModIs] :: DynFlags -> Module
[mainFunIs] :: DynFlags -> Maybe String

-- | Typechecker context stack depth
[ctxtStkDepth] :: DynFlags -> Int

-- | Typechecker type function stack depth
[tyFunStkDepth] :: DynFlags -> Int

-- | name of package currently being compiled
[thisPackage] :: DynFlags -> PackageKey

-- | Way flags from the command line
[ways] :: DynFlags -> [Way]

-- | The global "way" (e.g. "p" for prof)
[buildTag] :: DynFlags -> String

-- | The RTS "way"
[rtsBuildTag] :: DynFlags -> String
[splitInfo] :: DynFlags -> Maybe (String, Int)
[objectDir] :: DynFlags -> Maybe String
[dylibInstallName] :: DynFlags -> Maybe String
[hiDir] :: DynFlags -> Maybe String
[stubDir] :: DynFlags -> Maybe String
[dumpDir] :: DynFlags -> Maybe String
[objectSuf] :: DynFlags -> String
[hcSuf] :: DynFlags -> String
[hiSuf] :: DynFlags -> String
[canGenerateDynamicToo] :: DynFlags -> IORef Bool
[dynObjectSuf] :: DynFlags -> String
[dynHiSuf] :: DynFlags -> String
[dllSplitFile] :: DynFlags -> Maybe FilePath
[dllSplit] :: DynFlags -> Maybe [Set String]
[outputFile] :: DynFlags -> Maybe String
[dynOutputFile] :: DynFlags -> Maybe String
[outputHi] :: DynFlags -> Maybe String
[dynLibLoader] :: DynFlags -> DynLibLoader

-- | This is set by <a>runPipeline</a> based on where its output is going.
[dumpPrefix] :: DynFlags -> Maybe FilePath

-- | Override the <a>dumpPrefix</a> set by <a>runPipeline</a>. Set by
--   <tt>-ddump-file-prefix</tt>
[dumpPrefixForce] :: DynFlags -> Maybe FilePath
[ldInputs] :: DynFlags -> [Option]
[includePaths] :: DynFlags -> [String]
[libraryPaths] :: DynFlags -> [String]
[frameworkPaths] :: DynFlags -> [String]
[cmdlineFrameworks] :: DynFlags -> [String]
[rtsOpts] :: DynFlags -> Maybe String
[rtsOptsEnabled] :: DynFlags -> RtsOptsEnabled

-- | Path to store the .mix files
[hpcDir] :: DynFlags -> String
[pluginModNames] :: DynFlags -> [ModuleName]
[pluginModNameOpts] :: DynFlags -> [(ModuleName, String)]
[hooks] :: DynFlags -> Hooks
[depMakefile] :: DynFlags -> FilePath
[depIncludePkgDeps] :: DynFlags -> Bool
[depExcludeMods] :: DynFlags -> [ModuleName]
[depSuffixes] :: DynFlags -> [String]

-- | The <tt>-package-db</tt> flags given on the command line, in the order
--   they appeared.
[extraPkgConfs] :: DynFlags -> [PkgConfRef] -> [PkgConfRef]

-- | The <tt>-package</tt> and <tt>-hide-package</tt> flags from the
--   command-line
[packageFlags] :: DynFlags -> [PackageFlag]

-- | Filepath to the package environment file (if overriding default)
[packageEnv] :: DynFlags -> Maybe FilePath
[pkgDatabase] :: DynFlags -> Maybe [PackageConfig]
[pkgState] :: DynFlags -> PackageState
[filesToClean] :: DynFlags -> IORef [FilePath]
[dirsToClean] :: DynFlags -> IORef (Map FilePath FilePath)
[filesToNotIntermediateClean] :: DynFlags -> IORef [FilePath]
[nextTempSuffix] :: DynFlags -> IORef Int
[generatedDumps] :: DynFlags -> IORef (Set FilePath)
[dumpFlags] :: DynFlags -> IntSet
[generalFlags] :: DynFlags -> IntSet
[warningFlags] :: DynFlags -> IntSet
[language] :: DynFlags -> Maybe Language

-- | Safe Haskell mode
[safeHaskell] :: DynFlags -> SafeHaskellMode
[safeInfer] :: DynFlags -> Bool
[safeInferred] :: DynFlags -> Bool
[thOnLoc] :: DynFlags -> SrcSpan
[newDerivOnLoc] :: DynFlags -> SrcSpan
[overlapInstLoc] :: DynFlags -> SrcSpan
[incoherentOnLoc] :: DynFlags -> SrcSpan
[pkgTrustOnLoc] :: DynFlags -> SrcSpan
[warnSafeOnLoc] :: DynFlags -> SrcSpan
[warnUnsafeOnLoc] :: DynFlags -> SrcSpan
[trustworthyOnLoc] :: DynFlags -> SrcSpan
[extensions] :: DynFlags -> [OnOff ExtensionFlag]
[extensionFlags] :: DynFlags -> IntSet
[ufCreationThreshold] :: DynFlags -> Int
[ufUseThreshold] :: DynFlags -> Int
[ufFunAppDiscount] :: DynFlags -> Int
[ufDictDiscount] :: DynFlags -> Int
[ufKeenessFactor] :: DynFlags -> Float
[ufDearOp] :: DynFlags -> Int
[maxWorkerArgs] :: DynFlags -> Int
[ghciHistSize] :: DynFlags -> Int

-- | MsgDoc output action: use <a>ErrUtils</a> instead of this if you can
[log_action] :: DynFlags -> LogAction
[flushOut] :: DynFlags -> FlushOut
[flushErr] :: DynFlags -> FlushErr
[haddockOptions] :: DynFlags -> Maybe String
[ghciScripts] :: DynFlags -> [String]
[pprUserLength] :: DynFlags -> Int
[pprCols] :: DynFlags -> Int
[traceLevel] :: DynFlags -> Int
[useUnicode] :: DynFlags -> Bool

-- | what kind of {--} to add automatically
[profAuto] :: DynFlags -> ProfAuto
[interactivePrint] :: DynFlags -> Maybe String
[llvmVersion] :: DynFlags -> IORef Int
[nextWrapperNum] :: DynFlags -> IORef (ModuleEnv Int)

-- | Machine dependant flags (-m<a>blah</a> stuff)
[sseVersion] :: DynFlags -> Maybe SseVersion
[avx] :: DynFlags -> Bool
[avx2] :: DynFlags -> Bool
[avx512cd] :: DynFlags -> Bool
[avx512er] :: DynFlags -> Bool
[avx512f] :: DynFlags -> Bool
[avx512pf] :: DynFlags -> Bool

-- | Run-time linker information (what options we need, etc.)
[rtldInfo] :: DynFlags -> IORef (Maybe LinkerInfo)

-- | Run-time compiler information
[rtccInfo] :: DynFlags -> IORef (Maybe CompilerInfo)

-- | Max size, in bytes, of inline array allocations.
[maxInlineAllocSize] :: DynFlags -> Int

-- | Only inline memcpy if it generates no more than this many pseudo
--   (roughly: Cmm) instructions.
[maxInlineMemcpyInsns] :: DynFlags -> Int

-- | Only inline memset if it generates no more than this many pseudo
--   (roughly: Cmm) instructions.
[maxInlineMemsetInsns] :: DynFlags -> Int
data FlagSpec flag
[FlagSpec] :: String -> flag -> (TurnOnFlag -> DynP ()) -> GhcFlagMode -> FlagSpec flag

-- | Flag in string form
[flagSpecName] :: FlagSpec flag -> String

-- | Flag in internal form
[flagSpecFlag] :: FlagSpec flag -> flag

-- | Extra action to run when the flag is found Typically, emit a warning
--   or error
[flagSpecAction] :: FlagSpec flag -> (TurnOnFlag -> DynP ())

-- | In which ghc mode the flag has effect
[flagSpecGhcMode] :: FlagSpec flag -> GhcFlagMode
class HasDynFlags m
getDynFlags :: HasDynFlags m => m DynFlags
class ContainsDynFlags t
extractDynFlags :: ContainsDynFlags t => t -> DynFlags
replaceDynFlags :: ContainsDynFlags t => t -> DynFlags -> t
data RtsOptsEnabled
[RtsOptsNone] :: RtsOptsEnabled
[RtsOptsSafeOnly] :: RtsOptsEnabled
[RtsOptsAll] :: RtsOptsEnabled

-- | The target code type of the compilation (if any).
--   
--   Whenever you change the target, also make sure to set <a>ghcLink</a>
--   to something sensible.
--   
--   <a>HscNothing</a> can be used to avoid generating any output, however,
--   note that:
--   
--   <ul>
--   <li>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 <a>needsTemplateHaskell</a> 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.)</li>
--   </ul>
data HscTarget

-- | Generate C code.
[HscC] :: HscTarget

-- | Generate assembly using the native code generator.
[HscAsm] :: HscTarget

-- | Generate assembly using the llvm code generator.
[HscLlvm] :: HscTarget

-- | Generate bytecode. (Requires <a>LinkInMemory</a>)
[HscInterpreted] :: HscTarget

-- | Don't generate any code. See notes above.
[HscNothing] :: HscTarget

-- | Will this target result in an object file on the disk?
isObjectTarget :: HscTarget -> Bool

-- | The <a>HscTarget</a> value corresponding to the default way to create
--   object files on the current platform.
defaultObjectTarget :: Platform -> HscTarget

-- | Does this target retain *all* top-level bindings for a module, rather
--   than just the exported bindings, in the TypeEnv and compiled code (if
--   any)? In interpreted mode we do this, so that GHCi can call functions
--   inside a module. In HscNothing mode we also do it, so that Haddock can
--   get access to the GlobalRdrEnv for a module after typechecking it.
targetRetainsAllBindings :: HscTarget -> Bool

-- | The <a>GhcMode</a> tells us whether we're doing multi-module
--   compilation (controlled via the <a>GHC</a> API) or one-shot
--   (single-module) compilation. This makes a difference primarily to the
--   <a>Finder</a>: 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.
data GhcMode

-- | <tt>--make</tt>, GHCi, etc.
[CompManager] :: GhcMode

-- | <pre>
--   ghc -c Foo.hs
--   </pre>
[OneShot] :: GhcMode

-- | <tt>ghc -M</tt>, see <a>Finder</a> for why we need this
[MkDepend] :: GhcMode
isOneShot :: GhcMode -> Bool

-- | What to do in the link step, if there is one.
data GhcLink

-- | Don't link at all
[NoLink] :: GhcLink

-- | Link object code into a binary
[LinkBinary] :: GhcLink

-- | Use the in-memory dynamic linker (works for both bytecode and object
--   code).
[LinkInMemory] :: GhcLink

-- | Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
[LinkDynLib] :: GhcLink

-- | Link objects into a static lib
[LinkStaticLib] :: GhcLink
isNoLink :: GhcLink -> Bool
data PackageFlag
[ExposePackage] :: PackageArg -> ModRenaming -> PackageFlag
[HidePackage] :: String -> PackageFlag
[IgnorePackage] :: String -> PackageFlag
[TrustPackage] :: String -> PackageFlag
[DistrustPackage] :: String -> PackageFlag
data PackageArg
[PackageArg] :: String -> PackageArg
[PackageIdArg] :: String -> PackageArg
[PackageKeyArg] :: String -> PackageArg
data ModRenaming
[ModRenaming] :: Bool -> [(String, String)] -> ModRenaming
data PkgConfRef
[GlobalPkgConf] :: PkgConfRef
[UserPkgConf] :: PkgConfRef
[PkgConfFile] :: FilePath -> PkgConfRef

-- | When invoking external tools as part of the compilation pipeline, we
--   pass these a sequence of options on the command-line. Rather than just
--   using a list of Strings, we use a type that allows us to distinguish
--   between filepaths and 'other stuff'. The reason for this is that this
--   type gives us a handle on transforming filenames, and filenames only,
--   to whatever format they're expected to be on a particular platform.
data Option
[FileOption] :: String -> String -> Option
[Option] :: String -> Option
showOpt :: Option -> String
data DynLibLoader
[Deployable] :: DynLibLoader
[SystemDependent] :: DynLibLoader

-- | These <tt>-f&lt;blah&gt;</tt> flags can all be reversed with
--   <tt>-fno-&lt;blah&gt;</tt>
fFlags :: [FlagSpec GeneralFlag]

-- | These <tt>-f&lt;blah&gt;</tt> flags can all be reversed with
--   <tt>-fno-&lt;blah&gt;</tt>
fWarningFlags :: [FlagSpec WarningFlag]

-- | These <tt>-f&lt;blah&gt;</tt> flags can all be reversed with
--   <tt>-fno-&lt;blah&gt;</tt>
fLangFlags :: [FlagSpec ExtensionFlag]

-- | These -X<a>blah</a> flags can all be reversed with -XNo<a>blah</a>
xFlags :: [FlagSpec ExtensionFlag]

-- | Some modules have dependencies on others through the DynFlags rather
--   than textual imports
dynFlagDependencies :: DynFlags -> [ModuleName]
tablesNextToCode :: DynFlags -> Bool
mkTablesNextToCode :: Bool -> Bool
data SigOf
[NotSigOf] :: SigOf
[SigOf] :: Module -> SigOf
[SigOfMap] :: (Map ModuleName Module) -> SigOf
getSigOf :: DynFlags -> ModuleName -> Maybe Module
data Way
[WayCustom] :: String -> Way
[WayThreaded] :: Way
[WayDebug] :: Way
[WayProf] :: Way
[WayEventLog] :: Way
[WayPar] :: Way
[WayGran] :: Way
[WayNDP] :: Way
[WayDyn] :: Way
mkBuildTag :: [Way] -> String
wayRTSOnly :: Way -> Bool
addWay' :: Way -> DynFlags -> DynFlags
updateWays :: DynFlags -> DynFlags
wayGeneralFlags :: Platform -> Way -> [GeneralFlag]
wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]

-- | The various Safe Haskell modes
data SafeHaskellMode
[Sf_None] :: SafeHaskellMode
[Sf_Unsafe] :: SafeHaskellMode
[Sf_Trustworthy] :: SafeHaskellMode
[Sf_Safe] :: SafeHaskellMode

-- | Is Safe Haskell on in some way (including inference mode)
safeHaskellOn :: DynFlags -> Bool

-- | Test if Safe Imports are on in some form
safeImportsOn :: DynFlags -> Bool

-- | Is the Safe Haskell safe language in use
safeLanguageOn :: DynFlags -> Bool

-- | Is the Safe Haskell safe inference mode active
safeInferOn :: DynFlags -> Bool

-- | Is the -fpackage-trust mode on
packageTrustOn :: DynFlags -> Bool

-- | Are all direct imports required to be safe for this Safe Haskell mode?
--   Direct imports are when the code explicitly imports a module
safeDirectImpsReq :: DynFlags -> Bool

-- | Are all implicit imports required to be safe for this Safe Haskell
--   mode? Implicit imports are things in the prelude. e.g System.IO when
--   print is used.
safeImplicitImpsReq :: DynFlags -> Bool

-- | A list of unsafe flags under Safe Haskell. Tuple elements are: * name
--   of the flag * function to get srcspan that enabled the flag * function
--   to test if the flag is on * function to turn the flag off
unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]

-- | A list of unsafe flags under Safe Haskell. Tuple elements are: * name
--   of the flag * function to get srcspan that enabled the flag * function
--   to test if the flag is on * function to turn the flag off
unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
data Settings
[Settings] :: Platform -> FilePath -> FilePath -> FilePath -> String -> String -> String -> [(String, String)] -> [String] -> FilePath -> Bool -> Bool -> Bool -> Bool -> String -> (String, [Option]) -> String -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> String -> String -> String -> String -> (String, [Option]) -> (String, [Option]) -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> PlatformConstants -> Settings
[sTargetPlatform] :: Settings -> Platform
[sGhcUsagePath] :: Settings -> FilePath
[sGhciUsagePath] :: Settings -> FilePath
[sTopDir] :: Settings -> FilePath
[sTmpDir] :: Settings -> String
[sProgramName] :: Settings -> String
[sProjectVersion] :: Settings -> String
[sRawSettings] :: Settings -> [(String, String)]
[sExtraGccViaCFlags] :: Settings -> [String]
[sSystemPackageConfig] :: Settings -> FilePath
[sLdSupportsCompactUnwind] :: Settings -> Bool
[sLdSupportsBuildId] :: Settings -> Bool
[sLdSupportsFilelist] :: Settings -> Bool
[sLdIsGnuLd] :: Settings -> Bool
[sPgm_L] :: Settings -> String
[sPgm_P] :: Settings -> (String, [Option])
[sPgm_F] :: Settings -> String
[sPgm_c] :: Settings -> (String, [Option])
[sPgm_s] :: Settings -> (String, [Option])
[sPgm_a] :: Settings -> (String, [Option])
[sPgm_l] :: Settings -> (String, [Option])
[sPgm_dll] :: Settings -> (String, [Option])
[sPgm_T] :: Settings -> String
[sPgm_sysman] :: Settings -> String
[sPgm_windres] :: Settings -> String
[sPgm_libtool] :: Settings -> String
[sPgm_lo] :: Settings -> (String, [Option])
[sPgm_lc] :: Settings -> (String, [Option])
[sOpt_L] :: Settings -> [String]
[sOpt_P] :: Settings -> [String]
[sOpt_F] :: Settings -> [String]
[sOpt_c] :: Settings -> [String]
[sOpt_a] :: Settings -> [String]
[sOpt_l] :: Settings -> [String]
[sOpt_windres] :: Settings -> [String]
[sOpt_lo] :: Settings -> [String]
[sOpt_lc] :: Settings -> [String]
[sPlatformConstants] :: Settings -> PlatformConstants
targetPlatform :: DynFlags -> Platform
programName :: DynFlags -> String
projectVersion :: DynFlags -> String
ghcUsagePath :: DynFlags -> FilePath
ghciUsagePath :: DynFlags -> FilePath
topDir :: DynFlags -> FilePath
tmpDir :: DynFlags -> String
rawSettings :: DynFlags -> [(String, String)]

-- | The directory for this version of ghc in the user's app directory
--   (typically something like <tt>~<i>.ghc</i>x86_64-linux-7.6.3</tt>)
versionedAppDir :: DynFlags -> IO FilePath
extraGccViaCFlags :: DynFlags -> [String]
systemPackageConfig :: DynFlags -> FilePath
pgm_L :: DynFlags -> String
pgm_P :: DynFlags -> (String, [Option])
pgm_F :: DynFlags -> String
pgm_c :: DynFlags -> (String, [Option])
pgm_s :: DynFlags -> (String, [Option])
pgm_a :: DynFlags -> (String, [Option])
pgm_l :: DynFlags -> (String, [Option])
pgm_dll :: DynFlags -> (String, [Option])
pgm_T :: DynFlags -> String
pgm_sysman :: DynFlags -> String
pgm_windres :: DynFlags -> String
pgm_libtool :: DynFlags -> String
pgm_lo :: DynFlags -> (String, [Option])
pgm_lc :: DynFlags -> (String, [Option])
opt_L :: DynFlags -> [String]
opt_P :: DynFlags -> [String]
opt_F :: DynFlags -> [String]
opt_c :: DynFlags -> [String]
opt_a :: DynFlags -> [String]
opt_l :: DynFlags -> [String]
opt_windres :: DynFlags -> [String]
opt_lo :: DynFlags -> [String]
opt_lc :: DynFlags -> [String]

-- | The normal <a>DynFlags</a>. Note that they are not suitable for use in
--   this form and must be fully initialized by <a>runGhc</a> first.
defaultDynFlags :: Settings -> DynFlags
defaultWays :: Settings -> [Way]
interpWays :: [Way]

-- | Used by <a>runGhc</a> to partially initialize a new <a>DynFlags</a>
--   value
initDynFlags :: DynFlags -> IO DynFlags
defaultFatalMessager :: FatalMessager
defaultLogAction :: LogAction
defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultFlushOut :: FlushOut
defaultFlushErr :: FlushErr

-- | Retrieve the options corresponding to a particular <tt>opt_*</tt>
--   field in the correct order
getOpts :: DynFlags -> (DynFlags -> [a]) -> [a]

-- | Gets the verbosity flag for the current verbosity level. This is fed
--   to other tools, so GHC-specific verbosity flags like
--   <tt>-ddump-most</tt> are not included
getVerbFlags :: DynFlags -> [String]

-- | Sets the <a>DynFlags</a> to be appropriate to the optimisation level
updOptLevel :: Int -> DynFlags -> DynFlags
setTmpDir :: FilePath -> DynFlags -> DynFlags
setPackageKey :: String -> DynFlags -> DynFlags

-- | Find the package environment (if one exists)
--   
--   We interpret the package environment as a set of package flags; to be
--   specific, if we find a package environment
--   
--   <pre>
--   id1
--   id2
--   ..
--   idn
--   </pre>
--   
--   we interpret this as
--   
--   <pre>
--   [ -hide-all-packages
--   , -package-id id1
--   , -package-id id2
--   , ..
--   , -package-id idn
--   ]
--   </pre>
interpretPackageEnv :: DynFlags -> IO DynFlags

-- | Parse dynamic flags from a list of command line arguments. Returns the
--   the parsed <a>DynFlags</a>, the left-over arguments, and a list of
--   warnings. Throws a <a>UsageError</a> if errors occurred during parsing
--   (such as unknown flags or missing arguments).
parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])

-- | Like <a>parseDynamicFlagsCmdLine</a> but does not allow the package
--   flags (-package, -hide-package, -ignore-package, -hide-all-packages,
--   -package-db). Used to parse flags set in a modules pragma.
parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])

-- | Parses the dynamically set flags for GHC. This is the most general
--   form of the dynamic flag parser that the other methods simply wrap. It
--   allows saying which flags are valid flags and indicating if we are
--   parsing arguments from the command line or from a file pragma.
parseDynamicFlagsFull :: MonadIO m => [Flag (CmdLineP DynFlags)] -> Bool -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])

-- | All dynamic flags option strings. These are the user facing strings
--   for enabling and disabling options.
allFlags :: [String]
flagsAll :: [Flag (CmdLineP DynFlags)]
flagsDynamic :: [Flag (CmdLineP DynFlags)]
flagsPackage :: [Flag (CmdLineP DynFlags)]

-- | Make a list of flags for shell completion. Filter all available flags
--   into two groups, for interactive GHC vs all other.
flagsForCompletion :: Bool -> [String]
supportedLanguagesAndExtensions :: [String]
languageExtensions :: Maybe Language -> [ExtensionFlag]
picCCOpts :: DynFlags -> [String]
picPOpts :: DynFlags -> [String]
data StgToDo
[StgDoMassageForProfiling] :: StgToDo
[D_stg_stats] :: StgToDo
getStgToDo :: DynFlags -> [StgToDo]
compilerInfo :: DynFlags -> [(String, String)]
rtsIsProfiled :: Bool
dynamicGhc :: Bool
sTD_HDR_SIZE :: DynFlags -> Int
pROF_HDR_SIZE :: DynFlags -> Int
bLOCK_SIZE :: DynFlags -> Int
bLOCKS_PER_MBLOCK :: DynFlags -> Int
oFFSET_StgRegTable_rR1 :: DynFlags -> Int
oFFSET_StgRegTable_rR2 :: DynFlags -> Int
oFFSET_StgRegTable_rR3 :: DynFlags -> Int
oFFSET_StgRegTable_rR4 :: DynFlags -> Int
oFFSET_StgRegTable_rR5 :: DynFlags -> Int
oFFSET_StgRegTable_rR6 :: DynFlags -> Int
oFFSET_StgRegTable_rR7 :: DynFlags -> Int
oFFSET_StgRegTable_rR8 :: DynFlags -> Int
oFFSET_StgRegTable_rR9 :: DynFlags -> Int
oFFSET_StgRegTable_rR10 :: DynFlags -> Int
oFFSET_StgRegTable_rF1 :: DynFlags -> Int
oFFSET_StgRegTable_rF2 :: DynFlags -> Int
oFFSET_StgRegTable_rF3 :: DynFlags -> Int
oFFSET_StgRegTable_rF4 :: DynFlags -> Int
oFFSET_StgRegTable_rF5 :: DynFlags -> Int
oFFSET_StgRegTable_rF6 :: DynFlags -> Int
oFFSET_StgRegTable_rD1 :: DynFlags -> Int
oFFSET_StgRegTable_rD2 :: DynFlags -> Int
oFFSET_StgRegTable_rD3 :: DynFlags -> Int
oFFSET_StgRegTable_rD4 :: DynFlags -> Int
oFFSET_StgRegTable_rD5 :: DynFlags -> Int
oFFSET_StgRegTable_rD6 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM1 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM2 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM3 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM4 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM5 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM6 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM1 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM2 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM3 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM4 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM5 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM6 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM1 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM2 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM3 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM4 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM5 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM6 :: DynFlags -> Int
oFFSET_StgRegTable_rL1 :: DynFlags -> Int
oFFSET_StgRegTable_rSp :: DynFlags -> Int
oFFSET_StgRegTable_rSpLim :: DynFlags -> Int
oFFSET_StgRegTable_rHp :: DynFlags -> Int
oFFSET_StgRegTable_rHpLim :: DynFlags -> Int
oFFSET_StgRegTable_rCCCS :: DynFlags -> Int
oFFSET_StgRegTable_rCurrentTSO :: DynFlags -> Int
oFFSET_StgRegTable_rCurrentNursery :: DynFlags -> Int
oFFSET_StgRegTable_rHpAlloc :: DynFlags -> Int
oFFSET_stgEagerBlackholeInfo :: DynFlags -> Int
oFFSET_stgGCEnter1 :: DynFlags -> Int
oFFSET_stgGCFun :: DynFlags -> Int
oFFSET_Capability_r :: DynFlags -> Int
oFFSET_bdescr_start :: DynFlags -> Int
oFFSET_bdescr_free :: DynFlags -> Int
oFFSET_bdescr_blocks :: DynFlags -> Int
sIZEOF_CostCentreStack :: DynFlags -> Int
oFFSET_CostCentreStack_mem_alloc :: DynFlags -> Int
oFFSET_CostCentreStack_scc_count :: DynFlags -> Int
oFFSET_StgHeader_ccs :: DynFlags -> Int
oFFSET_StgHeader_ldvw :: DynFlags -> Int
sIZEOF_StgSMPThunkHeader :: DynFlags -> Int
oFFSET_StgEntCounter_allocs :: DynFlags -> Int
oFFSET_StgEntCounter_allocd :: DynFlags -> Int
oFFSET_StgEntCounter_registeredp :: DynFlags -> Int
oFFSET_StgEntCounter_link :: DynFlags -> Int
oFFSET_StgEntCounter_entry_count :: DynFlags -> Int
sIZEOF_StgUpdateFrame_NoHdr :: DynFlags -> Int
sIZEOF_StgMutArrPtrs_NoHdr :: DynFlags -> Int
oFFSET_StgMutArrPtrs_ptrs :: DynFlags -> Int
oFFSET_StgMutArrPtrs_size :: DynFlags -> Int
sIZEOF_StgSmallMutArrPtrs_NoHdr :: DynFlags -> Int
oFFSET_StgSmallMutArrPtrs_ptrs :: DynFlags -> Int
sIZEOF_StgArrWords_NoHdr :: DynFlags -> Int
oFFSET_StgArrWords_bytes :: DynFlags -> Int
oFFSET_StgTSO_alloc_limit :: DynFlags -> Int
oFFSET_StgTSO_cccs :: DynFlags -> Int
oFFSET_StgTSO_stackobj :: DynFlags -> Int
oFFSET_StgStack_sp :: DynFlags -> Int
oFFSET_StgStack_stack :: DynFlags -> Int
oFFSET_StgUpdateFrame_updatee :: DynFlags -> Int
oFFSET_StgFunInfoExtraFwd_arity :: DynFlags -> Int
sIZEOF_StgFunInfoExtraRev :: DynFlags -> Int
oFFSET_StgFunInfoExtraRev_arity :: DynFlags -> Int
mAX_SPEC_SELECTEE_SIZE :: DynFlags -> Int
mAX_SPEC_AP_SIZE :: DynFlags -> Int
mIN_PAYLOAD_SIZE :: DynFlags -> Int
mIN_INTLIKE :: DynFlags -> Int
mAX_INTLIKE :: DynFlags -> Int
mIN_CHARLIKE :: DynFlags -> Int
mAX_CHARLIKE :: DynFlags -> Int
mUT_ARR_PTRS_CARD_BITS :: DynFlags -> Int
mAX_Vanilla_REG :: DynFlags -> Int
mAX_Float_REG :: DynFlags -> Int
mAX_Double_REG :: DynFlags -> Int
mAX_Long_REG :: DynFlags -> Int
mAX_XMM_REG :: DynFlags -> Int
mAX_Real_Vanilla_REG :: DynFlags -> Int
mAX_Real_Float_REG :: DynFlags -> Int
mAX_Real_Double_REG :: DynFlags -> Int
mAX_Real_XMM_REG :: DynFlags -> Int
mAX_Real_Long_REG :: DynFlags -> Int
rESERVED_C_STACK_BYTES :: DynFlags -> Int
rESERVED_STACK_WORDS :: DynFlags -> Int
aP_STACK_SPLIM :: DynFlags -> Int
wORD_SIZE :: DynFlags -> Int
dOUBLE_SIZE :: DynFlags -> Int
cINT_SIZE :: DynFlags -> Int
cLONG_SIZE :: DynFlags -> Int
cLONG_LONG_SIZE :: DynFlags -> Int
bITMAP_BITS_SHIFT :: DynFlags -> Int
tAG_BITS :: DynFlags -> Int
wORDS_BIGENDIAN :: DynFlags -> Bool
dYNAMIC_BY_DEFAULT :: DynFlags -> Bool
lDV_SHIFT :: DynFlags -> Int
iLDV_CREATE_MASK :: DynFlags -> Integer
iLDV_STATE_CREATE :: DynFlags -> Integer
iLDV_STATE_USE :: DynFlags -> Integer
bLOCK_SIZE_W :: DynFlags -> Int
wORD_SIZE_IN_BITS :: DynFlags -> Int
tAG_MASK :: DynFlags -> Int
mAX_PTR_TAG :: DynFlags -> Int
tARGET_MIN_INT :: DynFlags -> Integer
tARGET_MAX_INT :: DynFlags -> Integer
tARGET_MAX_WORD :: DynFlags -> Integer
unsafeGlobalDynFlags :: DynFlags
setUnsafeGlobalDynFlags :: DynFlags -> IO ()
isSseEnabled :: DynFlags -> Bool
isSse2Enabled :: DynFlags -> Bool
isSse4_2Enabled :: DynFlags -> Bool
isAvxEnabled :: DynFlags -> Bool
isAvx2Enabled :: DynFlags -> Bool
isAvx512cdEnabled :: DynFlags -> Bool
isAvx512erEnabled :: DynFlags -> Bool
isAvx512fEnabled :: DynFlags -> Bool
isAvx512pfEnabled :: DynFlags -> Bool
data LinkerInfo
[GnuLD] :: [Option] -> LinkerInfo
[GnuGold] :: [Option] -> LinkerInfo
[DarwinLD] :: [Option] -> LinkerInfo
[SolarisLD] :: [Option] -> LinkerInfo
[UnknownLD] :: LinkerInfo
data CompilerInfo
[GCC] :: CompilerInfo
[Clang] :: CompilerInfo
[AppleClang] :: CompilerInfo
[AppleClang51] :: CompilerInfo
[UnknownCC] :: CompilerInfo
instance Show PackageFlag
instance Eq PackageFlag
instance Eq LinkerInfo
instance Eq CompilerInfo
instance Ord SseVersion
instance Eq SseVersion
instance Eq Option
instance Show Way
instance Ord Way
instance Eq Way
instance Show RtsOptsEnabled
instance Eq DynLibLoader
instance Show ModRenaming
instance Eq ModRenaming
instance Show PackageArg
instance Eq PackageArg
instance Show GhcLink
instance Eq GhcLink
instance Eq GhcMode
instance Show HscTarget
instance Eq HscTarget
instance Enum ProfAuto
instance Eq ProfAuto
instance Show ExtensionFlag
instance Enum ExtensionFlag
instance Eq ExtensionFlag
instance Eq SafeHaskellMode
instance Enum Language
instance Enum WarningFlag
instance Show WarningFlag
instance Eq WarningFlag
instance Enum GeneralFlag
instance Show GeneralFlag
instance Eq GeneralFlag
instance Enum DumpFlag
instance Show DumpFlag
instance Eq DumpFlag
instance Show SafeHaskellMode
instance Outputable SafeHaskellMode
instance Outputable GhcMode


-- | GHC uses several kinds of name internally:
--   
--   <ul>
--   <li><a>OccName</a> represents names as strings with just a little more
--   information: the "namespace" that the name came from, e.g. the
--   namespace of value, type constructors or data constructors</li>
--   <li><a>RdrName</a>: see <a>RdrName#name_types</a></li>
--   <li><a>Name</a>: see <a>Name#name_types</a></li>
--   <li><a>Id</a>: see <a>Id#name_types</a></li>
--   <li><a>Var</a>: see <a>Var#name_types</a></li>
--   </ul>
module OccName
data NameSpace
nameSpacesRelated :: NameSpace -> NameSpace -> Bool
tcName :: NameSpace
clsName :: NameSpace
tcClsName :: NameSpace
dataName :: NameSpace
varName :: NameSpace
tvName :: NameSpace
srcDataName :: NameSpace
pprNameSpace :: NameSpace -> SDoc
pprNonVarNameSpace :: NameSpace -> SDoc
pprNameSpaceBrief :: NameSpace -> SDoc
data OccName
pprOccName :: OccName -> SDoc
mkOccName :: NameSpace -> String -> OccName
mkOccNameFS :: NameSpace -> FastString -> OccName
mkVarOcc :: String -> OccName
mkVarOccFS :: FastString -> OccName
mkDataOcc :: String -> OccName
mkDataOccFS :: FastString -> OccName
mkTyVarOcc :: String -> OccName
mkTyVarOccFS :: FastString -> OccName
mkTcOcc :: String -> OccName
mkTcOccFS :: FastString -> OccName
mkClsOcc :: String -> OccName
mkClsOccFS :: FastString -> OccName
mkDFunOcc :: String -> Bool -> OccSet -> OccName
setOccNameSpace :: NameSpace -> OccName -> OccName
demoteOccName :: OccName -> Maybe OccName

-- | Other names in the compiler add additional information to an OccName.
--   This class provides a consistent way to access the underlying OccName.
class HasOccName name
occName :: HasOccName name => name -> OccName
isDerivedOccName :: OccName -> Bool
mkDataConWrapperOcc :: OccName -> OccName
mkWorkerOcc :: OccName -> OccName
mkMatcherOcc :: OccName -> OccName
mkBuilderOcc :: OccName -> OccName
mkDefaultMethodOcc :: OccName -> OccName
mkGenDefMethodOcc :: OccName -> OccName
mkDerivedTyConOcc :: OccName -> OccName
mkNewTyCoOcc :: OccName -> OccName
mkClassOpAuxOcc :: OccName -> OccName
mkCon2TagOcc :: OccName -> OccName
mkTag2ConOcc :: OccName -> OccName
mkMaxTagOcc :: OccName -> OccName
mkClassDataConOcc :: OccName -> OccName
mkDictOcc :: OccName -> OccName
mkIPOcc :: OccName -> OccName
mkSpecOcc :: OccName -> OccName
mkForeignExportOcc :: OccName -> OccName
mkRepEqOcc :: OccName -> OccName
mkGenOcc1 :: OccName -> OccName
mkGenOcc2 :: OccName -> OccName
mkGenD :: OccName -> OccName
mkGenR :: OccName -> OccName
mkGen1R :: OccName -> OccName
mkGenRCo :: OccName -> OccName
mkGenC :: OccName -> Int -> OccName
mkGenS :: OccName -> Int -> Int -> OccName
mkDataTOcc :: OccName -> OccName
mkDataCOcc :: OccName -> OccName
mkDataConWorkerOcc :: OccName -> OccName
mkSuperDictSelOcc :: Int -> OccName -> OccName
mkLocalOcc :: Unique -> OccName -> OccName
mkMethodOcc :: OccName -> OccName

-- | Derive a name for the representation type constructor of a
--   <tt>data</tt>/<tt>newtype</tt> instance.
mkInstTyTcOcc :: String -> OccSet -> OccName
mkInstTyCoOcc :: OccName -> OccName
mkEqPredCoOcc :: OccName -> OccName
mkVectOcc :: Maybe String -> OccName -> OccName
mkVectTyConOcc :: Maybe String -> OccName -> OccName
mkVectDataConOcc :: Maybe String -> OccName -> OccName
mkVectIsoOcc :: Maybe String -> OccName -> OccName
mkPDataTyConOcc :: Maybe String -> OccName -> OccName
mkPDataDataConOcc :: Maybe String -> OccName -> OccName
mkPDatasTyConOcc :: Maybe String -> OccName -> OccName
mkPDatasDataConOcc :: Maybe String -> OccName -> OccName
mkPReprTyConOcc :: Maybe String -> OccName -> OccName
mkPADFunOcc :: Maybe String -> OccName -> OccName
occNameFS :: OccName -> FastString
occNameString :: OccName -> String
occNameSpace :: OccName -> NameSpace
isVarOcc :: OccName -> Bool
isTvOcc :: OccName -> Bool
isTcOcc :: OccName -> Bool
isDataOcc :: OccName -> Bool

-- | Test if the <a>OccName</a> is a data constructor that starts with a
--   symbol (e.g. <tt>:</tt>, or <tt>[]</tt>)
isDataSymOcc :: OccName -> Bool

-- | Test if the <a>OccName</a> is that for any operator (whether it is a
--   data constructor or variable or whatever)
isSymOcc :: OccName -> Bool

-- | <i>Value</i> <tt>OccNames</tt>s are those that are either in the
--   variable or data constructor namespaces
isValOcc :: OccName -> Bool

-- | Wrap parens around an operator
parenSymOcc :: OccName -> SDoc -> SDoc

-- | Haskell 98 encourages compilers to suppress warnings about unsed names
--   in a pattern if they start with <tt>_</tt>: this implements that test
startsWithUnderscore :: OccName -> Bool
isTcClsNameSpace :: NameSpace -> Bool
isTvNameSpace :: NameSpace -> Bool
isDataConNameSpace :: NameSpace -> Bool
isVarNameSpace :: NameSpace -> Bool
isValNameSpace :: NameSpace -> Bool
data OccEnv a
emptyOccEnv :: OccEnv a
unitOccEnv :: OccName -> a -> OccEnv a
extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b
lookupOccEnv :: OccEnv a -> OccName -> Maybe a
mkOccEnv :: [(OccName, a)] -> OccEnv a
mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a
extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
elemOccEnv :: OccName -> OccEnv a -> Bool
occEnvElts :: OccEnv a -> [a]
foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a
extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a
extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b
filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt
pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc
type OccSet = UniqSet OccName
emptyOccSet :: OccSet
unitOccSet :: OccName -> OccSet
mkOccSet :: [OccName] -> OccSet
extendOccSet :: OccSet -> OccName -> OccSet
extendOccSetList :: OccSet -> [OccName] -> OccSet
unionOccSets :: OccSet -> OccSet -> OccSet
unionManyOccSets :: [OccSet] -> OccSet
minusOccSet :: OccSet -> OccSet -> OccSet
elemOccSet :: OccName -> OccSet -> Bool
occSetElts :: OccSet -> [OccName]
foldOccSet :: (OccName -> b -> b) -> b -> OccSet -> b
isEmptyOccSet :: OccSet -> Bool
intersectOccSet :: OccSet -> OccSet -> OccSet
intersectsOccSet :: OccSet -> OccSet -> Bool
type TidyOccEnv = UniqFM Int
emptyTidyOccEnv :: TidyOccEnv
tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
initTidyOccEnv :: [OccName] -> TidyOccEnv
type FastStringEnv a = UniqFM a
emptyFsEnv :: FastStringEnv a
lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
mkFsEnv :: [(FastString, a)] -> FastStringEnv a
instance Ord NameSpace
instance Eq NameSpace
instance Eq OccName
instance Ord OccName
instance Data OccName
instance HasOccName OccName
instance Outputable OccName
instance OutputableBndr OccName
instance Uniquable OccName
instance Outputable a => Outputable (OccEnv a)
instance Binary NameSpace
instance Binary OccName

module HsImpExp
type LImportDecl name = Located (ImportDecl name)  When in a list this may have  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi'

-- | A single Haskell <tt>import</tt> declaration.
data ImportDecl name

-- | <a>AnnKeywordId</a>s
--   
--   <ul>
--   <li><a>AnnImport</a></li>
--   <li><a>AnnOpen</a>, <a>AnnClose</a> for ideclSource</li>
--   <li><a>AnnSafe</a>,<a>AnnQualified</a>,
--   <a>AnnPackageName</a>,<a>AnnAs</a>, <a>AnnVal</a></li>
--   <li><a>AnnHiding</a>,<a>AnnOpen</a>, <a>AnnClose</a> attached to
--   location in ideclHiding</li>
--   </ul>
[ImportDecl] :: Maybe SourceText -> Located ModuleName -> Maybe FastString -> Bool -> Bool -> Bool -> Bool -> Maybe ModuleName -> Maybe (Bool, Located [LIE name]) -> ImportDecl name
[ideclSourceSrc] :: ImportDecl name -> Maybe SourceText

-- | Module name.
[ideclName] :: ImportDecl name -> Located ModuleName

-- | Package qualifier.
[ideclPkgQual] :: ImportDecl name -> Maybe FastString

-- | True <a>=</a> {-# SOURCE #-} import
[ideclSource] :: ImportDecl name -> Bool

-- | True =&gt; safe import
[ideclSafe] :: ImportDecl name -> Bool

-- | True =&gt; qualified
[ideclQualified] :: ImportDecl name -> Bool

-- | True =&gt; implicit import (of Prelude)
[ideclImplicit] :: ImportDecl name -> Bool

-- | as Module
[ideclAs] :: ImportDecl name -> Maybe ModuleName

-- | (True =&gt; hiding, names)
[ideclHiding] :: ImportDecl name -> Maybe (Bool, Located [LIE name])
simpleImportDecl :: ModuleName -> ImportDecl name
type LIE name = Located (IE name)  When in a list this may have  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma'

-- | Imported or exported entity.
data IE name

-- | <ul>
--   <li><a>AnnKeywordId</a>s : <a>AnnPattern</a>, <a>AnnType</a></li>
--   </ul>
[IEVar] :: (Located name) -> IE name

-- | Class/Type (can't tell) - <a>AnnKeywordId</a>s : <a>AnnPattern</a>,
--   <a>AnnType</a>,<a>AnnVal</a>
[IEThingAbs] :: (Located name) -> IE name

-- | Class<i>Type plus all methods</i>constructors
--   
--   <ul>
--   <li><a>AnnKeywordId</a>s : <a>AnnOpen</a>,
--   <a>AnnDotdot</a>,<a>AnnClose</a>, <a>AnnType</a></li>
--   </ul>
[IEThingAll] :: (Located name) -> IE name

-- | Class<i>Type plus some methods</i>constructors - <a>AnnKeywordId</a>s
--   : <a>AnnOpen</a>, <a>AnnClose</a>, <a>AnnComma</a>, <a>AnnType</a>
[IEThingWith] :: (Located name) -> [Located name] -> IE name

-- | (Export Only)
--   
--   <ul>
--   <li><a>AnnKeywordId</a>s : <a>AnnModule</a></li>
--   </ul>
[IEModuleContents] :: (Located ModuleName) -> IE name

-- | Doc section heading
[IEGroup] :: Int -> HsDocString -> IE name

-- | Some documentation
[IEDoc] :: HsDocString -> IE name

-- | Reference to named doc
[IEDocNamed] :: String -> IE name
ieName :: IE name -> name
ieNames :: IE a -> [a]
pprImpExp :: (HasOccName name, OutputableBndr name) => name -> SDoc
instance Data name => Data (ImportDecl name)
instance Data name => Data (IE name)
instance Eq name => Eq (IE name)
instance (OutputableBndr name, HasOccName name) => Outputable (ImportDecl name)
instance (HasOccName name, OutputableBndr name) => Outputable (IE name)

module ErrUtils
type MsgDoc = SDoc
data Validity
[IsValid] :: Validity
[NotValid] :: MsgDoc -> Validity
andValid :: Validity -> Validity -> Validity
allValid :: [Validity] -> Validity
isValid :: Validity -> Bool
getInvalids :: [Validity] -> [MsgDoc]
data ErrMsg
type WarnMsg = ErrMsg
data Severity
[SevOutput] :: Severity
[SevDump] :: Severity
[SevInteractive] :: Severity
[SevInfo] :: Severity
[SevWarning] :: Severity
[SevError] :: Severity
[SevFatal] :: Severity
type Messages = (WarningMessages, ErrorMessages)
type ErrorMessages = Bag ErrMsg
type WarningMessages = Bag WarnMsg
errMsgSpan :: ErrMsg -> SrcSpan
errMsgContext :: ErrMsg -> PrintUnqualified
errMsgShortDoc :: ErrMsg -> MsgDoc
errMsgExtraInfo :: ErrMsg -> MsgDoc
mkLocMessage :: Severity -> SrcSpan -> MsgDoc -> MsgDoc
pprMessageBag :: Bag MsgDoc -> SDoc
pprErrMsgBag :: Bag ErrMsg -> [SDoc]
pprErrMsgBagWithLoc :: Bag ErrMsg -> [SDoc]
pprLocErrMsg :: ErrMsg -> SDoc
makeIntoWarning :: ErrMsg -> ErrMsg
isWarning :: ErrMsg -> Bool
errorsFound :: DynFlags -> Messages -> Bool
emptyMessages :: Messages
isEmptyMessages :: Messages -> Bool
mkErrMsg :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> ErrMsg
mkPlainErrMsg :: DynFlags -> SrcSpan -> MsgDoc -> ErrMsg
mkLongErrMsg :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> MsgDoc -> ErrMsg
mkWarnMsg :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> ErrMsg
mkPlainWarnMsg :: DynFlags -> SrcSpan -> MsgDoc -> ErrMsg
printBagOfErrors :: DynFlags -> Bag ErrMsg -> IO ()
warnIsErrorMsg :: DynFlags -> ErrMsg
mkLongWarnMsg :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> MsgDoc -> ErrMsg
ghcExit :: DynFlags -> Int -> IO ()
doIfSet :: Bool -> IO () -> IO ()
doIfSet_dyn :: DynFlags -> GeneralFlag -> IO () -> IO ()
dumpIfSet :: DynFlags -> Bool -> String -> SDoc -> IO ()

-- | a wrapper around <a>dumpSDoc</a>. First check whether the dump flag is
--   set Do nothing if it is unset
dumpIfSet_dyn :: DynFlags -> DumpFlag -> String -> SDoc -> IO ()

-- | a wrapper around <a>dumpSDoc</a>. First check whether the dump flag is
--   set Do nothing if it is unset
--   
--   Unlike <a>dumpIfSet_dyn</a>, has a printer argument but no header
--   argument
dumpIfSet_dyn_printer :: PrintUnqualified -> DynFlags -> DumpFlag -> SDoc -> IO ()
mkDumpDoc :: String -> SDoc -> SDoc

-- | Write out a dump. If --dump-to-file is set then this goes to a file.
--   otherwise emit to stdout.
--   
--   When hdr is empty, we print in a more compact format (no separators
--   and blank lines)
--   
--   The DumpFlag is used only to choose the filename to use if
--   --dump-to-file is used; it is not used to decide whether to dump the
--   output
dumpSDoc :: DynFlags -> PrintUnqualified -> DumpFlag -> String -> SDoc -> IO ()
putMsg :: DynFlags -> MsgDoc -> IO ()
printInfoForUser :: DynFlags -> PrintUnqualified -> MsgDoc -> IO ()
printOutputForUser :: DynFlags -> PrintUnqualified -> MsgDoc -> IO ()
logInfo :: DynFlags -> PprStyle -> MsgDoc -> IO ()
logOutput :: DynFlags -> PprStyle -> MsgDoc -> IO ()
errorMsg :: DynFlags -> MsgDoc -> IO ()
fatalErrorMsg :: DynFlags -> MsgDoc -> IO ()
fatalErrorMsg' :: LogAction -> DynFlags -> MsgDoc -> IO ()
fatalErrorMsg'' :: FatalMessager -> String -> IO ()
compilationProgressMsg :: DynFlags -> String -> IO ()
showPass :: DynFlags -> String -> IO ()
debugTraceMsg :: DynFlags -> Int -> MsgDoc -> IO ()
prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a
instance Show ErrMsg


-- | The LLVM Type System.
module Llvm.Types

-- | A global mutable variable. Maybe defined or external
data LMGlobal
[LMGlobal] :: LlvmVar -> Maybe LlvmStatic -> LMGlobal

-- | Returns the variable of the <a>LMGlobal</a>
[getGlobalVar] :: LMGlobal -> LlvmVar

-- | Return the value of the <a>LMGlobal</a>
[getGlobalValue] :: LMGlobal -> Maybe LlvmStatic

-- | A String in LLVM
type LMString = FastString

-- | A type alias
type LlvmAlias = (LMString, LlvmType)

-- | Llvm Types
data LlvmType

-- | An integer with a given width in bits.
[LMInt] :: Int -> LlvmType

-- | 32 bit floating point
[LMFloat] :: LlvmType

-- | 64 bit floating point
[LMDouble] :: LlvmType

-- | 80 bit (x86 only) floating point
[LMFloat80] :: LlvmType

-- | 128 bit floating point
[LMFloat128] :: LlvmType

-- | A pointer to a <a>LlvmType</a>
[LMPointer] :: LlvmType -> LlvmType

-- | An array of <a>LlvmType</a>
[LMArray] :: Int -> LlvmType -> LlvmType

-- | A vector of <a>LlvmType</a>
[LMVector] :: Int -> LlvmType -> LlvmType

-- | A <a>LlvmVar</a> can represent a label (address)
[LMLabel] :: LlvmType

-- | Void type
[LMVoid] :: LlvmType

-- | Structure type
[LMStruct] :: [LlvmType] -> LlvmType

-- | A type alias
[LMAlias] :: LlvmAlias -> LlvmType

-- | LLVM Metadata
[LMMetadata] :: LlvmType

-- | Function type, used to create pointers to functions
[LMFunction] :: LlvmFunctionDecl -> LlvmType
ppParams :: LlvmParameterListType -> [LlvmParameter] -> SDoc

-- | An LLVM section definition. If Nothing then let LLVM decide the
--   section
type LMSection = Maybe LMString
type LMAlign = Maybe Int
data LMConst

-- | Mutable global variable
[Global] :: LMConst

-- | Constant global variable
[Constant] :: LMConst

-- | Alias of another variable
[Alias] :: LMConst

-- | LLVM Variables
data LlvmVar

-- | Variables with a global scope.
[LMGlobalVar] :: LMString -> LlvmType -> LlvmLinkageType -> LMSection -> LMAlign -> LMConst -> LlvmVar

-- | Variables local to a function or parameters.
[LMLocalVar] :: Unique -> LlvmType -> LlvmVar

-- | Named local variables. Sometimes we need to be able to explicitly name
--   variables (e.g for function arguments).
[LMNLocalVar] :: LMString -> LlvmType -> LlvmVar

-- | A constant variable
[LMLitVar] :: LlvmLit -> LlvmVar

-- | Llvm Literal Data.
--   
--   These can be used inline in expressions.
data LlvmLit

-- | Refers to an integer constant (i64 42).
[LMIntLit] :: Integer -> LlvmType -> LlvmLit

-- | Floating point literal
[LMFloatLit] :: Double -> LlvmType -> LlvmLit

-- | Literal NULL, only applicable to pointer types
[LMNullLit] :: LlvmType -> LlvmLit

-- | Vector literal
[LMVectorLit] :: [LlvmLit] -> LlvmLit

-- | Undefined value, random bit pattern. Useful for optimisations.
[LMUndefLit] :: LlvmType -> LlvmLit

-- | Llvm Static Data.
--   
--   These represent the possible global level variables and constants.
data LlvmStatic

-- | A comment in a static section
[LMComment] :: LMString -> LlvmStatic

-- | A static variant of a literal value
[LMStaticLit] :: LlvmLit -> LlvmStatic

-- | For uninitialised data
[LMUninitType] :: LlvmType -> LlvmStatic

-- | Defines a static <a>LMString</a>
[LMStaticStr] :: LMString -> LlvmType -> LlvmStatic

-- | A static array
[LMStaticArray] :: [LlvmStatic] -> LlvmType -> LlvmStatic

-- | A static structure type
[LMStaticStruc] :: [LlvmStatic] -> LlvmType -> LlvmStatic

-- | A pointer to other data
[LMStaticPointer] :: LlvmVar -> LlvmStatic

-- | Pointer to Pointer conversion
[LMBitc] :: LlvmStatic -> LlvmType -> LlvmStatic

-- | Pointer to Integer conversion
[LMPtoI] :: LlvmStatic -> LlvmType -> LlvmStatic

-- | Constant addition operation
[LMAdd] :: LlvmStatic -> LlvmStatic -> LlvmStatic

-- | Constant subtraction operation
[LMSub] :: LlvmStatic -> LlvmStatic -> LlvmStatic
pprStaticArith :: LlvmStatic -> LlvmStatic -> LitString -> LitString -> String -> SDoc

-- | Return the variable name or value of the <a>LlvmVar</a> in Llvm IR
--   textual representation (e.g. <tt>@x</tt>, <tt>%y</tt> or <tt>42</tt>).
ppName :: LlvmVar -> SDoc

-- | Return the variable name or value of the <a>LlvmVar</a> in a plain
--   textual representation (e.g. <tt>x</tt>, <tt>y</tt> or <tt>42</tt>).
ppPlainName :: LlvmVar -> SDoc

-- | Print a literal value. No type.
ppLit :: LlvmLit -> SDoc

-- | Return the <a>LlvmType</a> of the <a>LlvmVar</a>
getVarType :: LlvmVar -> LlvmType

-- | Return the <a>LlvmType</a> of a <a>LlvmLit</a>
getLitType :: LlvmLit -> LlvmType

-- | Return the <a>LlvmType</a> of the <a>LlvmStatic</a>
getStatType :: LlvmStatic -> LlvmType

-- | Return the <a>LlvmLinkageType</a> for a <a>LlvmVar</a>
getLink :: LlvmVar -> LlvmLinkageType

-- | Add a pointer indirection to the supplied type. <a>LMLabel</a> and
--   <a>LMVoid</a> cannot be lifted.
pLift :: LlvmType -> LlvmType

-- | Lower a variable of <a>LMPointer</a> type.
pVarLift :: LlvmVar -> LlvmVar

-- | Remove the pointer indirection of the supplied type. Only
--   <a>LMPointer</a> constructors can be lowered.
pLower :: LlvmType -> LlvmType

-- | Lower a variable of <a>LMPointer</a> type.
pVarLower :: LlvmVar -> LlvmVar

-- | Test if the given <a>LlvmType</a> is an integer
isInt :: LlvmType -> Bool

-- | Test if the given <a>LlvmType</a> is a floating point type
isFloat :: LlvmType -> Bool

-- | Test if the given <a>LlvmType</a> is an <a>LMPointer</a> construct
isPointer :: LlvmType -> Bool

-- | Test if the given <a>LlvmType</a> is an <a>LMVector</a> construct
isVector :: LlvmType -> Bool

-- | Test if a <a>LlvmVar</a> is global.
isGlobal :: LlvmVar -> Bool

-- | Width in bits of an <a>LlvmType</a>, returns 0 if not applicable
llvmWidthInBits :: DynFlags -> LlvmType -> Int
i128 :: LlvmType
i64 :: LlvmType
i32 :: LlvmType
i16 :: LlvmType
i8 :: LlvmType
i1 :: LlvmType
i8Ptr :: LlvmType

-- | The target architectures word size
llvmWord :: DynFlags -> LlvmType

-- | The target architectures word size
llvmWordPtr :: DynFlags -> LlvmType

-- | An LLVM Function
data LlvmFunctionDecl
[LlvmFunctionDecl] :: LMString -> LlvmLinkageType -> LlvmCallConvention -> LlvmType -> LlvmParameterListType -> [LlvmParameter] -> LMAlign -> LlvmFunctionDecl

-- | Unique identifier of the function
[decName] :: LlvmFunctionDecl -> LMString

-- | LinkageType of the function
[funcLinkage] :: LlvmFunctionDecl -> LlvmLinkageType

-- | The calling convention of the function
[funcCc] :: LlvmFunctionDecl -> LlvmCallConvention

-- | Type of the returned value
[decReturnType] :: LlvmFunctionDecl -> LlvmType

-- | Indicates if this function uses varargs
[decVarargs] :: LlvmFunctionDecl -> LlvmParameterListType

-- | Parameter types and attributes
[decParams] :: LlvmFunctionDecl -> [LlvmParameter]

-- | Function align value, must be power of 2
[funcAlign] :: LlvmFunctionDecl -> LMAlign
type LlvmFunctionDecls = [LlvmFunctionDecl]
type LlvmParameter = (LlvmType, [LlvmParamAttr])

-- | LLVM Parameter Attributes.
--   
--   Parameter attributes are used to communicate additional information
--   about the result or parameters of a function
data LlvmParamAttr

-- | This indicates to the code generator that the parameter or return
--   value should be zero-extended to a 32-bit value by the caller (for a
--   parameter) or the callee (for a return value).
[ZeroExt] :: LlvmParamAttr

-- | This indicates to the code generator that the parameter or return
--   value should be sign-extended to a 32-bit value by the caller (for a
--   parameter) or the callee (for a return value).
[SignExt] :: LlvmParamAttr

-- | This indicates that this parameter or return value should be treated
--   in a special target-dependent fashion during while emitting code for a
--   function call or return (usually, by putting it in a register as
--   opposed to memory).
[InReg] :: LlvmParamAttr

-- | This indicates that the pointer parameter should really be passed by
--   value to the function.
[ByVal] :: LlvmParamAttr

-- | This indicates that the pointer parameter specifies the address of a
--   structure that is the return value of the function in the source
--   program.
[SRet] :: LlvmParamAttr

-- | This indicates that the pointer does not alias any global or any other
--   parameter.
[NoAlias] :: LlvmParamAttr

-- | This indicates that the callee does not make any copies of the pointer
--   that outlive the callee itself
[NoCapture] :: LlvmParamAttr

-- | This indicates that the pointer parameter can be excised using the
--   trampoline intrinsics.
[Nest] :: LlvmParamAttr

-- | Llvm Function Attributes.
--   
--   Function attributes are set to communicate additional information
--   about a function. Function attributes are considered to be part of the
--   function, not of the function type, so functions with different
--   parameter attributes can have the same function type. Functions can
--   have multiple attributes.
--   
--   Descriptions taken from
--   <a>http://llvm.org/docs/LangRef.html#fnattrs</a>
data LlvmFuncAttr

-- | This attribute indicates that the inliner should attempt to inline
--   this function into callers whenever possible, ignoring any active
--   inlining size threshold for this caller.
[AlwaysInline] :: LlvmFuncAttr

-- | This attribute indicates that the source code contained a hint that
--   inlining this function is desirable (such as the "inline" keyword in
--   C/C++). It is just a hint; it imposes no requirements on the inliner.
[InlineHint] :: LlvmFuncAttr

-- | This attribute indicates that the inliner should never inline this
--   function in any situation. This attribute may not be used together
--   with the alwaysinline attribute.
[NoInline] :: LlvmFuncAttr

-- | This attribute suggests that optimization passes and code generator
--   passes make choices that keep the code size of this function low, and
--   otherwise do optimizations specifically to reduce code size.
[OptSize] :: LlvmFuncAttr

-- | This function attribute indicates that the function never returns
--   normally. This produces undefined behavior at runtime if the function
--   ever does dynamically return.
[NoReturn] :: LlvmFuncAttr

-- | This function attribute indicates that the function never returns with
--   an unwind or exceptional control flow. If the function does unwind,
--   its runtime behavior is undefined.
[NoUnwind] :: LlvmFuncAttr

-- | This attribute indicates that the function computes its result (or
--   decides to unwind an exception) based strictly on its arguments,
--   without dereferencing any pointer arguments or otherwise accessing any
--   mutable state (e.g. memory, control registers, etc) visible to caller
--   functions. It does not write through any pointer arguments (including
--   byval arguments) and never changes any state visible to callers. This
--   means that it cannot unwind exceptions by calling the C++ exception
--   throwing methods, but could use the unwind instruction.
[ReadNone] :: LlvmFuncAttr

-- | This attribute indicates that the function does not write through any
--   pointer arguments (including byval arguments) or otherwise modify any
--   state (e.g. memory, control registers, etc) visible to caller
--   functions. It may dereference pointer arguments and read state that
--   may be set in the caller. A readonly function always returns the same
--   value (or unwinds an exception identically) when called with the same
--   set of arguments and global state. It cannot unwind an exception by
--   calling the C++ exception throwing methods, but may use the unwind
--   instruction.
[ReadOnly] :: LlvmFuncAttr

-- | This attribute indicates that the function should emit a stack
--   smashing protector. It is in the form of a "canary"—a random value
--   placed on the stack before the local variables that's checked upon
--   return from the function to see if it has been overwritten. A
--   heuristic is used to determine if a function needs stack protectors or
--   not.
--   
--   If a function that has an ssp attribute is inlined into a function
--   that doesn't have an ssp attribute, then the resulting function will
--   have an ssp attribute.
[Ssp] :: LlvmFuncAttr

-- | This attribute indicates that the function should always emit a stack
--   smashing protector. This overrides the ssp function attribute.
--   
--   If a function that has an sspreq attribute is inlined into a function
--   that doesn't have an sspreq attribute or which has an ssp attribute,
--   then the resulting function will have an sspreq attribute.
[SspReq] :: LlvmFuncAttr

-- | This attribute indicates that the code generator should not use a red
--   zone, even if the target-specific ABI normally permits it.
[NoRedZone] :: LlvmFuncAttr

-- | This attributes disables implicit floating point instructions.
[NoImplicitFloat] :: LlvmFuncAttr

-- | This attribute disables prologue / epilogue emission for the function.
--   This can have very system-specific consequences.
[Naked] :: LlvmFuncAttr

-- | Different types to call a function.
data LlvmCallType

-- | Normal call, allocate a new stack frame.
[StdCall] :: LlvmCallType

-- | Tail call, perform the call in the current stack frame.
[TailCall] :: LlvmCallType

-- | Different calling conventions a function can use.
data LlvmCallConvention

-- | The C calling convention. This calling convention (the default if no
--   other calling convention is specified) matches the target C calling
--   conventions. This calling convention supports varargs function calls
--   and tolerates some mismatch in the declared prototype and implemented
--   declaration of the function (as does normal C).
[CC_Ccc] :: LlvmCallConvention

-- | This calling convention attempts to make calls as fast as possible
--   (e.g. by passing things in registers). This calling convention allows
--   the target to use whatever tricks it wants to produce fast code for
--   the target, without having to conform to an externally specified ABI
--   (Application Binary Interface). Implementations of this convention
--   should allow arbitrary tail call optimization to be supported. This
--   calling convention does not support varargs and requires the prototype
--   of al callees to exactly match the prototype of the function
--   definition.
[CC_Fastcc] :: LlvmCallConvention

-- | This calling convention attempts to make code in the caller as
--   efficient as possible under the assumption that the call is not
--   commonly executed. As such, these calls often preserve all registers
--   so that the call does not break any live ranges in the caller side.
--   This calling convention does not support varargs and requires the
--   prototype of all callees to exactly match the prototype of the
--   function definition.
[CC_Coldcc] :: LlvmCallConvention

-- | Any calling convention may be specified by number, allowing
--   target-specific calling conventions to be used. Target specific
--   calling conventions start at 64.
[CC_Ncc] :: Int -> LlvmCallConvention

-- | X86 Specific <a>StdCall</a> convention. LLVM includes a specific alias
--   for it rather than just using CC_Ncc.
[CC_X86_Stdcc] :: LlvmCallConvention

-- | Functions can have a fixed amount of parameters, or a variable amount.
data LlvmParameterListType
[FixedArgs] :: LlvmParameterListType
[VarArgs] :: LlvmParameterListType

-- | Linkage type of a symbol.
--   
--   The description of the constructors is copied from the Llvm Assembly
--   Language Reference Manual
--   <a>http://www.llvm.org/docs/LangRef.html#linkage</a>, because they
--   correspond to the Llvm linkage types.
data LlvmLinkageType

-- | Global values with internal linkage are only directly accessible by
--   objects in the current module. In particular, linking code into a
--   module with an internal global value may cause the internal to be
--   renamed as necessary to avoid collisions. Because the symbol is
--   internal to the module, all references can be updated. This
--   corresponds to the notion of the <tt>static</tt> keyword in C.
[Internal] :: LlvmLinkageType

-- | Globals with <tt>linkonce</tt> linkage are merged with other globals
--   of the same name when linkage occurs. This is typically used to
--   implement inline functions, templates, or other code which must be
--   generated in each translation unit that uses it. Unreferenced linkonce
--   globals are allowed to be discarded.
[LinkOnce] :: LlvmLinkageType

-- | <tt>weak</tt> linkage is exactly the same as linkonce linkage, except
--   that unreferenced weak globals may not be discarded. This is used for
--   globals that may be emitted in multiple translation units, but that
--   are not guaranteed to be emitted into every translation unit that uses
--   them. One example of this are common globals in C, such as <tt>int
--   X;</tt> at global scope.
[Weak] :: LlvmLinkageType

-- | <tt>appending</tt> linkage may only be applied to global variables of
--   pointer to array type. When two global variables with appending
--   linkage are linked together, the two global arrays are appended
--   together. This is the Llvm, typesafe, equivalent of having the system
--   linker append together <tt>sections</tt> with identical names when .o
--   files are linked.
[Appending] :: LlvmLinkageType

-- | The semantics of this linkage follow the ELF model: the symbol is weak
--   until linked, if not linked, the symbol becomes null instead of being
--   an undefined reference.
[ExternWeak] :: LlvmLinkageType

-- | The symbol participates in linkage and can be used to resolve external
--   symbol references.
[ExternallyVisible] :: LlvmLinkageType

-- | Alias for <a>ExternallyVisible</a> but with explicit textual form in
--   LLVM assembly.
[External] :: LlvmLinkageType

-- | Symbol is private to the module and should not appear in the symbol
--   table
[Private] :: LlvmLinkageType

-- | Llvm binary operators machine operations.
data LlvmMachOp

-- | add two integer, floating point or vector values.
[LM_MO_Add] :: LlvmMachOp

-- | subtract two ...
[LM_MO_Sub] :: LlvmMachOp

-- | multiply ..
[LM_MO_Mul] :: LlvmMachOp

-- | unsigned integer or vector division.
[LM_MO_UDiv] :: LlvmMachOp

-- | signed integer ..
[LM_MO_SDiv] :: LlvmMachOp

-- | unsigned integer or vector remainder (mod)
[LM_MO_URem] :: LlvmMachOp

-- | signed ...
[LM_MO_SRem] :: LlvmMachOp

-- | add two floating point or vector values.
[LM_MO_FAdd] :: LlvmMachOp

-- | subtract two ...
[LM_MO_FSub] :: LlvmMachOp

-- | multiply ...
[LM_MO_FMul] :: LlvmMachOp

-- | divide ...
[LM_MO_FDiv] :: LlvmMachOp

-- | remainder ...
[LM_MO_FRem] :: LlvmMachOp

-- | Left shift
[LM_MO_Shl] :: LlvmMachOp

-- | Logical shift right Shift right, filling with zero
[LM_MO_LShr] :: LlvmMachOp

-- | Arithmetic shift right The most significant bits of the result will be
--   equal to the sign bit of the left operand.
[LM_MO_AShr] :: LlvmMachOp

-- | AND bitwise logical operation.
[LM_MO_And] :: LlvmMachOp

-- | OR bitwise logical operation.
[LM_MO_Or] :: LlvmMachOp

-- | XOR bitwise logical operation.
[LM_MO_Xor] :: LlvmMachOp

-- | Llvm compare operations.
data LlvmCmpOp

-- | Equal (Signed and Unsigned)
[LM_CMP_Eq] :: LlvmCmpOp

-- | Not equal (Signed and Unsigned)
[LM_CMP_Ne] :: LlvmCmpOp

-- | Unsigned greater than
[LM_CMP_Ugt] :: LlvmCmpOp

-- | Unsigned greater than or equal
[LM_CMP_Uge] :: LlvmCmpOp

-- | Unsigned less than
[LM_CMP_Ult] :: LlvmCmpOp

-- | Unsigned less than or equal
[LM_CMP_Ule] :: LlvmCmpOp

-- | Signed greater than
[LM_CMP_Sgt] :: LlvmCmpOp

-- | Signed greater than or equal
[LM_CMP_Sge] :: LlvmCmpOp

-- | Signed less than
[LM_CMP_Slt] :: LlvmCmpOp

-- | Signed less than or equal
[LM_CMP_Sle] :: LlvmCmpOp

-- | Float equal
[LM_CMP_Feq] :: LlvmCmpOp

-- | Float not equal
[LM_CMP_Fne] :: LlvmCmpOp

-- | Float greater than
[LM_CMP_Fgt] :: LlvmCmpOp

-- | Float greater than or equal
[LM_CMP_Fge] :: LlvmCmpOp

-- | Float less than
[LM_CMP_Flt] :: LlvmCmpOp

-- | Float less than or equal
[LM_CMP_Fle] :: LlvmCmpOp

-- | Llvm cast operations.
data LlvmCastOp

-- | Integer truncate
[LM_Trunc] :: LlvmCastOp

-- | Integer extend (zero fill)
[LM_Zext] :: LlvmCastOp

-- | Integer extend (sign fill)
[LM_Sext] :: LlvmCastOp

-- | Float truncate
[LM_Fptrunc] :: LlvmCastOp

-- | Float extend
[LM_Fpext] :: LlvmCastOp

-- | Float to unsigned Integer
[LM_Fptoui] :: LlvmCastOp

-- | Float to signed Integer
[LM_Fptosi] :: LlvmCastOp

-- | Unsigned Integer to Float
[LM_Uitofp] :: LlvmCastOp

-- | Signed Int to Float
[LM_Sitofp] :: LlvmCastOp

-- | Pointer to Integer
[LM_Ptrtoint] :: LlvmCastOp

-- | Integer to Pointer
[LM_Inttoptr] :: LlvmCastOp

-- | Cast between types where no bit manipulation is needed
[LM_Bitcast] :: LlvmCastOp

-- | Convert a Haskell Double to an LLVM hex encoded floating point form.
--   In Llvm float literals can be printed in a big-endian hexadecimal
--   format, regardless of underlying architecture.
--   
--   See Note [LLVM Float Types].
ppDouble :: Double -> SDoc
narrowFp :: Double -> Float
widenFp :: Float -> Double
ppFloat :: Float -> SDoc

-- | Reverse or leave byte data alone to fix endianness on this target.
fixEndian :: [a] -> [a]
ppCommaJoin :: (Outputable a) => [a] -> SDoc
ppSpaceJoin :: (Outputable a) => [a] -> SDoc
instance Eq LlvmCastOp
instance Eq LlvmCmpOp
instance Eq LlvmMachOp
instance Eq LlvmVar
instance Eq LlvmLit
instance Eq LlvmType
instance Eq LlvmFunctionDecl
instance Eq LlvmLinkageType
instance Show LlvmParameterListType
instance Eq LlvmParameterListType
instance Eq LlvmCallConvention
instance Show LlvmCallType
instance Eq LlvmCallType
instance Eq LlvmFuncAttr
instance Eq LlvmParamAttr
instance Eq LMConst
instance Outputable LlvmType
instance Outputable LlvmVar
instance Outputable LlvmLit
instance Outputable LlvmStatic
instance Outputable LlvmFunctionDecl
instance Outputable LlvmParamAttr
instance Outputable LlvmFuncAttr
instance Outputable LlvmCallConvention
instance Outputable LlvmLinkageType
instance Outputable LlvmMachOp
instance Outputable LlvmCmpOp
instance Outputable LlvmCastOp

module Llvm.MetaData

-- | LLVM metadata expressions
data MetaExpr
[MetaStr] :: LMString -> MetaExpr
[MetaNode] :: Int -> MetaExpr
[MetaVar] :: LlvmVar -> MetaExpr
[MetaStruct] :: [MetaExpr] -> MetaExpr

-- | Associates some metadata with a specific label for attaching to an
--   instruction.
data MetaAnnot
[MetaAnnot] :: LMString -> MetaExpr -> MetaAnnot

-- | Metadata declarations. Metadata can only be declared in global scope.
data MetaDecl

-- | Named metadata. Only used for communicating module information to
--   LLVM. ('!name = !{ [!<a>n</a>] }' form).
[MetaNamed] :: LMString -> [Int] -> MetaDecl

-- | Metadata node declaration. ('!0 = metadata !{ <a>expression</a> }'
--   form).
[MetaUnamed] :: Int -> MetaExpr -> MetaDecl
instance Eq MetaAnnot
instance Eq MetaExpr
instance Outputable MetaExpr


-- | The LLVM abstract syntax.
module Llvm.AbsSyn

-- | Block labels
type LlvmBlockId = Unique

-- | A block of LLVM code.
data LlvmBlock
[LlvmBlock] :: LlvmBlockId -> [LlvmStatement] -> LlvmBlock

-- | The code label for this block
[blockLabel] :: LlvmBlock -> LlvmBlockId

-- | A list of LlvmStatement's representing the code for this block. This
--   list must end with a control flow statement.
[blockStmts] :: LlvmBlock -> [LlvmStatement]
type LlvmBlocks = [LlvmBlock]

-- | An LLVM Module. This is a top level container in LLVM.
data LlvmModule
[LlvmModule] :: [LMString] -> [LlvmAlias] -> [MetaDecl] -> [LMGlobal] -> LlvmFunctionDecls -> LlvmFunctions -> LlvmModule

-- | Comments to include at the start of the module.
[modComments] :: LlvmModule -> [LMString]

-- | LLVM Alias type definitions.
[modAliases] :: LlvmModule -> [LlvmAlias]

-- | LLVM meta data.
[modMeta] :: LlvmModule -> [MetaDecl]

-- | Global variables to include in the module.
[modGlobals] :: LlvmModule -> [LMGlobal]

-- | LLVM Functions used in this module but defined in other modules.
[modFwdDecls] :: LlvmModule -> LlvmFunctionDecls

-- | LLVM Functions defined in this module.
[modFuncs] :: LlvmModule -> LlvmFunctions

-- | An LLVM Function
data LlvmFunction
[LlvmFunction] :: LlvmFunctionDecl -> [LMString] -> [LlvmFuncAttr] -> LMSection -> LlvmBlocks -> LlvmFunction

-- | The signature of this declared function.
[funcDecl] :: LlvmFunction -> LlvmFunctionDecl

-- | The functions arguments
[funcArgs] :: LlvmFunction -> [LMString]

-- | The function attributes.
[funcAttrs] :: LlvmFunction -> [LlvmFuncAttr]

-- | The section to put the function into,
[funcSect] :: LlvmFunction -> LMSection

-- | The body of the functions.
[funcBody] :: LlvmFunction -> LlvmBlocks
type LlvmFunctions = [LlvmFunction]
type SingleThreaded = Bool

-- | LLVM ordering types for synchronization purposes. (Introduced in LLVM
--   3.0). Please see the LLVM documentation for a better description.
data LlvmSyncOrdering

-- | Some partial order of operations exists.
[SyncUnord] :: LlvmSyncOrdering

-- | A single total order for operations at a single address exists.
[SyncMonotonic] :: LlvmSyncOrdering

-- | Acquire synchronization operation.
[SyncAcquire] :: LlvmSyncOrdering

-- | Release synchronization operation.
[SyncRelease] :: LlvmSyncOrdering

-- | Acquire + Release synchronization operation.
[SyncAcqRel] :: LlvmSyncOrdering

-- | Full sequential Consistency operation.
[SyncSeqCst] :: LlvmSyncOrdering

-- | Llvm Statements
data LlvmStatement

-- | Assign an expression to an variable: * dest: Variable to assign to *
--   source: Source expression
[Assignment] :: LlvmVar -> LlvmExpression -> LlvmStatement

-- | Memory fence operation
[Fence] :: Bool -> LlvmSyncOrdering -> LlvmStatement

-- | Always branch to the target label
[Branch] :: LlvmVar -> LlvmStatement

-- | Branch to label targetTrue if cond is true otherwise to label
--   targetFalse * cond: condition that will be tested, must be of type i1
--   * targetTrue: label to branch to if cond is true * targetFalse: label
--   to branch to if cond is false
[BranchIf] :: LlvmVar -> LlvmVar -> LlvmVar -> LlvmStatement

-- | Comment Plain comment.
[Comment] :: [LMString] -> LlvmStatement

-- | Set a label on this position. * name: Identifier of this label, unique
--   for this module
[MkLabel] :: LlvmBlockId -> LlvmStatement

-- | Store variable value in pointer ptr. If value is of type t then ptr
--   must be of type t*. * value: Variable/Constant to store. * ptr:
--   Location to store the value in
[Store] :: LlvmVar -> LlvmVar -> LlvmStatement

-- | Mutliway branch * scrutinee: Variable or constant which must be of
--   integer type that is determines which arm is chosen. * def: The
--   default label if there is no match in target. * target: A list of
--   (value,label) where the value is an integer constant and label the
--   corresponding label to jump to if the scrutinee matches the value.
[Switch] :: LlvmVar -> LlvmVar -> [(LlvmVar, LlvmVar)] -> LlvmStatement

-- | Return a result. * result: The variable or constant to return
[Return] :: (Maybe LlvmVar) -> LlvmStatement

-- | An instruction for the optimizer that the code following is not
--   reachable
[Unreachable] :: LlvmStatement

-- | Raise an expression to a statement (if don't want result or want to
--   use Llvm unnamed values.
[Expr] :: LlvmExpression -> LlvmStatement

-- | A nop LLVM statement. Useful as its often more efficient to use this
--   then to wrap LLvmStatement in a Just or [].
[Nop] :: LlvmStatement

-- | A LLVM statement with metadata attached to it.
[MetaStmt] :: [MetaAnnot] -> LlvmStatement -> LlvmStatement

-- | Llvm Expressions
data LlvmExpression

-- | Allocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to
--   reserve room for * amount: The nr of tp's which must be allocated
[Alloca] :: LlvmType -> Int -> LlvmExpression

-- | Perform the machine operator op on the operands left and right * op:
--   operator * left: left operand * right: right operand
[LlvmOp] :: LlvmMachOp -> LlvmVar -> LlvmVar -> LlvmExpression

-- | Perform a compare operation on the operands left and right * op:
--   operator * left: left operand * right: right operand
[Compare] :: LlvmCmpOp -> LlvmVar -> LlvmVar -> LlvmExpression

-- | Extract a scalar element from a vector * val: The vector * idx: The
--   index of the scalar within the vector
[Extract] :: LlvmVar -> LlvmVar -> LlvmExpression

-- | Insert a scalar element into a vector * val: The source vector * elt:
--   The scalar to insert * index: The index at which to insert the scalar
[Insert] :: LlvmVar -> LlvmVar -> LlvmVar -> LlvmExpression

-- | Allocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to
--   reserve room for * amount: The nr of tp's which must be allocated
[Malloc] :: LlvmType -> Int -> LlvmExpression

-- | Load the value at location ptr
[Load] :: LlvmVar -> LlvmExpression

-- | Atomic load of the value at location ptr
[ALoad] :: LlvmSyncOrdering -> SingleThreaded -> LlvmVar -> LlvmExpression

-- | Navigate in an structure, selecting elements * inbound: Is the pointer
--   inbounds? (computed pointer doesn't overflow) * ptr: Location of the
--   structure * indexes: A list of indexes to select the correct value.
[GetElemPtr] :: Bool -> LlvmVar -> [LlvmVar] -> LlvmExpression

-- | Cast the variable from to the to type. This is an abstraction of three
--   cast operators in Llvm, inttoptr, prttoint and bitcast. * cast: Cast
--   type * from: Variable to cast * to: type to cast to
[Cast] :: LlvmCastOp -> LlvmVar -> LlvmType -> LlvmExpression

-- | Call a function. The result is the value of the expression. *
--   tailJumps: CallType to signal if the function should be tail called *
--   fnptrval: An LLVM value containing a pointer to a function to be
--   invoked. Can be indirect. Should be LMFunction type. * args: Concrete
--   arguments for the parameters * attrs: A list of function attributes
--   for the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid
--   here.
[Call] :: LlvmCallType -> LlvmVar -> [LlvmVar] -> [LlvmFuncAttr] -> LlvmExpression

-- | Call a function as above but potentially taking metadata as arguments.
--   * tailJumps: CallType to signal if the function should be tail called
--   * fnptrval: An LLVM value containing a pointer to a function to be
--   invoked. Can be indirect. Should be LMFunction type. * args: Arguments
--   that may include metadata. * attrs: A list of function attributes for
--   the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid
--   here.
[CallM] :: LlvmCallType -> LlvmVar -> [MetaExpr] -> [LlvmFuncAttr] -> LlvmExpression

-- | Merge variables from different basic blocks which are predecessors of
--   this basic block in a new variable of type tp. * tp: type of the
--   merged variable, must match the types of the predecessor variables. *
--   precessors: A list of variables and the basic block that they
--   originate from.
[Phi] :: LlvmType -> [(LlvmVar, LlvmVar)] -> LlvmExpression

-- | Inline assembly expression. Syntax is very similar to the style used
--   by GCC. * assembly: Actual inline assembly code. * constraints:
--   Operand constraints. * return ty: Return type of function. * vars: Any
--   variables involved in the assembly code. * sideeffect: Does the
--   expression have side effects not visible from the constraints list. *
--   alignstack: Should the stack be conservatively aligned before this
--   expression is executed.
[Asm] :: LMString -> LMString -> LlvmType -> [LlvmVar] -> Bool -> Bool -> LlvmExpression

-- | A LLVM expression with metadata attached to it.
[MExpr] :: [MetaAnnot] -> LlvmExpression -> LlvmExpression
instance Eq LlvmStatement
instance Eq LlvmExpression
instance Eq LlvmSyncOrdering
instance Show LlvmSyncOrdering


-- | Pretty print LLVM IR Code.
module Llvm.PpLlvm

-- | Print out a whole LLVM module.
ppLlvmModule :: LlvmModule -> SDoc

-- | Print out a multi-line comment, can be inside a function or on its own
ppLlvmComments :: [LMString] -> SDoc

-- | Print out a comment, can be inside a function or on its own
ppLlvmComment :: LMString -> SDoc

-- | Print out a list of global mutable variable definitions
ppLlvmGlobals :: [LMGlobal] -> SDoc

-- | Print out a global mutable variable definition
ppLlvmGlobal :: LMGlobal -> SDoc

-- | Print out a list of LLVM type aliases.
ppLlvmAliases :: [LlvmAlias] -> SDoc

-- | Print out an LLVM type alias.
ppLlvmAlias :: LlvmAlias -> SDoc

-- | Print out a list of LLVM metadata.
ppLlvmMetas :: [MetaDecl] -> SDoc

-- | Print out an LLVM metadata definition.
ppLlvmMeta :: MetaDecl -> SDoc

-- | Print out a list of function declaration.
ppLlvmFunctionDecls :: LlvmFunctionDecls -> SDoc

-- | Print out a function declaration. Declarations define the function
--   type but don't define the actual body of the function.
ppLlvmFunctionDecl :: LlvmFunctionDecl -> SDoc

-- | Print out a list of function definitions.
ppLlvmFunctions :: LlvmFunctions -> SDoc

-- | Print out a function definition.
ppLlvmFunction :: LlvmFunction -> SDoc


-- | This module supplies bindings to generate Llvm IR from Haskell
--   (<a>http://www.llvm.org/docs/LangRef.html</a>).
--   
--   Note: this module is developed in a demand driven way. It is no
--   complete LLVM binding library in Haskell, but enough to generate code
--   for GHC.
--   
--   This code is derived from code taken from the Essential Haskell
--   Compiler (EHC) project (<a>http://www.cs.uu.nl/wiki/Ehc/WebHome</a>).
module Llvm

-- | An LLVM Module. This is a top level container in LLVM.
data LlvmModule
[LlvmModule] :: [LMString] -> [LlvmAlias] -> [MetaDecl] -> [LMGlobal] -> LlvmFunctionDecls -> LlvmFunctions -> LlvmModule

-- | Comments to include at the start of the module.
[modComments] :: LlvmModule -> [LMString]

-- | LLVM Alias type definitions.
[modAliases] :: LlvmModule -> [LlvmAlias]

-- | LLVM meta data.
[modMeta] :: LlvmModule -> [MetaDecl]

-- | Global variables to include in the module.
[modGlobals] :: LlvmModule -> [LMGlobal]

-- | LLVM Functions used in this module but defined in other modules.
[modFwdDecls] :: LlvmModule -> LlvmFunctionDecls

-- | LLVM Functions defined in this module.
[modFuncs] :: LlvmModule -> LlvmFunctions

-- | An LLVM Function
data LlvmFunction
[LlvmFunction] :: LlvmFunctionDecl -> [LMString] -> [LlvmFuncAttr] -> LMSection -> LlvmBlocks -> LlvmFunction

-- | The signature of this declared function.
[funcDecl] :: LlvmFunction -> LlvmFunctionDecl

-- | The functions arguments
[funcArgs] :: LlvmFunction -> [LMString]

-- | The function attributes.
[funcAttrs] :: LlvmFunction -> [LlvmFuncAttr]

-- | The section to put the function into,
[funcSect] :: LlvmFunction -> LMSection

-- | The body of the functions.
[funcBody] :: LlvmFunction -> LlvmBlocks

-- | An LLVM Function
data LlvmFunctionDecl
[LlvmFunctionDecl] :: LMString -> LlvmLinkageType -> LlvmCallConvention -> LlvmType -> LlvmParameterListType -> [LlvmParameter] -> LMAlign -> LlvmFunctionDecl

-- | Unique identifier of the function
[decName] :: LlvmFunctionDecl -> LMString

-- | LinkageType of the function
[funcLinkage] :: LlvmFunctionDecl -> LlvmLinkageType

-- | The calling convention of the function
[funcCc] :: LlvmFunctionDecl -> LlvmCallConvention

-- | Type of the returned value
[decReturnType] :: LlvmFunctionDecl -> LlvmType

-- | Indicates if this function uses varargs
[decVarargs] :: LlvmFunctionDecl -> LlvmParameterListType

-- | Parameter types and attributes
[decParams] :: LlvmFunctionDecl -> [LlvmParameter]

-- | Function align value, must be power of 2
[funcAlign] :: LlvmFunctionDecl -> LMAlign
type LlvmFunctions = [LlvmFunction]
type LlvmFunctionDecls = [LlvmFunctionDecl]

-- | Llvm Statements
data LlvmStatement

-- | Assign an expression to an variable: * dest: Variable to assign to *
--   source: Source expression
[Assignment] :: LlvmVar -> LlvmExpression -> LlvmStatement

-- | Memory fence operation
[Fence] :: Bool -> LlvmSyncOrdering -> LlvmStatement

-- | Always branch to the target label
[Branch] :: LlvmVar -> LlvmStatement

-- | Branch to label targetTrue if cond is true otherwise to label
--   targetFalse * cond: condition that will be tested, must be of type i1
--   * targetTrue: label to branch to if cond is true * targetFalse: label
--   to branch to if cond is false
[BranchIf] :: LlvmVar -> LlvmVar -> LlvmVar -> LlvmStatement

-- | Comment Plain comment.
[Comment] :: [LMString] -> LlvmStatement

-- | Set a label on this position. * name: Identifier of this label, unique
--   for this module
[MkLabel] :: LlvmBlockId -> LlvmStatement

-- | Store variable value in pointer ptr. If value is of type t then ptr
--   must be of type t*. * value: Variable/Constant to store. * ptr:
--   Location to store the value in
[Store] :: LlvmVar -> LlvmVar -> LlvmStatement

-- | Mutliway branch * scrutinee: Variable or constant which must be of
--   integer type that is determines which arm is chosen. * def: The
--   default label if there is no match in target. * target: A list of
--   (value,label) where the value is an integer constant and label the
--   corresponding label to jump to if the scrutinee matches the value.
[Switch] :: LlvmVar -> LlvmVar -> [(LlvmVar, LlvmVar)] -> LlvmStatement

-- | Return a result. * result: The variable or constant to return
[Return] :: (Maybe LlvmVar) -> LlvmStatement

-- | An instruction for the optimizer that the code following is not
--   reachable
[Unreachable] :: LlvmStatement

-- | Raise an expression to a statement (if don't want result or want to
--   use Llvm unnamed values.
[Expr] :: LlvmExpression -> LlvmStatement

-- | A nop LLVM statement. Useful as its often more efficient to use this
--   then to wrap LLvmStatement in a Just or [].
[Nop] :: LlvmStatement

-- | A LLVM statement with metadata attached to it.
[MetaStmt] :: [MetaAnnot] -> LlvmStatement -> LlvmStatement

-- | Llvm Expressions
data LlvmExpression

-- | Allocate amount * sizeof(tp) bytes on the stack * tp: LlvmType to
--   reserve room for * amount: The nr of tp's which must be allocated
[Alloca] :: LlvmType -> Int -> LlvmExpression

-- | Perform the machine operator op on the operands left and right * op:
--   operator * left: left operand * right: right operand
[LlvmOp] :: LlvmMachOp -> LlvmVar -> LlvmVar -> LlvmExpression

-- | Perform a compare operation on the operands left and right * op:
--   operator * left: left operand * right: right operand
[Compare] :: LlvmCmpOp -> LlvmVar -> LlvmVar -> LlvmExpression

-- | Extract a scalar element from a vector * val: The vector * idx: The
--   index of the scalar within the vector
[Extract] :: LlvmVar -> LlvmVar -> LlvmExpression

-- | Insert a scalar element into a vector * val: The source vector * elt:
--   The scalar to insert * index: The index at which to insert the scalar
[Insert] :: LlvmVar -> LlvmVar -> LlvmVar -> LlvmExpression

-- | Allocate amount * sizeof(tp) bytes on the heap * tp: LlvmType to
--   reserve room for * amount: The nr of tp's which must be allocated
[Malloc] :: LlvmType -> Int -> LlvmExpression

-- | Load the value at location ptr
[Load] :: LlvmVar -> LlvmExpression

-- | Atomic load of the value at location ptr
[ALoad] :: LlvmSyncOrdering -> SingleThreaded -> LlvmVar -> LlvmExpression

-- | Navigate in an structure, selecting elements * inbound: Is the pointer
--   inbounds? (computed pointer doesn't overflow) * ptr: Location of the
--   structure * indexes: A list of indexes to select the correct value.
[GetElemPtr] :: Bool -> LlvmVar -> [LlvmVar] -> LlvmExpression

-- | Cast the variable from to the to type. This is an abstraction of three
--   cast operators in Llvm, inttoptr, prttoint and bitcast. * cast: Cast
--   type * from: Variable to cast * to: type to cast to
[Cast] :: LlvmCastOp -> LlvmVar -> LlvmType -> LlvmExpression

-- | Call a function. The result is the value of the expression. *
--   tailJumps: CallType to signal if the function should be tail called *
--   fnptrval: An LLVM value containing a pointer to a function to be
--   invoked. Can be indirect. Should be LMFunction type. * args: Concrete
--   arguments for the parameters * attrs: A list of function attributes
--   for the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid
--   here.
[Call] :: LlvmCallType -> LlvmVar -> [LlvmVar] -> [LlvmFuncAttr] -> LlvmExpression

-- | Call a function as above but potentially taking metadata as arguments.
--   * tailJumps: CallType to signal if the function should be tail called
--   * fnptrval: An LLVM value containing a pointer to a function to be
--   invoked. Can be indirect. Should be LMFunction type. * args: Arguments
--   that may include metadata. * attrs: A list of function attributes for
--   the call. Only NoReturn, NoUnwind, ReadOnly and ReadNone are valid
--   here.
[CallM] :: LlvmCallType -> LlvmVar -> [MetaExpr] -> [LlvmFuncAttr] -> LlvmExpression

-- | Merge variables from different basic blocks which are predecessors of
--   this basic block in a new variable of type tp. * tp: type of the
--   merged variable, must match the types of the predecessor variables. *
--   precessors: A list of variables and the basic block that they
--   originate from.
[Phi] :: LlvmType -> [(LlvmVar, LlvmVar)] -> LlvmExpression

-- | Inline assembly expression. Syntax is very similar to the style used
--   by GCC. * assembly: Actual inline assembly code. * constraints:
--   Operand constraints. * return ty: Return type of function. * vars: Any
--   variables involved in the assembly code. * sideeffect: Does the
--   expression have side effects not visible from the constraints list. *
--   alignstack: Should the stack be conservatively aligned before this
--   expression is executed.
[Asm] :: LMString -> LMString -> LlvmType -> [LlvmVar] -> Bool -> Bool -> LlvmExpression

-- | A LLVM expression with metadata attached to it.
[MExpr] :: [MetaAnnot] -> LlvmExpression -> LlvmExpression
type LlvmBlocks = [LlvmBlock]

-- | A block of LLVM code.
data LlvmBlock
[LlvmBlock] :: LlvmBlockId -> [LlvmStatement] -> LlvmBlock

-- | The code label for this block
[blockLabel] :: LlvmBlock -> LlvmBlockId

-- | A list of LlvmStatement's representing the code for this block. This
--   list must end with a control flow statement.
[blockStmts] :: LlvmBlock -> [LlvmStatement]

-- | Block labels
type LlvmBlockId = Unique

-- | LLVM Parameter Attributes.
--   
--   Parameter attributes are used to communicate additional information
--   about the result or parameters of a function
data LlvmParamAttr

-- | This indicates to the code generator that the parameter or return
--   value should be zero-extended to a 32-bit value by the caller (for a
--   parameter) or the callee (for a return value).
[ZeroExt] :: LlvmParamAttr

-- | This indicates to the code generator that the parameter or return
--   value should be sign-extended to a 32-bit value by the caller (for a
--   parameter) or the callee (for a return value).
[SignExt] :: LlvmParamAttr

-- | This indicates that this parameter or return value should be treated
--   in a special target-dependent fashion during while emitting code for a
--   function call or return (usually, by putting it in a register as
--   opposed to memory).
[InReg] :: LlvmParamAttr

-- | This indicates that the pointer parameter should really be passed by
--   value to the function.
[ByVal] :: LlvmParamAttr

-- | This indicates that the pointer parameter specifies the address of a
--   structure that is the return value of the function in the source
--   program.
[SRet] :: LlvmParamAttr

-- | This indicates that the pointer does not alias any global or any other
--   parameter.
[NoAlias] :: LlvmParamAttr

-- | This indicates that the callee does not make any copies of the pointer
--   that outlive the callee itself
[NoCapture] :: LlvmParamAttr

-- | This indicates that the pointer parameter can be excised using the
--   trampoline intrinsics.
[Nest] :: LlvmParamAttr
type LlvmParameter = (LlvmType, [LlvmParamAttr])

-- | LLVM ordering types for synchronization purposes. (Introduced in LLVM
--   3.0). Please see the LLVM documentation for a better description.
data LlvmSyncOrdering

-- | Some partial order of operations exists.
[SyncUnord] :: LlvmSyncOrdering

-- | A single total order for operations at a single address exists.
[SyncMonotonic] :: LlvmSyncOrdering

-- | Acquire synchronization operation.
[SyncAcquire] :: LlvmSyncOrdering

-- | Release synchronization operation.
[SyncRelease] :: LlvmSyncOrdering

-- | Acquire + Release synchronization operation.
[SyncAcqRel] :: LlvmSyncOrdering

-- | Full sequential Consistency operation.
[SyncSeqCst] :: LlvmSyncOrdering

-- | Different calling conventions a function can use.
data LlvmCallConvention

-- | The C calling convention. This calling convention (the default if no
--   other calling convention is specified) matches the target C calling
--   conventions. This calling convention supports varargs function calls
--   and tolerates some mismatch in the declared prototype and implemented
--   declaration of the function (as does normal C).
[CC_Ccc] :: LlvmCallConvention

-- | This calling convention attempts to make calls as fast as possible
--   (e.g. by passing things in registers). This calling convention allows
--   the target to use whatever tricks it wants to produce fast code for
--   the target, without having to conform to an externally specified ABI
--   (Application Binary Interface). Implementations of this convention
--   should allow arbitrary tail call optimization to be supported. This
--   calling convention does not support varargs and requires the prototype
--   of al callees to exactly match the prototype of the function
--   definition.
[CC_Fastcc] :: LlvmCallConvention

-- | This calling convention attempts to make code in the caller as
--   efficient as possible under the assumption that the call is not
--   commonly executed. As such, these calls often preserve all registers
--   so that the call does not break any live ranges in the caller side.
--   This calling convention does not support varargs and requires the
--   prototype of all callees to exactly match the prototype of the
--   function definition.
[CC_Coldcc] :: LlvmCallConvention

-- | Any calling convention may be specified by number, allowing
--   target-specific calling conventions to be used. Target specific
--   calling conventions start at 64.
[CC_Ncc] :: Int -> LlvmCallConvention

-- | X86 Specific <a>StdCall</a> convention. LLVM includes a specific alias
--   for it rather than just using CC_Ncc.
[CC_X86_Stdcc] :: LlvmCallConvention

-- | Different types to call a function.
data LlvmCallType

-- | Normal call, allocate a new stack frame.
[StdCall] :: LlvmCallType

-- | Tail call, perform the call in the current stack frame.
[TailCall] :: LlvmCallType

-- | Functions can have a fixed amount of parameters, or a variable amount.
data LlvmParameterListType
[FixedArgs] :: LlvmParameterListType
[VarArgs] :: LlvmParameterListType

-- | Linkage type of a symbol.
--   
--   The description of the constructors is copied from the Llvm Assembly
--   Language Reference Manual
--   <a>http://www.llvm.org/docs/LangRef.html#linkage</a>, because they
--   correspond to the Llvm linkage types.
data LlvmLinkageType

-- | Global values with internal linkage are only directly accessible by
--   objects in the current module. In particular, linking code into a
--   module with an internal global value may cause the internal to be
--   renamed as necessary to avoid collisions. Because the symbol is
--   internal to the module, all references can be updated. This
--   corresponds to the notion of the <tt>static</tt> keyword in C.
[Internal] :: LlvmLinkageType

-- | Globals with <tt>linkonce</tt> linkage are merged with other globals
--   of the same name when linkage occurs. This is typically used to
--   implement inline functions, templates, or other code which must be
--   generated in each translation unit that uses it. Unreferenced linkonce
--   globals are allowed to be discarded.
[LinkOnce] :: LlvmLinkageType

-- | <tt>weak</tt> linkage is exactly the same as linkonce linkage, except
--   that unreferenced weak globals may not be discarded. This is used for
--   globals that may be emitted in multiple translation units, but that
--   are not guaranteed to be emitted into every translation unit that uses
--   them. One example of this are common globals in C, such as <tt>int
--   X;</tt> at global scope.
[Weak] :: LlvmLinkageType

-- | <tt>appending</tt> linkage may only be applied to global variables of
--   pointer to array type. When two global variables with appending
--   linkage are linked together, the two global arrays are appended
--   together. This is the Llvm, typesafe, equivalent of having the system
--   linker append together <tt>sections</tt> with identical names when .o
--   files are linked.
[Appending] :: LlvmLinkageType

-- | The semantics of this linkage follow the ELF model: the symbol is weak
--   until linked, if not linked, the symbol becomes null instead of being
--   an undefined reference.
[ExternWeak] :: LlvmLinkageType

-- | The symbol participates in linkage and can be used to resolve external
--   symbol references.
[ExternallyVisible] :: LlvmLinkageType

-- | Alias for <a>ExternallyVisible</a> but with explicit textual form in
--   LLVM assembly.
[External] :: LlvmLinkageType

-- | Symbol is private to the module and should not appear in the symbol
--   table
[Private] :: LlvmLinkageType

-- | Llvm Function Attributes.
--   
--   Function attributes are set to communicate additional information
--   about a function. Function attributes are considered to be part of the
--   function, not of the function type, so functions with different
--   parameter attributes can have the same function type. Functions can
--   have multiple attributes.
--   
--   Descriptions taken from
--   <a>http://llvm.org/docs/LangRef.html#fnattrs</a>
data LlvmFuncAttr

-- | This attribute indicates that the inliner should attempt to inline
--   this function into callers whenever possible, ignoring any active
--   inlining size threshold for this caller.
[AlwaysInline] :: LlvmFuncAttr

-- | This attribute indicates that the source code contained a hint that
--   inlining this function is desirable (such as the "inline" keyword in
--   C/C++). It is just a hint; it imposes no requirements on the inliner.
[InlineHint] :: LlvmFuncAttr

-- | This attribute indicates that the inliner should never inline this
--   function in any situation. This attribute may not be used together
--   with the alwaysinline attribute.
[NoInline] :: LlvmFuncAttr

-- | This attribute suggests that optimization passes and code generator
--   passes make choices that keep the code size of this function low, and
--   otherwise do optimizations specifically to reduce code size.
[OptSize] :: LlvmFuncAttr

-- | This function attribute indicates that the function never returns
--   normally. This produces undefined behavior at runtime if the function
--   ever does dynamically return.
[NoReturn] :: LlvmFuncAttr

-- | This function attribute indicates that the function never returns with
--   an unwind or exceptional control flow. If the function does unwind,
--   its runtime behavior is undefined.
[NoUnwind] :: LlvmFuncAttr

-- | This attribute indicates that the function computes its result (or
--   decides to unwind an exception) based strictly on its arguments,
--   without dereferencing any pointer arguments or otherwise accessing any
--   mutable state (e.g. memory, control registers, etc) visible to caller
--   functions. It does not write through any pointer arguments (including
--   byval arguments) and never changes any state visible to callers. This
--   means that it cannot unwind exceptions by calling the C++ exception
--   throwing methods, but could use the unwind instruction.
[ReadNone] :: LlvmFuncAttr

-- | This attribute indicates that the function does not write through any
--   pointer arguments (including byval arguments) or otherwise modify any
--   state (e.g. memory, control registers, etc) visible to caller
--   functions. It may dereference pointer arguments and read state that
--   may be set in the caller. A readonly function always returns the same
--   value (or unwinds an exception identically) when called with the same
--   set of arguments and global state. It cannot unwind an exception by
--   calling the C++ exception throwing methods, but may use the unwind
--   instruction.
[ReadOnly] :: LlvmFuncAttr

-- | This attribute indicates that the function should emit a stack
--   smashing protector. It is in the form of a "canary"—a random value
--   placed on the stack before the local variables that's checked upon
--   return from the function to see if it has been overwritten. A
--   heuristic is used to determine if a function needs stack protectors or
--   not.
--   
--   If a function that has an ssp attribute is inlined into a function
--   that doesn't have an ssp attribute, then the resulting function will
--   have an ssp attribute.
[Ssp] :: LlvmFuncAttr

-- | This attribute indicates that the function should always emit a stack
--   smashing protector. This overrides the ssp function attribute.
--   
--   If a function that has an sspreq attribute is inlined into a function
--   that doesn't have an sspreq attribute or which has an ssp attribute,
--   then the resulting function will have an sspreq attribute.
[SspReq] :: LlvmFuncAttr

-- | This attribute indicates that the code generator should not use a red
--   zone, even if the target-specific ABI normally permits it.
[NoRedZone] :: LlvmFuncAttr

-- | This attributes disables implicit floating point instructions.
[NoImplicitFloat] :: LlvmFuncAttr

-- | This attribute disables prologue / epilogue emission for the function.
--   This can have very system-specific consequences.
[Naked] :: LlvmFuncAttr

-- | Llvm compare operations.
data LlvmCmpOp

-- | Equal (Signed and Unsigned)
[LM_CMP_Eq] :: LlvmCmpOp

-- | Not equal (Signed and Unsigned)
[LM_CMP_Ne] :: LlvmCmpOp

-- | Unsigned greater than
[LM_CMP_Ugt] :: LlvmCmpOp

-- | Unsigned greater than or equal
[LM_CMP_Uge] :: LlvmCmpOp

-- | Unsigned less than
[LM_CMP_Ult] :: LlvmCmpOp

-- | Unsigned less than or equal
[LM_CMP_Ule] :: LlvmCmpOp

-- | Signed greater than
[LM_CMP_Sgt] :: LlvmCmpOp

-- | Signed greater than or equal
[LM_CMP_Sge] :: LlvmCmpOp

-- | Signed less than
[LM_CMP_Slt] :: LlvmCmpOp

-- | Signed less than or equal
[LM_CMP_Sle] :: LlvmCmpOp

-- | Float equal
[LM_CMP_Feq] :: LlvmCmpOp

-- | Float not equal
[LM_CMP_Fne] :: LlvmCmpOp

-- | Float greater than
[LM_CMP_Fgt] :: LlvmCmpOp

-- | Float greater than or equal
[LM_CMP_Fge] :: LlvmCmpOp

-- | Float less than
[LM_CMP_Flt] :: LlvmCmpOp

-- | Float less than or equal
[LM_CMP_Fle] :: LlvmCmpOp

-- | Llvm binary operators machine operations.
data LlvmMachOp

-- | add two integer, floating point or vector values.
[LM_MO_Add] :: LlvmMachOp

-- | subtract two ...
[LM_MO_Sub] :: LlvmMachOp

-- | multiply ..
[LM_MO_Mul] :: LlvmMachOp

-- | unsigned integer or vector division.
[LM_MO_UDiv] :: LlvmMachOp

-- | signed integer ..
[LM_MO_SDiv] :: LlvmMachOp

-- | unsigned integer or vector remainder (mod)
[LM_MO_URem] :: LlvmMachOp

-- | signed ...
[LM_MO_SRem] :: LlvmMachOp

-- | add two floating point or vector values.
[LM_MO_FAdd] :: LlvmMachOp

-- | subtract two ...
[LM_MO_FSub] :: LlvmMachOp

-- | multiply ...
[LM_MO_FMul] :: LlvmMachOp

-- | divide ...
[LM_MO_FDiv] :: LlvmMachOp

-- | remainder ...
[LM_MO_FRem] :: LlvmMachOp

-- | Left shift
[LM_MO_Shl] :: LlvmMachOp

-- | Logical shift right Shift right, filling with zero
[LM_MO_LShr] :: LlvmMachOp

-- | Arithmetic shift right The most significant bits of the result will be
--   equal to the sign bit of the left operand.
[LM_MO_AShr] :: LlvmMachOp

-- | AND bitwise logical operation.
[LM_MO_And] :: LlvmMachOp

-- | OR bitwise logical operation.
[LM_MO_Or] :: LlvmMachOp

-- | XOR bitwise logical operation.
[LM_MO_Xor] :: LlvmMachOp

-- | Llvm cast operations.
data LlvmCastOp

-- | Integer truncate
[LM_Trunc] :: LlvmCastOp

-- | Integer extend (zero fill)
[LM_Zext] :: LlvmCastOp

-- | Integer extend (sign fill)
[LM_Sext] :: LlvmCastOp

-- | Float truncate
[LM_Fptrunc] :: LlvmCastOp

-- | Float extend
[LM_Fpext] :: LlvmCastOp

-- | Float to unsigned Integer
[LM_Fptoui] :: LlvmCastOp

-- | Float to signed Integer
[LM_Fptosi] :: LlvmCastOp

-- | Unsigned Integer to Float
[LM_Uitofp] :: LlvmCastOp

-- | Signed Int to Float
[LM_Sitofp] :: LlvmCastOp

-- | Pointer to Integer
[LM_Ptrtoint] :: LlvmCastOp

-- | Integer to Pointer
[LM_Inttoptr] :: LlvmCastOp

-- | Cast between types where no bit manipulation is needed
[LM_Bitcast] :: LlvmCastOp

-- | LLVM Variables
data LlvmVar

-- | Variables with a global scope.
[LMGlobalVar] :: LMString -> LlvmType -> LlvmLinkageType -> LMSection -> LMAlign -> LMConst -> LlvmVar

-- | Variables local to a function or parameters.
[LMLocalVar] :: Unique -> LlvmType -> LlvmVar

-- | Named local variables. Sometimes we need to be able to explicitly name
--   variables (e.g for function arguments).
[LMNLocalVar] :: LMString -> LlvmType -> LlvmVar

-- | A constant variable
[LMLitVar] :: LlvmLit -> LlvmVar

-- | Llvm Static Data.
--   
--   These represent the possible global level variables and constants.
data LlvmStatic

-- | A comment in a static section
[LMComment] :: LMString -> LlvmStatic

-- | A static variant of a literal value
[LMStaticLit] :: LlvmLit -> LlvmStatic

-- | For uninitialised data
[LMUninitType] :: LlvmType -> LlvmStatic

-- | Defines a static <a>LMString</a>
[LMStaticStr] :: LMString -> LlvmType -> LlvmStatic

-- | A static array
[LMStaticArray] :: [LlvmStatic] -> LlvmType -> LlvmStatic

-- | A static structure type
[LMStaticStruc] :: [LlvmStatic] -> LlvmType -> LlvmStatic

-- | A pointer to other data
[LMStaticPointer] :: LlvmVar -> LlvmStatic

-- | Pointer to Pointer conversion
[LMBitc] :: LlvmStatic -> LlvmType -> LlvmStatic

-- | Pointer to Integer conversion
[LMPtoI] :: LlvmStatic -> LlvmType -> LlvmStatic

-- | Constant addition operation
[LMAdd] :: LlvmStatic -> LlvmStatic -> LlvmStatic

-- | Constant subtraction operation
[LMSub] :: LlvmStatic -> LlvmStatic -> LlvmStatic

-- | Llvm Literal Data.
--   
--   These can be used inline in expressions.
data LlvmLit

-- | Refers to an integer constant (i64 42).
[LMIntLit] :: Integer -> LlvmType -> LlvmLit

-- | Floating point literal
[LMFloatLit] :: Double -> LlvmType -> LlvmLit

-- | Literal NULL, only applicable to pointer types
[LMNullLit] :: LlvmType -> LlvmLit

-- | Vector literal
[LMVectorLit] :: [LlvmLit] -> LlvmLit

-- | Undefined value, random bit pattern. Useful for optimisations.
[LMUndefLit] :: LlvmType -> LlvmLit

-- | Llvm Types
data LlvmType

-- | An integer with a given width in bits.
[LMInt] :: Int -> LlvmType

-- | 32 bit floating point
[LMFloat] :: LlvmType

-- | 64 bit floating point
[LMDouble] :: LlvmType

-- | 80 bit (x86 only) floating point
[LMFloat80] :: LlvmType

-- | 128 bit floating point
[LMFloat128] :: LlvmType

-- | A pointer to a <a>LlvmType</a>
[LMPointer] :: LlvmType -> LlvmType

-- | An array of <a>LlvmType</a>
[LMArray] :: Int -> LlvmType -> LlvmType

-- | A vector of <a>LlvmType</a>
[LMVector] :: Int -> LlvmType -> LlvmType

-- | A <a>LlvmVar</a> can represent a label (address)
[LMLabel] :: LlvmType

-- | Void type
[LMVoid] :: LlvmType

-- | Structure type
[LMStruct] :: [LlvmType] -> LlvmType

-- | A type alias
[LMAlias] :: LlvmAlias -> LlvmType

-- | LLVM Metadata
[LMMetadata] :: LlvmType

-- | Function type, used to create pointers to functions
[LMFunction] :: LlvmFunctionDecl -> LlvmType

-- | A type alias
type LlvmAlias = (LMString, LlvmType)

-- | A global mutable variable. Maybe defined or external
data LMGlobal
[LMGlobal] :: LlvmVar -> Maybe LlvmStatic -> LMGlobal

-- | Returns the variable of the <a>LMGlobal</a>
[getGlobalVar] :: LMGlobal -> LlvmVar

-- | Return the value of the <a>LMGlobal</a>
[getGlobalValue] :: LMGlobal -> Maybe LlvmStatic

-- | A String in LLVM
type LMString = FastString

-- | An LLVM section definition. If Nothing then let LLVM decide the
--   section
type LMSection = Maybe LMString
type LMAlign = Maybe Int
data LMConst

-- | Mutable global variable
[Global] :: LMConst

-- | Constant global variable
[Constant] :: LMConst

-- | Alias of another variable
[Alias] :: LMConst
i64 :: LlvmType
i32 :: LlvmType
i16 :: LlvmType
i8 :: LlvmType
i1 :: LlvmType
i8Ptr :: LlvmType

-- | The target architectures word size
llvmWord :: DynFlags -> LlvmType

-- | The target architectures word size
llvmWordPtr :: DynFlags -> LlvmType

-- | LLVM metadata expressions
data MetaExpr
[MetaStr] :: LMString -> MetaExpr
[MetaNode] :: Int -> MetaExpr
[MetaVar] :: LlvmVar -> MetaExpr
[MetaStruct] :: [MetaExpr] -> MetaExpr

-- | Associates some metadata with a specific label for attaching to an
--   instruction.
data MetaAnnot
[MetaAnnot] :: LMString -> MetaExpr -> MetaAnnot

-- | Metadata declarations. Metadata can only be declared in global scope.
data MetaDecl

-- | Named metadata. Only used for communicating module information to
--   LLVM. ('!name = !{ [!<a>n</a>] }' form).
[MetaNamed] :: LMString -> [Int] -> MetaDecl

-- | Metadata node declaration. ('!0 = metadata !{ <a>expression</a> }'
--   form).
[MetaUnamed] :: Int -> MetaExpr -> MetaDecl

-- | Test if a <a>LlvmVar</a> is global.
isGlobal :: LlvmVar -> Bool

-- | Return the <a>LlvmType</a> of a <a>LlvmLit</a>
getLitType :: LlvmLit -> LlvmType

-- | Return the <a>LlvmType</a> of the <a>LlvmVar</a>
getVarType :: LlvmVar -> LlvmType

-- | Return the <a>LlvmLinkageType</a> for a <a>LlvmVar</a>
getLink :: LlvmVar -> LlvmLinkageType

-- | Return the <a>LlvmType</a> of the <a>LlvmStatic</a>
getStatType :: LlvmStatic -> LlvmType

-- | Lower a variable of <a>LMPointer</a> type.
pVarLift :: LlvmVar -> LlvmVar

-- | Lower a variable of <a>LMPointer</a> type.
pVarLower :: LlvmVar -> LlvmVar

-- | Add a pointer indirection to the supplied type. <a>LMLabel</a> and
--   <a>LMVoid</a> cannot be lifted.
pLift :: LlvmType -> LlvmType

-- | Remove the pointer indirection of the supplied type. Only
--   <a>LMPointer</a> constructors can be lowered.
pLower :: LlvmType -> LlvmType

-- | Test if the given <a>LlvmType</a> is an integer
isInt :: LlvmType -> Bool

-- | Test if the given <a>LlvmType</a> is a floating point type
isFloat :: LlvmType -> Bool

-- | Test if the given <a>LlvmType</a> is an <a>LMPointer</a> construct
isPointer :: LlvmType -> Bool

-- | Test if the given <a>LlvmType</a> is an <a>LMVector</a> construct
isVector :: LlvmType -> Bool

-- | Width in bits of an <a>LlvmType</a>, returns 0 if not applicable
llvmWidthInBits :: DynFlags -> LlvmType -> Int

-- | Print a literal value. No type.
ppLit :: LlvmLit -> SDoc

-- | Return the variable name or value of the <a>LlvmVar</a> in Llvm IR
--   textual representation (e.g. <tt>@x</tt>, <tt>%y</tt> or <tt>42</tt>).
ppName :: LlvmVar -> SDoc

-- | Return the variable name or value of the <a>LlvmVar</a> in a plain
--   textual representation (e.g. <tt>x</tt>, <tt>y</tt> or <tt>42</tt>).
ppPlainName :: LlvmVar -> SDoc

-- | Print out a whole LLVM module.
ppLlvmModule :: LlvmModule -> SDoc

-- | Print out a multi-line comment, can be inside a function or on its own
ppLlvmComments :: [LMString] -> SDoc

-- | Print out a comment, can be inside a function or on its own
ppLlvmComment :: LMString -> SDoc

-- | Print out a list of global mutable variable definitions
ppLlvmGlobals :: [LMGlobal] -> SDoc

-- | Print out a global mutable variable definition
ppLlvmGlobal :: LMGlobal -> SDoc

-- | Print out a list of function declaration.
ppLlvmFunctionDecls :: LlvmFunctionDecls -> SDoc

-- | Print out a function declaration. Declarations define the function
--   type but don't define the actual body of the function.
ppLlvmFunctionDecl :: LlvmFunctionDecl -> SDoc

-- | Print out a list of function definitions.
ppLlvmFunctions :: LlvmFunctions -> SDoc

-- | Print out a function definition.
ppLlvmFunction :: LlvmFunction -> SDoc

-- | Print out an LLVM type alias.
ppLlvmAlias :: LlvmAlias -> SDoc

-- | Print out a list of LLVM type aliases.
ppLlvmAliases :: [LlvmAlias] -> SDoc

-- | Print out a list of LLVM metadata.
ppLlvmMetas :: [MetaDecl] -> SDoc

-- | Print out an LLVM metadata definition.
ppLlvmMeta :: MetaDecl -> SDoc

module SMRep

-- | Word offset, or word count
type WordOff = Int

-- | Byte offset, or byte count
type ByteOff = Int

-- | Convert the given number of words to a number of bytes.
--   
--   This function morally has type <tt>WordOff -&gt; ByteOff</tt>, but
--   uses <tt>Num a</tt> to allow for overloading.
wordsToBytes :: Num a => DynFlags -> a -> a

-- | First round the given byte count up to a multiple of the machine's
--   word size and then convert the result to words.
bytesToWordsRoundUp :: DynFlags -> ByteOff -> WordOff

-- | Round up the given byte count to the next byte count that's a multiple
--   of the machine's word size.
roundUpToWords :: DynFlags -> ByteOff -> ByteOff
data StgWord
fromStgWord :: StgWord -> Integer
toStgWord :: DynFlags -> Integer -> StgWord
data StgHalfWord
fromStgHalfWord :: StgHalfWord -> Integer
toStgHalfWord :: DynFlags -> Integer -> StgHalfWord
hALF_WORD_SIZE :: DynFlags -> ByteOff
hALF_WORD_SIZE_IN_BITS :: DynFlags -> Int

-- | A description of the layout of a closure. Corresponds directly to the
--   closure types in includes<i>rts</i>storage/ClosureTypes.h.
data SMRep
[HeapRep] :: IsStatic -> !WordOff -> !WordOff -> ClosureTypeInfo -> SMRep
[ArrayPtrsRep] :: !WordOff -> !WordOff -> SMRep
[SmallArrayPtrsRep] :: !WordOff -> SMRep
[ArrayWordsRep] :: !WordOff -> SMRep
[StackRep] :: Liveness -> SMRep
[RTSRep] :: Int -> SMRep -> SMRep

-- | True <a>=</a> This is a static closure. Affects how we garbage-collect
--   it. Static closure have an extra static link field at the end.
type IsStatic = Bool
data ClosureTypeInfo
[Constr] :: ConstrTag -> ConstrDescription -> ClosureTypeInfo
[Fun] :: FunArity -> ArgDescr -> ClosureTypeInfo
[Thunk] :: ClosureTypeInfo
[ThunkSelector] :: SelectorOffset -> ClosureTypeInfo
[BlackHole] :: ClosureTypeInfo
[IndStatic] :: ClosureTypeInfo
data ArgDescr
[ArgSpec] :: !Int -> ArgDescr
[ArgGen] :: Liveness -> ArgDescr
type Liveness = [Bool]
type ConstrDescription = [Word8]
mkHeapRep :: DynFlags -> IsStatic -> WordOff -> WordOff -> ClosureTypeInfo -> SMRep
blackHoleRep :: SMRep
indStaticRep :: SMRep
mkStackRep :: [Bool] -> SMRep
mkRTSRep :: Int -> SMRep -> SMRep
arrPtrsRep :: DynFlags -> WordOff -> SMRep
smallArrPtrsRep :: WordOff -> SMRep
arrWordsRep :: DynFlags -> ByteOff -> SMRep
isStaticRep :: SMRep -> IsStatic
isConRep :: SMRep -> Bool
isThunkRep :: SMRep -> Bool
isFunRep :: SMRep -> Bool
isStaticNoCafCon :: SMRep -> Bool
isStackRep :: SMRep -> Bool

-- | The total size of the closure, in words.
heapClosureSizeW :: DynFlags -> SMRep -> WordOff

-- | Size of a closure header (StgHeader in
--   includes<i>rts</i>storage/Closures.h)
fixedHdrSizeW :: DynFlags -> WordOff
arrWordsHdrSize :: DynFlags -> ByteOff
arrWordsHdrSizeW :: DynFlags -> WordOff
arrPtrsHdrSize :: DynFlags -> ByteOff
arrPtrsHdrSizeW :: DynFlags -> WordOff

-- | Size of the profiling part of a closure header (StgProfHeader in
--   includes<i>rts</i>storage/Closures.h)
profHdrSize :: DynFlags -> WordOff
thunkHdrSize :: DynFlags -> WordOff
nonHdrSize :: DynFlags -> SMRep -> ByteOff
nonHdrSizeW :: SMRep -> WordOff
smallArrPtrsHdrSize :: DynFlags -> ByteOff
smallArrPtrsHdrSizeW :: DynFlags -> WordOff
hdrSize :: DynFlags -> SMRep -> ByteOff
hdrSizeW :: DynFlags -> SMRep -> WordOff
fixedHdrSize :: DynFlags -> ByteOff

-- | Derives the RTS closure type from an <a>SMRep</a>
rtsClosureType :: SMRep -> Int
rET_SMALL :: Int
rET_BIG :: Int
aRG_GEN :: Int
aRG_GEN_BIG :: Int

-- | The byte offset into the card table of the card for a given element
card :: DynFlags -> Int -> Int

-- | Convert a number of elements to a number of cards, rounding up
cardRoundUp :: DynFlags -> Int -> Int

-- | The size of a card table, in bytes
cardTableSizeB :: DynFlags -> Int -> ByteOff

-- | The size of a card table, in words
cardTableSizeW :: DynFlags -> Int -> WordOff
pprWord8String :: [Word8] -> SDoc
stringToWord8s :: String -> [Word8]
instance Eq StgHalfWord
instance Bits StgWord
instance Eq StgWord
instance Outputable StgWord
instance Outputable StgHalfWord
instance Outputable ClosureTypeInfo
instance Outputable SMRep
instance Outputable ArgDescr

module Bitmap

-- | A bitmap represented by a sequence of <a>StgWord</a>s on the
--   <i>target</i> architecture. These are used for bitmaps in info tables
--   and other generated code which need to be emitted as sequences of
--   StgWords.
type Bitmap = [StgWord]

-- | Make a bitmap from a sequence of bits
mkBitmap :: DynFlags -> [Bool] -> Bitmap

-- | Make a bitmap where the slots specified are the <i>ones</i> in the
--   bitmap. eg. <tt>[0,1,3], size 4 ==&gt; 0xb</tt>.
--   
--   The list of <tt>Int</tt>s <i>must</i> be already sorted.
intsToBitmap :: DynFlags -> Int -> [Int] -> Bitmap

-- | Make a bitmap where the slots specified are the <i>zeros</i> in the
--   bitmap. eg. <tt>[0,1,3], size 4 ==&gt; 0x4</tt> (we leave any bits
--   outside the size as zero, just to make the bitmap easier to read).
--   
--   The list of <tt>Int</tt>s <i>must</i> be already sorted and
--   duplicate-free.
intsToReverseBitmap :: DynFlags -> Int -> [Int] -> Bitmap

-- | Magic number, must agree with <tt>BITMAP_BITS_SHIFT</tt> in
--   InfoTables.h. Some kinds of bitmap pack a size/bitmap into a single
--   word if possible, or fall back to an external pointer when the bitmap
--   is too large. This value represents the largest size of bitmap that
--   can be packed into a single word.
mAX_SMALL_BITMAP_SIZE :: DynFlags -> Int
seqBitmap :: Bitmap -> a -> a

module CmmType
data CmmType
b8 :: CmmType
b16 :: CmmType
b32 :: CmmType
b64 :: CmmType
b128 :: CmmType
b256 :: CmmType
b512 :: CmmType
f32 :: CmmType
f64 :: CmmType
bWord :: DynFlags -> CmmType
bHalfWord :: DynFlags -> CmmType
gcWord :: DynFlags -> CmmType
cInt :: DynFlags -> CmmType
cLong :: DynFlags -> CmmType
cmmBits :: Width -> CmmType
cmmFloat :: Width -> CmmType
typeWidth :: CmmType -> Width
cmmEqType :: CmmType -> CmmType -> Bool
cmmEqType_ignoring_ptrhood :: CmmType -> CmmType -> Bool
isFloatType :: CmmType -> Bool
isGcPtrType :: CmmType -> Bool
isWord32 :: CmmType -> Bool
isWord64 :: CmmType -> Bool
isFloat64 :: CmmType -> Bool
isFloat32 :: CmmType -> Bool
data Width
[W8] :: Width
[W16] :: Width
[W32] :: Width
[W64] :: Width
[W80] :: Width
[W128] :: Width
[W256] :: Width
[W512] :: Width
widthInBits :: Width -> Int
widthInBytes :: Width -> Int
widthInLog :: Width -> Int
widthFromBytes :: Int -> Width
wordWidth :: DynFlags -> Width
halfWordWidth :: DynFlags -> Width
cIntWidth :: DynFlags -> Width
cLongWidth :: DynFlags -> Width
halfWordMask :: DynFlags -> Integer
narrowU :: Width -> Integer -> Integer
narrowS :: Width -> Integer -> Integer
rEP_CostCentreStack_mem_alloc :: DynFlags -> CmmType
rEP_CostCentreStack_scc_count :: DynFlags -> CmmType
rEP_StgEntCounter_allocs :: DynFlags -> CmmType
rEP_StgEntCounter_allocd :: DynFlags -> CmmType
data ForeignHint
[NoHint] :: ForeignHint
[AddrHint] :: ForeignHint
[SignedHint] :: ForeignHint
type Length = Int
vec :: Length -> CmmType -> CmmType
vec2 :: CmmType -> CmmType
vec4 :: CmmType -> CmmType
vec8 :: CmmType -> CmmType
vec16 :: CmmType -> CmmType
vec2f64 :: CmmType
vec2b64 :: CmmType
vec4f32 :: CmmType
vec4b32 :: CmmType
vec8b16 :: CmmType
vec16b8 :: CmmType
cmmVec :: Int -> CmmType -> CmmType
vecLength :: CmmType -> Length
vecElemType :: CmmType -> CmmType
isVecType :: CmmType -> Bool
instance Eq ForeignHint
instance Eq CmmCat
instance Show Width
instance Ord Width
instance Eq Width
instance Outputable CmmType
instance Outputable CmmCat
instance Outputable Width

module CmmMachOp

-- | Machine-level primops; ones which we can reasonably delegate to the
--   native code generators to handle.
--   
--   Most operations are parameterised by the <a>Width</a> that they
--   operate on. Some operations have separate signed and unsigned
--   versions, and float and integer versions.
data MachOp
[MO_Add] :: Width -> MachOp
[MO_Sub] :: Width -> MachOp
[MO_Eq] :: Width -> MachOp
[MO_Ne] :: Width -> MachOp
[MO_Mul] :: Width -> MachOp
[MO_S_MulMayOflo] :: Width -> MachOp
[MO_S_Quot] :: Width -> MachOp
[MO_S_Rem] :: Width -> MachOp
[MO_S_Neg] :: Width -> MachOp
[MO_U_MulMayOflo] :: Width -> MachOp
[MO_U_Quot] :: Width -> MachOp
[MO_U_Rem] :: Width -> MachOp
[MO_S_Ge] :: Width -> MachOp
[MO_S_Le] :: Width -> MachOp
[MO_S_Gt] :: Width -> MachOp
[MO_S_Lt] :: Width -> MachOp
[MO_U_Ge] :: Width -> MachOp
[MO_U_Le] :: Width -> MachOp
[MO_U_Gt] :: Width -> MachOp
[MO_U_Lt] :: Width -> MachOp
[MO_F_Add] :: Width -> MachOp
[MO_F_Sub] :: Width -> MachOp
[MO_F_Neg] :: Width -> MachOp
[MO_F_Mul] :: Width -> MachOp
[MO_F_Quot] :: Width -> MachOp
[MO_F_Eq] :: Width -> MachOp
[MO_F_Ne] :: Width -> MachOp
[MO_F_Ge] :: Width -> MachOp
[MO_F_Le] :: Width -> MachOp
[MO_F_Gt] :: Width -> MachOp
[MO_F_Lt] :: Width -> MachOp
[MO_And] :: Width -> MachOp
[MO_Or] :: Width -> MachOp
[MO_Xor] :: Width -> MachOp
[MO_Not] :: Width -> MachOp
[MO_Shl] :: Width -> MachOp
[MO_U_Shr] :: Width -> MachOp
[MO_S_Shr] :: Width -> MachOp
[MO_SF_Conv] :: Width -> Width -> MachOp
[MO_FS_Conv] :: Width -> Width -> MachOp
[MO_SS_Conv] :: Width -> Width -> MachOp
[MO_UU_Conv] :: Width -> Width -> MachOp
[MO_FF_Conv] :: Width -> Width -> MachOp
[MO_V_Insert] :: Length -> Width -> MachOp
[MO_V_Extract] :: Length -> Width -> MachOp
[MO_V_Add] :: Length -> Width -> MachOp
[MO_V_Sub] :: Length -> Width -> MachOp
[MO_V_Mul] :: Length -> Width -> MachOp
[MO_VS_Quot] :: Length -> Width -> MachOp
[MO_VS_Rem] :: Length -> Width -> MachOp
[MO_VS_Neg] :: Length -> Width -> MachOp
[MO_VU_Quot] :: Length -> Width -> MachOp
[MO_VU_Rem] :: Length -> Width -> MachOp
[MO_VF_Insert] :: Length -> Width -> MachOp
[MO_VF_Extract] :: Length -> Width -> MachOp
[MO_VF_Add] :: Length -> Width -> MachOp
[MO_VF_Sub] :: Length -> Width -> MachOp
[MO_VF_Neg] :: Length -> Width -> MachOp
[MO_VF_Mul] :: Length -> Width -> MachOp
[MO_VF_Quot] :: Length -> Width -> MachOp
pprMachOp :: MachOp -> SDoc

-- | Returns <a>True</a> if the MachOp has commutable arguments. This is
--   used in the platform-independent Cmm optimisations.
--   
--   If in doubt, return <a>False</a>. This generates worse code on the
--   native routes, but is otherwise harmless.
isCommutableMachOp :: MachOp -> Bool

-- | Returns <a>True</a> if the MachOp is associative (i.e. <tt>(x+y)+z ==
--   x+(y+z)</tt>) This is used in the platform-independent Cmm
--   optimisations.
--   
--   If in doubt, return <a>False</a>. This generates worse code on the
--   native routes, but is otherwise harmless.
isAssociativeMachOp :: MachOp -> Bool

-- | Returns <a>True</a> if the MachOp is a comparison.
--   
--   If in doubt, return False. This generates worse code on the native
--   routes, but is otherwise harmless.
isComparisonMachOp :: MachOp -> Bool

-- | Returns <tt>Just w</tt> if the operation is an integer comparison with
--   width <tt>w</tt>, or <tt>Nothing</tt> otherwise.
maybeIntComparison :: MachOp -> Maybe Width

-- | Returns the MachRep of the result of a MachOp.
machOpResultType :: DynFlags -> MachOp -> [CmmType] -> CmmType

-- | This function is used for debugging only: we can check whether an
--   application of a MachOp is "type-correct" by checking that the
--   MachReps of its arguments are the same as the MachOp expects. This is
--   used when linting a CmmExpr.
machOpArgReps :: DynFlags -> MachOp -> [Width]
maybeInvertComparison :: MachOp -> Maybe MachOp
mo_wordAdd :: DynFlags -> MachOp
mo_wordSub :: DynFlags -> MachOp
mo_wordEq :: DynFlags -> MachOp
mo_wordNe :: DynFlags -> MachOp
mo_wordMul :: DynFlags -> MachOp
mo_wordSQuot :: DynFlags -> MachOp
mo_wordSRem :: DynFlags -> MachOp
mo_wordSNeg :: DynFlags -> MachOp
mo_wordUQuot :: DynFlags -> MachOp
mo_wordURem :: DynFlags -> MachOp
mo_wordSGe :: DynFlags -> MachOp
mo_wordSLe :: DynFlags -> MachOp
mo_wordSGt :: DynFlags -> MachOp
mo_wordSLt :: DynFlags -> MachOp
mo_wordUGe :: DynFlags -> MachOp
mo_wordULe :: DynFlags -> MachOp
mo_wordUGt :: DynFlags -> MachOp
mo_wordULt :: DynFlags -> MachOp
mo_wordAnd :: DynFlags -> MachOp
mo_wordOr :: DynFlags -> MachOp
mo_wordXor :: DynFlags -> MachOp
mo_wordNot :: DynFlags -> MachOp
mo_wordShl :: DynFlags -> MachOp
mo_wordSShr :: DynFlags -> MachOp
mo_wordUShr :: DynFlags -> MachOp
mo_u_8To32 :: MachOp
mo_s_8To32 :: MachOp
mo_u_16To32 :: MachOp
mo_s_16To32 :: MachOp
mo_u_8ToWord :: DynFlags -> MachOp
mo_s_8ToWord :: DynFlags -> MachOp
mo_u_16ToWord :: DynFlags -> MachOp
mo_s_16ToWord :: DynFlags -> MachOp
mo_u_32ToWord :: DynFlags -> MachOp
mo_s_32ToWord :: DynFlags -> MachOp
mo_32To8 :: MachOp
mo_32To16 :: MachOp
mo_WordTo8 :: DynFlags -> MachOp
mo_WordTo16 :: DynFlags -> MachOp
mo_WordTo32 :: DynFlags -> MachOp
mo_WordTo64 :: DynFlags -> MachOp
data CallishMachOp
[MO_F64_Pwr] :: CallishMachOp
[MO_F64_Sin] :: CallishMachOp
[MO_F64_Cos] :: CallishMachOp
[MO_F64_Tan] :: CallishMachOp
[MO_F64_Sinh] :: CallishMachOp
[MO_F64_Cosh] :: CallishMachOp
[MO_F64_Tanh] :: CallishMachOp
[MO_F64_Asin] :: CallishMachOp
[MO_F64_Acos] :: CallishMachOp
[MO_F64_Atan] :: CallishMachOp
[MO_F64_Log] :: CallishMachOp
[MO_F64_Exp] :: CallishMachOp
[MO_F64_Sqrt] :: CallishMachOp
[MO_F32_Pwr] :: CallishMachOp
[MO_F32_Sin] :: CallishMachOp
[MO_F32_Cos] :: CallishMachOp
[MO_F32_Tan] :: CallishMachOp
[MO_F32_Sinh] :: CallishMachOp
[MO_F32_Cosh] :: CallishMachOp
[MO_F32_Tanh] :: CallishMachOp
[MO_F32_Asin] :: CallishMachOp
[MO_F32_Acos] :: CallishMachOp
[MO_F32_Atan] :: CallishMachOp
[MO_F32_Log] :: CallishMachOp
[MO_F32_Exp] :: CallishMachOp
[MO_F32_Sqrt] :: CallishMachOp
[MO_UF_Conv] :: Width -> CallishMachOp
[MO_S_QuotRem] :: Width -> CallishMachOp
[MO_U_QuotRem] :: Width -> CallishMachOp
[MO_U_QuotRem2] :: Width -> CallishMachOp
[MO_Add2] :: Width -> CallishMachOp
[MO_AddIntC] :: Width -> CallishMachOp
[MO_SubIntC] :: Width -> CallishMachOp
[MO_U_Mul2] :: Width -> CallishMachOp
[MO_WriteBarrier] :: CallishMachOp
[MO_Touch] :: CallishMachOp
[MO_Prefetch_Data] :: Int -> CallishMachOp
[MO_Memcpy] :: CallishMachOp
[MO_Memset] :: CallishMachOp
[MO_Memmove] :: CallishMachOp
[MO_PopCnt] :: Width -> CallishMachOp
[MO_Clz] :: Width -> CallishMachOp
[MO_Ctz] :: Width -> CallishMachOp
[MO_BSwap] :: Width -> CallishMachOp
[MO_AtomicRMW] :: Width -> AtomicMachOp -> CallishMachOp
[MO_AtomicRead] :: Width -> CallishMachOp
[MO_AtomicWrite] :: Width -> CallishMachOp
[MO_Cmpxchg] :: Width -> CallishMachOp
callishMachOpHints :: CallishMachOp -> ([ForeignHint], [ForeignHint])
pprCallishMachOp :: CallishMachOp -> SDoc

-- | The operation to perform atomically.
data AtomicMachOp
[AMO_Add] :: AtomicMachOp
[AMO_Sub] :: AtomicMachOp
[AMO_And] :: AtomicMachOp
[AMO_Nand] :: AtomicMachOp
[AMO_Or] :: AtomicMachOp
[AMO_Xor] :: AtomicMachOp
instance Show CallishMachOp
instance Eq CallishMachOp
instance Show AtomicMachOp
instance Eq AtomicMachOp
instance Show MachOp
instance Eq MachOp


-- | Generating C symbol names emitted by the compiler.
module CPrim
atomicReadLabel :: Width -> String
atomicWriteLabel :: Width -> String
atomicRMWLabel :: Width -> AtomicMachOp -> String
cmpxchgLabel :: Width -> String
popCntLabel :: Width -> String
bSwapLabel :: Width -> String
clzLabel :: Width -> String
ctzLabel :: Width -> String
word2FloatLabel :: Width -> String


-- | Break Arrays in the IO monad
--   
--   Entries in the array are Word sized Conceptually, a zero-indexed
--   IOArray of Bools, initially False. They're represented as Words with
--   0==False, 1==True. They're used to determine whether GHCI breakpoints
--   are on or off.
--   
--   (c) The University of Glasgow 2007
module BreakArray
data BreakArray
[BA] :: (MutableByteArray# RealWorld) -> BreakArray
newBreakArray :: DynFlags -> Int -> IO BreakArray
getBreak :: DynFlags -> BreakArray -> Int -> IO (Maybe Word)
setBreakOn :: DynFlags -> BreakArray -> Int -> IO Bool
setBreakOff :: DynFlags -> BreakArray -> Int -> IO Bool
showBreakArray :: DynFlags -> BreakArray -> IO ()


-- | Bits and pieces on the bottom of the module dependency tree. Also
--   import the required constants, so we know what we're using.
--   
--   In the interests of cross-compilation, we want to free ourselves from
--   the autoconf generated modules like main/Constants
module SPARC.Base
wordLength :: Int
wordLengthInBits :: Int
spillAreaLength :: DynFlags -> Int

-- | We need 8 bytes because our largest registers are 64 bit.
spillSlotSize :: Int

-- | We (allegedly) put the first six C-call arguments in registers; where
--   do we start putting the rest of them?
extraStackArgsHere :: Int

-- | Check whether an offset is representable with 13 bits.
fits13Bits :: Integral a => a -> Bool

-- | Check whether an integer will fit in 32 bits. A CmmInt is intended to
--   be truncated to the appropriate number of bits, so here we truncate it
--   to Int64. This is important because e.g. -1 as a CmmInt might be
--   either -1 or 18446744073709551615.
is32BitInteger :: Integer -> Bool

-- | Sadness.
largeOffsetError :: (Integral a, Show a) => a -> b


-- | The assignment of virtual registers to stack slots
module RegAlloc.Linear.StackMap

-- | Identifier for a stack slot.
type StackSlot = Int
data StackMap
[StackMap] :: !Int -> UniqFM StackSlot -> StackMap

-- | The slots that are still available to be allocated.
[stackMapNextFreeSlot] :: StackMap -> !Int

-- | Assignment of vregs to stack slots.
[stackMapAssignment] :: StackMap -> UniqFM StackSlot

-- | An empty stack map, with all slots available.
emptyStackMap :: DynFlags -> StackMap

-- | If this vreg unique already has a stack assignment then return the
--   slot number, otherwise allocate a new slot, and update the map.
getStackSlotFor :: StackMap -> Unique -> (StackMap, Int)

-- | Return the number of stack slots that were allocated
getStackUse :: StackMap -> Int

module IOEnv
data IOEnv env a
failM :: IOEnv env a
failWithM :: String -> IOEnv env a
data IOEnvFailure
[IOEnvFailure] :: IOEnvFailure
getEnv :: IOEnv env env

-- | Perform a computation with a different environment
setEnv :: env' -> IOEnv env' a -> IOEnv env a

-- | Perform a computation with an altered environment
updEnv :: (env -> env') -> IOEnv env' a -> IOEnv env a
runIOEnv :: env -> IOEnv env a -> IO a
unsafeInterleaveM :: IOEnv env a -> IOEnv env a
uninterruptibleMaskM_ :: IOEnv env a -> IOEnv env a
tryM :: IOEnv env r -> IOEnv env (Either IOEnvFailure r)
tryAllM :: IOEnv env r -> IOEnv env (Either SomeException r)
tryMostM :: IOEnv env r -> IOEnv env (Either SomeException r)
fixM :: (a -> IOEnv env a) -> IOEnv env a

-- | A mutable variable in the <a>IO</a> monad
data IORef a :: * -> *
newMutVar :: a -> IOEnv env (IORef a)
readMutVar :: IORef a -> IOEnv env a
writeMutVar :: IORef a -> a -> IOEnv env ()
updMutVar :: IORef a -> (a -> a) -> IOEnv env ()

-- | Atomically update the reference. Does not force the evaluation of the
--   new variable contents. For strict update, use <a>atomicUpdMutVar'</a>.
atomicUpdMutVar :: IORef a -> (a -> (a, b)) -> IOEnv env b

-- | Strict variant of <a>atomicUpdMutVar</a>.
atomicUpdMutVar' :: IORef a -> (a -> (a, b)) -> IOEnv env b
instance Monad (IOEnv m)
instance Applicative (IOEnv m)
instance Functor (IOEnv m)
instance Show IOEnvFailure
instance Exception IOEnvFailure
instance ContainsDynFlags env => HasDynFlags (IOEnv env)
instance ContainsModule env => HasModule (IOEnv env)
instance MonadPlus IO => Alternative (IOEnv env)
instance MonadPlus IO => MonadPlus (IOEnv env)
instance MonadIO (IOEnv env)

module ForeignCall
newtype ForeignCall
[CCall] :: CCallSpec -> ForeignCall
isSafeForeignCall :: ForeignCall -> Bool
data Safety
[PlaySafe] :: Safety
[PlayInterruptible] :: Safety
[PlayRisky] :: Safety
playSafe :: Safety -> Bool
playInterruptible :: Safety -> Bool
data CExportSpec
[CExportStatic] :: CLabelString -> CCallConv -> CExportSpec
type CLabelString = FastString
isCLabelString :: CLabelString -> Bool
pprCLabelString :: CLabelString -> SDoc
data CCallSpec
[CCallSpec] :: CCallTarget -> CCallConv -> Safety -> CCallSpec

-- | How to call a particular function in C-land.
data CCallTarget
[StaticTarget] :: CLabelString -> (Maybe PackageKey) -> Bool -> CCallTarget
[DynamicTarget] :: CCallTarget
isDynamicTarget :: CCallTarget -> Bool
data CCallConv
[CCallConv] :: CCallConv
[CApiConv] :: CCallConv
[StdCallConv] :: CCallConv
[PrimCallConv] :: CCallConv
[JavaScriptCallConv] :: CCallConv
defaultCCallConv :: CCallConv
ccallConvToInt :: CCallConv -> Int
ccallConvAttribute :: CCallConv -> SDoc
newtype Header
[Header] :: FastString -> Header

-- | A C type, used in CAPI FFI calls
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{-# CTYPE'</tt>,
--   <a>AnnHeader</a>,<a>AnnVal</a>, <a>AnnClose</a> <tt>'#-}'</tt>,</li>
--   </ul>
data CType
[CType] :: SourceText -> (Maybe Header) -> FastString -> CType
instance Data CType
instance Data Header
instance Eq Header
instance Data CExportSpec
instance Eq ForeignCall
instance Eq CCallSpec
instance Data CCallTarget
instance Eq CCallTarget
instance Data CCallConv
instance Eq CCallConv
instance Data Safety
instance Show Safety
instance Eq Safety
instance Outputable ForeignCall
instance Outputable Safety
instance Outputable CCallConv
instance Outputable CExportSpec
instance Outputable CCallSpec
instance Outputable Header
instance Outputable CType
instance Binary ForeignCall
instance Binary Safety
instance Binary CExportSpec
instance Binary CCallSpec
instance Binary CCallTarget
instance Binary CCallConv
instance Binary CType
instance Binary Header


-- | Boolean formulas without quantifiers and without negation. Such a
--   formula consists of variables, conjunctions (and), and disjunctions
--   (or).
--   
--   This module is used to represent minimal complete definitions for
--   classes.
module BooleanFormula
data BooleanFormula a
[Var] :: a -> BooleanFormula a
[And] :: [BooleanFormula a] -> BooleanFormula a
[Or] :: [BooleanFormula a] -> BooleanFormula a
mkFalse :: BooleanFormula a
mkTrue :: BooleanFormula a
mkAnd :: Eq a => [BooleanFormula a] -> BooleanFormula a
mkOr :: Eq a => [BooleanFormula a] -> BooleanFormula a
mkVar :: a -> BooleanFormula a
isFalse :: BooleanFormula a -> Bool
isTrue :: BooleanFormula a -> Bool
eval :: (a -> Bool) -> BooleanFormula a -> Bool
simplify :: Eq a => (a -> Maybe Bool) -> BooleanFormula a -> BooleanFormula a
isUnsatisfied :: Eq a => (a -> Bool) -> BooleanFormula a -> Maybe (BooleanFormula a)
implies :: Eq a => BooleanFormula a -> BooleanFormula a -> Bool
impliesAtom :: Eq a => BooleanFormula a -> a -> Bool
pprBooleanFormula :: (Rational -> a -> SDoc) -> Rational -> BooleanFormula a -> SDoc
pprBooleanFormulaNice :: Outputable a => BooleanFormula a -> SDoc
instance Traversable BooleanFormula
instance Foldable BooleanFormula
instance Functor BooleanFormula
instance Data a => Data (BooleanFormula a)
instance Eq a => Eq (BooleanFormula a)
instance Outputable a => Outputable (BooleanFormula a)
instance Binary a => Binary (BooleanFormula a)

module Serialized

-- | Represents a serialized value of a particular type. Attempts can be
--   made to deserialize it at certain types
data Serialized

-- | Force the contents of the Serialized value so weknow it doesn't
--   contain any bottoms
seqSerialized :: Serialized -> ()

-- | Put a Typeable value that we are able to actually turn into bytes into
--   a <a>Serialized</a> value ready for deserialization later
toSerialized :: Typeable a => (a -> [Word8]) -> a -> Serialized

-- | If the <a>Serialized</a> value contains something of the given type,
--   then use the specified deserializer to return <tt>Just</tt> that.
--   Otherwise return <tt>Nothing</tt>.
fromSerialized :: Typeable a => ([Word8] -> a) -> Serialized -> Maybe a

-- | Use a <a>Data</a> instance to implement a serialization scheme dual to
--   that of <a>deserializeWithData</a>
serializeWithData :: Data a => a -> [Word8]

-- | Use a <a>Data</a> instance to implement a deserialization scheme dual
--   to that of <a>serializeWithData</a>
deserializeWithData :: Data a => [Word8] -> a
instance Outputable Serialized
instance Binary Serialized


-- | GHC uses several kinds of name internally:
--   
--   <ul>
--   <li><a>OccName</a>: see <a>OccName#name_types</a></li>
--   <li><a>RdrName</a>: see <a>RdrName#name_types</a></li>
--   <li><a>Name</a> is the type of names that have had their scoping and
--   binding resolved. They have an <a>OccName</a> but also a <a>Unique</a>
--   that disambiguates Names that have the same <a>OccName</a> and indeed
--   is used for all <a>Name</a> comparison. Names also contain information
--   about where they originated from, see <a>Name#name_sorts</a></li>
--   <li><a>Id</a>: see <a>Id#name_types</a></li>
--   <li><a>Var</a>: see <a>Var#name_types</a></li>
--   </ul>
--   
--   Names are one of:
--   
--   <ul>
--   <li>External, if they name things declared in other modules. Some
--   external Names are wired in, i.e. they name primitives defined in the
--   compiler itself</li>
--   <li>Internal, if they name things in the module being compiled. Some
--   internal Names are system names, if they are names manufactured by the
--   compiler</li>
--   </ul>
module Name

-- | A unique, unambigious name for something, containing information about
--   where that thing originated.
data Name

-- | BuiltInSyntax is for things like <tt>(:)</tt>, <tt>[]</tt> and tuples,
--   which have special syntactic forms. They aren't in scope as such.
data BuiltInSyntax
[BuiltInSyntax] :: BuiltInSyntax
[UserSyntax] :: BuiltInSyntax

-- | Create a name brought into being by the compiler
mkSystemName :: Unique -> OccName -> Name
mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name

-- | Create a name which is (for now at least) local to the current module
--   and hence does not need a <a>Module</a> to disambiguate it from other
--   <a>Name</a>s
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
mkClonedInternalName :: Unique -> Name -> Name
mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
mkSystemVarName :: Unique -> FastString -> Name
mkSysTvName :: Unique -> FastString -> Name

-- | Make a name for a foreign call
mkFCallName :: Unique -> String -> Name

-- | Create a name which definitely originates in the given module
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name

-- | Create a name which is actually defined by the compiler itself
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
nameUnique :: Name -> Unique
setNameUnique :: Name -> Unique -> Name
nameOccName :: Name -> OccName
nameModule :: Name -> Module
nameModule_maybe :: Name -> Maybe Module
setNameLoc :: Name -> SrcSpan -> Name
tidyNameOcc :: Name -> OccName -> Name

-- | Make the <a>Name</a> into an internal name, regardless of what it was
--   to begin with
localiseName :: Name -> Name

-- | Create a localised variant of a name.
--   
--   If the name is external, encode the original's module name to
--   disambiguate. SPJ says: this looks like a rather odd-looking function;
--   but it seems to be used only during vectorisation, so I'm not going to
--   worry
mkLocalisedOccName :: Module -> (Maybe String -> OccName -> OccName) -> Name -> OccName
nameSrcLoc :: Name -> SrcLoc
nameSrcSpan :: Name -> SrcSpan
pprNameDefnLoc :: Name -> SDoc
pprDefinedAt :: Name -> SDoc
isSystemName :: Name -> Bool
isInternalName :: Name -> Bool
isExternalName :: Name -> Bool
isTyVarName :: Name -> Bool
isTyConName :: Name -> Bool
isDataConName :: Name -> Bool
isValName :: Name -> Bool
isVarName :: Name -> Bool
isWiredInName :: Name -> Bool
isBuiltInSyntax :: Name -> Bool
wiredInNameTyThing_maybe :: Name -> Maybe TyThing

-- | Returns True if the name is (a) Internal (b) External but from the
--   specified module (c) External but from the <tt>interactive</tt>
--   package
--   
--   The key idea is that False means: the entity is defined in some other
--   module you can find the details (type, fixity, instances) in some
--   interface file those details will be stored in the EPT or HPT
--   
--   True means: the entity is defined in this module or earlier in the
--   GHCi session you can find details (type, fixity, instances) in the
--   TcGblEnv or TcLclEnv
--   
--   The isInteractiveModule part is because successive interactions of a
--   GCHi session each give rise to a fresh module (Ghci1, Ghci2, etc), but
--   they all come from the magic <tt>interactive</tt> package; and all the
--   details are kept in the TcLclEnv, TcGblEnv, NOT in the HPT or EPT. See
--   Note [The interactive package] in HscTypes
nameIsLocalOrFrom :: Module -> Name -> Bool
stableNameCmp :: Name -> Name -> Ordering

-- | A class allowing convenient access to the <a>Name</a> of various
--   datatypes
class NamedThing a where getOccName n = nameOccName (getName n)
getOccName :: NamedThing a => a -> OccName
getName :: NamedThing a => a -> Name
getSrcLoc :: NamedThing a => a -> SrcLoc
getSrcSpan :: NamedThing a => a -> SrcSpan
getOccString :: NamedThing a => a -> String
pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc
pprPrefixName :: (Outputable a, NamedThing a) => a -> SDoc
pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
instance HasOccName Name
instance Eq Name
instance Ord Name
instance Uniquable Name
instance NamedThing Name
instance Data Name
instance Binary Name
instance Outputable Name
instance OutputableBndr Name

module NameEnv
type NameEnv a = UniqFM a
mkNameEnv :: [(Name, a)] -> NameEnv a
emptyNameEnv :: NameEnv a
unitNameEnv :: Name -> a -> NameEnv a
nameEnvElts :: NameEnv a -> [a]
nameEnvUniqueElts :: NameEnv a -> [(Unique, a)]
extendNameEnv_C :: (a -> a -> a) -> NameEnv a -> Name -> a -> NameEnv a
extendNameEnv_Acc :: (a -> b -> b) -> (a -> b) -> NameEnv b -> Name -> a -> NameEnv b
extendNameEnv :: NameEnv a -> Name -> a -> NameEnv a
extendNameEnvList :: NameEnv a -> [(Name, a)] -> NameEnv a
extendNameEnvList_C :: (a -> a -> a) -> NameEnv a -> [(Name, a)] -> NameEnv a
foldNameEnv :: (a -> b -> b) -> b -> NameEnv a -> b
filterNameEnv :: (elt -> Bool) -> NameEnv elt -> NameEnv elt
anyNameEnv :: (elt -> Bool) -> NameEnv elt -> Bool
plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a
plusNameEnv_C :: (a -> a -> a) -> NameEnv a -> NameEnv a -> NameEnv a
alterNameEnv :: (Maybe a -> Maybe a) -> NameEnv a -> Name -> NameEnv a
lookupNameEnv :: NameEnv a -> Name -> Maybe a
lookupNameEnv_NF :: NameEnv a -> Name -> a
delFromNameEnv :: NameEnv a -> Name -> NameEnv a
delListFromNameEnv :: NameEnv a -> [Name] -> NameEnv a
elemNameEnv :: Name -> NameEnv a -> Bool
mapNameEnv :: (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2
disjointNameEnv :: NameEnv a -> NameEnv a -> Bool
depAnal :: (node -> [Name]) -> (node -> [Name]) -> [node] -> [SCC node]

module NameSet
type NameSet = UniqSet Name
emptyNameSet :: NameSet
unitNameSet :: Name -> NameSet
mkNameSet :: [Name] -> NameSet
unionNameSet :: NameSet -> NameSet -> NameSet
unionNameSets :: [NameSet] -> NameSet
minusNameSet :: NameSet -> NameSet -> NameSet
elemNameSet :: Name -> NameSet -> Bool
nameSetElems :: NameSet -> [Name]
extendNameSet :: NameSet -> Name -> NameSet
extendNameSetList :: NameSet -> [Name] -> NameSet
delFromNameSet :: NameSet -> Name -> NameSet
delListFromNameSet :: NameSet -> [Name] -> NameSet
isEmptyNameSet :: NameSet -> Bool
foldNameSet :: (Name -> b -> b) -> b -> NameSet -> b
filterNameSet :: (Name -> Bool) -> NameSet -> NameSet

-- | True if there is a non-empty intersection. <tt>s1
--   <a>intersectsNameSet</a> s2</tt> doesn't compute <tt>s2</tt> if
--   <tt>s1</tt> is empty
intersectsNameSet :: NameSet -> NameSet -> Bool
intersectNameSet :: NameSet -> NameSet -> NameSet
type FreeVars = NameSet
isEmptyFVs :: NameSet -> Bool
emptyFVs :: FreeVars
plusFVs :: [FreeVars] -> FreeVars
plusFV :: FreeVars -> FreeVars -> FreeVars
mkFVs :: [Name] -> FreeVars
addOneFV :: FreeVars -> Name -> FreeVars
unitFV :: Name -> FreeVars
delFV :: Name -> FreeVars -> FreeVars
delFVs :: [Name] -> FreeVars -> FreeVars

-- | A set of names that are defined somewhere
type Defs = NameSet

-- | A set of names that are used somewhere
type Uses = NameSet

-- | <tt>(Just ds, us) =&gt;</tt> The use of any member of the <tt>ds</tt>
--   implies that all the <tt>us</tt> are used too. Also, <tt>us</tt> may
--   mention <tt>ds</tt>.
--   
--   <tt>Nothing =&gt;</tt> Nothing is defined in this group, but
--   nevertheless all the uses are essential. Used for instance
--   declarations, for example
type DefUse = (Maybe Defs, Uses)

-- | A number of <a>DefUse</a>s in dependency order: earlier <a>Defs</a>
--   scope over later <a>Uses</a> In a single (def, use) pair, the defs
--   also scope over the uses
type DefUses = [DefUse]
emptyDUs :: DefUses
usesOnly :: Uses -> DefUses
mkDUs :: [(Defs, Uses)] -> DefUses
plusDU :: DefUses -> DefUses -> DefUses

-- | Given some <a>DefUses</a> and some <a>Uses</a>, find all the uses,
--   transitively. The result is a superset of the input <a>Uses</a>; and
--   includes things defined in the input <a>DefUses</a> (but only if they
--   are used)
findUses :: DefUses -> Uses -> Uses
duDefs :: DefUses -> Defs

-- | Collect all <a>Uses</a>, regardless of whether the group is itself
--   used, but remove <a>Defs</a> on the way
duUses :: DefUses -> Uses

-- | Just like <a>duUses</a>, but <a>Defs</a> are not eliminated from the
--   <a>Uses</a> returned
allUses :: DefUses -> Uses

module Avail

-- | A collection of <a>AvailInfo</a> - several things that are "available"
type Avails = [AvailInfo]

-- | Records what things are "available", i.e. in scope
data AvailInfo

-- | An ordinary identifier in scope
[Avail] :: Name -> AvailInfo

-- | A type or class in scope. Parameters:
--   
--   1) The name of the type or class 2) The available pieces of type or
--   class.
--   
--   The AvailTC Invariant: * If the type or class is itself to be in
--   scope, it must be *first* in this list. Thus, typically: <tt>AvailTC
--   Eq [Eq, ==, /=]</tt>
[AvailTC] :: Name -> [Name] -> AvailInfo
availsToNameSet :: [AvailInfo] -> NameSet
availsToNameEnv :: [AvailInfo] -> NameEnv AvailInfo

-- | Just the main name made available, i.e. not the available pieces of
--   type or class brought into scope by the <tt>GenAvailInfo</tt>
availName :: AvailInfo -> Name

-- | All names made available by the availability information
availNames :: AvailInfo -> [Name]

-- | Compare lexicographically
stableAvailCmp :: AvailInfo -> AvailInfo -> Ordering
instance Eq AvailInfo
instance Outputable AvailInfo
instance Binary AvailInfo

module ConLike

-- | A constructor-like thing
data ConLike
[RealDataCon] :: DataCon -> ConLike
[PatSynCon] :: PatSyn -> ConLike
instance Eq ConLike
instance Ord ConLike
instance Uniquable ConLike
instance NamedThing ConLike
instance Outputable ConLike
instance OutputableBndr ConLike
instance Data ConLike


-- | GHC uses several kinds of name internally:
--   
--   <ul>
--   <li><a>OccName</a>: see <a>OccName#name_types</a></li>
--   <li><a>RdrName</a> is the type of names that come directly from the
--   parser. They have not yet had their scoping and binding resolved by
--   the renamer and can be thought of to a first approximation as an
--   <a>OccName</a> with an optional module qualifier</li>
--   <li><a>Name</a>: see <a>Name#name_types</a></li>
--   <li><a>Id</a>: see <a>Id#name_types</a></li>
--   <li><a>Var</a>: see <a>Var#name_types</a></li>
--   </ul>
module RdrName

-- | Do not use the data constructors of RdrName directly: prefer the
--   family of functions that creates them, such as <a>mkRdrUnqual</a>
--   
--   <ul>
--   <li>Note: A Located RdrName will only have API Annotations if it is a
--   compound one, e.g.</li>
--   </ul>
--   
--   <pre>
--   `bar`
--   ( ~ )
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnType</a>, <a>AnnOpen</a> <tt>'('</tt>
--   or <tt>'['</tt> or <tt>'[:'</tt>, <a>AnnClose</a> <tt>')'</tt> or
--   <tt>']'</tt> or <tt>':]'</tt>,, <a>AnnBackquote</a> <tt>'`'</tt>,
--   <a>AnnVal</a>,<a>AnnTildehsh</a>, <a>AnnTilde</a>,</li>
--   </ul>
data RdrName

-- | Used for ordinary, unqualified occurrences, e.g. <tt>x</tt>,
--   <tt>y</tt> or <tt>Foo</tt>. Create such a <a>RdrName</a> with
--   <a>mkRdrUnqual</a>
[Unqual] :: OccName -> RdrName

-- | A qualified name written by the user in <i>source</i> code. The module
--   isn't necessarily the module where the thing is defined; just the one
--   from which it is imported. Examples are <tt>Bar.x</tt>, <tt>Bar.y</tt>
--   or <tt>Bar.Foo</tt>. Create such a <a>RdrName</a> with
--   <a>mkRdrQual</a>
[Qual] :: ModuleName -> OccName -> RdrName

-- | An original name; the module is the <i>defining</i> module. This is
--   used when GHC generates code that will be fed into the renamer (e.g.
--   from deriving clauses), but where we want to say "Use Prelude.map
--   dammit". One of these can be created with <a>mkOrig</a>
[Orig] :: Module -> OccName -> RdrName

-- | We know exactly the <a>Name</a>. This is used:
--   
--   <ol>
--   <li>When the parser parses built-in syntax like <tt>[]</tt> and
--   <tt>(,)</tt>, but wants a <a>RdrName</a> from it</li>
--   <li>By Template Haskell, when TH has generated a unique name</li>
--   </ol>
--   
--   Such a <a>RdrName</a> can be created by using <a>getRdrName</a> on a
--   <a>Name</a>
[Exact] :: Name -> RdrName
mkRdrUnqual :: OccName -> RdrName
mkRdrQual :: ModuleName -> OccName -> RdrName
mkUnqual :: NameSpace -> FastString -> RdrName
mkVarUnqual :: FastString -> RdrName

-- | Make a qualified <a>RdrName</a> in the given namespace and where the
--   <a>ModuleName</a> and the <a>OccName</a> are taken from the first and
--   second elements of the tuple respectively
mkQual :: NameSpace -> (FastString, FastString) -> RdrName
mkOrig :: Module -> OccName -> RdrName
nameRdrName :: Name -> RdrName
getRdrName :: NamedThing thing => thing -> RdrName
rdrNameOcc :: RdrName -> OccName
rdrNameSpace :: RdrName -> NameSpace

-- | This rather gruesome function is used mainly by the parser. When
--   parsing:
--   
--   <pre>
--   data T a = T | T1 Int
--   </pre>
--   
--   we parse the data constructors as <i>types</i> because of parser
--   ambiguities, so then we need to change the <i>type constr</i> to a
--   <i>data constr</i>
--   
--   The exact-name case <i>can</i> occur when parsing:
--   
--   <pre>
--   data [] a = [] | a : [a]
--   </pre>
--   
--   For the exact-name case we return an original name.
setRdrNameSpace :: RdrName -> NameSpace -> RdrName
demoteRdrName :: RdrName -> Maybe RdrName
isRdrDataCon :: RdrName -> Bool
isRdrTyVar :: RdrName -> Bool
isRdrTc :: RdrName -> Bool
isQual :: RdrName -> Bool
isQual_maybe :: RdrName -> Maybe (ModuleName, OccName)
isUnqual :: RdrName -> Bool
isOrig :: RdrName -> Bool
isOrig_maybe :: RdrName -> Maybe (Module, OccName)
isExact :: RdrName -> Bool
isExact_maybe :: RdrName -> Maybe Name
isSrcRdrName :: RdrName -> Bool

-- | This environment is used to store local bindings (<tt>let</tt>,
--   <tt>where</tt>, lambda, <tt>case</tt>). It is keyed by OccName,
--   because we never use it for qualified names We keep the current
--   mapping, *and* the set of all Names in scope Reason: see Note
--   [Splicing Exact Names] in RnEnv
data LocalRdrEnv
emptyLocalRdrEnv :: LocalRdrEnv
extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv
extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv
lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name
lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name
elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool
inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool
localRdrEnvElts :: LocalRdrEnv -> [Name]
delLocalRdrEnvList :: LocalRdrEnv -> [OccName] -> LocalRdrEnv

-- | Keyed by <a>OccName</a>; when looking up a qualified name we look up
--   the <a>OccName</a> part, and then check the <a>Provenance</a> to see
--   if the appropriate qualification is valid. This saves routinely
--   doubling the size of the env by adding both qualified and unqualified
--   names to the domain.
--   
--   The list in the codomain is required because there may be name clashes
--   These only get reported on lookup, not on construction
--   
--   INVARIANT: All the members of the list have distinct <a>gre_name</a>
--   fields; that is, no duplicate Names
--   
--   INVARIANT: Imported provenance =&gt; Name is an ExternalName However
--   LocalDefs can have an InternalName. This happens only when
--   type-checking a [d| ... |] Template Haskell quotation; see this note
--   in RnNames Note [Top-level Names in Template Haskell decl quotes]
type GlobalRdrEnv = OccEnv [GlobalRdrElt]
emptyGlobalRdrEnv :: GlobalRdrEnv
mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv
plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
lookupGlobalRdrEnv :: GlobalRdrEnv -> OccName -> [GlobalRdrElt]
extendGlobalRdrEnv :: Bool -> GlobalRdrEnv -> [AvailInfo] -> GlobalRdrEnv
pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc
globalRdrEnvElts :: GlobalRdrEnv -> [GlobalRdrElt]
lookupGRE_RdrName :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
lookupGRE_Name :: GlobalRdrEnv -> Name -> [GlobalRdrElt]
getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]

-- | Apply a transformation function to the GREs for these OccNames
transformGREs :: (GlobalRdrElt -> GlobalRdrElt) -> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv

-- | For each <a>OccName</a>, see if there are multiple local definitions
--   for it; return a list of all such and return a list of the duplicate
--   bindings
findLocalDupsRdrEnv :: GlobalRdrEnv -> [Name] -> [[GlobalRdrElt]]

-- | Take a list of GREs which have the right OccName Pick those GREs that
--   are suitable for this RdrName And for those, keep only only the
--   Provenances that are suitable Only used for Qual and Unqual, not Orig
--   or Exact
--   
--   Consider:
--   
--   <pre>
--   module A ( f ) where
--   import qualified Foo( f )
--   import Baz( f )
--   f = undefined
--   </pre>
--   
--   Let's suppose that <tt>Foo.f</tt> and <tt>Baz.f</tt> are the same
--   entity really. The export of <tt>f</tt> is ambiguous because it's in
--   scope from the local def and the import. The lookup of <tt>Unqual
--   f</tt> should return a GRE for the locally-defined <tt>f</tt>, and a
--   GRE for the imported <tt>f</tt>, with a <i>single</i> provenance,
--   namely the one for <tt>Baz(f)</tt>.
pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]

-- | make a <a>GlobalRdrEnv</a> where all the elements point to the same
--   Provenance (useful for "hiding" imports, or imports with no details).
gresFromAvails :: Provenance -> [AvailInfo] -> [GlobalRdrElt]
gresFromAvail :: (Name -> Provenance) -> AvailInfo -> [GlobalRdrElt]

-- | An element of the <a>GlobalRdrEnv</a>
data GlobalRdrElt
[GRE] :: Name -> Parent -> Provenance -> GlobalRdrElt
[gre_name] :: GlobalRdrElt -> Name
[gre_par] :: GlobalRdrElt -> Parent

-- | Why it's in scope
[gre_prov] :: GlobalRdrElt -> Provenance
isLocalGRE :: GlobalRdrElt -> Bool

-- | Test if an unqualifed version of this thing would be in scope
unQualOK :: GlobalRdrElt -> Bool

-- | Is in scope qualified with the given module?
qualSpecOK :: ModuleName -> ImportSpec -> Bool

-- | Is in scope unqualified?
unQualSpecOK :: ImportSpec -> Bool

-- | The <a>Provenance</a> of something says how it came to be in scope.
--   It's quite elaborate so that we can give accurate unused-name
--   warnings.
data Provenance

-- | The thing was defined locally
[LocalDef] :: Provenance

-- | The thing was imported.
--   
--   INVARIANT: the list of <a>ImportSpec</a> is non-empty
[Imported] :: [ImportSpec] -> Provenance

-- | Print out the place where the name was imported
pprNameProvenance :: GlobalRdrElt -> SDoc

-- | The children of a Name are the things that are abbreviated by the ".."
--   notation in export lists. See Note [Parents]
data Parent
[NoParent] :: Parent
[ParentIs] :: Name -> Parent
data ImportSpec
[ImpSpec] :: ImpDeclSpec -> ImpItemSpec -> ImportSpec
[is_decl] :: ImportSpec -> ImpDeclSpec
[is_item] :: ImportSpec -> ImpItemSpec

-- | Describes a particular import declaration and is shared among all the
--   <a>Provenance</a>s for that decl
data ImpDeclSpec
[ImpDeclSpec] :: ModuleName -> ModuleName -> Bool -> SrcSpan -> ImpDeclSpec

-- | Module imported, e.g. <tt>import Muggle</tt> Note the <tt>Muggle</tt>
--   may well not be the defining module for this thing!
[is_mod] :: ImpDeclSpec -> ModuleName

-- | Import alias, e.g. from <tt>as M</tt> (or <tt>Muggle</tt> if there is
--   no <tt>as</tt> clause)
[is_as] :: ImpDeclSpec -> ModuleName

-- | Was this import qualified?
[is_qual] :: ImpDeclSpec -> Bool

-- | The location of the entire import declaration
[is_dloc] :: ImpDeclSpec -> SrcSpan

-- | Describes import info a particular Name
data ImpItemSpec

-- | The import had no import list, or had a hiding list
[ImpAll] :: ImpItemSpec

-- | The import had an import list. The <a>is_explicit</a> field is
--   <tt>True</tt> iff the thing was named <i>explicitly</i> in the import
--   specs rather than being imported as part of a "..." group. Consider:
--   
--   <pre>
--   import C( T(..) )
--   </pre>
--   
--   Here the constructors of <tt>T</tt> are not named explicitly; only
--   <tt>T</tt> is named explicitly.
[ImpSome] :: Bool -> SrcSpan -> ImpItemSpec
[is_explicit] :: ImpItemSpec -> Bool
[is_iloc] :: ImpItemSpec -> SrcSpan
importSpecLoc :: ImportSpec -> SrcSpan
importSpecModule :: ImportSpec -> ModuleName
isExplicitItem :: ImpItemSpec -> Bool
instance Ord ImportSpec
instance Eq ImportSpec
instance Eq Parent
instance Data RdrName
instance HasOccName RdrName
instance Outputable RdrName
instance OutputableBndr RdrName
instance Eq RdrName
instance Ord RdrName
instance Outputable LocalRdrEnv
instance Outputable Parent
instance Outputable GlobalRdrElt
instance Eq Provenance
instance Eq ImpDeclSpec
instance Eq ImpItemSpec
instance Ord Provenance
instance Ord ImpDeclSpec
instance Ord ImpItemSpec
instance Outputable ImportSpec

module PrelNames

-- | The type of unique identifiers that are used in many places in GHC for
--   fast ordering and equality tests. You should generate these with the
--   functions from the <tt>UniqSupply</tt> module
data Unique

-- | Class of things that we can obtain a <a>Unique</a> from
class Uniquable a
getUnique :: Uniquable a => a -> Unique
hasKey :: Uniquable a => a -> Unique -> Bool
allNameStrings :: [String]
itName :: Unique -> SrcSpan -> Name
mkUnboundName :: RdrName -> Name
isUnboundName :: Name -> Bool
basicKnownKeyNames :: [Name]
genericTyConNames :: [Name]
pRELUDE :: Module
gHC_PRIM :: Module
gHC_TYPES :: Module
gHC_GENERICS :: Module
gHC_MAGIC :: Module
gHC_CLASSES :: Module
gHC_BASE :: Module
gHC_ENUM :: Module
gHC_GHCI :: Module
gHC_CSTRING :: Module
gHC_SHOW :: Module
gHC_READ :: Module
gHC_NUM :: Module
gHC_INTEGER_TYPE :: Module
gHC_LIST :: Module
gHC_TUPLE :: Module
dATA_TUPLE :: Module
dATA_EITHER :: Module
dATA_STRING :: Module
dATA_FOLDABLE :: Module
dATA_TRAVERSABLE :: Module
dATA_MONOID :: Module
gHC_CONC :: Module
gHC_IO :: Module
gHC_IO_Exception :: Module
gHC_ST :: Module
gHC_ARR :: Module
gHC_STABLE :: Module
gHC_PTR :: Module
gHC_ERR :: Module
gHC_REAL :: Module
gHC_FLOAT :: Module
gHC_TOP_HANDLER :: Module
sYSTEM_IO :: Module
dYNAMIC :: Module
tYPEABLE :: Module
tYPEABLE_INTERNAL :: Module
gENERICS :: Module
rEAD_PREC :: Module
lEX :: Module
gHC_INT :: Module
gHC_WORD :: Module
mONAD :: Module
mONAD_FIX :: Module
mONAD_ZIP :: Module
aRROW :: Module
cONTROL_APPLICATIVE :: Module
gHC_DESUGAR :: Module
rANDOM :: Module
gHC_EXTS :: Module
cONTROL_EXCEPTION_BASE :: Module
gHC_TYPELITS :: Module
gHC_IP :: Module
gHC_PARR' :: Module
gHC_STATICPTR :: Module
gHC_FINGERPRINT_TYPE :: Module
mAIN :: Module
rOOT_MAIN :: Module
mkInteractiveModule :: Int -> Module
pRELUDE_NAME :: ModuleName
mAIN_NAME :: ModuleName
dATA_ARRAY_PARALLEL_NAME :: ModuleName
dATA_ARRAY_PARALLEL_PRIM_NAME :: ModuleName
mkPrimModule :: FastString -> Module
mkIntegerModule :: FastString -> Module
mkBaseModule :: FastString -> Module
mkBaseModule_ :: ModuleName -> Module
mkThisGhcModule :: FastString -> Module
mkThisGhcModule_ :: ModuleName -> Module
mkMainModule :: FastString -> Module
mkMainModule_ :: ModuleName -> Module
mkTupleModule :: TupleSort -> Module
main_RDR_Unqual :: RdrName
forall_tv_RDR :: RdrName
dot_tv_RDR :: RdrName
eq_RDR :: RdrName
ge_RDR :: RdrName
ne_RDR :: RdrName
le_RDR :: RdrName
lt_RDR :: RdrName
gt_RDR :: RdrName
compare_RDR :: RdrName
ltTag_RDR :: RdrName
eqTag_RDR :: RdrName
gtTag_RDR :: RdrName
eqClass_RDR :: RdrName
numClass_RDR :: RdrName
ordClass_RDR :: RdrName
enumClass_RDR :: RdrName
monadClass_RDR :: RdrName
map_RDR :: RdrName
append_RDR :: RdrName
foldr_RDR :: RdrName
build_RDR :: RdrName
returnM_RDR :: RdrName
bindM_RDR :: RdrName
failM_RDR :: RdrName
left_RDR :: RdrName
right_RDR :: RdrName
fromEnum_RDR :: RdrName
toEnum_RDR :: RdrName
enumFrom_RDR :: RdrName
enumFromTo_RDR :: RdrName
enumFromThen_RDR :: RdrName
enumFromThenTo_RDR :: RdrName
ratioDataCon_RDR :: RdrName
plusInteger_RDR :: RdrName
timesInteger_RDR :: RdrName
ioDataCon_RDR :: RdrName
eqString_RDR :: RdrName
unpackCString_RDR :: RdrName
unpackCStringFoldr_RDR :: RdrName
unpackCStringUtf8_RDR :: RdrName
newStablePtr_RDR :: RdrName
bindIO_RDR :: RdrName
returnIO_RDR :: RdrName
fromInteger_RDR :: RdrName
fromRational_RDR :: RdrName
minus_RDR :: RdrName
times_RDR :: RdrName
plus_RDR :: RdrName
fromString_RDR :: RdrName
fromList_RDR :: RdrName
fromListN_RDR :: RdrName
toList_RDR :: RdrName
compose_RDR :: RdrName
not_RDR :: RdrName
getTag_RDR :: RdrName
succ_RDR :: RdrName
pred_RDR :: RdrName
minBound_RDR :: RdrName
maxBound_RDR :: RdrName
and_RDR :: RdrName
range_RDR :: RdrName
inRange_RDR :: RdrName
index_RDR :: RdrName
unsafeIndex_RDR :: RdrName
unsafeRangeSize_RDR :: RdrName
readList_RDR :: RdrName
readListDefault_RDR :: RdrName
readListPrec_RDR :: RdrName
readListPrecDefault_RDR :: RdrName
readPrec_RDR :: RdrName
parens_RDR :: RdrName
choose_RDR :: RdrName
lexP_RDR :: RdrName
expectP_RDR :: RdrName
punc_RDR :: RdrName
ident_RDR :: RdrName
symbol_RDR :: RdrName
step_RDR :: RdrName
alt_RDR :: RdrName
reset_RDR :: RdrName
prec_RDR :: RdrName
pfail_RDR :: RdrName
showList_RDR :: RdrName
showList___RDR :: RdrName
showsPrec_RDR :: RdrName
showString_RDR :: RdrName
showSpace_RDR :: RdrName
showParen_RDR :: RdrName
typeRep_RDR :: RdrName
mkTyCon_RDR :: RdrName
mkTyConApp_RDR :: RdrName
undefined_RDR :: RdrName
error_RDR :: RdrName
u1DataCon_RDR :: RdrName
par1DataCon_RDR :: RdrName
rec1DataCon_RDR :: RdrName
k1DataCon_RDR :: RdrName
m1DataCon_RDR :: RdrName
l1DataCon_RDR :: RdrName
r1DataCon_RDR :: RdrName
prodDataCon_RDR :: RdrName
comp1DataCon_RDR :: RdrName
unPar1_RDR :: RdrName
unRec1_RDR :: RdrName
unK1_RDR :: RdrName
unComp1_RDR :: RdrName
from_RDR :: RdrName
from1_RDR :: RdrName
to_RDR :: RdrName
to1_RDR :: RdrName
datatypeName_RDR :: RdrName
moduleName_RDR :: RdrName
isNewtypeName_RDR :: RdrName
conName_RDR :: RdrName
conFixity_RDR :: RdrName
conIsRecord_RDR :: RdrName
noArityDataCon_RDR :: RdrName
arityDataCon_RDR :: RdrName
selName_RDR :: RdrName
prefixDataCon_RDR :: RdrName
infixDataCon_RDR :: RdrName
leftAssocDataCon_RDR :: RdrName
rightAssocDataCon_RDR :: RdrName
notAssocDataCon_RDR :: RdrName
fmap_RDR :: RdrName
pure_RDR :: RdrName
ap_RDR :: RdrName
foldable_foldr_RDR :: RdrName
foldMap_RDR :: RdrName
traverse_RDR :: RdrName
mempty_RDR :: RdrName
mappend_RDR :: RdrName
varQual_RDR :: Module -> FastString -> RdrName
tcQual_RDR :: Module -> FastString -> RdrName
clsQual_RDR :: Module -> FastString -> RdrName
dataQual_RDR :: Module -> FastString -> RdrName
wildCardName :: Name
runMainIOName :: Name
orderingTyConName :: Name
ltDataConName :: Name
eqDataConName :: Name
gtDataConName :: Name
specTyConName :: Name
eitherTyConName :: Name
leftDataConName :: Name
rightDataConName :: Name
v1TyConName :: Name
u1TyConName :: Name
par1TyConName :: Name
rec1TyConName :: Name
k1TyConName :: Name
m1TyConName :: Name
sumTyConName :: Name
prodTyConName :: Name
compTyConName :: Name
rTyConName :: Name
pTyConName :: Name
dTyConName :: Name
cTyConName :: Name
sTyConName :: Name
rec0TyConName :: Name
par0TyConName :: Name
d1TyConName :: Name
c1TyConName :: Name
s1TyConName :: Name
noSelTyConName :: Name
repTyConName :: Name
rep1TyConName :: Name
unpackCStringName :: Name
unpackCStringFoldrName :: Name
unpackCStringUtf8Name :: Name
eqStringName :: Name
stringTyConName :: Name
inlineIdName :: Name
fmapName :: Name
eqClassName :: Name
eqName :: Name
ordClassName :: Name
geName :: Name
functorClassName :: Name
monadClassName :: Name
thenMName :: Name
bindMName :: Name
returnMName :: Name
failMName :: Name
applicativeClassName :: Name
foldableClassName :: Name
traversableClassName :: Name
joinMName :: Name
apAName :: Name
pureAName :: Name
alternativeClassName :: Name
joinMIdKey :: Unique
apAClassOpKey :: Unique
pureAClassOpKey :: Unique
alternativeClassKey :: Unique
groupWithName :: Name
fromStringName :: Name
otherwiseIdName :: Name
foldrName :: Name
buildName :: Name
augmentName :: Name
mapName :: Name
appendName :: Name
assertName :: Name
breakpointName :: Name
breakpointCondName :: Name
breakpointAutoName :: Name
opaqueTyConName :: Name
breakpointJumpName :: Name
breakpointCondJumpName :: Name
breakpointAutoJumpName :: Name
fstName :: Name
sndName :: Name
numClassName :: Name
fromIntegerName :: Name
minusName :: Name
negateName :: Name
integerTyConName :: Name
mkIntegerName :: Name
integerSDataConName :: Name
integerToWord64Name :: Name
integerToInt64Name :: Name
word64ToIntegerName :: Name
int64ToIntegerName :: Name
plusIntegerName :: Name
timesIntegerName :: Name
smallIntegerName :: Name
wordToIntegerName :: Name
integerToWordName :: Name
integerToIntName :: Name
minusIntegerName :: Name
negateIntegerName :: Name
eqIntegerPrimName :: Name
neqIntegerPrimName :: Name
absIntegerName :: Name
signumIntegerName :: Name
leIntegerPrimName :: Name
gtIntegerPrimName :: Name
ltIntegerPrimName :: Name
geIntegerPrimName :: Name
compareIntegerName :: Name
quotRemIntegerName :: Name
divModIntegerName :: Name
quotIntegerName :: Name
remIntegerName :: Name
divIntegerName :: Name
modIntegerName :: Name
floatFromIntegerName :: Name
doubleFromIntegerName :: Name
encodeFloatIntegerName :: Name
encodeDoubleIntegerName :: Name
decodeDoubleIntegerName :: Name
gcdIntegerName :: Name
lcmIntegerName :: Name
andIntegerName :: Name
orIntegerName :: Name
xorIntegerName :: Name
complementIntegerName :: Name
shiftLIntegerName :: Name
shiftRIntegerName :: Name
rationalTyConName :: Name
ratioTyConName :: Name
ratioDataConName :: Name
realClassName :: Name
integralClassName :: Name
realFracClassName :: Name
fractionalClassName :: Name
fromRationalName :: Name
toIntegerName :: Name
toRationalName :: Name
fromIntegralName :: Name
realToFracName :: Name
floatingClassName :: Name
realFloatClassName :: Name
rationalToFloatName :: Name
rationalToDoubleName :: Name
ixClassName :: Name
typeableClassName :: Name
typeRepTyConName :: Name
mkTyConName :: Name
mkPolyTyConAppName :: Name
mkAppTyName :: Name
typeLitTypeRepName :: Name
dataClassName :: Name
assertErrorName :: Name
enumClassName :: Name
enumFromName :: Name
enumFromToName :: Name
enumFromThenName :: Name
enumFromThenToName :: Name
boundedClassName :: Name
concatName :: Name
filterName :: Name
zipName :: Name
isListClassName :: Name
fromListName :: Name
fromListNName :: Name
toListName :: Name
showClassName :: Name
readClassName :: Name
genClassName :: Name
gen1ClassName :: Name
datatypeClassName :: Name
constructorClassName :: Name
selectorClassName :: Name
genericClassNames :: [Name]
ghciIoClassName :: Name
ghciStepIoMName :: Name
ioTyConName :: Name
ioDataConName :: Name
thenIOName :: Name
bindIOName :: Name
returnIOName :: Name
failIOName :: Name
printName :: Name
int8TyConName :: Name
int16TyConName :: Name
int32TyConName :: Name
int64TyConName :: Name
word8TyConName :: Name
word16TyConName :: Name
word32TyConName :: Name
word64TyConName :: Name
ptrTyConName :: Name
funPtrTyConName :: Name
stablePtrTyConName :: Name
newStablePtrName :: Name
runSTRepName :: Name
monadFixClassName :: Name
mfixName :: Name
arrAName :: Name
composeAName :: Name
firstAName :: Name
appAName :: Name
choiceAName :: Name
loopAName :: Name
guardMName :: Name
liftMName :: Name
mzipName :: Name
toAnnotationWrapperName :: Name
monadPlusClassName :: Name
randomClassName :: Name
randomGenClassName :: Name
isStringClassName :: Name
knownNatClassName :: Name
knownSymbolClassName :: Name
ipClassName :: Name
pLUGINS :: Module
pluginTyConName :: Name
staticPtrInfoTyConName :: Name
staticPtrInfoDataConName :: Name
staticPtrTyConName :: Name
staticPtrDataConName :: Name
fingerprintDataConName :: Name
varQual :: Module -> FastString -> Unique -> Name
tcQual :: Module -> FastString -> Unique -> Name
clsQual :: Module -> FastString -> Unique -> Name
mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
conName :: Module -> FastString -> Unique -> Name
boundedClassKey :: Unique
enumClassKey :: Unique
eqClassKey :: Unique
floatingClassKey :: Unique
fractionalClassKey :: Unique
integralClassKey :: Unique
monadClassKey :: Unique
dataClassKey :: Unique
functorClassKey :: Unique
numClassKey :: Unique
ordClassKey :: Unique
readClassKey :: Unique
realClassKey :: Unique
realFloatClassKey :: Unique
realFracClassKey :: Unique
showClassKey :: Unique
ixClassKey :: Unique
typeableClassKey :: Unique
typeable1ClassKey :: Unique
typeable2ClassKey :: Unique
typeable3ClassKey :: Unique
typeable4ClassKey :: Unique
typeable5ClassKey :: Unique
typeable6ClassKey :: Unique
typeable7ClassKey :: Unique
monadFixClassKey :: Unique
monadPlusClassKey :: Unique
randomClassKey :: Unique
randomGenClassKey :: Unique
isStringClassKey :: Unique
applicativeClassKey :: Unique
foldableClassKey :: Unique
traversableClassKey :: Unique
genClassKey :: Unique
gen1ClassKey :: Unique
datatypeClassKey :: Unique
constructorClassKey :: Unique
selectorClassKey :: Unique
knownNatClassNameKey :: Unique
knownSymbolClassNameKey :: Unique
ghciIoClassKey :: Unique
ipClassNameKey :: Unique
addrPrimTyConKey :: Unique
arrayPrimTyConKey :: Unique
arrayArrayPrimTyConKey :: Unique
boolTyConKey :: Unique
byteArrayPrimTyConKey :: Unique
charPrimTyConKey :: Unique
charTyConKey :: Unique
doublePrimTyConKey :: Unique
doubleTyConKey :: Unique
floatPrimTyConKey :: Unique
floatTyConKey :: Unique
funTyConKey :: Unique
intPrimTyConKey :: Unique
intTyConKey :: Unique
int8TyConKey :: Unique
int16TyConKey :: Unique
int32PrimTyConKey :: Unique
int32TyConKey :: Unique
int64PrimTyConKey :: Unique
int64TyConKey :: Unique
integerTyConKey :: Unique
listTyConKey :: Unique
foreignObjPrimTyConKey :: Unique
weakPrimTyConKey :: Unique
mutableArrayPrimTyConKey :: Unique
mutableArrayArrayPrimTyConKey :: Unique
mutableByteArrayPrimTyConKey :: Unique
orderingTyConKey :: Unique
mVarPrimTyConKey :: Unique
ratioTyConKey :: Unique
rationalTyConKey :: Unique
realWorldTyConKey :: Unique
stablePtrPrimTyConKey :: Unique
stablePtrTyConKey :: Unique
anyTyConKey :: Unique
eqTyConKey :: Unique
smallArrayPrimTyConKey :: Unique
smallMutableArrayPrimTyConKey :: Unique
statePrimTyConKey :: Unique
stableNamePrimTyConKey :: Unique
stableNameTyConKey :: Unique
mutVarPrimTyConKey :: Unique
ioTyConKey :: Unique
wordPrimTyConKey :: Unique
wordTyConKey :: Unique
word8TyConKey :: Unique
word16TyConKey :: Unique
word32PrimTyConKey :: Unique
word32TyConKey :: Unique
word64PrimTyConKey :: Unique
word64TyConKey :: Unique
liftedConKey :: Unique
unliftedConKey :: Unique
anyBoxConKey :: Unique
kindConKey :: Unique
boxityConKey :: Unique
typeConKey :: Unique
threadIdPrimTyConKey :: Unique
bcoPrimTyConKey :: Unique
ptrTyConKey :: Unique
funPtrTyConKey :: Unique
tVarPrimTyConKey :: Unique
eqPrimTyConKey :: Unique
eqReprPrimTyConKey :: Unique
voidPrimTyConKey :: Unique
parrTyConKey :: Unique
objectTyConKey :: Unique
eitherTyConKey :: Unique
superKindTyConKey :: Unique
liftedTypeKindTyConKey :: Unique
anyKindTyConKey :: Unique
openTypeKindTyConKey :: Unique
unliftedTypeKindTyConKey :: Unique
constraintKindTyConKey :: Unique
symCoercionTyConKey :: Unique
transCoercionTyConKey :: Unique
leftCoercionTyConKey :: Unique
rightCoercionTyConKey :: Unique
instCoercionTyConKey :: Unique
unsafeCoercionTyConKey :: Unique
csel1CoercionTyConKey :: Unique
csel2CoercionTyConKey :: Unique
cselRCoercionTyConKey :: Unique
pluginTyConKey :: Unique
unknownTyConKey :: Unique
unknown1TyConKey :: Unique
unknown2TyConKey :: Unique
unknown3TyConKey :: Unique
opaqueTyConKey :: Unique
stringTyConKey :: Unique
v1TyConKey :: Unique
u1TyConKey :: Unique
par1TyConKey :: Unique
rec1TyConKey :: Unique
k1TyConKey :: Unique
m1TyConKey :: Unique
sumTyConKey :: Unique
prodTyConKey :: Unique
compTyConKey :: Unique
rTyConKey :: Unique
pTyConKey :: Unique
dTyConKey :: Unique
cTyConKey :: Unique
sTyConKey :: Unique
rec0TyConKey :: Unique
par0TyConKey :: Unique
d1TyConKey :: Unique
c1TyConKey :: Unique
s1TyConKey :: Unique
noSelTyConKey :: Unique
repTyConKey :: Unique
rep1TyConKey :: Unique
typeNatKindConNameKey :: Unique
typeSymbolKindConNameKey :: Unique
typeNatAddTyFamNameKey :: Unique
typeNatMulTyFamNameKey :: Unique
typeNatExpTyFamNameKey :: Unique
typeNatLeqTyFamNameKey :: Unique
typeNatSubTyFamNameKey :: Unique
typeSymbolCmpTyFamNameKey :: Unique
typeNatCmpTyFamNameKey :: Unique
ntTyConKey :: Unique
coercibleTyConKey :: Unique
proxyPrimTyConKey :: Unique
specTyConKey :: Unique
staticPtrTyConKey :: Unique
staticPtrInfoTyConKey :: Unique
typeRepTyConKey :: Unique
unitTyConKey :: Unique
charDataConKey :: Unique
consDataConKey :: Unique
doubleDataConKey :: Unique
falseDataConKey :: Unique
floatDataConKey :: Unique
intDataConKey :: Unique
integerSDataConKey :: Unique
nilDataConKey :: Unique
ratioDataConKey :: Unique
stableNameDataConKey :: Unique
trueDataConKey :: Unique
wordDataConKey :: Unique
ioDataConKey :: Unique
integerDataConKey :: Unique
eqBoxDataConKey :: Unique
coercibleDataConKey :: Unique
crossDataConKey :: Unique
inlDataConKey :: Unique
inrDataConKey :: Unique
genUnitDataConKey :: Unique
parrDataConKey :: Unique
leftDataConKey :: Unique
rightDataConKey :: Unique
ltDataConKey :: Unique
eqDataConKey :: Unique
gtDataConKey :: Unique
staticPtrDataConKey :: Unique
staticPtrInfoDataConKey :: Unique
fingerprintDataConKey :: Unique
wildCardKey :: Unique
absentErrorIdKey :: Unique
augmentIdKey :: Unique
appendIdKey :: Unique
buildIdKey :: Unique
errorIdKey :: Unique
foldrIdKey :: Unique
recSelErrorIdKey :: Unique
seqIdKey :: Unique
irrefutPatErrorIdKey :: Unique
eqStringIdKey :: Unique
noMethodBindingErrorIdKey :: Unique
nonExhaustiveGuardsErrorIdKey :: Unique
runtimeErrorIdKey :: Unique
patErrorIdKey :: Unique
voidPrimIdKey :: Unique
realWorldPrimIdKey :: Unique
recConErrorIdKey :: Unique
unpackCStringUtf8IdKey :: Unique
unpackCStringAppendIdKey :: Unique
unpackCStringFoldrIdKey :: Unique
unpackCStringIdKey :: Unique
unsafeCoerceIdKey :: Unique
concatIdKey :: Unique
filterIdKey :: Unique
zipIdKey :: Unique
bindIOIdKey :: Unique
returnIOIdKey :: Unique
newStablePtrIdKey :: Unique
printIdKey :: Unique
failIOIdKey :: Unique
nullAddrIdKey :: Unique
voidArgIdKey :: Unique
fstIdKey :: Unique
sndIdKey :: Unique
otherwiseIdKey :: Unique
assertIdKey :: Unique
runSTRepIdKey :: Unique
mkIntegerIdKey :: Unique
smallIntegerIdKey :: Unique
wordToIntegerIdKey :: Unique
integerToWordIdKey :: Unique
integerToIntIdKey :: Unique
integerToWord64IdKey :: Unique
integerToInt64IdKey :: Unique
word64ToIntegerIdKey :: Unique
int64ToIntegerIdKey :: Unique
plusIntegerIdKey :: Unique
timesIntegerIdKey :: Unique
minusIntegerIdKey :: Unique
negateIntegerIdKey :: Unique
eqIntegerPrimIdKey :: Unique
neqIntegerPrimIdKey :: Unique
absIntegerIdKey :: Unique
signumIntegerIdKey :: Unique
leIntegerPrimIdKey :: Unique
gtIntegerPrimIdKey :: Unique
ltIntegerPrimIdKey :: Unique
geIntegerPrimIdKey :: Unique
compareIntegerIdKey :: Unique
quotRemIntegerIdKey :: Unique
divModIntegerIdKey :: Unique
quotIntegerIdKey :: Unique
remIntegerIdKey :: Unique
divIntegerIdKey :: Unique
modIntegerIdKey :: Unique
floatFromIntegerIdKey :: Unique
doubleFromIntegerIdKey :: Unique
encodeFloatIntegerIdKey :: Unique
encodeDoubleIntegerIdKey :: Unique
decodeDoubleIntegerIdKey :: Unique
gcdIntegerIdKey :: Unique
lcmIntegerIdKey :: Unique
andIntegerIdKey :: Unique
orIntegerIdKey :: Unique
xorIntegerIdKey :: Unique
complementIntegerIdKey :: Unique
shiftLIntegerIdKey :: Unique
shiftRIntegerIdKey :: Unique
rootMainKey :: Unique
runMainKey :: Unique
thenIOIdKey :: Unique
lazyIdKey :: Unique
assertErrorIdKey :: Unique
oneShotKey :: Unique
breakpointIdKey :: Unique
breakpointCondIdKey :: Unique
breakpointAutoIdKey :: Unique
breakpointJumpIdKey :: Unique
breakpointCondJumpIdKey :: Unique
breakpointAutoJumpIdKey :: Unique
inlineIdKey :: Unique
mapIdKey :: Unique
groupWithIdKey :: Unique
dollarIdKey :: Unique
coercionTokenIdKey :: Unique
rationalToFloatIdKey :: Unique
rationalToDoubleIdKey :: Unique
unmarshalObjectIdKey :: Unique
marshalObjectIdKey :: Unique
marshalStringIdKey :: Unique
unmarshalStringIdKey :: Unique
checkDotnetResNameIdKey :: Unique
undefinedKey :: Unique
magicDictKey :: Unique
coerceKey :: Unique
unboundKey :: Unique
fromIntegerClassOpKey :: Unique
minusClassOpKey :: Unique
fromRationalClassOpKey :: Unique
enumFromClassOpKey :: Unique
enumFromThenClassOpKey :: Unique
enumFromToClassOpKey :: Unique
enumFromThenToClassOpKey :: Unique
eqClassOpKey :: Unique
geClassOpKey :: Unique
negateClassOpKey :: Unique
failMClassOpKey :: Unique
bindMClassOpKey :: Unique
thenMClassOpKey :: Unique
returnMClassOpKey :: Unique
fmapClassOpKey :: Unique
mfixIdKey :: Unique
arrAIdKey :: Unique
composeAIdKey :: Unique
firstAIdKey :: Unique
appAIdKey :: Unique
choiceAIdKey :: Unique
loopAIdKey :: Unique
fromStringClassOpKey :: Unique
toAnnotationWrapperIdKey :: Unique
fromIntegralIdKey :: Unique
realToFracIdKey :: Unique
toIntegerClassOpKey :: Unique
toRationalClassOpKey :: Unique
guardMIdKey :: Unique
liftMIdKey :: Unique
mzipIdKey :: Unique
ghciStepIoMClassOpKey :: Unique
isListClassKey :: Unique
fromListClassOpKey :: Unique
fromListNClassOpKey :: Unique
toListClassOpKey :: Unique
proxyHashKey :: Unique
mkTyConKey :: Unique
mkPolyTyConAppKey :: Unique
mkAppTyKey :: Unique
typeLitTypeRepKey :: Unique
numericClassKeys :: [Unique]
fractionalClassKeys :: [Unique]
standardClassKeys :: [Unique]
derivableClassKeys :: [Unique]
int8X16PrimTyConKey :: Unique
int16X8PrimTyConKey :: Unique
int32X4PrimTyConKey :: Unique
int64X2PrimTyConKey :: Unique
int8X32PrimTyConKey :: Unique
int16X16PrimTyConKey :: Unique
int32X8PrimTyConKey :: Unique
int64X4PrimTyConKey :: Unique
int8X64PrimTyConKey :: Unique
int16X32PrimTyConKey :: Unique
int32X16PrimTyConKey :: Unique
int64X8PrimTyConKey :: Unique
word8X16PrimTyConKey :: Unique
word16X8PrimTyConKey :: Unique
word32X4PrimTyConKey :: Unique
word64X2PrimTyConKey :: Unique
word8X32PrimTyConKey :: Unique
word16X16PrimTyConKey :: Unique
word32X8PrimTyConKey :: Unique
word64X4PrimTyConKey :: Unique
word8X64PrimTyConKey :: Unique
word16X32PrimTyConKey :: Unique
word32X16PrimTyConKey :: Unique
word64X8PrimTyConKey :: Unique
floatX4PrimTyConKey :: Unique
doubleX2PrimTyConKey :: Unique
floatX8PrimTyConKey :: Unique
doubleX4PrimTyConKey :: Unique
floatX16PrimTyConKey :: Unique
doubleX8PrimTyConKey :: Unique

module ApiAnnotation

-- | Retrieve a list of annotation <a>SrcSpan</a>s based on the
--   <a>SrcSpan</a> of the annotated AST element, and the known type of the
--   annotation.
getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]

-- | Retrieve a list of annotation <a>SrcSpan</a>s based on the
--   <a>SrcSpan</a> of the annotated AST element, and the known type of the
--   annotation. The list is removed from the annotations.
getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns)

-- | Retrieve the comments allocated to the current <a>SrcSpan</a>
--   
--   Note: A given <a>SrcSpan</a> may appear in multiple AST elements,
--   beware of duplicates
getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]

-- | Retrieve the comments allocated to the current <a>SrcSpan</a>, and
--   remove them from the annotations
getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns)
type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment])
type ApiAnnKey = (SrcSpan, 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 <tt><tt>pm_annotations</tt></tt> field of
--   <tt><a>ParsedModule</a></tt>. Comments are only retained if
--   <tt><tt>Opt_KeepRawTokenStream</tt></tt> is set in
--   <tt><a>DynFlags</a></tt> before parsing.
--   
--   The wiki page describing this feature is
--   <a>https://ghc.haskell.org/trac/ghc/wiki/ApiAnnotations</a>
--   
--   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
data AnnKeywordId
[AnnAs] :: AnnKeywordId
[AnnAt] :: AnnKeywordId

-- | <tt>!</tt>
[AnnBang] :: AnnKeywordId

-- | '`'
[AnnBackquote] :: AnnKeywordId
[AnnBy] :: AnnKeywordId

-- | case or lambda case
[AnnCase] :: AnnKeywordId
[AnnClass] :: AnnKeywordId

-- | '#)' or '#-}' etc
[AnnClose] :: AnnKeywordId

-- | '}'
[AnnCloseC] :: AnnKeywordId

-- | ')'
[AnnCloseP] :: AnnKeywordId

-- | ']'
[AnnCloseS] :: AnnKeywordId
[AnnColon] :: AnnKeywordId

-- | as a list separator
[AnnComma] :: AnnKeywordId

-- | in a RdrName for a tuple
[AnnCommaTuple] :: AnnKeywordId

-- | '=&gt;'
[AnnDarrow] :: AnnKeywordId
[AnnData] :: AnnKeywordId

-- | '::'
[AnnDcolon] :: AnnKeywordId
[AnnDefault] :: AnnKeywordId
[AnnDeriving] :: AnnKeywordId
[AnnDo] :: AnnKeywordId

-- | <a>.</a>
[AnnDot] :: AnnKeywordId

-- | '..'
[AnnDotdot] :: AnnKeywordId
[AnnElse] :: AnnKeywordId
[AnnEqual] :: AnnKeywordId
[AnnExport] :: AnnKeywordId
[AnnFamily] :: AnnKeywordId
[AnnForall] :: AnnKeywordId
[AnnForeign] :: AnnKeywordId

-- | for function name in matches where there are multiple equations for
--   the function.
[AnnFunId] :: AnnKeywordId
[AnnGroup] :: AnnKeywordId

-- | for CType
[AnnHeader] :: AnnKeywordId
[AnnHiding] :: AnnKeywordId
[AnnIf] :: AnnKeywordId
[AnnImport] :: AnnKeywordId
[AnnIn] :: AnnKeywordId

-- | 'infix' or 'infixl' or 'infixr'
[AnnInfix] :: AnnKeywordId
[AnnInstance] :: AnnKeywordId
[AnnLam] :: AnnKeywordId

-- | '&lt;-'
[AnnLarrow] :: AnnKeywordId
[AnnLet] :: AnnKeywordId
[AnnMdo] :: AnnKeywordId

-- | <a>-</a>
[AnnMinus] :: AnnKeywordId
[AnnModule] :: AnnKeywordId
[AnnNewtype] :: AnnKeywordId
[AnnOf] :: AnnKeywordId

-- | '(#' or '{-# LANGUAGE' etc
[AnnOpen] :: AnnKeywordId

-- | '{'
[AnnOpenC] :: AnnKeywordId

-- | '('
[AnnOpenP] :: AnnKeywordId

-- | '['
[AnnOpenS] :: AnnKeywordId
[AnnPackageName] :: AnnKeywordId
[AnnPattern] :: AnnKeywordId
[AnnProc] :: AnnKeywordId
[AnnQualified] :: AnnKeywordId

-- | '-&gt;'
[AnnRarrow] :: AnnKeywordId
[AnnRec] :: AnnKeywordId
[AnnRole] :: AnnKeywordId
[AnnSafe] :: AnnKeywordId

-- | ';'
[AnnSemi] :: AnnKeywordId

-- | <tt>static</tt>
[AnnStatic] :: AnnKeywordId
[AnnThen] :: AnnKeywordId

-- | '~'
[AnnTilde] :: AnnKeywordId

-- | <tt>~#</tt>
[AnnTildehsh] :: AnnKeywordId
[AnnType] :: AnnKeywordId

-- | '()' for types
[AnnUnit] :: AnnKeywordId
[AnnUsing] :: AnnKeywordId

-- | e.g. INTEGER
[AnnVal] :: AnnKeywordId

-- | String value, will need quotes when output
[AnnValStr] :: AnnKeywordId

-- | '|'
[AnnVbar] :: AnnKeywordId
[AnnWhere] :: AnnKeywordId

-- | <tt>-&lt;</tt>
[Annlarrowtail] :: AnnKeywordId

-- | '-&gt;'
[Annrarrowtail] :: AnnKeywordId

-- | <tt>-&lt;&lt;</tt>
[AnnLarrowtail] :: AnnKeywordId

-- | <tt>&gt;&gt;-</tt>
[AnnRarrowtail] :: AnnKeywordId
[AnnEofPos] :: AnnKeywordId
data AnnotationComment

-- | something beginning '-- |'
[AnnDocCommentNext] :: String -> AnnotationComment

-- | something beginning '-- ^'
[AnnDocCommentPrev] :: String -> AnnotationComment

-- | something beginning '-- $'
[AnnDocCommentNamed] :: String -> AnnotationComment

-- | a section heading
[AnnDocSection] :: Int -> String -> AnnotationComment

-- | doc options (prune, ignore-exports, etc)
[AnnDocOptions] :: String -> AnnotationComment

-- | doc options declared "-- # ..."-style
[AnnDocOptionsOld] :: String -> AnnotationComment

-- | comment starting by "--"
[AnnLineComment] :: String -> AnnotationComment

-- | comment in {- -}
[AnnBlockComment] :: String -> AnnotationComment

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnClose</a>,<a>AnnComma</a>, <a>AnnRarrow</a>,<a>AnnTildehsh</a>,
--   <a>AnnTilde</a></li>
--   <li>May have <a>AnnComma</a> when in a list</li>
--   </ul>
type LRdrName = Located RdrName
instance Show AnnotationComment
instance Data AnnotationComment
instance Ord AnnotationComment
instance Eq AnnotationComment
instance Show AnnKeywordId
instance Data AnnKeywordId
instance Ord AnnKeywordId
instance Eq AnnKeywordId
instance Outputable AnnKeywordId
instance Outputable AnnotationComment

module Lexer
data Token
[ITas] :: Token
[ITcase] :: Token
[ITclass] :: Token
[ITdata] :: Token
[ITdefault] :: Token
[ITderiving] :: Token
[ITdo] :: Token
[ITelse] :: Token
[IThiding] :: Token
[ITforeign] :: Token
[ITif] :: Token
[ITimport] :: Token
[ITin] :: Token
[ITinfix] :: Token
[ITinfixl] :: Token
[ITinfixr] :: Token
[ITinstance] :: Token
[ITlet] :: Token
[ITmodule] :: Token
[ITnewtype] :: Token
[ITof] :: Token
[ITqualified] :: Token
[ITthen] :: Token
[ITtype] :: Token
[ITwhere] :: Token
[ITforall] :: Token
[ITexport] :: Token
[ITlabel] :: Token
[ITdynamic] :: Token
[ITsafe] :: Token
[ITinterruptible] :: Token
[ITunsafe] :: Token
[ITstdcallconv] :: Token
[ITccallconv] :: Token
[ITcapiconv] :: Token
[ITprimcallconv] :: Token
[ITjavascriptcallconv] :: Token
[ITmdo] :: Token
[ITfamily] :: Token
[ITrole] :: Token
[ITgroup] :: Token
[ITby] :: Token
[ITusing] :: Token
[ITpattern] :: Token
[ITstatic] :: Token
[ITinline_prag] :: SourceText -> InlineSpec -> RuleMatchInfo -> Token
[ITspec_prag] :: SourceText -> Token
[ITspec_inline_prag] :: SourceText -> Bool -> Token
[ITsource_prag] :: SourceText -> Token
[ITrules_prag] :: SourceText -> Token
[ITwarning_prag] :: SourceText -> Token
[ITdeprecated_prag] :: SourceText -> Token
[ITline_prag] :: Token
[ITscc_prag] :: SourceText -> Token
[ITgenerated_prag] :: SourceText -> Token
[ITcore_prag] :: SourceText -> Token
[ITunpack_prag] :: SourceText -> Token
[ITnounpack_prag] :: SourceText -> Token
[ITann_prag] :: SourceText -> Token
[ITclose_prag] :: Token
[IToptions_prag] :: String -> Token
[ITinclude_prag] :: String -> Token
[ITlanguage_prag] :: Token
[ITvect_prag] :: SourceText -> Token
[ITvect_scalar_prag] :: SourceText -> Token
[ITnovect_prag] :: SourceText -> Token
[ITminimal_prag] :: SourceText -> Token
[IToverlappable_prag] :: SourceText -> Token
[IToverlapping_prag] :: SourceText -> Token
[IToverlaps_prag] :: SourceText -> Token
[ITincoherent_prag] :: SourceText -> Token
[ITctype] :: SourceText -> Token
[ITdotdot] :: Token
[ITcolon] :: Token
[ITdcolon] :: Token
[ITequal] :: Token
[ITlam] :: Token
[ITlcase] :: Token
[ITvbar] :: Token
[ITlarrow] :: Token
[ITrarrow] :: Token
[ITat] :: Token
[ITtilde] :: Token
[ITtildehsh] :: Token
[ITdarrow] :: Token
[ITminus] :: Token
[ITbang] :: Token
[ITstar] :: Token
[ITdot] :: Token
[ITbiglam] :: Token
[ITocurly] :: Token
[ITccurly] :: Token
[ITvocurly] :: Token
[ITvccurly] :: Token
[ITobrack] :: Token
[ITopabrack] :: Token
[ITcpabrack] :: Token
[ITcbrack] :: Token
[IToparen] :: Token
[ITcparen] :: Token
[IToubxparen] :: Token
[ITcubxparen] :: Token
[ITsemi] :: Token
[ITcomma] :: Token
[ITunderscore] :: Token
[ITbackquote] :: Token
[ITsimpleQuote] :: Token
[ITvarid] :: FastString -> Token
[ITconid] :: FastString -> Token
[ITvarsym] :: FastString -> Token
[ITconsym] :: FastString -> Token
[ITqvarid] :: (FastString, FastString) -> Token
[ITqconid] :: (FastString, FastString) -> Token
[ITqvarsym] :: (FastString, FastString) -> Token
[ITqconsym] :: (FastString, FastString) -> Token
[ITprefixqvarsym] :: (FastString, FastString) -> Token
[ITprefixqconsym] :: (FastString, FastString) -> Token
[ITdupipvarid] :: FastString -> Token
[ITchar] :: SourceText -> Char -> Token
[ITstring] :: SourceText -> FastString -> Token
[ITinteger] :: SourceText -> Integer -> Token
[ITrational] :: FractionalLit -> Token
[ITprimchar] :: SourceText -> Char -> Token
[ITprimstring] :: SourceText -> ByteString -> Token
[ITprimint] :: SourceText -> Integer -> Token
[ITprimword] :: SourceText -> Integer -> Token
[ITprimfloat] :: FractionalLit -> Token
[ITprimdouble] :: FractionalLit -> Token
[ITopenExpQuote] :: Token
[ITopenPatQuote] :: Token
[ITopenDecQuote] :: Token
[ITopenTypQuote] :: Token
[ITcloseQuote] :: Token
[ITopenTExpQuote] :: Token
[ITcloseTExpQuote] :: Token
[ITidEscape] :: FastString -> Token
[ITparenEscape] :: Token
[ITidTyEscape] :: FastString -> Token
[ITparenTyEscape] :: Token
[ITtyQuote] :: Token
[ITquasiQuote] :: (FastString, FastString, RealSrcSpan) -> Token
[ITqQuasiQuote] :: (FastString, FastString, FastString, RealSrcSpan) -> Token
[ITproc] :: Token
[ITrec] :: Token
[IToparenbar] :: Token
[ITcparenbar] :: Token
[ITlarrowtail] :: Token
[ITrarrowtail] :: Token
[ITLarrowtail] :: Token
[ITRarrowtail] :: Token
[ITunknown] :: String -> Token
[ITeof] :: Token
[ITdocCommentNext] :: String -> Token
[ITdocCommentPrev] :: String -> Token
[ITdocCommentNamed] :: String -> Token
[ITdocSection] :: Int -> String -> Token
[ITdocOptions] :: String -> Token
[ITdocOptionsOld] :: String -> Token
[ITlineComment] :: String -> Token
[ITblockComment] :: String -> Token
lexer :: Bool -> (Located Token -> P a) -> P a
pragState :: DynFlags -> StringBuffer -> RealSrcLoc -> PState
mkPState :: DynFlags -> StringBuffer -> RealSrcLoc -> PState
data PState
[PState] :: StringBuffer -> DynFlags -> Messages -> Maybe Token -> RealSrcSpan -> !Int -> RealSrcLoc -> !ExtsBitmap -> [LayoutContext] -> [Int] -> [FastString] -> [RealLocated Token] -> Maybe (RealLocated Token) -> RealSrcSpan -> [ALRContext] -> Maybe ALRLayout -> Bool -> [(ApiAnnKey, [SrcSpan])] -> [Located AnnotationComment] -> [(SrcSpan, [Located AnnotationComment])] -> PState
[buffer] :: PState -> StringBuffer
[dflags] :: PState -> DynFlags
[messages] :: PState -> Messages
[last_tk] :: PState -> Maybe Token
[last_loc] :: PState -> RealSrcSpan
[last_len] :: PState -> !Int
[loc] :: PState -> RealSrcLoc
[extsBitmap] :: PState -> !ExtsBitmap
[context] :: PState -> [LayoutContext]
[lex_state] :: PState -> [Int]
[srcfiles] :: PState -> [FastString]
[alr_pending_implicit_tokens] :: PState -> [RealLocated Token]
[alr_next_token] :: PState -> Maybe (RealLocated Token)
[alr_last_loc] :: PState -> RealSrcSpan
[alr_context] :: PState -> [ALRContext]
[alr_expecting_ocurly] :: PState -> Maybe ALRLayout
[alr_justClosedExplicitLetBlock] :: PState -> Bool
[annotations] :: PState -> [(ApiAnnKey, [SrcSpan])]
[comment_q] :: PState -> [Located AnnotationComment]
[annotations_comments] :: PState -> [(SrcSpan, [Located AnnotationComment])]
newtype P a
[P] :: (PState -> ParseResult a) -> P a
[unP] :: P a -> PState -> ParseResult a
data ParseResult a
[POk] :: PState -> a -> ParseResult a
[PFailed] :: SrcSpan -> MsgDoc -> ParseResult a
getSrcLoc :: P RealSrcLoc
getPState :: P PState
getDynFlags :: HasDynFlags m => m DynFlags
withThisPackage :: (PackageKey -> a) -> P a
failLocMsgP :: RealSrcLoc -> RealSrcLoc -> String -> P a
failSpanMsgP :: SrcSpan -> SDoc -> P a
srcParseFail :: P a
getMessages :: PState -> Messages
popContext :: P ()
pushCurrentContext :: P ()
setLastToken :: RealSrcSpan -> Int -> P ()
setSrcLoc :: RealSrcLoc -> P ()
activeContext :: P Bool
nextIsEOF :: P Bool
getLexState :: P Int
popLexState :: P Int
pushLexState :: Int -> P ()
extension :: (ExtsBitmap -> Bool) -> P Bool
bangPatEnabled :: ExtsBitmap -> Bool
datatypeContextsEnabled :: ExtsBitmap -> Bool
traditionalRecordSyntaxEnabled :: ExtsBitmap -> Bool
explicitForallEnabled :: ExtsBitmap -> Bool
inRulePrag :: ExtsBitmap -> Bool
explicitNamespacesEnabled :: ExtsBitmap -> Bool
patternSynonymsEnabled :: ExtsBitmap -> Bool
sccProfilingOn :: ExtsBitmap -> Bool
hpcEnabled :: ExtsBitmap -> Bool
addWarning :: WarningFlag -> SrcSpan -> SDoc -> P ()
lexTokenStream :: StringBuffer -> RealSrcLoc -> DynFlags -> ParseResult [Located Token]
addAnnotation :: SrcSpan -> AnnKeywordId -> SrcSpan -> P ()

-- | Encapsulated call to addAnnotation, requiring only the SrcSpan of the
--   AST element the annotation belongs to
type AddAnn = SrcSpan -> P ()

-- | Given a <a>SrcSpan</a> that surrounds a <tt>HsPar</tt> or
--   <tt>HsParTy</tt>, generate <a>AddAnn</a> values for the opening and
--   closing bordering on the start and end of the span
mkParensApiAnn :: SrcSpan -> [AddAnn]
instance Enum ExtBits
instance Show LayoutContext
instance Show Token
instance Outputable Token
instance Functor P
instance Applicative P
instance Monad P
instance HasDynFlags P
instance Functor AlexLastAcc


-- | Package manipulation
module Packages
data PackageState

-- | Call this after <a>parseDynFlags</a>. It reads the package database
--   files, and sets up various internal tables of package information,
--   according to the package-related flags on the command-line
--   (<tt>-package</tt>, <tt>-hide-package</tt> etc.)
--   
--   Returns a list of packages to link in if we're doing dynamic linking.
--   This list contains the packages that the user explicitly mentioned
--   with <tt>-package</tt> flags.
--   
--   <a>initPackages</a> can be called again subsequently after updating
--   the <a>packageFlags</a> field of the <a>DynFlags</a>, and it will
--   update the <a>pkgState</a> in <a>DynFlags</a> and return a list of
--   packages to link in.
initPackages :: DynFlags -> IO (DynFlags, [PackageKey])
readPackageConfigs :: DynFlags -> IO [PackageConfig]
getPackageConfRefs :: DynFlags -> IO [PkgConfRef]
resolvePackageConfig :: DynFlags -> PkgConfRef -> IO (Maybe FilePath)
readPackageConfig :: DynFlags -> FilePath -> IO [PackageConfig]

-- | Find the package we know about with the given key (e.g.
--   <tt>foo_HASH</tt>), if any
lookupPackage :: DynFlags -> PackageKey -> Maybe PackageConfig

-- | Looks up a <a>PackageKey</a> given an <a>InstalledPackageId</a>
resolveInstalledPackageId :: DynFlags -> InstalledPackageId -> PackageKey

-- | Search for packages with a given package ID (e.g. "foo-0.1")
searchPackageId :: DynFlags -> SourcePackageId -> [PackageConfig]

-- | Looks up the package with the given id in the package state, panicing
--   if it is not found
getPackageDetails :: DynFlags -> PackageKey -> PackageConfig
listVisibleModuleNames :: DynFlags -> [ModuleName]

-- | Takes a <a>ModuleName</a>, and if the module is in any package returns
--   list of modules which take that name.
lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(Module, PackageConfig)]
lookupModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult

-- | The result of performing a lookup
data LookupResult

-- | Found the module uniquely, nothing else to do
[LookupFound] :: Module -> PackageConfig -> LookupResult

-- | Multiple modules with the same name in scope
[LookupMultiple] :: [(Module, ModuleOrigin)] -> LookupResult

-- | No modules found, but there were some hidden ones with an exact name
--   match. First is due to package hidden, second is due to module being
--   hidden
[LookupHidden] :: [(Module, ModuleOrigin)] -> [(Module, ModuleOrigin)] -> LookupResult

-- | Nothing found, here are some suggested different names
[LookupNotFound] :: [ModuleSuggestion] -> LookupResult
data ModuleSuggestion
[SuggestVisible] :: ModuleName -> Module -> ModuleOrigin -> ModuleSuggestion
[SuggestHidden] :: ModuleName -> Module -> ModuleOrigin -> ModuleSuggestion

-- | Package state is all stored in <a>DynFlags</a>, including the details
--   of all packages, which packages are exposed, and which modules they
--   provide.
--   
--   The package state is computed by <a>initPackages</a>, and kept in
--   DynFlags. It is influenced by various package flags:
--   
--   <ul>
--   <li><tt>-package <a>pkg</a></tt> and <tt>-package-id <a>pkg</a></tt>
--   cause <tt><a>pkg</a></tt> to become exposed. If
--   <tt>-hide-all-packages</tt> was not specified, these commands also
--   cause all other packages with the same name to become hidden.</li>
--   <li><tt>-hide-package <a>pkg</a></tt> causes <tt><a>pkg</a></tt> to
--   become hidden.</li>
--   <li>(there are a few more flags, check below for their semantics)</li>
--   </ul>
--   
--   The package state has the following properties.
--   
--   <ul>
--   <li>Let <tt>exposedPackages</tt> be the set of packages thus exposed.
--   Let <tt>depExposedPackages</tt> be the transitive closure from
--   <tt>exposedPackages</tt> of their dependencies.</li>
--   <li>When searching for a module from an preload import declaration,
--   only the exposed modules in <tt>exposedPackages</tt> are valid.</li>
--   <li>When searching for a module from an implicit import, all modules
--   from <tt>depExposedPackages</tt> are valid.</li>
--   <li>When linking in a compilation manager mode, we link in packages
--   the program depends on (the compiler knows this list by the time it
--   gets to the link step). Also, we link in all packages which were
--   mentioned with preload <tt>-package</tt> flags on the command-line, or
--   are a transitive dependency of same, or are "base"/"rts". The reason
--   for this is that we might need packages which don't contain any
--   Haskell modules, and therefore won't be discovered by the normal
--   mechanism of dependency tracking.</li>
--   </ul>
--   
--   Given a module name, there may be multiple ways it came into scope,
--   possibly simultaneously. This data type tracks all the possible ways
--   it could have come into scope. Warning: don't use the record
--   functions, they're partial!
data ModuleOrigin

-- | Module is hidden, and thus never will be available for import. (But
--   maybe the user didn't realize), so we'll still keep track of these
--   modules.)
[ModHidden] :: ModuleOrigin

-- | Module is public, and could have come from some places.
[ModOrigin] :: Maybe Bool -> [PackageConfig] -> [PackageConfig] -> Bool -> ModuleOrigin

-- | <tt>Just False</tt> means that this module is in someone's
--   <tt>exported-modules</tt> list, but that package is hidden; <tt>Just
--   True</tt> means that it is available; <tt>Nothing</tt> means neither
--   applies.
[fromOrigPackage] :: ModuleOrigin -> Maybe Bool

-- | Is the module available from a reexport of an exposed package? There
--   could be multiple.
[fromExposedReexport] :: ModuleOrigin -> [PackageConfig]

-- | Is the module available from a reexport of a hidden package?
[fromHiddenReexport] :: ModuleOrigin -> [PackageConfig]

-- | Did the module export come from a package flag? (ToDo: track more
--   information.
[fromPackageFlag] :: ModuleOrigin -> Bool

-- | Find all the include directories in these and the preload packages
getPackageIncludePath :: DynFlags -> [PackageKey] -> IO [String]

-- | Find all the library paths in these and the preload packages
getPackageLibraryPath :: DynFlags -> [PackageKey] -> IO [String]

-- | Find all the link options in these and the preload packages, returning
--   (package hs lib options, extra library options, other flags)
getPackageLinkOpts :: DynFlags -> [PackageKey] -> IO ([String], [String], [String])

-- | Find all the C-compiler options in these and the preload packages
getPackageExtraCcOpts :: DynFlags -> [PackageKey] -> IO [String]

-- | Find all the package framework paths in these and the preload packages
getPackageFrameworkPath :: DynFlags -> [PackageKey] -> IO [String]

-- | Find all the package frameworks in these and the preload packages
getPackageFrameworks :: DynFlags -> [PackageKey] -> IO [String]

-- | Find all the <a>PackageConfig</a> in both the preload packages from
--   <a>DynFlags</a> and corresponding to the list of <a>PackageConfig</a>s
getPreloadPackagesAnd :: DynFlags -> [PackageKey] -> IO [PackageConfig]
collectIncludeDirs :: [PackageConfig] -> [FilePath]
collectLibraryPaths :: [PackageConfig] -> [FilePath]
collectLinkOpts :: DynFlags -> [PackageConfig] -> ([String], [String], [String])
packageHsLibs :: DynFlags -> PackageConfig -> [String]
packageKeyPackageIdString :: DynFlags -> PackageKey -> String
pprFlag :: PackageFlag -> SDoc

-- | Show (very verbose) package info
pprPackages :: DynFlags -> SDoc

-- | Show simplified package info.
--   
--   The idea is to only print package id, and any information that might
--   be different from the package databases (exposure, trust)
pprPackagesSimple :: DynFlags -> SDoc

-- | Show the mapping of modules to where they come from.
pprModuleMap :: DynFlags -> SDoc

-- | Will the <a>Name</a> come from a dynamically linked library?
isDllName :: DynFlags -> PackageKey -> Module -> Name -> Bool
instance Outputable ModuleOrigin
instance Monoid ModuleOrigin

module SysTools
initSysTools :: Maybe String -> IO Settings
runUnlit :: DynFlags -> [Option] -> IO ()
runCpp :: DynFlags -> [Option] -> IO ()
runCc :: DynFlags -> [Option] -> IO ()
runPp :: DynFlags -> [Option] -> IO ()
runSplit :: DynFlags -> [Option] -> IO ()
runAs :: DynFlags -> [Option] -> IO ()
runLink :: DynFlags -> [Option] -> IO ()
runLibtool :: DynFlags -> [Option] -> IO ()
runMkDLL :: DynFlags -> [Option] -> IO ()
runWindres :: DynFlags -> [Option] -> IO ()

-- | Run the LLVM Optimiser
runLlvmOpt :: DynFlags -> [Option] -> IO ()

-- | Run the LLVM Compiler
runLlvmLlc :: DynFlags -> [Option] -> IO ()

-- | Run the clang compiler (used as an assembler for the LLVM backend on
--   OS X as LLVM doesn't support the OS X system assembler)
runClang :: DynFlags -> [Option] -> IO ()

-- | Figure out which version of LLVM we are running this session
figureLlvmVersion :: DynFlags -> IO (Maybe Int)

-- | read the contents of the named section in an ELF object as a String.
readElfSection :: DynFlags -> String -> FilePath -> IO (Maybe String)
getLinkerInfo :: DynFlags -> IO LinkerInfo
getCompilerInfo :: DynFlags -> IO CompilerInfo
linkDynLib :: DynFlags -> [String] -> [PackageKey] -> IO ()
askCc :: DynFlags -> [Option] -> IO String
touch :: DynFlags -> String -> String -> IO ()
copy :: DynFlags -> String -> FilePath -> FilePath -> IO ()
copyWithHeader :: DynFlags -> String -> Maybe String -> FilePath -> FilePath -> IO ()
setTmpDir :: FilePath -> DynFlags -> DynFlags
newTempName :: DynFlags -> Suffix -> IO FilePath
newTempLibName :: DynFlags -> Suffix -> IO (FilePath, FilePath, String)
cleanTempDirs :: DynFlags -> IO ()
cleanTempFiles :: DynFlags -> IO ()
cleanTempFilesExcept :: DynFlags -> [FilePath] -> IO ()
addFilesToClean :: DynFlags -> [FilePath] -> IO ()

-- | When invoking external tools as part of the compilation pipeline, we
--   pass these a sequence of options on the command-line. Rather than just
--   using a list of Strings, we use a type that allows us to distinguish
--   between filepaths and 'other stuff'. The reason for this is that this
--   type gives us a handle on transforming filenames, and filenames only,
--   to whatever format they're expected to be on a particular platform.
data Option
[FileOption] :: String -> String -> Option
[Option] :: String -> Option


-- | Support for source code annotation feature of GHC. That is the ANN
--   pragma.
--   
--   (c) The University of Glasgow 2006 (c) The GRASP/AQUA Project, Glasgow
--   University, 1992-1998
module Annotations

-- | Represents an annotation after it has been sufficiently desugared from
--   it's initial form of <a>AnnDecl</a>
data Annotation
[Annotation] :: CoreAnnTarget -> AnnPayload -> Annotation

-- | The target of the annotation
[ann_target] :: Annotation -> CoreAnnTarget
[ann_value] :: Annotation -> AnnPayload
type AnnPayload = Serialized  The "payload" of an annotation allows recovery of its value at a given type, and can be persisted to an interface file

-- | An annotation target
data AnnTarget name

-- | We are annotating something with a name: a type or identifier
[NamedTarget] :: name -> AnnTarget name

-- | We are annotating a particular module
[ModuleTarget] :: Module -> AnnTarget name

-- | The kind of annotation target found in the middle end of the compiler
type CoreAnnTarget = AnnTarget Name

-- | Get the <tt>name</tt> of an annotation target if it exists.
getAnnTargetName_maybe :: AnnTarget name -> Maybe name

-- | A collection of annotations Can't use a type synonym or we hit bug
--   #2412 due to source import
data AnnEnv

-- | Construct a new annotation environment that contains the list of
--   annotations provided.
mkAnnEnv :: [Annotation] -> AnnEnv

-- | Add the given annotation to the environment.
extendAnnEnvList :: AnnEnv -> [Annotation] -> AnnEnv

-- | Union two annotation environments.
plusAnnEnv :: AnnEnv -> AnnEnv -> AnnEnv

-- | An empty annotation environment.
emptyAnnEnv :: AnnEnv

-- | Find the annotations attached to the given target as <a>Typeable</a>
--   values of your choice. If no deserializer is specified, only transient
--   annotations will be returned.
findAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> CoreAnnTarget -> [a]

-- | Deserialize all annotations of a given type. This happens lazily, that
--   is no deserialization will take place until the [a] is actually
--   demanded and the [a] can also be empty (the UniqFM is not filtered).
deserializeAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> UniqFM [a]
instance Functor AnnTarget
instance Uniquable name => Uniquable (AnnTarget name)
instance Outputable name => Outputable (AnnTarget name)
instance Binary name => Binary (AnnTarget name)
instance Outputable Annotation


-- | GHC uses several kinds of name internally:
--   
--   <ul>
--   <li><a>OccName</a>: see <a>OccName#name_types</a></li>
--   <li><a>RdrName</a>: see <a>RdrName#name_types</a></li>
--   <li><a>Name</a>: see <a>Name#name_types</a></li>
--   <li><a>Id</a>: see <a>Id#name_types</a></li>
--   <li><a>Var</a> is a synonym for the <a>Id</a> type but it may
--   additionally potentially contain type variables, which have a
--   <a>Kind</a> rather than a <a>Type</a> and only contain some extra
--   details during typechecking.</li>
--   </ul>
--   
--   These <a>Var</a> names may either be global or local, see
--   <a>Var#globalvslocal</a>
--   
--   Global <a>Id</a>s and <a>Var</a>s are those that are imported or
--   correspond to a data constructor, primitive operation, or record
--   selectors. Local <a>Id</a>s and <a>Var</a>s are those bound within an
--   expression (e.g. by a lambda) or at the top level of the module being
--   compiled.
module Var

-- | Essentially a typed <a>Name</a>, that may also contain some additional
--   information about the <a>Var</a> and it's use sites.
data Var
type CoVar = Id
type Id = Var
type DictId = EvId
type DFunId = Id
type EvVar = EvId
type EqVar = EvId
type EvId = Id
type IpId = EvId
type TyVar = Var
type TypeVar = Var
type KindVar = Var
type TKVar = Var
varName :: Var -> Name
varUnique :: Var -> Unique

-- | The type or kind of the <a>Var</a> in question
varType :: Var -> Kind
setVarName :: Var -> Name -> Var
setVarUnique :: Var -> Unique -> Var
setVarType :: Id -> Type -> Id
mkGlobalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
mkLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id

-- | Exported <a>Var</a>s will not be removed as dead code
mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
mkCoVar :: Name -> Type -> CoVar
idInfo :: Id -> IdInfo
idDetails :: Id -> IdDetails
lazySetIdInfo :: Id -> IdInfo -> Var
setIdDetails :: Id -> IdDetails -> Id

-- | If it's a local, make it global
globaliseId :: Id -> Id

-- | Exports the given local <a>Id</a>. Can also be called on global
--   <a>Id</a>s, such as data constructors and class operations, which are
--   born as global <a>Id</a>s and automatically exported
setIdExported :: Id -> Id

-- | We can only do this to LocalIds
setIdNotExported :: Id -> Id
isId :: Var -> Bool
isTKVar :: Var -> Bool
isTyVar :: Var -> Bool
isTcTyVar :: Var -> Bool

-- | <a>isLocalVar</a> returns <tt>True</tt> for type variables as well as
--   local <a>Id</a>s These are the variables that we need to pay attention
--   to when finding free variables, or doing dependency analysis.
isLocalVar :: Var -> Bool
isLocalId :: Var -> Bool
isGlobalId :: Var -> Bool

-- | <tt>isExportedIdVar</tt> means "don't throw this away"
isExportedId :: Var -> Bool

-- | <a>mustHaveLocalBinding</a> returns <tt>True</tt> of <a>Id</a>s and
--   <a>TyVar</a>s that must have a binding in this module. The converse is
--   not quite right: there are some global <a>Id</a>s that must have
--   bindings, such as record selectors. But that doesn't matter, because
--   it's only used for assertions
mustHaveLocalBinding :: Var -> Bool
mkTyVar :: Name -> Kind -> TyVar
mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar
mkKindVar :: Name -> SuperKind -> KindVar
tyVarName :: TyVar -> Name
tyVarKind :: TyVar -> Kind
tcTyVarDetails :: TyVar -> TcTyVarDetails
setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar
setTyVarName :: TyVar -> Name -> TyVar
setTyVarUnique :: TyVar -> Unique -> TyVar
setTyVarKind :: TyVar -> Kind -> TyVar
updateTyVarKind :: (Kind -> Kind) -> TyVar -> TyVar
updateTyVarKindM :: (Monad m) => (Kind -> m Kind) -> TyVar -> m TyVar
instance Outputable Var
instance NamedThing Var
instance Uniquable Var
instance Eq Var
instance Ord Var
instance Data Var

module CostCentre

-- | A Cost Centre is a single <tt>{--}</tt> annotation.
data CostCentre
[NormalCC] :: {-# UNPACK #-} !Int -> CcName -> Module -> SrcSpan -> IsCafCC -> CostCentre

-- | Two cost centres may have the same name and module but different
--   SrcSpans, so we need a way to distinguish them easily and give them
--   different object-code labels. So every CostCentre has a Unique that is
--   distinct from every other CostCentre in the same module.
--   
--   XXX: should really be using Unique here, but we need to derive Data
--   below and there's no Data instance for Unique.
[cc_key] :: CostCentre -> {-# UNPACK #-} !Int

-- | Name of the cost centre itself
[cc_name] :: CostCentre -> CcName

-- | Name of module defining this CC.
[cc_mod] :: CostCentre -> Module
[cc_loc] :: CostCentre -> SrcSpan
[cc_is_caf] :: CostCentre -> IsCafCC
[AllCafsCC] :: Module -> SrcSpan -> CostCentre

-- | Name of module defining this CC.
[cc_mod] :: CostCentre -> Module
[cc_loc] :: CostCentre -> SrcSpan
type CcName = FastString
data IsCafCC
[NotCafCC] :: IsCafCC
[CafCC] :: IsCafCC

-- | A Cost Centre Stack is something that can be attached to a closure.
--   This is either:
--   
--   <ul>
--   <li>the current cost centre stack (CCCS)</li>
--   <li>a pre-defined cost centre stack (there are several pre-defined
--   CCSs, see below).</li>
--   </ul>
data CostCentreStack
type CollectedCCs = ([CostCentre], [CostCentre], [CostCentreStack])
noCCS :: CostCentreStack
currentCCS :: CostCentreStack
dontCareCCS :: CostCentreStack
noCCSAttached :: CostCentreStack -> Bool
isCurrentCCS :: CostCentreStack -> Bool
maybeSingletonCCS :: CostCentreStack -> Maybe CostCentre
mkUserCC :: FastString -> Module -> SrcSpan -> Unique -> CostCentre
mkAutoCC :: Id -> Module -> IsCafCC -> CostCentre
mkAllCafsCC :: Module -> SrcSpan -> CostCentre
mkSingletonCCS :: CostCentre -> CostCentreStack
isCafCCS :: CostCentreStack -> Bool
isCafCC :: CostCentre -> Bool

-- | Is this a cost-centre which records scc counts
isSccCountCC :: CostCentre -> Bool

-- | Is this a cost-centre which can be sccd ?
sccAbleCC :: CostCentre -> Bool
ccFromThisModule :: CostCentre -> Module -> Bool
pprCostCentreCore :: CostCentre -> SDoc
costCentreUserName :: CostCentre -> String
costCentreUserNameFS :: CostCentre -> FastString
costCentreSrcSpan :: CostCentre -> SrcSpan
cmpCostCentre :: CostCentre -> CostCentre -> Ordering
instance Ord CostCentreStack
instance Eq CostCentreStack
instance Data CostCentre
instance Data IsCafCC
instance Ord IsCafCC
instance Eq IsCafCC
instance Eq CostCentre
instance Ord CostCentre
instance Outputable CostCentreStack
instance Outputable CostCentre
instance Binary IsCafCC
instance Binary CostCentre

module Class
data Class
type ClassOpItem = (Id, DefMeth)
data DefMeth
[NoDefMeth] :: DefMeth
[DefMeth] :: Name -> DefMeth
[GenDefMeth] :: Name -> DefMeth
data ClassATItem
[ATI] :: TyCon -> (Maybe Type) -> ClassATItem
type ClassMinimalDef = BooleanFormula Name

-- | Convert a <a>DefMethSpec</a> to a <a>DefMeth</a>, which discards the
--   name field in the <a>DefMeth</a> constructor of the <a>DefMeth</a>.
defMethSpecOfDefMeth :: DefMeth -> DefMethSpec
type FunDep a = ([a], [a])
pprFundeps :: Outputable a => [FunDep a] -> SDoc
pprFunDep :: Outputable a => FunDep a -> SDoc
mkClass :: [TyVar] -> [([TyVar], [TyVar])] -> [PredType] -> [Id] -> [ClassATItem] -> [ClassOpItem] -> ClassMinimalDef -> TyCon -> Class
classTyVars :: Class -> [TyVar]
classArity :: Class -> Arity
classKey :: Class -> Unique
className :: Class -> Name
classATs :: Class -> [TyCon]
classATItems :: Class -> [ClassATItem]
classTyCon :: Class -> TyCon
classMethods :: Class -> [Id]
classOpItems :: Class -> [ClassOpItem]
classBigSig :: Class -> ([TyVar], [PredType], [Id], [ClassOpItem])
classExtraBigSig :: Class -> ([TyVar], [FunDep TyVar], [PredType], [Id], [ClassATItem], [ClassOpItem])
classTvsFds :: Class -> ([TyVar], [FunDep TyVar])
classSCTheta :: Class -> [PredType]
classAllSelIds :: Class -> [Id]
classSCSelId :: Class -> Int -> Id
classMinimalDef :: Class -> ClassMinimalDef
instance Eq DefMeth
instance Eq Class
instance Ord Class
instance Uniquable Class
instance NamedThing Class
instance Outputable Class
instance Outputable DefMeth
instance Data Class

module VarSet
type VarSet = UniqSet Var
type IdSet = UniqSet Id
type TyVarSet = UniqSet TyVar
type CoVarSet = UniqSet CoVar
emptyVarSet :: VarSet
unitVarSet :: Var -> VarSet
mkVarSet :: [Var] -> VarSet
extendVarSet :: VarSet -> Var -> VarSet
extendVarSetList :: VarSet -> [Var] -> VarSet
extendVarSet_C :: (Var -> Var -> Var) -> VarSet -> Var -> VarSet
elemVarSet :: Var -> VarSet -> Bool
varSetElems :: VarSet -> [Var]
subVarSet :: VarSet -> VarSet -> Bool
unionVarSet :: VarSet -> VarSet -> VarSet
unionVarSets :: [VarSet] -> VarSet

-- | map the function oer the list, and union the results
mapUnionVarSet :: (a -> VarSet) -> [a] -> VarSet
intersectVarSet :: VarSet -> VarSet -> VarSet
intersectsVarSet :: VarSet -> VarSet -> Bool
disjointVarSet :: VarSet -> VarSet -> Bool
isEmptyVarSet :: VarSet -> Bool
delVarSet :: VarSet -> Var -> VarSet
delVarSetList :: VarSet -> [Var] -> VarSet
delVarSetByKey :: VarSet -> Unique -> VarSet
minusVarSet :: VarSet -> VarSet -> VarSet
foldVarSet :: (Var -> a -> a) -> a -> VarSet -> a
filterVarSet :: (Var -> Bool) -> VarSet -> VarSet
fixVarSet :: (VarSet -> VarSet) -> VarSet -> VarSet
lookupVarSet :: VarSet -> Var -> Maybe Var
mapVarSet :: (Var -> Var) -> VarSet -> VarSet
sizeVarSet :: VarSet -> Int
seqVarSet :: VarSet -> ()
elemVarSetByKey :: Unique -> VarSet -> Bool
partitionVarSet :: (Var -> Bool) -> VarSet -> (VarSet, VarSet)

module VarEnv
type VarEnv elt = UniqFM elt
type IdEnv elt = VarEnv elt
type TyVarEnv elt = VarEnv elt
type CoVarEnv elt = VarEnv elt
emptyVarEnv :: VarEnv a
unitVarEnv :: Var -> a -> VarEnv a
mkVarEnv :: [(Var, a)] -> VarEnv a
elemVarEnv :: Var -> VarEnv a -> Bool
varEnvElts :: VarEnv a -> [a]
varEnvKeys :: VarEnv a -> [Unique]
extendVarEnv :: VarEnv a -> Var -> a -> VarEnv a
extendVarEnv_C :: (a -> a -> a) -> VarEnv a -> Var -> a -> VarEnv a
extendVarEnv_Acc :: (a -> b -> b) -> (a -> b) -> VarEnv b -> Var -> a -> VarEnv b
extendVarEnvList :: VarEnv a -> [(Var, a)] -> VarEnv a
plusVarEnv :: VarEnv a -> VarEnv a -> VarEnv a
plusVarEnv_C :: (a -> a -> a) -> VarEnv a -> VarEnv a -> VarEnv a
plusVarEnv_CD :: (a -> a -> a) -> VarEnv a -> a -> VarEnv a -> a -> VarEnv a
alterVarEnv :: (Maybe a -> Maybe a) -> VarEnv a -> Var -> VarEnv a
delVarEnvList :: VarEnv a -> [Var] -> VarEnv a
delVarEnv :: VarEnv a -> Var -> VarEnv a
minusVarEnv :: VarEnv a -> VarEnv b -> VarEnv a
intersectsVarEnv :: VarEnv a -> VarEnv a -> Bool
lookupVarEnv :: VarEnv a -> Var -> Maybe a
lookupVarEnv_NF :: VarEnv a -> Var -> a
lookupWithDefaultVarEnv :: VarEnv a -> a -> Var -> a
mapVarEnv :: (a -> b) -> VarEnv a -> VarEnv b
zipVarEnv :: [Var] -> [a] -> VarEnv a
modifyVarEnv :: (a -> a) -> VarEnv a -> Var -> VarEnv a
modifyVarEnv_Directly :: (a -> a) -> UniqFM a -> Unique -> UniqFM a
isEmptyVarEnv :: VarEnv a -> Bool
foldVarEnv :: (a -> b -> b) -> b -> VarEnv a -> b
elemVarEnvByKey :: Unique -> VarEnv a -> Bool
lookupVarEnv_Directly :: VarEnv a -> Unique -> Maybe a
filterVarEnv :: (a -> Bool) -> VarEnv a -> VarEnv a
filterVarEnv_Directly :: (Unique -> a -> Bool) -> VarEnv a -> VarEnv a
restrictVarEnv :: VarEnv a -> VarSet -> VarEnv a
partitionVarEnv :: (a -> Bool) -> VarEnv a -> (VarEnv a, VarEnv a)

-- | A set of variables that are in scope at some point
data InScopeSet
emptyInScopeSet :: InScopeSet
mkInScopeSet :: VarEnv Var -> InScopeSet
delInScopeSet :: InScopeSet -> Var -> InScopeSet
extendInScopeSet :: InScopeSet -> Var -> InScopeSet
extendInScopeSetList :: InScopeSet -> [Var] -> InScopeSet
extendInScopeSetSet :: InScopeSet -> VarEnv Var -> InScopeSet
getInScopeVars :: InScopeSet -> VarEnv Var

-- | Look up a variable the <a>InScopeSet</a>. This lets you map from the
--   variable's identity (unique) to its full value.
lookupInScope :: InScopeSet -> Var -> Maybe Var
lookupInScope_Directly :: InScopeSet -> Unique -> Maybe Var
unionInScope :: InScopeSet -> InScopeSet -> InScopeSet
elemInScopeSet :: Var -> InScopeSet -> Bool

-- | <tt>uniqAway in_scope v</tt> finds a unique that is not used in the
--   in-scope set, and gives that to v.
uniqAway :: InScopeSet -> Var -> Var

-- | When we are comparing (or matching) types or terms, we are faced with
--   "going under" corresponding binders. E.g. when comparing:
--   
--   <pre>
--   \x. e1     ~   \y. e2
--   </pre>
--   
--   Basically we want to rename [<tt>x</tt> -&gt; <tt>y</tt>] or
--   [<tt>y</tt> -&gt; <tt>x</tt>], but there are lots of things we must be
--   careful of. In particular, <tt>x</tt> might be free in <tt>e2</tt>, or
--   y in <tt>e1</tt>. So the idea is that we come up with a fresh binder
--   that is free in neither, and rename <tt>x</tt> and <tt>y</tt>
--   respectively. That means we must maintain:
--   
--   <ol>
--   <li>A renaming for the left-hand expression</li>
--   <li>A renaming for the right-hand expressions</li>
--   <li>An in-scope set</li>
--   </ol>
--   
--   Furthermore, when matching, we want to be able to have an 'occurs
--   check', to prevent:
--   
--   <pre>
--   \x. f   ~   \y. y
--   </pre>
--   
--   matching with [<tt>f</tt> -&gt; <tt>y</tt>]. So for each expression we
--   want to know that set of locally-bound variables. That is precisely
--   the domain of the mappings 1. and 2., but we must ensure that we
--   always extend the mappings as we go in.
--   
--   All of this information is bundled up in the <a>RnEnv2</a>
data RnEnv2
mkRnEnv2 :: InScopeSet -> RnEnv2

-- | <tt>rnBndr2 env bL bR</tt> goes under a binder <tt>bL</tt> in the Left
--   term, and binder <tt>bR</tt> in the Right term. It finds a new binder,
--   <tt>new_b</tt>, and returns an environment mapping <tt>bL -&gt;
--   new_b</tt> and <tt>bR -&gt; new_b</tt>
rnBndr2 :: RnEnv2 -> Var -> Var -> RnEnv2

-- | Applies <a>rnBndr2</a> to several variables: the two variable lists
--   must be of equal length
rnBndrs2 :: RnEnv2 -> [Var] -> [Var] -> RnEnv2

-- | Look up the renaming of an occurrence in the left or right term
rnOccL :: RnEnv2 -> Var -> Var

-- | Look up the renaming of an occurrence in the left or right term
rnOccR :: RnEnv2 -> Var -> Var

-- | Tells whether a variable is locally bound
inRnEnvL :: RnEnv2 -> Var -> Bool

-- | Tells whether a variable is locally bound
inRnEnvR :: RnEnv2 -> Var -> Bool

-- | Look up the renaming of an occurrence in the left or right term
rnOccL_maybe :: RnEnv2 -> Var -> Maybe Var

-- | Look up the renaming of an occurrence in the left or right term
rnOccR_maybe :: RnEnv2 -> Var -> Maybe Var

-- | Similar to <a>rnBndr2</a> but used when there's a binder on the left
--   side only.
rnBndrL :: RnEnv2 -> Var -> (RnEnv2, Var)

-- | Similar to <a>rnBndr2</a> but used when there's a binder on the right
--   side only.
rnBndrR :: RnEnv2 -> Var -> (RnEnv2, Var)

-- | Wipe the left or right side renaming
nukeRnEnvL :: RnEnv2 -> RnEnv2

-- | Wipe the left or right side renaming
nukeRnEnvR :: RnEnv2 -> RnEnv2
delBndrL :: RnEnv2 -> Var -> RnEnv2
delBndrR :: RnEnv2 -> Var -> RnEnv2
delBndrsL :: RnEnv2 -> [Var] -> RnEnv2
delBndrsR :: RnEnv2 -> [Var] -> RnEnv2
addRnInScopeSet :: RnEnv2 -> VarEnv Var -> RnEnv2

-- | Similar to <a>rnBndrL</a> but used for eta expansion See Note [Eta
--   expansion]
rnEtaL :: RnEnv2 -> Var -> (RnEnv2, Var)

-- | Similar to <a>rnBndr2</a> but used for eta expansion See Note [Eta
--   expansion]
rnEtaR :: RnEnv2 -> Var -> (RnEnv2, Var)
rnInScope :: Var -> RnEnv2 -> Bool
rnInScopeSet :: RnEnv2 -> InScopeSet
lookupRnInScope :: RnEnv2 -> Var -> Var

-- | When tidying up print names, we keep a mapping of in-scope occ-names
--   (the <a>TidyOccEnv</a>) and a Var-to-Var of the current renamings
type TidyEnv = (TidyOccEnv, VarEnv Var)
emptyTidyEnv :: TidyEnv
instance Outputable InScopeSet


-- | Module for coercion axioms, used to represent type family instances
--   and newtypes
module CoAxiom
data Branched
data Unbranched
type BranchIndex = Int
data BranchList a br
[FirstBranch] :: a -> BranchList a br
[NextBranch] :: a -> BranchList a br -> BranchList a Branched
toBranchList :: [a] -> BranchList a Branched
fromBranchList :: BranchList a br -> [a]
toBranchedList :: BranchList a br -> BranchList a Branched
toUnbranchedList :: BranchList a br -> BranchList a Unbranched
brListLength :: BranchList a br -> Int
brListNth :: BranchList a br -> BranchIndex -> a
brListMap :: (a -> b) -> BranchList a br -> [b]
brListFoldr :: (a -> b -> b) -> b -> BranchList a br -> b
brListMapM :: Monad m => (a -> m b) -> BranchList a br -> m [b]
brListFoldlM_ :: Monad m => (a -> b -> m a) -> a -> BranchList b br -> m ()
brListZipWith :: (a -> b -> c) -> BranchList a br1 -> BranchList b br2 -> [c]

-- | A <a>CoAxiom</a> is a "coercion constructor", i.e. a named equality
--   axiom.
data CoAxiom br
[CoAxiom] :: Unique -> Name -> Role -> TyCon -> BranchList CoAxBranch br -> Bool -> CoAxiom br
[co_ax_unique] :: CoAxiom br -> Unique
[co_ax_name] :: CoAxiom br -> Name
[co_ax_role] :: CoAxiom br -> Role
[co_ax_tc] :: CoAxiom br -> TyCon
[co_ax_branches] :: CoAxiom br -> BranchList CoAxBranch br
[co_ax_implicit] :: CoAxiom br -> Bool
data CoAxBranch
[CoAxBranch] :: SrcSpan -> [TyVar] -> [Role] -> [Type] -> Type -> [CoAxBranch] -> CoAxBranch
[cab_loc] :: CoAxBranch -> SrcSpan
[cab_tvs] :: CoAxBranch -> [TyVar]
[cab_roles] :: CoAxBranch -> [Role]
[cab_lhs] :: CoAxBranch -> [Type]
[cab_rhs] :: CoAxBranch -> Type
[cab_incomps] :: CoAxBranch -> [CoAxBranch]
toBranchedAxiom :: CoAxiom br -> CoAxiom Branched
toUnbranchedAxiom :: CoAxiom br -> CoAxiom Unbranched
coAxiomName :: CoAxiom br -> Name
coAxiomArity :: CoAxiom br -> BranchIndex -> Arity
coAxiomBranches :: CoAxiom br -> BranchList CoAxBranch br
coAxiomTyCon :: CoAxiom br -> TyCon
isImplicitCoAxiom :: CoAxiom br -> Bool
coAxiomNumPats :: CoAxiom br -> Int
coAxiomNthBranch :: CoAxiom br -> BranchIndex -> CoAxBranch
coAxiomSingleBranch_maybe :: CoAxiom br -> Maybe CoAxBranch
coAxiomRole :: CoAxiom br -> Role
coAxiomSingleBranch :: CoAxiom Unbranched -> CoAxBranch
coAxBranchTyVars :: CoAxBranch -> [TyVar]
coAxBranchRoles :: CoAxBranch -> [Role]
coAxBranchLHS :: CoAxBranch -> [Type]
coAxBranchRHS :: CoAxBranch -> Type
coAxBranchSpan :: CoAxBranch -> SrcSpan
coAxBranchIncomps :: CoAxBranch -> [CoAxBranch]
placeHolderIncomps :: [CoAxBranch]
data Role
[Nominal] :: Role
[Representational] :: Role
[Phantom] :: Role
fsFromRole :: Role -> FastString

-- | For now, we work only with nominal equality.
data CoAxiomRule
[CoAxiomRule] :: FastString -> Int -> [Role] -> Role -> ([Type] -> [Eqn] -> Maybe Eqn) -> CoAxiomRule
[coaxrName] :: CoAxiomRule -> FastString
[coaxrTypeArity] :: CoAxiomRule -> Int
[coaxrAsmpRoles] :: CoAxiomRule -> [Role]
[coaxrRole] :: CoAxiomRule -> Role

-- | coaxrProves returns <tt>Nothing</tt> when it doesn't like the supplied
--   arguments. When this happens in a coercion that means that the
--   coercion is ill-formed, and Core Lint checks for that.
[coaxrProves] :: CoAxiomRule -> [Type] -> [Eqn] -> Maybe Eqn

-- | A more explicit representation for `t1 ~ t2`.
type Eqn = Pair Type
data BuiltInSynFamily
[BuiltInSynFamily] :: ([Type] -> Maybe (CoAxiomRule, [Type], Type)) -> ([Type] -> Type -> [Eqn]) -> ([Type] -> Type -> [Type] -> Type -> [Eqn]) -> BuiltInSynFamily
[sfMatchFam] :: BuiltInSynFamily -> [Type] -> Maybe (CoAxiomRule, [Type], Type)
[sfInteractTop] :: BuiltInSynFamily -> [Type] -> Type -> [Eqn]
[sfInteractInert] :: BuiltInSynFamily -> [Type] -> Type -> [Type] -> Type -> [Eqn]
trivialBuiltInFamily :: BuiltInSynFamily
instance Data Role
instance Eq Role
instance Outputable a => Outputable (BranchList a br)
instance Eq (CoAxiom br)
instance Ord (CoAxiom br)
instance Uniquable (CoAxiom br)
instance Outputable (CoAxiom br)
instance NamedThing (CoAxiom br)
instance Typeable br => Data (CoAxiom br)
instance Outputable Role
instance Binary Role
instance Data CoAxiomRule
instance Uniquable CoAxiomRule
instance Eq CoAxiomRule
instance Ord CoAxiomRule
instance Outputable CoAxiomRule

module TyCon

-- | TyCons represent type constructors. Type constructors are introduced
--   by things such as:
--   
--   1) Data declarations: <tt>data Foo = ...</tt> creates the <tt>Foo</tt>
--   type constructor of kind <tt>*</tt>
--   
--   2) Type synonyms: <tt>type Foo = ...</tt> creates the <tt>Foo</tt>
--   type constructor
--   
--   3) Newtypes: <tt>newtype Foo a = MkFoo ...</tt> creates the
--   <tt>Foo</tt> type constructor of kind <tt>* -&gt; *</tt>
--   
--   4) Class declarations: <tt>class Foo where</tt> creates the
--   <tt>Foo</tt> type constructor of kind <tt>*</tt>
--   
--   This data type also encodes a number of primitive, built in type
--   constructors such as those for function and tuple types.
data TyCon

-- | Names of the fields in an algebraic record type
type FieldLabel = Name

-- | Represents right-hand-sides of <a>TyCon</a>s for algebraic types
data AlgTyConRhs

-- | Says that we know nothing about this data type, except that it's
--   represented by a pointer. Used when we export a data type abstractly
--   into an .hi file.
[AbstractTyCon] :: Bool -> AlgTyConRhs

-- | Represents an open type family without a fixed right hand side.
--   Additional instances can appear at any time.
--   
--   These are introduced by either a top level declaration:
--   
--   <pre>
--   data T a :: *
--   </pre>
--   
--   Or an associated data type declaration, within a class declaration:
--   
--   <pre>
--   class C a b where
--     data T b :: *
--   </pre>
[DataFamilyTyCon] :: AlgTyConRhs

-- | Information about those <a>TyCon</a>s derived from a <tt>data</tt>
--   declaration. This includes data types with no constructors at all.
[DataTyCon] :: [DataCon] -> Bool -> AlgTyConRhs

-- | The data type constructors; can be empty if the user declares the type
--   to have no constructors
--   
--   INVARIANT: Kept in order of increasing <a>DataCon</a> tag (see the tag
--   assignment in DataCon.mkDataCon)
[data_cons] :: AlgTyConRhs -> [DataCon]

-- | Cached value: is this an enumeration type? See Note [Enumeration
--   types]
[is_enum] :: AlgTyConRhs -> Bool

-- | Information about those <a>TyCon</a>s derived from a <tt>newtype</tt>
--   declaration
[NewTyCon] :: DataCon -> Type -> ([TyVar], Type) -> CoAxiom Unbranched -> AlgTyConRhs

-- | The unique constructor for the <tt>newtype</tt>. It has no
--   existentials
[data_con] :: AlgTyConRhs -> DataCon

-- | Cached value: the argument type of the constructor, which is just the
--   representation type of the <a>TyCon</a> (remember that
--   <tt>newtype</tt>s do not exist at runtime so need a different
--   representation type).
--   
--   The free <a>TyVar</a>s of this type are the <a>tyConTyVars</a> from
--   the corresponding <a>TyCon</a>
[nt_rhs] :: AlgTyConRhs -> Type

-- | Same as the <a>nt_rhs</a>, but this time eta-reduced. Hence the list
--   of <a>TyVar</a>s in this field may be shorter than the declared arity
--   of the <a>TyCon</a>.
[nt_etad_rhs] :: AlgTyConRhs -> ([TyVar], Type)
[nt_co] :: AlgTyConRhs -> CoAxiom Unbranched

-- | Both type classes as well as family instances imply implicit type
--   constructors. These implicit type constructors refer to their parent
--   structure (ie, the class or family from which they derive) using a
--   type of the following form. We use <a>TyConParent</a> for both
--   algebraic and synonym types, but the variant <a>ClassTyCon</a> will
--   only be used by algebraic <a>TyCon</a>s.
--   
--   Extract those <a>DataCon</a>s that we are able to learn about. Note
--   that visibility in this sense does not correspond to visibility in the
--   context of any particular user program!
visibleDataCons :: AlgTyConRhs -> [DataCon]
data TyConParent

-- | An ordinary type constructor has no parent.
[NoParentTyCon] :: TyConParent

-- | Type constructors representing a class dictionary. See Note [ATyCon
--   for classes] in TypeRep
[ClassTyCon] :: Class -> TyConParent

-- | An *associated* type of a class.
[AssocFamilyTyCon] :: Class -> TyConParent

-- | Type constructors representing an instance of a *data* family.
--   Parameters:
--   
--   1) The type family in question
--   
--   2) Instance types; free variables are the <a>tyConTyVars</a> of the
--   current <a>TyCon</a> (not the family one). INVARIANT: the number of
--   types matches the arity of the family <a>TyCon</a>
--   
--   3) A <tt>CoTyCon</tt> identifying the representation type with the
--   type instance family
[FamInstTyCon] :: (CoAxiom Unbranched) -> TyCon -> [Type] -> TyConParent
isNoParent :: TyConParent -> Bool

-- | Information pertaining to the expansion of a type synonym
--   (<tt>type</tt>)
data FamTyConFlav

-- | An open type synonym family e.g. <tt>type family F x y :: * -&gt;
--   *</tt>
[OpenSynFamilyTyCon] :: FamTyConFlav

-- | A closed type synonym family e.g. <tt>type family F x where { F Int =
--   Bool }</tt>
[ClosedSynFamilyTyCon] :: (CoAxiom Branched) -> FamTyConFlav

-- | A closed type synonym family declared in an hs-boot file with type
--   family F a where ..
[AbstractClosedSynFamilyTyCon] :: FamTyConFlav

-- | Built-in type family used by the TypeNats solver
[BuiltInSynFamTyCon] :: BuiltInSynFamily -> FamTyConFlav
data Role
[Nominal] :: Role
[Representational] :: Role
[Phantom] :: Role

-- | This is the making of an algebraic <a>TyCon</a>. Notably, you have to
--   pass in the generic (in the -XGenerics sense) information about the
--   type constructor - you can get hold of it easily (see Generics module)
mkAlgTyCon :: Name -> Kind -> [TyVar] -> [Role] -> Maybe CType -> [PredType] -> AlgTyConRhs -> TyConParent -> RecFlag -> Bool -> Maybe TyCon -> TyCon

-- | Simpler specialization of <a>mkAlgTyCon</a> for classes
mkClassTyCon :: Name -> Kind -> [TyVar] -> [Role] -> AlgTyConRhs -> Class -> RecFlag -> TyCon

-- | Given the name of the function type constructor and it's kind, create
--   the corresponding <a>TyCon</a>. It is reccomended to use
--   <a>funTyCon</a> if you want this functionality
mkFunTyCon :: Name -> Kind -> TyCon

-- | Create an unlifted primitive <a>TyCon</a>, such as <tt>Int#</tt>
mkPrimTyCon :: Name -> Kind -> [Role] -> PrimRep -> TyCon

-- | Kind constructors
mkKindTyCon :: Name -> Kind -> TyCon

-- | Create a lifted primitive <a>TyCon</a> such as <tt>RealWorld</tt>
mkLiftedPrimTyCon :: Name -> Kind -> [Role] -> PrimRep -> TyCon
mkTupleTyCon :: Name -> Kind -> Arity -> [TyVar] -> DataCon -> TupleSort -> Maybe TyCon -> TyCon

-- | Create a type synonym <a>TyCon</a>
mkSynonymTyCon :: Name -> Kind -> [TyVar] -> [Role] -> Type -> TyCon

-- | Create a type family <a>TyCon</a>
mkFamilyTyCon :: Name -> Kind -> [TyVar] -> FamTyConFlav -> TyConParent -> TyCon

-- | Create a promoted data constructor <a>TyCon</a> Somewhat dodgily, we
--   give it the same Name as the data constructor itself; when we
--   pretty-print the TyCon we add a quote; see the Outputable TyCon
--   instance
mkPromotedDataCon :: DataCon -> Name -> Unique -> Kind -> [Role] -> TyCon

-- | Create a promoted type constructor <a>TyCon</a> Somewhat dodgily, we
--   give it the same Name as the type constructor itself
mkPromotedTyCon :: TyCon -> Kind -> TyCon

-- | Returns <tt>True</tt> if the supplied <a>TyCon</a> resulted from
--   either a <tt>data</tt> or <tt>newtype</tt> declaration
isAlgTyCon :: TyCon -> Bool

-- | Is this <a>TyCon</a> that for a class instance?
isClassTyCon :: TyCon -> Bool

-- | Is this <a>TyCon</a> that for a data family instance?
isFamInstTyCon :: TyCon -> Bool
isFunTyCon :: TyCon -> Bool

-- | Does this <a>TyCon</a> represent something that cannot be defined in
--   Haskell?
isPrimTyCon :: TyCon -> Bool

-- | Does this <a>TyCon</a> represent a tuple?
--   
--   NB: when compiling <tt>Data.Tuple</tt>, the tycons won't reply
--   <tt>True</tt> to <a>isTupleTyCon</a>, because they are built as
--   <tt>AlgTyCons</tt>. However they get spat into the interface file as
--   tuple tycons, so I don't think it matters.
isTupleTyCon :: TyCon -> Bool

-- | Is this the <a>TyCon</a> for an unboxed tuple?
isUnboxedTupleTyCon :: TyCon -> Bool

-- | Is this the <a>TyCon</a> for a boxed tuple?
isBoxedTupleTyCon :: TyCon -> Bool

-- | Is this a <a>TyCon</a> representing a regular H98 type synonym
--   (<tt>type</tt>)?
isTypeSynonymTyCon :: TyCon -> Bool
isDecomposableTyCon :: TyCon -> Bool

-- | Is this a PromotedDataCon?
isPromotedDataCon :: TyCon -> Bool

-- | Is this a PromotedTyCon?
isPromotedTyCon :: TyCon -> Bool

-- | Retrieves the promoted DataCon if this is a PromotedDataCon;
isPromotedDataCon_maybe :: TyCon -> Maybe DataCon

-- | Retrieves the promoted TyCon if this is a PromotedTyCon;
isPromotedTyCon_maybe :: TyCon -> Maybe TyCon
promotableTyCon_maybe :: TyCon -> Maybe TyCon
promoteTyCon :: TyCon -> TyCon

-- | Returns <tt>True</tt> for data types that are <i>definitely</i>
--   represented by heap-allocated constructors. These are scrutinised by
--   Core-level <tt>case</tt> expressions, and they get info tables
--   allocated for them.
--   
--   Generally, the function will be true for all <tt>data</tt> types and
--   false for <tt>newtype</tt>s, unboxed tuples and type family
--   <a>TyCon</a>s. But it is not guaranteed to return <tt>True</tt> in all
--   cases that it could.
--   
--   NB: for a data type family, only the <i>instance</i> <a>TyCon</a>s get
--   an info table. The family declaration <a>TyCon</a> does not
isDataTyCon :: TyCon -> Bool
isProductTyCon :: TyCon -> Bool
isDataProductTyCon_maybe :: TyCon -> Maybe DataCon

-- | Is this an algebraic <a>TyCon</a> which is just an enumeration of
--   values?
isEnumerationTyCon :: TyCon -> Bool

-- | Is this <a>TyCon</a> that for a <tt>newtype</tt>
isNewTyCon :: TyCon -> Bool

-- | Test if the <a>TyCon</a> is algebraic but abstract (invisible data
--   constructors)
isAbstractTyCon :: TyCon -> Bool

-- | Is this a <a>TyCon</a>, synonym or otherwise, that defines a family?
isFamilyTyCon :: TyCon -> Bool

-- | Is this a <a>TyCon</a>, synonym or otherwise, that defines a family
--   with instances?
isOpenFamilyTyCon :: TyCon -> Bool

-- | Is this a synonym <a>TyCon</a> that can have may have further
--   instances appear?
isTypeFamilyTyCon :: TyCon -> Bool

-- | Is this a synonym <a>TyCon</a> that can have may have further
--   instances appear?
isDataFamilyTyCon :: TyCon -> Bool
isOpenTypeFamilyTyCon :: TyCon -> Bool
isClosedSynFamilyTyCon_maybe :: TyCon -> Maybe (CoAxiom Branched)
isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily

-- | Is this <a>TyCon</a> unlifted (i.e. cannot contain bottom)? Note that
--   this can only be true for primitive and unboxed-tuple <a>TyCon</a>s
isUnLiftedTyCon :: TyCon -> Bool

-- | Is this an algebraic <a>TyCon</a> declared with the GADT syntax?
isGadtSyntaxTyCon :: TyCon -> Bool

-- | <a>isDistinctTyCon</a> is true of <a>TyCon</a>s that are equal only to
--   themselves, even via coercions (except for unsafeCoerce). This
--   excludes newtypes, type functions, type synonyms. It relates directly
--   to the FC consistency story: If the axioms are consistent, and co : S
--   tys ~ T tys, and S,T are "distinct" TyCons, then S=T. Cf Note [Pruning
--   dead case alternatives] in Unify
isDistinctTyCon :: TyCon -> Bool
isDistinctAlgRhs :: AlgTyConRhs -> Bool

-- | Are we able to extract informationa <a>TyVar</a> to class argument
--   list mappping from a given <a>TyCon</a>?
isTyConAssoc :: TyCon -> Bool
tyConAssoc_maybe :: TyCon -> Maybe Class

-- | Is this a recursive <a>TyCon</a>?
isRecursiveTyCon :: TyCon -> Bool

-- | Identifies implicit tycons that, in particular, do not go into
--   interface files (because they are implicitly reconstructed when the
--   interface is read).
--   
--   Note that:
--   
--   <ul>
--   <li>Associated families are implicit, as they are re-constructed from
--   the class declaration in which they reside, and</li>
--   <li>Family instances are <i>not</i> implicit as they represent the
--   instance body (similar to a <tt>dfun</tt> does that for a class
--   instance).</li>
--   </ul>
isImplicitTyCon :: TyCon -> Bool

-- | Name of the constructor
tyConName :: TyCon -> Name

-- | Kind of this TyCon (full kind, not just the return kind)
tyConKind :: TyCon -> Kind

-- | A Unique of this TyCon. Invariant: identical to Unique of Name stored
--   in tyConName field.
tyConUnique :: TyCon -> Unique

-- | The kind and type variables used in the type constructor. Invariant:
--   length tyvars = arity Precisely, this list scopes over:
--   
--   <ol>
--   <li>The <a>algTcStupidTheta</a></li>
--   <li>The cached types in algTyConRhs.NewTyCon</li>
--   <li>The family instance types if present</li>
--   </ol>
--   
--   Note that it does <i>not</i> scope over the data constructors.
tyConTyVars :: TyCon -> [TyVar]

-- | The C type that should be used for this type when using the FFI and
--   CAPI
tyConCType :: TyCon -> Maybe CType
tyConCType_maybe :: TyCon -> Maybe CType

-- | As <a>tyConDataCons_maybe</a>, but returns the empty list of
--   constructors if no constructors could be found
tyConDataCons :: TyCon -> [DataCon]

-- | Determine the <a>DataCon</a>s originating from the given <a>TyCon</a>,
--   if the <a>TyCon</a> is the sort that can have any constructors (note:
--   this does not include abstract algebraic types)
tyConDataCons_maybe :: TyCon -> Maybe [DataCon]

-- | If the given <a>TyCon</a> has a <i>single</i> data constructor, i.e.
--   it is a <tt>data</tt> type with one alternative, a tuple type or a
--   <tt>newtype</tt> then that constructor is returned. If the
--   <a>TyCon</a> has more than one constructor, or represents a primitive
--   or function type constructor then <tt>Nothing</tt> is returned. In any
--   other case, the function panics
tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon

-- | Determine the number of value constructors a <a>TyCon</a> has. Panics
--   if the <a>TyCon</a> is not algebraic or a tuple
tyConFamilySize :: TyCon -> Int

-- | Find the "stupid theta" of the <a>TyCon</a>. A "stupid theta" is the
--   context to the left of an algebraic type declaration, e.g. <tt>Eq
--   a</tt> in the declaration <tt>data Eq a =&gt; T a ...</tt>
tyConStupidTheta :: TyCon -> [PredType]

-- | Number of arguments this TyCon must receive to be considered saturated
--   (including implicit kind variables)
tyConArity :: TyCon -> Arity

-- | Get the list of roles for the type parameters of a TyCon
tyConRoles :: TyCon -> [Role]
tyConParent :: TyCon -> TyConParent
tyConTuple_maybe :: TyCon -> Maybe TupleSort

-- | If this <a>TyCon</a> is that for a class instance, return the class it
--   is for. Otherwise returns <tt>Nothing</tt>
tyConClass_maybe :: TyCon -> Maybe Class

-- | If this <a>TyCon</a> is that of a family instance, return the family
--   in question and the instance types. Otherwise, return <tt>Nothing</tt>
tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)

-- | If this <a>TyCon</a> is that of a family instance, return a
--   <a>TyCon</a> which represents a coercion identifying the
--   representation type with the type instance family. Otherwise, return
--   <tt>Nothing</tt>
tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)

-- | Extract the <a>TyVar</a>s bound by a vanilla type synonym and the
--   corresponding (unsubstituted) right hand side.
synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)

-- | Extract the information pertaining to the right hand side of a type
--   synonym (<tt>type</tt>) declaration.
synTyConRhs_maybe :: TyCon -> Maybe Type

-- | Extract the flavour of a type family (with all the extra information
--   that it carries)
famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav

-- | Extract an <a>AlgTyConRhs</a> with information about data constructors
--   from an algebraic or tuple <a>TyCon</a>. Panics for any other sort of
--   <a>TyCon</a>
algTyConRhs :: TyCon -> AlgTyConRhs

-- | Extract the bound type variables and type expansion of a type synonym
--   <a>TyCon</a>. Panics if the <a>TyCon</a> is not a synonym
newTyConRhs :: TyCon -> ([TyVar], Type)

-- | The number of type parameters that need to be passed to a newtype to
--   resolve it. May be less than in the definition if it can be
--   eta-contracted.
newTyConEtadArity :: TyCon -> Int

-- | Extract the bound type variables and type expansion of an
--   eta-contracted type synonym <a>TyCon</a>. Panics if the <a>TyCon</a>
--   is not a synonym
newTyConEtadRhs :: TyCon -> ([TyVar], Type)

-- | Take a <a>TyCon</a> apart into the <a>TyVar</a>s it scopes over, the
--   <a>Type</a> it expands into, and (possibly) a coercion from the
--   representation type to the <tt>newtype</tt>. Returns <tt>Nothing</tt>
--   if this is not possible.
unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)

-- | Extract the boxity of the given <a>TyCon</a>, if it is a
--   <a>TupleTyCon</a>. Panics otherwise
tupleTyConBoxity :: TyCon -> Boxity

-- | Extract the <a>TupleSort</a> of the given <a>TyCon</a>, if it is a
--   <a>TupleTyCon</a>. Panics otherwise
tupleTyConSort :: TyCon -> TupleSort

-- | Extract the arity of the given <a>TyCon</a>, if it is a
--   <a>TupleTyCon</a>. Panics otherwise
tupleTyConArity :: TyCon -> Arity

-- | Used to create the view <i>Core</i> has on <a>TyCon</a>s. We expand
--   not only closed synonyms like <a>tcExpandTyCon_maybe</a>, but also
--   non-recursive <tt>newtype</tt>s
--   
--   Used to create the view the <i>typechecker</i> has on <a>TyCon</a>s.
--   We expand (closed) synonyms only, cf. <a>coreExpandTyCon_maybe</a>
tcExpandTyCon_maybe :: TyCon -> [tyco] -> Maybe ([(TyVar, tyco)], Type, [tyco])

-- | Used to create the view the <i>typechecker</i> has on <a>TyCon</a>s.
--   We expand (closed) synonyms only, cf. <a>coreExpandTyCon_maybe</a>
coreExpandTyCon_maybe :: TyCon -> [tyco] -> Maybe ([(TyVar, tyco)], Type, [tyco])

-- | Make an algebraic <a>TyCon</a> abstract. Panics if the supplied
--   <a>TyCon</a> is not algebraic
makeTyConAbstract :: TyCon -> TyCon
newTyConCo :: TyCon -> CoAxiom Unbranched

-- | Extracts the <tt>newtype</tt> coercion from such a <a>TyCon</a>, which
--   can be used to construct something with the <tt>newtype</tt>s type
--   from its representation type (right hand side). If the supplied
--   <a>TyCon</a> is not a <tt>newtype</tt>, returns <tt>Nothing</tt>
newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
pprPromotionQuote :: TyCon -> SDoc

-- | A <a>PrimRep</a> is an abstraction of a type. It contains information
--   that the code generator needs in order to pass arguments, return
--   results, and store values of this type.
data PrimRep
[VoidRep] :: PrimRep
[PtrRep] :: PrimRep

-- | Signed, word-sized value
[IntRep] :: PrimRep

-- | Unsigned, word-sized value
[WordRep] :: PrimRep

-- | Signed, 64 bit value (with 32-bit words only)
[Int64Rep] :: PrimRep

-- | Unsigned, 64 bit value (with 32-bit words only)
[Word64Rep] :: PrimRep

-- | A pointer, but <i>not</i> to a Haskell value (use <a>PtrRep</a>)
[AddrRep] :: PrimRep
[FloatRep] :: PrimRep
[DoubleRep] :: PrimRep

-- | A vector
[VecRep] :: Int -> PrimElemRep -> PrimRep
data PrimElemRep
[Int8ElemRep] :: PrimElemRep
[Int16ElemRep] :: PrimElemRep
[Int32ElemRep] :: PrimElemRep
[Int64ElemRep] :: PrimElemRep
[Word8ElemRep] :: PrimElemRep
[Word16ElemRep] :: PrimElemRep
[Word32ElemRep] :: PrimElemRep
[Word64ElemRep] :: PrimElemRep
[FloatElemRep] :: PrimElemRep
[DoubleElemRep] :: PrimElemRep

-- | Find the primitive representation of a <a>TyCon</a>
tyConPrimRep :: TyCon -> PrimRep
isVoidRep :: PrimRep -> Bool
isGcPtrRep :: PrimRep -> Bool

-- | Find the size of a <a>PrimRep</a>, in words
primRepSizeW :: DynFlags -> PrimRep -> Int
primElemRepSizeB :: PrimElemRep -> Int
data RecTcChecker
initRecTc :: RecTcChecker
checkRecTc :: RecTcChecker -> TyCon -> Maybe RecTcChecker
instance Show PrimRep
instance Eq PrimRep
instance Show PrimElemRep
instance Eq PrimElemRep
instance Outputable TyConParent
instance Outputable PrimRep
instance Outputable PrimElemRep
instance Eq TyCon
instance Ord TyCon
instance Uniquable TyCon
instance Outputable TyCon
instance NamedThing TyCon
instance Data TyCon


-- | This module defines TyCons that can't be expressed in Haskell. They
--   are all, therefore, wired-in TyCons. C.f module TysWiredIn
module TysPrim
mkPrimTyConName :: FastString -> Unique -> TyCon -> Name
tyVarList :: Kind -> [TyVar]
alphaTyVars :: [TyVar]
betaTyVars :: [TyVar]
alphaTyVar :: TyVar
betaTyVar :: TyVar
gammaTyVar :: TyVar
deltaTyVar :: TyVar
alphaTy :: Type
betaTy :: Type
gammaTy :: Type
deltaTy :: Type
openAlphaTy :: Type
openBetaTy :: Type
openAlphaTyVar :: TyVar
openBetaTyVar :: TyVar
openAlphaTyVars :: [TyVar]
kKiVar :: KindVar

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
superKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
superKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
anyKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
liftedTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
openTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
unliftedTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
constraintKindTyCon :: TyCon
superKindTyConName :: Name
anyKindTyConName :: Name
liftedTypeKindTyConName :: Name
openTypeKindTyConName :: Name
unliftedTypeKindTyConName :: Name
constraintKindTyConName :: Name

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
anyKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
liftedTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
unliftedTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
openTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
constraintKind :: Kind

-- | Given two kinds <tt>k1</tt> and <tt>k2</tt>, creates the <a>Kind</a>
--   <tt>k1 -&gt; k2</tt>
mkArrowKind :: Kind -> Kind -> Kind

-- | Iterated application of <a>mkArrowKind</a>
mkArrowKinds :: [Kind] -> Kind -> Kind
funTyCon :: TyCon
funTyConName :: Name
primTyCons :: [TyCon]
charPrimTyCon :: TyCon
charPrimTy :: Type
intPrimTyCon :: TyCon
intPrimTy :: Type
wordPrimTyCon :: TyCon
wordPrimTy :: Type
addrPrimTyCon :: TyCon
addrPrimTy :: Type
floatPrimTyCon :: TyCon
floatPrimTy :: Type
doublePrimTyCon :: TyCon
doublePrimTy :: Type
voidPrimTyCon :: TyCon
voidPrimTy :: Type
statePrimTyCon :: TyCon
mkStatePrimTy :: Type -> Type
realWorldTyCon :: TyCon
realWorldTy :: Type
realWorldStatePrimTy :: Type
proxyPrimTyCon :: TyCon
mkProxyPrimTy :: Type -> Type -> Type
arrayPrimTyCon :: TyCon
mkArrayPrimTy :: Type -> Type
byteArrayPrimTyCon :: TyCon
byteArrayPrimTy :: Type
arrayArrayPrimTyCon :: TyCon
mkArrayArrayPrimTy :: Type
smallArrayPrimTyCon :: TyCon
mkSmallArrayPrimTy :: Type -> Type
mutableArrayPrimTyCon :: TyCon
mkMutableArrayPrimTy :: Type -> Type -> Type
mutableByteArrayPrimTyCon :: TyCon
mkMutableByteArrayPrimTy :: Type -> Type
mutableArrayArrayPrimTyCon :: TyCon
mkMutableArrayArrayPrimTy :: Type -> Type
smallMutableArrayPrimTyCon :: TyCon
mkSmallMutableArrayPrimTy :: Type -> Type -> Type
mutVarPrimTyCon :: TyCon
mkMutVarPrimTy :: Type -> Type -> Type
mVarPrimTyCon :: TyCon
mkMVarPrimTy :: Type -> Type -> Type
tVarPrimTyCon :: TyCon
mkTVarPrimTy :: Type -> Type -> Type
stablePtrPrimTyCon :: TyCon
mkStablePtrPrimTy :: Type -> Type
stableNamePrimTyCon :: TyCon
mkStableNamePrimTy :: Type -> Type
bcoPrimTyCon :: TyCon
bcoPrimTy :: Type
weakPrimTyCon :: TyCon
mkWeakPrimTy :: Type -> Type
threadIdPrimTyCon :: TyCon
threadIdPrimTy :: Type
int32PrimTyCon :: TyCon
int32PrimTy :: Type
word32PrimTyCon :: TyCon
word32PrimTy :: Type
int64PrimTyCon :: TyCon
int64PrimTy :: Type
word64PrimTyCon :: TyCon
word64PrimTy :: Type
eqPrimTyCon :: TyCon
eqReprPrimTyCon :: TyCon
anyTy :: Type
anyTyCon :: TyCon
anyTypeOfKind :: Kind -> Type
int8X16PrimTy :: Type
int8X16PrimTyCon :: TyCon
int16X8PrimTy :: Type
int16X8PrimTyCon :: TyCon
int32X4PrimTy :: Type
int32X4PrimTyCon :: TyCon
int64X2PrimTy :: Type
int64X2PrimTyCon :: TyCon
int8X32PrimTy :: Type
int8X32PrimTyCon :: TyCon
int16X16PrimTy :: Type
int16X16PrimTyCon :: TyCon
int32X8PrimTy :: Type
int32X8PrimTyCon :: TyCon
int64X4PrimTy :: Type
int64X4PrimTyCon :: TyCon
int8X64PrimTy :: Type
int8X64PrimTyCon :: TyCon
int16X32PrimTy :: Type
int16X32PrimTyCon :: TyCon
int32X16PrimTy :: Type
int32X16PrimTyCon :: TyCon
int64X8PrimTy :: Type
int64X8PrimTyCon :: TyCon
word8X16PrimTy :: Type
word8X16PrimTyCon :: TyCon
word16X8PrimTy :: Type
word16X8PrimTyCon :: TyCon
word32X4PrimTy :: Type
word32X4PrimTyCon :: TyCon
word64X2PrimTy :: Type
word64X2PrimTyCon :: TyCon
word8X32PrimTy :: Type
word8X32PrimTyCon :: TyCon
word16X16PrimTy :: Type
word16X16PrimTyCon :: TyCon
word32X8PrimTy :: Type
word32X8PrimTyCon :: TyCon
word64X4PrimTy :: Type
word64X4PrimTyCon :: TyCon
word8X64PrimTy :: Type
word8X64PrimTyCon :: TyCon
word16X32PrimTy :: Type
word16X32PrimTyCon :: TyCon
word32X16PrimTy :: Type
word32X16PrimTyCon :: TyCon
word64X8PrimTy :: Type
word64X8PrimTyCon :: TyCon
floatX4PrimTy :: Type
floatX4PrimTyCon :: TyCon
doubleX2PrimTy :: Type
doubleX2PrimTyCon :: TyCon
floatX8PrimTy :: Type
floatX8PrimTyCon :: TyCon
doubleX4PrimTy :: Type
doubleX4PrimTyCon :: TyCon
floatX16PrimTy :: Type
floatX16PrimTyCon :: TyCon
doubleX8PrimTy :: Type
doubleX8PrimTyCon :: TyCon

module Kind

-- | "Super kinds", used to help encode <a>Kind</a>s as types. Invariant: a
--   super kind is always of this form:
--   
--   <pre>
--   TyConApp SuperKindTyCon ...
--   </pre>
type SuperKind = Type

-- | The key type representing kinds in the compiler. Invariant: a kind is
--   always in one of these forms:
--   
--   <pre>
--   FunTy k1 k2
--   TyConApp PrimTyCon [...]
--   TyVar kv   -- (during inference only)
--   ForAll ... -- (for top-level coercions)
--   </pre>
type Kind = Type
typeKind :: Type -> Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
anyKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
liftedTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
unliftedTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
openTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
constraintKind :: Kind

-- | Given two kinds <tt>k1</tt> and <tt>k2</tt>, creates the <a>Kind</a>
--   <tt>k1 -&gt; k2</tt>
mkArrowKind :: Kind -> Kind -> Kind

-- | Iterated application of <a>mkArrowKind</a>
mkArrowKinds :: [Kind] -> Kind -> Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
anyKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
liftedTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
openTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
unliftedTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
constraintKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
superKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
superKindTyCon :: TyCon
pprKind :: Kind -> SDoc
pprParendKind :: Kind -> SDoc
kindAppResult :: SDoc -> Kind -> [Type] -> Kind

-- | Find the result <a>Kind</a> of a type synonym, after applying it to
--   its <tt>arity</tt> number of type variables Actually this function
--   works fine on data types too, but they'd always return <a>*</a>, so we
--   never need to ask
synTyConResKind :: TyCon -> Kind

-- | Essentially <tt>splitFunTys</tt> on kinds
splitKindFunTys :: Kind -> ([Kind], Kind)

-- | Essentially <tt>splitFunTysN</tt> on kinds
splitKindFunTysN :: Int -> Kind -> ([Kind], Kind)
splitKindFunTy_maybe :: Kind -> Maybe (Kind, Kind)
isLiftedTypeKind :: Kind -> Bool

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
isUnliftedTypeKind :: Kind -> Bool

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
isOpenTypeKind :: Kind -> Bool

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
isConstraintKind :: Kind -> Bool

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
isConstraintOrLiftedKind :: Kind -> Bool
returnsConstraintKind :: Kind -> Bool

-- | Is this a kind (i.e. a type-of-types)?
isKind :: Kind -> Bool
isKindVar :: Var -> Bool

-- | Is this a super-kind (i.e. a type-of-kinds)?
isSuperKind :: Type -> Bool
isSuperKindTyCon :: TyCon -> Bool
isLiftedTypeKindCon :: TyCon -> Bool
isConstraintKindCon :: TyCon -> Bool

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
isAnyKind :: Kind -> Bool
isAnyKindCon :: TyCon -> Bool
okArrowArgKind :: Kind -> Bool
okArrowResultKind :: Kind -> Bool

-- | True of any sub-kind of OpenTypeKind
isSubOpenTypeKind :: Kind -> Bool
isSubOpenTypeKindKey :: Unique -> Bool

-- | <tt>k1 `isSubKind` k2</tt> checks that <tt>k1</tt> &lt;: <tt>k2</tt>
--   Sub-kinding is extremely simple and does not look under arrrows or
--   type constructors
isSubKind :: Kind -> Kind -> Bool

-- | <tt>kc1 `isSubKindCon` kc2</tt> checks that <tt>kc1</tt> &lt;:
--   <tt>kc2</tt>
isSubKindCon :: TyCon -> TyCon -> Bool
tcIsSubKind :: Kind -> Kind -> Bool
tcIsSubKindCon :: TyCon -> TyCon -> Bool
defaultKind :: Kind -> Kind

-- | Used when generalising: default OpenKind and ArgKind to *. See
--   <a>Type#kind_subtyping</a> for more information on what that means
defaultKind_maybe :: Kind -> Maybe Kind
kiVarsOfKind :: Kind -> VarSet
kiVarsOfKinds :: [Kind] -> VarSet


-- | Main functions for manipulating types and type-related things
module Type

-- | A typecheckable-thing, essentially anything that has a name
data TyThing
[AnId] :: Id -> TyThing
[AConLike] :: ConLike -> TyThing
[ATyCon] :: TyCon -> TyThing
[ACoAxiom] :: (CoAxiom Branched) -> TyThing

-- | The key representation of types within the compiler
data Type
type KindOrType = Type

-- | A type of the form <tt>p</tt> of kind <tt>Constraint</tt> represents a
--   value whose type is the Haskell predicate <tt>p</tt>, where a
--   predicate is what occurs before the <tt>=&gt;</tt> in a Haskell type.
--   
--   We use <a>PredType</a> as documentation to mark those types that we
--   guarantee to have this kind.
--   
--   It can be expanded into its representation, but:
--   
--   <ul>
--   <li>The type checker must treat it as opaque</li>
--   <li>The rest of the compiler treats it as transparent</li>
--   </ul>
--   
--   Consider these examples:
--   
--   <pre>
--   f :: (Eq a) =&gt; a -&gt; Int
--   g :: (?x :: Int -&gt; Int) =&gt; a -&gt; Int
--   h :: (r\l) =&gt; {r} =&gt; {l::Int | r}
--   </pre>
--   
--   Here the <tt>Eq a</tt> and <tt>?x :: Int -&gt; Int</tt> and
--   <tt>rl</tt> are all called "predicates"
type PredType = Type

-- | A collection of <a>PredType</a>s
type ThetaType = [PredType]

-- | Essentially a typed <a>Name</a>, that may also contain some additional
--   information about the <a>Var</a> and it's use sites.
data Var
type TyVar = Var
isTyVar :: Var -> Bool
mkTyVarTy :: TyVar -> Type
mkTyVarTys :: [TyVar] -> [Type]

-- | Attempts to obtain the type variable underlying a <a>Type</a>, and
--   panics with the given message if this is not a type variable type. See
--   also <a>getTyVar_maybe</a>
getTyVar :: String -> Type -> TyVar

-- | Attempts to obtain the type variable underlying a <a>Type</a>
getTyVar_maybe :: Type -> Maybe TyVar

-- | Applies a type to another, as in e.g. <tt>k a</tt>
mkAppTy :: Type -> Type -> Type
mkAppTys :: Type -> [Type] -> Type

-- | Attempts to take a type application apart, as in
--   <a>splitAppTy_maybe</a>, and panics if this is not possible
splitAppTy :: Type -> (Type, Type)

-- | Recursively splits a type as far as is possible, leaving a residual
--   type being applied to and the type arguments applied to it. Never
--   fails, even if that means returning an empty list of type
--   applications.
splitAppTys :: Type -> (Type, [Type])

-- | Attempt to take a type application apart, whether it is a function,
--   type constructor, or plain type application. Note that type family
--   applications are NEVER unsaturated by this!
splitAppTy_maybe :: Type -> Maybe (Type, Type)

-- | Does the AppTy split as in <a>splitAppTy_maybe</a>, but assumes that
--   any Core view stuff is already done
repSplitAppTy_maybe :: Type -> Maybe (Type, Type)

-- | Creates a function type from the given argument and result type
mkFunTy :: Type -> Type -> Type
mkFunTys :: [Type] -> Type -> Type

-- | Attempts to extract the argument and result types from a type, and
--   panics if that is not possible. See also <a>splitFunTy_maybe</a>
splitFunTy :: Type -> (Type, Type)

-- | Attempts to extract the argument and result types from a type
splitFunTy_maybe :: Type -> Maybe (Type, Type)
splitFunTys :: Type -> ([Type], Type)

-- | Split off exactly the given number argument types, and panics if that
--   is not possible
splitFunTysN :: Int -> Type -> ([Type], Type)

-- | Extract the function result type and panic if that is not possible
funResultTy :: Type -> Type

-- | Extract the function argument type and panic if that is not possible
funArgTy :: Type -> Type

-- | Splits off argument types from the given type and associating them
--   with the things in the input list from left to right. The final result
--   type is returned, along with the resulting pairs of objects and types,
--   albeit with the list of pairs in reverse order. Panics if there are
--   not enough argument types for the input list.
zipFunTys :: Outputable a => [a] -> Type -> ([(a, Type)], Type)

-- | A key function: builds a <a>TyConApp</a> or <a>FunTy</a> as
--   appropriate to its arguments. Applies its arguments to the constructor
--   from left to right.
mkTyConApp :: TyCon -> [Type] -> Type

-- | Create the plain type constructor type which has been applied to no
--   type arguments at all.
mkTyConTy :: TyCon -> Type

-- | The same as <tt>fst . splitTyConApp</tt>
tyConAppTyCon_maybe :: Type -> Maybe TyCon

-- | The same as <tt>snd . splitTyConApp</tt>
tyConAppArgs_maybe :: Type -> Maybe [Type]
tyConAppTyCon :: Type -> TyCon
tyConAppArgs :: Type -> [Type]

-- | Attempts to tease a type apart into a type constructor and the
--   application of a number of arguments to that constructor
splitTyConApp_maybe :: Type -> Maybe (TyCon, [Type])

-- | Attempts to tease a type apart into a type constructor and the
--   application of a number of arguments to that constructor. Panics if
--   that is not possible. See also <a>splitTyConApp_maybe</a>
splitTyConApp :: Type -> (TyCon, [Type])
tyConAppArgN :: Int -> Type -> Type

-- | What is the role assigned to the next parameter of this type? Usually,
--   this will be <a>Nominal</a>, but if the type is a <a>TyConApp</a>, we
--   may be able to do better. The type does *not* have to be well-kinded
--   when applied for this to work!
nextRole :: Type -> Role
mkForAllTy :: TyVar -> Type -> Type

-- | Wraps foralls over the type using the provided <a>TyVar</a>s from left
--   to right
mkForAllTys :: [TyVar] -> Type -> Type

-- | Attempts to take a forall type apart, returning the bound type
--   variable and the remainder of the type
splitForAllTy_maybe :: Type -> Maybe (TyVar, Type)

-- | 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 <a>TyVar</a>s
splitForAllTys :: Type -> ([TyVar], Type)
mkPiKinds :: [TyVar] -> Kind -> Kind

-- | Makes a <tt>(-&gt;)</tt> type or a forall type, depending on whether
--   it is given a type variable or a term variable.
mkPiType :: Var -> Type -> Type

-- | <a>mkPiType</a> for multiple type or value arguments
mkPiTypes :: [Var] -> Type -> Type

-- | Instantiate a forall type with one or more type arguments. Used when
--   we have a polymorphic function applied to type args:
--   
--   <pre>
--   f t1 t2
--   </pre>
--   
--   We use <tt>applyTys type-of-f [t1,t2]</tt> to compute the type of the
--   expression. Panics if no application is possible.
applyTy :: Type -> KindOrType -> Type

-- | This function is interesting because:
--   
--   <ol>
--   <li>The function may have more for-alls than there are
--   args<ol><li>Less obviously, it may have fewer for-alls</li></ol></li>
--   </ol>
--   
--   For case 2. think of:
--   
--   <pre>
--   applyTys (forall a.a) [forall b.b, Int]
--   </pre>
--   
--   This really can happen, but only (I think) in situations involving
--   undefined. For example: undefined :: forall a. a Term: undefined
--   <tt>(forall b. b-&gt;b) </tt>Int This term should have type (Int -&gt;
--   Int), but notice that there are more type args than foralls in
--   <a>undefined</a>s type.
applyTys :: Type -> [KindOrType] -> Type
applyTysD :: SDoc -> Type -> [Type] -> Type
applyTysX :: [TyVar] -> Type -> [Type] -> Type

-- | Equivalent to <tt>snd . splitForAllTys</tt>
dropForAlls :: Type -> Type
mkNumLitTy :: Integer -> Type

-- | Is this a numeric literal. We also look through type synonyms.
isNumLitTy :: Type -> Maybe Integer
mkStrLitTy :: FastString -> Type

-- | Is this a symbol literal. We also look through type synonyms.
isStrLitTy :: Type -> Maybe FastString

-- | Get the type on the LHS of a coercion induced by a type/data family
--   instance.
coAxNthLHS :: CoAxiom br -> Int -> Type

-- | Unwrap one <tt>layer</tt> of newtype on a type constructor and its
--   arguments, using an eta-reduced version of the <tt>newtype</tt> if
--   possible. This requires tys to have at least <tt>newTyConInstArity
--   tycon</tt> elements.
newTyConInstRhs :: TyCon -> [Type] -> Type

-- | Given a family instance TyCon and its arg types, return the
--   corresponding family type. E.g:
--   
--   <pre>
--   data family T a
--   data instance T (Maybe b) = MkT b
--   </pre>
--   
--   Where the instance tycon is :RTL, so:
--   
--   <pre>
--   mkFamilyTyConApp :RTL Int  =  T (Maybe Int)
--   </pre>
mkFamilyTyConApp :: TyCon -> [Type] -> Type
isDictLikeTy :: Type -> Bool

-- | Creates a type equality predicate
mkEqPred :: Type -> Type -> PredType
mkCoerciblePred :: Type -> Type -> PredType
mkPrimEqPred :: Type -> Type -> Type
mkReprPrimEqPred :: Type -> Type -> Type
mkClassPred :: Class -> [Type] -> PredType
isClassPred :: PredType -> Bool
isEqPred :: PredType -> Bool
isIPPred :: PredType -> Bool
isIPPred_maybe :: Type -> Maybe (FastString, Type)
isIPTyCon :: TyCon -> Bool
isIPClass :: Class -> Bool
data PredTree
[ClassPred] :: Class -> [Type] -> PredTree
[EqPred] :: EqRel -> Type -> Type -> PredTree
[TuplePred] :: [PredType] -> PredTree
[IrredPred] :: PredType -> PredTree

-- | A choice of equality relation. This is separate from the type
--   <a>Role</a> because <a>Phantom</a> does not define a (non-trivial)
--   equality relation.
data EqRel
[NomEq] :: EqRel
[ReprEq] :: EqRel
eqRelRole :: EqRel -> Role
classifyPredType :: PredType -> PredTree
getClassPredTys :: PredType -> (Class, [Type])
getClassPredTys_maybe :: PredType -> Maybe (Class, [Type])
getEqPredTys :: PredType -> (Type, Type)
getEqPredTys_maybe :: PredType -> Maybe (Role, Type, Type)
getEqPredRole :: PredType -> Role

-- | Get the equality relation relevant for a pred type.
predTypeEqRel :: PredType -> EqRel
funTyCon :: TyCon
isTypeVar :: Var -> Bool
isKindVar :: Var -> Bool
allDistinctTyVars :: [KindOrType] -> Bool
isForAllTy :: Type -> Bool
isTyVarTy :: Type -> Bool
isFunTy :: Type -> Bool
isDictTy :: Type -> Bool
isPredTy :: Type -> Bool
isVoidTy :: Type -> Bool

-- | See <a>Type#type_classification</a> for what an unlifted type is
isUnLiftedType :: Type -> Bool
isUnboxedTupleType :: Type -> Bool

-- | See <a>Type#type_classification</a> for what an algebraic type is.
--   Should only be applied to <i>types</i>, as opposed to e.g. partially
--   saturated type constructors
isAlgType :: Type -> Bool

-- | See <a>Type#type_classification</a> for what an algebraic type is.
--   Should only be applied to <i>types</i>, as opposed to e.g. partially
--   saturated type constructors. Closed type constructors are those with a
--   fixed right hand side, as opposed to e.g. associated types
isClosedAlgType :: Type -> Bool

-- | Returns true of types that are opaque to Haskell.
isPrimitiveType :: Type -> Bool

-- | Computes whether an argument (or let right hand side) should be
--   computed strictly or lazily, based only on its type. Currently, it's
--   just <a>isUnLiftedType</a>.
isStrictType :: Type -> Bool

-- | The key type representing kinds in the compiler. Invariant: a kind is
--   always in one of these forms:
--   
--   <pre>
--   FunTy k1 k2
--   TyConApp PrimTyCon [...]
--   TyVar kv   -- (during inference only)
--   ForAll ... -- (for top-level coercions)
--   </pre>
type Kind = Type
type SimpleKind = Kind
type MetaKindVar = TyVar
typeKind :: Type -> Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
anyKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
liftedTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
unliftedTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
openTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
constraintKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
superKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
liftedTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
openTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
unliftedTypeKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
constraintKindTyCon :: TyCon

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   the <a>Kind</a> <a>TyCon</a>s
anyKindTyCon :: TyCon

-- | NB: for type synonyms tyVarsOfType does <i>not</i> expand the synonym
--   tyVarsOfType returns only the free variables of a type For example,
--   tyVarsOfType (a::k) returns {a}, not including the kind variable {k}
tyVarsOfType :: Type -> VarSet
tyVarsOfTypes :: [Type] -> TyVarSet
closeOverKinds :: TyVarSet -> TyVarSet

-- | Expand out all type synonyms. Actually, it'd suffice to expand out
--   just the ones that discard type variables (e.g. type Funny a = Int)
--   But we don't know which those are currently, so we just expand all.
expandTypeSynonyms :: Type -> Type
typeSize :: Type -> Int
varSetElemsKvsFirst :: VarSet -> [TyVar]

-- | Type equality on source types. Does not look through <tt>newtypes</tt>
--   or <a>PredType</a>s, but it does look through type synonyms. Watch out
--   for horrible hack: See Note [Comparison with OpenTypeKind]
eqType :: Type -> Type -> Bool
eqTypeX :: RnEnv2 -> Type -> Type -> Bool
eqTypes :: [Type] -> [Type] -> Bool
cmpType :: Type -> Type -> Ordering
cmpTypes :: [Type] -> [Type] -> Ordering
eqPred :: PredType -> PredType -> Bool
eqPredX :: RnEnv2 -> PredType -> PredType -> Bool
cmpPred :: PredType -> PredType -> Ordering
eqKind :: Kind -> Kind -> Bool
eqTyVarBndrs :: RnEnv2 -> [TyVar] -> [TyVar] -> Maybe RnEnv2
seqType :: Type -> ()
seqTypes :: [Type] -> ()

-- | In Core, we "look through" non-recursive newtypes and
--   <tt>PredTypes</tt>: this function tries to obtain a different view of
--   the supplied type given this
--   
--   Strips off the <i>top layer only</i> of a type to give its underlying
--   representation type. Returns Nothing if there is nothing to look
--   through.
--   
--   By being non-recursive and inlined, this case analysis gets
--   efficiently joined onto the case analysis that the caller is already
--   doing
coreView :: Type -> Maybe Type

-- | Similar to <a>coreView</a>, but for the type checker, which just looks
--   through synonyms
tcView :: Type -> Maybe Type
type UnaryType = Type
data RepType
[UbxTupleRep] :: [UnaryType] -> RepType
[UnaryRep] :: UnaryType -> RepType
flattenRepType :: RepType -> [UnaryType]

-- | Looks through:
--   
--   <ol>
--   <li>For-alls</li>
--   <li>Synonyms</li>
--   <li>Predicates</li>
--   <li>All newtypes, including recursive ones, but not newtype
--   families</li>
--   </ol>
--   
--   It's useful in the back end of the compiler.
repType :: Type -> RepType

-- | All type constructors occurring in the type; looking through type
--   synonyms, but not newtypes. When it finds a Class, it returns the
--   class TyCon.
tyConsOfType :: Type -> NameEnv TyCon

-- | Discovers the primitive representation of a more abstract
--   <a>UnaryType</a>
typePrimRep :: UnaryType -> PrimRep
typeRepArity :: Arity -> Type -> RepArity

-- | A substitution of <a>Type</a>s for <a>TyVar</a>s and <a>Kind</a>s for
--   <a>KindVar</a>s
type TvSubstEnv = TyVarEnv Type

-- | Type substitution
--   
--   The following invariants must hold of a <a>TvSubst</a>:
--   
--   <ol>
--   <li>The in-scope set is needed <i>only</i> to guide the generation of
--   fresh uniques</li>
--   <li>In particular, the <i>kind</i> of the type variables in the
--   in-scope set is not relevant</li>
--   <li>The substitution is only applied ONCE! This is because in general
--   such application will not reached a fixed point.</li>
--   </ol>
data TvSubst
[TvSubst] :: InScopeSet -> TvSubstEnv -> TvSubst
emptyTvSubstEnv :: TvSubstEnv
emptyTvSubst :: TvSubst
mkTvSubst :: InScopeSet -> TvSubstEnv -> TvSubst

-- | Generates the in-scope set for the <a>TvSubst</a> from the types in
--   the incoming environment, hence "open"
mkOpenTvSubst :: TvSubstEnv -> TvSubst

-- | Generates the in-scope set for the <a>TvSubst</a> from the types in
--   the incoming environment, hence "open"
zipOpenTvSubst :: [TyVar] -> [Type] -> TvSubst
zipTopTvSubst :: [TyVar] -> [Type] -> TvSubst

-- | Called when doing top-level substitutions. Here we expect that the
--   free vars of the range of the substitution will be empty.
mkTopTvSubst :: [(TyVar, Type)] -> TvSubst
notElemTvSubst :: CoVar -> TvSubst -> Bool
getTvSubstEnv :: TvSubst -> TvSubstEnv
setTvSubstEnv :: TvSubst -> TvSubstEnv -> TvSubst
zapTvSubstEnv :: TvSubst -> TvSubst
getTvInScope :: TvSubst -> InScopeSet
extendTvInScope :: TvSubst -> Var -> TvSubst
extendTvInScopeList :: TvSubst -> [Var] -> TvSubst
extendTvSubst :: TvSubst -> TyVar -> Type -> TvSubst
extendTvSubstList :: TvSubst -> [TyVar] -> [Type] -> TvSubst
isInScope :: Var -> TvSubst -> Bool

-- | <tt>(compose env1 env2)(x)</tt> is <tt>env1(env2(x))</tt>; i.e. apply
--   <tt>env2</tt> then <tt>env1</tt>. It assumes that both are idempotent.
--   Typically, <tt>env1</tt> is the refinement to a base substitution
--   <tt>env2</tt>
composeTvSubst :: InScopeSet -> TvSubstEnv -> TvSubstEnv -> TvSubstEnv
zipTyEnv :: [TyVar] -> [Type] -> TvSubstEnv
isEmptyTvSubst :: TvSubst -> Bool
unionTvSubst :: TvSubst -> TvSubst -> TvSubst

-- | Substitute within a <a>Type</a>
substTy :: TvSubst -> Type -> Type

-- | Substitute within several <a>Type</a>s
substTys :: TvSubst -> [Type] -> [Type]

-- | Type substitution making use of an <a>TvSubst</a> that is assumed to
--   be open, see <a>zipOpenTvSubst</a>
substTyWith :: [TyVar] -> [Type] -> Type -> Type

-- | Type substitution making use of an <a>TvSubst</a> that is assumed to
--   be open, see <a>zipOpenTvSubst</a>
substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]

-- | Substitute within a <a>ThetaType</a>
substTheta :: TvSubst -> ThetaType -> ThetaType
substTyVar :: TvSubst -> TyVar -> Type
substTyVars :: TvSubst -> [TyVar] -> [Type]
substTyVarBndr :: TvSubst -> TyVar -> (TvSubst, TyVar)
cloneTyVarBndr :: TvSubst -> TyVar -> Unique -> (TvSubst, TyVar)

-- | Remove any nested binders mentioning the <a>TyVar</a>s in the
--   <a>TyVarSet</a>
deShadowTy :: TyVarSet -> Type -> Type
lookupTyVar :: TvSubst -> TyVar -> Maybe Type
substKiWith :: [KindVar] -> [Kind] -> Kind -> Kind
substKisWith :: [KindVar] -> [Kind] -> [Kind] -> [Kind]
pprType :: Type -> SDoc
pprParendType :: Type -> SDoc
pprTypeApp :: TyCon -> [Type] -> SDoc
pprTyThingCategory :: TyThing -> SDoc
pprTyThing :: TyThing -> SDoc
pprTvBndr :: TyVar -> SDoc
pprTvBndrs :: [TyVar] -> SDoc
pprForAll :: [TyVar] -> SDoc
pprUserForAll :: [TyVar] -> SDoc
pprSigmaType :: Type -> SDoc
pprTheta :: ThetaType -> SDoc
pprThetaArrowTy :: ThetaType -> SDoc
pprClassPred :: Class -> [Type] -> SDoc
pprKind :: Kind -> SDoc
pprParendKind :: Kind -> SDoc

-- | Pretty prints a <a>TyCon</a>, using the family instance in case of a
--   representation tycon. For example:
--   
--   <pre>
--   data T [a] = ...
--   </pre>
--   
--   In that case we want to print <tt>T [a]</tt>, where <tt>T</tt> is the
--   family <a>TyCon</a>
pprSourceTyCon :: TyCon -> SDoc
data TyPrec
[TopPrec] :: TyPrec
[FunPrec] :: TyPrec
[TyOpPrec] :: TyPrec
[TyConPrec] :: TyPrec
maybeParen :: TyPrec -> TyPrec -> SDoc -> SDoc
pprSigmaTypeExtraCts :: Bool -> Type -> SDoc
tidyType :: TidyEnv -> Type -> Type
tidyTypes :: TidyEnv -> [Type] -> [Type]

-- | Grabs the free type variables, tidies them and then uses
--   <a>tidyType</a> to work over the type itself
tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)
tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])
tidyOpenKind :: TidyEnv -> Kind -> (TidyEnv, Kind)
tidyTyVarBndr :: TidyEnv -> TyVar -> (TidyEnv, TyVar)

-- | This tidies up a type for printing in an error message, or in an
--   interface file.
--   
--   It doesn't change the uniques at all, just the print names.
tidyTyVarBndrs :: TidyEnv -> [TyVar] -> (TidyEnv, [TyVar])

-- | Add the free <a>TyVar</a>s to the env in tidy form, so that we can
--   tidy the type they are free in
tidyFreeTyVars :: TidyEnv -> TyVarSet -> TidyEnv

-- | Treat a new <a>TyVar</a> as a binder, and give it a fresh tidy name
--   using the environment if one has not already been allocated. See also
--   <a>tidyTyVarBndr</a>
tidyOpenTyVar :: TidyEnv -> TyVar -> (TidyEnv, TyVar)
tidyOpenTyVars :: TidyEnv -> [TyVar] -> (TidyEnv, [TyVar])
tidyTyVarOcc :: TidyEnv -> TyVar -> TyVar

-- | Calls <a>tidyType</a> on a top-level type (i.e. with an empty tidying
--   environment)
tidyTopType :: Type -> Type
tidyKind :: TidyEnv -> Kind -> Kind
instance Ord EqRel
instance Eq EqRel
instance Outputable EqRel
instance Eq Type
instance Outputable TvSubst

module Unify
tcMatchTy :: TyVarSet -> Type -> Type -> Maybe TvSubst
tcMatchTys :: TyVarSet -> [Type] -> [Type] -> Maybe TvSubst
tcMatchTyX :: TyVarSet -> TvSubst -> Type -> Type -> Maybe TvSubst
ruleMatchTyX :: MatchEnv -> TvSubstEnv -> Type -> Type -> Maybe TvSubstEnv
tcMatchPreds :: [TyVar] -> [PredType] -> [PredType] -> Maybe TvSubstEnv
data MatchEnv
[ME] :: VarSet -> RnEnv2 -> MatchEnv
[me_tmpls] :: MatchEnv -> VarSet
[me_env] :: MatchEnv -> RnEnv2
matchList :: (env -> a -> b -> Maybe env) -> env -> [a] -> [b] -> Maybe env
typesCantMatch :: [(Type, Type)] -> Bool
tcUnifyTy :: Type -> Type -> Maybe TvSubst
tcUnifyTys :: (TyVar -> BindFlag) -> [Type] -> [Type] -> Maybe TvSubst
data BindFlag
[BindMe] :: BindFlag
[Skolem] :: BindFlag
data UnifyResultM a
[Unifiable] :: a -> UnifyResultM a
[MaybeApart] :: a -> UnifyResultM a
[SurelyApart] :: UnifyResultM a
type UnifyResult = UnifyResultM TvSubst
tcUnifyTysFG :: (TyVar -> BindFlag) -> [Type] -> [Type] -> UnifyResult
instance Functor UM
instance Applicative UM
instance Monad UM


-- | Module for (a) type kinds and (b) type coercions, as used in System
--   FC. See <a>Expr</a> for more on System FC and how coercions fit into
--   it.
module Coercion

-- | A <a>Coercion</a> is concrete evidence of the equality/convertibility
--   of two types.
data Coercion
[Refl] :: Role -> Type -> Coercion
[TyConAppCo] :: Role -> TyCon -> [Coercion] -> Coercion
[AppCo] :: Coercion -> Coercion -> Coercion
[ForAllCo] :: TyVar -> Coercion -> Coercion
[CoVarCo] :: CoVar -> Coercion
[AxiomInstCo] :: (CoAxiom Branched) -> BranchIndex -> [Coercion] -> Coercion
[UnivCo] :: FastString -> Role -> Type -> Type -> Coercion
[SymCo] :: Coercion -> Coercion
[TransCo] :: Coercion -> Coercion -> Coercion
[AxiomRuleCo] :: CoAxiomRule -> [Type] -> [Coercion] -> Coercion
[NthCo] :: Int -> Coercion -> Coercion
[LRCo] :: LeftOrRight -> Coercion -> Coercion
[InstCo] :: Coercion -> Type -> Coercion
[SubCo] :: Coercion -> Coercion

-- | Essentially a typed <a>Name</a>, that may also contain some additional
--   information about the <a>Var</a> and it's use sites.
data Var
type CoVar = Id
data LeftOrRight
[CLeft] :: LeftOrRight
[CRight] :: LeftOrRight
pickLR :: LeftOrRight -> (a, a) -> a
data Role
[Nominal] :: Role
[Representational] :: Role
[Phantom] :: Role
ltRole :: Role -> Role -> Bool
coVarKind :: CoVar -> (Type, Type)
coVarRole :: CoVar -> Role
coercionType :: Coercion -> Type

-- | If it is the case that
--   
--   <pre>
--   c :: (t1 ~ t2)
--   </pre>
--   
--   i.e. the kind of <tt>c</tt> relates <tt>t1</tt> and <tt>t2</tt>, then
--   <tt>coercionKind c = Pair t1 t2</tt>.
coercionKind :: Coercion -> Pair Type

-- | Apply <a>coercionKind</a> to multiple <a>Coercion</a>s
coercionKinds :: [Coercion] -> Pair [Type]
isReflCo :: Coercion -> Bool
isReflCo_maybe :: Coercion -> Maybe Type

-- | Retrieve the role from a coercion.
coercionRole :: Coercion -> Role

-- | Get a coercion's kind and role. Why both at once? See Note [Computing
--   a coercion kind and role]
coercionKindRole :: Coercion -> (Pair Type, Role)

-- | Makes a coercion type from two types: the types whose equality is
--   proven by the relevant <a>Coercion</a>
mkCoercionType :: Role -> Type -> Type -> Type
mkReflCo :: Role -> Type -> Coercion
mkCoVarCo :: CoVar -> Coercion
mkAxInstCo :: Role -> CoAxiom br -> BranchIndex -> [Type] -> Coercion
mkUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [Type] -> Coercion
mkAxInstLHS :: CoAxiom br -> BranchIndex -> [Type] -> Type
mkAxInstRHS :: CoAxiom br -> BranchIndex -> [Type] -> Type
mkUnbranchedAxInstRHS :: CoAxiom Unbranched -> [Type] -> Type
mkPiCo :: Role -> Var -> Coercion -> Coercion
mkPiCos :: Role -> [Var] -> Coercion -> Coercion
mkCoCast :: Coercion -> Coercion -> Coercion

-- | Create a symmetric version of the given <a>Coercion</a> that asserts
--   equality between the same types but in the other "direction", so a
--   kind of <tt>t1 ~ t2</tt> becomes the kind <tt>t2 ~ t1</tt>.
mkSymCo :: Coercion -> Coercion

-- | Create a new <a>Coercion</a> by composing the two given
--   <a>Coercion</a>s transitively.
mkTransCo :: Coercion -> Coercion -> Coercion
mkNthCo :: Int -> Coercion -> Coercion
mkNthCoRole :: Role -> Int -> Coercion -> Coercion
mkLRCo :: LeftOrRight -> Coercion -> Coercion

-- | Instantiates a <a>Coercion</a> with a <a>Type</a> argument.
mkInstCo :: Coercion -> Type -> Coercion

-- | Apply a <a>Coercion</a> to another <a>Coercion</a>. The second
--   coercion must be Nominal, unless the first is Phantom. If the first is
--   Phantom, then the second can be either Phantom or Nominal.
mkAppCo :: Coercion -> Coercion -> Coercion

-- | Apply a <a>Coercion</a> to another <a>Coercion</a>. The second
--   <a>Coercion</a>s role is given, making this more flexible than
--   <a>mkAppCo</a>.
mkAppCoFlexible :: Coercion -> Role -> Coercion -> Coercion

-- | Apply a type constructor to a list of coercions. It is the caller's
--   responsibility to get the roles correct on argument coercions.
mkTyConAppCo :: Role -> TyCon -> [Coercion] -> Coercion

-- | Make a function <a>Coercion</a> between two other <a>Coercion</a>s
mkFunCo :: Role -> Coercion -> Coercion -> Coercion

-- | Make a <a>Coercion</a> which binds a variable within an inner
--   <a>Coercion</a>
mkForAllCo :: Var -> Coercion -> Coercion

-- | Manufacture an unsafe coercion from thin air. Currently (May 14) this
--   is used only to implement the <tt>unsafeCoerce#</tt> primitive.
--   Optimise by pushing down through type constructors.
mkUnsafeCo :: Type -> Type -> Coercion
mkUnivCo :: FastString -> Role -> Type -> Type -> Coercion
mkSubCo :: Coercion -> Coercion
mkPhantomCo :: Coercion -> Coercion

-- | Create a coercion constructor (axiom) suitable for the given newtype
--   <a>TyCon</a>. The <a>Name</a> should be that of a new coercion
--   <a>CoAxiom</a>, the <a>TyVar</a>s the arguments expected by the
--   <tt>newtype</tt> and the type the appropriate right hand side of the
--   <tt>newtype</tt>, with the free variables a subset of those
--   <a>TyVar</a>s.
mkNewTypeCo :: Name -> TyCon -> [TyVar] -> [Role] -> Type -> CoAxiom Unbranched
downgradeRole :: Role -> Role -> Coercion -> Coercion
mkAxiomRuleCo :: CoAxiomRule -> [Type] -> [Coercion] -> Coercion

-- | If <tt>co :: T ts ~ rep_ty</tt> then:
--   
--   <pre>
--   instNewTyCon_maybe T ts = Just (rep_ty, co)
--   </pre>
--   
--   Checks for a newtype, and for being saturated
instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, Coercion)

-- | A function to check if we can reduce a type by one step. Used with
--   <a>topNormaliseTypeX_maybe</a>.
type NormaliseStepper = RecTcChecker -> TyCon -> [Type] -> NormaliseStepResult

-- | The result of stepping in a normalisation function. See
--   <a>topNormaliseTypeX_maybe</a>.
data NormaliseStepResult

-- | nothing more to do
[NS_Done] :: NormaliseStepResult

-- | utter failure. The outer function should fail too.
[NS_Abort] :: NormaliseStepResult

-- | we stepped, yielding new bits; ^ co :: old type ~ new type
[NS_Step] :: RecTcChecker -> Type -> Coercion -> NormaliseStepResult

-- | Try one stepper and then try the next, if the first doesn't make
--   progress.
composeSteppers :: NormaliseStepper -> NormaliseStepper -> NormaliseStepper
modifyStepResultCo :: (Coercion -> Coercion) -> NormaliseStepResult -> NormaliseStepResult

-- | A <a>NormaliseStepper</a> that unwraps newtypes, careful not to fall
--   into a loop. If it would fall into a loop, it produces
--   <a>NS_Abort</a>.
unwrapNewTypeStepper :: NormaliseStepper

-- | Sometimes we want to look through a <tt>newtype</tt> and get its
--   associated coercion. This function strips off <tt>newtype</tt> layers
--   enough to reveal something that isn't a <tt>newtype</tt>, or responds
--   False to ok_tc. Specifically, here's the invariant:
--   
--   <pre>
--   topNormaliseNewType_maybe ty = Just (co, ty')
--   </pre>
--   
--   then (a) <tt>co : ty0 ~ ty'</tt>. (b) ty' is not a newtype.
--   
--   The function returns <tt>Nothing</tt> for non-<tt>newtypes</tt>, or
--   unsaturated applications
--   
--   This function does *not* look through type families, because it has no
--   access to the type family environment. If you do have that at hand,
--   consider to use topNormaliseType_maybe, which should be a drop-in
--   replacement for topNormaliseNewType_maybe
topNormaliseNewType_maybe :: Type -> Maybe (Coercion, Type)

-- | A general function for normalising the top-level of a type. It
--   continues to use the provided <a>NormaliseStepper</a> until that
--   function fails, and then this function returns. The roles of the
--   coercions produced by the <a>NormaliseStepper</a> must all be the
--   same, which is the role returned from the call to
--   <a>topNormaliseTypeX_maybe</a>.
topNormaliseTypeX_maybe :: NormaliseStepper -> Type -> Maybe (Coercion, Type)

-- | This breaks a <a>Coercion</a> with type <tt>T A B C ~ T D E F</tt>
--   into a list of <a>Coercion</a>s of kinds <tt>A ~ D</tt>, <tt>B ~
--   E</tt> and <tt>E ~ F</tt>. Hence:
--   
--   <pre>
--   decomposeCo 3 c = [nth 0 c, nth 1 c, nth 2 c]
--   </pre>
decomposeCo :: Arity -> Coercion -> [Coercion]

-- | Attempts to obtain the type variable underlying a <a>Coercion</a>
getCoVar_maybe :: Coercion -> Maybe CoVar

-- | Attempt to take a coercion application apart.
splitAppCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
splitForAllCo_maybe :: Coercion -> Maybe (TyVar, Coercion)
nthRole :: Role -> TyCon -> Int -> Role
tyConRolesX :: Role -> TyCon -> [Role]
setNominalRole_maybe :: Coercion -> Maybe Coercion
mkCoVar :: Name -> Type -> CoVar
isCoVar :: Var -> Bool
isCoVarType :: Type -> Bool
coVarName :: CoVar -> Name
setCoVarName :: CoVar -> Name -> CoVar
setCoVarUnique :: CoVar -> Unique -> CoVar
tyCoVarsOfCo :: Coercion -> VarSet
tyCoVarsOfCos :: [Coercion] -> VarSet
coVarsOfCo :: Coercion -> VarSet
coercionSize :: Coercion -> Int

-- | A substitution of <a>Coercion</a>s for <a>CoVar</a>s (OR
--   <a>TyVar</a>s, when doing a "lifting" substitution)
type CvSubstEnv = VarEnv Coercion
emptyCvSubstEnv :: CvSubstEnv
data CvSubst
[CvSubst] :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> CvSubst
emptyCvSubst :: CvSubst
lookupTyVar :: CvSubst -> TyVar -> Maybe Type
lookupCoVar :: CvSubst -> Var -> Maybe Coercion
isEmptyCvSubst :: CvSubst -> Bool
zapCvSubstEnv :: CvSubst -> CvSubst
getCvInScope :: CvSubst -> InScopeSet

-- | Substitute within a <a>Coercion</a>
substCo :: CvSubst -> Coercion -> Coercion

-- | Substitute within several <a>Coercion</a>s
substCos :: CvSubst -> [Coercion] -> [Coercion]
substCoVar :: CvSubst -> CoVar -> Coercion
substCoVars :: CvSubst -> [CoVar] -> [Coercion]
substCoWithTy :: InScopeSet -> TyVar -> Type -> Coercion -> Coercion
substCoWithTys :: InScopeSet -> [TyVar] -> [Type] -> Coercion -> Coercion
cvTvSubst :: CvSubst -> TvSubst
tvCvSubst :: TvSubst -> CvSubst
mkCvSubst :: InScopeSet -> [(Var, Coercion)] -> CvSubst
zipOpenCvSubst :: [Var] -> [Coercion] -> CvSubst
substTy :: CvSubst -> Type -> Type
extendTvSubst :: CvSubst -> TyVar -> Type -> CvSubst
extendCvSubstAndInScope :: CvSubst -> CoVar -> Coercion -> CvSubst
extendTvSubstAndInScope :: CvSubst -> TyVar -> Type -> CvSubst
substTyVarBndr :: CvSubst -> TyVar -> (CvSubst, TyVar)
substCoVarBndr :: CvSubst -> CoVar -> (CvSubst, CoVar)

-- | <a>liftCoMatch</a> is sort of inverse to <a>liftCoSubst</a>. In
--   particular, if <tt>liftCoMatch vars ty co == Just s</tt>, then
--   <tt>tyCoSubst s ty == co</tt>. That is, it matches a type against a
--   coercion of the same "shape", and returns a lifting substitution which
--   could have been used to produce the given coercion from the given
--   type.
liftCoMatch :: TyVarSet -> Type -> Coercion -> Maybe LiftCoSubst
liftCoSubstTyVar :: LiftCoSubst -> Role -> TyVar -> Maybe Coercion
liftCoSubstWith :: Role -> [TyVar] -> [Coercion] -> Type -> Coercion

-- | Determines syntactic equality of coercions
coreEqCoercion :: Coercion -> Coercion -> Bool
coreEqCoercion2 :: RnEnv2 -> Coercion -> Coercion -> Bool
seqCo :: Coercion -> ()
pprCo :: Coercion -> SDoc
pprParendCo :: Coercion -> SDoc
pprCoAxiom :: CoAxiom br -> SDoc
pprCoAxBranch :: TyCon -> CoAxBranch -> SDoc
pprCoAxBranchHdr :: CoAxiom br -> BranchIndex -> SDoc
tidyCo :: TidyEnv -> Coercion -> Coercion
tidyCos :: TidyEnv -> [Coercion] -> [Coercion]
applyCo :: Type -> Coercion -> Type
instance Data Coercion
instance Data LeftOrRight
instance Eq LeftOrRight
instance Binary LeftOrRight
instance Outputable Coercion
instance Outputable LeftOrRight
instance Outputable CvSubst

module PlaceHolder

-- | used as place holder in PostTc and PostRn values
data PlaceHolder
[PlaceHolder] :: PlaceHolder

-- | Types that are not defined until after type checking

-- | Types that are not defined until after renaming
placeHolderKind :: PlaceHolder
placeHolderFixity :: PlaceHolder
placeHolderType :: PlaceHolder
placeHolderTypeTc :: Type
placeHolderNames :: PlaceHolder
placeHolderNamesTc :: NameSet
type DataId id = (Data id, Data (PostRn id NameSet), Data (PostRn id Fixity), Data (PostRn id Bool), Data (PostRn id [Name]), Data (PostTc id Type), Data (PostTc id Coercion))
instance Data PlaceHolder

module HsLit
data HsLit
[HsChar] :: SourceText -> Char -> HsLit
[HsCharPrim] :: SourceText -> Char -> HsLit
[HsString] :: SourceText -> FastString -> HsLit
[HsStringPrim] :: SourceText -> ByteString -> HsLit
[HsInt] :: SourceText -> Integer -> HsLit
[HsIntPrim] :: SourceText -> Integer -> HsLit
[HsWordPrim] :: SourceText -> Integer -> HsLit
[HsInt64Prim] :: SourceText -> Integer -> HsLit
[HsWord64Prim] :: SourceText -> Integer -> HsLit
[HsInteger] :: SourceText -> Integer -> Type -> HsLit
[HsRat] :: FractionalLit -> Type -> HsLit
[HsFloatPrim] :: FractionalLit -> HsLit
[HsDoublePrim] :: FractionalLit -> HsLit
data HsOverLit id
[OverLit] :: OverLitVal -> PostRn id Bool -> SyntaxExpr id -> PostTc id Type -> HsOverLit id
[ol_val] :: HsOverLit id -> OverLitVal
[ol_rebindable] :: HsOverLit id -> PostRn id Bool
[ol_witness] :: HsOverLit id -> SyntaxExpr id
[ol_type] :: HsOverLit id -> PostTc id Type
data OverLitVal
[HsIntegral] :: !SourceText -> !Integer -> OverLitVal
[HsFractional] :: !FractionalLit -> OverLitVal
[HsIsString] :: !SourceText -> !FastString -> OverLitVal
overLitType :: HsOverLit a -> PostTc a Type
instance Data OverLitVal
instance Data HsLit
instance DataId id => Data (HsOverLit id)
instance Eq HsLit
instance Eq (HsOverLit id)
instance Eq OverLitVal
instance Ord (HsOverLit id)
instance Ord OverLitVal
instance Outputable HsLit
instance OutputableBndr id => Outputable (HsOverLit id)
instance Outputable OverLitVal

module DataCon

-- | A data constructor
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnClose</a>,<a>AnnComma</a></li>
--   </ul>
data DataCon
data DataConRep
[NoDataConRep] :: DataConRep
[DCR] :: Id -> DataConBoxer -> [Type] -> [StrictnessMark] -> [HsImplBang] -> DataConRep
[dcr_wrap_id] :: DataConRep -> Id
[dcr_boxer] :: DataConRep -> DataConBoxer
[dcr_arg_tys] :: DataConRep -> [Type]
[dcr_stricts] :: DataConRep -> [StrictnessMark]
[dcr_bangs] :: DataConRep -> [HsImplBang]
data HsBang
[HsNoBang] :: HsBang
[HsSrcBang] :: (Maybe SourceText) -> (Maybe Bool) -> Bool -> HsBang
[HsUnpack] :: (Maybe Coercion) -> HsBang
[HsStrict] :: HsBang
type HsSrcBang = HsBang
type HsImplBang = HsBang
data StrictnessMark
[MarkedStrict] :: StrictnessMark
[NotMarkedStrict] :: StrictnessMark

-- | Type of the tags associated with each constructor possibility
type ConTag = Int

-- | Build a new data constructor
mkDataCon :: Name -> Bool -> [HsBang] -> [FieldLabel] -> [TyVar] -> [TyVar] -> [(TyVar, Type)] -> ThetaType -> [Type] -> Type -> TyCon -> ThetaType -> Id -> DataConRep -> DataCon

-- | Tags are allocated from here for real constructors
fIRST_TAG :: ConTag
buildAlgTyCon :: Name -> [TyVar] -> [Role] -> Maybe CType -> ThetaType -> AlgTyConRhs -> RecFlag -> Bool -> Bool -> TyConParent -> TyCon

-- | The representation type of the data constructor, i.e. the sort type
--   that will represent values of this type at runtime
dataConRepType :: DataCon -> Type

-- | The "signature" of the <a>DataCon</a> returns, in order:
--   
--   1) The result of <a>dataConAllTyVars</a>,
--   
--   2) All the <a>ThetaType</a>s relating to the <a>DataCon</a> (coercion,
--   dictionary, implicit parameter - whatever)
--   
--   3) The type arguments to the constructor
--   
--   4) The <i>original</i> result type of the <a>DataCon</a>
dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)

-- | The "full signature" of the <a>DataCon</a> returns, in order:
--   
--   1) The result of <a>dataConUnivTyVars</a>
--   
--   2) The result of <a>dataConExTyVars</a>
--   
--   3) The result of <a>dataConEqSpec</a>
--   
--   4) The result of <tt>dataConDictTheta</tt>
--   
--   5) The original argument types to the <a>DataCon</a> (i.e. before any
--   change of the representation of the type)
--   
--   6) The original result type of the <a>DataCon</a>
dataConFullSig :: DataCon -> ([TyVar], [TyVar], [(TyVar, Type)], ThetaType, [Type], Type)

-- | The <a>Name</a> of the <a>DataCon</a>, giving it a unique, rooted
--   identification
dataConName :: DataCon -> Name

-- | The string <tt>package:module.name</tt> identifying a constructor,
--   which is attached to its info table and used by the GHCi debugger and
--   the heap profiler
dataConIdentity :: DataCon -> [Word8]

-- | The tag used for ordering <a>DataCon</a>s
dataConTag :: DataCon -> ConTag

-- | The type constructor that we are building via this data constructor
dataConTyCon :: DataCon -> TyCon

-- | The original type constructor used in the definition of this data
--   constructor. In case of a data family instance, that will be the
--   family type constructor.
dataConOrigTyCon :: DataCon -> TyCon

-- | The user-declared type of the data constructor in the nice-to-read
--   form:
--   
--   <pre>
--   T :: forall a b. a -&gt; b -&gt; T [a]
--   </pre>
--   
--   rather than:
--   
--   <pre>
--   T :: forall a c. forall b. (c~[a]) =&gt; a -&gt; b -&gt; T c
--   </pre>
--   
--   NB: If the constructor is part of a data instance, the result type
--   mentions the family tycon, not the internal one.
dataConUserType :: DataCon -> Type

-- | The universally-quantified type variables of the constructor
dataConUnivTyVars :: DataCon -> [TyVar]

-- | The existentially-quantified type variables of the constructor
dataConExTyVars :: DataCon -> [TyVar]

-- | Both the universal and existentiatial type variables of the
--   constructor
dataConAllTyVars :: DataCon -> [TyVar]

-- | Equalities derived from the result type of the data constructor, as
--   written by the programmer in any GADT declaration
dataConEqSpec :: DataCon -> [(TyVar, Type)]
eqSpecPreds :: [(TyVar, Type)] -> ThetaType

-- | The *full* constraints on the constructor type
dataConTheta :: DataCon -> ThetaType

-- | The "stupid theta" of the <a>DataCon</a>, such as <tt>data Eq a</tt>
--   in:
--   
--   <pre>
--   data Eq a =&gt; T a = ...
--   </pre>
dataConStupidTheta :: DataCon -> ThetaType

-- | Finds the instantiated types of the arguments required to construct a
--   <a>DataCon</a> representation NB: these INCLUDE any dictionary args
--   but EXCLUDE the data-declaration context, which is discarded It's all
--   post-flattening etc; this is a representation type
dataConInstArgTys :: DataCon -> [Type] -> [Type]

-- | Returns the argument types of the wrapper, excluding all dictionary
--   arguments and without substituting for any type variables
dataConOrigArgTys :: DataCon -> [Type]
dataConOrigResTy :: DataCon -> Type

-- | Returns just the instantiated <i>value</i> argument types of a
--   <a>DataCon</a>, (excluding dictionary args)
dataConInstOrigArgTys :: DataCon -> [Type] -> [Type]

-- | Returns the arg types of the worker, including *all* evidence, after
--   any flattening has been done and without substituting for any type
--   variables
dataConRepArgTys :: DataCon -> [Type]

-- | The labels for the fields of this particular <a>DataCon</a>
dataConFieldLabels :: DataCon -> [FieldLabel]

-- | Extract the type for any given labelled field of the <a>DataCon</a>
dataConFieldType :: DataCon -> FieldLabel -> Type

-- | The strictness markings written by the porgrammer. The list is in
--   one-to-one correspondence with the arity of the <a>DataCon</a>
dataConSrcBangs :: DataCon -> [HsSrcBang]

-- | Source-level arity of the data constructor
dataConSourceArity :: DataCon -> Arity

-- | Gives the number of actual fields in the <i>representation</i> of the
--   data constructor. This may be more than appear in the source code; the
--   extra ones are the existentially quantified dictionaries
dataConRepArity :: DataCon -> Arity

-- | The number of fields in the <i>representation</i> of the constructor
--   AFTER taking into account the unpacking of any unboxed tuple fields
dataConRepRepArity :: DataCon -> RepArity

-- | Should the <a>DataCon</a> be presented infix?
dataConIsInfix :: DataCon -> Bool

-- | Get the Id of the <a>DataCon</a> worker: a function that is the
--   "actual" constructor and has no top level binding in the program. The
--   type may be different from the obvious one written in the source
--   program. Panics if there is no such <a>Id</a> for this <a>DataCon</a>
dataConWorkId :: DataCon -> Id

-- | Returns an Id which looks like the Haskell-source constructor by using
--   the wrapper if it exists (see <a>dataConWrapId_maybe</a>) and failing
--   over to the worker (see <a>dataConWorkId</a>)
dataConWrapId :: DataCon -> Id

-- | Get the Id of the <a>DataCon</a> wrapper: a function that wraps the
--   "actual" constructor so it has the type visible in the source program:
--   c.f. <a>dataConWorkId</a>. Returns Nothing if there is no wrapper,
--   which occurs for an algebraic data constructor and also for a newtype
--   (whose constructor is inlined compulsorily)
dataConWrapId_maybe :: DataCon -> Maybe Id

-- | Find all the <a>Id</a>s implicitly brought into scope by the data
--   constructor. Currently, the union of the <a>dataConWorkId</a> and the
--   <a>dataConWrapId</a>
dataConImplicitIds :: DataCon -> [Id]

-- | Give the demands on the arguments of a Core constructor application
--   (Con dc args)
dataConRepStrictness :: DataCon -> [StrictnessMark]
dataConImplBangs :: DataCon -> [HsImplBang]
dataConBoxer :: DataCon -> Maybe DataConBoxer

-- | Extract the type constructor, type argument, data constructor and it's
--   <i>representation</i> argument types from a type if it is a product
--   type.
--   
--   Precisely, we return <tt>Just</tt> for any type that is all of:
--   
--   <ul>
--   <li>Concrete (i.e. constructors visible)</li>
--   <li>Single-constructor</li>
--   <li>Not existentially quantified</li>
--   </ul>
--   
--   Whether the type is a <tt>data</tt> type or a <tt>newtype</tt>
splitDataProductType_maybe :: Type -> Maybe (TyCon, [Type], DataCon, [Type])

-- | Return whether there are any argument types for this <a>DataCon</a>s
--   original source type
isNullarySrcDataCon :: DataCon -> Bool

-- | Return whether there are any argument types for this <a>DataCon</a>s
--   runtime representation type
isNullaryRepDataCon :: DataCon -> Bool
isTupleDataCon :: DataCon -> Bool
isUnboxedTupleCon :: DataCon -> Bool

-- | Vanilla <a>DataCon</a>s are those that are nice boring Haskell 98
--   constructors
isVanillaDataCon :: DataCon -> Bool
classDataCon :: Class -> DataCon
dataConCannotMatch :: [Type] -> DataCon -> Bool
isBanged :: HsBang -> Bool
isMarkedStrict :: StrictnessMark -> Bool
eqHsBang :: HsBang -> HsBang -> Bool
promoteKind :: Kind -> SuperKind
promoteDataCon :: DataCon -> TyCon
promoteDataCon_maybe :: DataCon -> Maybe TyCon
instance Data HsBang
instance Eq DataCon
instance Ord DataCon
instance Uniquable DataCon
instance NamedThing DataCon
instance Outputable DataCon
instance OutputableBndr DataCon
instance Data DataCon
instance Outputable HsBang
instance Outputable StrictnessMark

module Demand
data StrDmd
data UseDmd
[UCall] :: Count -> UseDmd -> UseDmd
[UProd] :: [MaybeUsed] -> UseDmd
[UHead] :: UseDmd
[Used] :: UseDmd
data Count
[One] :: Count
[Many] :: Count
countOnce :: Count
countMany :: Count
type Demand = JointDmd
data CleanDemand
mkProdDmd :: [JointDmd] -> CleanDemand
mkOnceUsedDmd :: CleanDemand -> JointDmd
mkManyUsedDmd :: CleanDemand -> JointDmd
mkHeadStrict :: CleanDemand -> CleanDemand
oneifyDmd :: JointDmd -> JointDmd
getUsage :: CleanDemand -> UseDmd
toCleanDmd :: Demand -> Type -> (CleanDemand, DeferAndUseM)
absDmd :: JointDmd
topDmd :: JointDmd
botDmd :: JointDmd
seqDmd :: JointDmd
lubDmd :: JointDmd -> JointDmd -> JointDmd
bothDmd :: JointDmd -> JointDmd -> JointDmd
apply1Dmd :: Demand
apply2Dmd :: Demand
isTopDmd :: JointDmd -> Bool
isBotDmd :: JointDmd -> Bool
isAbsDmd :: JointDmd -> Bool
isSeqDmd :: JointDmd -> Bool
peelUseCall :: UseDmd -> Maybe (Count, UseDmd)
cleanUseDmd_maybe :: JointDmd -> Maybe UseDmd
strictenDmd :: JointDmd -> CleanDemand
bothCleanDmd :: CleanDemand -> CleanDemand -> CleanDemand
data DmdType
[DmdType] :: DmdEnv -> [Demand] -> DmdResult -> DmdType
dmdTypeDepth :: DmdType -> Arity
lubDmdType :: DmdType -> DmdType -> DmdType
bothDmdType :: DmdType -> BothDmdArg -> DmdType
nopDmdType :: DmdType
botDmdType :: DmdType
mkDmdType :: DmdEnv -> [Demand] -> DmdResult -> DmdType
addDemand :: Demand -> DmdType -> DmdType
removeDmdTyArgs :: DmdType -> DmdType
type BothDmdArg = (DmdEnv, Termination ())
mkBothDmdArg :: DmdEnv -> BothDmdArg
toBothDmdArg :: DmdType -> BothDmdArg
type DmdEnv = VarEnv Demand
emptyDmdEnv :: VarEnv Demand
peelFV :: DmdType -> Var -> (DmdType, Demand)
type DmdResult = Termination CPRResult
data CPRResult
isBotRes :: DmdResult -> Bool
isTopRes :: DmdResult -> Bool
topRes :: DmdResult
botRes :: DmdResult
cprProdRes :: [DmdType] -> DmdResult
vanillaCprProdRes :: Arity -> DmdResult
cprSumRes :: ConTag -> DmdResult
appIsBottom :: StrictSig -> Int -> Bool
isBottomingSig :: StrictSig -> Bool
pprIfaceStrictSig :: StrictSig -> SDoc
trimCPRInfo :: Bool -> Bool -> DmdResult -> DmdResult
returnsCPR_maybe :: DmdResult -> Maybe ConTag
newtype StrictSig
[StrictSig] :: DmdType -> StrictSig
mkStrictSig :: DmdType -> StrictSig
mkClosedStrictSig :: [Demand] -> DmdResult -> StrictSig
nopSig :: StrictSig
botSig :: StrictSig
cprProdSig :: Arity -> StrictSig
isNopSig :: StrictSig -> Bool
splitStrictSig :: StrictSig -> ([Demand], DmdResult)
increaseStrictSigArity :: Int -> StrictSig -> StrictSig
seqDemand :: JointDmd -> ()
seqDemandList :: [JointDmd] -> ()
seqDmdType :: DmdType -> ()
seqStrictSig :: StrictSig -> ()
evalDmd :: JointDmd
cleanEvalDmd :: CleanDemand
cleanEvalProdDmd :: Arity -> CleanDemand
isStrictDmd :: Demand -> Bool
splitDmdTy :: DmdType -> (Demand, DmdType)
splitFVs :: Bool -> DmdEnv -> (DmdEnv, DmdEnv)
deferAfterIO :: DmdType -> DmdType
postProcessUnsat :: DeferAndUse -> DmdType -> DmdType
postProcessDmdTypeM :: DeferAndUseM -> DmdType -> BothDmdArg
splitProdDmd_maybe :: JointDmd -> Maybe [JointDmd]
peelCallDmd :: CleanDemand -> (CleanDemand, DeferAndUse)
mkCallDmd :: CleanDemand -> CleanDemand
dmdTransformSig :: StrictSig -> CleanDemand -> DmdType
dmdTransformDataConSig :: Arity -> StrictSig -> CleanDemand -> DmdType
dmdTransformDictSelSig :: StrictSig -> CleanDemand -> DmdType
argOneShots :: OneShotInfo -> JointDmd -> [OneShotInfo]
argsOneShots :: StrictSig -> Arity -> [[OneShotInfo]]
trimToType :: JointDmd -> TypeShape -> JointDmd
data TypeShape
[TsFun] :: TypeShape -> TypeShape
[TsProd] :: [TypeShape] -> TypeShape
[TsUnk] :: TypeShape
isSingleUsed :: JointDmd -> Bool
reuseEnv :: DmdEnv -> DmdEnv
zapDemand :: DynFlags -> Demand -> Demand
zapStrictSig :: DynFlags -> StrictSig -> StrictSig
strictifyDictDmd :: Type -> Demand -> Demand
instance Eq StrictSig
instance Show CPRResult
instance Eq CPRResult
instance Show r => Show (Termination r)
instance Eq r => Eq (Termination r)
instance Show CleanDemand
instance Eq CleanDemand
instance Show JointDmd
instance Eq JointDmd
instance Show MaybeUsed
instance Eq MaybeUsed
instance Show UseDmd
instance Eq UseDmd
instance Show Count
instance Eq Count
instance Show StrDmd
instance Eq StrDmd
instance Show MaybeStr
instance Eq MaybeStr
instance Outputable StrDmd
instance Outputable MaybeStr
instance Outputable MaybeUsed
instance Outputable UseDmd
instance Outputable Count
instance Outputable JointDmd
instance Outputable CleanDemand
instance Outputable TypeShape
instance Outputable DmdResult
instance Outputable CPRResult
instance Eq DmdType
instance Outputable DmdType
instance Outputable StrictSig
instance Binary StrDmd
instance Binary MaybeStr
instance Binary Count
instance Binary MaybeUsed
instance Binary UseDmd
instance Binary JointDmd
instance Binary StrictSig
instance Binary DmdType
instance Binary DmdResult
instance Binary CPRResult

module Literal

-- | So-called <a>Literal</a>s are one of:
--   
--   <ul>
--   <li>An unboxed (<i>machine</i>) literal (<a>MachInt</a>,
--   <a>MachFloat</a>, etc.), which is presumed to be surrounded by
--   appropriate constructors (<tt>Int#</tt>, etc.), so that the overall
--   thing makes sense.</li>
--   <li>The literal derived from the label mentioned in a "foreign label"
--   declaration (<a>MachLabel</a>)</li>
--   </ul>
data Literal

-- | <tt>Char#</tt> - at least 31 bits. Create with <a>mkMachChar</a>
[MachChar] :: Char -> Literal

-- | A string-literal: stored and emitted UTF-8 encoded, we'll arrange to
--   decode it at runtime. Also emitted with a <tt>'\0'</tt> terminator.
--   Create with <a>mkMachString</a>
[MachStr] :: ByteString -> Literal

-- | The <tt>NULL</tt> pointer, the only pointer value that can be
--   represented as a Literal. Create with <a>nullAddrLit</a>
[MachNullAddr] :: Literal

-- | <tt>Int#</tt> - at least <tt>WORD_SIZE_IN_BITS</tt> bits. Create with
--   <a>mkMachInt</a>
[MachInt] :: Integer -> Literal

-- | <tt>Int64#</tt> - at least 64 bits. Create with <a>mkMachInt64</a>
[MachInt64] :: Integer -> Literal

-- | <tt>Word#</tt> - at least <tt>WORD_SIZE_IN_BITS</tt> bits. Create with
--   <a>mkMachWord</a>
[MachWord] :: Integer -> Literal

-- | <tt>Word64#</tt> - at least 64 bits. Create with <a>mkMachWord64</a>
[MachWord64] :: Integer -> Literal

-- | <tt>Float#</tt>. Create with <a>mkMachFloat</a>
[MachFloat] :: Rational -> Literal

-- | <tt>Double#</tt>. Create with <a>mkMachDouble</a>
[MachDouble] :: Rational -> Literal

-- | A label literal. Parameters:
--   
--   1) The name of the symbol mentioned in the declaration
--   
--   2) The size (in bytes) of the arguments the label expects. Only
--   applicable with <tt>stdcall</tt> labels. <tt>Just x</tt> =&gt;
--   <tt>&lt;x&gt;</tt> will be appended to label name when emitting
--   assembly.
[MachLabel] :: FastString -> (Maybe Int) -> FunctionOrData -> Literal
[LitInteger] :: Integer -> Type -> Literal

-- | Creates a <a>Literal</a> of type <tt>Int#</tt>
mkMachInt :: DynFlags -> Integer -> Literal

-- | Creates a <a>Literal</a> of type <tt>Word#</tt>
mkMachWord :: DynFlags -> Integer -> Literal

-- | Creates a <a>Literal</a> of type <tt>Int64#</tt>
mkMachInt64 :: Integer -> Literal

-- | Creates a <a>Literal</a> of type <tt>Word64#</tt>
mkMachWord64 :: Integer -> Literal

-- | Creates a <a>Literal</a> of type <tt>Float#</tt>
mkMachFloat :: Rational -> Literal

-- | Creates a <a>Literal</a> of type <tt>Double#</tt>
mkMachDouble :: Rational -> Literal

-- | Creates a <a>Literal</a> of type <tt>Char#</tt>
mkMachChar :: Char -> Literal

-- | Creates a <a>Literal</a> of type <tt>Addr#</tt>, which is appropriate
--   for passing to e.g. some of the "error" functions in GHC.Err such as
--   <tt>GHC.Err.runtimeError</tt>
mkMachString :: String -> Literal
mkLitInteger :: Integer -> Type -> Literal

-- | Find the Haskell <a>Type</a> the literal occupies
literalType :: Literal -> Type
hashLiteral :: Literal -> Int
absentLiteralOf :: TyCon -> Maybe Literal
pprLiteral :: (SDoc -> SDoc) -> Literal -> SDoc

-- | True if code space does not go bad if we duplicate this literal
--   Currently we treat it just like <a>litIsTrivial</a>
litIsDupable :: DynFlags -> Literal -> Bool

-- | True if there is absolutely no penalty to duplicating the literal.
--   False principally of strings
litIsTrivial :: Literal -> Bool
litIsLifted :: Literal -> Bool
inIntRange :: DynFlags -> Integer -> Bool
inWordRange :: DynFlags -> Integer -> Bool
tARGET_MAX_INT :: DynFlags -> Integer
inCharRange :: Char -> Bool

-- | Tests whether the literal represents a zero of whatever type it is
isZeroLit :: Literal -> Bool
litFitsInChar :: Literal -> Bool
word2IntLit :: DynFlags -> Literal -> Literal
int2WordLit :: DynFlags -> Literal -> Literal
narrow8IntLit :: Literal -> Literal
narrow16IntLit :: Literal -> Literal
narrow32IntLit :: Literal -> Literal
narrow8WordLit :: Literal -> Literal
narrow16WordLit :: Literal -> Literal
narrow32WordLit :: Literal -> Literal
char2IntLit :: Literal -> Literal
int2CharLit :: Literal -> Literal
float2IntLit :: Literal -> Literal
int2FloatLit :: Literal -> Literal
double2IntLit :: Literal -> Literal
int2DoubleLit :: Literal -> Literal
nullAddrLit :: Literal
float2DoubleLit :: Literal -> Literal
double2FloatLit :: Literal -> Literal
instance Data Literal
instance Binary Literal
instance Outputable Literal
instance Eq Literal
instance Ord Literal


-- | CoreSyn holds all the main data types for use by for the Glasgow
--   Haskell Compiler midsection
module CoreSyn

-- | This is the data type that represents GHCs core intermediate language.
--   Currently GHC uses System FC
--   <a>http://research.microsoft.com/~simonpj/papers/ext-f/</a> for this
--   purpose, which is closely related to the simpler and better known
--   System F <a>http://en.wikipedia.org/wiki/System_F</a>.
--   
--   We get from Haskell source to this Core language in a number of
--   stages:
--   
--   <ol>
--   <li>The source code is parsed into an abstract syntax tree, which is
--   represented by the data type <a>HsExpr</a> with the names being
--   <a>RdrNames</a></li>
--   <li>This syntax tree is <i>renamed</i>, which attaches a <a>Unique</a>
--   to every <a>RdrName</a> (yielding a <a>Name</a>) to disambiguate
--   identifiers which are lexically identical. For example, this
--   program:</li>
--   </ol>
--   
--   <pre>
--   f x = let f x = x + 1
--         in f (x - 2)
--   </pre>
--   
--   Would be renamed by having <tt>Unique</tt>s attached so it looked
--   something like this:
--   
--   <pre>
--   f_1 x_2 = let f_3 x_4 = x_4 + 1
--             in f_3 (x_2 - 2)
--   </pre>
--   
--   But see Note [Shadowing] below.
--   
--   <ol>
--   <li>The resulting syntax tree undergoes type checking (which also
--   deals with instantiating type class arguments) to yield a
--   <a>HsExpr</a> type that has <a>Id</a> as it's names.</li>
--   <li>Finally the syntax tree is <i>desugared</i> from the expressive
--   <a>HsExpr</a> type into this <a>Expr</a> type, which has far fewer
--   constructors and hence is easier to perform optimization, analysis and
--   code generation on.</li>
--   </ol>
--   
--   The type parameter <tt>b</tt> is for the type of binders in the
--   expression tree.
--   
--   The language consists of the following elements:
--   
--   <ul>
--   <li>Variables</li>
--   <li>Primitive literals</li>
--   <li>Applications: note that the argument may be a <a>Type</a>.See
--   <a>CoreSyn#let_app_invariant</a> for another invariant</li>
--   <li>Lambda abstraction</li>
--   <li>Recursive and non recursive <tt>let</tt>s. Operationally this
--   corresponds to allocating a thunk for the things bound and then
--   executing the sub-expression. The right hand sides of all top-level
--   and recursive <tt>let</tt>s <i>must</i> be of lifted type (see
--   <a>Type#type_classification</a> for the meaning of <i>lifted</i> vs.
--   <i>unlifted</i>).See Note [CoreSyn let/app invariant] We allow a
--   <i>non-recursive</i> let to bind a type variable, thus:<pre>Let
--   (NonRec tv (Type ty)) body</pre>This can be very convenient for
--   postponing type substitutions until the next run of the simplifier.At
--   the moment, the rest of the compiler only deals with type-let in a Let
--   expression, rather than at top level. We may want to revist this
--   choice.</li>
--   <li>Case split. Operationally this corresponds to evaluating the
--   scrutinee (expression examined) to weak head normal form and then
--   examining at most one level of resulting constructor (i.e. you cannot
--   do nested pattern matching directly with this).The binder gets bound
--   to the value of the scrutinee, and the <a>Type</a> must be that of all
--   the case alternatives This is one of the more complicated elements of
--   the Core language, and comes with a number of restrictions:<ol><li>The
--   list of alternatives may be empty; See Note [Empty case
--   alternatives]</li><li>The <a>DEFAULT</a> case alternative must be
--   first in the list, if it occurs at all.</li><li>The remaining cases
--   are in order of increasing tag (for <tt>DataAlts</tt>) or lit (for
--   <tt>LitAlts</tt>). This makes finding the relevant constructor easy,
--   and makes comparison easier too.</li><li>The list of alternatives must
--   be exhaustive. An <i>exhaustive</i> case does not necessarily mention
--   all constructors:</li></ol><pre> data Foo = Red | Green | Blue ...
--   case x of Red -&gt; True other -&gt; f (case x of Green -&gt; ... Blue
--   -&gt; ... ) ... </pre>The inner case does not need a <tt>Red</tt>
--   alternative, because <tt>x</tt> can't be <tt>Red</tt> at that program
--   point.</li>
--   <li>Cast an expression to a particular type. This is used to implement
--   <tt>newtype</tt>s (a <tt>newtype</tt> constructor or destructor just
--   becomes a <a>Cast</a> in Core) and GADTs.</li>
--   <li>Notes. These allow general information to be added to expressions
--   in the syntax tree</li>
--   <li>A type: this should only show up at the top level of an Arg</li>
--   <li>A coercion</li>
--   </ul>
data Expr b
[Var] :: Id -> Expr b
[Lit] :: Literal -> Expr b
[App] :: (Expr b) -> (Arg b) -> Expr b
[Lam] :: b -> (Expr b) -> Expr b
[Let] :: (Bind b) -> (Expr b) -> Expr b
[Case] :: (Expr b) -> b -> Type -> [Alt b] -> Expr b
[Cast] :: (Expr b) -> Coercion -> Expr b
[Tick] :: (Tickish Id) -> (Expr b) -> Expr b
[Type] :: Type -> Expr b
[Coercion] :: Coercion -> Expr b

-- | A case split alternative. Consists of the constructor leading to the
--   alternative, the variables bound from the constructor, and the
--   expression to be executed given that binding. The default alternative
--   is <tt>(DEFAULT, [], rhs)</tt>
type Alt b = (AltCon, [b], Expr b)

-- | Binding, used for top level bindings in a module and local bindings in
--   a <tt>let</tt>.
data Bind b
[NonRec] :: b -> (Expr b) -> Bind b
[Rec] :: [(b, Expr b)] -> Bind b

-- | A case alternative constructor (i.e. pattern match)
data AltCon
[DataAlt] :: DataCon -> AltCon

-- | A literal: <tt>case e of { 1 -&gt; ... }</tt> Invariant: always an
--   *unlifted* literal See Note [Literal alternatives]
[LitAlt] :: Literal -> AltCon

-- | Trivial alternative: <tt>case e of { _ -&gt; ... }</tt>
[DEFAULT] :: AltCon

-- | Type synonym for expressions that occur in function argument
--   positions. Only <a>Arg</a> should contain a <a>Type</a> at top level,
--   general <a>Expr</a> should not
type Arg b = Expr b

-- | Allows attaching extra information to points in expressions
data Tickish id

-- | An <tt>{--}</tt> profiling annotation, either automatically added by
--   the desugarer as a result of -auto-all, or added by the user.
[ProfNote] :: CostCentre -> !Bool -> !Bool -> Tickish id

-- | the cost centre
[profNoteCC] :: Tickish id -> CostCentre

-- | bump the entry count?
[profNoteCount] :: Tickish id -> !Bool

-- | scopes over the enclosed expression (i.e. not just a tick)
[profNoteScope] :: Tickish id -> !Bool

-- | A "tick" used by HPC to track the execution of each subexpression in
--   the original source code.
[HpcTick] :: Module -> !Int -> Tickish id
[tickModule] :: Tickish id -> Module
[tickId] :: Tickish id -> !Int

-- | A breakpoint for the GHCi debugger. This behaves like an HPC tick, but
--   has a list of free variables which will be available for inspection in
--   GHCi when the program stops at the breakpoint.
--   
--   NB. we must take account of these Ids when (a) counting free
--   variables, and (b) substituting (don't substitute for them)
[Breakpoint] :: !Int -> [id] -> Tickish id
[breakpointId] :: Tickish id -> !Int

-- | the order of this list is important: it matches the order of the lists
--   in the appropriate entry in HscTypes.ModBreaks.
--   
--   Careful about substitution! See Note [substTickish] in CoreSubst.
[breakpointFVs] :: Tickish id -> [id]

-- | A source note.
--   
--   Source notes are pure annotations: Their presence should neither
--   influence compilation nor execution. The semantics are given by
--   causality: The presence of a source note means that a local change in
--   the referenced source code span will possibly provoke the generated
--   code to change. On the flip-side, the functionality of annotated code
--   *must* be invariant against changes to all source code *except* the
--   spans referenced in the source notes (see "Causality of optimized
--   Haskell" paper for details).
--   
--   Therefore extending the scope of any given source note is always
--   valid. Note that it is still undesirable though, as this reduces their
--   usefulness for debugging and profiling. Therefore we will generally
--   try only to make use of this property where it is neccessary to enable
--   optimizations.
[SourceNote] :: RealSrcSpan -> String -> Tickish id

-- | Source covered
[sourceSpan] :: Tickish id -> RealSrcSpan

-- | Name for source location (uses same names as CCs)
[sourceName] :: Tickish id -> String

-- | Specifies the scoping behaviour of ticks. This governs the behaviour
--   of ticks that care about the covered code and the cost associated with
--   it. Important for ticks relating to profiling.
data TickishScoping

-- | No scoping: The tick does not care about what code it covers.
--   Transformations can freely move code inside as well as outside without
--   any additional annotation obligations
[NoScope] :: TickishScoping

-- | Soft scoping: We want all code that is covered to stay covered. Note
--   that this scope type does not forbid transformations from happening,
--   as as long as all results of the transformations are still covered by
--   this tick or a copy of it. For example
--   
--   let x = tick<a>...</a> (let y = foo in bar) in baz ===&gt; let x =
--   tick<a>...</a> bar; y = tick<a>...</a> foo in baz
--   
--   Is a valid transformation as far as "bar" and "foo" is concerned,
--   because both still are scoped over by the tick.
--   
--   Note though that one might object to the "let" not being covered by
--   the tick any more. However, we are generally lax with this - constant
--   costs don't matter too much, and given that the "let" was effectively
--   merged we can view it as having lost its identity anyway.
--   
--   Also note that this scoping behaviour allows floating a tick "upwards"
--   in pretty much any situation. For example:
--   
--   case foo of x -&gt; tick<a>...</a> bar ==&gt; tick<a>...</a> case foo
--   of x -&gt; bar
--   
--   While this is always leagl, we want to make a best effort to only make
--   us of this where it exposes transformation opportunities.
[SoftScope] :: TickishScoping

-- | Cost centre scoping: We don't want any costs to move to other
--   cost-centre stacks. This means we not only want no code or cost to get
--   moved out of their cost centres, but we also object to code getting
--   associated with new cost-centre ticks - or changing the order in which
--   they get applied.
--   
--   A rule of thumb is that we don't want any code to gain new
--   annotations. However, there are notable exceptions, for example:
--   
--   let f = y -&gt; foo in tick<a>...</a> ... (f x) ... ==&gt;
--   tick<a>...</a> ... foo[x/y] ...
--   
--   In-lining lambdas like this is always legal, because inlining a
--   function does not change the cost-centre stack when the function is
--   called.
[CostCentreScope] :: TickishScoping

-- | Governs the kind of expression that the tick gets placed on when
--   annotating for example using <tt>mkTick</tt>. If we find that we want
--   to put a tickish on an expression ruled out here, we try to float it
--   inwards until we find a suitable expression.
data TickishPlacement

-- | Place ticks exactly on run-time expressions. We can still move the
--   tick through pure compile-time constructs such as other ticks, casts
--   or type lambdas. This is the most restrictive placement rule for
--   ticks, as all tickishs have in common that they want to track runtime
--   processes. The only legal placement rule for counting ticks.
[PlaceRuntime] :: TickishPlacement

-- | As <tt>PlaceRuntime</tt>, but we float the tick through all lambdas.
--   This makes sense where there is little difference between annotating
--   the lambda and annotating the lambda's code.
[PlaceNonLam] :: TickishPlacement

-- | In addition to floating through lambdas, cost-centre style tickishs
--   can also be moved from constructors, non-function variables and
--   literals. For example:
--   
--   let x = scc<a>...</a> C (scc<a>...</a> y) (scc<a>...</a> 3) in ...
--   
--   Neither the constructor application, the variable or the literal are
--   likely to have any cost worth mentioning. And even if y names a thunk,
--   the call would not care about the evaluation context. Therefore
--   removing all annotations in the above example is safe.
[PlaceCostCentre] :: TickishPlacement
type CoreProgram = [CoreBind]

-- | Expressions where binders are <a>CoreBndr</a>s
type CoreExpr = Expr CoreBndr

-- | Case alternatives where binders are <a>CoreBndr</a>s
type CoreAlt = Alt CoreBndr

-- | Binding groups where binders are <a>CoreBndr</a>s
type CoreBind = Bind CoreBndr

-- | Argument expressions where binders are <a>CoreBndr</a>s
type CoreArg = Arg CoreBndr

-- | The common case for the type of binders and variables when we are
--   manipulating the Core language within GHC
type CoreBndr = Var
type TaggedExpr t = Expr (TaggedBndr t)
type TaggedAlt t = Alt (TaggedBndr t)
type TaggedBind t = Bind (TaggedBndr t)
type TaggedArg t = Arg (TaggedBndr t)

-- | Binders are <i>tagged</i> with a t
data TaggedBndr t
[TB] :: CoreBndr -> t -> TaggedBndr t
deTagExpr :: TaggedExpr t -> CoreExpr

-- | Bind all supplied binding groups over an expression in a nested let
--   expression. Assumes that the rhs satisfies the let/app invariant.
--   Prefer to use <a>mkCoreLets</a> if possible, which does guarantee the
--   invariant
mkLets :: [Bind b] -> Expr b -> Expr b

-- | Bind all supplied binders over an expression in a nested lambda
--   expression. Prefer to use <a>mkCoreLams</a> if possible
mkLams :: [b] -> Expr b -> Expr b

-- | Apply a list of argument expressions to a function expression in a
--   nested fashion. Prefer to use <a>mkCoreApps</a> if possible
mkApps :: Expr b -> [Arg b] -> Expr b

-- | Apply a list of type argument expressions to a function expression in
--   a nested fashion
mkTyApps :: Expr b -> [Type] -> Expr b

-- | Apply a list of coercion argument expressions to a function expression
--   in a nested fashion
mkCoApps :: Expr b -> [Coercion] -> Expr b

-- | Apply a list of type or value variables to a function expression in a
--   nested fashion
mkVarApps :: Expr b -> [Var] -> Expr b

-- | Create a machine integer literal expression of type <tt>Int#</tt> from
--   an <tt>Integer</tt>. If you want an expression of type <tt>Int</tt>
--   use <a>mkIntExpr</a>
mkIntLit :: DynFlags -> Integer -> Expr b

-- | Create a machine integer literal expression of type <tt>Int#</tt> from
--   an <tt>Int</tt>. If you want an expression of type <tt>Int</tt> use
--   <a>mkIntExpr</a>
mkIntLitInt :: DynFlags -> Int -> Expr b

-- | Create a machine word literal expression of type <tt>Word#</tt> from
--   an <tt>Integer</tt>. If you want an expression of type <tt>Word</tt>
--   use <a>mkWordExpr</a>
mkWordLit :: DynFlags -> Integer -> Expr b

-- | Create a machine word literal expression of type <tt>Word#</tt> from a
--   <tt>Word</tt>. If you want an expression of type <tt>Word</tt> use
--   <a>mkWordExpr</a>
mkWordLitWord :: DynFlags -> Word -> Expr b
mkWord64LitWord64 :: Word64 -> Expr b
mkInt64LitInt64 :: Int64 -> Expr b

-- | Create a machine character literal expression of type <tt>Char#</tt>.
--   If you want an expression of type <tt>Char</tt> use <a>mkCharExpr</a>
mkCharLit :: Char -> Expr b

-- | Create a machine string literal expression of type <tt>Addr#</tt>. If
--   you want an expression of type <tt>String</tt> use <a>mkStringExpr</a>
mkStringLit :: String -> Expr b

-- | Create a machine single precision literal expression of type
--   <tt>Float#</tt> from a <tt>Rational</tt>. If you want an expression of
--   type <tt>Float</tt> use <a>mkFloatExpr</a>
mkFloatLit :: Rational -> Expr b

-- | Create a machine single precision literal expression of type
--   <tt>Float#</tt> from a <tt>Float</tt>. If you want an expression of
--   type <tt>Float</tt> use <a>mkFloatExpr</a>
mkFloatLitFloat :: Float -> Expr b

-- | Create a machine double precision literal expression of type
--   <tt>Double#</tt> from a <tt>Rational</tt>. If you want an expression
--   of type <tt>Double</tt> use <a>mkDoubleExpr</a>
mkDoubleLit :: Rational -> Expr b

-- | Create a machine double precision literal expression of type
--   <tt>Double#</tt> from a <tt>Double</tt>. If you want an expression of
--   type <tt>Double</tt> use <a>mkDoubleExpr</a>
mkDoubleLitDouble :: Double -> Expr b

-- | Apply a list of argument expressions to a data constructor in a nested
--   fashion. Prefer to use <a>mkCoreConApps</a> if possible
mkConApp :: DataCon -> [Arg b] -> Expr b
mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b

-- | Create a binding group where a type variable is bound to a type. Per
--   <a>CoreSyn#type_let</a>, this can only be used to bind something in a
--   non-recursive <tt>let</tt> expression
mkTyBind :: TyVar -> Type -> CoreBind

-- | Create a binding group where a type variable is bound to a type. Per
--   <a>CoreSyn#type_let</a>, this can only be used to bind something in a
--   non-recursive <tt>let</tt> expression
mkCoBind :: CoVar -> Coercion -> CoreBind

-- | Convert a binder into either a <a>Var</a> or <a>Type</a> <a>Expr</a>
--   appropriately
varToCoreExpr :: CoreBndr -> Expr b
varsToCoreExprs :: [CoreBndr] -> [Expr b]
isId :: Var -> Bool

-- | Compares <a>AltCon</a>s within a single list of alternatives
cmpAltCon :: AltCon -> AltCon -> Ordering
cmpAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Ordering
ltAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Bool

-- | Extract every variable by this group
bindersOf :: Bind b -> [b]

-- | <a>bindersOf</a> applied to a list of binding groups
bindersOfBinds :: [Bind b] -> [b]
rhssOfBind :: Bind b -> [Expr b]
rhssOfAlts :: [Alt b] -> [Expr b]

-- | We often want to strip off leading lambdas before getting down to
--   business. This function is your friend.
collectBinders :: Expr b -> ([b], Expr b)

-- | Collect as many type bindings as possible from the front of a nested
--   lambda
collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)

-- | Collect as many value bindings as possible from the front of a nested
--   lambda
collectValBinders :: CoreExpr -> ([Id], CoreExpr)

-- | Collect type binders from the front of the lambda first, then follow
--   up by collecting as many value bindings as possible from the resulting
--   stripped expression
collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)

-- | Takes a nested application expression and returns the the function
--   being applied and the arguments to which it is applied
collectArgs :: Expr b -> (Expr b, [Arg b])

-- | Like <tt>collectArgs</tt>, but also collects looks through floatable
--   ticks if it means that we can find more arguments.
collectArgsTicks :: (Tickish Id -> Bool) -> Expr b -> (Expr b, [Arg b], [Tickish Id])

-- | Collapse all the bindings in the supplied groups into a single list of
--   lhs/rhs pairs suitable for binding in a <a>Rec</a> binding group
flattenBinds :: [Bind b] -> [(b, Expr b)]

-- | Returns <tt>True</tt> for value arguments, false for type args NB:
--   coercions are value arguments (zero width, to be sure, like State#,
--   but still value args).
isValArg :: Expr b -> Bool

-- | Returns <tt>True</tt> iff the expression is a <a>Type</a> expression
--   at its top level. Note this does NOT include <a>Coercion</a>s.
isTypeArg :: Expr b -> Bool

-- | Returns <tt>True</tt> iff the expression is a <a>Type</a> or
--   <a>Coercion</a> expression at its top level
isTyCoArg :: Expr b -> Bool

-- | The number of argument expressions that are values rather than types
--   at their top level
valArgCount :: [Arg b] -> Int

-- | The number of binders that bind values rather than types
valBndrCount :: [CoreBndr] -> Int

-- | Will this argument expression exist at runtime?
isRuntimeArg :: CoreExpr -> Bool

-- | Will this variable exist at runtime?
isRuntimeVar :: Var -> Bool

-- | A "counting tick" (where tickishCounts is True) is one that counts
--   evaluations in some way. We cannot discard a counting tick, and the
--   compiler should preserve the number of counting ticks as far as
--   possible.
--   
--   However, we still allow the simplifier to increase or decrease
--   sharing, so in practice the actual number of ticks may vary, except
--   that we never change the value from zero to non-zero or vice versa.
tickishCounts :: Tickish id -> Bool

-- | Returns the intended scoping rule for a Tickish
tickishScoped :: Tickish id -> TickishScoping

-- | Returns whether the tick scoping rule is at least as permissive as the
--   given scoping rule.
tickishScopesLike :: Tickish id -> TickishScoping -> Bool

-- | Returns <tt>True</tt> for ticks that can be floated upwards easily
--   even where it might change execution counts, such as:
--   
--   Just (tick<a>...</a> foo) ==&gt; tick<a>...</a> (Just foo)
--   
--   This is a combination of <tt>tickishSoftScope</tt> and
--   <tt>tickishCounts</tt>. Note that in principle splittable ticks can
--   become floatable using <tt>mkNoTick</tt> -- even though there's
--   currently no tickish for which that is the case.
tickishFloatable :: Tickish id -> Bool

-- | Returns <tt>True</tt> for a tick that is both counting <i>and</i>
--   scoping and can be split into its (tick, scope) parts using
--   <a>mkNoScope</a> and <tt>mkNoTick</tt> respectively.
tickishCanSplit :: Tickish id -> Bool
mkNoCount :: Tickish id -> Tickish id
mkNoScope :: Tickish id -> Tickish id

-- | Return <tt>True</tt> if this source annotation compiles to some
--   backend code. Without this flag, the tickish is seen as a simple
--   annotation that does not have any associated evaluation code.
--   
--   What this means that we are allowed to disregard the tick if doing so
--   means that we can skip generating any code in the first place. A
--   typical example is top-level bindings:
--   
--   foo = tick<a>...</a> y -&gt; ... ==&gt; foo = y -&gt; tick<a>...</a>
--   ...
--   
--   Here there is just no operational difference between the first and the
--   second version. Therefore code generation should simply translate the
--   code as if it found the latter.
tickishIsCode :: Tickish id -> Bool

-- | Placement behaviour we want for the ticks
tickishPlace :: Tickish id -> TickishPlacement

-- | Returns whether one tick "contains" the other one, therefore making
--   the second tick redundant.
tickishContains :: Eq b => Tickish b -> Tickish b -> Bool

-- | Records the <i>unfolding</i> of an identifier, which is approximately
--   the form the identifier would have if we substituted its definition in
--   for the identifier. This type should be treated as abstract everywhere
--   except in <a>CoreUnfold</a>
data Unfolding

-- | We have no information about the unfolding
[NoUnfolding] :: Unfolding

-- | It ain't one of these constructors. <tt>OtherCon xs</tt> also
--   indicates that something has been evaluated and hence there's no point
--   in re-evaluating it. <tt>OtherCon []</tt> is used even for
--   non-data-type values to indicated evaluated-ness. Notably:
--   
--   <pre>
--   data C = C !(Int -&gt; Int)
--   case x of { C f -&gt; ... }
--   </pre>
--   
--   Here, <tt>f</tt> gets an <tt>OtherCon []</tt> unfolding.
[OtherCon] :: [AltCon] -> Unfolding
[DFunUnfolding] :: [Var] -> DataCon -> [CoreExpr] -> Unfolding
[df_bndrs] :: Unfolding -> [Var]
[df_con] :: Unfolding -> DataCon
[df_args] :: Unfolding -> [CoreExpr]

-- | An unfolding with redundant cached information. Parameters:
--   
--   uf_tmpl: Template used to perform unfolding; NB: Occurrence info is
--   guaranteed correct: see Note [OccInfo in unfoldings and rules]
--   
--   uf_is_top: Is this a top level binding?
--   
--   uf_is_value: <tt>exprIsHNF</tt> template (cached); it is ok to discard
--   a <a>seq</a> on this variable
--   
--   uf_is_work_free: Does this waste only a little work if we expand it
--   inside an inlining? Basically this is a cached version of
--   <tt>exprIsWorkFree</tt>
--   
--   uf_guidance: Tells us about the <i>size</i> of the unfolding template
[CoreUnfolding] :: CoreExpr -> UnfoldingSource -> Bool -> Bool -> Bool -> Bool -> Bool -> UnfoldingGuidance -> Unfolding
[uf_tmpl] :: Unfolding -> CoreExpr
[uf_src] :: Unfolding -> UnfoldingSource
[uf_is_top] :: Unfolding -> Bool
[uf_is_value] :: Unfolding -> Bool
[uf_is_conlike] :: Unfolding -> Bool
[uf_is_work_free] :: Unfolding -> Bool
[uf_expandable] :: Unfolding -> Bool
[uf_guidance] :: Unfolding -> UnfoldingGuidance

-- | <a>UnfoldingGuidance</a> says when unfolding should take place
data UnfoldingGuidance
[UnfWhen] :: Arity -> Bool -> Bool -> UnfoldingGuidance
[ug_arity] :: UnfoldingGuidance -> Arity
[ug_unsat_ok] :: UnfoldingGuidance -> Bool
[ug_boring_ok] :: UnfoldingGuidance -> Bool
[UnfIfGoodArgs] :: [Int] -> Int -> Int -> UnfoldingGuidance
[ug_args] :: UnfoldingGuidance -> [Int]
[ug_size] :: UnfoldingGuidance -> Int
[ug_res] :: UnfoldingGuidance -> Int
[UnfNever] :: UnfoldingGuidance
data UnfoldingSource
[InlineRhs] :: UnfoldingSource
[InlineStable] :: UnfoldingSource
[InlineCompulsory] :: UnfoldingSource

-- | There is no known <a>Unfolding</a>
noUnfolding :: Unfolding

-- | This unfolding marks the associated thing as being evaluated
evaldUnfolding :: Unfolding
mkOtherCon :: [AltCon] -> Unfolding
unSaturatedOk :: Bool
needSaturated :: Bool
boringCxtOk :: Bool
boringCxtNotOk :: Bool

-- | Retrieves the template of an unfolding: panics if none is known
unfoldingTemplate :: Unfolding -> CoreExpr
expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr

-- | Retrieves the template of an unfolding if possible
--   maybeUnfoldingTemplate is used mainly wnen specialising, and we do
--   want to specialise DFuns, so it's important to return a template for
--   DFunUnfoldings
maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr

-- | The constructors that the unfolding could never be: returns
--   <tt>[]</tt> if no information is available
otherCons :: Unfolding -> [AltCon]

-- | Determines if it is certainly the case that the unfolding will yield a
--   value (something in HNF): returns <tt>False</tt> if unsure
isValueUnfolding :: Unfolding -> Bool

-- | Determines if it possibly the case that the unfolding will yield a
--   value. Unlike <a>isValueUnfolding</a> it returns <tt>True</tt> for
--   <a>OtherCon</a>
isEvaldUnfolding :: Unfolding -> Bool

-- | Is the thing we will unfold into certainly cheap?
isCheapUnfolding :: Unfolding -> Bool
isExpandableUnfolding :: Unfolding -> Bool

-- | <tt>True</tt> if the unfolding is a constructor application, the
--   application of a CONLIKE function or <a>OtherCon</a>
isConLikeUnfolding :: Unfolding -> Bool
isCompulsoryUnfolding :: Unfolding -> Bool
isStableUnfolding :: Unfolding -> Bool
hasStableCoreUnfolding_maybe :: Unfolding -> Maybe Bool
isClosedUnfolding :: Unfolding -> Bool

-- | Only returns False if there is no unfolding information available at
--   all
hasSomeUnfolding :: Unfolding -> Bool
canUnfold :: Unfolding -> Bool
neverUnfoldGuidance :: UnfoldingGuidance -> Bool
isStableSource :: UnfoldingSource -> Bool
seqExpr :: CoreExpr -> ()
seqExprs :: [CoreExpr] -> ()
seqUnfolding :: Unfolding -> ()

-- | Annotated core: allows annotation at every node in the tree
type AnnExpr bndr annot = (annot, AnnExpr' bndr annot)

-- | A clone of the <a>Expr</a> type but allowing annotation at every tree
--   node
data AnnExpr' bndr annot
[AnnVar] :: Id -> AnnExpr' bndr annot
[AnnLit] :: Literal -> AnnExpr' bndr annot
[AnnLam] :: bndr -> (AnnExpr bndr annot) -> AnnExpr' bndr annot
[AnnApp] :: (AnnExpr bndr annot) -> (AnnExpr bndr annot) -> AnnExpr' bndr annot
[AnnCase] :: (AnnExpr bndr annot) -> bndr -> Type -> [AnnAlt bndr annot] -> AnnExpr' bndr annot
[AnnLet] :: (AnnBind bndr annot) -> (AnnExpr bndr annot) -> AnnExpr' bndr annot
[AnnCast] :: (AnnExpr bndr annot) -> (annot, Coercion) -> AnnExpr' bndr annot
[AnnTick] :: (Tickish Id) -> (AnnExpr bndr annot) -> AnnExpr' bndr annot
[AnnType] :: Type -> AnnExpr' bndr annot
[AnnCoercion] :: Coercion -> AnnExpr' bndr annot

-- | A clone of the <a>Bind</a> type but allowing annotation at every tree
--   node
data AnnBind bndr annot
[AnnNonRec] :: bndr -> (AnnExpr bndr annot) -> AnnBind bndr annot
[AnnRec] :: [(bndr, AnnExpr bndr annot)] -> AnnBind bndr annot

-- | A clone of the <a>Alt</a> type but allowing annotation at every tree
--   node
type AnnAlt bndr annot = (AltCon, [bndr], AnnExpr bndr annot)

-- | Takes a nested application expression and returns the the function
--   being applied and the arguments to which it is applied
collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])
collectAnnArgsTicks :: (Tickish Var -> Bool) -> AnnExpr b a -> (AnnExpr b a, [AnnExpr b a], [Tickish Var])
deAnnotate :: AnnExpr bndr annot -> Expr bndr
deAnnotate' :: AnnExpr' bndr annot -> Expr bndr
deAnnAlt :: AnnAlt bndr annot -> Alt bndr

-- | As <a>collectBinders</a> but for <a>AnnExpr</a> rather than
--   <a>Expr</a>
collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)

-- | A <a>CoreRule</a> is:
--   
--   <ul>
--   <li>"Local" if the function it is a rule for is defined in the same
--   module as the rule itself.</li>
--   <li>"Orphan" if nothing on the LHS is defined in the same module as
--   the rule itself</li>
--   </ul>
data CoreRule
[Rule] :: RuleName -> Activation -> Name -> [Maybe Name] -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> Bool -> Bool -> CoreRule

-- | Name of the rule, for communication with the user
[ru_name] :: CoreRule -> RuleName

-- | When the rule is active
[ru_act] :: CoreRule -> Activation

-- | Name of the <a>Id</a> at the head of this rule
[ru_fn] :: CoreRule -> Name

-- | Name at the head of each argument to the left hand side
[ru_rough] :: CoreRule -> [Maybe Name]

-- | Variables quantified over
[ru_bndrs] :: CoreRule -> [CoreBndr]

-- | Left hand side arguments
[ru_args] :: CoreRule -> [CoreExpr]

-- | Right hand side of the rule Occurrence info is guaranteed correct See
--   Note [OccInfo in unfoldings and rules]
[ru_rhs] :: CoreRule -> CoreExpr

-- | <tt>True</tt> <a>=</a> this rule is auto-generated <tt>False</tt>
--   <a>=</a> generated at the users behest Main effect: reporting of
--   orphan-hood
[ru_auto] :: CoreRule -> Bool

-- | <tt>True</tt> iff the fn at the head of the rule is defined in the
--   same module as the rule and is not an implicit <a>Id</a> (like a
--   record selector, class operation, or data constructor)
[ru_local] :: CoreRule -> Bool

-- | Built-in rules are used for constant folding and suchlike. They have
--   no free variables.
[BuiltinRule] :: RuleName -> Name -> Int -> RuleFun -> CoreRule

-- | Name of the rule, for communication with the user
[ru_name] :: CoreRule -> RuleName

-- | Name of the <a>Id</a> at the head of this rule
[ru_fn] :: CoreRule -> Name

-- | Number of arguments that <a>ru_try</a> consumes, if it fires,
--   including type arguments
[ru_nargs] :: CoreRule -> Int

-- | This function does the rewrite. It given too many arguments, it simply
--   discards them; the returned <a>CoreExpr</a> is just the rewrite of
--   <a>ru_fn</a> applied to the first <a>ru_nargs</a> args
[ru_try] :: CoreRule -> RuleFun
type RuleName = FastString
type RuleFun = DynFlags -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr
type IdUnfoldingFun = Id -> Unfolding
type InScopeEnv = (InScopeSet, IdUnfoldingFun)
seqRules :: [CoreRule] -> ()

-- | The number of arguments the <a>ru_fn</a> must be applied to before the
--   rule can match on it
ruleArity :: CoreRule -> Int
ruleName :: CoreRule -> RuleName

-- | The <a>Name</a> of the <a>Id</a> at the head of the rule left hand
--   side
ruleIdName :: CoreRule -> Name
ruleActivation :: CoreRule -> Activation

-- | Set the <a>Name</a> of the <a>Id</a> at the head of the rule left hand
--   side
setRuleIdName :: Name -> CoreRule -> CoreRule
isBuiltinRule :: CoreRule -> Bool
isLocalRule :: CoreRule -> Bool
isAutoRule :: CoreRule -> Bool
data CoreVect
[Vect] :: Id -> CoreExpr -> CoreVect
[NoVect] :: Id -> CoreVect
[VectType] :: Bool -> TyCon -> (Maybe TyCon) -> CoreVect
[VectClass] :: TyCon -> CoreVect
[VectInst] :: Id -> CoreVect
instance Eq UnfoldingGuidance
instance Eq TickishPlacement
instance Eq TickishScoping
instance Data b => Data (Bind b)
instance Data b => Data (Expr b)
instance Data id => Data (Tickish id)
instance Ord id => Ord (Tickish id)
instance Eq id => Eq (Tickish id)
instance Data AltCon
instance Ord AltCon
instance Eq AltCon
instance Outputable AltCon
instance Outputable b => Outputable (TaggedBndr b)
instance Outputable b => OutputableBndr (TaggedBndr b)

module IdInfo

-- | The <a>IdDetails</a> of an <tt>Id</tt> give stable, and necessary,
--   information about the Id.
data IdDetails
[VanillaId] :: IdDetails

-- | The <tt>Id</tt> for a record selector
[RecSelId] :: TyCon -> Bool -> IdDetails

-- | For a data type family, this is the <i>instance</i> <a>TyCon</a> not
--   the family <a>TyCon</a>
[sel_tycon] :: IdDetails -> TyCon
[sel_naughty] :: IdDetails -> Bool

-- | The <tt>Id</tt> is for a data constructor <i>worker</i>
[DataConWorkId] :: DataCon -> IdDetails

-- | The <tt>Id</tt> is for a data constructor <i>wrapper</i>
[DataConWrapId] :: DataCon -> IdDetails

-- | The <tt>Id</tt> is a superclass selector or class operation of a class
[ClassOpId] :: Class -> IdDetails

-- | The <tt>Id</tt> is for a primitive operator
[PrimOpId] :: PrimOp -> IdDetails

-- | The <tt>Id</tt> is for a foreign call
[FCallId] :: ForeignCall -> IdDetails

-- | The <tt>Id</tt> is for a HPC tick box (both traditional and binary)
[TickBoxOpId] :: TickBoxOp -> IdDetails

-- | A dictionary function. Int = the number of "silent" arguments to the
--   dfun e.g. class D a =&gt; C a where ... instance C a =&gt; C [a] has
--   is_silent = 1, because the dfun has type dfun :: (D a, C a) =&gt; C
--   [a] See Note [Silent superclass arguments] in TcInstDcls
--   
--   Bool = True <a>=</a> the class has only one method, so may be
--   implemented with a newtype, so it might be bad to be strict on this
--   dictionary
[DFunId] :: Int -> Bool -> IdDetails
pprIdDetails :: IdDetails -> SDoc
coVarDetails :: IdDetails

-- | An <a>IdInfo</a> gives <i>optional</i> information about an
--   <tt>Id</tt>. If present it never lies, but it may not be present, in
--   which case there is always a conservative assumption which can be
--   made.
--   
--   Two <tt>Id</tt>s may have different info even though they have the
--   same <tt>Unique</tt> (and are hence the same <tt>Id</tt>); for
--   example, one might lack the properties attached to the other.
--   
--   The <a>IdInfo</a> gives information about the value, or definition, of
--   the <tt>Id</tt>. It does not contain information about the
--   <tt>Id'</tt>s usage, except for <a>demandInfo</a> and
--   <a>oneShotInfo</a>.
data IdInfo

-- | Basic <a>IdInfo</a> that carries no useful information whatsoever
vanillaIdInfo :: IdInfo

-- | More informative <a>IdInfo</a> we can use when we know the <tt>Id</tt>
--   has no CAF references
noCafIdInfo :: IdInfo

-- | Just evaluate the <a>IdInfo</a> to WHNF
seqIdInfo :: IdInfo -> ()

-- | Evaluate all the fields of the <a>IdInfo</a> that are generally
--   demanded by the compiler
megaSeqIdInfo :: IdInfo -> ()

-- | If the <tt>Id</tt> is a lambda-bound variable then it may have
--   lambda-bound variable info. Sometimes we know whether the lambda
--   binding this variable is a "one-shot" lambda; that is, whether it is
--   applied at most once.
--   
--   This information may be useful in optimisation, as computations may
--   safely be floated inside such a lambda without risk of duplicating
--   work.
data OneShotInfo

-- | No information
[NoOneShotInfo] :: OneShotInfo

-- | The lambda is probably applied at most once See Note [Computing
--   one-shot info, and ProbOneShot] in OccurAnl
[ProbOneShot] :: OneShotInfo

-- | The lambda is applied at most once.
[OneShotLam] :: OneShotInfo

-- | Info about a lambda-bound variable, if the <tt>Id</tt> is one
oneShotInfo :: IdInfo -> OneShotInfo

-- | It is always safe to assume that an <tt>Id</tt> has no lambda-bound
--   variable information
noOneShotInfo :: OneShotInfo
hasNoOneShotInfo :: OneShotInfo -> Bool
setOneShotInfo :: IdInfo -> OneShotInfo -> IdInfo

-- | This is used to remove information on lambda binders that we have
--   setup as part of a lambda group, assuming they will be applied all at
--   once, but turn out to be part of an unsaturated lambda as in e.g:
--   
--   <pre>
--   (\x1. \x2. e) arg1
--   </pre>
zapLamInfo :: IdInfo -> Maybe IdInfo

-- | Zap info that depends on free variables
zapFragileInfo :: IdInfo -> Maybe IdInfo

-- | Remove demand info on the <a>IdInfo</a> if it is present, otherwise
--   return <tt>Nothing</tt>
zapDemandInfo :: IdInfo -> Maybe IdInfo

-- | An <a>ArityInfo</a> of <tt>n</tt> tells us that partial application of
--   this <tt>Id</tt> to up to <tt>n-1</tt> value arguments does
--   essentially no work.
--   
--   That is not necessarily the same as saying that it has <tt>n</tt>
--   leading lambdas, because coerces may get in the way.
--   
--   The arity might increase later in the compilation process, if an extra
--   lambda floats up to the binding site.
type ArityInfo = Arity

-- | It is always safe to assume that an <tt>Id</tt> has an arity of 0
unknownArity :: Arity

-- | <tt>Id</tt> arity
arityInfo :: IdInfo -> ArityInfo
setArityInfo :: IdInfo -> ArityInfo -> IdInfo
ppArityInfo :: Int -> SDoc

-- | How this is called. n <a>=</a> all calls have at least n arguments
callArityInfo :: IdInfo -> ArityInfo
setCallArityInfo :: IdInfo -> ArityInfo -> IdInfo
strictnessInfo :: IdInfo -> StrictSig
setStrictnessInfo :: IdInfo -> StrictSig -> IdInfo

-- | ID demand information
demandInfo :: IdInfo -> Demand
setDemandInfo :: IdInfo -> Demand -> IdInfo
pprStrictness :: StrictSig -> SDoc

-- | The <tt>Id</tt>s unfolding
unfoldingInfo :: IdInfo -> Unfolding
setUnfoldingInfo :: IdInfo -> Unfolding -> IdInfo
setUnfoldingInfoLazily :: IdInfo -> Unfolding -> IdInfo

-- | Tells when the inlining is active. When it is active the thing may be
--   inlined, depending on how big it is.
--   
--   If there was an <tt>INLINE</tt> pragma, then as a separate matter, the
--   RHS will have been made to look small with a Core inline <tt>Note</tt>
--   
--   The default <a>InlinePragInfo</a> is <a>AlwaysActive</a>, so the info
--   serves entirely as a way to inhibit inlining until we want it
type InlinePragInfo = InlinePragma

-- | Any inline pragma atached to the <tt>Id</tt>
inlinePragInfo :: IdInfo -> InlinePragma
setInlinePragInfo :: IdInfo -> InlinePragma -> IdInfo

-- | Identifier occurrence information
data OccInfo

-- | There are many occurrences, or unknown occurrences
[NoOccInfo] :: OccInfo

-- | Marks unused variables. Sometimes useful for lambda and case-bound
--   variables.
[IAmDead] :: OccInfo

-- | Occurs exactly once, not inside a rule
[OneOcc] :: !InsideLam -> !OneBranch -> !InterestingCxt -> OccInfo

-- | This identifier breaks a loop of mutually recursive functions. The
--   field marks whether it is only a loop breaker due to a reference in a
--   rule
[IAmALoopBreaker] :: !RulesOnly -> OccInfo
isDeadOcc :: OccInfo -> Bool
isStrongLoopBreaker :: OccInfo -> Bool
isWeakLoopBreaker :: OccInfo -> Bool

-- | How the <tt>Id</tt> occurs in the program
occInfo :: IdInfo -> OccInfo
setOccInfo :: IdInfo -> OccInfo -> IdInfo
type InsideLam = Bool
type OneBranch = Bool
insideLam :: InsideLam
notInsideLam :: InsideLam
oneBranch :: OneBranch
notOneBranch :: OneBranch

-- | Records the specializations of this <tt>Id</tt> that we know about in
--   the form of rewrite <a>CoreRule</a>s that target them
data SpecInfo
[SpecInfo] :: [CoreRule] -> VarSet -> SpecInfo

-- | Assume that no specilizations exist: always safe
emptySpecInfo :: SpecInfo
isEmptySpecInfo :: SpecInfo -> Bool

-- | Retrieve the locally-defined free variables of both the left and right
--   hand sides of the specialization rules
specInfoFreeVars :: SpecInfo -> VarSet
specInfoRules :: SpecInfo -> [CoreRule]
seqSpecInfo :: SpecInfo -> ()

-- | Change the name of the function the rule is keyed on on all of the
--   <a>CoreRule</a>s
setSpecInfoHead :: Name -> SpecInfo -> SpecInfo

-- | Specialisations of the <tt>Id</tt>s function which exist See Note
--   [Specialisations and RULES in IdInfo]
specInfo :: IdInfo -> SpecInfo
setSpecInfo :: IdInfo -> SpecInfo -> IdInfo

-- | Records whether an <tt>Id</tt> makes Constant Applicative Form
--   references
data CafInfo

-- | Indicates that the <tt>Id</tt> is for either:
--   
--   <ol>
--   <li>A function or static constructor that refers to one or more CAFs,
--   or</li>
--   <li>A real live CAF</li>
--   </ol>
[MayHaveCafRefs] :: CafInfo

-- | A function or static constructor that refers to no CAFs.
[NoCafRefs] :: CafInfo
ppCafInfo :: CafInfo -> SDoc
mayHaveCafRefs :: CafInfo -> Bool

-- | <tt>Id</tt> CAF info
cafInfo :: IdInfo -> CafInfo
setCafInfo :: IdInfo -> CafInfo -> IdInfo

-- | Tick box for Hpc-style coverage
data TickBoxOp
[TickBox] :: Module -> {-# UNPACK #-} !TickBoxId -> TickBoxOp
type TickBoxId = Int
instance Ord CafInfo
instance Eq CafInfo
instance Outputable IdDetails
instance Outputable CafInfo
instance Outputable TickBoxOp


-- | GHC uses several kinds of name internally:
--   
--   <ul>
--   <li><a>OccName</a>: see <a>OccName#name_types</a></li>
--   <li><a>RdrName</a>: see <a>RdrName#name_types</a></li>
--   <li><a>Name</a>: see <a>Name#name_types</a></li>
--   <li><a>Id</a> represents names that not only have a <a>Name</a> but
--   also a <a>Type</a> and some additional details (a <a>IdInfo</a> and
--   one of <a>LocalIdDetails</a> or <a>GlobalIdDetails</a>) that are
--   added, modified and inspected by various compiler passes. These
--   <a>Var</a> names may either be global or local, see
--   <a>Var#globalvslocal</a></li>
--   <li><a>Var</a>: see <a>Var#name_types</a></li>
--   </ul>
module Id

-- | Essentially a typed <a>Name</a>, that may also contain some additional
--   information about the <a>Var</a> and it's use sites.
data Var
type Id = Var
isId :: Var -> Bool

-- | For an explanation of global vs. local <a>Id</a>s, see
--   <a>Var#globalvslocal</a>
mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id

-- | Make a global <a>Id</a> without any extra information at all
mkVanillaGlobal :: Name -> Type -> Id

-- | Make a global <a>Id</a> with no global information but some generic
--   <a>IdInfo</a>
mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id

-- | For an explanation of global vs. local <a>Id</a>s, see
--   <a>Var#globalvslocal</a>
mkLocalId :: Name -> Type -> Id
mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id

-- | Create a local <a>Id</a> that is marked as exported. This prevents
--   things attached to it from being removed as dead code. See Note
--   [Exported LocalIds]
mkExportedLocalId :: IdDetails -> Name -> Type -> Id

-- | Create a system local <a>Id</a>. These are local <a>Id</a>s (see
--   <a>Var#globalvslocal</a>) that are created by the compiler out of thin
--   air
mkSysLocal :: FastString -> Unique -> Type -> Id
mkSysLocalM :: MonadUnique m => FastString -> Type -> m Id

-- | Create a user local <a>Id</a>. These are local <a>Id</a>s (see
--   <a>Var#globalvslocal</a>) with a name and location that the user might
--   recognize
mkUserLocal :: OccName -> Unique -> Type -> SrcSpan -> Id
mkUserLocalM :: MonadUnique m => OccName -> Type -> SrcSpan -> m Id
mkDerivedLocalM :: MonadUnique m => (OccName -> OccName) -> Id -> Type -> m Id

-- | Create a template local for a series of types
mkTemplateLocals :: [Type] -> [Id]

-- | Create a template local for a series of type, but start from a
--   specified template local
mkTemplateLocalsNum :: Int -> [Type] -> [Id]

-- | Create a <i>template local</i>: a family of system local <a>Id</a>s in
--   bijection with <tt>Int</tt>s, typically used in unfoldings
mkTemplateLocal :: Int -> Type -> Id

-- | Workers get local names. <a>CoreTidy</a> will externalise these if
--   necessary
mkWorkerId :: Unique -> Id -> Type -> Id
mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name
idName :: Id -> Name
idType :: Id -> Kind
idUnique :: Id -> Unique
idInfo :: Id -> IdInfo
idDetails :: Id -> IdDetails
idRepArity :: Id -> RepArity

-- | If the <a>Id</a> is that for a record selector, extract the
--   <a>sel_tycon</a> and label. Panic otherwise
recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)
setIdName :: Id -> Name -> Id
setIdUnique :: Id -> Unique -> Id

-- | Not only does this set the <a>Id</a> <a>Type</a>, it also evaluates
--   the type to try and reduce space usage
setIdType :: Id -> Type -> Id
setIdExported :: Id -> Id
setIdNotExported :: Id -> Id

-- | If it's a local, make it global
globaliseId :: Id -> Id
localiseId :: Id -> Id
setIdInfo :: Id -> IdInfo -> Id
lazySetIdInfo :: Id -> IdInfo -> Id
modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
zapLamIdInfo :: Id -> Id
zapDemandIdInfo :: Id -> Id
zapFragileIdInfo :: Id -> Id
transferPolyIdInfo :: Id -> [Var] -> Id -> Id
zapIdStrictness :: Id -> Id

-- | <a>isImplicitId</a> tells whether an <a>Id</a>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.
isImplicitId :: Id -> Bool
isDeadBinder :: Id -> Bool

-- | This predicate says whether the <a>Id</a> has a strict demand placed
--   on it or has a type such that it can always be evaluated strictly (i.e
--   an unlifted type, as of GHC 7.6). We need to check separately whether
--   the <a>Id</a> has a so-called "strict type" because if the demand for
--   the given <tt>id</tt> hasn't been computed yet but <tt>id</tt> has a
--   strict type, we still want <tt>isStrictId id</tt> to be <tt>True</tt>.
isStrictId :: Id -> Bool

-- | <tt>isExportedIdVar</tt> means "don't throw this away"
isExportedId :: Var -> Bool
isLocalId :: Var -> Bool
isGlobalId :: Var -> Bool
isRecordSelector :: Id -> Bool
isNaughtyRecordSelector :: Id -> Bool
isClassOpId_maybe :: Id -> Maybe Class
isDFunId :: Id -> Bool
isPrimOpId :: Id -> Bool
isPrimOpId_maybe :: Id -> Maybe PrimOp
isFCallId :: Id -> Bool
isFCallId_maybe :: Id -> Maybe ForeignCall
isDataConWorkId :: Id -> Bool
isDataConWorkId_maybe :: Id -> Maybe DataCon
isDataConId_maybe :: Id -> Maybe DataCon

-- | Get from either the worker or the wrapper <a>Id</a> to the
--   <a>DataCon</a>. Currently used only in the desugarer.
--   
--   INVARIANT: <tt>idDataCon (dataConWrapId d) = d</tt>: remember,
--   <a>dataConWrapId</a> can return either the wrapper or the worker
idDataCon :: Id -> DataCon
isConLikeId :: Id -> Bool

-- | Returns true if an application to n args would diverge
isBottomingId :: Id -> Bool
idIsFrom :: Module -> Id -> Bool

-- | Returns <tt>True</tt> of an <a>Id</a> which may not have a binding,
--   even though it is defined in this module.
hasNoBinding :: Id -> Bool
type DictId = EvId
isDictId :: Id -> Bool
dfunNSilent :: Id -> Int
isEvVar :: Var -> Bool
idInlinePragma :: Id -> InlinePragma
setInlinePragma :: Id -> InlinePragma -> Id
modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
idInlineActivation :: Id -> Activation
setInlineActivation :: Id -> Activation -> Id
idRuleMatchInfo :: Id -> RuleMatchInfo

-- | Returns whether the lambda associated with the <a>Id</a> is certainly
--   applied at most once This one is the "business end", called
--   externally. It works on type variables as well as Ids, returning True
--   Its main purpose is to encapsulate the Horrible State Hack
isOneShotBndr :: Var -> Bool

-- | Returns whether the lambda associated with the <a>Id</a> is certainly
--   applied at most once. You probably want to use <a>isOneShotBndr</a>
--   instead
isOneShotLambda :: Id -> Bool
isProbablyOneShotLambda :: Id -> Bool
setOneShotLambda :: Id -> Id
clearOneShotLambda :: Id -> Id
updOneShotInfo :: Id -> OneShotInfo -> Id
setIdOneShotInfo :: Id -> OneShotInfo -> Id
isStateHackType :: Type -> Bool

-- | Should we apply the state hack to values of this <a>Type</a>?
stateHackOneShot :: OneShotInfo
typeOneShot :: Type -> OneShotInfo
idArity :: Id -> Arity
idCallArity :: Id -> Arity
idUnfolding :: Id -> Unfolding
realIdUnfolding :: Id -> Unfolding
idSpecialisation :: Id -> SpecInfo
idCoreRules :: Id -> [CoreRule]
idHasRules :: Id -> Bool
idCafInfo :: Id -> CafInfo
idOneShotInfo :: Id -> OneShotInfo
idOccInfo :: Id -> OccInfo
setIdUnfoldingLazily :: Id -> Unfolding -> Id
setIdUnfolding :: Id -> Unfolding -> Id
setIdArity :: Id -> Arity -> Id
setIdCallArity :: Id -> Arity -> Id
setIdSpecialisation :: Id -> SpecInfo -> Id
setIdCafInfo :: Id -> CafInfo -> Id
setIdOccInfo :: Id -> OccInfo -> Id
zapIdOccInfo :: Id -> Id
setIdDemandInfo :: Id -> Demand -> Id
setIdStrictness :: Id -> StrictSig -> Id
idDemandInfo :: Id -> Demand
idStrictness :: Id -> StrictSig

module UnVarGraph
data UnVarSet
emptyUnVarSet :: UnVarSet
mkUnVarSet :: [Var] -> UnVarSet
varEnvDom :: VarEnv a -> UnVarSet
unionUnVarSet :: UnVarSet -> UnVarSet -> UnVarSet
unionUnVarSets :: [UnVarSet] -> UnVarSet
delUnVarSet :: UnVarSet -> Var -> UnVarSet
elemUnVarSet :: Var -> UnVarSet -> Bool
isEmptyUnVarSet :: UnVarSet -> Bool
data UnVarGraph
emptyUnVarGraph :: UnVarGraph
unionUnVarGraph :: UnVarGraph -> UnVarGraph -> UnVarGraph
unionUnVarGraphs :: [UnVarGraph] -> UnVarGraph
completeGraph :: UnVarSet -> UnVarGraph
completeBipartiteGraph :: UnVarSet -> UnVarSet -> UnVarGraph
neighbors :: UnVarGraph -> Var -> UnVarSet
delNode :: UnVarGraph -> Var -> UnVarGraph
instance Eq UnVarSet
instance Outputable UnVarSet
instance Outputable Gen
instance Outputable UnVarGraph


-- | Simple vectorised constructors and projections.
module Vectorise.Vect

-- | Contains the vectorised and lifted versions of some thing.
type Vect a = (a, a)
type VVar = Vect Var
type VExpr = Vect CoreExpr
type VBind = Vect CoreBind

-- | Get the vectorised version of a thing.
vectorised :: Vect a -> a

-- | Get the lifted version of a thing.
lifted :: Vect a -> a

-- | Apply some function to both the vectorised and lifted versions of a
--   thing.
mapVect :: (a -> b) -> Vect a -> Vect b

-- | Get the type of a vectorised variable.
vVarType :: VVar -> Type

-- | Make a vectorised non-recursive binding.
vNonRec :: VVar -> VExpr -> VBind

-- | Make a vectorised recursive binding.
vRec :: [VVar] -> [VExpr] -> VBind

-- | Wrap a vectorised variable as a vectorised expression.
vVar :: VVar -> VExpr

-- | Wrap a vectorised type as a vectorised expression.
vType :: Type -> VExpr

-- | Make a vectorised note.
vTick :: Tickish Id -> VExpr -> VExpr

-- | Make a vectorised let expresion.
vLet :: VBind -> VExpr -> VExpr

-- | Make a vectorised lambda abstraction.
--   
--   The lifted version also binds the lifting context <tt>lc</tt>.
vLams :: Var -> [VVar] -> VExpr -> VExpr

-- | Apply an expression to a set of argument variables.
--   
--   The lifted version is also applied to the variable of the lifting
--   context.
vVarApps :: Var -> VExpr -> [VVar] -> VExpr
vCaseDEFAULT :: VExpr -> VVar -> Type -> Type -> VExpr -> VExpr

module PprCore
pprCoreExpr :: OutputableBndr b => Expr b -> SDoc
pprParendExpr :: OutputableBndr b => Expr b -> SDoc
pprCoreBinding :: OutputableBndr b => Bind b -> SDoc
pprCoreBindings :: OutputableBndr b => [Bind b] -> SDoc
pprCoreAlt :: OutputableBndr a => (AltCon, [a], Expr a) -> SDoc
pprRules :: [CoreRule] -> SDoc
instance OutputableBndr b => Outputable (Bind b)
instance OutputableBndr b => Outputable (Expr b)
instance OutputableBndr Var
instance Outputable UnfoldingGuidance
instance Outputable UnfoldingSource
instance Outputable Unfolding
instance Outputable CoreRule
instance Outputable id => Outputable (Tickish id)
instance Outputable CoreVect

module HsTypes
data HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnForall</a>,
--   <a>AnnDot</a>,<a>AnnDarrow</a></li>
--   </ul>
[HsForAllTy] :: HsExplicitFlag -> (Maybe SrcSpan) -> (LHsTyVarBndrs name) -> (LHsContext name) -> (LHsType name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsTyVar] :: name -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsAppTy] :: (LHsType name) -> (LHsType name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnRarrow</a>,</li>
--   </ul>
[HsFunTy] :: (LHsType name) -> (LHsType name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'['</tt>, <a>AnnClose</a>
--   <tt>']'</tt></li>
--   </ul>
[HsListTy] :: (LHsType name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'[:'</tt>,
--   <a>AnnClose</a> <tt>':]'</tt></li>
--   </ul>
[HsPArrTy] :: (LHsType name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'(' or '(#'</tt>,
--   <a>AnnClose</a> <tt>')' or '#)'</tt></li>
--   </ul>
[HsTupleTy] :: HsTupleSort -> [LHsType name] -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsOpTy] :: (LHsType name) -> (LHsTyOp name) -> (LHsType name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'('</tt>, <a>AnnClose</a>
--   <tt>')'</tt></li>
--   </ul>
[HsParTy] :: (LHsType name) -> HsType name

-- | <pre>
--   (?x :: ty)
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDcolon</a></li>
--   </ul>
[HsIParamTy] :: HsIPName -> (LHsType name) -> HsType name

-- | <pre>
--   ty1 ~ ty2
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnTilde</a></li>
--   </ul>
[HsEqTy] :: (LHsType name) -> (LHsType name) -> HsType name

-- | <pre>
--   (ty :: kind)
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'('</tt>,
--   <a>AnnDcolon</a>,<a>AnnClose</a> <tt>')'</tt></li>
--   </ul>
[HsKindSig] :: (LHsType name) -> (LHsKind name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsQuasiQuoteTy] :: (HsQuasiQuote name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'$('</tt>,
--   <a>AnnClose</a> <tt>')'</tt></li>
--   </ul>
[HsSpliceTy] :: (HsSplice name) -> (PostTc name Kind) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsDocTy] :: (LHsType name) -> LHsDocString -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{-# UNPACK' or '{-#
--   NOUNPACK'</tt>, <a>AnnClose</a> <tt>'#-}'</tt> <a>AnnBang</a>
--   <tt>'!'</tt></li>
--   </ul>
[HsBangTy] :: HsSrcBang -> (LHsType name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{'</tt>, <a>AnnClose</a>
--   <tt>'}'</tt></li>
--   </ul>
[HsRecTy] :: [LConDeclField name] -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsCoreTy] :: Type -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>"'["</tt>,
--   <a>AnnClose</a> <tt>']'</tt></li>
--   </ul>
[HsExplicitListTy] :: (PostTc name Kind) -> [LHsType name] -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>"'("</tt>,
--   <a>AnnClose</a> <tt>')'</tt></li>
--   </ul>
[HsExplicitTupleTy] :: [PostTc name Kind] -> [LHsType name] -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsTyLit] :: HsTyLit -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsWrapTy] :: HsTyWrapper -> (HsType name) -> HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsWildcardTy] :: HsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : None</li>
--   </ul>
[HsNamedWildcardTy] :: name -> HsType name
type LHsType name = Located (HsType name)  May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list
type HsKind name = HsType name
type LHsKind name = Located (HsKind name)
type HsTyOp name = (HsTyWrapper, name)
type LHsTyOp name = HsTyOp (Located name)
data HsTyVarBndr name
[UserTyVar] :: name -> HsTyVarBndr name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnDcolon</a>,
--   <a>AnnClose</a></li>
--   </ul>
[KindedTyVar] :: (Located name) -> (LHsKind name) -> HsTyVarBndr name
type LHsTyVarBndr name = Located (HsTyVarBndr name)
data LHsTyVarBndrs name
[HsQTvs] :: [Name] -> [LHsTyVarBndr name] -> LHsTyVarBndrs name
[hsq_kvs] :: LHsTyVarBndrs name -> [Name]
[hsq_tvs] :: LHsTyVarBndrs name -> [LHsTyVarBndr name]
data HsWithBndrs name thing
[HsWB] :: thing -> PostRn name [Name] -> PostRn name [Name] -> PostRn name [Name] -> HsWithBndrs name thing
[hswb_cts] :: HsWithBndrs name thing -> thing
[hswb_kvs] :: HsWithBndrs name thing -> PostRn name [Name]
[hswb_tvs] :: HsWithBndrs name thing -> PostRn name [Name]
[hswb_wcs] :: HsWithBndrs name thing -> PostRn name [Name]
data HsTupleSort
[HsUnboxedTuple] :: HsTupleSort
[HsBoxedTuple] :: HsTupleSort
[HsConstraintTuple] :: HsTupleSort
[HsBoxedOrConstraintTuple] :: HsTupleSort
data HsExplicitFlag
[Qualified] :: HsExplicitFlag
[Implicit] :: HsExplicitFlag
[Explicit] :: HsExplicitFlag
type HsContext name = [LHsType name]
type LHsContext name = Located (HsContext name)  'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnUnit'
data HsQuasiQuote id
[HsQuasiQuote] :: id -> SrcSpan -> FastString -> HsQuasiQuote id
data HsTyWrapper
[WpKiApps] :: [Kind] -> HsTyWrapper
data HsTyLit
[HsNumTy] :: SourceText -> Integer -> HsTyLit
[HsStrTy] :: SourceText -> FastString -> HsTyLit

-- | These names are used early on to store the names of implicit
--   parameters. They completely disappear after type-checking.
newtype HsIPName
[HsIPName] :: FastString -> HsIPName
hsIPNameFS :: HsIPName -> FastString
type LBangType name = Located (BangType name)
type BangType name = HsType name
data HsBang
[HsNoBang] :: HsBang
[HsSrcBang] :: (Maybe SourceText) -> (Maybe Bool) -> Bool -> HsBang
[HsUnpack] :: (Maybe Coercion) -> HsBang
[HsStrict] :: HsBang
type HsSrcBang = HsBang
type HsImplBang = HsBang
getBangType :: LHsType a -> LHsType a
getBangStrictness :: LHsType a -> HsSrcBang
data ConDeclField name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDcolon</a></li>
--   </ul>
[ConDeclField] :: [Located name] -> LBangType name -> Maybe LHsDocString -> ConDeclField name
[cd_fld_names] :: ConDeclField name -> [Located name]
[cd_fld_type] :: ConDeclField name -> LBangType name
[cd_fld_doc] :: ConDeclField name -> Maybe LHsDocString
type LConDeclField name = Located (ConDeclField name)  May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list
pprConDeclFields :: OutputableBndr name => [LConDeclField name] -> SDoc
mkHsQTvs :: [LHsTyVarBndr RdrName] -> LHsTyVarBndrs RdrName
hsQTvBndrs :: LHsTyVarBndrs name -> [LHsTyVarBndr name]

-- | Does this <a>HsTyVarBndr</a> come with an explicit kind annotation?
isHsKindedTyVar :: HsTyVarBndr name -> Bool

-- | Do all type variables in this <a>LHsTyVarBndr</a> come with kind
--   annotations?
hsTvbAllKinded :: LHsTyVarBndrs name -> Bool
mkExplicitHsForAllTy :: [LHsTyVarBndr RdrName] -> LHsContext RdrName -> LHsType RdrName -> HsType RdrName
mkImplicitHsForAllTy :: LHsContext RdrName -> LHsType RdrName -> HsType RdrName
mkQualifiedHsForAllTy :: LHsContext RdrName -> LHsType RdrName -> HsType RdrName
hsExplicitTvs :: LHsType Name -> [Name]
hsTyVarName :: HsTyVarBndr name -> name
mkHsWithBndrs :: thing -> HsWithBndrs RdrName thing
hsLKiTyVarNames :: LHsTyVarBndrs Name -> [Name]
hsLTyVarName :: LHsTyVarBndr name -> name
hsLTyVarNames :: LHsTyVarBndrs name -> [name]
hsLTyVarLocName :: LHsTyVarBndr name -> Located name
hsLTyVarLocNames :: LHsTyVarBndrs name -> [Located name]
splitLHsInstDeclTy_maybe :: LHsType name -> Maybe (LHsTyVarBndrs name, HsContext name, Located name, [LHsType name])
splitHsClassTy_maybe :: HsType name -> Maybe (name, [LHsType name])
splitLHsClassTy_maybe :: LHsType name -> Maybe (Located name, [LHsType name])
splitHsFunType :: LHsType Name -> ([LHsType Name], LHsType Name)
splitHsAppTys :: LHsType n -> [LHsType n] -> (LHsType n, [LHsType n])
hsTyGetAppHead_maybe :: LHsType n -> Maybe (n, [LHsType n])
mkHsAppTys :: OutputableBndr n => LHsType n -> [LHsType n] -> HsType n
mkHsOpTy :: LHsType name -> Located name -> LHsType name -> HsType name
isWildcardTy :: HsType a -> Bool
isNamedWildcardTy :: HsType a -> Bool
pprParendHsType :: (OutputableBndr name) => HsType name -> SDoc
pprHsForAll :: OutputableBndr name => HsExplicitFlag -> LHsTyVarBndrs name -> LHsContext name -> SDoc

-- | Version of <a>pprHsForAll</a> that can also print an extra-constraints
--   wildcard, e.g. <tt>_ =&gt; a -&gt; Bool</tt> or <tt>(Show a, _) =&gt;
--   a -&gt; String</tt>. This underscore will be printed when the 'Maybe
--   SrcSpan' argument is a <a>Just</a> containing the location of the
--   extra-constraints wildcard. A special function for this is needed, as
--   the extra-constraints wildcard is removed from the actual context and
--   type, and stored in a separate field, thus just printing the type will
--   not print the extra-constraints wildcard.
pprHsForAllExtra :: OutputableBndr name => HsExplicitFlag -> Maybe SrcSpan -> LHsTyVarBndrs name -> LHsContext name -> SDoc
pprHsContext :: (OutputableBndr name) => HsContext name -> SDoc
pprHsContextNoArrow :: (OutputableBndr name) => HsContext name -> SDoc
pprHsContextMaybe :: (OutputableBndr name) => HsContext name -> Maybe SDoc
instance Data HsExplicitFlag
instance Data HsTupleSort
instance Data HsTyWrapper
instance Data HsTyLit
instance Data HsIPName
instance Eq HsIPName
instance Data id => Data (HsQuasiQuote id)
instance DataId name => Data (LHsTyVarBndrs name)
instance (Data name, Data thing, Data (PostRn name [Name])) => Data (HsWithBndrs name thing)
instance DataId name => Data (HsTyVarBndr name)
instance DataId name => Data (HsType name)
instance DataId name => Data (ConDeclField name)
instance OutputableBndr id => Outputable (HsQuasiQuote id)
instance Outputable HsIPName
instance OutputableBndr HsIPName
instance OutputableBndr name => Outputable (HsType name)
instance Outputable HsTyLit
instance OutputableBndr name => Outputable (LHsTyVarBndrs name)
instance OutputableBndr name => Outputable (HsTyVarBndr name)
instance Outputable thing => Outputable (HsWithBndrs name thing)


-- | This module is about types that can be defined in Haskell, but which
--   must be wired into the compiler nonetheless. C.f module TysPrim
module TysWiredIn
wiredInTyCons :: [TyCon]
isBuiltInOcc_maybe :: OccName -> Maybe Name
boolTy :: Type
boolTyCon :: TyCon
boolTyCon_RDR :: RdrName
boolTyConName :: Name
trueDataCon :: DataCon
trueDataConId :: Id
true_RDR :: RdrName
falseDataCon :: DataCon
falseDataConId :: Id
false_RDR :: RdrName
promotedBoolTyCon :: TyCon
promotedFalseDataCon :: TyCon
promotedTrueDataCon :: TyCon
ltDataCon :: DataCon
ltDataConId :: Id
eqDataCon :: DataCon
eqDataConId :: Id
gtDataCon :: DataCon
gtDataConId :: Id
promotedOrderingTyCon :: TyCon
promotedLTDataCon :: TyCon
promotedEQDataCon :: TyCon
promotedGTDataCon :: TyCon
charTyCon :: TyCon
charDataCon :: DataCon
charTyCon_RDR :: RdrName
charTy :: Type
stringTy :: Type
charTyConName :: Name
doubleTyCon :: TyCon
doubleDataCon :: DataCon
doubleTy :: Type
doubleTyConName :: Name
floatTyCon :: TyCon
floatDataCon :: DataCon
floatTy :: Type
floatTyConName :: Name
intTyCon :: TyCon
intDataCon :: DataCon
intTyCon_RDR :: RdrName
intDataCon_RDR :: RdrName
intTyConName :: Name
intTy :: Type
wordTyCon :: TyCon
wordDataCon :: DataCon
wordTyConName :: Name
wordTy :: Type
listTyCon :: TyCon
nilDataCon :: DataCon
nilDataConName :: Name
consDataCon :: DataCon
consDataConName :: Name
listTyCon_RDR :: RdrName
consDataCon_RDR :: RdrName
listTyConName :: Name
mkListTy :: Type -> Type
mkPromotedListTy :: Type -> Type
mkTupleTy :: TupleSort -> [Type] -> Type

-- | Build the type of a small tuple that holds the specified type of thing
mkBoxedTupleTy :: [Type] -> Type
tupleTyCon :: TupleSort -> Arity -> TyCon
tupleCon :: TupleSort -> Arity -> DataCon
promotedTupleTyCon :: TupleSort -> Arity -> TyCon
promotedTupleDataCon :: TupleSort -> Arity -> TyCon
unitTyCon :: TyCon
unitDataCon :: DataCon
unitDataConId :: Id
pairTyCon :: TyCon
unboxedUnitTyCon :: TyCon
unboxedUnitDataCon :: DataCon
unboxedSingletonTyCon :: TyCon
unboxedSingletonDataCon :: DataCon
unboxedPairTyCon :: TyCon
unboxedPairDataCon :: DataCon
unitTy :: Type
typeNatKindCon :: TyCon
typeNatKind :: Kind
typeSymbolKindCon :: TyCon
typeSymbolKind :: Kind

-- | Construct a type representing the application of the parallel array
--   constructor
mkPArrTy :: Type -> Type

-- | Represents the type constructor of parallel arrays
--   
--   <ul>
--   <li>This must match the definition in <tt>PrelPArr</tt></li>
--   </ul>
--   
--   NB: Although the constructor is given here, it will not be accessible
--   in user code as it is not in the environment of any compiled module
--   except <tt>PrelPArr</tt>.
parrTyCon :: TyCon

-- | Fake array constructors
--   
--   <ul>
--   <li>These constructors are never really used to represent array
--   values; however, they are very convenient during desugaring (and, in
--   particular, in the pattern matching compiler) to treat array pattern
--   just like yet another constructor pattern</li>
--   </ul>
parrFakeCon :: Arity -> DataCon

-- | Check whether a type constructor is the constructor for parallel
--   arrays
isPArrTyCon :: TyCon -> Bool

-- | Checks whether a data constructor is a fake constructor for parallel
--   arrays
isPArrFakeCon :: DataCon -> Bool
parrTyCon_RDR :: RdrName
parrTyConName :: Name
eqTyCon_RDR :: RdrName
eqTyCon :: TyCon
eqTyConName :: Name
eqBoxDataCon :: DataCon
coercibleTyCon :: TyCon
coercibleDataCon :: DataCon
coercibleClass :: Class
mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name

module PrimOp
data PrimOp
[CharGtOp] :: PrimOp
[CharGeOp] :: PrimOp
[CharEqOp] :: PrimOp
[CharNeOp] :: PrimOp
[CharLtOp] :: PrimOp
[CharLeOp] :: PrimOp
[OrdOp] :: PrimOp
[IntAddOp] :: PrimOp
[IntSubOp] :: PrimOp
[IntMulOp] :: PrimOp
[IntMulMayOfloOp] :: PrimOp
[IntQuotOp] :: PrimOp
[IntRemOp] :: PrimOp
[IntQuotRemOp] :: PrimOp
[AndIOp] :: PrimOp
[OrIOp] :: PrimOp
[XorIOp] :: PrimOp
[NotIOp] :: PrimOp
[IntNegOp] :: PrimOp
[IntAddCOp] :: PrimOp
[IntSubCOp] :: PrimOp
[IntGtOp] :: PrimOp
[IntGeOp] :: PrimOp
[IntEqOp] :: PrimOp
[IntNeOp] :: PrimOp
[IntLtOp] :: PrimOp
[IntLeOp] :: PrimOp
[ChrOp] :: PrimOp
[Int2WordOp] :: PrimOp
[Int2FloatOp] :: PrimOp
[Int2DoubleOp] :: PrimOp
[Word2FloatOp] :: PrimOp
[Word2DoubleOp] :: PrimOp
[ISllOp] :: PrimOp
[ISraOp] :: PrimOp
[ISrlOp] :: PrimOp
[WordAddOp] :: PrimOp
[WordAdd2Op] :: PrimOp
[WordSubOp] :: PrimOp
[WordMulOp] :: PrimOp
[WordMul2Op] :: PrimOp
[WordQuotOp] :: PrimOp
[WordRemOp] :: PrimOp
[WordQuotRemOp] :: PrimOp
[WordQuotRem2Op] :: PrimOp
[AndOp] :: PrimOp
[OrOp] :: PrimOp
[XorOp] :: PrimOp
[NotOp] :: PrimOp
[SllOp] :: PrimOp
[SrlOp] :: PrimOp
[Word2IntOp] :: PrimOp
[WordGtOp] :: PrimOp
[WordGeOp] :: PrimOp
[WordEqOp] :: PrimOp
[WordNeOp] :: PrimOp
[WordLtOp] :: PrimOp
[WordLeOp] :: PrimOp
[PopCnt8Op] :: PrimOp
[PopCnt16Op] :: PrimOp
[PopCnt32Op] :: PrimOp
[PopCnt64Op] :: PrimOp
[PopCntOp] :: PrimOp
[Clz8Op] :: PrimOp
[Clz16Op] :: PrimOp
[Clz32Op] :: PrimOp
[Clz64Op] :: PrimOp
[ClzOp] :: PrimOp
[Ctz8Op] :: PrimOp
[Ctz16Op] :: PrimOp
[Ctz32Op] :: PrimOp
[Ctz64Op] :: PrimOp
[CtzOp] :: PrimOp
[BSwap16Op] :: PrimOp
[BSwap32Op] :: PrimOp
[BSwap64Op] :: PrimOp
[BSwapOp] :: PrimOp
[Narrow8IntOp] :: PrimOp
[Narrow16IntOp] :: PrimOp
[Narrow32IntOp] :: PrimOp
[Narrow8WordOp] :: PrimOp
[Narrow16WordOp] :: PrimOp
[Narrow32WordOp] :: PrimOp
[DoubleGtOp] :: PrimOp
[DoubleGeOp] :: PrimOp
[DoubleEqOp] :: PrimOp
[DoubleNeOp] :: PrimOp
[DoubleLtOp] :: PrimOp
[DoubleLeOp] :: PrimOp
[DoubleAddOp] :: PrimOp
[DoubleSubOp] :: PrimOp
[DoubleMulOp] :: PrimOp
[DoubleDivOp] :: PrimOp
[DoubleNegOp] :: PrimOp
[Double2IntOp] :: PrimOp
[Double2FloatOp] :: PrimOp
[DoubleExpOp] :: PrimOp
[DoubleLogOp] :: PrimOp
[DoubleSqrtOp] :: PrimOp
[DoubleSinOp] :: PrimOp
[DoubleCosOp] :: PrimOp
[DoubleTanOp] :: PrimOp
[DoubleAsinOp] :: PrimOp
[DoubleAcosOp] :: PrimOp
[DoubleAtanOp] :: PrimOp
[DoubleSinhOp] :: PrimOp
[DoubleCoshOp] :: PrimOp
[DoubleTanhOp] :: PrimOp
[DoublePowerOp] :: PrimOp
[DoubleDecode_2IntOp] :: PrimOp
[DoubleDecode_Int64Op] :: PrimOp
[FloatGtOp] :: PrimOp
[FloatGeOp] :: PrimOp
[FloatEqOp] :: PrimOp
[FloatNeOp] :: PrimOp
[FloatLtOp] :: PrimOp
[FloatLeOp] :: PrimOp
[FloatAddOp] :: PrimOp
[FloatSubOp] :: PrimOp
[FloatMulOp] :: PrimOp
[FloatDivOp] :: PrimOp
[FloatNegOp] :: PrimOp
[Float2IntOp] :: PrimOp
[FloatExpOp] :: PrimOp
[FloatLogOp] :: PrimOp
[FloatSqrtOp] :: PrimOp
[FloatSinOp] :: PrimOp
[FloatCosOp] :: PrimOp
[FloatTanOp] :: PrimOp
[FloatAsinOp] :: PrimOp
[FloatAcosOp] :: PrimOp
[FloatAtanOp] :: PrimOp
[FloatSinhOp] :: PrimOp
[FloatCoshOp] :: PrimOp
[FloatTanhOp] :: PrimOp
[FloatPowerOp] :: PrimOp
[Float2DoubleOp] :: PrimOp
[FloatDecode_IntOp] :: PrimOp
[NewArrayOp] :: PrimOp
[SameMutableArrayOp] :: PrimOp
[ReadArrayOp] :: PrimOp
[WriteArrayOp] :: PrimOp
[SizeofArrayOp] :: PrimOp
[SizeofMutableArrayOp] :: PrimOp
[IndexArrayOp] :: PrimOp
[UnsafeFreezeArrayOp] :: PrimOp
[UnsafeThawArrayOp] :: PrimOp
[CopyArrayOp] :: PrimOp
[CopyMutableArrayOp] :: PrimOp
[CloneArrayOp] :: PrimOp
[CloneMutableArrayOp] :: PrimOp
[FreezeArrayOp] :: PrimOp
[ThawArrayOp] :: PrimOp
[CasArrayOp] :: PrimOp
[NewSmallArrayOp] :: PrimOp
[SameSmallMutableArrayOp] :: PrimOp
[ReadSmallArrayOp] :: PrimOp
[WriteSmallArrayOp] :: PrimOp
[SizeofSmallArrayOp] :: PrimOp
[SizeofSmallMutableArrayOp] :: PrimOp
[IndexSmallArrayOp] :: PrimOp
[UnsafeFreezeSmallArrayOp] :: PrimOp
[UnsafeThawSmallArrayOp] :: PrimOp
[CopySmallArrayOp] :: PrimOp
[CopySmallMutableArrayOp] :: PrimOp
[CloneSmallArrayOp] :: PrimOp
[CloneSmallMutableArrayOp] :: PrimOp
[FreezeSmallArrayOp] :: PrimOp
[ThawSmallArrayOp] :: PrimOp
[CasSmallArrayOp] :: PrimOp
[NewByteArrayOp_Char] :: PrimOp
[NewPinnedByteArrayOp_Char] :: PrimOp
[NewAlignedPinnedByteArrayOp_Char] :: PrimOp
[ByteArrayContents_Char] :: PrimOp
[SameMutableByteArrayOp] :: PrimOp
[ShrinkMutableByteArrayOp_Char] :: PrimOp
[ResizeMutableByteArrayOp_Char] :: PrimOp
[UnsafeFreezeByteArrayOp] :: PrimOp
[SizeofByteArrayOp] :: PrimOp
[SizeofMutableByteArrayOp] :: PrimOp
[IndexByteArrayOp_Char] :: PrimOp
[IndexByteArrayOp_WideChar] :: PrimOp
[IndexByteArrayOp_Int] :: PrimOp
[IndexByteArrayOp_Word] :: PrimOp
[IndexByteArrayOp_Addr] :: PrimOp
[IndexByteArrayOp_Float] :: PrimOp
[IndexByteArrayOp_Double] :: PrimOp
[IndexByteArrayOp_StablePtr] :: PrimOp
[IndexByteArrayOp_Int8] :: PrimOp
[IndexByteArrayOp_Int16] :: PrimOp
[IndexByteArrayOp_Int32] :: PrimOp
[IndexByteArrayOp_Int64] :: PrimOp
[IndexByteArrayOp_Word8] :: PrimOp
[IndexByteArrayOp_Word16] :: PrimOp
[IndexByteArrayOp_Word32] :: PrimOp
[IndexByteArrayOp_Word64] :: PrimOp
[ReadByteArrayOp_Char] :: PrimOp
[ReadByteArrayOp_WideChar] :: PrimOp
[ReadByteArrayOp_Int] :: PrimOp
[ReadByteArrayOp_Word] :: PrimOp
[ReadByteArrayOp_Addr] :: PrimOp
[ReadByteArrayOp_Float] :: PrimOp
[ReadByteArrayOp_Double] :: PrimOp
[ReadByteArrayOp_StablePtr] :: PrimOp
[ReadByteArrayOp_Int8] :: PrimOp
[ReadByteArrayOp_Int16] :: PrimOp
[ReadByteArrayOp_Int32] :: PrimOp
[ReadByteArrayOp_Int64] :: PrimOp
[ReadByteArrayOp_Word8] :: PrimOp
[ReadByteArrayOp_Word16] :: PrimOp
[ReadByteArrayOp_Word32] :: PrimOp
[ReadByteArrayOp_Word64] :: PrimOp
[WriteByteArrayOp_Char] :: PrimOp
[WriteByteArrayOp_WideChar] :: PrimOp
[WriteByteArrayOp_Int] :: PrimOp
[WriteByteArrayOp_Word] :: PrimOp
[WriteByteArrayOp_Addr] :: PrimOp
[WriteByteArrayOp_Float] :: PrimOp
[WriteByteArrayOp_Double] :: PrimOp
[WriteByteArrayOp_StablePtr] :: PrimOp
[WriteByteArrayOp_Int8] :: PrimOp
[WriteByteArrayOp_Int16] :: PrimOp
[WriteByteArrayOp_Int32] :: PrimOp
[WriteByteArrayOp_Int64] :: PrimOp
[WriteByteArrayOp_Word8] :: PrimOp
[WriteByteArrayOp_Word16] :: PrimOp
[WriteByteArrayOp_Word32] :: PrimOp
[WriteByteArrayOp_Word64] :: PrimOp
[CopyByteArrayOp] :: PrimOp
[CopyMutableByteArrayOp] :: PrimOp
[CopyByteArrayToAddrOp] :: PrimOp
[CopyMutableByteArrayToAddrOp] :: PrimOp
[CopyAddrToByteArrayOp] :: PrimOp
[SetByteArrayOp] :: PrimOp
[AtomicReadByteArrayOp_Int] :: PrimOp
[AtomicWriteByteArrayOp_Int] :: PrimOp
[CasByteArrayOp_Int] :: PrimOp
[FetchAddByteArrayOp_Int] :: PrimOp
[FetchSubByteArrayOp_Int] :: PrimOp
[FetchAndByteArrayOp_Int] :: PrimOp
[FetchNandByteArrayOp_Int] :: PrimOp
[FetchOrByteArrayOp_Int] :: PrimOp
[FetchXorByteArrayOp_Int] :: PrimOp
[NewArrayArrayOp] :: PrimOp
[SameMutableArrayArrayOp] :: PrimOp
[UnsafeFreezeArrayArrayOp] :: PrimOp
[SizeofArrayArrayOp] :: PrimOp
[SizeofMutableArrayArrayOp] :: PrimOp
[IndexArrayArrayOp_ByteArray] :: PrimOp
[IndexArrayArrayOp_ArrayArray] :: PrimOp
[ReadArrayArrayOp_ByteArray] :: PrimOp
[ReadArrayArrayOp_MutableByteArray] :: PrimOp
[ReadArrayArrayOp_ArrayArray] :: PrimOp
[ReadArrayArrayOp_MutableArrayArray] :: PrimOp
[WriteArrayArrayOp_ByteArray] :: PrimOp
[WriteArrayArrayOp_MutableByteArray] :: PrimOp
[WriteArrayArrayOp_ArrayArray] :: PrimOp
[WriteArrayArrayOp_MutableArrayArray] :: PrimOp
[CopyArrayArrayOp] :: PrimOp
[CopyMutableArrayArrayOp] :: PrimOp
[AddrAddOp] :: PrimOp
[AddrSubOp] :: PrimOp
[AddrRemOp] :: PrimOp
[Addr2IntOp] :: PrimOp
[Int2AddrOp] :: PrimOp
[AddrGtOp] :: PrimOp
[AddrGeOp] :: PrimOp
[AddrEqOp] :: PrimOp
[AddrNeOp] :: PrimOp
[AddrLtOp] :: PrimOp
[AddrLeOp] :: PrimOp
[IndexOffAddrOp_Char] :: PrimOp
[IndexOffAddrOp_WideChar] :: PrimOp
[IndexOffAddrOp_Int] :: PrimOp
[IndexOffAddrOp_Word] :: PrimOp
[IndexOffAddrOp_Addr] :: PrimOp
[IndexOffAddrOp_Float] :: PrimOp
[IndexOffAddrOp_Double] :: PrimOp
[IndexOffAddrOp_StablePtr] :: PrimOp
[IndexOffAddrOp_Int8] :: PrimOp
[IndexOffAddrOp_Int16] :: PrimOp
[IndexOffAddrOp_Int32] :: PrimOp
[IndexOffAddrOp_Int64] :: PrimOp
[IndexOffAddrOp_Word8] :: PrimOp
[IndexOffAddrOp_Word16] :: PrimOp
[IndexOffAddrOp_Word32] :: PrimOp
[IndexOffAddrOp_Word64] :: PrimOp
[ReadOffAddrOp_Char] :: PrimOp
[ReadOffAddrOp_WideChar] :: PrimOp
[ReadOffAddrOp_Int] :: PrimOp
[ReadOffAddrOp_Word] :: PrimOp
[ReadOffAddrOp_Addr] :: PrimOp
[ReadOffAddrOp_Float] :: PrimOp
[ReadOffAddrOp_Double] :: PrimOp
[ReadOffAddrOp_StablePtr] :: PrimOp
[ReadOffAddrOp_Int8] :: PrimOp
[ReadOffAddrOp_Int16] :: PrimOp
[ReadOffAddrOp_Int32] :: PrimOp
[ReadOffAddrOp_Int64] :: PrimOp
[ReadOffAddrOp_Word8] :: PrimOp
[ReadOffAddrOp_Word16] :: PrimOp
[ReadOffAddrOp_Word32] :: PrimOp
[ReadOffAddrOp_Word64] :: PrimOp
[WriteOffAddrOp_Char] :: PrimOp
[WriteOffAddrOp_WideChar] :: PrimOp
[WriteOffAddrOp_Int] :: PrimOp
[WriteOffAddrOp_Word] :: PrimOp
[WriteOffAddrOp_Addr] :: PrimOp
[WriteOffAddrOp_Float] :: PrimOp
[WriteOffAddrOp_Double] :: PrimOp
[WriteOffAddrOp_StablePtr] :: PrimOp
[WriteOffAddrOp_Int8] :: PrimOp
[WriteOffAddrOp_Int16] :: PrimOp
[WriteOffAddrOp_Int32] :: PrimOp
[WriteOffAddrOp_Int64] :: PrimOp
[WriteOffAddrOp_Word8] :: PrimOp
[WriteOffAddrOp_Word16] :: PrimOp
[WriteOffAddrOp_Word32] :: PrimOp
[WriteOffAddrOp_Word64] :: PrimOp
[NewMutVarOp] :: PrimOp
[ReadMutVarOp] :: PrimOp
[WriteMutVarOp] :: PrimOp
[SameMutVarOp] :: PrimOp
[AtomicModifyMutVarOp] :: PrimOp
[CasMutVarOp] :: PrimOp
[CatchOp] :: PrimOp
[RaiseOp] :: PrimOp
[RaiseIOOp] :: PrimOp
[MaskAsyncExceptionsOp] :: PrimOp
[MaskUninterruptibleOp] :: PrimOp
[UnmaskAsyncExceptionsOp] :: PrimOp
[MaskStatus] :: PrimOp
[AtomicallyOp] :: PrimOp
[RetryOp] :: PrimOp
[CatchRetryOp] :: PrimOp
[CatchSTMOp] :: PrimOp
[Check] :: PrimOp
[NewTVarOp] :: PrimOp
[ReadTVarOp] :: PrimOp
[ReadTVarIOOp] :: PrimOp
[WriteTVarOp] :: PrimOp
[SameTVarOp] :: PrimOp
[NewMVarOp] :: PrimOp
[TakeMVarOp] :: PrimOp
[TryTakeMVarOp] :: PrimOp
[PutMVarOp] :: PrimOp
[TryPutMVarOp] :: PrimOp
[ReadMVarOp] :: PrimOp
[TryReadMVarOp] :: PrimOp
[SameMVarOp] :: PrimOp
[IsEmptyMVarOp] :: PrimOp
[DelayOp] :: PrimOp
[WaitReadOp] :: PrimOp
[WaitWriteOp] :: PrimOp
[ForkOp] :: PrimOp
[ForkOnOp] :: PrimOp
[KillThreadOp] :: PrimOp
[YieldOp] :: PrimOp
[MyThreadIdOp] :: PrimOp
[LabelThreadOp] :: PrimOp
[IsCurrentThreadBoundOp] :: PrimOp
[NoDuplicateOp] :: PrimOp
[ThreadStatusOp] :: PrimOp
[MkWeakOp] :: PrimOp
[MkWeakNoFinalizerOp] :: PrimOp
[AddCFinalizerToWeakOp] :: PrimOp
[DeRefWeakOp] :: PrimOp
[FinalizeWeakOp] :: PrimOp
[TouchOp] :: PrimOp
[MakeStablePtrOp] :: PrimOp
[DeRefStablePtrOp] :: PrimOp
[EqStablePtrOp] :: PrimOp
[MakeStableNameOp] :: PrimOp
[EqStableNameOp] :: PrimOp
[StableNameToIntOp] :: PrimOp
[ReallyUnsafePtrEqualityOp] :: PrimOp
[ParOp] :: PrimOp
[SparkOp] :: PrimOp
[SeqOp] :: PrimOp
[GetSparkOp] :: PrimOp
[NumSparks] :: PrimOp
[ParGlobalOp] :: PrimOp
[ParLocalOp] :: PrimOp
[ParAtOp] :: PrimOp
[ParAtAbsOp] :: PrimOp
[ParAtRelOp] :: PrimOp
[ParAtForNowOp] :: PrimOp
[DataToTagOp] :: PrimOp
[TagToEnumOp] :: PrimOp
[AddrToAnyOp] :: PrimOp
[MkApUpd0_Op] :: PrimOp
[NewBCOOp] :: PrimOp
[UnpackClosureOp] :: PrimOp
[GetApStackValOp] :: PrimOp
[GetCCSOfOp] :: PrimOp
[GetCurrentCCSOp] :: PrimOp
[TraceEventOp] :: PrimOp
[TraceMarkerOp] :: PrimOp
[VecBroadcastOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecPackOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecUnpackOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecInsertOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecAddOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecSubOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecMulOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecDivOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecQuotOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecRemOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecNegOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecIndexByteArrayOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecReadByteArrayOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecWriteByteArrayOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecIndexOffAddrOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecReadOffAddrOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecWriteOffAddrOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecIndexScalarByteArrayOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecReadScalarByteArrayOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecWriteScalarByteArrayOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecIndexScalarOffAddrOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecReadScalarOffAddrOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[VecWriteScalarOffAddrOp] :: PrimOpVecCat -> Length -> Width -> PrimOp
[PrefetchByteArrayOp3] :: PrimOp
[PrefetchMutableByteArrayOp3] :: PrimOp
[PrefetchAddrOp3] :: PrimOp
[PrefetchValueOp3] :: PrimOp
[PrefetchByteArrayOp2] :: PrimOp
[PrefetchMutableByteArrayOp2] :: PrimOp
[PrefetchAddrOp2] :: PrimOp
[PrefetchValueOp2] :: PrimOp
[PrefetchByteArrayOp1] :: PrimOp
[PrefetchMutableByteArrayOp1] :: PrimOp
[PrefetchAddrOp1] :: PrimOp
[PrefetchValueOp1] :: PrimOp
[PrefetchByteArrayOp0] :: PrimOp
[PrefetchMutableByteArrayOp0] :: PrimOp
[PrefetchAddrOp0] :: PrimOp
[PrefetchValueOp0] :: PrimOp
data PrimOpVecCat
[IntVec] :: PrimOpVecCat
[WordVec] :: PrimOpVecCat
[FloatVec] :: PrimOpVecCat
allThePrimOps :: [PrimOp]
primOpType :: PrimOp -> Type
primOpSig :: PrimOp -> ([TyVar], [Type], Type, Arity, StrictSig)
primOpTag :: PrimOp -> Int
maxPrimOpTag :: Int
primOpOcc :: PrimOp -> OccName
tagToEnumKey :: Unique
primOpOutOfLine :: PrimOp -> Bool
primOpCodeSize :: PrimOp -> Int
primOpOkForSpeculation :: PrimOp -> Bool
primOpOkForSideEffects :: PrimOp -> Bool
primOpIsCheap :: PrimOp -> Bool
primOpFixity :: PrimOp -> Maybe Fixity
getPrimOpResultInfo :: PrimOp -> PrimOpResultInfo
data PrimOpResultInfo
[ReturnsPrim] :: PrimRep -> PrimOpResultInfo
[ReturnsAlg] :: TyCon -> PrimOpResultInfo
data PrimCall
[PrimCall] :: CLabelString -> PackageKey -> PrimCall
instance Eq PrimOp
instance Ord PrimOp
instance Outputable PrimOp
instance Outputable PrimCall

module CLabel
data CLabel

-- | Record where a foreign label is stored.
data ForeignLabelSource

-- | Label is in a named package
[ForeignLabelInPackage] :: PackageKey -> ForeignLabelSource

-- | Label is in some external, system package that doesn't also contain
--   compiled Haskell code, and is not associated with any .hi files. We
--   don't have to worry about Haskell code being inlined from external
--   packages. It is safe to treat the RTS package as "external".
[ForeignLabelInExternalPackage] :: ForeignLabelSource

-- | Label is in the package currenly being compiled. This is only used for
--   creating hacky tmp labels during code generation. Don't use it in any
--   code that might be inlined across a package boundary (ie, core code)
--   else the information will be wrong relative to the destination module.
[ForeignLabelInThisPackage] :: ForeignLabelSource

-- | For debugging problems with the CLabel representation. We can't make a
--   Show instance for CLabel because lots of its components don't have
--   instances. The regular Outputable instance only shows the label name,
--   and not its other info.
pprDebugCLabel :: CLabel -> SDoc
mkClosureLabel :: Name -> CafInfo -> CLabel
mkSRTLabel :: Name -> CafInfo -> CLabel
mkTopSRTLabel :: Unique -> CLabel
mkInfoTableLabel :: Name -> CafInfo -> CLabel
mkEntryLabel :: Name -> CafInfo -> CLabel
mkSlowEntryLabel :: Name -> CafInfo -> CLabel
mkConEntryLabel :: Name -> CafInfo -> CLabel
mkStaticConEntryLabel :: Name -> CafInfo -> CLabel
mkRednCountsLabel :: Name -> CLabel
mkConInfoTableLabel :: Name -> CafInfo -> CLabel
mkStaticInfoTableLabel :: Name -> CafInfo -> CLabel
mkLargeSRTLabel :: Unique -> CLabel
mkApEntryLabel :: Bool -> Int -> CLabel
mkApInfoTableLabel :: Bool -> Int -> CLabel
mkClosureTableLabel :: Name -> CafInfo -> CLabel
mkLocalClosureLabel :: Name -> CafInfo -> CLabel
mkLocalInfoTableLabel :: Name -> CafInfo -> CLabel
mkLocalEntryLabel :: Name -> CafInfo -> CLabel
mkLocalConEntryLabel :: CafInfo -> Name -> CLabel
mkLocalStaticConEntryLabel :: CafInfo -> Name -> CLabel
mkLocalConInfoTableLabel :: CafInfo -> Name -> CLabel
mkLocalStaticInfoTableLabel :: CafInfo -> Name -> CLabel
mkLocalClosureTableLabel :: Name -> CafInfo -> CLabel
mkReturnPtLabel :: Unique -> CLabel
mkReturnInfoLabel :: Unique -> CLabel
mkAltLabel :: Unique -> ConTag -> CLabel
mkDefaultLabel :: Unique -> CLabel
mkBitmapLabel :: Unique -> CLabel
mkStringLitLabel :: Unique -> CLabel
mkAsmTempLabel :: Uniquable a => a -> CLabel
mkAsmTempDerivedLabel :: CLabel -> FastString -> CLabel
mkAsmTempEndLabel :: CLabel -> CLabel
mkPlainModuleInitLabel :: Module -> CLabel
mkSplitMarkerLabel :: CLabel
mkDirty_MUT_VAR_Label :: CLabel
mkUpdInfoLabel :: CLabel
mkBHUpdInfoLabel :: CLabel
mkIndStaticInfoLabel :: CLabel
mkMainCapabilityLabel :: CLabel
mkMAP_FROZEN_infoLabel :: CLabel
mkMAP_FROZEN0_infoLabel :: CLabel
mkMAP_DIRTY_infoLabel :: CLabel
mkSMAP_FROZEN_infoLabel :: CLabel
mkSMAP_FROZEN0_infoLabel :: CLabel
mkSMAP_DIRTY_infoLabel :: CLabel
mkEMPTY_MVAR_infoLabel :: CLabel
mkArrWords_infoLabel :: CLabel
mkTopTickyCtrLabel :: CLabel
mkCAFBlackHoleInfoTableLabel :: CLabel
mkCAFBlackHoleEntryLabel :: CLabel
mkRtsPrimOpLabel :: PrimOp -> CLabel
mkRtsSlowFastTickyCtrLabel :: String -> CLabel
mkSelectorInfoLabel :: Bool -> Int -> CLabel
mkSelectorEntryLabel :: Bool -> Int -> CLabel
mkCmmInfoLabel :: PackageKey -> FastString -> CLabel
mkCmmEntryLabel :: PackageKey -> FastString -> CLabel
mkCmmRetInfoLabel :: PackageKey -> FastString -> CLabel
mkCmmRetLabel :: PackageKey -> FastString -> CLabel
mkCmmCodeLabel :: PackageKey -> FastString -> CLabel
mkCmmDataLabel :: PackageKey -> FastString -> CLabel
mkCmmClosureLabel :: PackageKey -> FastString -> CLabel
mkRtsApFastLabel :: FastString -> CLabel
mkPrimCallLabel :: PrimCall -> CLabel

-- | Make a foreign label
mkForeignLabel :: FastString -> Maybe Int -> ForeignLabelSource -> FunctionOrData -> CLabel

-- | Update the label size field in a ForeignLabel
addLabelSize :: CLabel -> Int -> CLabel

-- | Get the label size field from a ForeignLabel
foreignLabelStdcallInfo :: CLabel -> Maybe Int
mkCCLabel :: CostCentre -> CLabel
mkCCSLabel :: CostCentreStack -> CLabel
data DynamicLinkerLabelInfo
[CodeStub] :: DynamicLinkerLabelInfo
[SymbolPtr] :: DynamicLinkerLabelInfo
[GotSymbolPtr] :: DynamicLinkerLabelInfo
[GotSymbolOffset] :: DynamicLinkerLabelInfo
mkDynamicLinkerLabel :: DynamicLinkerLabelInfo -> CLabel -> CLabel
dynamicLinkerLabelInfo :: CLabel -> Maybe (DynamicLinkerLabelInfo, CLabel)
mkPicBaseLabel :: CLabel
mkDeadStripPreventer :: CLabel -> CLabel
mkHpcTicksLabel :: Module -> CLabel
hasCAF :: CLabel -> Bool
needsCDecl :: CLabel -> Bool

-- | If a label is a local temporary used for native code generation then
--   return just its unique, otherwise nothing.
maybeAsmTemp :: CLabel -> Maybe Unique

-- | Is a CLabel visible outside this object file or not? From the point of
--   view of the code generator, a name is externally visible if it has to
--   be declared as exported in the .o file's symbol table; that is, made
--   non-static.
externallyVisibleCLabel :: CLabel -> Bool

-- | Check whether a label corresponds to a C function that has a prototype
--   in a system header somehere, or is built-in to the C compiler. For
--   these labels we avoid generating our own C prototypes.
isMathFun :: CLabel -> Bool
isCFunctionLabel :: CLabel -> Bool
isGcPtrLabel :: CLabel -> Bool
labelDynamic :: DynFlags -> PackageKey -> Module -> CLabel -> Bool
toClosureLbl :: CLabel -> CLabel
toSlowEntryLbl :: CLabel -> CLabel
toEntryLbl :: CLabel -> CLabel
toInfoLbl :: CLabel -> CLabel
toRednCountsLbl :: CLabel -> Maybe CLabel
hasHaskellName :: CLabel -> Maybe Name
pprCLabel :: Platform -> CLabel -> SDoc
instance Ord CLabel
instance Eq CLabel
instance Ord DynamicLinkerLabelInfo
instance Eq DynamicLinkerLabelInfo
instance Ord CmmLabelInfo
instance Eq CmmLabelInfo
instance Ord RtsLabelInfo
instance Eq RtsLabelInfo
instance Ord CaseLabelInfo
instance Eq CaseLabelInfo
instance Ord IdLabelInfo
instance Eq IdLabelInfo
instance Ord ForeignLabelSource
instance Eq ForeignLabelSource
instance Outputable CLabel
instance Outputable ForeignLabelSource

module BlockId
type BlockId = Label
mkBlockId :: Unique -> BlockId
type BlockSet = LabelSet
type BlockEnv a = LabelMap a
class IsSet set where type family ElemOf set :: *
setNull :: IsSet set => set -> Bool
setSize :: IsSet set => set -> Int
setMember :: IsSet set => ElemOf set -> set -> Bool
setEmpty :: IsSet set => set
setSingleton :: IsSet set => ElemOf set -> set
setInsert :: IsSet set => ElemOf set -> set -> set
setDelete :: IsSet set => ElemOf set -> set -> set
setUnion :: IsSet set => set -> set -> set
setDifference :: IsSet set => set -> set -> set
setIntersection :: IsSet set => set -> set -> set
setIsSubsetOf :: IsSet set => set -> set -> Bool
setFold :: IsSet set => (ElemOf set -> b -> b) -> b -> set -> b
setElems :: IsSet set => set -> [ElemOf set]
setFromList :: IsSet set => [ElemOf set] -> set
setInsertList :: IsSet set => [ElemOf set] -> set -> set
setDeleteList :: IsSet set => [ElemOf set] -> set -> set
setUnions :: IsSet set => [set] -> set
class IsMap (map :: * -> *) where type family KeyOf (map :: * -> *) :: *
mapNull :: IsMap map => map a -> Bool
mapSize :: IsMap map => map a -> Int
mapMember :: IsMap map => KeyOf map -> map a -> Bool
mapLookup :: IsMap map => KeyOf map -> map a -> Maybe a
mapFindWithDefault :: IsMap map => a -> KeyOf map -> map a -> a
mapEmpty :: IsMap map => map a
mapSingleton :: IsMap map => KeyOf map -> a -> map a
mapInsert :: IsMap map => KeyOf map -> a -> map a -> map a
mapInsertWith :: IsMap map => (a -> a -> a) -> KeyOf map -> a -> map a -> map a
mapDelete :: IsMap map => KeyOf map -> map a -> map a
mapUnion :: IsMap map => map a -> map a -> map a
mapUnionWithKey :: IsMap map => (KeyOf map -> a -> a -> a) -> map a -> map a -> map a
mapDifference :: IsMap map => map a -> map a -> map a
mapIntersection :: IsMap map => map a -> map a -> map a
mapIsSubmapOf :: (IsMap map, Eq a) => map a -> map a -> Bool
mapMap :: IsMap map => (a -> b) -> map a -> map b
mapMapWithKey :: IsMap map => (KeyOf map -> a -> b) -> map a -> map b
mapFold :: IsMap map => (a -> b -> b) -> b -> map a -> b
mapFoldWithKey :: IsMap map => (KeyOf map -> a -> b -> b) -> b -> map a -> b
mapFilter :: IsMap map => (a -> Bool) -> map a -> map a
mapElems :: IsMap map => map a -> [a]
mapKeys :: IsMap map => map a -> [KeyOf map]
mapToList :: IsMap map => map a -> [(KeyOf map, a)]
mapFromList :: IsMap map => [(KeyOf map, a)] -> map a
mapFromListWith :: IsMap map => (a -> a -> a) -> [(KeyOf map, a)] -> map a
mapInsertList :: IsMap map => [(KeyOf map, a)] -> map a -> map a
mapDeleteList :: IsMap map => [KeyOf map] -> map a -> map a
mapUnions :: IsMap map => [map a] -> map a
emptyBlockSet :: BlockSet
emptyBlockMap :: BlockEnv a
blockLbl :: BlockId -> CLabel
infoTblLbl :: BlockId -> CLabel
retPtLbl :: BlockId -> CLabel
instance Uniquable BlockId
instance Outputable BlockId
instance Outputable a => Outputable (BlockEnv a)
instance Outputable BlockSet

module CmmExpr
data CmmExpr
[CmmLit] :: CmmLit -> CmmExpr
[CmmLoad] :: !CmmExpr -> !CmmType -> CmmExpr
[CmmReg] :: !CmmReg -> CmmExpr
[CmmMachOp] :: MachOp -> [CmmExpr] -> CmmExpr
[CmmStackSlot] :: Area -> {-# UNPACK #-} !Int -> CmmExpr
[CmmRegOff] :: !CmmReg -> Int -> CmmExpr
cmmExprType :: DynFlags -> CmmExpr -> CmmType
cmmExprWidth :: DynFlags -> CmmExpr -> Width
maybeInvertCmmExpr :: CmmExpr -> Maybe CmmExpr
data CmmReg
[CmmLocal] :: {-# UNPACK #-} !LocalReg -> CmmReg
[CmmGlobal] :: GlobalReg -> CmmReg
cmmRegType :: DynFlags -> CmmReg -> CmmType
data CmmLit
[CmmInt] :: !Integer -> Width -> CmmLit
[CmmFloat] :: Rational -> Width -> CmmLit
[CmmVec] :: [CmmLit] -> CmmLit
[CmmLabel] :: CLabel -> CmmLit
[CmmLabelOff] :: CLabel -> Int -> CmmLit
[CmmLabelDiffOff] :: CLabel -> CLabel -> Int -> CmmLit
[CmmBlock] :: {-# UNPACK #-} !BlockId -> CmmLit
[CmmHighStackMark] :: CmmLit
cmmLitType :: DynFlags -> CmmLit -> CmmType
data LocalReg

-- | Parameters: 1. Identifier 2. Type
[LocalReg] :: {-# UNPACK #-} !Unique -> CmmType -> LocalReg
localRegType :: LocalReg -> CmmType
data GlobalReg
[VanillaReg] :: {-# UNPACK #-} !Int -> VGcPtr -> GlobalReg
[FloatReg] :: {-# UNPACK #-} !Int -> GlobalReg
[DoubleReg] :: {-# UNPACK #-} !Int -> GlobalReg
[LongReg] :: {-# UNPACK #-} !Int -> GlobalReg
[XmmReg] :: {-# UNPACK #-} !Int -> GlobalReg
[YmmReg] :: {-# UNPACK #-} !Int -> GlobalReg
[ZmmReg] :: {-# UNPACK #-} !Int -> GlobalReg
[Sp] :: GlobalReg
[SpLim] :: GlobalReg
[Hp] :: GlobalReg
[HpLim] :: GlobalReg
[CCCS] :: GlobalReg
[CurrentTSO] :: GlobalReg
[CurrentNursery] :: GlobalReg
[HpAlloc] :: GlobalReg
[EagerBlackholeInfo] :: GlobalReg
[GCEnter1] :: GlobalReg
[GCFun] :: GlobalReg
[BaseReg] :: GlobalReg
[PicBaseReg] :: GlobalReg
isArgReg :: GlobalReg -> Bool
globalRegType :: DynFlags -> GlobalReg -> CmmType
spReg :: CmmReg
hpReg :: CmmReg
spLimReg :: CmmReg
nodeReg :: CmmReg
node :: GlobalReg
baseReg :: CmmReg
data VGcPtr
[VGcPtr] :: VGcPtr
[VNonGcPtr] :: VGcPtr
vgcFlag :: CmmType -> VGcPtr
class Ord r => DefinerOfRegs r a
foldRegsDefd :: DefinerOfRegs r a => DynFlags -> (b -> r -> b) -> b -> a -> b
class Ord r => UserOfRegs r a
foldRegsUsed :: UserOfRegs r a => DynFlags -> (b -> r -> b) -> b -> a -> b
filterRegsUsed :: UserOfRegs r e => DynFlags -> (r -> Bool) -> e -> RegSet r
foldLocalRegsDefd :: DefinerOfRegs LocalReg a => DynFlags -> (b -> LocalReg -> b) -> b -> a -> b
foldLocalRegsUsed :: UserOfRegs LocalReg a => DynFlags -> (b -> LocalReg -> b) -> b -> a -> b

-- | Sets of registers
type RegSet r = Set r
type LocalRegSet = RegSet LocalReg
type GlobalRegSet = RegSet GlobalReg
emptyRegSet :: Ord r => RegSet r
elemRegSet :: Ord r => r -> RegSet r -> Bool
extendRegSet :: Ord r => RegSet r -> r -> RegSet r
deleteFromRegSet :: Ord r => RegSet r -> r -> RegSet r
mkRegSet :: Ord r => [r] -> RegSet r
plusRegSet :: Ord r => RegSet r -> RegSet r -> RegSet r
minusRegSet :: Ord r => RegSet r -> RegSet r -> RegSet r
timesRegSet :: Ord r => RegSet r -> RegSet r -> RegSet r
sizeRegSet :: Ord r => RegSet r -> Int
nullRegSet :: Ord r => RegSet r -> Bool
regSetToList :: Ord r => RegSet r -> [r]
regUsedIn :: CmmReg -> CmmExpr -> Bool

-- | A stack area is either the stack slot where a variable is spilled or
--   the stack space where function arguments and results are passed.
data Area
[Old] :: Area
[Young] :: {-# UNPACK #-} !BlockId -> Area
instance Ord CmmReg
instance Eq CmmReg
instance Show GlobalReg
instance Show VGcPtr
instance Eq VGcPtr
instance Eq CmmLit
instance Ord Area
instance Eq Area
instance Eq CmmExpr
instance Eq LocalReg
instance Ord LocalReg
instance Uniquable LocalReg
instance UserOfRegs LocalReg CmmReg
instance DefinerOfRegs LocalReg CmmReg
instance UserOfRegs GlobalReg CmmReg
instance DefinerOfRegs GlobalReg CmmReg
instance Ord r => UserOfRegs r r
instance Ord r => DefinerOfRegs r r
instance Ord r => UserOfRegs r (RegSet r)
instance UserOfRegs r CmmReg => UserOfRegs r CmmExpr
instance UserOfRegs r a => UserOfRegs r (Maybe a)
instance UserOfRegs r a => UserOfRegs r [a]
instance DefinerOfRegs r a => DefinerOfRegs r [a]
instance DefinerOfRegs r a => DefinerOfRegs r (Maybe a)
instance Eq GlobalReg
instance Ord GlobalReg

module PprCmmExpr
pprExpr :: CmmExpr -> SDoc
pprLit :: CmmLit -> SDoc
instance Outputable CmmExpr
instance Outputable CmmReg
instance Outputable CmmLit
instance Outputable LocalReg
instance Outputable Area
instance Outputable GlobalReg


-- | Deal with Cmm registers
module LlvmCodeGen.Regs

-- | Get the LlvmVar function argument storing the real register
lmGlobalRegArg :: DynFlags -> GlobalReg -> LlvmVar

-- | Get the LlvmVar function variable storing the real register
lmGlobalRegVar :: DynFlags -> GlobalReg -> LlvmVar

-- | A list of STG Registers that should always be considered alive
alwaysLive :: [GlobalReg]

-- | STG Type Based Alias Analysis hierarchy
stgTBAA :: [(Unique, LMString, Maybe Unique)]

-- | Id values
baseN :: Unique

-- | Id values
stackN :: Unique

-- | Id values
heapN :: Unique

-- | Id values
rxN :: Unique

-- | Id values
otherN :: Unique

-- | The TBAA metadata identifier
tbaa :: LMString

-- | Get the correct TBAA metadata information for this register type
getTBAA :: GlobalReg -> Unique

module CmmLex
data CmmToken
[CmmT_SpecChar] :: Char -> CmmToken
[CmmT_DotDot] :: CmmToken
[CmmT_DoubleColon] :: CmmToken
[CmmT_Shr] :: CmmToken
[CmmT_Shl] :: CmmToken
[CmmT_Ge] :: CmmToken
[CmmT_Le] :: CmmToken
[CmmT_Eq] :: CmmToken
[CmmT_Ne] :: CmmToken
[CmmT_BoolAnd] :: CmmToken
[CmmT_BoolOr] :: CmmToken
[CmmT_CLOSURE] :: CmmToken
[CmmT_INFO_TABLE] :: CmmToken
[CmmT_INFO_TABLE_RET] :: CmmToken
[CmmT_INFO_TABLE_FUN] :: CmmToken
[CmmT_INFO_TABLE_CONSTR] :: CmmToken
[CmmT_INFO_TABLE_SELECTOR] :: CmmToken
[CmmT_else] :: CmmToken
[CmmT_export] :: CmmToken
[CmmT_section] :: CmmToken
[CmmT_align] :: CmmToken
[CmmT_goto] :: CmmToken
[CmmT_if] :: CmmToken
[CmmT_call] :: CmmToken
[CmmT_jump] :: CmmToken
[CmmT_foreign] :: CmmToken
[CmmT_never] :: CmmToken
[CmmT_prim] :: CmmToken
[CmmT_reserve] :: CmmToken
[CmmT_return] :: CmmToken
[CmmT_returns] :: CmmToken
[CmmT_import] :: CmmToken
[CmmT_switch] :: CmmToken
[CmmT_case] :: CmmToken
[CmmT_default] :: CmmToken
[CmmT_push] :: CmmToken
[CmmT_unwind] :: CmmToken
[CmmT_bits8] :: CmmToken
[CmmT_bits16] :: CmmToken
[CmmT_bits32] :: CmmToken
[CmmT_bits64] :: CmmToken
[CmmT_bits128] :: CmmToken
[CmmT_bits256] :: CmmToken
[CmmT_bits512] :: CmmToken
[CmmT_float32] :: CmmToken
[CmmT_float64] :: CmmToken
[CmmT_gcptr] :: CmmToken
[CmmT_GlobalReg] :: GlobalReg -> CmmToken
[CmmT_Name] :: FastString -> CmmToken
[CmmT_String] :: String -> CmmToken
[CmmT_Int] :: Integer -> CmmToken
[CmmT_Float] :: Rational -> CmmToken
[CmmT_EOF] :: CmmToken
cmmlex :: (Located CmmToken -> P a) -> P a
instance Show CmmToken
instance Functor AlexLastAcc

module CodeGen.Platform.ARM
callerSaves :: GlobalReg -> Bool
activeStgRegs :: [GlobalReg]
haveRegBase :: Bool
globalRegMaybe :: GlobalReg -> Maybe RealReg
freeReg :: RegNo -> FastBool

module CodeGen.Platform.ARM64
callerSaves :: GlobalReg -> Bool
activeStgRegs :: [GlobalReg]
haveRegBase :: Bool
globalRegMaybe :: GlobalReg -> Maybe RealReg
freeReg :: RegNo -> FastBool

module CodeGen.Platform.PPC
callerSaves :: GlobalReg -> Bool
activeStgRegs :: [GlobalReg]
haveRegBase :: Bool
globalRegMaybe :: GlobalReg -> Maybe RealReg
freeReg :: RegNo -> FastBool

module CodeGen.Platform.PPC_Darwin
callerSaves :: GlobalReg -> Bool
activeStgRegs :: [GlobalReg]
haveRegBase :: Bool
globalRegMaybe :: GlobalReg -> Maybe RealReg
freeReg :: RegNo -> FastBool

module CodeGen.Platform.SPARC
callerSaves :: GlobalReg -> Bool
activeStgRegs :: [GlobalReg]
haveRegBase :: Bool
globalRegMaybe :: GlobalReg -> Maybe RealReg
freeReg :: RegNo -> FastBool

module CodeGen.Platform.X86
callerSaves :: GlobalReg -> Bool
activeStgRegs :: [GlobalReg]
haveRegBase :: Bool
globalRegMaybe :: GlobalReg -> Maybe RealReg
freeReg :: RegNo -> FastBool
freeRegBase :: RegNo -> FastBool

module CodeGen.Platform.X86_64
callerSaves :: GlobalReg -> Bool
activeStgRegs :: [GlobalReg]
haveRegBase :: Bool
globalRegMaybe :: GlobalReg -> Maybe RealReg
freeReg :: RegNo -> FastBool
freeRegBase :: RegNo -> FastBool

module CodeGen.Platform.NoRegs
callerSaves :: GlobalReg -> Bool
activeStgRegs :: [GlobalReg]
haveRegBase :: Bool
globalRegMaybe :: GlobalReg -> Maybe RealReg
freeReg :: RegNo -> FastBool

module CodeGen.Platform

-- | Returns <a>True</a> if this global register is stored in a
--   caller-saves machine register.
callerSaves :: Platform -> GlobalReg -> Bool

-- | Here is where the STG register map is defined for each target arch.
--   The order matters (for the llvm backend anyway)! We must make sure to
--   maintain the order here with the order used in the LLVM calling
--   conventions. Note that also, this isn't all registers, just the ones
--   that are currently possbily mapped to real registers.
activeStgRegs :: Platform -> [GlobalReg]
haveRegBase :: Platform -> Bool
globalRegMaybe :: Platform -> GlobalReg -> Maybe RealReg
freeReg :: Platform -> RegNo -> FastBool

module CmmNode
data CmmNode e x
[CmmEntry] :: {-# UNPACK #-} !Label -> CmmTickScope -> CmmNode C O
[CmmComment] :: FastString -> CmmNode O O
[CmmTick] :: !CmmTickish -> CmmNode O O
[CmmUnwind] :: !GlobalReg -> !CmmExpr -> CmmNode O O
[CmmAssign] :: !CmmReg -> !CmmExpr -> CmmNode O O
[CmmStore] :: !CmmExpr -> !CmmExpr -> CmmNode O O
[CmmUnsafeForeignCall] :: ForeignTarget -> [CmmFormal] -> [CmmActual] -> CmmNode O O
[CmmBranch] :: {-# UNPACK #-} !Label -> CmmNode O C
[CmmCondBranch] :: CmmExpr -> {-# UNPACK #-} !Label -> CmmNode O C
[cml_pred] :: CmmNode O C -> CmmExpr
[cml_true, cml_false] :: CmmNode O C -> {-# UNPACK #-} !Label
[CmmSwitch] :: CmmExpr -> [Maybe Label] -> CmmNode O C
[CmmCall] :: CmmExpr -> Maybe Label -> [GlobalReg] -> ByteOff -> ByteOff -> ByteOff -> CmmNode O C
[cml_target] :: CmmNode O C -> CmmExpr
[cml_cont] :: CmmNode O C -> Maybe Label
[cml_args_regs] :: CmmNode O C -> [GlobalReg]
[cml_args] :: CmmNode O C -> ByteOff
[cml_ret_args] :: CmmNode O C -> ByteOff
[cml_ret_off] :: CmmNode O C -> ByteOff
[CmmForeignCall] :: ForeignTarget -> [CmmFormal] -> [CmmActual] -> {-# UNPACK #-} !Label -> ByteOff -> ByteOff -> Bool -> CmmNode O C
[tgt] :: CmmNode O C -> ForeignTarget
[res] :: CmmNode O C -> [CmmFormal]
[args] :: CmmNode O C -> [CmmActual]
[succ] :: CmmNode O C -> {-# UNPACK #-} !Label
[ret_args] :: CmmNode O C -> ByteOff
[ret_off] :: CmmNode O C -> ByteOff
[intrbl] :: CmmNode O C -> Bool
type CmmFormal = LocalReg
type CmmActual = CmmExpr

-- | Tickish in Cmm context (annotations only)
type CmmTickish = Tickish ()
type UpdFrameOffset = ByteOff

-- | A convention maps a list of values (function arguments or return
--   values) to registers or stack locations.
data Convention

-- | top-level Haskell functions use <tt>NativeDirectCall</tt>, which maps
--   arguments to registers starting with R2, according to how many
--   registers are available on the platform. This convention ignores R1,
--   because for a top-level function call the function closure is
--   implicit, and doesn't need to be passed.
[NativeDirectCall] :: Convention

-- | non-top-level Haskell functions, which pass the address of the
--   function closure in R1 (regardless of whether R1 is a real register or
--   not), and the rest of the arguments in registers or on the stack.
[NativeNodeCall] :: Convention

-- | a native return. The convention for returns depends on how many values
--   are returned: for just one value returned, the appropriate register is
--   used (R1, F1, etc.). regardless of whether it is a real register or
--   not. For multiple values returned, they are mapped to registers or the
--   stack.
[NativeReturn] :: Convention

-- | Slow entry points: all args pushed on the stack
[Slow] :: Convention

-- | Entry to the garbage collector: uses the node reg! (TODO: I don't
--   think we need this --SDM)
[GC] :: Convention
data ForeignConvention
[ForeignConvention] :: CCallConv -> [ForeignHint] -> [ForeignHint] -> CmmReturnInfo -> ForeignConvention
data ForeignTarget
[ForeignTarget] :: CmmExpr -> ForeignConvention -> ForeignTarget
[PrimTarget] :: CallishMachOp -> ForeignTarget
foreignTargetHints :: ForeignTarget -> ([ForeignHint], [ForeignHint])
data CmmReturnInfo
[CmmMayReturn] :: CmmReturnInfo
[CmmNeverReturns] :: CmmReturnInfo
mapExp :: (CmmExpr -> CmmExpr) -> CmmNode e x -> CmmNode e x
mapExpDeep :: (CmmExpr -> CmmExpr) -> CmmNode e x -> CmmNode e x
wrapRecExp :: (CmmExpr -> CmmExpr) -> CmmExpr -> CmmExpr
foldExp :: (CmmExpr -> z -> z) -> CmmNode e x -> z -> z
foldExpDeep :: (CmmExpr -> z -> z) -> CmmNode e x -> z -> z
wrapRecExpf :: (CmmExpr -> z -> z) -> CmmExpr -> z -> z
mapExpM :: (CmmExpr -> Maybe CmmExpr) -> CmmNode e x -> Maybe (CmmNode e x)
mapExpDeepM :: (CmmExpr -> Maybe CmmExpr) -> CmmNode e x -> Maybe (CmmNode e x)
wrapRecExpM :: (CmmExpr -> Maybe CmmExpr) -> (CmmExpr -> Maybe CmmExpr)
mapSuccessors :: (Label -> Label) -> CmmNode O C -> CmmNode O C

-- | Tick scope identifier, allowing us to reason about what annotations in
--   a Cmm block should scope over. We especially take care to allow
--   optimisations to reorganise blocks without losing tick association in
--   the process.
data CmmTickScope

-- | The global scope is the "root" of the scope graph. Every scope is a
--   sub-scope of the global scope. It doesn't make sense to add ticks to
--   this scope. On the other hand, this means that setting this scope on a
--   block means no ticks apply to it.
[GlobalScope] :: CmmTickScope

-- | Constructs a new sub-scope to an existing scope. This allows us to
--   translate Core-style scoping rules (see <tt>tickishScoped</tt>) into
--   the Cmm world. Suppose the following code:
--   
--   tick<a>1</a> case ... of A -&gt; tick<a>2</a> ... B -&gt; tick<a>3</a>
--   ...
--   
--   We want the top-level tick annotation to apply to blocks generated for
--   the A and B alternatives. We can achieve that by generating
--   tick<a>1</a> into a block with scope a, while the code for
--   alternatives A and B gets generated into sub-scopes a/b and a/c
--   respectively.
[SubScope] :: Unique -> CmmTickScope -> CmmTickScope

-- | A combined scope scopes over everything that the two given scopes
--   cover. It is therefore a sub-scope of either scope. This is required
--   for optimisations. Consider common block elimination:
--   
--   A -&gt; tick<a>2</a> case ... of C -&gt; [common] B -&gt; tick<a>3</a>
--   case ... of D -&gt; [common]
--   
--   We will generate code for the C and D alternatives, and figure out
--   afterwards that it's actually common code. Scoping rules dictate that
--   the resulting common block needs to be covered by both tick<a>2</a>
--   and tick<a>3</a>, therefore we need to construct a scope that is a
--   child to *both* scope. Now we can do that - if we assign the scopes
--   a<i>c and b</i>d to the common-ed up blocks, the new block could have
--   a combined tick scope a<i>c+b</i>d, which both tick<a>2</a> and
--   tick<a>3</a> apply to.
[CombinedScope] :: CmmTickScope -> CmmTickScope -> CmmTickScope

-- | Checks whether two tick scopes are sub-scopes of each other. True if
--   the two scopes are equal.
isTickSubScope :: CmmTickScope -> CmmTickScope -> Bool

-- | Combine two tick scopes. The new scope should be sub-scope of both
--   parameters. We simplfy automatically if one tick scope is a sub-scope
--   of the other already.
combineTickScopes :: CmmTickScope -> CmmTickScope -> CmmTickScope
instance Eq ForeignTarget
instance Eq ForeignConvention
instance Eq CmmReturnInfo
instance Eq Convention
instance Eq (CmmNode e x)
instance NonLocal CmmNode
instance UserOfRegs LocalReg (CmmNode e x)
instance UserOfRegs GlobalReg (CmmNode e x)
instance UserOfRegs r CmmExpr => UserOfRegs r ForeignTarget
instance DefinerOfRegs LocalReg (CmmNode e x)
instance DefinerOfRegs GlobalReg (CmmNode e x)
instance Eq CmmTickScope
instance Ord CmmTickScope
instance Outputable CmmTickScope

module Cmm
type CmmProgram = [CmmGroup]
type CmmGroup = GenCmmGroup CmmStatics CmmTopInfo CmmGraph
type GenCmmGroup d h g = [GenCmmDecl d h g]
type CmmDecl = GenCmmDecl CmmStatics CmmTopInfo CmmGraph

-- | A top-level chunk, abstracted over the type of the contents of the
--   basic blocks (Cmm or instructions are the likely instantiations).
data GenCmmDecl d h g
[CmmProc] :: h -> CLabel -> [GlobalReg] -> g -> GenCmmDecl d h g
[CmmData] :: Section -> d -> GenCmmDecl d h g
type CmmGraph = GenCmmGraph CmmNode
data GenCmmGraph n
[CmmGraph] :: BlockId -> Graph n C C -> GenCmmGraph n
[g_entry] :: GenCmmGraph n -> BlockId
[g_graph] :: GenCmmGraph n -> Graph n C C
type CmmBlock = Block CmmNode C C
type RawCmmDecl = GenCmmDecl CmmStatics (BlockEnv CmmStatics) CmmGraph
type RawCmmGroup = GenCmmGroup CmmStatics (BlockEnv CmmStatics) CmmGraph
data Section
[Text] :: Section
[Data] :: Section
[ReadOnlyData] :: Section
[RelocatableReadOnlyData] :: Section
[UninitialisedData] :: Section
[ReadOnlyData16] :: Section
[OtherSection] :: String -> Section
data CmmStatics
[Statics] :: CLabel -> [CmmStatic] -> CmmStatics
data CmmStatic
[CmmStaticLit] :: CmmLit -> CmmStatic
[CmmUninitialised] :: Int -> CmmStatic
[CmmString] :: [Word8] -> CmmStatic
data GenBasicBlock i
[BasicBlock] :: BlockId -> [i] -> GenBasicBlock i

-- | The branch block id is that of the first block in the branch, which is
--   that branch's entry point
blockId :: GenBasicBlock i -> BlockId
newtype ListGraph i
[ListGraph] :: [GenBasicBlock i] -> ListGraph i
pprBBlock :: Outputable stmt => GenBasicBlock stmt -> SDoc
type CmmReplGraph e x = GenCmmReplGraph CmmNode e x
type GenCmmReplGraph n e x = UniqSM (Maybe (Graph n e x))
type CmmFwdRewrite f = FwdRewrite UniqSM CmmNode f
type CmmBwdRewrite f = BwdRewrite UniqSM CmmNode f
data CmmTopInfo
[TopInfo] :: BlockEnv CmmInfoTable -> CmmStackInfo -> CmmTopInfo
[info_tbls] :: CmmTopInfo -> BlockEnv CmmInfoTable
[stack_info] :: CmmTopInfo -> CmmStackInfo
data CmmStackInfo
[StackInfo] :: ByteOff -> Maybe ByteOff -> Bool -> CmmStackInfo
[arg_space] :: CmmStackInfo -> ByteOff
[updfr_space] :: CmmStackInfo -> Maybe ByteOff
[do_layout] :: CmmStackInfo -> Bool

-- | Info table as a haskell data type
data CmmInfoTable
[CmmInfoTable] :: CLabel -> SMRep -> ProfilingInfo -> C_SRT -> CmmInfoTable
[cit_lbl] :: CmmInfoTable -> CLabel
[cit_rep] :: CmmInfoTable -> SMRep
[cit_prof] :: CmmInfoTable -> ProfilingInfo
[cit_srt] :: CmmInfoTable -> C_SRT
topInfoTable :: GenCmmDecl a CmmTopInfo (GenCmmGraph n) -> Maybe CmmInfoTable
data ClosureTypeInfo
[Constr] :: ConstrTag -> ConstrDescription -> ClosureTypeInfo
[Fun] :: FunArity -> ArgDescr -> ClosureTypeInfo
[Thunk] :: ClosureTypeInfo
[ThunkSelector] :: SelectorOffset -> ClosureTypeInfo
[BlackHole] :: ClosureTypeInfo
[IndStatic] :: ClosureTypeInfo
data C_SRT
[NoC_SRT] :: C_SRT
[C_SRT] :: !CLabel -> !WordOff -> !StgHalfWord -> C_SRT
needsSRT :: C_SRT -> Bool
data ProfilingInfo
[NoProfilingInfo] :: ProfilingInfo
[ProfilingInfo] :: [Word8] -> [Word8] -> ProfilingInfo
type ConstrDescription = [Word8]
instance Eq C_SRT
instance Outputable instr => Outputable (ListGraph instr)
instance Outputable instr => Outputable (GenBasicBlock instr)


-- | Sizes on this architecture A Size is a combination of width and class
--   
--   TODO: Rename this to <a>Format</a> instead of <a>Size</a> to reflect
--   the fact that it represents floating point vs integer.
--   
--   TODO: Signed vs unsigned?
--   
--   TODO: This module is currenly shared by all architectures because
--   NCGMonad need to know about it to make a VReg. It would be better to
--   have architecture specific formats, and do the overloading properly.
--   eg SPARC doesn't care about FF80.
module Size
data Size
[II8] :: Size
[II16] :: Size
[II32] :: Size
[II64] :: Size
[FF32] :: Size
[FF64] :: Size
[FF80] :: Size

-- | Get the integer size of this width.
intSize :: Width -> Size

-- | Get the float size of this width.
floatSize :: Width -> Size

-- | Check if a size represents a floating point value.
isFloatSize :: Size -> Bool

-- | Convert a Cmm type to a Size.
cmmTypeSize :: CmmType -> Size

-- | Get the Width of a Size.
sizeToWidth :: Size -> Width
sizeInBytes :: Size -> Int
instance Eq Size
instance Show Size

module SPARC.Regs

-- | Get the standard name for the register with this number.
showReg :: RegNo -> String

-- | regSqueeze_class reg Calculuate the maximum number of register colors
--   that could be denied to a node of this class due to having this reg as
--   a neighbour.
virtualRegSqueeze :: RegClass -> VirtualReg -> FastInt
realRegSqueeze :: RegClass -> RealReg -> FastInt
classOfRealReg :: RealReg -> RegClass

-- | All the allocatable registers in the machine, including register
--   pairs.
allRealRegs :: [RealReg]

-- | Get the regno for this sort of reg
gReg :: Int -> RegNo

-- | Get the regno for this sort of reg
iReg :: Int -> RegNo

-- | Get the regno for this sort of reg
lReg :: Int -> RegNo

-- | Get the regno for this sort of reg
oReg :: Int -> RegNo

-- | Get the regno for this sort of reg
fReg :: Int -> RegNo

-- | Some specific regs used by the code generator.
fp :: Reg

-- | Some specific regs used by the code generator.
sp :: Reg

-- | Some specific regs used by the code generator.
g0 :: Reg

-- | Some specific regs used by the code generator.
g1 :: Reg

-- | Some specific regs used by the code generator.
g2 :: Reg

-- | Some specific regs used by the code generator.
o0 :: Reg

-- | Some specific regs used by the code generator.
o1 :: Reg

-- | Some specific regs used by the code generator.
f0 :: Reg

-- | Some specific regs used by the code generator.
f1 :: Reg

-- | Some specific regs used by the code generator.
f6 :: Reg

-- | Some specific regs used by the code generator.
f8 :: Reg

-- | Some specific regs used by the code generator.
f22 :: Reg

-- | Some specific regs used by the code generator.
f26 :: Reg

-- | Some specific regs used by the code generator.
f27 :: Reg

-- | Produce the second-half-of-a-double register given the first half.
--   
--   All the regs that the register allocator can allocate to, with the the
--   fixed use regs removed.
allocatableRegs :: [RealReg]

-- | The registers to place arguments for function calls, for some number
--   of arguments.
argRegs :: RegNo -> [Reg]

-- | All all the regs that could possibly be returned by argRegs
allArgRegs :: [Reg]
callClobberedRegs :: [Reg]

-- | Make a virtual reg with this size.
mkVirtualReg :: Unique -> Size -> VirtualReg
regDotColor :: RealReg -> SDoc

module CmmUtils
primRepCmmType :: DynFlags -> PrimRep -> CmmType
primRepForeignHint :: PrimRep -> ForeignHint
typeCmmType :: DynFlags -> UnaryType -> CmmType
typeForeignHint :: UnaryType -> ForeignHint
zeroCLit :: DynFlags -> CmmLit
mkIntCLit :: DynFlags -> Int -> CmmLit
mkWordCLit :: DynFlags -> Integer -> CmmLit
packHalfWordsCLit :: DynFlags -> StgHalfWord -> StgHalfWord -> CmmLit
mkByteStringCLit :: Unique -> [Word8] -> (CmmLit, GenCmmDecl CmmStatics info stmt)
mkDataLits :: Section -> CLabel -> [CmmLit] -> GenCmmDecl CmmStatics info stmt
mkRODataLits :: CLabel -> [CmmLit] -> GenCmmDecl CmmStatics info stmt
mkStgWordCLit :: DynFlags -> StgWord -> CmmLit
mkIntExpr :: DynFlags -> Int -> CmmExpr
zeroExpr :: DynFlags -> CmmExpr
mkLblExpr :: CLabel -> CmmExpr
cmmRegOff :: CmmReg -> Int -> CmmExpr
cmmOffset :: DynFlags -> CmmExpr -> Int -> CmmExpr
cmmLabelOff :: CLabel -> Int -> CmmLit
cmmOffsetLit :: CmmLit -> Int -> CmmLit
cmmOffsetExpr :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmRegOffB :: CmmReg -> ByteOff -> CmmExpr
cmmOffsetB :: DynFlags -> CmmExpr -> ByteOff -> CmmExpr
cmmLabelOffB :: CLabel -> ByteOff -> CmmLit
cmmOffsetLitB :: CmmLit -> ByteOff -> CmmLit
cmmOffsetExprB :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmRegOffW :: DynFlags -> CmmReg -> WordOff -> CmmExpr
cmmOffsetW :: DynFlags -> CmmExpr -> WordOff -> CmmExpr
cmmLabelOffW :: DynFlags -> CLabel -> WordOff -> CmmLit
cmmOffsetLitW :: DynFlags -> CmmLit -> WordOff -> CmmLit
cmmOffsetExprW :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr

-- | Useful for creating an index into an array, with a staticaly known
--   offset. The type is the element type; used for making the multiplier
cmmIndex :: DynFlags -> Width -> CmmExpr -> Int -> CmmExpr

-- | Useful for creating an index into an array, with an unknown offset.
cmmIndexExpr :: DynFlags -> Width -> CmmExpr -> CmmExpr -> CmmExpr
cmmLoadIndex :: DynFlags -> CmmType -> CmmExpr -> Int -> CmmExpr
cmmLoadIndexW :: DynFlags -> CmmExpr -> Int -> CmmType -> CmmExpr
cmmNegate :: DynFlags -> CmmExpr -> CmmExpr
cmmULtWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmUGeWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmUGtWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmSubWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmNeWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmEqWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmOrWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmAndWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmUShrWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmAddWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmMulWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmQuotWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmToWord :: DynFlags -> CmmExpr -> CmmExpr
isTrivialCmmExpr :: CmmExpr -> Bool
hasNoGlobalRegs :: CmmExpr -> Bool
blankWord :: DynFlags -> CmmStatic
cmmTagMask :: DynFlags -> CmmExpr
cmmPointerMask :: DynFlags -> CmmExpr
cmmUntag :: DynFlags -> CmmExpr -> CmmExpr
cmmIsTagged :: DynFlags -> CmmExpr -> CmmExpr
cmmConstrTag1 :: DynFlags -> CmmExpr -> CmmExpr
mkLiveness :: DynFlags -> [Maybe LocalReg] -> Liveness
modifyGraph :: (Graph n C C -> Graph n' C C) -> GenCmmGraph n -> GenCmmGraph n'
ofBlockMap :: BlockId -> BlockEnv CmmBlock -> CmmGraph
toBlockMap :: CmmGraph -> BlockEnv CmmBlock
insertBlock :: CmmBlock -> BlockEnv CmmBlock -> BlockEnv CmmBlock
ofBlockList :: BlockId -> [CmmBlock] -> CmmGraph
toBlockList :: CmmGraph -> [CmmBlock]
bodyToBlockList :: Body CmmNode -> [CmmBlock]

-- | like <a>toBlockList</a>, but the entry block always comes first
toBlockListEntryFirst :: CmmGraph -> [CmmBlock]

-- | Like <a>toBlockListEntryFirst</a>, but we strive to ensure that we
--   order blocks so that the false case of a conditional jumps to the next
--   block in the output list of blocks. This matches the way OldCmm blocks
--   were output since in OldCmm the false case was a fallthrough, whereas
--   in Cmm conditional branches have both true and false successors. Block
--   ordering can make a big difference in performance in the LLVM backend.
--   Note that we rely crucially on the order of successors returned for
--   CmmCondBranch by the NonLocal instance for CmmNode defind in
--   cmm/CmmNode.hs. -GBM
toBlockListEntryFirstFalseFallthrough :: CmmGraph -> [CmmBlock]
foldGraphBlocks :: (CmmBlock -> a -> a) -> a -> CmmGraph -> a
mapGraphNodes :: (CmmNode C O -> CmmNode C O, CmmNode O O -> CmmNode O O, CmmNode O C -> CmmNode O C) -> CmmGraph -> CmmGraph
postorderDfs :: CmmGraph -> [CmmBlock]
mapGraphNodes1 :: (forall e x. CmmNode e x -> CmmNode e x) -> CmmGraph -> CmmGraph
analFwd :: DataflowLattice f -> FwdTransfer n f -> FwdPass UniqSM n f
analBwd :: DataflowLattice f -> BwdTransfer n f -> BwdPass UniqSM n f
analRewFwd :: DataflowLattice f -> FwdTransfer n f -> FwdRewrite UniqSM n f -> FwdPass UniqSM n f
analRewBwd :: DataflowLattice f -> BwdTransfer n f -> BwdRewrite UniqSM n f -> BwdPass UniqSM n f
dataflowPassFwd :: NonLocal n => GenCmmGraph n -> [(BlockId, f)] -> FwdPass UniqSM n f -> UniqSM (GenCmmGraph n, BlockEnv f)
dataflowPassBwd :: NonLocal n => GenCmmGraph n -> [(BlockId, f)] -> BwdPass UniqSM n f -> UniqSM (GenCmmGraph n, BlockEnv f)
dataflowAnalFwd :: NonLocal n => GenCmmGraph n -> [(BlockId, f)] -> FwdPass UniqSM n f -> BlockEnv f
dataflowAnalBwd :: NonLocal n => GenCmmGraph n -> [(BlockId, f)] -> BwdPass UniqSM n f -> BlockEnv f
dataflowAnalFwdBlocks :: NonLocal n => GenCmmGraph n -> [(BlockId, f)] -> FwdPass UniqSM n f -> UniqSM (BlockEnv f)

-- | Extract all tick annotations from the given block
blockTicks :: Block CmmNode C C -> [CmmTickish]

module Debug

-- | Debug information about a block of code. Ticks scope over nested
--   blocks.
data DebugBlock
[DebugBlock] :: !Label -> !Label -> !CLabel -> !Bool -> ![CmmTickish] -> !(Maybe CmmTickish) -> !(Maybe Int) -> !UnwindTable -> ![DebugBlock] -> DebugBlock

-- | Entry label of containing proc
[dblProcedure] :: DebugBlock -> !Label

-- | Hoopl label
[dblLabel] :: DebugBlock -> !Label

-- | Output label
[dblCLabel] :: DebugBlock -> !CLabel

-- | Has an info table?
[dblHasInfoTbl] :: DebugBlock -> !Bool

-- | Ticks defined in this block
[dblTicks] :: DebugBlock -> ![CmmTickish]

-- | Best source tick covering block
[dblSourceTick] :: DebugBlock -> !(Maybe CmmTickish)

-- | Output position relative to other blocks. <tt>Nothing</tt> means the
--   block was optimized out
[dblPosition] :: DebugBlock -> !(Maybe Int)

-- | Unwind information
[dblUnwind] :: DebugBlock -> !UnwindTable

-- | Nested blocks
[dblBlocks] :: DebugBlock -> ![DebugBlock]

-- | Is this the entry block?
dblIsEntry :: DebugBlock -> Bool

-- | Maps registers to expressions that yield their "old" values further up
--   the stack. Most interesting for the stack pointer Sp, but might be
--   useful to document saved registers, too.
type UnwindTable = Map GlobalReg UnwindExpr

-- | Expressions, used for unwind information
data UnwindExpr

-- | literal value
[UwConst] :: Int -> UnwindExpr

-- | register plus offset
[UwReg] :: GlobalReg -> Int -> UnwindExpr

-- | pointer dereferencing
[UwDeref] :: UnwindExpr -> UnwindExpr
[UwPlus] :: UnwindExpr -> UnwindExpr -> UnwindExpr
[UwMinus] :: UnwindExpr -> UnwindExpr -> UnwindExpr
[UwTimes] :: UnwindExpr -> UnwindExpr -> UnwindExpr

-- | Extract debug data from a group of procedures. We will prefer source
--   notes that come from the given module (presumably the module that we
--   are currently compiling).
cmmDebugGen :: ModLocation -> RawCmmGroup -> [DebugBlock]
cmmDebugLabels :: (i -> Bool) -> GenCmmGroup d g (ListGraph i) -> [Label]

-- | Sets position fields in the debug block tree according to native
--   generated code.
cmmDebugLink :: [Label] -> [DebugBlock] -> [DebugBlock]

-- | Converts debug blocks into a label map for easier lookups
debugToMap :: [DebugBlock] -> LabelMap DebugBlock
instance Eq UnwindExpr
instance Outputable DebugBlock
instance Outputable UnwindExpr


-- | Base LLVM Code Generation module
--   
--   Contains functions useful through out the code generator.
module LlvmCodeGen.Base
type LlvmCmmDecl = GenCmmDecl [LlvmData] (Maybe CmmStatics) (ListGraph LlvmStatement)
type LlvmBasicBlock = GenBasicBlock LlvmStatement

-- | Global registers live on proc entry
type LiveGlobalRegs = [GlobalReg]

-- | Unresolved code. Of the form: (data label, data type, unresolved data)
type LlvmUnresData = (CLabel, Section, LlvmType, [UnresStatic])

-- | Top level LLVM Data (globals and type aliases)
type LlvmData = ([LMGlobal], [LlvmType])

-- | An unresolved Label.
--   
--   Labels are unresolved when we haven't yet determined if they are
--   defined in the module we are currently compiling, or an external one.
type UnresLabel = CmmLit
type UnresStatic = Either UnresLabel LlvmStatic

-- | LLVM Version Number
type LlvmVersion = Int

-- | The LLVM Version we assume if we don't know
defaultLlvmVersion :: LlvmVersion
minSupportLlvmVersion :: LlvmVersion
maxSupportLlvmVersion :: LlvmVersion

-- | The Llvm monad. Wraps <tt>LlvmEnv</tt> state as well as the
--   <tt>IO</tt> monad
data LlvmM a

-- | Get initial Llvm environment.
runLlvm :: DynFlags -> LlvmVersion -> BufHandle -> UniqSupply -> LlvmM () -> IO ()

-- | Lift a stream into the LlvmM monad
liftStream :: Stream IO a x -> Stream LlvmM a x

-- | Clear variables from the environment for a subcomputation
withClearVars :: LlvmM a -> LlvmM a

-- | Lookup variables or functions in the environment.
varLookup :: Uniquable key => key -> LlvmM (Maybe LlvmType)

-- | Insert variables or functions into the environment.
varInsert :: Uniquable key => key -> LlvmType -> LlvmM ()

-- | Set a register as allocated on the stack
markStackReg :: GlobalReg -> LlvmM ()

-- | Check whether a register is allocated on the stack
checkStackReg :: GlobalReg -> LlvmM Bool

-- | Lookup variables or functions in the environment.
funLookup :: Uniquable key => key -> LlvmM (Maybe LlvmType)

-- | Insert variables or functions into the environment.
funInsert :: Uniquable key => key -> LlvmType -> LlvmM ()

-- | Get the LLVM version we are generating code for
getLlvmVer :: LlvmM LlvmVersion
getDynFlags :: HasDynFlags m => m DynFlags

-- | Get the platform we are generating code for
getDynFlag :: (DynFlags -> a) -> LlvmM a

-- | Get the platform we are generating code for
getLlvmPlatform :: LlvmM Platform

-- | Dumps the document if the corresponding flag has been set by the user
dumpIfSetLlvm :: DumpFlag -> String -> SDoc -> LlvmM ()

-- | Prints the given contents to the output handle
renderLlvm :: SDoc -> LlvmM ()

-- | Run a <tt>UniqSM</tt> action with our unique supply
runUs :: UniqSM a -> LlvmM a

-- | Marks a variable as "used"
markUsedVar :: LlvmVar -> LlvmM ()

-- | Return all variables marked as "used" so far
getUsedVars :: LlvmM [LlvmVar]

-- | Here we pre-initialise some functions that are used internally by GHC
--   so as to make sure they have the most general type in the case that
--   user code also uses these functions but with a different type than GHC
--   internally. (Main offender is treating return type as <tt>void</tt>
--   instead of 'void *'). Fixes trac #5486.
ghcInternalFunctions :: LlvmM ()

-- | Allocate a new global unnamed metadata identifier
getMetaUniqueId :: LlvmM Int

-- | Sets metadata node for a given unique
setUniqMeta :: Unique -> Int -> LlvmM ()

-- | Gets metadata node for given unique
getUniqMeta :: Unique -> LlvmM (Maybe Int)

-- | Returns a fresh section ID
freshSectionId :: LlvmM Int

-- | Translate a basic CmmType to an LlvmType.
cmmToLlvmType :: CmmType -> LlvmType

-- | Translate a Cmm Float Width to a LlvmType.
widthToLlvmFloat :: Width -> LlvmType

-- | Translate a Cmm Bit Width to a LlvmType.
widthToLlvmInt :: Width -> LlvmType

-- | Llvm Function type for Cmm function
llvmFunTy :: LiveGlobalRegs -> LlvmM LlvmType

-- | Llvm Function signature
llvmFunSig :: LiveGlobalRegs -> CLabel -> LlvmLinkageType -> LlvmM LlvmFunctionDecl

-- | Llvm standard fun attributes
llvmStdFunAttrs :: [LlvmFuncAttr]

-- | Alignment to use for functions
llvmFunAlign :: DynFlags -> LMAlign

-- | Alignment to use for into tables
llvmInfAlign :: DynFlags -> LMAlign

-- | Pointer width
llvmPtrBits :: DynFlags -> Int

-- | Create a Haskell function in LLVM.
mkLlvmFunc :: LiveGlobalRegs -> CLabel -> LlvmLinkageType -> LMSection -> LlvmBlocks -> LlvmM LlvmFunction

-- | Convert a list of types to a list of function parameters (each with no
--   parameter attributes)
tysToParams :: [LlvmType] -> [LlvmParameter]

-- | Pretty print a <a>CLabel</a>.
strCLabel_llvm :: CLabel -> LlvmM LMString
strDisplayName_llvm :: CLabel -> LlvmM LMString
strProcedureName_llvm :: CLabel -> LlvmM LMString

-- | Create/get a pointer to a global value. Might return an alias if the
--   value in question hasn't been defined yet. We especially make no
--   guarantees on the type of the returned pointer.
getGlobalPtr :: LMString -> LlvmM LlvmVar

-- | Generate definitions for aliases forward-referenced by
--   <tt>getGlobalPtr</tt>.
--   
--   Must be called at a point where we are sure that no new global
--   definitions will be generated anymore!
generateExternDecls :: LlvmM ([LMGlobal], [LlvmType])

-- | Here we take a global variable definition, rename it with a
--   <tt>$def</tt> suffix, and generate the appropriate alias.
aliasify :: LMGlobal -> LlvmM [LMGlobal]
instance Functor LlvmM
instance Applicative LlvmM
instance Monad LlvmM
instance HasDynFlags LlvmM


-- | Handle conversion of CmmData to LLVM code.
module LlvmCodeGen.Data

-- | Pass a CmmStatic section to an equivalent Llvm code.
genLlvmData :: (Section, CmmStatics) -> LlvmM LlvmData


-- | Pretty print helpers for the LLVM Code generator.
module LlvmCodeGen.Ppr

-- | Header code for LLVM modules
pprLlvmHeader :: SDoc

-- | Pretty print LLVM code
pprLlvmCmmDecl :: Int -> LlvmCmmDecl -> LlvmM (SDoc, [LlvmVar])

-- | Pretty print LLVM data code
pprLlvmData :: LlvmData -> SDoc

-- | The section we are putting info tables and their entry code into,
--   should be unique since we process the assembly pattern matching this.
infoSection :: String

-- | We generate labels for info tables by converting them to the same
--   label as for the entry code but adding this string as a suffix.
iTableSuf :: String


-- | GHC LLVM Mangler
--   
--   This script processes the assembly produced by LLVM, rearranging the
--   code so that an info table appears before its corresponding function.
module LlvmMangler

-- | Read in assembly file and process
llvmFixupAsm :: DynFlags -> FilePath -> FilePath -> IO ()

module CgUtils

-- | Fixup global registers so that they assign to locations within the
--   RegTable if they aren't pinned for the current target.
fixStgRegisters :: DynFlags -> RawCmmDecl -> RawCmmDecl

module PprCmmDecl
writeCmms :: (Outputable info, Outputable g) => DynFlags -> Handle -> [GenCmmGroup CmmStatics info g] -> IO ()
pprCmms :: (Outputable info, Outputable g) => [GenCmmGroup CmmStatics info g] -> SDoc
pprCmmGroup :: (Outputable d, Outputable info, Outputable g) => GenCmmGroup d info g -> SDoc
pprSection :: Section -> SDoc
pprStatic :: CmmStatic -> SDoc
instance (Outputable d, Outputable info, Outputable i) => Outputable (GenCmmDecl d info i)
instance Outputable CmmStatics
instance Outputable CmmStatic
instance Outputable CmmInfoTable
instance Outputable C_SRT
instance Outputable ForeignHint

module PprCmm
instance Outputable CmmStackInfo
instance Outputable CmmTopInfo
instance Outputable (CmmNode e x)
instance Outputable Convention
instance Outputable ForeignConvention
instance Outputable ForeignTarget
instance Outputable CmmReturnInfo
instance Outputable (Block CmmNode C C)
instance Outputable (Block CmmNode C O)
instance Outputable (Block CmmNode O C)
instance Outputable (Block CmmNode O O)
instance Outputable (Graph CmmNode e x)
instance Outputable CmmGraph


-- | Handle conversion of CmmProc to LLVM code.
module LlvmCodeGen.CodeGen

-- | Top-level of the LLVM proc Code generator
genLlvmProc :: RawCmmDecl -> LlvmM [LlvmCmmDecl]


-- | This is the top-level module in the LLVM code generator.
module LlvmCodeGen

-- | Top-level of the LLVM Code generator
llvmCodeGen :: DynFlags -> Handle -> UniqSupply -> Stream IO RawCmmGroup () -> IO ()

-- | Read in assembly file and process
llvmFixupAsm :: DynFlags -> FilePath -> FilePath -> IO ()

module CmmContFlowOpt
cmmCfgOpts :: Bool -> CmmGraph -> CmmGraph
cmmCfgOptsProc :: Bool -> CmmDecl -> CmmDecl
removeUnreachableBlocksProc :: CmmDecl -> CmmDecl
replaceLabels :: BlockEnv BlockId -> CmmGraph -> CmmGraph

module CmmCommonBlockElim
elimCommonBlocks :: CmmGraph -> CmmGraph

module CmmCallConv
data ParamLocation
[RegisterParam] :: GlobalReg -> ParamLocation
[StackParam] :: ByteOff -> ParamLocation

-- | Given a list of arguments, and a function that tells their types,
--   return a list showing where each argument is passed
assignArgumentsPos :: DynFlags -> ByteOff -> Convention -> (a -> CmmType) -> [a] -> (ByteOff, [(a, ParamLocation)])
assignStack :: DynFlags -> ByteOff -> (a -> CmmType) -> [a] -> (ByteOff, [(a, ParamLocation)])
realArgRegsCover :: DynFlags -> [GlobalReg]
instance Outputable ParamLocation

module CmmLive
type CmmLocalLive = CmmLive LocalReg
type CmmGlobalLive = CmmLive GlobalReg

-- | Calculated liveness info for a CmmGraph
cmmLocalLiveness :: DynFlags -> CmmGraph -> BlockEntryLiveness LocalReg
cmmGlobalLiveness :: DynFlags -> CmmGraph -> BlockEntryLiveness GlobalReg

-- | The dataflow lattice
liveLattice :: Ord r => DataflowLattice (CmmLive r)

-- | On entry to the procedure, there had better not be any LocalReg's
--   live-in.
noLiveOnEntry :: BlockId -> CmmLive LocalReg -> a -> a

-- | The transfer function
xferLive :: (UserOfRegs r (CmmNode O O), DefinerOfRegs r (CmmNode O O), UserOfRegs r (CmmNode O C), DefinerOfRegs r (CmmNode O C)) => DynFlags -> BwdTransfer CmmNode (CmmLive r)

-- | The transfer equations use the traditional <a>gen</a> and <a>kill</a>
--   notations, which should be familiar from the Dragon Book.
gen :: UserOfRegs r a => DynFlags -> a -> RegSet r -> RegSet r
kill :: DefinerOfRegs r a => DynFlags -> a -> RegSet r -> RegSet r
gen_kill :: (DefinerOfRegs r a, UserOfRegs r a) => DynFlags -> a -> CmmLive r -> CmmLive r

module CmmLint
cmmLint :: (Outputable d, Outputable h) => DynFlags -> GenCmmGroup d h CmmGraph -> Maybe SDoc
cmmLintGraph :: DynFlags -> CmmGraph -> Maybe SDoc
instance Functor CmmLint
instance Applicative CmmLint
instance Monad CmmLint
instance HasDynFlags CmmLint

module CmmOpt
constantFoldNode :: DynFlags -> CmmNode e x -> CmmNode e x
constantFoldExpr :: DynFlags -> CmmExpr -> CmmExpr
cmmMachOpFold :: DynFlags -> MachOp -> [CmmExpr] -> CmmExpr
cmmMachOpFoldM :: DynFlags -> MachOp -> [CmmExpr] -> Maybe CmmExpr

module MkGraph

-- | CmmAGraph is a chunk of code consisting of:
--   
--   <ul>
--   <li>ordinary statements (assignments, stores etc.)</li>
--   <li>jumps</li>
--   <li>labels</li>
--   <li>out-of-line labelled blocks</li>
--   </ul>
--   
--   The semantics is that control falls through labels and out-of-line
--   blocks. Everything after a jump up to the next label is by definition
--   unreachable code, and will be discarded.
--   
--   Two CmmAGraphs can be stuck together with <a>*</a>, with the meaning
--   that control flows from the first to the second.
--   
--   A <a>CmmAGraph</a> can be turned into a <a>CmmGraph</a> (closed at
--   both ends) by providing a label for the entry point and a tick scope;
--   see <a>labelAGraph</a>.
type CmmAGraph = OrdList CgStmt

-- | Unlabeled graph with tick scope
type CmmAGraphScoped = (CmmAGraph, CmmTickScope)
data CgStmt
[CgLabel] :: BlockId -> CmmTickScope -> CgStmt
[CgStmt] :: (CmmNode O O) -> CgStmt
[CgLast] :: (CmmNode O C) -> CgStmt
[CgFork] :: BlockId -> CmmAGraph -> CmmTickScope -> CgStmt
(<*>) :: CmmAGraph -> CmmAGraph -> CmmAGraph
catAGraphs :: [CmmAGraph] -> CmmAGraph

-- | created a sequence "goto id; id:" as an AGraph
mkLabel :: BlockId -> CmmTickScope -> CmmAGraph

-- | creates an open AGraph from a given node
mkMiddle :: CmmNode O O -> CmmAGraph

-- | created a closed AGraph from a given node
mkLast :: CmmNode O C -> CmmAGraph

-- | A labelled code block; should end in a last node
outOfLine :: BlockId -> CmmAGraphScoped -> CmmAGraph

-- | allocate a fresh label for the entry point
lgraphOfAGraph :: CmmAGraphScoped -> UniqSM CmmGraph

-- | use the given BlockId as the label of the entry point
labelAGraph :: BlockId -> CmmAGraphScoped -> CmmGraph
stackStubExpr :: Width -> CmmExpr
mkNop :: CmmAGraph
mkAssign :: CmmReg -> CmmExpr -> CmmAGraph
mkStore :: CmmExpr -> CmmExpr -> CmmAGraph
mkUnsafeCall :: ForeignTarget -> [CmmFormal] -> [CmmActual] -> CmmAGraph
mkFinalCall :: DynFlags -> CmmExpr -> CCallConv -> [CmmActual] -> UpdFrameOffset -> CmmAGraph
mkCallReturnsTo :: DynFlags -> CmmExpr -> Convention -> [CmmActual] -> BlockId -> ByteOff -> UpdFrameOffset -> [CmmActual] -> CmmAGraph
mkJumpReturnsTo :: DynFlags -> CmmExpr -> Convention -> [CmmActual] -> BlockId -> ByteOff -> UpdFrameOffset -> CmmAGraph
mkJump :: DynFlags -> Convention -> CmmExpr -> [CmmActual] -> UpdFrameOffset -> CmmAGraph
mkJumpExtra :: DynFlags -> Convention -> CmmExpr -> [CmmActual] -> UpdFrameOffset -> [CmmActual] -> CmmAGraph

-- | A jump where the caller says what the live GlobalRegs are. Used for
--   low-level hand-written Cmm.
mkRawJump :: DynFlags -> CmmExpr -> UpdFrameOffset -> [GlobalReg] -> CmmAGraph
mkCbranch :: CmmExpr -> BlockId -> BlockId -> CmmAGraph
mkSwitch :: CmmExpr -> [Maybe BlockId] -> CmmAGraph
mkReturn :: DynFlags -> CmmExpr -> [CmmActual] -> UpdFrameOffset -> CmmAGraph
mkComment :: FastString -> CmmAGraph
mkCallEntry :: DynFlags -> Convention -> [CmmFormal] -> [CmmFormal] -> (Int, [GlobalReg], CmmAGraph)
mkBranch :: BlockId -> CmmAGraph
copyInOflow :: DynFlags -> Convention -> Area -> [CmmFormal] -> [CmmFormal] -> (Int, [GlobalReg], CmmAGraph)
copyOutOflow :: DynFlags -> Convention -> Transfer -> Area -> [CmmActual] -> UpdFrameOffset -> [CmmActual] -> (Int, [GlobalReg], CmmAGraph)
noExtraStack :: [CmmActual]
toCall :: CmmExpr -> Maybe BlockId -> UpdFrameOffset -> ByteOff -> ByteOff -> [GlobalReg] -> CmmAGraph
data Transfer
[Call] :: Transfer
[JumpRet] :: Transfer
[Jump] :: Transfer
[Ret] :: Transfer
instance Eq Transfer

module Instruction

-- | Holds a list of source and destination registers used by a particular
--   instruction.
--   
--   Machine registers that are pre-allocated to stgRegs are filtered out,
--   because they are uninteresting from a register allocation standpoint.
--   (We wouldn't want them to end up on the free list!)
--   
--   As far as we are concerned, the fixed registers simply don't exist
--   (for allocation purposes, anyway).
data RegUsage
[RU] :: [Reg] -> [Reg] -> RegUsage

-- | No regs read or written to.
noUsage :: RegUsage
data GenBasicBlock i
[BasicBlock] :: BlockId -> [i] -> GenBasicBlock i

-- | The branch block id is that of the first block in the branch, which is
--   that branch's entry point
blockId :: GenBasicBlock i -> BlockId
newtype ListGraph i
[ListGraph] :: [GenBasicBlock i] -> ListGraph i
type NatCmm instr = GenCmmGroup CmmStatics (BlockEnv CmmStatics) (ListGraph instr)
type NatCmmDecl statics instr = GenCmmDecl statics (BlockEnv CmmStatics) (ListGraph instr)
type NatBasicBlock instr = GenBasicBlock instr

-- | Returns the info table associated with the CmmDecl's entry point, if
--   any.
topInfoTable :: GenCmmDecl a (BlockEnv i) (ListGraph b) -> Maybe i

-- | Return the list of BlockIds in a CmmDecl that are entry points for
--   this proc (i.e. they may be jumped to from outside this proc).
entryBlocks :: GenCmmDecl a (BlockEnv i) (ListGraph b) -> [BlockId]

-- | Common things that we can do with instructions, on all architectures.
--   These are used by the shared parts of the native code generator,
--   specifically the register allocators.
class Instruction instr
regUsageOfInstr :: Instruction instr => Platform -> instr -> RegUsage
patchRegsOfInstr :: Instruction instr => instr -> (Reg -> Reg) -> instr
isJumpishInstr :: Instruction instr => instr -> Bool
jumpDestsOfInstr :: Instruction instr => instr -> [BlockId]
patchJumpInstr :: Instruction instr => instr -> (BlockId -> BlockId) -> instr
mkSpillInstr :: Instruction instr => DynFlags -> Reg -> Int -> Int -> instr
mkLoadInstr :: Instruction instr => DynFlags -> Reg -> Int -> Int -> instr
takeDeltaInstr :: Instruction instr => instr -> Maybe Int
isMetaInstr :: Instruction instr => instr -> Bool
mkRegRegMoveInstr :: Instruction instr => Platform -> Reg -> Reg -> instr
takeRegRegMoveInstr :: Instruction instr => instr -> Maybe (Reg, Reg)
mkJumpInstr :: Instruction instr => BlockId -> [instr]
mkStackAllocInstr :: Instruction instr => Platform -> Int -> instr
mkStackDeallocInstr :: Instruction instr => Platform -> Int -> instr

module RegAlloc.Liveness
type RegSet = UniqSet Reg
type RegMap a = UniqFM a
emptyRegMap :: UniqFM a
type BlockMap a = BlockEnv a
emptyBlockMap :: BlockEnv a

-- | A top level thing which carries liveness information.
type LiveCmmDecl statics instr = GenCmmDecl statics LiveInfo [SCC (LiveBasicBlock instr)]

-- | The register allocator also wants to use SPILL/RELOAD meta
--   instructions, so we'll keep those here.
data InstrSR instr

-- | A real machine instruction
[Instr] :: instr -> InstrSR instr

-- | spill this reg to a stack slot
[SPILL] :: Reg -> Int -> InstrSR instr

-- | reload this reg from a stack slot
[RELOAD] :: Int -> Reg -> InstrSR instr

-- | An instruction with liveness information.
data LiveInstr instr
[LiveInstr] :: (InstrSR instr) -> (Maybe Liveness) -> LiveInstr instr

-- | Liveness information. The regs which die are ones which are no longer
--   live in the *next* instruction in this sequence. (NB. if the
--   instruction is a jump, these registers might still be live at the jump
--   target(s) - you have to check the liveness at the destination block to
--   find out).
data Liveness

-- | registers that died because they were clobbered by something.
[Liveness] :: RegSet -> RegSet -> RegSet -> Liveness

-- | registers born in this instruction (written to for first time).
[liveBorn] :: Liveness -> RegSet

-- | registers that died because they were read for the last time.
[liveDieRead] :: Liveness -> RegSet
[liveDieWrite] :: Liveness -> RegSet

-- | Stash regs live on entry to each basic block in the info part of the
--   cmm code.
data LiveInfo
[LiveInfo] :: (BlockEnv CmmStatics) -> [BlockId] -> (Maybe (BlockMap RegSet)) -> (Map BlockId (Set Int)) -> LiveInfo

-- | A basic block with liveness information.
type LiveBasicBlock instr = GenBasicBlock (LiveInstr instr)

-- | map a function across all the basic blocks in this code
mapBlockTop :: (LiveBasicBlock instr -> LiveBasicBlock instr) -> LiveCmmDecl statics instr -> LiveCmmDecl statics instr

-- | map a function across all the basic blocks in this code (monadic
--   version)
mapBlockTopM :: Monad m => (LiveBasicBlock instr -> m (LiveBasicBlock instr)) -> LiveCmmDecl statics instr -> m (LiveCmmDecl statics instr)
mapSCCM :: Monad m => (a -> m b) -> SCC a -> m (SCC b)
mapGenBlockTop :: (GenBasicBlock i -> GenBasicBlock i) -> (GenCmmDecl d h (ListGraph i) -> GenCmmDecl d h (ListGraph i))

-- | map a function across all the basic blocks in this code (monadic
--   version)
mapGenBlockTopM :: Monad m => (GenBasicBlock i -> m (GenBasicBlock i)) -> (GenCmmDecl d h (ListGraph i) -> m (GenCmmDecl d h (ListGraph i)))

-- | Strip away liveness information, yielding NatCmmDecl
stripLive :: (Outputable statics, Outputable instr, Instruction instr) => DynFlags -> LiveCmmDecl statics instr -> NatCmmDecl statics instr

-- | Strip away liveness information from a basic block, and make real
--   spill instructions out of SPILL, RELOAD pseudos along the way.
stripLiveBlock :: Instruction instr => DynFlags -> LiveBasicBlock instr -> NatBasicBlock instr

-- | Slurp out the list of register conflicts and reg-reg moves from this
--   top level thing. Slurping of conflicts and moves is wrapped up
--   together so we don't have to make two passes over the same code when
--   we want to build the graph.
slurpConflicts :: Instruction instr => LiveCmmDecl statics instr -> (Bag (UniqSet Reg), Bag (Reg, Reg))

-- | For spill/reloads
--   
--   SPILL v1, slot1 ... RELOAD slot1, v2
--   
--   If we can arrange that v1 and v2 are allocated to the same hreg it's
--   more likely the spill/reload instrs can be cleaned and replaced by a
--   nop reg-reg move.
slurpReloadCoalesce :: Instruction instr => LiveCmmDecl statics instr -> Bag (Reg, Reg)

-- | Erase Delta instructions.
eraseDeltasLive :: Instruction instr => LiveCmmDecl statics instr -> LiveCmmDecl statics instr

-- | Patch the registers in this code according to this register mapping.
--   also erase reg -&gt; reg moves when the reg is the same. also erase
--   reg -&gt; reg moves when the destination dies in this instr.
patchEraseLive :: Instruction instr => (Reg -> Reg) -> LiveCmmDecl statics instr -> LiveCmmDecl statics instr

-- | Patch registers in this LiveInstr, including the liveness information.
patchRegsLiveInstr :: Instruction instr => (Reg -> Reg) -> LiveInstr instr -> LiveInstr instr

-- | If we've compute liveness info for this code already we have to
--   reverse the SCCs in each top to get them back to the right order so we
--   can do it again.
reverseBlocksInTops :: LiveCmmDecl statics instr -> LiveCmmDecl statics instr
regLiveness :: (Outputable instr, Instruction instr) => Platform -> LiveCmmDecl statics instr -> UniqSM (LiveCmmDecl statics instr)

-- | Convert a NatCmmDecl to a LiveCmmDecl, with empty liveness information
natCmmTopToLive :: Instruction instr => NatCmmDecl statics instr -> LiveCmmDecl statics instr
instance Instruction instr => Instruction (InstrSR instr)
instance Outputable instr => Outputable (InstrSR instr)
instance Outputable instr => Outputable (LiveInstr instr)
instance Outputable LiveInfo


-- | Put common type definitions here to break recursive module
--   dependencies.
module RegAlloc.Linear.Base

-- | Used to store the register assignment on entry to a basic block. We
--   use this to handle join points, where multiple branch instructions
--   target a particular label. We have to insert fixup code to make the
--   register assignments from the different sources match up.
type BlockAssignment freeRegs = BlockMap (freeRegs, RegMap Loc)

-- | Where a vreg is currently stored A temporary can be marked as living
--   in both a register and memory (InBoth), for example if it was recently
--   loaded from a spill location. This makes it cheap to spill (no save
--   instruction required), but we have to be careful to turn this into
--   InReg if the value in the register is changed.
data Loc

-- | vreg is in a register
[InReg] :: !RealReg -> Loc

-- | vreg is held in a stack slot
[InMem] :: {-# UNPACK #-} !StackSlot -> Loc

-- | vreg is held in both a register and a stack slot
[InBoth] :: !RealReg -> {-# UNPACK #-} !StackSlot -> Loc

-- | Get the reg numbers stored in this Loc.
regsOfLoc :: Loc -> [RealReg]

-- | Reasons why instructions might be inserted by the spiller. Used when
--   generating stats for -ddrop-asm-stats.
data SpillReason

-- | vreg was spilled to a slot so we could use its current hreg for
--   another vreg
[SpillAlloc] :: !Unique -> SpillReason

-- | vreg was moved because its hreg was clobbered
[SpillClobber] :: !Unique -> SpillReason

-- | vreg was loaded from a spill slot
[SpillLoad] :: !Unique -> SpillReason

-- | reg-reg move inserted during join to targets
[SpillJoinRR] :: !Unique -> SpillReason

-- | reg-mem move inserted during join to targets
[SpillJoinRM] :: !Unique -> SpillReason

-- | Used to carry interesting stats out of the register allocator.
data RegAllocStats
[RegAllocStats] :: UniqFM [Int] -> RegAllocStats
[ra_spillInstrs] :: RegAllocStats -> UniqFM [Int]

-- | The register allocator state
data RA_State freeRegs
[RA_State] :: BlockAssignment freeRegs -> !freeRegs -> RegMap Loc -> Int -> StackMap -> UniqSupply -> [SpillReason] -> DynFlags -> RA_State freeRegs

-- | the current mapping from basic blocks to the register assignments at
--   the beginning of that block.
[ra_blockassig] :: RA_State freeRegs -> BlockAssignment freeRegs

-- | free machine registers
[ra_freeregs] :: RA_State freeRegs -> !freeRegs

-- | assignment of temps to locations
[ra_assig] :: RA_State freeRegs -> RegMap Loc

-- | current stack delta
[ra_delta] :: RA_State freeRegs -> Int

-- | free stack slots for spilling
[ra_stack] :: RA_State freeRegs -> StackMap

-- | unique supply for generating names for join point fixup blocks.
[ra_us] :: RA_State freeRegs -> UniqSupply

-- | Record why things were spilled, for -ddrop-asm-stats. Just keep a list
--   here instead of a map of regs -&gt; reasons. We don't want to slow
--   down the allocator if we're not going to emit the stats.
[ra_spills] :: RA_State freeRegs -> [SpillReason]
[ra_DynFlags] :: RA_State freeRegs -> DynFlags
instance Ord Loc
instance Show Loc
instance Eq Loc
instance Outputable Loc

module RegAlloc.Linear.Stats

-- | Build a map of how many times each reg was alloced, clobbered, loaded
--   etc.
binSpillReasons :: [SpillReason] -> UniqFM [Int]

-- | Count reg-reg moves remaining in this code.
countRegRegMovesNat :: Instruction instr => NatCmmDecl statics instr -> Int

-- | Pretty print some RegAllocStats
pprStats :: Instruction instr => [NatCmmDecl statics instr] -> [RegAllocStats] -> SDoc


-- | State monad for the linear register allocator.
module RegAlloc.Linear.State

-- | The register allocator state
data RA_State freeRegs
[RA_State] :: BlockAssignment freeRegs -> !freeRegs -> RegMap Loc -> Int -> StackMap -> UniqSupply -> [SpillReason] -> DynFlags -> RA_State freeRegs

-- | the current mapping from basic blocks to the register assignments at
--   the beginning of that block.
[ra_blockassig] :: RA_State freeRegs -> BlockAssignment freeRegs

-- | free machine registers
[ra_freeregs] :: RA_State freeRegs -> !freeRegs

-- | assignment of temps to locations
[ra_assig] :: RA_State freeRegs -> RegMap Loc

-- | current stack delta
[ra_delta] :: RA_State freeRegs -> Int

-- | free stack slots for spilling
[ra_stack] :: RA_State freeRegs -> StackMap

-- | unique supply for generating names for join point fixup blocks.
[ra_us] :: RA_State freeRegs -> UniqSupply

-- | Record why things were spilled, for -ddrop-asm-stats. Just keep a list
--   here instead of a map of regs -&gt; reasons. We don't want to slow
--   down the allocator if we're not going to emit the stats.
[ra_spills] :: RA_State freeRegs -> [SpillReason]
[ra_DynFlags] :: RA_State freeRegs -> DynFlags

-- | The register allocator monad type.
data RegM freeRegs a

-- | Run a computation in the RegM register allocator monad.
runR :: DynFlags -> BlockAssignment freeRegs -> freeRegs -> RegMap Loc -> StackMap -> UniqSupply -> RegM freeRegs a -> (BlockAssignment freeRegs, StackMap, RegAllocStats, a)
spillR :: Instruction instr => Reg -> Unique -> RegM freeRegs (instr, Int)
loadR :: Instruction instr => Reg -> Int -> RegM freeRegs instr
getFreeRegsR :: RegM freeRegs freeRegs
setFreeRegsR :: freeRegs -> RegM freeRegs ()
getAssigR :: RegM freeRegs (RegMap Loc)
setAssigR :: RegMap Loc -> RegM freeRegs ()
getBlockAssigR :: RegM freeRegs (BlockAssignment freeRegs)
setBlockAssigR :: BlockAssignment freeRegs -> RegM freeRegs ()
setDeltaR :: Int -> RegM freeRegs ()
getDeltaR :: RegM freeRegs Int
getUniqueR :: RegM freeRegs Unique

-- | Record that a spill instruction was inserted, for profiling.
recordSpill :: SpillReason -> RegM freeRegs ()
instance Functor (RegM freeRegs)
instance Applicative (RegM freeRegs)
instance Monad (RegM freeRegs)
instance HasDynFlags (RegM a)


-- | When there aren't enough registers to hold all the vregs we have to
--   spill some of those vregs to slots on the stack. This module is used
--   modify the code to use those slots.
module RegAlloc.Graph.Spill

-- | Spill all these virtual regs to stack slots.
--   
--   TODO: See if we can split some of the live ranges instead of just
--   globally spilling the virtual reg. This might make the spill cleaner's
--   job easier.
--   
--   TODO: On CISCy x86 and x86_64 we don't nessesarally have to add a mov
--   instruction when making spills. If an instr is using a spilled virtual
--   we may be able to address the spill slot directly.
regSpill :: Instruction instr => Platform -> [LiveCmmDecl statics instr] -> UniqSet Int -> UniqSet VirtualReg -> UniqSM ([LiveCmmDecl statics instr], UniqSet Int, SpillStats)

-- | Spiller statistics. Tells us what registers were spilled.
data SpillStats
[SpillStats] :: UniqFM (Reg, Int, Int) -> SpillStats
[spillStoreLoad] :: SpillStats -> UniqFM (Reg, Int, Int)

-- | Add a spill/reload count to a stats record for a register.
accSpillSL :: (Reg, Int, Int) -> (Reg, Int, Int) -> (Reg, Int, Int)
instance Outputable SpillStats


-- | Clean out unneeded spill/reload instructions.
--   
--   Handling of join points ~~~~~~~~~~~~~~~~~~~~~~~
--   
--   B1: B2: ... ... RELOAD SLOT(0), %r1 RELOAD SLOT(0), %r1 ... A ... ...
--   B ... jump B3 jump B3
--   
--   B3: ... C ... RELOAD SLOT(0), %r1 ...
--   
--   The Plan ~~~~~~~~ As long as %r1 hasn't been written to in A, B or C
--   then we don't need the reload in B3.
--   
--   What we really care about here is that on the entry to B3, %r1 will
--   always have the same value that is in SLOT(0) (ie, %r1 is _valid_)
--   
--   This also works if the reloads in B1/B2 were spills instead, because
--   spilling %r1 to a slot makes that slot have the same value as %r1.
module RegAlloc.Graph.SpillClean

-- | Clean out unneeded spill/reloads from this top level thing.
cleanSpills :: Instruction instr => Platform -> LiveCmmDecl statics instr -> LiveCmmDecl statics instr
instance Uniquable Store
instance Outputable Store

module RegAlloc.Graph.SpillCost

-- | Records the expected cost to spill some regster.
type SpillCostRecord = (VirtualReg, Int, Int, Int)

-- | Add two spill cost records.
plusSpillCostRecord :: SpillCostRecord -> SpillCostRecord -> SpillCostRecord

-- | Show a spill cost record, including the degree from the graph and
--   final calulated spill cost.
pprSpillCostRecord :: (VirtualReg -> RegClass) -> (Reg -> SDoc) -> Graph VirtualReg RegClass RealReg -> SpillCostRecord -> SDoc

-- | Map of <a>SpillCostRecord</a>
type SpillCostInfo = UniqFM SpillCostRecord

-- | An empty map of spill costs.
zeroSpillCostInfo :: SpillCostInfo

-- | Add two spill cost infos.
plusSpillCostInfo :: SpillCostInfo -> SpillCostInfo -> SpillCostInfo

-- | Slurp out information used for determining spill costs.
--   
--   For each vreg, the number of times it was written to, read from, and
--   the number of instructions it was live on entry to (lifetime)
slurpSpillCostInfo :: (Outputable instr, Instruction instr) => Platform -> LiveCmmDecl statics instr -> SpillCostInfo

-- | Choose a node to spill from this graph
chooseSpill :: SpillCostInfo -> Graph VirtualReg RegClass RealReg -> VirtualReg

-- | Extract a map of register lifetimes from a <a>SpillCostInfo</a>.
lifeMapFromSpillCostInfo :: SpillCostInfo -> UniqFM (VirtualReg, Int)


-- | Register coalescing.
module RegAlloc.Graph.Coalesce

-- | Do register coalescing on this top level thing
--   
--   For Reg -&gt; Reg moves, if the first reg dies at the same time the
--   second reg is born then the mov only serves to join live ranges. The
--   two regs can be renamed to be the same and the move instruction safely
--   erased.
regCoalesce :: Instruction instr => [LiveCmmDecl statics instr] -> UniqSM [LiveCmmDecl statics instr]

-- | Slurp out mov instructions that only serve to join live ranges.
--   
--   During a mov, if the source reg dies and the destiation reg is born
--   then we can rename the two regs to the same thing and eliminate the
--   move.
slurpJoinMovs :: Instruction instr => LiveCmmDecl statics instr -> Bag (Reg, Reg)

module CmmSink
cmmSink :: DynFlags -> CmmGraph -> CmmGraph


-- | Free regs map for SPARC
module RegAlloc.Linear.SPARC.FreeRegs
data FreeRegs
[FreeRegs] :: !Word32 -> !Word32 -> !Word32 -> FreeRegs

-- | A reg map where no regs are free to be allocated.
noFreeRegs :: FreeRegs

-- | The initial set of free regs.
initFreeRegs :: Platform -> FreeRegs

-- | Get all the free registers of this class.
getFreeRegs :: RegClass -> FreeRegs -> [RealReg]

-- | Grab a register.
allocateReg :: Platform -> RealReg -> FreeRegs -> FreeRegs

-- | Release a register from allocation. The register liveness information
--   says that most regs die after a C call, but we still don't want to
--   allocate to some of them.
releaseReg :: Platform -> RealReg -> FreeRegs -> FreeRegs
bitMask :: Int -> Word32
showFreeRegs :: FreeRegs -> String
instance Show FreeRegs

module CmmInfo
mkEmptyContInfoTable :: CLabel -> CmmInfoTable
cmmToRawCmm :: DynFlags -> Stream IO CmmGroup () -> IO (Stream IO RawCmmGroup ())
mkInfoTable :: DynFlags -> CmmDecl -> UniqSM [RawCmmDecl]

-- | Value of the srt field of an info table when using an StgLargeSRT
srtEscape :: DynFlags -> StgHalfWord
closureInfoPtr :: DynFlags -> CmmExpr -> CmmExpr
entryCode :: DynFlags -> CmmExpr -> CmmExpr
getConstrTag :: DynFlags -> CmmExpr -> CmmExpr
cmmGetClosureType :: DynFlags -> CmmExpr -> CmmExpr
infoTable :: DynFlags -> CmmExpr -> CmmExpr
infoTableConstrTag :: DynFlags -> CmmExpr -> CmmExpr
infoTableSrtBitmap :: DynFlags -> CmmExpr -> CmmExpr
infoTableClosureType :: DynFlags -> CmmExpr -> CmmExpr
infoTablePtrs :: DynFlags -> CmmExpr -> CmmExpr
infoTableNonPtrs :: DynFlags -> CmmExpr -> CmmExpr
funInfoTable :: DynFlags -> CmmExpr -> CmmExpr
funInfoArity :: DynFlags -> CmmExpr -> CmmExpr
stdInfoTableSizeW :: DynFlags -> WordOff
fixedInfoTableSizeW :: WordOff
profInfoTableSizeW :: WordOff
maxStdInfoTableSizeW :: WordOff
maxRetInfoTableSizeW :: WordOff
stdInfoTableSizeB :: DynFlags -> ByteOff
stdSrtBitmapOffset :: DynFlags -> ByteOff
stdClosureTypeOffset :: DynFlags -> ByteOff
stdPtrsOffset :: DynFlags -> ByteOff
stdNonPtrsOffset :: DynFlags -> ByteOff

module CmmBuildInfoTables
type CAFSet = Set CLabel
type CAFEnv = BlockEnv CAFSet
cafAnal :: CmmGraph -> CAFEnv
doSRTs :: DynFlags -> TopSRT -> [(CAFEnv, [CmmDecl])] -> IO (TopSRT, [CmmDecl])
data TopSRT
emptySRT :: MonadUnique m => m TopSRT
isEmptySRT :: TopSRT -> Bool
srtToData :: TopSRT -> CmmGroup
instance Outputable TopSRT

module CmmProcPoint
type ProcPointSet = BlockSet
data Status
[ReachedBy] :: ProcPointSet -> Status
[ProcPoint] :: Status
callProcPoints :: CmmGraph -> ProcPointSet
minimalProcPointSet :: Platform -> ProcPointSet -> CmmGraph -> UniqSM ProcPointSet
splitAtProcPoints :: DynFlags -> CLabel -> ProcPointSet -> ProcPointSet -> BlockEnv Status -> CmmDecl -> UniqSM [CmmDecl]
procPointAnalysis :: ProcPointSet -> CmmGraph -> UniqSM (BlockEnv Status)
attachContInfoTables :: ProcPointSet -> CmmDecl -> CmmDecl
instance Outputable Status

module PprC
writeCs :: DynFlags -> Handle -> [RawCmmGroup] -> IO ()
pprStringInCStyle :: [Word8] -> SDoc
instance Functor TE
instance Applicative TE
instance Monad TE


-- | Code generation for the Static Pointer Table
--   
--   (c) 2014 I/O Tweag
--   
--   Each module that uses <tt>static</tt> keyword declares an
--   initialization function of the form hs_spt_init_<a>module</a>() which
--   is emitted into the _stub.c file and annotated with
--   <b>attribute</b>((constructor)) so that it gets executed at startup
--   time.
--   
--   The function's purpose is to call hs_spt_insert to insert the static
--   pointers of this module in the hashtable of the RTS, and it looks
--   something like this:
--   
--   <pre>
--   static void hs_hpc_init_Main(void) __attribute__((constructor));
--   static void hs_hpc_init_Main(void) {
--   
--     static StgWord64 k0[2] = {16252233372134256ULL,7370534374096082ULL};
--     extern StgPtr Main_sptEntryZC0_closure;
--     hs_spt_insert(k0, &amp;Main_sptEntryZC0_closure);
--   
--     static StgWord64 k1[2] = {12545634534567898ULL,5409674567544151ULL};
--     extern StgPtr Main_sptEntryZC1_closure;
--     hs_spt_insert(k1, &amp;Main_sptEntryZC1_closure);
--   
--   }
--   </pre>
--   
--   where the constants are fingerprints produced from the static forms.
--   
--   There is also a finalization function for the time when the module is
--   unloaded.
--   
--   <pre>
--   static void hs_hpc_fini_Main(void) __attribute__((destructor));
--   static void hs_hpc_fini_Main(void) {
--   
--     static StgWord64 k0[2] = {16252233372134256ULL,7370534374096082ULL};
--     hs_spt_remove(k0);
--   
--     static StgWord64 k1[2] = {12545634534567898ULL,5409674567544151ULL};
--     hs_spt_remove(k1);
--   
--   }
--   </pre>
module StaticPtrTable

-- | <tt>sptInitCode module statics</tt> is a C stub to insert the static
--   entries <tt>statics</tt> of <tt>module</tt> into the static pointer
--   table.
--   
--   Each entry contains the fingerprint used to locate the entry and the
--   top-level binding for the entry.
sptInitCode :: Module -> [(Fingerprint, (Id, CoreExpr))] -> SDoc

module ProfInit
profilingInitCode :: Module -> CollectedCCs -> SDoc

module X86.Regs

-- | regSqueeze_class reg Calculuate the maximum number of register colors
--   that could be denied to a node of this class due to having this reg as
--   a neighbour.
virtualRegSqueeze :: RegClass -> VirtualReg -> FastInt
realRegSqueeze :: RegClass -> RealReg -> FastInt
data Imm
[ImmInt] :: Int -> Imm
[ImmInteger] :: Integer -> Imm
[ImmCLbl] :: CLabel -> Imm
[ImmLit] :: SDoc -> Imm
[ImmIndex] :: CLabel -> Int -> Imm
[ImmFloat] :: Rational -> Imm
[ImmDouble] :: Rational -> Imm
[ImmConstantSum] :: Imm -> Imm -> Imm
[ImmConstantDiff] :: Imm -> Imm -> Imm
strImmLit :: String -> Imm
litToImm :: CmmLit -> Imm
data AddrMode
[AddrBaseIndex] :: EABase -> EAIndex -> Displacement -> AddrMode
[ImmAddr] :: Imm -> Int -> AddrMode
addrOffset :: AddrMode -> Int -> Maybe AddrMode
spRel :: DynFlags -> Int -> AddrMode
argRegs :: RegNo -> [Reg]
allArgRegs :: Platform -> [(Reg, Reg)]
allIntArgRegs :: Platform -> [Reg]

-- | these are the regs which we cannot assume stay alive over a C call.
callClobberedRegs :: Platform -> [Reg]
instrClobberedRegs :: Platform -> [Reg]

-- | The complete set of machine registers.
allMachRegNos :: Platform -> [RegNo]

-- | Take the class of a register.
classOfRealReg :: Platform -> RealReg -> RegClass

-- | Get the name of the register with this number.
showReg :: Platform -> RegNo -> String
data EABase
[EABaseNone] :: EABase
[EABaseReg] :: Reg -> EABase
[EABaseRip] :: EABase
data EAIndex
[EAIndexNone] :: EAIndex
[EAIndex] :: Reg -> Int -> EAIndex
addrModeRegs :: AddrMode -> [Reg]
eax :: Reg
ebx :: Reg
ecx :: Reg
edx :: Reg
esi :: Reg
edi :: Reg
ebp :: Reg
esp :: Reg
fake0 :: Reg
fake1 :: Reg
fake2 :: Reg
fake3 :: Reg
fake4 :: Reg
fake5 :: Reg
firstfake :: RegNo
rax :: Reg
rbx :: Reg
rcx :: Reg
rdx :: Reg
rsi :: Reg
rdi :: Reg
rbp :: Reg
rsp :: Reg
r8 :: Reg
r9 :: Reg
r10 :: Reg
r11 :: Reg
r12 :: Reg
r13 :: Reg
r14 :: Reg
r15 :: Reg
xmm0 :: Reg
xmm1 :: Reg
xmm2 :: Reg
xmm3 :: Reg
xmm4 :: Reg
xmm5 :: Reg
xmm6 :: Reg
xmm7 :: Reg
xmm8 :: Reg
xmm9 :: Reg
xmm10 :: Reg
xmm11 :: Reg
xmm12 :: Reg
xmm13 :: Reg
xmm14 :: Reg
xmm15 :: Reg
xmm :: RegNo -> Reg
ripRel :: Displacement -> AddrMode
allFPArgRegs :: Platform -> [Reg]
allocatableRegs :: Platform -> [RealReg]

module X86.RegInfo
mkVirtualReg :: Unique -> Size -> VirtualReg
regDotColor :: Platform -> RealReg -> SDoc


-- | Free regs map for i386
module RegAlloc.Linear.X86.FreeRegs
newtype FreeRegs
[FreeRegs] :: Word32 -> FreeRegs
noFreeRegs :: FreeRegs
releaseReg :: RealReg -> FreeRegs -> FreeRegs
initFreeRegs :: Platform -> FreeRegs
getFreeRegs :: Platform -> RegClass -> FreeRegs -> [RealReg]
allocateReg :: RealReg -> FreeRegs -> FreeRegs
instance Show FreeRegs


-- | Free regs map for x86_64
module RegAlloc.Linear.X86_64.FreeRegs
newtype FreeRegs
[FreeRegs] :: Word64 -> FreeRegs
noFreeRegs :: FreeRegs
releaseReg :: RealReg -> FreeRegs -> FreeRegs
initFreeRegs :: Platform -> FreeRegs
getFreeRegs :: Platform -> RegClass -> FreeRegs -> [RealReg]
allocateReg :: RealReg -> FreeRegs -> FreeRegs
instance Show FreeRegs


-- | Constants describing the DWARF format. Most of this simply mirrors
--   <i>usr</i>include/dwarf.h.
module Dwarf.Constants

-- | Language ID used for Haskell.
dW_LANG_Haskell :: Word

-- | Dwarf tags
dW_TAG_compile_unit :: Word

-- | Dwarf tags
dW_TAG_subroutine_type :: Word

-- | Dwarf tags
dW_TAG_file_type :: Word

-- | Dwarf tags
dW_TAG_subprogram :: Word

-- | Dwarf tags
dW_TAG_lexical_block :: Word

-- | Dwarf tags
dW_TAG_base_type :: Word

-- | Dwarf tags
dW_TAG_structure_type :: Word

-- | Dwarf tags
dW_TAG_pointer_type :: Word

-- | Dwarf tags
dW_TAG_array_type :: Word

-- | Dwarf tags
dW_TAG_subrange_type :: Word

-- | Dwarf tags
dW_TAG_typedef :: Word

-- | Dwarf tags
dW_TAG_variable :: Word

-- | Dwarf tags
dW_TAG_arg_variable :: Word

-- | Dwarf tags
dW_TAG_auto_variable :: Word

-- | Dwarf attributes
dW_AT_name :: Word

-- | Dwarf attributes
dW_AT_stmt_list :: Word

-- | Dwarf attributes
dW_AT_low_pc :: Word

-- | Dwarf attributes
dW_AT_high_pc :: Word

-- | Dwarf attributes
dW_AT_language :: Word

-- | Dwarf attributes
dW_AT_comp_dir :: Word

-- | Dwarf attributes
dW_AT_producer :: Word

-- | Dwarf attributes
dW_AT_external :: Word

-- | Dwarf attributes
dW_AT_frame_base :: Word

-- | Dwarf attributes
dW_AT_use_UTF8 :: Word

-- | Dwarf attributes
dW_AT_MIPS_linkage_name :: Word

-- | Abbrev declaration
dW_CHILDREN_no :: Word8

-- | Abbrev declaration
dW_CHILDREN_yes :: Word8
dW_FORM_addr :: Word
dW_FORM_data4 :: Word
dW_FORM_string :: Word
dW_FORM_flag :: Word
dW_FORM_block1 :: Word
dW_FORM_ref4 :: Word

-- | Dwarf native types
dW_ATE_address :: Word

-- | Dwarf native types
dW_ATE_boolean :: Word

-- | Dwarf native types
dW_ATE_float :: Word

-- | Dwarf native types
dW_ATE_signed :: Word

-- | Dwarf native types
dW_ATE_signed_char :: Word

-- | Dwarf native types
dW_ATE_unsigned :: Word

-- | Dwarf native types
dW_ATE_unsigned_char :: Word

-- | Call frame information
dW_CFA_set_loc :: Word8

-- | Call frame information
dW_CFA_undefined :: Word8

-- | Call frame information
dW_CFA_same_value :: Word8

-- | Call frame information
dW_CFA_def_cfa :: Word8

-- | Call frame information
dW_CFA_def_cfa_offset :: Word8

-- | Call frame information
dW_CFA_def_cfa_expression :: Word8

-- | Call frame information
dW_CFA_expression :: Word8

-- | Call frame information
dW_CFA_offset_extended_sf :: Word8

-- | Call frame information
dW_CFA_def_cfa_offset_sf :: Word8

-- | Call frame information
dW_CFA_def_cfa_sf :: Word8

-- | Call frame information
dW_CFA_val_offset :: Word8

-- | Call frame information
dW_CFA_val_expression :: Word8

-- | Call frame information
dW_CFA_offset :: Word8

-- | Operations
dW_OP_deref :: Word8

-- | Operations
dW_OP_consts :: Word8

-- | Operations
dW_OP_minus :: Word8

-- | Operations
dW_OP_mul :: Word8

-- | Operations
dW_OP_plus :: Word8

-- | Operations
dW_OP_lit0 :: Word8

-- | Operations
dW_OP_breg0 :: Word8

-- | Operations
dW_OP_call_frame_cfa :: Word8

-- | Dwarf section declarations
dwarfInfoSection :: SDoc

-- | Dwarf section declarations
dwarfAbbrevSection :: SDoc

-- | Dwarf section declarations
dwarfLineSection :: SDoc

-- | Dwarf section declarations
dwarfFrameSection :: SDoc

-- | Dwarf section declarations
dwarfGhcSection :: SDoc
dwarfSection :: String -> SDoc

-- | Dwarf section labels
dwarfInfoLabel :: LitString

-- | Dwarf section labels
dwarfAbbrevLabel :: LitString

-- | Dwarf section labels
dwarfLineLabel :: LitString

-- | Dwarf section labels
dwarfFrameLabel :: LitString

-- | Mapping of registers to DWARF register numbers
dwarfRegNo :: Platform -> Reg -> Word8

-- | Virtual register number to use for return address.
dwarfReturnRegNo :: Platform -> Word8

module PPC.Regs

-- | regSqueeze_class reg Calculuate the maximum number of register colors
--   that could be denied to a node of this class due to having this reg as
--   a neighbour.
virtualRegSqueeze :: RegClass -> VirtualReg -> FastInt
realRegSqueeze :: RegClass -> RealReg -> FastInt
mkVirtualReg :: Unique -> Size -> VirtualReg
regDotColor :: RealReg -> SDoc
data Imm
[ImmInt] :: Int -> Imm
[ImmInteger] :: Integer -> Imm
[ImmCLbl] :: CLabel -> Imm
[ImmLit] :: SDoc -> Imm
[ImmIndex] :: CLabel -> Int -> Imm
[ImmFloat] :: Rational -> Imm
[ImmDouble] :: Rational -> Imm
[ImmConstantSum] :: Imm -> Imm -> Imm
[ImmConstantDiff] :: Imm -> Imm -> Imm
[LO] :: Imm -> Imm
[HI] :: Imm -> Imm
[HA] :: Imm -> Imm
strImmLit :: String -> Imm
litToImm :: CmmLit -> Imm
data AddrMode
[AddrRegReg] :: Reg -> Reg -> AddrMode
[AddrRegImm] :: Reg -> Imm -> AddrMode
addrOffset :: AddrMode -> Int -> Maybe AddrMode
spRel :: DynFlags -> Int -> AddrMode
argRegs :: RegNo -> [Reg]
allArgRegs :: [Reg]
callClobberedRegs :: Platform -> [Reg]
allMachRegNos :: [RegNo]
classOfRealReg :: RealReg -> RegClass
showReg :: RegNo -> String
allFPArgRegs :: Platform -> [Reg]
fits16Bits :: Integral a => a -> Bool
makeImmediate :: Integral a => Width -> Bool -> a -> Maybe Imm
fReg :: Int -> RegNo
sp :: Reg
r3 :: Reg
r4 :: Reg
r27 :: Reg
r28 :: Reg
r30 :: Reg
f1 :: Reg
f20 :: Reg
f21 :: Reg
allocatableRegs :: Platform -> [RealReg]


-- | Hard wired things related to registers. This is module is preventing
--   the native code generator being able to emit code for non-host
--   architectures.
--   
--   TODO: Do a better job of the overloading, and eliminate this module.
--   We'd probably do better with a Register type class, and hook this to
--   Instruction somehow.
--   
--   TODO: We should also make arch specific versions of
--   RegAlloc.Graph.TrivColorable
module TargetReg
targetVirtualRegSqueeze :: Platform -> RegClass -> VirtualReg -> FastInt
targetRealRegSqueeze :: Platform -> RegClass -> RealReg -> FastInt
targetClassOfRealReg :: Platform -> RealReg -> RegClass
targetMkVirtualReg :: Platform -> Unique -> Size -> VirtualReg
targetRegDotColor :: Platform -> RealReg -> SDoc
targetClassOfReg :: Platform -> Reg -> RegClass

module X86.Instr
data Instr
[COMMENT] :: FastString -> Instr
[LOCATION] :: Int -> Int -> Int -> String -> Instr
[LDATA] :: Section -> (Alignment, CmmStatics) -> Instr
[NEWBLOCK] :: BlockId -> Instr
[DELTA] :: Int -> Instr
[MOV] :: Size -> Operand -> Operand -> Instr
[CMOV] :: Cond -> Size -> Operand -> Reg -> Instr
[MOVZxL] :: Size -> Operand -> Operand -> Instr
[MOVSxL] :: Size -> Operand -> Operand -> Instr
[LEA] :: Size -> Operand -> Operand -> Instr
[ADD] :: Size -> Operand -> Operand -> Instr
[ADC] :: Size -> Operand -> Operand -> Instr
[SUB] :: Size -> Operand -> Operand -> Instr
[SBB] :: Size -> Operand -> Operand -> Instr
[MUL] :: Size -> Operand -> Operand -> Instr
[MUL2] :: Size -> Operand -> Instr
[IMUL] :: Size -> Operand -> Operand -> Instr
[IMUL2] :: Size -> Operand -> Instr
[DIV] :: Size -> Operand -> Instr
[IDIV] :: Size -> Operand -> Instr
[ADD_CC] :: Size -> Operand -> Operand -> Instr
[SUB_CC] :: Size -> Operand -> Operand -> Instr
[AND] :: Size -> Operand -> Operand -> Instr
[OR] :: Size -> Operand -> Operand -> Instr
[XOR] :: Size -> Operand -> Operand -> Instr
[NOT] :: Size -> Operand -> Instr
[NEGI] :: Size -> Operand -> Instr
[BSWAP] :: Size -> Reg -> Instr
[SHL] :: Size -> Operand -> Operand -> Instr
[SAR] :: Size -> Operand -> Operand -> Instr
[SHR] :: Size -> Operand -> Operand -> Instr
[BT] :: Size -> Imm -> Operand -> Instr
[NOP] :: Instr
[GMOV] :: Reg -> Reg -> Instr
[GLD] :: Size -> AddrMode -> Reg -> Instr
[GST] :: Size -> Reg -> AddrMode -> Instr
[GLDZ] :: Reg -> Instr
[GLD1] :: Reg -> Instr
[GFTOI] :: Reg -> Reg -> Instr
[GDTOI] :: Reg -> Reg -> Instr
[GITOF] :: Reg -> Reg -> Instr
[GITOD] :: Reg -> Reg -> Instr
[GDTOF] :: Reg -> Reg -> Instr
[GADD] :: Size -> Reg -> Reg -> Reg -> Instr
[GDIV] :: Size -> Reg -> Reg -> Reg -> Instr
[GSUB] :: Size -> Reg -> Reg -> Reg -> Instr
[GMUL] :: Size -> Reg -> Reg -> Reg -> Instr
[GCMP] :: Cond -> Reg -> Reg -> Instr
[GABS] :: Size -> Reg -> Reg -> Instr
[GNEG] :: Size -> Reg -> Reg -> Instr
[GSQRT] :: Size -> Reg -> Reg -> Instr
[GSIN] :: Size -> CLabel -> CLabel -> Reg -> Reg -> Instr
[GCOS] :: Size -> CLabel -> CLabel -> Reg -> Reg -> Instr
[GTAN] :: Size -> CLabel -> CLabel -> Reg -> Reg -> Instr
[GFREE] :: Instr
[CVTSS2SD] :: Reg -> Reg -> Instr
[CVTSD2SS] :: Reg -> Reg -> Instr
[CVTTSS2SIQ] :: Size -> Operand -> Reg -> Instr
[CVTTSD2SIQ] :: Size -> Operand -> Reg -> Instr
[CVTSI2SS] :: Size -> Operand -> Reg -> Instr
[CVTSI2SD] :: Size -> Operand -> Reg -> Instr
[FDIV] :: Size -> Operand -> Operand -> Instr
[SQRT] :: Size -> Operand -> Reg -> Instr
[TEST] :: Size -> Operand -> Operand -> Instr
[CMP] :: Size -> Operand -> Operand -> Instr
[SETCC] :: Cond -> Operand -> Instr
[PUSH] :: Size -> Operand -> Instr
[POP] :: Size -> Operand -> Instr
[JMP] :: Operand -> [Reg] -> Instr
[JXX] :: Cond -> BlockId -> Instr
[JXX_GBL] :: Cond -> Imm -> Instr
[JMP_TBL] :: Operand -> [Maybe BlockId] -> Section -> CLabel -> Instr
[CALL] :: (Either Imm Reg) -> [Reg] -> Instr
[CLTD] :: Size -> Instr
[FETCHGOT] :: Reg -> Instr
[FETCHPC] :: Reg -> Instr
[POPCNT] :: Size -> Operand -> Reg -> Instr
[BSF] :: Size -> Operand -> Reg -> Instr
[BSR] :: Size -> Operand -> Reg -> Instr
[PREFETCH] :: PrefetchVariant -> Size -> Operand -> Instr
[LOCK] :: Instr -> Instr
[XADD] :: Size -> Operand -> Operand -> Instr
[CMPXCHG] :: Size -> Operand -> Operand -> Instr
[MFENCE] :: Instr
data Operand
[OpReg] :: Reg -> Operand
[OpImm] :: Imm -> Operand
[OpAddr] :: AddrMode -> Operand
data PrefetchVariant
[NTA] :: PrefetchVariant
[Lvl0] :: PrefetchVariant
[Lvl1] :: PrefetchVariant
[Lvl2] :: PrefetchVariant
data JumpDest
getJumpDestBlockId :: JumpDest -> Maybe BlockId
canShortcut :: Instr -> Maybe JumpDest
shortcutStatics :: (BlockId -> Maybe JumpDest) -> (Alignment, CmmStatics) -> (Alignment, CmmStatics)
shortcutJump :: (BlockId -> Maybe JumpDest) -> Instr -> Instr
i386_insert_ffrees :: [GenBasicBlock Instr] -> [GenBasicBlock Instr]
allocMoreStack :: Platform -> Int -> NatCmmDecl statics Instr -> UniqSM (NatCmmDecl statics Instr)
maxSpillSlots :: DynFlags -> Int
archWordSize :: Bool -> Size
instance Instruction Instr

module X86.Ppr
pprNatCmmDecl :: NatCmmDecl (Alignment, CmmStatics) Instr -> SDoc
pprBasicBlock :: BlockEnv CmmStatics -> NatBasicBlock Instr -> SDoc
pprSectionHeader :: Section -> SDoc
pprData :: CmmStatic -> SDoc
pprInstr :: Instr -> SDoc
pprSize :: Size -> SDoc
pprImm :: Imm -> SDoc
pprDataItem :: CmmLit -> SDoc
instance Outputable Instr


-- | Carries interesting info for debugging / profiling of the graph
--   coloring register allocator.
module RegAlloc.Graph.Stats

-- | Holds interesting statistics from the register allocator.
data RegAllocStats statics instr
[RegAllocStatsStart] :: [LiveCmmDecl statics instr] -> Graph VirtualReg RegClass RealReg -> SpillCostInfo -> RegAllocStats statics instr

-- | Initial code, with liveness.
[raLiveCmm] :: RegAllocStats statics instr -> [LiveCmmDecl statics instr]

-- | The initial, uncolored graph.
[raGraph] :: RegAllocStats statics instr -> Graph VirtualReg RegClass RealReg

-- | Information to help choose which regs to spill.
[raSpillCosts] :: RegAllocStats statics instr -> SpillCostInfo
[RegAllocStatsSpill] :: [LiveCmmDecl statics instr] -> Graph VirtualReg RegClass RealReg -> UniqFM VirtualReg -> SpillStats -> SpillCostInfo -> [LiveCmmDecl statics instr] -> RegAllocStats statics instr

-- | Code we tried to allocate registers for.
[raCode] :: RegAllocStats statics instr -> [LiveCmmDecl statics instr]

-- | The initial, uncolored graph.
[raGraph] :: RegAllocStats statics instr -> Graph VirtualReg RegClass RealReg

-- | The regs that were coaleced.
[raCoalesced] :: RegAllocStats statics instr -> UniqFM VirtualReg

-- | Spiller stats.
[raSpillStats] :: RegAllocStats statics instr -> SpillStats

-- | Information to help choose which regs to spill.
[raSpillCosts] :: RegAllocStats statics instr -> SpillCostInfo

-- | Code with spill instructions added.
[raSpilled] :: RegAllocStats statics instr -> [LiveCmmDecl statics instr]
[RegAllocStatsColored] :: [LiveCmmDecl statics instr] -> Graph VirtualReg RegClass RealReg -> Graph VirtualReg RegClass RealReg -> UniqFM VirtualReg -> [LiveCmmDecl statics instr] -> [LiveCmmDecl statics instr] -> [LiveCmmDecl statics instr] -> [NatCmmDecl statics instr] -> (Int, Int, Int) -> RegAllocStats statics instr

-- | Code we tried to allocate registers for.
[raCode] :: RegAllocStats statics instr -> [LiveCmmDecl statics instr]

-- | The initial, uncolored graph.
[raGraph] :: RegAllocStats statics instr -> Graph VirtualReg RegClass RealReg

-- | Coalesced and colored graph.
[raGraphColored] :: RegAllocStats statics instr -> Graph VirtualReg RegClass RealReg

-- | The regs that were coaleced.
[raCoalesced] :: RegAllocStats statics instr -> UniqFM VirtualReg

-- | Code with coalescings applied.
[raCodeCoalesced] :: RegAllocStats statics instr -> [LiveCmmDecl statics instr]

-- | Code with vregs replaced by hregs.
[raPatched] :: RegAllocStats statics instr -> [LiveCmmDecl statics instr]

-- | Code with unneeded spill/reloads cleaned out.
[raSpillClean] :: RegAllocStats statics instr -> [LiveCmmDecl statics instr]

-- | Final code.
[raFinal] :: RegAllocStats statics instr -> [NatCmmDecl statics instr]

-- | Spill/reload/reg-reg moves present in this code.
[raSRMs] :: RegAllocStats statics instr -> (Int, Int, Int)

-- | Do all the different analysis on this list of RegAllocStats
pprStats :: [RegAllocStats statics instr] -> Graph VirtualReg RegClass RealReg -> SDoc

-- | Dump a table of how many spill loads / stores were inserted for each
--   vreg.
pprStatsSpills :: [RegAllocStats statics instr] -> SDoc

-- | Dump a table of how long vregs tend to live for in the initial code.
pprStatsLifetimes :: [RegAllocStats statics instr] -> SDoc

-- | Dump a table of how many conflicts vregs tend to have in the initial
--   code.
pprStatsConflict :: [RegAllocStats statics instr] -> SDoc

-- | For every vreg, dump it's how many conflicts it has and its lifetime
--   good for making a scatter plot.
pprStatsLifeConflict :: [RegAllocStats statics instr] -> Graph VirtualReg RegClass RealReg -> SDoc

-- | Count spill<i>reload</i>reg-reg moves. Lets us see how well the
--   register allocator has done.
countSRMs :: Instruction instr => LiveCmmDecl statics instr -> (Int, Int, Int)
addSRM :: (Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)
instance (Outputable statics, Outputable instr) => Outputable (RegAllocStats statics instr)


-- | Graph coloring register allocator.
module RegAlloc.Graph.Main

-- | The top level of the graph coloring register allocator.
regAlloc :: (Outputable statics, Outputable instr, Instruction instr) => DynFlags -> UniqFM (UniqSet RealReg) -> UniqSet Int -> [LiveCmmDecl statics instr] -> UniqSM ([NatCmmDecl statics instr], [RegAllocStats statics instr])


-- | Free regs map for PowerPC
module RegAlloc.Linear.PPC.FreeRegs
data FreeRegs
[FreeRegs] :: !Word32 -> !Word32 -> FreeRegs
noFreeRegs :: FreeRegs
releaseReg :: RealReg -> FreeRegs -> FreeRegs
initFreeRegs :: Platform -> FreeRegs
getFreeRegs :: RegClass -> FreeRegs -> [RealReg]
allocateReg :: RealReg -> FreeRegs -> FreeRegs
instance Show FreeRegs

module PPC.Instr
archWordSize :: Size
data RI
[RIReg] :: Reg -> RI
[RIImm] :: Imm -> RI
data Instr
[COMMENT] :: FastString -> Instr
[LDATA] :: Section -> CmmStatics -> Instr
[NEWBLOCK] :: BlockId -> Instr
[DELTA] :: Int -> Instr
[LD] :: Size -> Reg -> AddrMode -> Instr
[LA] :: Size -> Reg -> AddrMode -> Instr
[ST] :: Size -> Reg -> AddrMode -> Instr
[STU] :: Size -> Reg -> AddrMode -> Instr
[LIS] :: Reg -> Imm -> Instr
[LI] :: Reg -> Imm -> Instr
[MR] :: Reg -> Reg -> Instr
[CMP] :: Size -> Reg -> RI -> Instr
[CMPL] :: Size -> Reg -> RI -> Instr
[BCC] :: Cond -> BlockId -> Instr
[BCCFAR] :: Cond -> BlockId -> Instr
[JMP] :: CLabel -> Instr
[MTCTR] :: Reg -> Instr
[BCTR] :: [Maybe BlockId] -> (Maybe CLabel) -> Instr
[BL] :: CLabel -> [Reg] -> Instr
[BCTRL] :: [Reg] -> Instr
[ADD] :: Reg -> Reg -> RI -> Instr
[ADDC] :: Reg -> Reg -> Reg -> Instr
[ADDE] :: Reg -> Reg -> Reg -> Instr
[ADDI] :: Reg -> Reg -> Imm -> Instr
[ADDIS] :: Reg -> Reg -> Imm -> Instr
[SUBF] :: Reg -> Reg -> Reg -> Instr
[SUBFC] :: Reg -> Reg -> Reg -> Instr
[SUBFE] :: Reg -> Reg -> Reg -> Instr
[MULLW] :: Reg -> Reg -> RI -> Instr
[DIVW] :: Reg -> Reg -> Reg -> Instr
[DIVWU] :: Reg -> Reg -> Reg -> Instr
[MULLW_MayOflo] :: Reg -> Reg -> Reg -> Instr
[AND] :: Reg -> Reg -> RI -> Instr
[OR] :: Reg -> Reg -> RI -> Instr
[XOR] :: Reg -> Reg -> RI -> Instr
[XORIS] :: Reg -> Reg -> Imm -> Instr
[EXTS] :: Size -> Reg -> Reg -> Instr
[NEG] :: Reg -> Reg -> Instr
[NOT] :: Reg -> Reg -> Instr
[SLW] :: Reg -> Reg -> RI -> Instr
[SRW] :: Reg -> Reg -> RI -> Instr
[SRAW] :: Reg -> Reg -> RI -> Instr
[RLWINM] :: Reg -> Reg -> Int -> Int -> Int -> Instr
[FADD] :: Size -> Reg -> Reg -> Reg -> Instr
[FSUB] :: Size -> Reg -> Reg -> Reg -> Instr
[FMUL] :: Size -> Reg -> Reg -> Reg -> Instr
[FDIV] :: Size -> Reg -> Reg -> Reg -> Instr
[FNEG] :: Reg -> Reg -> Instr
[FCMP] :: Reg -> Reg -> Instr
[FCTIWZ] :: Reg -> Reg -> Instr
[FRSP] :: Reg -> Reg -> Instr
[CRNOR] :: Int -> Int -> Int -> Instr
[MFCR] :: Reg -> Instr
[MFLR] :: Reg -> Instr
[FETCHPC] :: Reg -> Instr
[LWSYNC] :: Instr

-- | The number of spill slots available without allocating more.
maxSpillSlots :: DynFlags -> Int
allocMoreStack :: Platform -> Int -> NatCmmDecl statics Instr -> UniqSM (NatCmmDecl statics Instr)
makeFarBranches :: BlockEnv CmmStatics -> [NatBasicBlock Instr] -> [NatBasicBlock Instr]
instance Instruction Instr

module PPC.RegInfo
data JumpDest
[DestBlockId] :: BlockId -> JumpDest
getJumpDestBlockId :: JumpDest -> Maybe BlockId
canShortcut :: Instr -> Maybe JumpDest
shortcutJump :: (BlockId -> Maybe JumpDest) -> Instr -> Instr
shortcutStatics :: (BlockId -> Maybe JumpDest) -> CmmStatics -> CmmStatics

module PPC.Ppr
pprNatCmmDecl :: NatCmmDecl CmmStatics Instr -> SDoc
pprBasicBlock :: BlockEnv CmmStatics -> NatBasicBlock Instr -> SDoc
pprSectionHeader :: Section -> SDoc
pprData :: CmmStatic -> SDoc
pprInstr :: Instr -> SDoc
pprSize :: Size -> SDoc
pprImm :: Imm -> SDoc
pprDataItem :: CmmLit -> SDoc
instance Outputable Instr

module NCGMonad
data NatM_State
[NatM_State] :: UniqSupply -> Int -> [(CLabel)] -> Maybe Reg -> DynFlags -> Module -> ModLocation -> DwarfFiles -> LabelMap DebugBlock -> NatM_State
[natm_us] :: NatM_State -> UniqSupply
[natm_delta] :: NatM_State -> Int
[natm_imports] :: NatM_State -> [(CLabel)]
[natm_pic] :: NatM_State -> Maybe Reg
[natm_dflags] :: NatM_State -> DynFlags
[natm_this_module] :: NatM_State -> Module
[natm_modloc] :: NatM_State -> ModLocation
[natm_fileid] :: NatM_State -> DwarfFiles
[natm_debug_map] :: NatM_State -> LabelMap DebugBlock
mkNatM_State :: UniqSupply -> Int -> DynFlags -> Module -> ModLocation -> DwarfFiles -> LabelMap DebugBlock -> NatM_State
data NatM result
initNat :: NatM_State -> NatM a -> (a, NatM_State)
addImportNat :: CLabel -> NatM ()
getUniqueNat :: NatM Unique
mapAccumLNat :: (acc -> x -> NatM (acc, y)) -> acc -> [x] -> NatM (acc, [y])
setDeltaNat :: Int -> NatM ()
getDeltaNat :: NatM Int
getThisModuleNat :: NatM Module
getBlockIdNat :: NatM BlockId
getNewLabelNat :: NatM CLabel
getNewRegNat :: Size -> NatM Reg
getNewRegPairNat :: Size -> NatM (Reg, Reg)
getPicBaseMaybeNat :: NatM (Maybe Reg)
getPicBaseNat :: Size -> NatM Reg
getDynFlags :: HasDynFlags m => m DynFlags
getModLoc :: NatM ModLocation
getFileId :: FastString -> NatM Int
getDebugBlock :: Label -> NatM (Maybe DebugBlock)
type DwarfFiles = UniqFM (FastString, Int)
instance Functor NatM
instance Applicative NatM
instance Monad NatM
instance HasDynFlags NatM

module PIC
cmmMakeDynamicReference :: CmmMakeDynamicReferenceM m => DynFlags -> ReferenceKind -> CLabel -> m CmmExpr
class Monad m => CmmMakeDynamicReferenceM m
addImport :: CmmMakeDynamicReferenceM m => CLabel -> m ()
getThisModule :: CmmMakeDynamicReferenceM m => m Module
data ReferenceKind
[DataReference] :: ReferenceKind
[CallReference] :: ReferenceKind
[JumpReference] :: ReferenceKind
needImportedSymbols :: DynFlags -> Arch -> OS -> Bool
pprImportedSymbol :: DynFlags -> Platform -> CLabel -> SDoc
pprGotDeclaration :: DynFlags -> Arch -> OS -> SDoc
initializePicBase_ppc :: Arch -> OS -> Reg -> [NatCmmDecl CmmStatics Instr] -> NatM [NatCmmDecl CmmStatics Instr]
initializePicBase_x86 :: Arch -> OS -> Reg -> [NatCmmDecl (Alignment, CmmStatics) Instr] -> NatM [NatCmmDecl (Alignment, CmmStatics) Instr]
instance Eq ReferenceKind
instance CmmMakeDynamicReferenceM NatM

module X86.CodeGen
cmmTopCodeGen :: RawCmmDecl -> NatM [NatCmmDecl (Alignment, CmmStatics) Instr]
generateJumpTableForInstr :: DynFlags -> Instr -> Maybe (NatCmmDecl (Alignment, CmmStatics) Instr)

-- | <a>InstrBlock</a>s are the insn sequences generated by the insn
--   selectors. They are really trees of insns to facilitate fast
--   appending, where a left-to-right traversal yields the insns in the
--   correct order.
type InstrBlock = OrdList Instr

module PPC.CodeGen

-- | <a>InstrBlock</a>s are the insn sequences generated by the insn
--   selectors. They are really trees of insns to facilitate fast
--   appending, where a left-to-right traversal (pre-order?) yields the
--   insns in the correct order.
cmmTopCodeGen :: RawCmmDecl -> NatM [NatCmmDecl CmmStatics Instr]
generateJumpTableForInstr :: DynFlags -> Instr -> Maybe (NatCmmDecl CmmStatics Instr)

-- | <a>InstrBlock</a>s are the insn sequences generated by the insn
--   selectors. They are really trees of insns to facilitate fast
--   appending, where a left-to-right traversal yields the insns in the
--   correct order.
type InstrBlock = OrdList Instr

module SPARC.Imm

-- | An immediate value. Not all of these are directly representable by the
--   machine. Things like ImmLit are slurped out and put in a data segment
--   instead.
data Imm
[ImmInt] :: Int -> Imm
[ImmInteger] :: Integer -> Imm
[ImmCLbl] :: CLabel -> Imm
[ImmLit] :: SDoc -> Imm
[ImmIndex] :: CLabel -> Int -> Imm
[ImmFloat] :: Rational -> Imm
[ImmDouble] :: Rational -> Imm
[ImmConstantSum] :: Imm -> Imm -> Imm
[ImmConstantDiff] :: Imm -> Imm -> Imm
[LO] :: Imm -> Imm
[HI] :: Imm -> Imm

-- | Create a ImmLit containing this string.
strImmLit :: String -> Imm

-- | Convert a CmmLit to an Imm. Narrow to the width: a CmmInt might be out
--   of range, but we assume that ImmInteger only contains in-range values.
--   A signed value should be fine here.
litToImm :: CmmLit -> Imm

module SPARC.AddrMode

-- | Represents a memory address in an instruction. Being a RISC machine,
--   the SPARC addressing modes are very regular.
data AddrMode
[AddrRegReg] :: Reg -> Reg -> AddrMode
[AddrRegImm] :: Reg -> Imm -> AddrMode

-- | Add an integer offset to the address in an AddrMode.
addrOffset :: AddrMode -> Int -> Maybe AddrMode

module SPARC.Stack

-- | Get an AddrMode relative to the address in sp. This gives us a stack
--   relative addressing mode for volatile temporaries and for excess call
--   arguments.
spRel :: Int -> AddrMode

-- | Get an address relative to the frame pointer. This doesn't work work
--   for offsets greater than 13 bits; we just hope for the best
fpRel :: Int -> AddrMode

-- | Convert a spill slot number to a *byte* offset, with no sign.
spillSlotToOffset :: DynFlags -> Int -> Int

-- | The maximum number of spill slots available on the C stack. If we use
--   up all of the slots, then we're screwed.
--   
--   Why do we reserve 64 bytes, instead of using the whole thing?? -- BL
--   2009<i>02</i>15
maxSpillSlots :: DynFlags -> Int

module SPARC.Instr

-- | Register or immediate
data RI
[RIReg] :: Reg -> RI
[RIImm] :: Imm -> RI

-- | Check if a RI represents a zero value. - a literal zero - register
--   %g0, which is always zero.
riZero :: RI -> Bool

-- | Calculate the effective address which would be used by the
--   corresponding fpRel sequence.
fpRelEA :: Int -> Reg -> Instr

-- | Code to shift the stack pointer by n words.
moveSp :: Int -> Instr

-- | An instruction that will cause the one after it never to be exectuted
isUnconditionalJump :: Instr -> Bool

-- | SPARC instruction set. Not complete. This is only the ones we need.
data Instr
[COMMENT] :: FastString -> Instr
[LDATA] :: Section -> CmmStatics -> Instr
[NEWBLOCK] :: BlockId -> Instr
[DELTA] :: Int -> Instr
[LD] :: Size -> AddrMode -> Reg -> Instr
[ST] :: Size -> Reg -> AddrMode -> Instr
[ADD] :: Bool -> Bool -> Reg -> RI -> Reg -> Instr
[SUB] :: Bool -> Bool -> Reg -> RI -> Reg -> Instr
[UMUL] :: Bool -> Reg -> RI -> Reg -> Instr
[SMUL] :: Bool -> Reg -> RI -> Reg -> Instr
[UDIV] :: Bool -> Reg -> RI -> Reg -> Instr
[SDIV] :: Bool -> Reg -> RI -> Reg -> Instr
[RDY] :: Reg -> Instr
[WRY] :: Reg -> Reg -> Instr
[AND] :: Bool -> Reg -> RI -> Reg -> Instr
[ANDN] :: Bool -> Reg -> RI -> Reg -> Instr
[OR] :: Bool -> Reg -> RI -> Reg -> Instr
[ORN] :: Bool -> Reg -> RI -> Reg -> Instr
[XOR] :: Bool -> Reg -> RI -> Reg -> Instr
[XNOR] :: Bool -> Reg -> RI -> Reg -> Instr
[SLL] :: Reg -> RI -> Reg -> Instr
[SRL] :: Reg -> RI -> Reg -> Instr
[SRA] :: Reg -> RI -> Reg -> Instr
[SETHI] :: Imm -> Reg -> Instr
[NOP] :: Instr
[FABS] :: Size -> Reg -> Reg -> Instr
[FADD] :: Size -> Reg -> Reg -> Reg -> Instr
[FCMP] :: Bool -> Size -> Reg -> Reg -> Instr
[FDIV] :: Size -> Reg -> Reg -> Reg -> Instr
[FMOV] :: Size -> Reg -> Reg -> Instr
[FMUL] :: Size -> Reg -> Reg -> Reg -> Instr
[FNEG] :: Size -> Reg -> Reg -> Instr
[FSQRT] :: Size -> Reg -> Reg -> Instr
[FSUB] :: Size -> Reg -> Reg -> Reg -> Instr
[FxTOy] :: Size -> Size -> Reg -> Reg -> Instr
[BI] :: Cond -> Bool -> BlockId -> Instr
[BF] :: Cond -> Bool -> BlockId -> Instr
[JMP] :: AddrMode -> Instr
[JMP_TBL] :: AddrMode -> [Maybe BlockId] -> CLabel -> Instr
[CALL] :: (Either Imm Reg) -> Int -> Bool -> Instr

-- | The maximum number of spill slots available on the C stack. If we use
--   up all of the slots, then we're screwed.
--   
--   Why do we reserve 64 bytes, instead of using the whole thing?? -- BL
--   2009<i>02</i>15
maxSpillSlots :: DynFlags -> Int
instance Instruction Instr

module SPARC.Ppr
pprNatCmmDecl :: NatCmmDecl CmmStatics Instr -> SDoc
pprBasicBlock :: BlockEnv CmmStatics -> NatBasicBlock Instr -> SDoc

-- | Pretty print a section / segment header. On SPARC all the data
--   sections must be at least 8 byte aligned incase we store doubles in
--   them.
pprSectionHeader :: Section -> SDoc
pprData :: CmmStatic -> SDoc

-- | Pretty print an instruction.
pprInstr :: Instr -> SDoc

-- | Pretty print a size for an instruction suffix.
pprSize :: Size -> SDoc

-- | Pretty print an immediate value.
pprImm :: Imm -> SDoc

-- | Pretty print a data item.
pprDataItem :: CmmLit -> SDoc
instance Outputable Instr

module SPARC.ShortcutJump
data JumpDest
[DestBlockId] :: BlockId -> JumpDest
[DestImm] :: Imm -> JumpDest
getJumpDestBlockId :: JumpDest -> Maybe BlockId
canShortcut :: Instr -> Maybe JumpDest
shortcutJump :: (BlockId -> Maybe JumpDest) -> Instr -> Instr
shortcutStatics :: (BlockId -> Maybe JumpDest) -> CmmStatics -> CmmStatics
shortBlockId :: (BlockId -> Maybe JumpDest) -> BlockId -> CLabel


-- | Expand out synthetic instructions into single machine instrs.
module SPARC.CodeGen.Expand

-- | Expand out synthetic instructions in this top level thing
expandTop :: NatCmmDecl CmmStatics Instr -> NatCmmDecl CmmStatics Instr


-- | One ounce of sanity checking is worth 10000000000000000 ounces of
--   staring blindly at assembly code trying to find the problem..
module SPARC.CodeGen.Sanity

-- | Enforce intra-block invariants.
checkBlock :: CmmBlock -> NatBasicBlock Instr -> NatBasicBlock Instr

module SPARC.CodeGen.Base

-- | <a>InstrBlock</a>s are the insn sequences generated by the insn
--   selectors. They are really trees of insns to facilitate fast
--   appending, where a left-to-right traversal yields the insns in the
--   correct order.
type InstrBlock = OrdList Instr

-- | Condition codes passed up the tree.
data CondCode
[CondCode] :: Bool -> Cond -> InstrBlock -> CondCode

-- | a.k.a <a>Register64</a> Reg is the lower 32-bit temporary which
--   contains the result. Use getHiVRegFromLo to find the other VRegUnique.
--   
--   Rules of this simplified insn selection game are therefore that the
--   returned Reg may be modified
data ChildCode64
[ChildCode64] :: InstrBlock -> Reg -> ChildCode64

-- | Holds code that references a memory address.
data Amode
[Amode] :: AddrMode -> InstrBlock -> Amode

-- | Code to produce a result into a register. If the result must go in a
--   specific register, it comes out as Fixed. Otherwise, the parent can
--   decide which register to put it in.
data Register
[Fixed] :: Size -> Reg -> InstrBlock -> Register
[Any] :: Size -> (Reg -> InstrBlock) -> Register

-- | Change the size field in a Register.
setSizeOfRegister :: Register -> Size -> Register

-- | Grab the Reg for a CmmReg
getRegisterReg :: Platform -> CmmReg -> Reg
mangleIndexTree :: DynFlags -> CmmExpr -> CmmExpr

module RegAlloc.Linear.FreeRegs
class Show freeRegs => FR freeRegs
frAllocateReg :: FR freeRegs => Platform -> RealReg -> freeRegs -> freeRegs
frGetFreeRegs :: FR freeRegs => Platform -> RegClass -> freeRegs -> [RealReg]
frInitFreeRegs :: FR freeRegs => Platform -> freeRegs
frReleaseReg :: FR freeRegs => Platform -> RealReg -> freeRegs -> freeRegs
maxSpillSlots :: DynFlags -> Int
instance FR FreeRegs
instance FR FreeRegs
instance FR FreeRegs
instance FR FreeRegs


-- | Handles joining of a jump instruction to its targets.
module RegAlloc.Linear.JoinToTargets

-- | For a jump instruction at the end of a block, generate fixup code so
--   its vregs are in the correct regs for its destination.
joinToTargets :: (FR freeRegs, Instruction instr) => BlockMap RegSet -> BlockId -> instr -> RegM freeRegs ([NatBasicBlock instr], instr)

module RegAlloc.Linear.Main
regAlloc :: (Outputable instr, Instruction instr) => DynFlags -> LiveCmmDecl statics instr -> UniqSM (NatCmmDecl statics instr, Maybe Int, Maybe RegAllocStats)

module SPARC.CodeGen.Amode

-- | Generate code to reference a memory address.
getAmode :: CmmExpr -> NatM Amode

module SPARC.CodeGen.CondCode
getCondCode :: CmmExpr -> NatM CondCode
condIntCode :: Cond -> CmmExpr -> CmmExpr -> NatM CondCode
condFltCode :: Cond -> CmmExpr -> CmmExpr -> NatM CondCode


-- | Evaluation of 64 bit values on 32 bit platforms.
module SPARC.CodeGen.Gen64

-- | Code to assign a 64 bit value to memory.
assignMem_I64Code :: CmmExpr -> CmmExpr -> NatM InstrBlock

-- | Code to assign a 64 bit value to a register.
assignReg_I64Code :: CmmReg -> CmmExpr -> NatM InstrBlock

-- | Get the value of an expression into a 64 bit register.
iselExpr64 :: CmmExpr -> NatM ChildCode64


-- | Evaluation of 32 bit values.
module SPARC.CodeGen.Gen32

-- | The dual to getAnyReg: compute an expression into a register, but we
--   don't mind which one it is.
getSomeReg :: CmmExpr -> NatM (Reg, InstrBlock)

-- | Make code to evaluate a 32 bit expression.
getRegister :: CmmExpr -> NatM Register

module SPARC.CodeGen

-- | Top level code generation
cmmTopCodeGen :: RawCmmDecl -> NatM [NatCmmDecl CmmStatics Instr]
generateJumpTableForInstr :: DynFlags -> Instr -> Maybe (NatCmmDecl CmmStatics Instr)

-- | <a>InstrBlock</a>s are the insn sequences generated by the insn
--   selectors. They are really trees of insns to facilitate fast
--   appending, where a left-to-right traversal yields the insns in the
--   correct order.
type InstrBlock = OrdList Instr

module Dwarf.Types

-- | Individual dwarf records. Each one will be encoded as an entry in the
--   .debug_info section.
data DwarfInfo
[DwarfCompileUnit] :: [DwarfInfo] -> String -> String -> String -> LitString -> DwarfInfo
[dwChildren] :: DwarfInfo -> [DwarfInfo]
[dwName] :: DwarfInfo -> String
[dwProducer] :: DwarfInfo -> String
[dwCompDir] :: DwarfInfo -> String
[dwLineLabel] :: DwarfInfo -> LitString
[DwarfSubprogram] :: [DwarfInfo] -> String -> CLabel -> DwarfInfo
[dwChildren] :: DwarfInfo -> [DwarfInfo]
[dwName] :: DwarfInfo -> String
[dwLabel] :: DwarfInfo -> CLabel
[DwarfBlock] :: [DwarfInfo] -> CLabel -> CLabel -> DwarfInfo
[dwChildren] :: DwarfInfo -> [DwarfInfo]
[dwLabel] :: DwarfInfo -> CLabel
[dwMarker] :: DwarfInfo -> CLabel

-- | Generate assembly for DWARF data
pprDwarfInfo :: Bool -> DwarfInfo -> SDoc

-- | Abbreviation declaration. This explains the binary encoding we use for
--   representing <tt>DwarfInfo</tt>.
pprAbbrevDecls :: Bool -> SDoc

-- | Information about unwind instructions for a procedure. This
--   corresponds to a "Common Information Entry" (CIE) in DWARF.
data DwarfFrame
[DwarfFrame] :: CLabel -> UnwindTable -> [DwarfFrameProc] -> DwarfFrame
[dwCieLabel] :: DwarfFrame -> CLabel
[dwCieInit] :: DwarfFrame -> UnwindTable
[dwCieProcs] :: DwarfFrame -> [DwarfFrameProc]

-- | Unwind instructions for an individual procedure. Corresponds to a
--   "Frame Description Entry" (FDE) in DWARF.
data DwarfFrameProc
[DwarfFrameProc] :: CLabel -> Bool -> [DwarfFrameBlock] -> DwarfFrameProc
[dwFdeProc] :: DwarfFrameProc -> CLabel
[dwFdeHasInfo] :: DwarfFrameProc -> Bool

-- | List of blocks. Order must match asm!
[dwFdeBlocks] :: DwarfFrameProc -> [DwarfFrameBlock]

-- | Unwind instructions for a block. Will become part of the containing
--   FDE.
data DwarfFrameBlock
[DwarfFrameBlock] :: CLabel -> Bool -> UnwindTable -> DwarfFrameBlock
[dwFdeBlock] :: DwarfFrameBlock -> CLabel
[dwFdeBlkHasInfo] :: DwarfFrameBlock -> Bool
[dwFdeUnwind] :: DwarfFrameBlock -> UnwindTable

-- | Header for the .debug_frame section. Here we emit the "Common
--   Information Entry" record that etablishes general call frame
--   parameters and the default stack layout.
pprDwarfFrame :: DwarfFrame -> SDoc

-- | Assembly for a single byte of constant DWARF data
pprByte :: Word8 -> SDoc

-- | Assembly for 4 bytes of dynamic DWARF data
pprData4' :: SDoc -> SDoc

-- | Assembly for a DWARF word of dynamic data. This means 32 bit, as we
--   are generating 32 bit DWARF.
pprDwWord :: SDoc -> SDoc

-- | Assembly for a machine word of dynamic data. Depends on the
--   architecture we are currently generating code for.
pprWord :: SDoc -> SDoc

-- | Prints a number in "little endian base 128" format. The idea is to
--   optimize for small numbers by stopping once all further bytes would be
--   0. The highest bit in every byte signals whether there are further
--   bytes to read.
pprLEBWord :: Word -> SDoc

-- | Same as <tt>pprLEBWord</tt>, but for a signed number
pprLEBInt :: Int -> SDoc

-- | Align assembly at (machine) word boundary
wordAlign :: SDoc

-- | Generate an offset into another section. This is tricky because this
--   is handled differently depending on platform: Mac Os expects us to
--   calculate the offset using assembler arithmetic. Meanwhile, GNU tools
--   expect us to just reference the target directly, and will figure out
--   on their own that we actually need an offset.
sectionOffset :: LitString -> LitString -> SDoc
instance Enum DwarfAbbrev
instance Eq DwarfAbbrev

module Dwarf

-- | Generate DWARF/debug information
dwarfGen :: DynFlags -> ModLocation -> UniqSupply -> [DebugBlock] -> IO (SDoc, UniqSupply)

module AsmCodeGen
nativeCodeGen :: DynFlags -> Module -> ModLocation -> Handle -> UniqSupply -> Stream IO RawCmmGroup () -> IO UniqSupply
instance Functor CmmOptM
instance Applicative CmmOptM
instance Monad CmmOptM
instance CmmMakeDynamicReferenceM CmmOptM
instance HasDynFlags CmmOptM

module StgSyn
data GenStgArg occ
[StgVarArg] :: occ -> GenStgArg occ
[StgLitArg] :: Literal -> GenStgArg occ
type GenStgLiveVars occ = UniqSet occ
data GenStgBinding bndr occ
[StgNonRec] :: bndr -> (GenStgRhs bndr occ) -> GenStgBinding bndr occ
[StgRec] :: [(bndr, GenStgRhs bndr occ)] -> GenStgBinding bndr occ
data GenStgExpr bndr occ
[StgApp] :: occ -> [GenStgArg occ] -> GenStgExpr bndr occ
[StgLit] :: Literal -> GenStgExpr bndr occ
[StgConApp] :: DataCon -> [GenStgArg occ] -> GenStgExpr bndr occ
[StgOpApp] :: StgOp -> [GenStgArg occ] -> Type -> GenStgExpr bndr occ
[StgLam] :: [bndr] -> StgExpr -> GenStgExpr bndr occ
[StgCase] :: (GenStgExpr bndr occ) -> (GenStgLiveVars occ) -> (GenStgLiveVars occ) -> bndr -> SRT -> AltType -> [GenStgAlt bndr occ] -> GenStgExpr bndr occ
[StgLet] :: (GenStgBinding bndr occ) -> (GenStgExpr bndr occ) -> GenStgExpr bndr occ
[StgLetNoEscape] :: (GenStgLiveVars occ) -> (GenStgLiveVars occ) -> (GenStgBinding bndr occ) -> (GenStgExpr bndr occ) -> GenStgExpr bndr occ
[StgTick] :: (Tickish bndr) -> (GenStgExpr bndr occ) -> GenStgExpr bndr occ
data GenStgRhs bndr occ
[StgRhsClosure] :: CostCentreStack -> StgBinderInfo -> [occ] -> !UpdateFlag -> SRT -> [bndr] -> (GenStgExpr bndr occ) -> GenStgRhs bndr occ
[StgRhsCon] :: CostCentreStack -> DataCon -> [GenStgArg occ] -> GenStgRhs bndr occ
type GenStgAlt bndr occ = (AltCon, [bndr], [Bool], GenStgExpr bndr occ)
data AltType
[PolyAlt] :: AltType
[UbxTupAlt] :: Int -> AltType
[AlgAlt] :: TyCon -> AltType
[PrimAlt] :: TyCon -> AltType
data UpdateFlag
[ReEntrant] :: UpdateFlag
[Updatable] :: UpdateFlag
[SingleEntry] :: UpdateFlag
isUpdatable :: UpdateFlag -> Bool
data StgBinderInfo
noBinderInfo :: StgBinderInfo
stgSatOcc :: StgBinderInfo
stgUnsatOcc :: StgBinderInfo
satCallsOnly :: StgBinderInfo -> Bool
combineStgBinderInfo :: StgBinderInfo -> StgBinderInfo -> StgBinderInfo
type StgArg = GenStgArg Id
type StgLiveVars = GenStgLiveVars Id
type StgBinding = GenStgBinding Id Id
type StgExpr = GenStgExpr Id Id
type StgRhs = GenStgRhs Id Id
type StgAlt = GenStgAlt Id Id
data StgOp
[StgPrimOp] :: PrimOp -> StgOp
[StgPrimCallOp] :: PrimCall -> StgOp
[StgFCallOp] :: ForeignCall -> Unique -> StgOp
data SRT
[NoSRT] :: SRT
[SRTEntries] :: IdSet -> SRT
[SRT] :: !Int -> !Int -> !Bitmap -> SRT
stgBindHasCafRefs :: GenStgBinding bndr Id -> Bool
stgArgHasCafRefs :: GenStgArg Id -> Bool
stgRhsArity :: StgRhs -> Int

-- | Does this constructor application refer to anything in a different
--   *Windows* DLL? If so, we can't allocate it statically
isDllConApp :: DynFlags -> Module -> DataCon -> [StgArg] -> Bool

-- | Type of an <tt>StgArg</tt>
--   
--   Very half baked becase we have lost the type arguments.
stgArgType :: StgArg -> Type

-- | Strip ticks of a given type from an STG expression
stripStgTicksTop :: (Tickish Id -> Bool) -> StgExpr -> ([Tickish Id], StgExpr)
pprStgBinding :: StgBinding -> SDoc
pprStgBindings :: [StgBinding] -> SDoc
pprStgLVs :: Outputable occ => GenStgLiveVars occ -> SDoc
instance Outputable UpdateFlag
instance Outputable bdee => Outputable (GenStgArg bdee)
instance (OutputableBndr bndr, Outputable bdee, Ord bdee) => Outputable (GenStgBinding bndr bdee)
instance (OutputableBndr bndr, Outputable bdee, Ord bdee) => Outputable (GenStgExpr bndr bdee)
instance (OutputableBndr bndr, Outputable bdee, Ord bdee) => Outputable (GenStgRhs bndr bdee)
instance Outputable AltType

module SCCfinal
stgMassageForProfiling :: DynFlags -> Module -> UniqSupply -> [StgBinding] -> (CollectedCCs, [StgBinding])
instance Functor MassageM
instance Applicative MassageM
instance Monad MassageM

module StgStats
showStgStats :: [StgBinding] -> String
instance Ord CounterType
instance Eq CounterType

module StgLint
lintStgBindings :: String -> [StgBinding] -> [StgBinding]
instance Functor LintM
instance Applicative LintM
instance Monad LintM


-- | Builtin types and functions used by the vectoriser. These are all
--   defined in <a>Prim</a>.
module Vectorise.Builtins.Base
mAX_DPH_PROD :: Int
mAX_DPH_SUM :: Int
mAX_DPH_COMBINE :: Int
mAX_DPH_SCALAR_ARGS :: Int
aLL_DPH_PRIM_TYCONS :: [Name]

-- | Holds the names of the types and functions from <a>Prim</a> that are
--   used by the vectoriser.
data Builtins
[Builtins] :: TyCon -> TyCon -> TyCon -> Class -> TyCon -> TyCon -> Class -> TyCon -> DataCon -> Var -> Var -> NameEnv Var -> Var -> NameEnv Var -> Var -> NameEnv Var -> Array Int Var -> Array Int (NameEnv Var) -> Class -> Array Int Var -> TyCon -> Var -> Var -> Array Int TyCon -> TyCon -> Var -> Var -> TyCon -> Var -> Var -> Var -> Var -> Array Int Var -> Array Int Type -> Array Int Type -> Array Int CoreExpr -> Array Int CoreExpr -> Array Int CoreExpr -> Array (Int, Int) CoreExpr -> Var -> Builtins

-- | PArray
[parrayTyCon] :: Builtins -> TyCon

-- | PData
[pdataTyCon] :: Builtins -> TyCon

-- | PDatas
[pdatasTyCon] :: Builtins -> TyCon

-- | PR
[prClass] :: Builtins -> Class

-- | PR
[prTyCon] :: Builtins -> TyCon

-- | PRepr
[preprTyCon] :: Builtins -> TyCon

-- | PA
[paClass] :: Builtins -> Class

-- | PA
[paTyCon] :: Builtins -> TyCon

-- | PA
[paDataCon] :: Builtins -> DataCon

-- | PA
[paPRSel] :: Builtins -> Var

-- | replicatePD
[replicatePDVar] :: Builtins -> Var

-- | replicatePD_Int# etc.
[replicatePD_PrimVars] :: Builtins -> NameEnv Var

-- | emptyPD
[emptyPDVar] :: Builtins -> Var

-- | emptyPD_Int# etc.
[emptyPD_PrimVars] :: Builtins -> NameEnv Var

-- | packByTagPD
[packByTagPDVar] :: Builtins -> Var

-- | packByTagPD_Int# etc.
[packByTagPD_PrimVars] :: Builtins -> NameEnv Var

-- | combinePD
[combinePDVars] :: Builtins -> Array Int Var

-- | combine2PD_Int# etc.
[combinePD_PrimVarss] :: Builtins -> Array Int (NameEnv Var)

-- | Scalar
[scalarClass] :: Builtins -> Class

-- | map, zipWith, zipWith3
[scalarZips] :: Builtins -> Array Int Var

-- | Void
[voidTyCon] :: Builtins -> TyCon

-- | void
[voidVar] :: Builtins -> Var

-- | fromVoid
[fromVoidVar] :: Builtins -> Var

-- | Sum2 .. Sum3
[sumTyCons] :: Builtins -> Array Int TyCon

-- | Wrap
[wrapTyCon] :: Builtins -> TyCon

-- | pvoid
[pvoidVar] :: Builtins -> Var

-- | pvoids
[pvoidsVar] :: Builtins -> Var

-- | :-&gt;
[closureTyCon] :: Builtins -> TyCon

-- | closure
[closureVar] :: Builtins -> Var

-- | liftedClosure
[liftedClosureVar] :: Builtins -> Var

-- | $:
[applyVar] :: Builtins -> Var

-- | liftedApply
[liftedApplyVar] :: Builtins -> Var

-- | closure1 .. closure3
[closureCtrFuns] :: Builtins -> Array Int Var

-- | Sel2
[selTys] :: Builtins -> Array Int Type

-- | Sels2
[selsTys] :: Builtins -> Array Int Type

-- | lengthSels2
[selsLengths] :: Builtins -> Array Int CoreExpr

-- | replicate2
[selReplicates] :: Builtins -> Array Int CoreExpr

-- | tagsSel2
[selTagss] :: Builtins -> Array Int CoreExpr

-- | elementsSel2_0 .. elementsSel_2_1
[selElementss] :: Builtins -> Array (Int, Int) CoreExpr

-- | lc
[liftingContext] :: Builtins -> Var
selTy :: Int -> Builtins -> Type
selsTy :: Int -> Builtins -> Type
selReplicate :: Int -> Builtins -> CoreExpr
selTags :: Int -> Builtins -> CoreExpr
selElements :: Int -> Int -> Builtins -> CoreExpr
selsLength :: Int -> Builtins -> CoreExpr
sumTyCon :: Int -> Builtins -> TyCon
prodTyCon :: Int -> Builtins -> TyCon
prodDataCon :: Int -> Builtins -> DataCon
replicatePD_PrimVar :: TyCon -> Builtins -> Var
emptyPD_PrimVar :: TyCon -> Builtins -> Var
packByTagPD_PrimVar :: TyCon -> Builtins -> Var
combinePDVar :: Int -> Builtins -> Var
combinePD_PrimVar :: Int -> TyCon -> Builtins -> Var
scalarZip :: Int -> Builtins -> Var
closureCtrFun :: Int -> Builtins -> Var

module Vectorise.Type.Classify

-- | From a list of type constructors, extract those that can be
--   vectorised, returning them in two sets, where the first result list
--   <i>must be</i> vectorised and the second result list <i>need not
--   be</i> vectorised. The third result list are those type constructors
--   that we cannot convert (either because they use language extensions or
--   because they dependent on type constructors for which no vectorised
--   version is available).
--   
--   NB: In order to be able to vectorise a type constructor, we require
--   members of the depending set (i.e., those type constructors that the
--   current one depends on) to be vectorised only if they are also
--   parallel (i.e., appear in the second argument to the function).
--   
--   The first argument determines the <i>conversion status</i> of external
--   type constructors as follows:
--   
--   <ul>
--   <li>tycons which have converted versions are mapped to
--   <a>True</a></li>
--   <li>tycons which are not changed by vectorisation are mapped to
--   <a>False</a></li>
--   <li>tycons which haven't been converted (because they can't or weren't
--   vectorised) are not elements of the map</li>
--   </ul>
classifyTyCons :: UniqFM Bool -> NameSet -> [TyCon] -> ([TyCon], [TyCon], [TyCon], [TyCon])

module LibFFI
type ForeignCallToken = C_ffi_cif
prepForeignCall :: DynFlags -> CCallConv -> [PrimRep] -> PrimRep -> IO (Ptr ForeignCallToken)

module TcType
type TcType = Type
type TcSigmaType = TcType
type TcRhoType = TcType
type TcTauType = TcType
type TcPredType = PredType
type TcThetaType = ThetaType
type TcTyVar = TyVar
type TcTyVarSet = TyVarSet
type TcKind = Kind
type TcCoVar = CoVar
newtype TcLevel
[TcLevel] :: Int -> TcLevel
topTcLevel :: TcLevel
pushTcLevel :: TcLevel -> TcLevel
strictlyDeeperThan :: TcLevel -> TcLevel -> Bool
sameDepthAs :: TcLevel -> TcLevel -> Bool
fskTcLevel :: TcLevel
data UserTypeCtxt
[FunSigCtxt] :: Name -> UserTypeCtxt
[InfSigCtxt] :: Name -> UserTypeCtxt
[ExprSigCtxt] :: UserTypeCtxt
[ConArgCtxt] :: Name -> UserTypeCtxt
[TySynCtxt] :: Name -> UserTypeCtxt
[PatSigCtxt] :: UserTypeCtxt
[RuleSigCtxt] :: Name -> UserTypeCtxt
[ResSigCtxt] :: UserTypeCtxt
[ForSigCtxt] :: Name -> UserTypeCtxt
[DefaultDeclCtxt] :: UserTypeCtxt
[InstDeclCtxt] :: UserTypeCtxt
[SpecInstCtxt] :: UserTypeCtxt
[ThBrackCtxt] :: UserTypeCtxt
[GenSigCtxt] :: UserTypeCtxt
[GhciCtxt] :: UserTypeCtxt
[ClassSCCtxt] :: Name -> UserTypeCtxt
[SigmaCtxt] :: UserTypeCtxt
[DataTyCtxt] :: Name -> UserTypeCtxt
pprUserTypeCtxt :: UserTypeCtxt -> SDoc
pprSigCtxt :: UserTypeCtxt -> SDoc -> SDoc -> SDoc
data TcTyVarDetails
[SkolemTv] :: Bool -> TcTyVarDetails
[FlatSkol] :: TcType -> TcTyVarDetails
[RuntimeUnk] :: TcTyVarDetails
[MetaTv] :: MetaInfo -> IORef MetaDetails -> TcLevel -> TcTyVarDetails
[mtv_info] :: TcTyVarDetails -> MetaInfo
[mtv_ref] :: TcTyVarDetails -> IORef MetaDetails
[mtv_tclvl] :: TcTyVarDetails -> TcLevel
pprTcTyVarDetails :: TcTyVarDetails -> SDoc
vanillaSkolemTv :: TcTyVarDetails
superSkolemTv :: TcTyVarDetails
data MetaDetails
[Flexi] :: MetaDetails
[Indirect] :: TcType -> MetaDetails
data MetaInfo
[TauTv] :: Bool -> MetaInfo
[ReturnTv] :: MetaInfo
[SigTv] :: MetaInfo
[FlatMetaTv] :: MetaInfo
isImmutableTyVar :: TyVar -> Bool
isSkolemTyVar :: TcTyVar -> Bool
isMetaTyVar :: TcTyVar -> Bool
isMetaTyVarTy :: TcType -> Bool
isTyVarTy :: Type -> Bool
isSigTyVar :: Var -> Bool
isOverlappableTyVar :: TcTyVar -> Bool
isTyConableTyVar :: TcTyVar -> Bool

-- | True of FlatSkol skolems only
isFskTyVar :: TcTyVar -> Bool
isFmvTyVar :: TcTyVar -> Bool

-- | True of both given and wanted flatten-skolems (fak and usk)
isFlattenTyVar :: TcTyVar -> Bool
isReturnTyVar :: TcTyVar -> Bool
isAmbiguousTyVar :: TcTyVar -> Bool
metaTvRef :: TyVar -> IORef MetaDetails
metaTyVarInfo :: TcTyVar -> MetaInfo
isFlexi :: MetaDetails -> Bool
isIndirect :: MetaDetails -> Bool
isRuntimeUnkSkol :: TyVar -> Bool
isTypeVar :: Var -> Bool
isKindVar :: Var -> Bool
metaTyVarTcLevel :: TcTyVar -> TcLevel
setMetaTyVarTcLevel :: TcTyVar -> TcLevel -> TcTyVar
metaTyVarTcLevel_maybe :: TcTyVar -> Maybe TcLevel
isTouchableMetaTyVar :: TcLevel -> TcTyVar -> Bool
isTouchableOrFmv :: TcLevel -> TcTyVar -> Bool
isFloatedTouchableMetaTyVar :: TcLevel -> TcTyVar -> Bool
canUnifyWithPolyType :: DynFlags -> TcTyVarDetails -> TcKind -> Bool
mkPhiTy :: [PredType] -> Type -> Type
mkSigmaTy :: [TyVar] -> [PredType] -> Type -> Type
mkTcEqPred :: TcType -> TcType -> Type

-- | Make a representational equality predicate
mkTcReprEqPred :: TcType -> TcType -> Type

-- | Make an equality predicate at a given role. The role must not be
--   Phantom.
mkTcEqPredRole :: Role -> TcType -> TcType -> Type

-- | Similar to <a>coreView</a>, but for the type checker, which just looks
--   through synonyms
tcView :: Type -> Maybe Type
tcSplitForAllTys :: Type -> ([TyVar], Type)
tcSplitPhiTy :: Type -> (ThetaType, Type)
tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)
tcSplitFunTy_maybe :: Type -> Maybe (Type, Type)
tcSplitFunTys :: Type -> ([Type], Type)
tcFunArgTy :: Type -> Type
tcFunResultTy :: Type -> Type
tcSplitFunTysN :: TcRhoType -> Arity -> ([TcSigmaType], TcSigmaType)
tcSplitTyConApp :: Type -> (TyCon, [Type])
tcSplitTyConApp_maybe :: Type -> Maybe (TyCon, [Type])
tcTyConAppTyCon :: Type -> TyCon
tcTyConAppArgs :: Type -> [Type]
tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)
tcSplitAppTy :: Type -> (Type, Type)
tcSplitAppTys :: Type -> (Type, [Type])

-- | Does the AppTy split as in <a>splitAppTy_maybe</a>, but assumes that
--   any Core view stuff is already done
repSplitAppTy_maybe :: Type -> Maybe (Type, Type)
tcInstHeadTyNotSynonym :: Type -> Bool
tcInstHeadTyAppAllTyVars :: Type -> Bool
tcGetTyVar_maybe :: Type -> Maybe TyVar
tcGetTyVar :: String -> Type -> TyVar

-- | What is the role assigned to the next parameter of this type? Usually,
--   this will be <a>Nominal</a>, but if the type is a <a>TyConApp</a>, we
--   may be able to do better. The type does *not* have to be well-kinded
--   when applied for this to work!
nextRole :: Type -> Role
tcSplitSigmaTy :: Type -> ([TyVar], ThetaType, Type)
tcDeepSplitSigmaTy_maybe :: TcSigmaType -> Maybe ([TcType], [TyVar], ThetaType, TcSigmaType)

-- | Type equality on source types. Does not look through <tt>newtypes</tt>
--   or <a>PredType</a>s, but it does look through type synonyms. Watch out
--   for horrible hack: See Note [Comparison with OpenTypeKind]
eqType :: Type -> Type -> Bool
eqTypes :: [Type] -> [Type] -> Bool
eqPred :: PredType -> PredType -> Bool
cmpType :: Type -> Type -> Ordering
cmpTypes :: [Type] -> [Type] -> Ordering
cmpPred :: PredType -> PredType -> Ordering
eqTypeX :: RnEnv2 -> Type -> Type -> Bool
pickyEqType :: TcType -> TcType -> Bool
tcEqType :: TcType -> TcType -> Bool
tcEqKind :: TcKind -> TcKind -> Bool
isSigmaTy :: TcType -> Bool
isRhoTy :: TcType -> Bool
isOverloadedTy :: Type -> Bool
isDoubleTy :: Type -> Bool
isFloatTy :: Type -> Bool
isIntTy :: Type -> Bool
isWordTy :: Type -> Bool
isStringTy :: Type -> Bool
isIntegerTy :: Type -> Bool
isBoolTy :: Type -> Bool
isUnitTy :: Type -> Bool
isCharTy :: Type -> Bool
isTauTy :: Type -> Bool
isTauTyCon :: TyCon -> Bool
tcIsTyVarTy :: Type -> Bool
tcIsForAllTy :: Type -> Bool
isPredTy :: Type -> Bool
isTyVarClassPred :: PredType -> Bool

-- | Does the given tyvar appear in the given type outside of any
--   non-newtypes? Assume we're looking for <tt>a</tt>. Says "yes" for
--   <tt>a</tt>, <tt>N a</tt>, <tt>b a</tt>, <tt>a b</tt>, <tt>b (N
--   a)</tt>. Says "no" for <tt>[a]</tt>, <tt>Maybe a</tt>, <tt>T a</tt>,
--   where <tt>N</tt> is a newtype and <tt>T</tt> is a datatype.
isTyVarExposed :: TcTyVar -> TcType -> Bool
deNoteType :: Type -> Type
occurCheckExpand :: DynFlags -> TcTyVar -> Type -> OccCheckResult Type
data OccCheckResult a
[OC_OK] :: a -> OccCheckResult a
[OC_Forall] :: OccCheckResult a
[OC_NonTyVar] :: OccCheckResult a
[OC_Occurs] :: OccCheckResult a
orphNamesOfType :: Type -> NameSet
orphNamesOfDFunHead :: Type -> NameSet
orphNamesOfCo :: Coercion -> NameSet
orphNamesOfTypes :: [Type] -> NameSet
orphNamesOfCoCon :: CoAxiom br -> NameSet
getDFunTyKey :: Type -> OccName
evVarPred_maybe :: EvVar -> Maybe PredType
evVarPred :: EvVar -> PredType
mkMinimalBySCs :: [PredType] -> [PredType]
transSuperClasses :: Class -> [Type] -> [PredType]
immSuperClasses :: Class -> [Type] -> [PredType]

-- | Finds outermost type-family applications occuring in a type, after
--   expanding synonyms.
tcTyFamInsts :: Type -> [(TyCon, [Type])]
exactTyVarsOfType :: Type -> TyVarSet
exactTyVarsOfTypes :: [Type] -> TyVarSet
isFFIArgumentTy :: DynFlags -> Safety -> Type -> Validity
isFFIImportResultTy :: DynFlags -> Type -> Validity
isFFIExportResultTy :: Type -> Validity
isFFIExternalTy :: Type -> Validity
isFFIDynTy :: Type -> Type -> Validity
isFFIPrimArgumentTy :: DynFlags -> Type -> Validity
isFFIPrimResultTy :: DynFlags -> Type -> Validity
isFFILabelTy :: Type -> Validity
isFFITy :: Type -> Bool
isFunPtrTy :: Type -> Bool
tcSplitIOType_maybe :: Type -> Maybe (TyCon, Type)

-- | The key type representing kinds in the compiler. Invariant: a kind is
--   always in one of these forms:
--   
--   <pre>
--   FunTy k1 k2
--   TyConApp PrimTyCon [...]
--   TyVar kv   -- (during inference only)
--   ForAll ... -- (for top-level coercions)
--   </pre>
type Kind = Type
typeKind :: Type -> Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
unliftedTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
liftedTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
openTypeKind :: Kind

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
constraintKind :: Kind

-- | Given two kinds <tt>k1</tt> and <tt>k2</tt>, creates the <a>Kind</a>
--   <tt>k1 -&gt; k2</tt>
mkArrowKind :: Kind -> Kind -> Kind

-- | Iterated application of <a>mkArrowKind</a>
mkArrowKinds :: [Kind] -> Kind -> Kind
isLiftedTypeKind :: Kind -> Bool

-- | See <a>Type#kind_subtyping</a> for details of the distinction between
--   these <a>Kind</a>s
isUnliftedTypeKind :: Kind -> Bool

-- | True of any sub-kind of OpenTypeKind
isSubOpenTypeKind :: Kind -> Bool
tcIsSubKind :: Kind -> Kind -> Bool

-- | Essentially <tt>splitFunTys</tt> on kinds
splitKindFunTys :: Kind -> ([Kind], Kind)
defaultKind :: Kind -> Kind

-- | The key representation of types within the compiler
data Type

-- | A type of the form <tt>p</tt> of kind <tt>Constraint</tt> represents a
--   value whose type is the Haskell predicate <tt>p</tt>, where a
--   predicate is what occurs before the <tt>=&gt;</tt> in a Haskell type.
--   
--   We use <a>PredType</a> as documentation to mark those types that we
--   guarantee to have this kind.
--   
--   It can be expanded into its representation, but:
--   
--   <ul>
--   <li>The type checker must treat it as opaque</li>
--   <li>The rest of the compiler treats it as transparent</li>
--   </ul>
--   
--   Consider these examples:
--   
--   <pre>
--   f :: (Eq a) =&gt; a -&gt; Int
--   g :: (?x :: Int -&gt; Int) =&gt; a -&gt; Int
--   h :: (r\l) =&gt; {r} =&gt; {l::Int | r}
--   </pre>
--   
--   Here the <tt>Eq a</tt> and <tt>?x :: Int -&gt; Int</tt> and
--   <tt>rl</tt> are all called "predicates"
type PredType = Type

-- | A collection of <a>PredType</a>s
type ThetaType = [PredType]
mkForAllTy :: TyVar -> Type -> Type

-- | Wraps foralls over the type using the provided <a>TyVar</a>s from left
--   to right
mkForAllTys :: [TyVar] -> Type -> Type

-- | Creates a function type from the given argument and result type
mkFunTy :: Type -> Type -> Type
mkFunTys :: [Type] -> Type -> Type

-- | Splits off argument types from the given type and associating them
--   with the things in the input list from left to right. The final result
--   type is returned, along with the resulting pairs of objects and types,
--   albeit with the list of pairs in reverse order. Panics if there are
--   not enough argument types for the input list.
zipFunTys :: Outputable a => [a] -> Type -> ([(a, Type)], Type)

-- | A key function: builds a <a>TyConApp</a> or <a>FunTy</a> as
--   appropriate to its arguments. Applies its arguments to the constructor
--   from left to right.
mkTyConApp :: TyCon -> [Type] -> Type

-- | Applies a type to another, as in e.g. <tt>k a</tt>
mkAppTy :: Type -> Type -> Type
mkAppTys :: Type -> [Type] -> Type

-- | Instantiate a forall type with one or more type arguments. Used when
--   we have a polymorphic function applied to type args:
--   
--   <pre>
--   f t1 t2
--   </pre>
--   
--   We use <tt>applyTys type-of-f [t1,t2]</tt> to compute the type of the
--   expression. Panics if no application is possible.
applyTy :: Type -> KindOrType -> Type

-- | This function is interesting because:
--   
--   <ol>
--   <li>The function may have more for-alls than there are
--   args<ol><li>Less obviously, it may have fewer for-alls</li></ol></li>
--   </ol>
--   
--   For case 2. think of:
--   
--   <pre>
--   applyTys (forall a.a) [forall b.b, Int]
--   </pre>
--   
--   This really can happen, but only (I think) in situations involving
--   undefined. For example: undefined :: forall a. a Term: undefined
--   <tt>(forall b. b-&gt;b) </tt>Int This term should have type (Int -&gt;
--   Int), but notice that there are more type args than foralls in
--   <a>undefined</a>s type.
applyTys :: Type -> [KindOrType] -> Type
mkTyVarTy :: TyVar -> Type
mkTyVarTys :: [TyVar] -> [Type]

-- | Create the plain type constructor type which has been applied to no
--   type arguments at all.
mkTyConTy :: TyCon -> Type
isClassPred :: PredType -> Bool
isEqPred :: PredType -> Bool
isIPPred :: PredType -> Bool
mkClassPred :: Class -> [Type] -> PredType
isDictLikeTy :: Type -> Bool
tcSplitDFunTy :: Type -> ([TyVar], [Type], Class, [Type])
tcSplitDFunHead :: Type -> (Class, [Type])

-- | Creates a type equality predicate
mkEqPred :: Type -> Type -> PredType

-- | Type substitution
--   
--   The following invariants must hold of a <a>TvSubst</a>:
--   
--   <ol>
--   <li>The in-scope set is needed <i>only</i> to guide the generation of
--   fresh uniques</li>
--   <li>In particular, the <i>kind</i> of the type variables in the
--   in-scope set is not relevant</li>
--   <li>The substitution is only applied ONCE! This is because in general
--   such application will not reached a fixed point.</li>
--   </ol>
data TvSubst
[TvSubst] :: InScopeSet -> TvSubstEnv -> TvSubst

-- | A substitution of <a>Type</a>s for <a>TyVar</a>s and <a>Kind</a>s for
--   <a>KindVar</a>s
type TvSubstEnv = TyVarEnv Type
emptyTvSubst :: TvSubst

-- | Generates the in-scope set for the <a>TvSubst</a> from the types in
--   the incoming environment, hence "open"
mkOpenTvSubst :: TvSubstEnv -> TvSubst

-- | Generates the in-scope set for the <a>TvSubst</a> from the types in
--   the incoming environment, hence "open"
zipOpenTvSubst :: [TyVar] -> [Type] -> TvSubst
zipTopTvSubst :: [TyVar] -> [Type] -> TvSubst

-- | Called when doing top-level substitutions. Here we expect that the
--   free vars of the range of the substitution will be empty.
mkTopTvSubst :: [(TyVar, Type)] -> TvSubst
notElemTvSubst :: CoVar -> TvSubst -> Bool
unionTvSubst :: TvSubst -> TvSubst -> TvSubst
getTvSubstEnv :: TvSubst -> TvSubstEnv
setTvSubstEnv :: TvSubst -> TvSubstEnv -> TvSubst
getTvInScope :: TvSubst -> InScopeSet
extendTvInScope :: TvSubst -> Var -> TvSubst
lookupTyVar :: TvSubst -> TyVar -> Maybe Type
extendTvSubst :: TvSubst -> TyVar -> Type -> TvSubst
substTyVarBndr :: TvSubst -> TyVar -> (TvSubst, TyVar)
extendTvSubstList :: TvSubst -> [TyVar] -> [Type] -> TvSubst
isInScope :: Var -> TvSubst -> Bool
mkTvSubst :: InScopeSet -> TvSubstEnv -> TvSubst
zipTyEnv :: [TyVar] -> [Type] -> TvSubstEnv

-- | Substitute within a <a>Type</a>
substTy :: TvSubst -> Type -> Type

-- | Substitute within several <a>Type</a>s
substTys :: TvSubst -> [Type] -> [Type]

-- | Type substitution making use of an <a>TvSubst</a> that is assumed to
--   be open, see <a>zipOpenTvSubst</a>
substTyWith :: [TyVar] -> [Type] -> Type -> Type

-- | Substitute within a <a>ThetaType</a>
substTheta :: TvSubst -> ThetaType -> ThetaType
substTyVar :: TvSubst -> TyVar -> Type
substTyVars :: TvSubst -> [TyVar] -> [Type]

-- | See <a>Type#type_classification</a> for what an unlifted type is
isUnLiftedType :: Type -> Bool
isUnboxedTupleType :: Type -> Bool

-- | Returns true of types that are opaque to Haskell.
isPrimitiveType :: Type -> Bool

-- | NB: for type synonyms tyVarsOfType does <i>not</i> expand the synonym
--   tyVarsOfType returns only the free variables of a type For example,
--   tyVarsOfType (a::k) returns {a}, not including the kind variable {k}
tyVarsOfType :: Type -> VarSet
tyVarsOfTypes :: [Type] -> TyVarSet
closeOverKinds :: TyVarSet -> TyVarSet
tcTyVarsOfType :: Type -> TcTyVarSet
tcTyVarsOfTypes :: [Type] -> TyVarSet
pprKind :: Kind -> SDoc
pprParendKind :: Kind -> SDoc
pprSigmaType :: Type -> SDoc
pprType :: Type -> SDoc
pprParendType :: Type -> SDoc
pprTypeApp :: TyCon -> [Type] -> SDoc
pprTyThingCategory :: TyThing -> SDoc
pprTheta :: ThetaType -> SDoc
pprThetaArrowTy :: ThetaType -> SDoc
pprClassPred :: Class -> [Type] -> SDoc
instance Eq TcLevel
instance Outputable MetaDetails
instance Outputable TcLevel
instance Functor OccCheckResult
instance Applicative OccCheckResult
instance Monad OccCheckResult

module StgCmmClosure
type DynTag = Int
tagForCon :: DynFlags -> DataCon -> DynTag
isSmallFamily :: DynFlags -> Int -> Bool
type ConTagZ = Int
dataConTagZ :: DataCon -> ConTagZ
idPrimRep :: Id -> PrimRep
isVoidRep :: PrimRep -> Bool
isGcPtrRep :: PrimRep -> Bool
addIdReps :: [Id] -> [(PrimRep, Id)]
addArgReps :: [StgArg] -> [(PrimRep, StgArg)]
argPrimRep :: StgArg -> PrimRep
data LambdaFormInfo
data StandardFormInfo
mkLFThunk :: Type -> TopLevelFlag -> [Id] -> UpdateFlag -> LambdaFormInfo
mkLFReEntrant :: TopLevelFlag -> [Id] -> [Id] -> ArgDescr -> LambdaFormInfo
mkConLFInfo :: DataCon -> LambdaFormInfo
mkSelectorLFInfo :: Id -> Int -> Bool -> LambdaFormInfo
mkApLFInfo :: Id -> UpdateFlag -> Arity -> LambdaFormInfo
mkLFImported :: Id -> LambdaFormInfo
mkLFArgument :: Id -> LambdaFormInfo
mkLFLetNoEscape :: LambdaFormInfo
lfDynTag :: DynFlags -> LambdaFormInfo -> DynTag
maybeIsLFCon :: LambdaFormInfo -> Maybe DataCon
isLFThunk :: LambdaFormInfo -> Bool
isLFReEntrant :: LambdaFormInfo -> Bool
lfUpdatable :: LambdaFormInfo -> Bool
data CgLoc
[CmmLoc] :: CmmExpr -> CgLoc
[LneLoc] :: BlockId -> [LocalReg] -> CgLoc
type SelfLoopInfo = (Id, BlockId, [LocalReg])
data CallMethod
[EnterIt] :: CallMethod
[JumpToIt] :: BlockId -> [LocalReg] -> CallMethod
[ReturnIt] :: CallMethod
[SlowCall] :: CallMethod
[DirectEntry] :: CLabel -> RepArity -> CallMethod
nodeMustPointToIt :: DynFlags -> LambdaFormInfo -> Bool
isKnownFun :: LambdaFormInfo -> Bool
funTag :: DynFlags -> ClosureInfo -> DynTag
tagForArity :: DynFlags -> RepArity -> DynTag
getCallMethod :: DynFlags -> Name -> Id -> LambdaFormInfo -> RepArity -> CgLoc -> Maybe SelfLoopInfo -> CallMethod
data ClosureInfo
mkClosureInfo :: DynFlags -> Bool -> Id -> LambdaFormInfo -> Int -> Int -> String -> ClosureInfo

-- | Convert from <a>ClosureInfo</a> to <a>CmmInfoTable</a>.
mkCmmInfo :: ClosureInfo -> CmmInfoTable
closureLFInfo :: ClosureInfo -> LambdaFormInfo
closureName :: ClosureInfo -> Name
closureInfoLabel :: ClosureInfo -> CLabel
staticClosureLabel :: ClosureInfo -> CLabel
closureSlowEntryLabel :: ClosureInfo -> CLabel
closureLocalEntryLabel :: DynFlags -> ClosureInfo -> CLabel
closureUpdReqd :: ClosureInfo -> Bool
closureSingleEntry :: ClosureInfo -> Bool
closureReEntrant :: ClosureInfo -> Bool
closureFunInfo :: ClosureInfo -> Maybe (RepArity, ArgDescr)
isToplevClosure :: ClosureInfo -> Bool
blackHoleOnEntry :: ClosureInfo -> Bool
isStaticClosure :: ClosureInfo -> Bool
mkDataConInfoTable :: DynFlags -> DataCon -> Bool -> Int -> Int -> CmmInfoTable
cafBlackHoleInfoTable :: CmmInfoTable
indStaticInfoTable :: CmmInfoTable
staticClosureNeedsLink :: Bool -> CmmInfoTable -> Bool
instance Outputable CgLoc

module StgCmmMonad
data FCode a
initC :: IO CgState
runC :: DynFlags -> Module -> CgState -> FCode a -> (a, CgState)
thenC :: FCode () -> FCode a -> FCode a
thenFC :: FCode a -> (a -> FCode c) -> FCode c
listCs :: [FCode ()] -> FCode ()
returnFC :: a -> FCode a
fixC :: (a -> FCode a) -> FCode a
newUnique :: FCode Unique
newUniqSupply :: FCode UniqSupply
newLabelC :: FCode BlockId
emitLabel :: BlockId -> FCode ()
emit :: CmmAGraph -> FCode ()
emitDecl :: CmmDecl -> FCode ()
emitProc :: Maybe CmmInfoTable -> CLabel -> [GlobalReg] -> CmmAGraphScoped -> Int -> FCode ()
emitProcWithConvention :: Convention -> Maybe CmmInfoTable -> CLabel -> [CmmFormal] -> CmmAGraphScoped -> FCode ()
emitProcWithStackFrame :: Convention -> Maybe CmmInfoTable -> CLabel -> [CmmFormal] -> [CmmFormal] -> CmmAGraphScoped -> Bool -> FCode ()
emitOutOfLine :: BlockId -> CmmAGraphScoped -> FCode ()
emitAssign :: CmmReg -> CmmExpr -> FCode ()
emitStore :: CmmExpr -> CmmExpr -> FCode ()
emitComment :: FastString -> FCode ()
emitTick :: CmmTickish -> FCode ()
emitUnwind :: GlobalReg -> CmmExpr -> FCode ()
getCmm :: FCode () -> FCode CmmGroup
aGraphToGraph :: CmmAGraphScoped -> FCode CmmGraph
getCodeR :: FCode a -> FCode (a, CmmAGraph)
getCode :: FCode a -> FCode CmmAGraph

-- | Generate code into a fresh tick (sub-)scope and gather generated code
getCodeScoped :: FCode a -> FCode (a, CmmAGraphScoped)
getHeapUsage :: (VirtualHpOffset -> FCode a) -> FCode a
mkCmmIfThenElse :: CmmExpr -> CmmAGraph -> CmmAGraph -> FCode CmmAGraph
mkCmmIfThen :: CmmExpr -> CmmAGraph -> FCode CmmAGraph
mkCmmIfGoto :: CmmExpr -> BlockId -> FCode CmmAGraph
mkCall :: CmmExpr -> (Convention, Convention) -> [CmmFormal] -> [CmmActual] -> UpdFrameOffset -> [CmmActual] -> FCode CmmAGraph
mkCmmCall :: CmmExpr -> [CmmFormal] -> [CmmActual] -> UpdFrameOffset -> FCode CmmAGraph
forkClosureBody :: FCode () -> FCode ()
forkLneBody :: FCode a -> FCode a
forkAlts :: [FCode a] -> FCode [a]
codeOnly :: FCode () -> FCode ()
type ConTagZ = Int
data Sequel
[Return] :: Bool -> Sequel
[AssignTo] :: [LocalReg] -> Bool -> Sequel
data ReturnKind
[AssignedDirectly] :: ReturnKind
[ReturnedTo] :: BlockId -> ByteOff -> ReturnKind
withSequel :: Sequel -> FCode a -> FCode a
getSequel :: FCode Sequel
setTickyCtrLabel :: CLabel -> FCode a -> FCode a
getTickyCtrLabel :: FCode CLabel

-- | Places blocks generated by the given code into a fresh (sub-)scope.
--   This will make sure that Cmm annotations in our scope will apply to
--   the Cmm blocks generated therein - but not the other way around.
tickScope :: FCode a -> FCode a

-- | The current tick scope. We will assign this to generated blocks.
getTickScope :: FCode CmmTickScope
withUpdFrameOff :: UpdFrameOffset -> FCode a -> FCode a
getUpdFrameOff :: FCode UpdFrameOffset
initUpdFrameOff :: DynFlags -> UpdFrameOffset
data HeapUsage
[HeapUsage] :: VirtualHpOffset -> VirtualHpOffset -> HeapUsage
[virtHp] :: HeapUsage -> VirtualHpOffset
[realHp] :: HeapUsage -> VirtualHpOffset
type VirtualHpOffset = WordOff
initHpUsage :: HeapUsage
getHpUsage :: FCode HeapUsage
setHpUsage :: HeapUsage -> FCode ()
heapHWM :: HeapUsage -> VirtualHpOffset
setVirtHp :: VirtualHpOffset -> FCode ()
getVirtHp :: FCode VirtualHpOffset
setRealHp :: VirtualHpOffset -> FCode ()
getModuleName :: FCode Module
getState :: FCode CgState
setState :: CgState -> FCode ()
getSelfLoop :: FCode (Maybe SelfLoopInfo)
withSelfLoop :: SelfLoopInfo -> FCode a -> FCode a
getInfoDown :: FCode CgInfoDownwards
getDynFlags :: HasDynFlags m => m DynFlags
getThisPackage :: FCode PackageKey
data CgIdInfo
[CgIdInfo] :: Id -> LambdaFormInfo -> CgLoc -> CgIdInfo
[cg_id] :: CgIdInfo -> Id
[cg_lf] :: CgIdInfo -> LambdaFormInfo
[cg_loc] :: CgIdInfo -> CgLoc
getBinds :: FCode CgBindings
setBinds :: CgBindings -> FCode ()
data CgInfoDownwards
[MkCgInfoDown] :: DynFlags -> Module -> UpdFrameOffset -> CLabel -> Sequel -> Maybe SelfLoopInfo -> CmmTickScope -> CgInfoDownwards
[cgd_dflags] :: CgInfoDownwards -> DynFlags
[cgd_mod] :: CgInfoDownwards -> Module
[cgd_updfr_off] :: CgInfoDownwards -> UpdFrameOffset
[cgd_ticky] :: CgInfoDownwards -> CLabel
[cgd_sequel] :: CgInfoDownwards -> Sequel
[cgd_self_loop] :: CgInfoDownwards -> Maybe SelfLoopInfo
[cgd_tick_scope] :: CgInfoDownwards -> CmmTickScope
data CgState
[MkCgState] :: CmmAGraph -> OrdList CmmDecl -> CgBindings -> HeapUsage -> UniqSupply -> CgState
[cgs_stmts] :: CgState -> CmmAGraph
[cgs_tops] :: CgState -> OrdList CmmDecl
[cgs_binds] :: CgState -> CgBindings
[cgs_hp_usg] :: CgState -> HeapUsage
[cgs_uniqs] :: CgState -> UniqSupply
instance Functor FCode
instance Applicative FCode
instance Monad FCode
instance Outputable CgIdInfo
instance HasDynFlags FCode


-- | Our extended FCode monad.
module StgCmmExtCode

-- | Does a computation in the FCode monad, with a current environment and
--   a list of local declarations. Returns the resulting list of
--   declarations.
data CmmParse a
unEC :: CmmParse a -> String -> Env -> Decls -> FCode (Decls, a)

-- | The environment contains variable definitions or blockids.
data Named

-- | Holds CmmLit(CmmLabel ..) which gives the label type, eg, RtsLabel,
--   ForeignLabel, CmmLabel etc.
[VarN] :: CmmExpr -> Named

-- | A function name from this package
[FunN] :: PackageKey -> Named

-- | A blockid of some code or data.
[LabelN] :: BlockId -> Named

-- | An environment of named things.
type Env = UniqFM Named

-- | Takes the variable decarations and imports from the monad and makes an
--   environment, which is looped back into the computation. In this way,
--   we can have embedded declarations that scope over the whole procedure,
--   and imports that scope over the entire module. Discards the local
--   declaration contained within decl'
loopDecls :: CmmParse a -> CmmParse a

-- | Get the current environment from the monad.
getEnv :: CmmParse Env

-- | Set context name for a sub-parse
withName :: String -> CmmParse a -> CmmParse a

-- | Get the current context name from the monad
getName :: CmmParse String

-- | Create a fresh local variable of a given type.
newLocal :: CmmType -> FastString -> CmmParse LocalReg

-- | Allocate a fresh label.
newLabel :: FastString -> CmmParse BlockId
newBlockId :: CmmParse BlockId

-- | Add add a local function to the environment.
newFunctionName :: FastString -> PackageKey -> ExtCode

-- | Add an imported foreign label to the list of local declarations. If
--   this is done at the start of the module the declaration will scope
--   over the whole module.
newImport :: (FastString, CLabel) -> CmmParse ()

-- | Lookup the BlockId bound to the label with this name. If one hasn't
--   been bound yet, create a fresh one based on the Unique of the name.
lookupLabel :: FastString -> CmmParse BlockId

-- | Lookup the location of a named variable. Unknown names are treated as
--   if they had been 'import'ed from the runtime system. This saves us a
--   lot of bother in the RTS sources, at the expense of deferring some
--   errors to link time.
lookupName :: FastString -> CmmParse CmmExpr

-- | Lift an FCode computation into the CmmParse monad
code :: FCode a -> CmmParse a
emit :: CmmAGraph -> CmmParse ()
emitLabel :: BlockId -> CmmParse ()
emitAssign :: CmmReg -> CmmExpr -> CmmParse ()
emitStore :: CmmExpr -> CmmExpr -> CmmParse ()
getCode :: CmmParse a -> CmmParse CmmAGraph
getCodeR :: CmmParse a -> CmmParse (a, CmmAGraph)
getCodeScoped :: CmmParse a -> CmmParse (a, CmmAGraphScoped)
emitOutOfLine :: BlockId -> CmmAGraphScoped -> CmmParse ()
withUpdFrameOff :: UpdFrameOffset -> CmmParse () -> CmmParse ()
getUpdFrameOff :: CmmParse UpdFrameOffset
instance Functor CmmParse
instance Applicative CmmParse
instance Monad CmmParse
instance HasDynFlags CmmParse

module StgCmmUtils
cgLit :: Literal -> FCode CmmLit
mkSimpleLit :: DynFlags -> Literal -> CmmLit
emitDataLits :: CLabel -> [CmmLit] -> FCode ()
mkDataLits :: Section -> CLabel -> [CmmLit] -> GenCmmDecl CmmStatics info stmt
emitRODataLits :: CLabel -> [CmmLit] -> FCode ()
mkRODataLits :: CLabel -> [CmmLit] -> GenCmmDecl CmmStatics info stmt
emitRtsCall :: PackageKey -> FastString -> [(CmmExpr, ForeignHint)] -> Bool -> FCode ()
emitRtsCallWithResult :: LocalReg -> ForeignHint -> PackageKey -> FastString -> [(CmmExpr, ForeignHint)] -> Bool -> FCode ()
emitRtsCallGen :: [(LocalReg, ForeignHint)] -> CLabel -> [(CmmExpr, ForeignHint)] -> Bool -> FCode ()
assignTemp :: CmmExpr -> FCode LocalReg
newTemp :: CmmType -> FCode LocalReg
newUnboxedTupleRegs :: Type -> FCode ([LocalReg], [ForeignHint])
emitMultiAssign :: [LocalReg] -> [CmmExpr] -> FCode ()
emitCmmLitSwitch :: CmmExpr -> [(Literal, CmmAGraphScoped)] -> CmmAGraphScoped -> FCode ()
emitSwitch :: CmmExpr -> [(ConTagZ, CmmAGraphScoped)] -> Maybe CmmAGraphScoped -> ConTagZ -> ConTagZ -> FCode ()
tagToClosure :: DynFlags -> TyCon -> CmmExpr -> CmmExpr
mkTaggedObjectLoad :: DynFlags -> LocalReg -> LocalReg -> ByteOff -> DynTag -> CmmAGraph

-- | Returns <a>True</a> if this global register is stored in a
--   caller-saves machine register.
callerSaves :: Platform -> GlobalReg -> Bool
callerSaveVolatileRegs :: DynFlags -> (CmmAGraph, CmmAGraph)
get_GlobalReg_addr :: DynFlags -> GlobalReg -> CmmExpr
cmmAndWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmOrWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmNegate :: DynFlags -> CmmExpr -> CmmExpr
cmmEqWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmNeWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmUGtWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmSubWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmMulWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmAddWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmUShrWord :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmOffsetExprW :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmOffsetExprB :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
cmmRegOffW :: DynFlags -> CmmReg -> WordOff -> CmmExpr
cmmRegOffB :: CmmReg -> ByteOff -> CmmExpr
cmmLabelOffW :: DynFlags -> CLabel -> WordOff -> CmmLit
cmmLabelOffB :: CLabel -> ByteOff -> CmmLit
cmmOffsetW :: DynFlags -> CmmExpr -> WordOff -> CmmExpr
cmmOffsetB :: DynFlags -> CmmExpr -> ByteOff -> CmmExpr
cmmOffsetLitW :: DynFlags -> CmmLit -> WordOff -> CmmLit
cmmOffsetLitB :: CmmLit -> ByteOff -> CmmLit
cmmLoadIndexW :: DynFlags -> CmmExpr -> Int -> CmmType -> CmmExpr
cmmConstrTag1 :: DynFlags -> CmmExpr -> CmmExpr
cmmUntag :: DynFlags -> CmmExpr -> CmmExpr
cmmIsTagged :: DynFlags -> CmmExpr -> CmmExpr
addToMem :: CmmType -> CmmExpr -> Int -> CmmAGraph
addToMemE :: CmmType -> CmmExpr -> CmmExpr -> CmmAGraph
addToMemLblE :: CmmType -> CLabel -> CmmExpr -> CmmAGraph
addToMemLbl :: CmmType -> CLabel -> Int -> CmmAGraph
mkWordCLit :: DynFlags -> Integer -> CmmLit
newStringCLit :: String -> FCode CmmLit
newByteStringCLit :: [Word8] -> FCode CmmLit
blankWord :: DynFlags -> CmmStatic

module StgCmmProf
initCostCentres :: CollectedCCs -> FCode ()
ccType :: DynFlags -> CmmType
ccsType :: DynFlags -> CmmType
mkCCostCentre :: CostCentre -> CmmLit
mkCCostCentreStack :: CostCentreStack -> CmmLit

-- | Profiling header words in a dynamic closure
dynProfHdr :: DynFlags -> CmmExpr -> [CmmExpr]

-- | Record the allocation of a closure. The CmmExpr is the cost centre
--   stack to which to attribute the allocation.
profDynAlloc :: SMRep -> CmmExpr -> FCode ()

-- | Record the allocation of a closure (size is given by a CmmExpr) The
--   size must be in words, because the allocation counter in a CCS counts
--   in words.
profAlloc :: CmmExpr -> CmmExpr -> FCode ()

-- | The profiling header words in a static closure
staticProfHdr :: DynFlags -> CostCentreStack -> [CmmLit]

-- | Initialise the profiling field of an update frame
initUpdFrameProf :: CmmExpr -> FCode ()
enterCostCentreThunk :: CmmExpr -> FCode ()
enterCostCentreFun :: CostCentreStack -> CmmExpr -> FCode ()
costCentreFrom :: DynFlags -> CmmExpr -> CmmExpr
curCCS :: CmmExpr
storeCurCCS :: CmmExpr -> CmmAGraph
emitSetCCC :: CostCentre -> Bool -> Bool -> FCode ()
saveCurrentCostCentre :: FCode (Maybe LocalReg)
restoreCurrentCostCentre :: Maybe LocalReg -> FCode ()
ldvEnter :: CmmExpr -> FCode ()
ldvEnterClosure :: ClosureInfo -> CmmReg -> FCode ()
ldvRecordCreate :: CmmExpr -> FCode ()

module StgCmmEnv
data CgIdInfo
litIdInfo :: DynFlags -> Id -> LambdaFormInfo -> CmmLit -> CgIdInfo
lneIdInfo :: DynFlags -> Id -> [NonVoid Id] -> CgIdInfo
rhsIdInfo :: Id -> LambdaFormInfo -> FCode (CgIdInfo, LocalReg)
mkRhsInit :: DynFlags -> LocalReg -> LambdaFormInfo -> CmmExpr -> CmmAGraph
idInfoToAmode :: CgIdInfo -> CmmExpr
newtype NonVoid a
[NonVoid] :: a -> NonVoid a
unsafe_stripNV :: NonVoid a -> a
nonVoidIds :: [Id] -> [NonVoid Id]
addBindC :: CgIdInfo -> FCode ()
addBindsC :: [CgIdInfo] -> FCode ()
bindArgsToRegs :: [NonVoid Id] -> FCode [LocalReg]
bindToReg :: NonVoid Id -> LambdaFormInfo -> FCode LocalReg
rebindToReg :: NonVoid Id -> FCode LocalReg
bindArgToReg :: NonVoid Id -> FCode LocalReg
idToReg :: DynFlags -> NonVoid Id -> LocalReg
getArgAmode :: NonVoid StgArg -> FCode CmmExpr
getNonVoidArgAmodes :: [StgArg] -> FCode [CmmExpr]
getCgIdInfo :: Id -> FCode CgIdInfo
maybeLetNoEscape :: CgIdInfo -> Maybe (BlockId, [LocalReg])
instance Show a => Show (NonVoid a)
instance Eq a => Eq (NonVoid a)
instance Outputable a => Outputable (NonVoid a)

module StgCmmArgRep
data ArgRep
[P] :: ArgRep
[N] :: ArgRep
[L] :: ArgRep
[V] :: ArgRep
[F] :: ArgRep
[D] :: ArgRep
[V16] :: ArgRep
[V32] :: ArgRep
[V64] :: ArgRep
toArgRep :: PrimRep -> ArgRep
argRepSizeW :: DynFlags -> ArgRep -> WordOff
argRepString :: ArgRep -> String
isNonV :: ArgRep -> Bool
idArgRep :: Id -> ArgRep
slowCallPattern :: [ArgRep] -> (FastString, RepArity)
instance Outputable ArgRep

module StgCmmTicky
withNewTickyCounterFun :: Name -> [NonVoid Id] -> FCode a -> FCode a
withNewTickyCounterLNE :: Name -> [NonVoid Id] -> FCode a -> FCode a
withNewTickyCounterThunk :: Bool -> Name -> FCode a -> FCode a
withNewTickyCounterStdThunk :: Bool -> Name -> FCode a -> FCode a
tickyDynAlloc :: Maybe Id -> SMRep -> LambdaFormInfo -> FCode ()
tickyAllocHeap :: Bool -> VirtualHpOffset -> FCode ()
tickyAllocPrim :: CmmExpr -> CmmExpr -> CmmExpr -> FCode ()
tickyAllocThunk :: CmmExpr -> CmmExpr -> FCode ()
tickyAllocPAP :: CmmExpr -> CmmExpr -> FCode ()
tickyHeapCheck :: FCode ()
tickyStackCheck :: FCode ()
tickyUnknownCall :: FCode ()
tickyDirectCall :: RepArity -> [StgArg] -> FCode ()
tickyPushUpdateFrame :: FCode ()
tickyUpdateFrameOmitted :: FCode ()
tickyEnterDynCon :: FCode ()
tickyEnterStaticCon :: FCode ()
tickyEnterViaNode :: FCode ()
tickyEnterFun :: ClosureInfo -> FCode ()
tickyEnterThunk :: ClosureInfo -> FCode ()
tickyEnterStdThunk :: ClosureInfo -> FCode ()
tickyEnterLNE :: FCode ()
tickyUpdateBhCaf :: ClosureInfo -> FCode ()
tickyBlackHole :: Bool -> FCode ()
tickyUnboxedTupleReturn :: RepArity -> FCode ()
tickyVectoredReturn :: Int -> FCode ()
tickyReturnOldCon :: RepArity -> FCode ()
tickyReturnNewCon :: RepArity -> FCode ()
tickyKnownCallTooFewArgs :: FCode ()
tickyKnownCallExact :: FCode ()
tickyKnownCallExtraArgs :: FCode ()
tickySlowCall :: LambdaFormInfo -> [StgArg] -> FCode ()
tickySlowCallPat :: [PrimRep] -> FCode ()

module StgCmmLayout
mkArgDescr :: DynFlags -> [Id] -> ArgDescr

-- | <tt>emitCall conv fun args</tt> makes a call to the entry-code of
--   <tt>fun</tt>, using the call/return convention <tt>conv</tt>, passing
--   <tt>args</tt>, and returning the results to the current sequel.
emitCall :: (Convention, Convention) -> CmmExpr -> [CmmExpr] -> FCode ReturnKind

-- | Return multiple values to the sequel
--   
--   If the sequel is <tt>Return</tt>
--   
--   <pre>
--   return (x,y)
--   </pre>
--   
--   If the sequel is <tt>AssignTo [p,q]</tt>
--   
--   <pre>
--   p=x; q=y;
--   </pre>
emitReturn :: [CmmExpr] -> FCode ReturnKind
adjustHpBackwards :: FCode ()
emitClosureProcAndInfoTable :: Bool -> Id -> LambdaFormInfo -> CmmInfoTable -> [NonVoid Id] -> ((Int, LocalReg, [LocalReg]) -> FCode ()) -> FCode ()
emitClosureAndInfoTable :: CmmInfoTable -> Convention -> [LocalReg] -> FCode () -> FCode ()
slowCall :: CmmExpr -> [StgArg] -> FCode ReturnKind
directCall :: Convention -> CLabel -> RepArity -> [StgArg] -> FCode ReturnKind
mkVirtHeapOffsets :: DynFlags -> Bool -> [(PrimRep, a)] -> (WordOff, WordOff, [(NonVoid a, ByteOff)])

-- | Just like mkVirtHeapOffsets, but for constructors
mkVirtConstrOffsets :: DynFlags -> [(PrimRep, a)] -> (WordOff, WordOff, [(NonVoid a, ByteOff)])
getHpRelOffset :: VirtualHpOffset -> FCode CmmExpr
data ArgRep
[P] :: ArgRep
[N] :: ArgRep
[L] :: ArgRep
[V] :: ArgRep
[F] :: ArgRep
[D] :: ArgRep
[V16] :: ArgRep
[V32] :: ArgRep
[V64] :: ArgRep
toArgRep :: PrimRep -> ArgRep
argRepSizeW :: DynFlags -> ArgRep -> WordOff

module StgCmmHeap
getVirtHp :: FCode VirtualHpOffset
setVirtHp :: VirtualHpOffset -> FCode ()
setRealHp :: VirtualHpOffset -> FCode ()
getHpRelOffset :: VirtualHpOffset -> FCode CmmExpr
entryHeapCheck :: ClosureInfo -> Maybe LocalReg -> Int -> [LocalReg] -> FCode () -> FCode ()
altHeapCheck :: [LocalReg] -> FCode a -> FCode a
noEscapeHeapCheck :: [LocalReg] -> FCode a -> FCode a
altHeapCheckReturnsTo :: [LocalReg] -> Label -> ByteOff -> FCode a -> FCode a
heapStackCheckGen :: Maybe CmmExpr -> Maybe CmmExpr -> FCode ()

-- | lower-level version for CmmParse
entryHeapCheck' :: Bool -> CmmExpr -> Int -> [LocalReg] -> FCode () -> FCode ()
mkStaticClosureFields :: DynFlags -> CmmInfoTable -> CostCentreStack -> CafInfo -> [CmmLit] -> [CmmLit]
mkStaticClosure :: DynFlags -> CLabel -> CostCentreStack -> [CmmLit] -> [CmmLit] -> [CmmLit] -> [CmmLit] -> [CmmLit]
allocDynClosure :: Maybe Id -> CmmInfoTable -> LambdaFormInfo -> CmmExpr -> CmmExpr -> [(NonVoid StgArg, VirtualHpOffset)] -> FCode CmmExpr
allocDynClosureCmm :: Maybe Id -> CmmInfoTable -> LambdaFormInfo -> CmmExpr -> CmmExpr -> [(CmmExpr, ByteOff)] -> FCode CmmExpr

-- | Low-level heap object allocation.
allocHeapClosure :: SMRep -> CmmExpr -> CmmExpr -> [(CmmExpr, ByteOff)] -> FCode CmmExpr
emitSetDynHdr :: CmmExpr -> CmmExpr -> CmmExpr -> FCode ()

module StgCmmForeign

-- | emit code for a foreign call, and return the results to the sequel.
cgForeignCall :: ForeignCall -> [StgArg] -> Type -> FCode ReturnKind
emitPrimCall :: [CmmFormal] -> CallishMachOp -> [CmmActual] -> FCode ()
emitCCall :: [(CmmFormal, ForeignHint)] -> CmmExpr -> [(CmmActual, ForeignHint)] -> FCode ()
emitForeignCall :: Safety -> [CmmFormal] -> ForeignTarget -> [CmmActual] -> FCode ReturnKind
emitSaveThreadState :: FCode ()
saveThreadState :: DynFlags -> LocalReg -> LocalReg -> CmmAGraph
emitLoadThreadState :: FCode ()
loadThreadState :: DynFlags -> LocalReg -> LocalReg -> LocalReg -> LocalReg -> LocalReg -> CmmAGraph
emitOpenNursery :: FCode ()
emitCloseNursery :: FCode ()

module CmmLayoutStack
cmmLayoutStack :: DynFlags -> ProcPointSet -> ByteOff -> CmmGraph -> UniqSM (CmmGraph, BlockEnv StackMap)
setInfoTableStackMap :: DynFlags -> BlockEnv StackMap -> CmmDecl -> CmmDecl
instance Outputable StackMap
instance Outputable StackSlot


-- | ByteCodeItbls: Generate infotables for interpreter-made bytecodes
module ByteCodeItbls
type ItblEnv = NameEnv (Name, ItblPtr)
newtype ItblPtr
[ItblPtr] :: (Ptr ()) -> ItblPtr
itblCode :: DynFlags -> ItblPtr -> Ptr ()
mkITbls :: DynFlags -> [TyCon] -> IO ItblEnv
peekItbl :: DynFlags -> Ptr StgInfoTable -> IO StgInfoTable
data StgInfoTable
[StgInfoTable] :: Maybe (Ptr ()) -> HalfWord -> HalfWord -> HalfWord -> HalfWord -> Maybe ItblCodes -> StgInfoTable
[entry] :: StgInfoTable -> Maybe (Ptr ())
[ptrs] :: StgInfoTable -> HalfWord
[nptrs] :: StgInfoTable -> HalfWord
[tipe] :: StgInfoTable -> HalfWord
[srtlen] :: StgInfoTable -> HalfWord
[code] :: StgInfoTable -> Maybe ItblCodes
instance Show ItblPtr


-- | ByteCodeInstrs: Bytecode instruction definitions
module ByteCodeInstr
data BCInstr
[STKCHECK] :: Word -> BCInstr
[PUSH_L] :: !Word16 -> BCInstr
[PUSH_LL] :: !Word16 -> !Word16 -> BCInstr
[PUSH_LLL] :: !Word16 -> !Word16 -> !Word16 -> BCInstr
[PUSH_G] :: Name -> BCInstr
[PUSH_PRIMOP] :: PrimOp -> BCInstr
[PUSH_BCO] :: (ProtoBCO Name) -> BCInstr
[PUSH_ALTS] :: (ProtoBCO Name) -> BCInstr
[PUSH_ALTS_UNLIFTED] :: (ProtoBCO Name) -> ArgRep -> BCInstr
[PUSH_UBX] :: (Either Literal (Ptr ())) -> Word16 -> BCInstr
[PUSH_APPLY_N] :: BCInstr
[PUSH_APPLY_V] :: BCInstr
[PUSH_APPLY_F] :: BCInstr
[PUSH_APPLY_D] :: BCInstr
[PUSH_APPLY_L] :: BCInstr
[PUSH_APPLY_P] :: BCInstr
[PUSH_APPLY_PP] :: BCInstr
[PUSH_APPLY_PPP] :: BCInstr
[PUSH_APPLY_PPPP] :: BCInstr
[PUSH_APPLY_PPPPP] :: BCInstr
[PUSH_APPLY_PPPPPP] :: BCInstr
[SLIDE] :: Word16 -> Word16 -> BCInstr
[ALLOC_AP] :: !Word16 -> BCInstr
[ALLOC_AP_NOUPD] :: !Word16 -> BCInstr
[ALLOC_PAP] :: !Word16 -> !Word16 -> BCInstr
[MKAP] :: !Word16 -> !Word16 -> BCInstr
[MKPAP] :: !Word16 -> !Word16 -> BCInstr
[UNPACK] :: !Word16 -> BCInstr
[PACK] :: DataCon -> !Word16 -> BCInstr
[LABEL] :: LocalLabel -> BCInstr
[TESTLT_I] :: Int -> LocalLabel -> BCInstr
[TESTEQ_I] :: Int -> LocalLabel -> BCInstr
[TESTLT_W] :: Word -> LocalLabel -> BCInstr
[TESTEQ_W] :: Word -> LocalLabel -> BCInstr
[TESTLT_F] :: Float -> LocalLabel -> BCInstr
[TESTEQ_F] :: Float -> LocalLabel -> BCInstr
[TESTLT_D] :: Double -> LocalLabel -> BCInstr
[TESTEQ_D] :: Double -> LocalLabel -> BCInstr
[TESTLT_P] :: Word16 -> LocalLabel -> BCInstr
[TESTEQ_P] :: Word16 -> LocalLabel -> BCInstr
[CASEFAIL] :: BCInstr
[JMP] :: LocalLabel -> BCInstr
[CCALL] :: Word16 -> (Ptr ()) -> Word16 -> BCInstr
[SWIZZLE] :: Word16 -> Word16 -> BCInstr
[ENTER] :: BCInstr
[RETURN] :: BCInstr
[RETURN_UBX] :: ArgRep -> BCInstr
[BRK_FUN] :: (MutableByteArray# RealWorld) -> Word16 -> BreakInfo -> BCInstr
data ProtoBCO a
[ProtoBCO] :: a -> [BCInstr] -> [StgWord] -> Word16 -> Int -> Either [AnnAlt Id VarSet] (AnnExpr Id VarSet) -> [Either ItblPtr (Ptr ())] -> ProtoBCO a
[protoBCOName] :: ProtoBCO a -> a
[protoBCOInstrs] :: ProtoBCO a -> [BCInstr]
[protoBCOBitmap] :: ProtoBCO a -> [StgWord]
[protoBCOBitmapSize] :: ProtoBCO a -> Word16
[protoBCOArity] :: ProtoBCO a -> Int
[protoBCOExpr] :: ProtoBCO a -> Either [AnnAlt Id VarSet] (AnnExpr Id VarSet)
[protoBCOPtrs] :: ProtoBCO a -> [Either ItblPtr (Ptr ())]
bciStackUse :: BCInstr -> Word
data BreakInfo
[BreakInfo] :: Module -> {-# UNPACK #-} !Int -> [(Id, Word16)] -> Type -> BreakInfo
[breakInfo_module] :: BreakInfo -> Module
[breakInfo_number] :: BreakInfo -> {-# UNPACK #-} !Int
[breakInfo_vars] :: BreakInfo -> [(Id, Word16)]
[breakInfo_resty] :: BreakInfo -> Type
instance Outputable BreakInfo
instance Outputable a => Outputable (ProtoBCO a)
instance Outputable BCInstr

module InteractiveEvalTypes
data RunResult

-- | names bound by this evaluation
[RunOk] :: [Name] -> RunResult

-- | statement raised an exception
[RunException] :: SomeException -> RunResult
[RunBreak] :: ThreadId -> [Name] -> (Maybe BreakInfo) -> RunResult
data Status

-- | the computation hit a breakpoint (Bool <a>=</a> was an exception)
[Break] :: Bool -> HValue -> BreakInfo -> ThreadId -> Status

-- | the computation completed with either an exception or a value
[Complete] :: (Either SomeException [HValue]) -> Status
data Resume
[Resume] :: String -> ThreadId -> MVar () -> MVar Status -> ([TyThing], GlobalRdrEnv) -> [Id] -> HValue -> Maybe BreakInfo -> SrcSpan -> [History] -> Int -> Resume
[resumeStmt] :: Resume -> String
[resumeThreadId] :: Resume -> ThreadId
[resumeBreakMVar] :: Resume -> MVar ()
[resumeStatMVar] :: Resume -> MVar Status
[resumeBindings] :: Resume -> ([TyThing], GlobalRdrEnv)
[resumeFinalIds] :: Resume -> [Id]
[resumeApStack] :: Resume -> HValue
[resumeBreakInfo] :: Resume -> Maybe BreakInfo
[resumeSpan] :: Resume -> SrcSpan
[resumeHistory] :: Resume -> [History]
[resumeHistoryIx] :: Resume -> Int
data History
[History] :: HValue -> BreakInfo -> [String] -> History
[historyApStack] :: History -> HValue
[historyBreakInfo] :: History -> BreakInfo
[historyEnclosingDecls] :: History -> [String]


-- | ByteCodeLink: Bytecode assembler and linker
module ByteCodeAsm
assembleBCOs :: DynFlags -> [ProtoBCO Name] -> [TyCon] -> IO CompiledByteCode
assembleBCO :: DynFlags -> ProtoBCO Name -> IO UnlinkedBCO
data CompiledByteCode
[ByteCode] :: [UnlinkedBCO] -> ItblEnv -> CompiledByteCode
data UnlinkedBCO
[UnlinkedBCO] :: Name -> Int -> ByteArray# -> ByteArray# -> (SizedSeq BCONPtr) -> (SizedSeq BCOPtr) -> UnlinkedBCO
[unlinkedBCOName] :: UnlinkedBCO -> Name
[unlinkedBCOArity] :: UnlinkedBCO -> Int
[unlinkedBCOInstrs] :: UnlinkedBCO -> ByteArray#
[unlinkedBCOBitmap] :: UnlinkedBCO -> ByteArray#
[unlinkedBCOLits] :: UnlinkedBCO -> (SizedSeq BCONPtr)
[unlinkedBCOPtrs] :: UnlinkedBCO -> (SizedSeq BCOPtr)
data BCOPtr
[BCOPtrName] :: Name -> BCOPtr
[BCOPtrPrimOp] :: PrimOp -> BCOPtr
[BCOPtrBCO] :: UnlinkedBCO -> BCOPtr
[BCOPtrBreakInfo] :: BreakInfo -> BCOPtr
[BCOPtrArray] :: (MutableByteArray# RealWorld) -> BCOPtr
data BCONPtr
[BCONPtrWord] :: Word -> BCONPtr
[BCONPtrLbl] :: FastString -> BCONPtr
[BCONPtrItbl] :: Name -> BCONPtr

-- | Finds external references. Remember to remove the names defined by
--   this group of BCOs themselves
bcoFreeNames :: UnlinkedBCO -> NameSet
data SizedSeq a
sizeSS :: SizedSeq a -> Word
ssElts :: SizedSeq a -> [a]
iNTERP_STACK_CHECK_THRESH :: Int
instance Outputable CompiledByteCode
instance Outputable UnlinkedBCO
instance Functor Assembler
instance Applicative Assembler
instance Monad Assembler


-- | ByteCodeLink: Bytecode assembler and linker
module ByteCodeLink
type ClosureEnv = NameEnv (Name, HValue)
emptyClosureEnv :: ClosureEnv
extendClosureEnv :: ClosureEnv -> [(Name, HValue)] -> ClosureEnv
linkBCO :: DynFlags -> ItblEnv -> ClosureEnv -> UnlinkedBCO -> IO HValue
lookupStaticPtr :: FastString -> IO (Ptr ())
lookupName :: ClosureEnv -> Name -> IO HValue
lookupIE :: DynFlags -> ItblEnv -> Name -> IO (Ptr a)
instance MArray IOArray e IO

module StgCmmPrim
cgOpApp :: StgOp -> [StgArg] -> Type -> FCode ReturnKind
cgPrimOp :: [LocalReg] -> PrimOp -> [StgArg] -> FCode ()

-- | Decide whether an out-of-line primop should be replaced by an inline
--   implementation. This might happen e.g. if there's enough static
--   information, such as statically know arguments, to emit a more
--   efficient implementation inline.
--   
--   Returns <a>Nothing</a> if this primop should use its out-of-line
--   implementation (defined elsewhere) and <a>Just</a> together with a
--   code generating function that takes the output regs as arguments
--   otherwise.
shouldInlinePrimOp :: DynFlags -> PrimOp -> [CmmExpr] -> Maybe ([LocalReg] -> FCode ())


-- | A module concerned with finding the free variables of an expression.
module CoreFVs

-- | Find all locally-defined free Ids or type variables in an expression
exprFreeVars :: CoreExpr -> VarSet

-- | Find all locally-defined free Ids in an expression
exprFreeIds :: CoreExpr -> IdSet

-- | Find all locally-defined free Ids or type variables in several
--   expressions
exprsFreeVars :: [CoreExpr] -> VarSet

-- | Find all locally defined free Ids in a binding group
bindFreeVars :: CoreBind -> VarSet

-- | Predicate on possible free variables: returns <tt>True</tt> iff the
--   variable is interesting
type InterestingVarFun = Var -> Bool

-- | Finds free variables in an expression selected by a predicate
exprSomeFreeVars :: InterestingVarFun -> CoreExpr -> VarSet

-- | Finds free variables in several expressions selected by a predicate
exprsSomeFreeVars :: InterestingVarFun -> [CoreExpr] -> VarSet
varTypeTyVars :: Var -> TyVarSet
idUnfoldingVars :: Id -> VarSet
idFreeVars :: Id -> VarSet
idRuleAndUnfoldingVars :: Id -> VarSet
idRuleVars :: Id -> VarSet
idRuleRhsVars :: (Activation -> Bool) -> Id -> VarSet
stableUnfoldingVars :: Unfolding -> Maybe VarSet

-- | Those variables free in the right hand side of a rule
ruleRhsFreeVars :: CoreRule -> VarSet

-- | Those variables free in the both the left right hand sides of a rule
ruleFreeVars :: CoreRule -> VarSet

-- | Those variables free in the right hand side of several rules
rulesFreeVars :: [CoreRule] -> VarSet

-- | ruleLhsOrphNames is used when deciding whether a rule is an orphan. In
--   particular, suppose that T is defined in this module; we want to avoid
--   declaring that a rule like:
--   
--   <pre>
--   fromIntegral T = fromIntegral_T
--   </pre>
--   
--   is an orphan. Of course it isn't, and declaring it an orphan would
--   make the whole module an orphan module, which is bad.
ruleLhsOrphNames :: CoreRule -> NameSet

-- | This finds all locally-defined free Ids on the left hand side of a
--   rule
ruleLhsFreeIds :: CoreRule -> VarSet

-- | Free variables of a vectorisation declaration
vectsFreeVars :: [CoreVect] -> VarSet

-- | Every node in an expression annotated with its (non-global) free
--   variables, both Ids and TyVars
type CoreExprWithFVs = AnnExpr Id VarSet

-- | Every node in a binding group annotated with its (non-global) free
--   variables, both Ids and TyVars
type CoreBindWithFVs = AnnBind Id VarSet

-- | Annotate a <a>CoreExpr</a> with its (non-global) free type and value
--   variables at every tree node
freeVars :: CoreExpr -> CoreExprWithFVs

-- | Inverse function to <a>freeVars</a>
freeVarsOf :: CoreExprWithFVs -> IdSet


-- | Commonly useful utilites for manipulating the Core language
module CoreUtils

-- | Wrap the given expression in the coercion safely, dropping identity
--   coercions and coalescing nested coercions
mkCast :: CoreExpr -> Coercion -> CoreExpr

-- | Wraps the given expression in the source annotation, dropping the
--   annotation if possible.
mkTick :: Tickish Id -> CoreExpr -> CoreExpr
mkTicks :: [Tickish Id] -> CoreExpr -> CoreExpr
mkTickNoHNF :: Tickish Id -> CoreExpr -> CoreExpr
tickHNFArgs :: Tickish Id -> CoreExpr -> CoreExpr

-- | <tt>bindNonRec x r b</tt> produces either:
--   
--   <pre>
--   let x = r in b
--   </pre>
--   
--   or:
--   
--   <pre>
--   case r of x { _DEFAULT_ -&gt; b }
--   </pre>
--   
--   depending on whether we have to use a <tt>case</tt> or <tt>let</tt>
--   binding for the expression (see <a>needsCaseBinding</a>). It's used by
--   the desugarer to avoid building bindings that give Core Lint a heart
--   attack, although actually the simplifier deals with them perfectly
--   well. See also <a>mkCoreLet</a>
bindNonRec :: Id -> CoreExpr -> CoreExpr -> CoreExpr

-- | Tests whether we have to use a <tt>case</tt> rather than <tt>let</tt>
--   binding for this expression as per the invariants of <a>CoreExpr</a>:
--   see <a>CoreSyn#let_app_invariant</a>
needsCaseBinding :: Type -> CoreExpr -> Bool

-- | This guy constructs the value that the scrutinee must have given that
--   you are in one particular branch of a case
mkAltExpr :: AltCon -> [CoreBndr] -> [Type] -> CoreExpr

-- | Extract the default case alternative
findDefault :: [(AltCon, [a], b)] -> ([(AltCon, [a], b)], Maybe b)

-- | Find the case alternative corresponding to a particular constructor:
--   panics if no such constructor exists
findAlt :: AltCon -> [(AltCon, a, b)] -> Maybe (AltCon, a, b)
isDefaultAlt :: (AltCon, a, b) -> Bool

-- | Merge alternatives preserving order; alternatives in the first
--   argument shadow ones in the second
mergeAlts :: [(AltCon, a, b)] -> [(AltCon, a, b)] -> [(AltCon, a, b)]

-- | Given:
--   
--   <pre>
--   case (C a b x y) of
--          C b x y -&gt; ...
--   </pre>
--   
--   We want to drop the leading type argument of the scrutinee leaving the
--   arguments to match agains the pattern
trimConArgs :: AltCon -> [CoreArg] -> [CoreArg]
filterAlts :: [Unique] -> Type -> [AltCon] -> [(AltCon, [Var], a)] -> ([AltCon], Bool, [(AltCon, [Var], a)])

-- | Recover the type of a well-typed Core expression. Fails when applied
--   to the actual <a>Type</a> expression as it cannot really be said to
--   have a type
exprType :: CoreExpr -> Type

-- | Returns the type of the alternatives right hand side
coreAltType :: CoreAlt -> Type

-- | Returns the type of the first alternative, which should be the same as
--   for all alternatives
coreAltsType :: [CoreAlt] -> Type
exprIsDupable :: DynFlags -> CoreExpr -> Bool
exprIsTrivial :: CoreExpr -> Bool
getIdFromTrivialExpr :: CoreExpr -> Id
exprIsBottom :: CoreExpr -> Bool
exprIsCheap :: CoreExpr -> Bool
exprIsExpandable :: CoreExpr -> Bool
exprIsCheap' :: CheapAppFun -> CoreExpr -> Bool
type CheapAppFun = Id -> Int -> Bool

-- | exprIsHNF returns true for expressions that are certainly
--   <i>already</i> evaluated to <i>head</i> normal form. This is used to
--   decide whether it's ok to change:
--   
--   <pre>
--   case x of _ -&gt; e
--   </pre>
--   
--   into:
--   
--   <pre>
--   e
--   </pre>
--   
--   and to decide whether it's safe to discard a <a>seq</a>.
--   
--   So, it does <i>not</i> treat variables as evaluated, unless they say
--   they are. However, it <i>does</i> treat partial applications and
--   constructor applications as values, even if their arguments are
--   non-trivial, provided the argument type is lifted. For example, both
--   of these are values:
--   
--   <pre>
--   (:) (f x) (map f xs)
--   map (...redex...)
--   </pre>
--   
--   because <a>seq</a> on such things completes immediately.
--   
--   For unlifted argument types, we have to be careful:
--   
--   <pre>
--   C (f x :: Int#)
--   </pre>
--   
--   Suppose <tt>f x</tt> diverges; then <tt>C (f x)</tt> is not a value.
--   However this can't happen: see <a>CoreSyn#let_app_invariant</a>. This
--   invariant states that arguments of unboxed type must be
--   ok-for-speculation (or trivial).
exprIsHNF :: CoreExpr -> Bool

-- | <a>exprOkForSpeculation</a> returns True of an expression that is:
--   
--   <ul>
--   <li>Safe to evaluate even if normal order eval might not evaluate the
--   expression at all, or</li>
--   <li>Safe <i>not</i> to evaluate even if normal order would do so</li>
--   </ul>
--   
--   It is usually called on arguments of unlifted type, but not always In
--   particular, Simplify.rebuildCase calls it on lifted types when a
--   'case' is a plain <a>seq</a>. See the example in Note
--   [exprOkForSpeculation: case expressions] below
--   
--   Precisely, it returns <tt>True</tt> iff: a) The expression guarantees
--   to terminate, b) soon, c) without causing a write side effect (e.g.
--   writing a mutable variable) d) without throwing a Haskell exception e)
--   without risking an unchecked runtime exception (array out of bounds,
--   divide by zero)
--   
--   For <tt>exprOkForSideEffects</tt> the list is the same, but omitting
--   (e).
--   
--   Note that exprIsHNF implies exprOkForSpeculation exprOkForSpeculation
--   implies exprOkForSideEffects
--   
--   See Note [PrimOp can_fail and has_side_effects] in PrimOp and Note
--   [Implementation: how can_fail/has_side_effects affect transformations]
--   
--   As an example of the considerations in this test, consider:
--   
--   <pre>
--   let x = case y# +# 1# of { r# -&gt; I# r# }
--   in E
--   </pre>
--   
--   being translated to:
--   
--   <pre>
--   case y# +# 1# of { r# -&gt;
--      let x = I# r#
--      in E
--   }
--   </pre>
--   
--   We can only do this if the <tt>y + 1</tt> is ok for speculation: it
--   has no side effects, and can't diverge or raise an exception.
exprOkForSpeculation :: Expr b -> Bool

-- | <a>exprOkForSpeculation</a> returns True of an expression that is:
--   
--   <ul>
--   <li>Safe to evaluate even if normal order eval might not evaluate the
--   expression at all, or</li>
--   <li>Safe <i>not</i> to evaluate even if normal order would do so</li>
--   </ul>
--   
--   It is usually called on arguments of unlifted type, but not always In
--   particular, Simplify.rebuildCase calls it on lifted types when a
--   'case' is a plain <a>seq</a>. See the example in Note
--   [exprOkForSpeculation: case expressions] below
--   
--   Precisely, it returns <tt>True</tt> iff: a) The expression guarantees
--   to terminate, b) soon, c) without causing a write side effect (e.g.
--   writing a mutable variable) d) without throwing a Haskell exception e)
--   without risking an unchecked runtime exception (array out of bounds,
--   divide by zero)
--   
--   For <tt>exprOkForSideEffects</tt> the list is the same, but omitting
--   (e).
--   
--   Note that exprIsHNF implies exprOkForSpeculation exprOkForSpeculation
--   implies exprOkForSideEffects
--   
--   See Note [PrimOp can_fail and has_side_effects] in PrimOp and Note
--   [Implementation: how can_fail/has_side_effects affect transformations]
--   
--   As an example of the considerations in this test, consider:
--   
--   <pre>
--   let x = case y# +# 1# of { r# -&gt; I# r# }
--   in E
--   </pre>
--   
--   being translated to:
--   
--   <pre>
--   case y# +# 1# of { r# -&gt;
--      let x = I# r#
--      in E
--   }
--   </pre>
--   
--   We can only do this if the <tt>y + 1</tt> is ok for speculation: it
--   has no side effects, and can't diverge or raise an exception.
exprOkForSideEffects :: Expr b -> Bool
exprIsWorkFree :: CoreExpr -> Bool

-- | Returns <tt>True</tt> of expressions that are too big to be compared
--   by <a>cheapEqExpr</a>
exprIsBig :: Expr b -> Bool

-- | Similar to <a>exprIsHNF</a> but includes CONLIKE functions as well as
--   data constructors. Conlike arguments are considered interesting by the
--   inliner.
exprIsConLike :: CoreExpr -> Bool

-- | This function is called only on *top-level* right-hand sides. Returns
--   <tt>True</tt> if the RHS can be allocated statically in the output,
--   with no thunks involved at all.
rhsIsStatic :: Platform -> (Name -> Bool) -> (Integer -> CoreExpr) -> CoreExpr -> Bool
isCheapApp :: CheapAppFun
isExpandableApp :: CheapAppFun
coreBindsSize :: [CoreBind] -> Int

-- | A measure of the size of the expressions, strictly greater than 0 It
--   also forces the expression pretty drastically as a side effect Counts
--   *leaves*, not internal nodes. Types and coercions are not counted.
exprSize :: CoreExpr -> Int
data CoreStats
[CS] :: Int -> Int -> Int -> CoreStats
[cs_tm] :: CoreStats -> Int
[cs_ty] :: CoreStats -> Int
[cs_co] :: CoreStats -> Int
coreBindsStats :: [CoreBind] -> CoreStats

-- | A cheap equality test which bales out fast! If it returns
--   <tt>True</tt> the arguments are definitely equal, otherwise, they may
--   or may not be equal.
--   
--   See also <a>exprIsBig</a>
cheapEqExpr :: Expr b -> Expr b -> Bool

-- | Cheap expression equality test, can ignore ticks by type.
cheapEqExpr' :: (Tickish Id -> Bool) -> Expr b -> Expr b -> Bool
eqExpr :: InScopeSet -> CoreExpr -> CoreExpr -> Bool

-- | Finds differences between core expressions, modulo alpha and renaming.
--   Setting <tt>top</tt> means that the <tt>IdInfo</tt> of bindings will
--   be checked for differences as well.
diffExpr :: Bool -> RnEnv2 -> CoreExpr -> CoreExpr -> [SDoc]

-- | Finds differences between core bindings, see <tt>diffExpr</tt>.
--   
--   The main problem here is that while we expect the binds to have the
--   same order in both lists, this is not guaranteed. To do this properly
--   we'd either have to do some sort of unification or check all possible
--   mappings, which would be seriously expensive. So instead we simply
--   match single bindings as far as we can. This leaves us just with
--   mutually recursive and/or mismatching bindings, which we then
--   specuatively match by ordering them. It's by no means perfect, but
--   gets the job done well enough.
diffBinds :: Bool -> RnEnv2 -> [(Var, CoreExpr)] -> [(Var, CoreExpr)] -> ([SDoc], RnEnv2)
tryEtaReduce :: [Var] -> CoreExpr -> Maybe CoreExpr

-- | A more efficient version of <a>applyTypeToArg</a> when we have several
--   arguments. The first argument is just for debugging, and gives some
--   context
applyTypeToArgs :: CoreExpr -> Type -> [CoreExpr] -> Type

-- | Determines the type resulting from applying an expression with given
--   type to a given argument expression
applyTypeToArg :: Type -> CoreExpr -> Type
dataConRepInstPat :: [Unique] -> DataCon -> [Type] -> ([TyVar], [Id])
dataConRepFSInstPat :: [FastString] -> [Unique] -> DataCon -> [Type] -> ([TyVar], [Id])

-- | Strip ticks satisfying a predicate from top of an expression
stripTicksTop :: (Tickish Id -> Bool) -> Expr b -> ([Tickish Id], Expr b)

-- | Strip ticks satisfying a predicate from top of an expression,
--   returning the remaining expresion
stripTicksTopE :: (Tickish Id -> Bool) -> Expr b -> Expr b

-- | Strip ticks satisfying a predicate from top of an expression,
--   returning the ticks
stripTicksTopT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]

-- | Completely strip ticks satisfying a predicate from an expression. Note
--   this is O(n) in the size of the expression!
stripTicksE :: (Tickish Id -> Bool) -> Expr b -> Expr b
stripTicksT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]
instance Outputable CoreStats

module SAT
doStaticArgs :: UniqSupply -> CoreProgram -> CoreProgram

module OccurAnal
occurAnalysePgm :: Module -> (Activation -> Bool) -> [CoreRule] -> [CoreVect] -> VarSet -> CoreProgram -> CoreProgram
occurAnalyseExpr :: CoreExpr -> CoreExpr
occurAnalyseExpr_NoBinderSwap :: CoreExpr -> CoreExpr
instance Outputable Details
instance Outputable OccEncl

module InstEnv
type DFunId = Id
type InstMatch = (ClsInst, [DFunInstType])
type ClsInstLookupResult = ([InstMatch], [ClsInst], Bool)

-- | The semantics allowed for overlapping instances for a particular
--   instance. See Note [Safe Haskell isSafeOverlap] (in <a>lhs</a>) for a
--   explanation of the <a>isSafeOverlap</a> field.
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{-# OVERLAPPABLE'</tt>
--   or <tt>'{-# OVERLAPPING'</tt> or <tt>'{-# OVERLAPS'</tt> or <tt>'{-#
--   INCOHERENT'</tt>, <a>AnnClose</a> <tt>`#-}`</tt>,</li>
--   </ul>
data OverlapFlag
[OverlapFlag] :: OverlapMode -> Bool -> OverlapFlag
[overlapMode] :: OverlapFlag -> OverlapMode
[isSafeOverlap] :: OverlapFlag -> Bool
data OverlapMode

-- | This instance must not overlap another <a>NoOverlap</a> instance.
--   However, it may be overlapped by <a>Overlapping</a> instances, and it
--   may overlap <a>Overlappable</a> instances.
[NoOverlap] :: SourceText -> OverlapMode

-- | Silently ignore this instance if you find a more specific one that
--   matches the constraint you are trying to resolve
--   
--   Example: constraint (Foo [Int]) instance Foo [Int] instance {--} Foo
--   [a]
--   
--   Since the second instance has the Overlappable flag, the first
--   instance will be chosen (otherwise its ambiguous which to choose)
[Overlappable] :: SourceText -> OverlapMode

-- | Silently ignore any more general instances that may be used to solve
--   the constraint.
--   
--   Example: constraint (Foo [Int]) instance {--} Foo [Int] instance Foo
--   [a]
--   
--   Since the first instance has the Overlapping flag, the second---more
--   general---instance will be ignored (otherwise it is ambiguous which to
--   choose)
[Overlapping] :: SourceText -> OverlapMode

-- | Equivalent to having both <a>Overlapping</a> and <a>Overlappable</a>
--   flags.
[Overlaps] :: SourceText -> OverlapMode

-- | Behave like Overlappable and Overlapping, and in addition pick an an
--   arbitrary one if there are multiple matching candidates, and don't
--   worry about later instantiation
--   
--   Example: constraint (Foo [b]) instance {-# INCOHERENT -} Foo [Int]
--   instance Foo [a] Without the Incoherent flag, we'd complain that
--   instantiating <tt>b</tt> would change which instance was chosen. See
--   also note [Incoherent instances] in InstEnv
[Incoherent] :: SourceText -> OverlapMode
setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag
data ClsInst
[ClsInst] :: Name -> [Maybe Name] -> [TyVar] -> Class -> [Type] -> DFunId -> OverlapFlag -> IsOrphan -> ClsInst
[is_cls_nm] :: ClsInst -> Name
[is_tcs] :: ClsInst -> [Maybe Name]
[is_tvs] :: ClsInst -> [TyVar]
[is_cls] :: ClsInst -> Class
[is_tys] :: ClsInst -> [Type]
[is_dfun] :: ClsInst -> DFunId
[is_flag] :: ClsInst -> OverlapFlag
[is_orphan] :: ClsInst -> IsOrphan
type DFunInstType = Maybe Type
pprInstance :: ClsInst -> SDoc
pprInstanceHdr :: ClsInst -> SDoc
pprInstances :: [ClsInst] -> SDoc
instanceHead :: ClsInst -> ([TyVar], Class, [Type])
instanceSig :: ClsInst -> ([TyVar], [Type], Class, [Type])
mkLocalInstance :: DFunId -> OverlapFlag -> [TyVar] -> Class -> [Type] -> ClsInst
mkImportedInstance :: Name -> [Maybe Name] -> DFunId -> OverlapFlag -> IsOrphan -> ClsInst
instanceDFunId :: ClsInst -> DFunId
tidyClsInstDFun :: (DFunId -> DFunId) -> ClsInst -> ClsInst
instanceRoughTcs :: ClsInst -> [Maybe Name]

-- | A fuzzy comparison function for class instances, intended for sorting
--   instances before displaying them to the user.
fuzzyClsInstCmp :: ClsInst -> ClsInst -> Ordering

-- | Is this instance an orphan? If it is not an orphan, contains an
--   <a>OccName</a> witnessing the instance's non-orphanhood. See Note
--   [Orphans]
data IsOrphan
[IsOrphan] :: IsOrphan
[NotOrphan] :: OccName -> IsOrphan

-- | Returns true if <a>IsOrphan</a> is orphan.
isOrphan :: IsOrphan -> Bool

-- | Returns true if <a>IsOrphan</a> is not an orphan.
notOrphan :: IsOrphan -> Bool

-- | <a>InstEnvs</a> represents the combination of the global type class
--   instance environment, the local type class instance environment, and
--   the set of transitively reachable orphan modules (according to what
--   modules have been directly imported) used to test orphan instance
--   visibility.
data InstEnvs
[InstEnvs] :: InstEnv -> InstEnv -> VisibleOrphanModules -> InstEnvs
[ie_global] :: InstEnvs -> InstEnv
[ie_local] :: InstEnvs -> InstEnv
[ie_visible] :: InstEnvs -> VisibleOrphanModules

-- | Set of visible orphan modules, according to what modules have been
--   directly imported. This is based off of the dep_orphs field, which
--   records transitively reachable orphan modules (modules that define
--   orphan instances).
type VisibleOrphanModules = ModuleSet
type InstEnv = UniqFM ClsInstEnv
emptyInstEnv :: InstEnv
extendInstEnv :: InstEnv -> ClsInst -> InstEnv
deleteFromInstEnv :: InstEnv -> ClsInst -> InstEnv

-- | True when when the instance heads are the same e.g. both are Eq
--   [(a,b)] Used for overriding in GHCi Obviously should be insenstive to
--   alpha-renaming
identicalClsInstHead :: ClsInst -> ClsInst -> Bool
extendInstEnvList :: InstEnv -> [ClsInst] -> InstEnv

-- | Look up an instance in the given instance environment. The given class
--   application must match exactly one instance and the match may not
--   contain any flexi type variables. If the lookup is unsuccessful, yield
--   'Left errorMessage'.
lookupUniqueInstEnv :: InstEnvs -> Class -> [Type] -> Either MsgDoc (ClsInst, [Type])
lookupInstEnv' :: InstEnv -> VisibleOrphanModules -> Class -> [Type] -> ([InstMatch], [ClsInst])

-- | See Note [Rules for instance lookup]
lookupInstEnv :: InstEnvs -> Class -> [Type] -> ClsInstLookupResult
instEnvElts :: InstEnv -> [ClsInst]

-- | Checks for an exact match of ClsInst in the instance environment. We
--   use this when we do signature checking in TcRnDriver
memberInstEnv :: InstEnv -> ClsInst -> Bool

-- | Test if an instance is visible, by checking that its origin module is
--   in <a>VisibleOrphanModules</a>. See Note [Instance lookup and orphan
--   instances]
instIsVisible :: VisibleOrphanModules -> ClsInst -> Bool
classInstances :: InstEnvs -> Class -> [ClsInst]

-- | Collects the names of concrete types and type constructors that make
--   up the head of a class instance. For instance, given `class Foo a b`:
--   
--   `instance Foo (Either (Maybe Int) a) Bool` would yield [Either, Maybe,
--   Int, Bool]
--   
--   Used in the implementation of ":info" in GHCi.
orphNamesOfClsInst :: ClsInst -> NameSet
instanceBindFun :: TyVar -> BindFlag
instanceCantMatch :: [Maybe Name] -> [Maybe Name] -> Bool
roughMatchTcs :: [Type] -> [Maybe Name]
instance Data ClsInst
instance Data IsOrphan
instance NamedThing ClsInst
instance Outputable ClsInst
instance Binary IsOrphan
instance Outputable ClsInstEnv

module FunDeps
data FDEq
[FDEq] :: Int -> Type -> Type -> FDEq
[fd_pos] :: FDEq -> Int
[fd_ty_left] :: FDEq -> Type
[fd_ty_right] :: FDEq -> Type
data Equation loc
[FDEqn] :: [TyVar] -> [FDEq] -> PredType -> loc -> Equation loc
[fd_qtvs] :: Equation loc -> [TyVar]
[fd_eqs] :: Equation loc -> [FDEq]
[fd_pred1, fd_pred2] :: Equation loc -> PredType
[fd_loc] :: Equation loc -> loc
pprEquation :: Equation a -> SDoc
improveFromInstEnv :: InstEnvs -> PredType -> [Equation SrcSpan]
improveFromAnother :: PredType -> PredType -> [Equation ()]
checkInstCoverage :: Bool -> Class -> [PredType] -> [Type] -> Validity
checkFunDeps :: InstEnvs -> ClsInst -> Maybe [ClsInst]
pprFundeps :: Outputable a => [FunDep a] -> SDoc
instance Outputable FDEq

module TrieMap
data CoreMap a
emptyCoreMap :: CoreMap a
extendCoreMap :: CoreMap a -> CoreExpr -> a -> CoreMap a
lookupCoreMap :: CoreMap a -> CoreExpr -> Maybe a
foldCoreMap :: (a -> b -> b) -> b -> CoreMap a -> b
data TypeMap a
emptyTypeMap :: TypeMap a
extendTypeMap :: TypeMap a -> Type -> a -> TypeMap a
lookupTypeMap :: TypeMap a -> Type -> Maybe a
foldTypeMap :: (a -> b -> b) -> b -> TypeMap a -> b
data CoercionMap a
data MaybeMap m a
data ListMap m a
class TrieMap m where type family Key m :: *
emptyTM :: TrieMap m => m a
lookupTM :: TrieMap m => Key m -> m b -> Maybe b
alterTM :: TrieMap m => Key m -> XT b -> m b -> m b
mapTM :: TrieMap m => (a -> b) -> m a -> m b
foldTM :: TrieMap m => (a -> b -> b) -> m a -> b -> b
insertTM :: TrieMap m => Key m -> a -> m a -> m a
deleteTM :: TrieMap m => Key m -> m a -> m a
lookupTypeMapTyCon :: TypeMap a -> TyCon -> [a]
instance TrieMap IntMap
instance Ord k => TrieMap (Map k)
instance TrieMap UniqFM
instance TrieMap m => TrieMap (MaybeMap m)
instance TrieMap m => TrieMap (ListMap m)
instance TrieMap CoreMap
instance Outputable a => Outputable (CoreMap a)
instance TrieMap AltMap
instance TrieMap CoercionMap
instance TrieMap RoleMap
instance Outputable a => Outputable (TypeMap a)
instance TrieMap TypeMap
instance TrieMap TyLitMap
instance TrieMap VarMap

module FamInstEnv
data FamInst
[FamInst] :: CoAxiom Unbranched -> FamFlavor -> Name -> [Maybe Name] -> [TyVar] -> [Type] -> Type -> FamInst
[fi_axiom] :: FamInst -> CoAxiom Unbranched
[fi_flavor] :: FamInst -> FamFlavor
[fi_fam] :: FamInst -> Name
[fi_tcs] :: FamInst -> [Maybe Name]
[fi_tvs] :: FamInst -> [TyVar]
[fi_tys] :: FamInst -> [Type]
[fi_rhs] :: FamInst -> Type
data FamFlavor
[SynFamilyInst] :: FamFlavor
[DataFamilyInst] :: TyCon -> FamFlavor
famInstAxiom :: FamInst -> CoAxiom Unbranched
famInstTyCon :: FamInst -> TyCon
famInstRHS :: FamInst -> Type
famInstsRepTyCons :: [FamInst] -> [TyCon]
famInstRepTyCon_maybe :: FamInst -> Maybe TyCon
dataFamInstRepTyCon :: FamInst -> TyCon
pprFamInst :: FamInst -> SDoc
pprFamInsts :: [FamInst] -> SDoc
mkImportedFamInst :: Name -> [Maybe Name] -> CoAxiom Unbranched -> FamInst
type FamInstEnvs = (FamInstEnv, FamInstEnv)
type FamInstEnv = UniqFM FamilyInstEnv
emptyFamInstEnv :: FamInstEnv
emptyFamInstEnvs :: (FamInstEnv, FamInstEnv)
extendFamInstEnv :: FamInstEnv -> FamInst -> FamInstEnv
deleteFromFamInstEnv :: FamInstEnv -> FamInst -> FamInstEnv
extendFamInstEnvList :: FamInstEnv -> [FamInst] -> FamInstEnv

-- | True when the LHSs are identical Used for overriding in GHCi
identicalFamInstHead :: FamInst -> FamInst -> Bool
famInstEnvElts :: FamInstEnv -> [FamInst]
familyInstances :: (FamInstEnv, FamInstEnv) -> TyCon -> [FamInst]

-- | Collects the names of the concrete types and type constructors that
--   make up the LHS of a type family instance, including the family name
--   itself.
--   
--   For instance, given `type family Foo a b`: `type instance Foo (F (G (H
--   a))) b = ...` would yield [Foo,F,G,H]
--   
--   Used in the implementation of ":info" in GHCi.
orphNamesOfFamInst :: FamInst -> NameSet
mkCoAxBranch :: [TyVar] -> [Type] -> Type -> SrcSpan -> CoAxBranch
mkBranchedCoAxiom :: Name -> TyCon -> [CoAxBranch] -> CoAxiom Branched
mkUnbranchedCoAxiom :: Name -> TyCon -> CoAxBranch -> CoAxiom Unbranched
mkSingleCoAxiom :: Name -> [TyVar] -> TyCon -> [Type] -> Type -> CoAxiom Unbranched
computeAxiomIncomps :: CoAxiom br -> CoAxiom br
data FamInstMatch
[FamInstMatch] :: FamInst -> [Type] -> FamInstMatch
[fim_instance] :: FamInstMatch -> FamInst
[fim_tys] :: FamInstMatch -> [Type]
lookupFamInstEnv :: FamInstEnvs -> TyCon -> [Type] -> [FamInstMatch]
lookupFamInstEnvConflicts :: FamInstEnvs -> FamInst -> [FamInstMatch]
isDominatedBy :: CoAxBranch -> [CoAxBranch] -> Bool
topNormaliseType :: FamInstEnvs -> Type -> Type

-- | Get rid of *outermost* (or toplevel) * type function redex * newtypes
--   using appropriate coercions. Specifically, if topNormaliseType_maybe
--   env ty = Maybe (co, ty') then (a) co :: ty ~ ty' (b) ty' is not a
--   newtype, and is not a type-family redex
--   
--   However, ty' can be something like (Maybe (F ty)), where (F ty) is a
--   redex.
--   
--   Its a bit like Type.repType, but handles type families too The
--   coercion returned is always an R coercion
topNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe (Coercion, Type)
normaliseType :: FamInstEnvs -> Role -> Type -> (Coercion, Type)
normaliseTcApp :: FamInstEnvs -> Role -> TyCon -> [Type] -> (Coercion, Type)
reduceTyFamApp_maybe :: FamInstEnvs -> Role -> TyCon -> [Type] -> Maybe (Coercion, Type)
chooseBranch :: CoAxiom Branched -> [Type] -> Maybe (BranchIndex, [Type])
flattenTys :: InScopeSet -> [Type] -> [Type]
instance NamedThing FamInst
instance Outputable FamInst
instance Outputable FamilyInstEnv
instance Outputable FamInstMatch

module OptCoercion

-- | optCoercion applies a substitution to a coercion, *and* optimises it
--   to reduce its size
optCoercion :: CvSubst -> Coercion -> NormalCo

-- | Check to make sure that an AxInstCo is internally consistent. Returns
--   the conflicting branch, if it exists See Note [Conflict checking with
--   AxiomInstCo]
checkAxInstCo :: Coercion -> Maybe CoAxBranch

module CoreSubst

-- | A substitution environment, containing both <a>Id</a> and <a>TyVar</a>
--   substitutions.
--   
--   Some invariants apply to how you use the substitution:
--   
--   <ol>
--   <li>The in-scope set contains at least those <a>Id</a>s and
--   <a>TyVar</a>s that will be in scope <i>after</i> applying the
--   substitution to a term. Precisely, the in-scope set must be a superset
--   of the free vars of the substitution range that might possibly clash
--   with locally-bound variables in the thing being substituted in.</li>
--   <li>You may apply the substitution only <i>once</i></li>
--   </ol>
--   
--   There are various ways of setting up the in-scope set such that the
--   first of these invariants hold:
--   
--   <ul>
--   <li>Arrange that the in-scope set really is all the things in
--   scope</li>
--   <li>Arrange that it's the free vars of the range of the
--   substitution</li>
--   <li>Make it empty, if you know that all the free vars of the
--   substitution are fresh, and hence can't possibly clash</li>
--   </ul>
data Subst
[Subst] :: InScopeSet -> IdSubstEnv -> TvSubstEnv -> CvSubstEnv -> Subst

-- | A substitution of <a>Type</a>s for <a>TyVar</a>s and <a>Kind</a>s for
--   <a>KindVar</a>s
type TvSubstEnv = TyVarEnv Type

-- | An environment for substituting for <a>Id</a>s
type IdSubstEnv = IdEnv CoreExpr

-- | A set of variables that are in scope at some point
data InScopeSet

-- | De-shadowing the program is sometimes a useful pre-pass. It can be
--   done simply by running over the bindings with an empty substitution,
--   because substitution returns a result that has no-shadowing
--   guaranteed.
--   
--   (Actually, within a single <i>type</i> there might still be shadowing,
--   because <a>substTy</a> is a no-op for the empty substitution, but
--   that's probably OK.)
--   
--   <ul>
--   <li><i>Aug 09</i> This function is not used in GHC at the moment, but
--   seems so short and simple that I'm going to leave it here</li>
--   </ul>
deShadowBinds :: CoreProgram -> CoreProgram

-- | Substitutes for the <a>Id</a>s within the <tt>WorkerInfo</tt> given
--   the new function <a>Id</a>
substSpec :: Subst -> Id -> SpecInfo -> SpecInfo
substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]

-- | See <a>substTy</a>
substTy :: Subst -> Type -> Type

-- | See <a>substCo</a>
substCo :: Subst -> Coercion -> Coercion
substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr

-- | Apply a substitution to an entire <a>CoreExpr</a>. Remember, you may
--   only apply the substitution <i>once</i>: see
--   <a>CoreSubst#apply_once</a>
--   
--   Do *not* attempt to short-cut in the case of an empty substitution!
--   See Note [Extending the Subst]
substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr

-- | Apply a substitution to an entire <a>CoreBind</a>, additionally
--   returning an updated <a>Subst</a> that should be used by subsequent
--   substitutions.
substBind :: Subst -> CoreBind -> (Subst, CoreBind)

-- | Apply a substitution to an entire <a>CoreBind</a>, additionally
--   returning an updated <a>Subst</a> that should be used by subsequent
--   substitutions.
substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)

-- | Substitutes for the <a>Id</a>s within an unfolding
substUnfolding :: Subst -> Unfolding -> Unfolding

-- | Substitutes for the <a>Id</a>s within an unfolding
substUnfoldingSC :: Subst -> Unfolding -> Unfolding

-- | Find the substitution for an <a>Id</a> in the <a>Subst</a>
lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr

-- | Find the substitution for a <a>TyVar</a> in the <a>Subst</a>
lookupTvSubst :: Subst -> TyVar -> Type

-- | Find the coercion substitution for a <a>CoVar</a> in the <a>Subst</a>
lookupCvSubst :: Subst -> CoVar -> Coercion
substIdOcc :: Subst -> Id -> Id
substTickish :: Subst -> Tickish Id -> Tickish Id
substVarSet :: Subst -> VarSet -> VarSet
emptySubst :: Subst
mkEmptySubst :: InScopeSet -> Subst
mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst

-- | Simultaneously substitute for a bunch of variables No left-right
--   shadowing ie the substitution for (x y. e) a1 a2 so neither x nor y
--   scope over a1 a2
mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst

-- | Find the in-scope set: see <a>CoreSubst#in_scope_invariant</a>
substInScope :: Subst -> InScopeSet
isEmptySubst :: Subst -> Bool

-- | Add a substitution for an <a>Id</a> to the <a>Subst</a>: you must
--   ensure that the in-scope set is such that the
--   <a>CoreSubst#in_scope_invariant</a> is true after extending the
--   substitution like this
extendIdSubst :: Subst -> Id -> CoreExpr -> Subst

-- | Adds multiple <a>Id</a> substitutions to the <a>Subst</a>: see also
--   <a>extendIdSubst</a>
extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst

-- | Add a substitution for a <a>TyVar</a> to the <a>Subst</a>: you must
--   ensure that the in-scope set is such that the
--   <a>CoreSubst#in_scope_invariant</a> is true after extending the
--   substitution like this
extendTvSubst :: Subst -> TyVar -> Type -> Subst

-- | Adds multiple <a>TyVar</a> substitutions to the <a>Subst</a>: see also
--   <a>extendTvSubst</a>
extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst

-- | Add a substitution from a <a>CoVar</a> to a <a>Coercion</a> to the
--   <a>Subst</a>: you must ensure that the in-scope set is such that the
--   <a>CoreSubst#in_scope_invariant</a> is true after extending the
--   substitution like this
extendCvSubst :: Subst -> CoVar -> Coercion -> Subst

-- | Adds multiple <a>CoVar</a> -&gt; <a>Coercion</a> substitutions to the
--   <a>Subst</a>: see also <a>extendCvSubst</a>
extendCvSubstList :: Subst -> [(CoVar, Coercion)] -> Subst

-- | Add a substitution appropriate to the thing being substituted (whether
--   an expression, type, or coercion). See also <a>extendIdSubst</a>,
--   <a>extendTvSubst</a>, and <a>extendCvSubst</a>.
extendSubst :: Subst -> Var -> CoreArg -> Subst

-- | Add a substitution as appropriate to each of the terms being
--   substituted (whether expressions, types, or coercions). See also
--   <a>extendSubst</a>.
extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst
extendSubstWithVar :: Subst -> Var -> Var -> Subst

-- | Remove all substitutions for <a>Id</a>s and <a>Var</a>s that might
--   have been built up while preserving the in-scope set
zapSubstEnv :: Subst -> Subst

-- | Add the <a>Var</a> to the in-scope set, but do not remove any existing
--   substitutions for it
addInScopeSet :: Subst -> VarSet -> Subst

-- | Add the <a>Var</a> to the in-scope set: as a side effect, and remove
--   any existing substitutions for it
extendInScope :: Subst -> Var -> Subst

-- | Add the <a>Var</a>s to the in-scope set: see also <a>extendInScope</a>
extendInScopeList :: Subst -> [Var] -> Subst

-- | Optimized version of <a>extendInScopeList</a> that can be used if you
--   are certain all the things being added are <a>Id</a>s and hence none
--   are <a>TyVar</a>s or <a>CoVar</a>s
extendInScopeIds :: Subst -> [Id] -> Subst
isInScope :: Var -> Subst -> Bool
setInScope :: Subst -> InScopeSet -> Subst
delBndr :: Subst -> Var -> Subst
delBndrs :: Subst -> [Var] -> Subst

-- | Substitutes a <a>Var</a> for another one according to the <a>Subst</a>
--   given, returning the result and an updated <a>Subst</a> that should be
--   used by subsequent substitutions. <a>IdInfo</a> is preserved by this
--   process, although it is substituted into appropriately.
substBndr :: Subst -> Var -> (Subst, Var)

-- | Applies <a>substBndr</a> to a number of <a>Var</a>s, accumulating a
--   new <a>Subst</a> left-to-right
substBndrs :: Subst -> [Var] -> (Subst, [Var])

-- | Substitute in a mutually recursive group of <a>Id</a>s
substRecBndrs :: Subst -> [Id] -> (Subst, [Id])
cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)
cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])

-- | Very similar to <a>substBndr</a>, but it always allocates a new
--   <a>Unique</a> for each variable in its output. It substitutes the
--   IdInfo though.
cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)

-- | Applies <a>cloneIdBndr</a> to a number of <a>Id</a>s, accumulating a
--   final substitution from left to right
cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

-- | Clone a mutually recursive group of <a>Id</a>s
cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
simpleOptPgm :: DynFlags -> Module -> CoreProgram -> [CoreRule] -> [CoreVect] -> IO (CoreProgram, [CoreRule], [CoreVect])
simpleOptExpr :: CoreExpr -> CoreExpr
simpleOptExprWith :: Subst -> InExpr -> OutExpr

-- | Returns <tt>Just (dc, [t1..tk], [x1..xn])</tt> if the argument
--   expression is a *saturated* constructor application of the form <tt>dc
--   t1..tk x1 .. xn</tt>, where t1..tk are the *universally-qantified*
--   type args of <tt>dc</tt>
exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (DataCon, [Type], [CoreExpr])
exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal
exprIsLambda_maybe :: InScopeEnv -> CoreExpr -> Maybe (Var, CoreExpr, [Tickish Id])
instance Outputable Subst


-- | Arity and eta expansion
module CoreArity

-- | manifestArity sees how many leading value lambdas there are, after
--   looking through casts
manifestArity :: CoreExpr -> Arity

-- | An approximate, fast, version of <a>exprEtaExpandArity</a>
exprArity :: CoreExpr -> Arity
typeArity :: Type -> [OneShotInfo]
exprBotStrictness_maybe :: CoreExpr -> Maybe (Arity, StrictSig)
exprEtaExpandArity :: DynFlags -> CoreExpr -> Arity

-- | The Arity returned is the number of value args the expression can be
--   applied to without doing much work
findRhsArity :: DynFlags -> Id -> CoreExpr -> Arity -> Arity
type CheapFun = CoreExpr -> Maybe Type -> Bool

-- | <tt>etaExpand n us e ty</tt> returns an expression with the same
--   meaning as <tt>e</tt>, but with arity <tt>n</tt>.
--   
--   Given:
--   
--   <pre>
--   e' = etaExpand n us e ty
--   </pre>
--   
--   We should have that:
--   
--   <pre>
--   ty = exprType e = exprType e'
--   </pre>
etaExpand :: Arity -> CoreExpr -> CoreExpr
instance Outputable EtaInfo

module CoreUnfold

-- | Records the <i>unfolding</i> of an identifier, which is approximately
--   the form the identifier would have if we substituted its definition in
--   for the identifier. This type should be treated as abstract everywhere
--   except in <a>CoreUnfold</a>
data Unfolding

-- | <a>UnfoldingGuidance</a> says when unfolding should take place
data UnfoldingGuidance

-- | There is no known <a>Unfolding</a>
noUnfolding :: Unfolding
mkImplicitUnfolding :: DynFlags -> CoreExpr -> Unfolding
mkUnfolding :: DynFlags -> UnfoldingSource -> Bool -> Bool -> CoreExpr -> Unfolding
mkCoreUnfolding :: UnfoldingSource -> Bool -> CoreExpr -> UnfoldingGuidance -> Unfolding
mkTopUnfolding :: DynFlags -> Bool -> CoreExpr -> Unfolding
mkSimpleUnfolding :: DynFlags -> CoreExpr -> Unfolding
mkWorkerUnfolding :: DynFlags -> (CoreExpr -> CoreExpr) -> Unfolding -> Unfolding
mkInlineUnfolding :: Maybe Arity -> CoreExpr -> Unfolding
mkInlinableUnfolding :: DynFlags -> CoreExpr -> Unfolding
mkWwInlineRule :: CoreExpr -> Arity -> Unfolding
mkCompulsoryUnfolding :: CoreExpr -> Unfolding
mkDFunUnfolding :: [Var] -> DataCon -> [CoreExpr] -> Unfolding
specUnfolding :: DynFlags -> Subst -> [Var] -> [CoreExpr] -> Unfolding -> Unfolding
interestingArg :: CoreExpr -> ArgSummary
data ArgSummary
[TrivArg] :: ArgSummary
[NonTrivArg] :: ArgSummary
[ValueArg] :: ArgSummary
couldBeSmallEnoughToInline :: DynFlags -> Int -> CoreExpr -> Bool
inlineBoringOk :: CoreExpr -> Bool
certainlyWillInline :: DynFlags -> Unfolding -> Maybe Unfolding
smallEnoughToInline :: DynFlags -> Unfolding -> Bool
callSiteInline :: DynFlags -> Id -> Bool -> Bool -> [ArgSummary] -> CallCtxt -> Maybe CoreExpr
data CallCtxt
[BoringCtxt] :: CallCtxt
[RhsCtxt] :: CallCtxt
[DiscArgCtxt] :: CallCtxt
[RuleArgCtxt] :: CallCtxt
[ValAppCtxt] :: CallCtxt
[CaseCtxt] :: CallCtxt

-- | Returns <tt>Just (dc, [t1..tk], [x1..xn])</tt> if the argument
--   expression is a *saturated* constructor application of the form <tt>dc
--   t1..tk x1 .. xn</tt>, where t1..tk are the *universally-qantified*
--   type args of <tt>dc</tt>
exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (DataCon, [Type], [CoreExpr])
exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal
instance Outputable ExprSize
instance Outputable ArgSummary
instance Outputable CallCtxt

module LiberateCase
liberateCase :: DynFlags -> CoreProgram -> CoreProgram

module CoreTidy
tidyExpr :: TidyEnv -> CoreExpr -> CoreExpr
tidyVarOcc :: TidyEnv -> Var -> Var
tidyRule :: TidyEnv -> CoreRule -> CoreRule
tidyRules :: TidyEnv -> [CoreRule] -> [CoreRule]
tidyUnfolding :: TidyEnv -> Unfolding -> Unfolding -> Unfolding


-- | Functions for collecting together and applying rewrite rules to a
--   module. The <a>CoreRule</a> datatype itself is declared elsewhere.
module Rules

-- | Gathers a collection of <a>CoreRule</a>s. Maps (the name of) an
--   <a>Id</a> to its rules
type RuleBase = NameEnv [CoreRule]
emptyRuleBase :: RuleBase
mkRuleBase :: [CoreRule] -> RuleBase
extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase
unionRuleBase :: RuleBase -> RuleBase -> RuleBase
pprRuleBase :: RuleBase -> SDoc

-- | Report partial matches for rules beginning with the specified string
--   for the purposes of error reporting
ruleCheckProgram :: CompilerPhase -> String -> RuleBase -> CoreProgram -> SDoc

-- | Make a <a>SpecInfo</a> containing a number of <a>CoreRule</a>s,
--   suitable for putting into an <tt>IdInfo</tt>
mkSpecInfo :: [CoreRule] -> SpecInfo
extendSpecInfo :: SpecInfo -> [CoreRule] -> SpecInfo
addSpecInfo :: SpecInfo -> SpecInfo -> SpecInfo
addIdSpecialisations :: Id -> [CoreRule] -> Id

-- | Gather all the rules for locally bound identifiers from the supplied
--   bindings
rulesOfBinds :: [CoreBind] -> [CoreRule]
getRules :: RuleBase -> Id -> [CoreRule]
pprRulesForUser :: [CoreRule] -> SDoc

-- | The main rule matching function. Attempts to apply all (active)
--   supplied rules to this instance of an application in a given context,
--   returning the rule applied and the resulting expression if successful.
lookupRule :: DynFlags -> InScopeEnv -> (Activation -> Bool) -> Id -> [CoreExpr] -> [CoreRule] -> Maybe (CoreRule, CoreExpr)

-- | Used to make <a>CoreRule</a> for an <a>Id</a> defined in the module
--   being compiled. See also <a>CoreRule</a>
mkRule :: Bool -> Bool -> RuleName -> Activation -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule

-- | Find the "top" free names of several expressions. Such names are
--   either:
--   
--   <ol>
--   <li>The function finally being applied to in an application chain (if
--   that name is a GlobalId: see <a>Var#globalvslocal</a>), or</li>
--   <li>The <tt>TyCon</tt> if the expression is a <a>Type</a></li>
--   </ol>
--   
--   This is used for the fast-match-check for rules; if the top names
--   don't match, the rest can't
roughTopNames :: [CoreExpr] -> [Maybe Name]

module CallArity
callArityAnalProgram :: DynFlags -> CoreProgram -> CoreProgram
callArityRHS :: CoreExpr -> CoreExpr

module CSE
cseProgram :: CoreProgram -> CoreProgram

module TcEvidence
data HsWrapper
[WpHole] :: HsWrapper
[WpCompose] :: HsWrapper -> HsWrapper -> HsWrapper
[WpFun] :: HsWrapper -> HsWrapper -> TcType -> TcType -> HsWrapper
[WpCast] :: TcCoercion -> HsWrapper
[WpEvLam] :: EvVar -> HsWrapper
[WpEvApp] :: EvTerm -> HsWrapper
[WpTyLam] :: TyVar -> HsWrapper
[WpTyApp] :: KindOrType -> HsWrapper
[WpLet] :: TcEvBinds -> HsWrapper
(<.>) :: HsWrapper -> HsWrapper -> HsWrapper
mkWpTyApps :: [Type] -> HsWrapper
mkWpEvApps :: [EvTerm] -> HsWrapper
mkWpEvVarApps :: [EvVar] -> HsWrapper
mkWpTyLams :: [TyVar] -> HsWrapper
mkWpLams :: [Var] -> HsWrapper
mkWpLet :: TcEvBinds -> HsWrapper
mkWpCast :: TcCoercion -> HsWrapper
mkWpFun :: HsWrapper -> HsWrapper -> TcType -> TcType -> HsWrapper
idHsWrapper :: HsWrapper
isIdHsWrapper :: HsWrapper -> Bool
pprHsWrapper :: SDoc -> HsWrapper -> SDoc
data TcEvBinds
[TcEvBinds] :: EvBindsVar -> TcEvBinds
[EvBinds] :: (Bag EvBind) -> TcEvBinds
data EvBindsVar
[EvBindsVar] :: (IORef EvBindMap) -> Unique -> EvBindsVar
newtype EvBindMap
[EvBindMap] :: VarEnv EvBind -> EvBindMap
[ev_bind_varenv] :: EvBindMap -> VarEnv EvBind
emptyEvBindMap :: EvBindMap
extendEvBinds :: EvBindMap -> EvVar -> EvTerm -> EvBindMap
lookupEvBind :: EvBindMap -> EvVar -> Maybe EvBind
evBindMapBinds :: EvBindMap -> Bag EvBind
data EvBind
[EvBind] :: EvVar -> EvTerm -> EvBind
emptyTcEvBinds :: TcEvBinds
isEmptyTcEvBinds :: TcEvBinds -> Bool
data EvTerm
[EvId] :: EvId -> EvTerm
[EvCoercion] :: TcCoercion -> EvTerm
[EvCast] :: EvTerm -> TcCoercion -> EvTerm
[EvDFunApp] :: DFunId -> [Type] -> [EvTerm] -> EvTerm
[EvTupleSel] :: EvTerm -> Int -> EvTerm
[EvTupleMk] :: [EvTerm] -> EvTerm
[EvDelayedError] :: Type -> FastString -> EvTerm
[EvSuperClass] :: EvTerm -> Int -> EvTerm
[EvLit] :: EvLit -> EvTerm
[EvTypeable] :: EvTypeable -> EvTerm
mkEvCast :: EvTerm -> TcCoercion -> EvTerm
evVarsOfTerm :: EvTerm -> VarSet
data EvLit
[EvNum] :: Integer -> EvLit
[EvStr] :: FastString -> EvLit
evTermCoercion :: EvTerm -> TcCoercion

-- | Instructions on how to make a <tt>Typeable</tt> dictionary.
data EvTypeable

-- | Dicitionary for concrete type constructors.
[EvTypeableTyCon] :: TyCon -> [Kind] -> EvTypeable

-- | Dictionary for type applications; this is used when we have a type
--   expression starting with a type variable (e.g., <tt>Typeable (f
--   a)</tt>)
[EvTypeableTyApp] :: (EvTerm, Type) -> (EvTerm, Type) -> EvTypeable

-- | Dictionary for a type literal.
[EvTypeableTyLit] :: Type -> EvTypeable
data TcCoercion
[TcRefl] :: Role -> TcType -> TcCoercion
[TcTyConAppCo] :: Role -> TyCon -> [TcCoercion] -> TcCoercion
[TcAppCo] :: TcCoercion -> TcCoercion -> TcCoercion
[TcForAllCo] :: TyVar -> TcCoercion -> TcCoercion
[TcCoVarCo] :: EqVar -> TcCoercion
[TcAxiomInstCo] :: (CoAxiom Branched) -> Int -> [TcCoercion] -> TcCoercion
[TcAxiomRuleCo] :: CoAxiomRule -> [TcType] -> [TcCoercion] -> TcCoercion
[TcPhantomCo] :: TcType -> TcType -> TcCoercion
[TcSymCo] :: TcCoercion -> TcCoercion
[TcTransCo] :: TcCoercion -> TcCoercion -> TcCoercion
[TcNthCo] :: Int -> TcCoercion -> TcCoercion
[TcLRCo] :: LeftOrRight -> TcCoercion -> TcCoercion
[TcSubCo] :: TcCoercion -> TcCoercion
[TcCastCo] :: TcCoercion -> TcCoercion -> TcCoercion
[TcLetCo] :: TcEvBinds -> TcCoercion -> TcCoercion
[TcCoercion] :: Coercion -> TcCoercion
data LeftOrRight
[CLeft] :: LeftOrRight
[CRight] :: LeftOrRight
pickLR :: LeftOrRight -> (a, a) -> a
mkTcReflCo :: Role -> TcType -> TcCoercion
mkTcNomReflCo :: TcType -> TcCoercion
mkTcRepReflCo :: TcType -> TcCoercion
mkTcTyConAppCo :: Role -> TyCon -> [TcCoercion] -> TcCoercion
mkTcAppCo :: TcCoercion -> TcCoercion -> TcCoercion
mkTcAppCos :: TcCoercion -> [TcCoercion] -> TcCoercion
mkTcFunCo :: Role -> TcCoercion -> TcCoercion -> TcCoercion
mkTcAxInstCo :: Role -> CoAxiom br -> Int -> [TcType] -> TcCoercion
mkTcUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [TcType] -> TcCoercion
mkTcForAllCo :: Var -> TcCoercion -> TcCoercion
mkTcForAllCos :: [Var] -> TcCoercion -> TcCoercion
mkTcSymCo :: TcCoercion -> TcCoercion
mkTcTransCo :: TcCoercion -> TcCoercion -> TcCoercion
mkTcNthCo :: Int -> TcCoercion -> TcCoercion
mkTcLRCo :: LeftOrRight -> TcCoercion -> TcCoercion
mkTcSubCo :: TcCoercion -> TcCoercion

-- | If the EqRel is ReprEq, makes a TcSubCo; otherwise, does nothing. Note
--   that the input coercion should always be nominal.
maybeTcSubCo :: EqRel -> TcCoercion -> TcCoercion

-- | Change the role of a <a>TcCoercion</a>. Panics if this isn't a
--   downgrade.
tcDowngradeRole :: Role -> Role -> TcCoercion -> TcCoercion

-- | Like <a>mkTcAppCo</a>, but allows the second coercion to be other than
--   nominal. See Note [mkTcTransAppCo]. Role r3 cannot be more stringent
--   than either r1 or r2.
mkTcTransAppCo :: Role -> TcCoercion -> TcType -> TcType -> Role -> TcCoercion -> TcType -> TcType -> Role -> TcCoercion
mkTcAxiomRuleCo :: CoAxiomRule -> [TcType] -> [TcCoercion] -> TcCoercion
mkTcPhantomCo :: TcType -> TcType -> TcCoercion
tcCoercionKind :: TcCoercion -> Pair Type
coVarsOfTcCo :: TcCoercion -> VarSet
isEqVar :: Var -> Bool
mkTcCoVarCo :: EqVar -> TcCoercion
isTcReflCo :: TcCoercion -> Bool
getTcCoVar_maybe :: TcCoercion -> Maybe CoVar
tcCoercionRole :: TcCoercion -> Role
eqVarRole :: EqVar -> Role
instance Data HsWrapper
instance Data TcCoercion
instance Data EvTypeable
instance Data EvTerm
instance Data EvLit
instance Outputable TcCoercion
instance Data TcEvBinds
instance Outputable HsWrapper
instance Outputable TcEvBinds
instance Outputable EvBindsVar
instance Outputable EvBind
instance Outputable EvTerm
instance Outputable EvLit
instance Outputable EvTypeable

module HsBinds
type HsLocalBinds id = HsLocalBindsLR id id

-- | Bindings in a 'let' expression or a 'where' clause
data HsLocalBindsLR idL idR
[HsValBinds] :: (HsValBindsLR idL idR) -> HsLocalBindsLR idL idR
[HsIPBinds] :: (HsIPBinds idR) -> HsLocalBindsLR idL idR
[EmptyLocalBinds] :: HsLocalBindsLR idL idR
type HsValBinds id = HsValBindsLR id id

-- | Value bindings (not implicit parameters) Used for both top level and
--   nested bindings May contain pattern synonym bindings
data HsValBindsLR idL idR

-- | Before renaming RHS; idR is always RdrName Not dependency analysed
--   Recursive by default
[ValBindsIn] :: (LHsBindsLR idL idR) -> [LSig idR] -> HsValBindsLR idL idR

-- | After renaming RHS; idR can be Name or Id Dependency analysed, later
--   bindings in the list may depend on earlier ones.
[ValBindsOut] :: [(RecFlag, LHsBinds idL)] -> [LSig Name] -> HsValBindsLR idL idR
type LHsBind id = LHsBindLR id id
type LHsBinds id = LHsBindsLR id id
type HsBind id = HsBindLR id id
type LHsBindsLR idL idR = Bag (LHsBindLR idL idR)
type LHsBindLR idL idR = Located (HsBindLR idL idR)
data HsBindLR idL idR

-- | FunBind is used for both functions <tt>f x = e</tt> and variables
--   <tt>f = x -&gt; e</tt>
--   
--   Reason 1: Special case for type inference: see <a>tcMonoBinds</a>.
--   
--   Reason 2: Instance decls can only have FunBinds, which is convenient.
--   If you change this, you'll need to change e.g. rnMethodBinds
--   
--   But note that the form <tt>f :: a-&gt;a = ...</tt> parses as a pattern
--   binding, just like <tt>(f :: a -&gt; a) = ... </tt>
--   
--   <a>AnnKeywordId</a>s
--   
--   <ul>
--   <li><a>AnnFunId</a>, attached to each element of fun_matches</li>
--   <li><a>AnnEqual</a>,<a>AnnWhere</a>,
--   <a>AnnOpen</a>,<a>AnnClose</a>,</li>
--   </ul>
[FunBind] :: Located idL -> Bool -> MatchGroup idR (LHsExpr idR) -> HsWrapper -> PostRn idL NameSet -> [Tickish Id] -> HsBindLR idL idR
[fun_id] :: HsBindLR idL idR -> Located idL

-- | True =&gt; infix declaration
[fun_infix] :: HsBindLR idL idR -> Bool

-- | The payload
[fun_matches] :: HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)

-- | Coercion from the type of the MatchGroup to the type of the Id.
--   Example:
--   
--   <pre>
--   f :: Int -&gt; forall a. a -&gt; a
--   f x y = y
--   </pre>
--   
--   Then the MatchGroup will have type (Int -&gt; a' -&gt; a') (with a
--   free type variable a'). The coercion will take a CoreExpr of this type
--   and convert it to a CoreExpr of type Int -&gt; forall a'. a' -&gt; a'
--   Notice that the coercion captures the free a'.
[fun_co_fn] :: HsBindLR idL idR -> HsWrapper

-- | After the renamer, this contains the locally-bound free variables of
--   this defn. See Note [Bind free vars]
[bind_fvs] :: HsBindLR idL idR -> PostRn idL NameSet

-- | Ticks to put on the rhs, if any
[fun_tick] :: HsBindLR idL idR -> [Tickish Id]

-- | The pattern is never a simple variable; That case is done by FunBind
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnBang</a>,
--   <a>AnnEqual</a>,<a>AnnWhere</a>, <a>AnnOpen</a>,<a>AnnClose</a>,</li>
--   </ul>
[PatBind] :: LPat idL -> GRHSs idR (LHsExpr idR) -> PostTc idR Type -> PostRn idL NameSet -> ([Tickish Id], [[Tickish Id]]) -> HsBindLR idL idR
[pat_lhs] :: HsBindLR idL idR -> LPat idL
[pat_rhs] :: HsBindLR idL idR -> GRHSs idR (LHsExpr idR)

-- | Type of the GRHSs
[pat_rhs_ty] :: HsBindLR idL idR -> PostTc idR Type

-- | After the renamer, this contains the locally-bound free variables of
--   this defn. See Note [Bind free vars]
[bind_fvs] :: HsBindLR idL idR -> PostRn idL NameSet

-- | Ticks to put on the rhs, if any, and ticks to put on the bound
--   variables.
[pat_ticks] :: HsBindLR idL idR -> ([Tickish Id], [[Tickish Id]])

-- | Dictionary binding and suchlike. All VarBinds are introduced by the
--   type checker
[VarBind] :: idL -> LHsExpr idR -> Bool -> HsBindLR idL idR
[var_id] :: HsBindLR idL idR -> idL

-- | Located only for consistency
[var_rhs] :: HsBindLR idL idR -> LHsExpr idR

-- | True <a>=</a> inline this binding regardless (used for implication
--   constraints only)
[var_inline] :: HsBindLR idL idR -> Bool
[AbsBinds] :: [TyVar] -> [EvVar] -> [ABExport idL] -> TcEvBinds -> LHsBinds idL -> HsBindLR idL idR
[abs_tvs] :: HsBindLR idL idR -> [TyVar]

-- | Includes equality constraints
[abs_ev_vars] :: HsBindLR idL idR -> [EvVar]

-- | AbsBinds only gets used when idL = idR after renaming, but these need
--   to be idL's for the collect... code in HsUtil to have the right type
[abs_exports] :: HsBindLR idL idR -> [ABExport idL]

-- | Evidence bindings
[abs_ev_binds] :: HsBindLR idL idR -> TcEvBinds

-- | Typechecked user bindings
[abs_binds] :: HsBindLR idL idR -> LHsBinds idL

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnPattern</a>,
--   <a>AnnLarrow</a>,<a>AnnEqual</a>, <a>AnnWhere</a> <a>AnnOpen</a>
--   <tt>'{'</tt>,<a>AnnClose</a> <tt>'}'</tt></li>
--   </ul>
[PatSynBind] :: (PatSynBind idL idR) -> HsBindLR idL idR
data ABExport id
[ABE] :: id -> id -> HsWrapper -> TcSpecPrags -> ABExport id

-- | Any INLINE pragmas is attached to this Id
[abe_poly] :: ABExport id -> id
[abe_mono] :: ABExport id -> id

-- | See Note [AbsBinds wrappers] Shape: (forall abs_tvs. abs_ev_vars =&gt;
--   abe_mono) ~ abe_poly
[abe_wrap] :: ABExport id -> HsWrapper

-- | SPECIALISE pragmas
[abe_prags] :: ABExport id -> TcSpecPrags

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnPattern</a>,
--   <a>AnnEqual</a>,<a>AnnLarrow</a> <a>AnnWhere</a>,<a>AnnOpen</a>
--   <tt>'{'</tt>, <a>AnnClose</a> <tt>'}'</tt>,</li>
--   </ul>
data PatSynBind idL idR
[PSB] :: Located idL -> PostRn idR NameSet -> HsPatSynDetails (Located idR) -> LPat idR -> HsPatSynDir idR -> PatSynBind idL idR

-- | Name of the pattern synonym
[psb_id] :: PatSynBind idL idR -> Located idL

-- | See Note [Bind free vars]
[psb_fvs] :: PatSynBind idL idR -> PostRn idR NameSet

-- | Formal parameter names
[psb_args] :: PatSynBind idL idR -> HsPatSynDetails (Located idR)

-- | Right-hand side
[psb_def] :: PatSynBind idL idR -> LPat idR

-- | Directionality
[psb_dir] :: PatSynBind idL idR -> HsPatSynDir idR
pprLHsBinds :: (OutputableBndr idL, OutputableBndr idR) => LHsBindsLR idL idR -> SDoc
pprLHsBindsForUser :: (OutputableBndr idL, OutputableBndr idR, OutputableBndr id2) => LHsBindsLR idL idR -> [LSig id2] -> [SDoc]
pprDeclList :: [SDoc] -> SDoc
emptyLocalBinds :: HsLocalBindsLR a b
isEmptyLocalBinds :: HsLocalBindsLR a b -> Bool
isEmptyValBinds :: HsValBindsLR a b -> Bool
emptyValBindsIn :: HsValBindsLR a b
emptyValBindsOut :: HsValBindsLR a b
emptyLHsBinds :: LHsBindsLR idL idR
isEmptyLHsBinds :: LHsBindsLR idL idR -> Bool
plusHsValBinds :: HsValBinds a -> HsValBinds a -> HsValBinds a
getTypeSigNames :: HsValBinds a -> NameSet
ppr_monobind :: (OutputableBndr idL, OutputableBndr idR) => HsBindLR idL idR -> SDoc
pprTicks :: SDoc -> SDoc -> SDoc
data HsIPBinds id
[IPBinds] :: [LIPBind id] -> TcEvBinds -> HsIPBinds id
isEmptyIPBinds :: HsIPBinds id -> Bool

-- | May have <a>AnnKeywordId</a> : <a>AnnSemi</a> when in a list
type LIPBind id = Located (IPBind id)

-- | Implicit parameter bindings.
--   
--   These bindings start off as (Left "x") in the parser and stay that way
--   until after type-checking when they are replaced with (Right d), where
--   "d" is the name of the dictionary holding the evidence for the
--   implicit parameter.
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnEqual</a></li>
--   </ul>
data IPBind id
[IPBind] :: (Either (Located HsIPName) id) -> (LHsExpr id) -> IPBind id
type LSig name = Located (Sig name)

-- | Signatures and pragmas
data Sig name

-- | An ordinary type signature
--   
--   <pre>
--   f :: Num a =&gt; a -&gt; a
--   </pre>
--   
--   After renaming, this list of Names contains the named and unnamed
--   wildcards brought into scope by this signature. For a signature <tt>_
--   -&gt; _a -&gt; Bool</tt>, the renamer will give the unnamed wildcard
--   <tt>_</tt> a freshly generated name, e.g. <tt>_w</tt>. <tt>_w</tt> and
--   the named wildcard <tt>_a</tt> are then both replaced with fresh meta
--   vars in the type. Their names are stored in the type signature that
--   brought them into scope, in this third field to be more specific.
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDcolon</a>, <a>AnnComma</a></li>
--   </ul>
[TypeSig] :: [Located name] -> (LHsType name) -> (PostRn name [Name]) -> Sig name

-- | A pattern synonym type signature
--   
--   <pre>
--   pattern Single :: () =&gt; (Show a) =&gt; a -&gt; [a]
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnPattern</a>,
--   <a>AnnDcolon</a>,<a>AnnForall</a> <a>AnnDot</a>,<a>AnnDarrow</a></li>
--   </ul>
[PatSynSig] :: (Located name) -> (HsExplicitFlag, LHsTyVarBndrs name) -> (LHsContext name) -> (LHsContext name) -> (LHsType name) -> Sig name

-- | A type signature for a default method inside a class
--   
--   <pre>
--   default eq :: (Representable0 a, GEq (Rep0 a)) =&gt; a -&gt; a -&gt; Bool
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDefault</a>, <a>AnnDcolon</a></li>
--   </ul>
[GenericSig] :: [Located name] -> (LHsType name) -> Sig name

-- | A type signature in generated code, notably the code generated for
--   record selectors. We simply record the desired Id itself, replete with
--   its name, type and IdDetails. Otherwise it's just like a type
--   signature: there should be an accompanying binding
[IdSig] :: Id -> Sig name

-- | An ordinary fixity declaration
--   
--   <pre>
--   infixl 8 ***
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnInfix</a>, <a>AnnVal</a></li>
--   </ul>
[FixSig] :: (FixitySig name) -> Sig name

-- | An inline pragma
--   
--   <pre>
--   {#- INLINE f #-}
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{-# INLINE'</tt> and
--   <tt>'['</tt>, <a>AnnClose</a>,<a>AnnOpen</a>,
--   <a>AnnVal</a>,<a>AnnTilde</a>, <a>AnnClose</a></li>
--   </ul>
[InlineSig] :: (Located name) -> InlinePragma -> Sig name

-- | A specialisation pragma
--   
--   <pre>
--   {-# SPECIALISE f :: Int -&gt; Int #-}
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnOpen</a> <tt>'{-#
--   SPECIALISE'</tt> and <tt>'['</tt>, <a>AnnTilde</a>, <a>AnnVal</a>,
--   <a>AnnClose</a> <tt>']'</tt> and <tt>'#-}'</tt>, <a>AnnDcolon</a></li>
--   </ul>
[SpecSig] :: (Located name) -> [LHsType name] -> InlinePragma -> Sig name

-- | A specialisation pragma for instance declarations only
--   
--   <pre>
--   {-# SPECIALISE instance Eq [Int] #-}
--   </pre>
--   
--   (Class tys); should be a specialisation of the current instance
--   declaration
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnInstance</a>,<a>AnnClose</a></li>
--   </ul>
[SpecInstSig] :: SourceText -> (LHsType name) -> Sig name

-- | A minimal complete definition pragma
--   
--   <pre>
--   {-# MINIMAL a | (b, c | (d | e)) #-}
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnVbar</a>,<a>AnnComma</a>, <a>AnnClose</a></li>
--   </ul>
[MinimalSig] :: SourceText -> (BooleanFormula (Located name)) -> Sig name
type LFixitySig name = Located (FixitySig name)
data FixitySig name
[FixitySig] :: [Located name] -> Fixity -> FixitySig name

-- | TsSpecPrags conveys pragmas from the type checker to the desugarer
data TcSpecPrags

-- | Super-specialised: a default method should be macro-expanded at every
--   call site
[IsDefaultMethod] :: TcSpecPrags
[SpecPrags] :: [LTcSpecPrag] -> TcSpecPrags
type LTcSpecPrag = Located TcSpecPrag
data TcSpecPrag

-- | The Id to be specialised, an wrapper that specialises the polymorphic
--   function, and inlining spec for the specialised function
[SpecPrag] :: Id -> HsWrapper -> InlinePragma -> TcSpecPrag
noSpecPrags :: TcSpecPrags
hasSpecPrags :: TcSpecPrags -> Bool
isDefaultMethod :: TcSpecPrags -> Bool
isFixityLSig :: LSig name -> Bool
isVanillaLSig :: LSig name -> Bool
isTypeLSig :: LSig name -> Bool
isSpecLSig :: LSig name -> Bool
isSpecInstLSig :: LSig name -> Bool
isPragLSig :: LSig name -> Bool
isInlineLSig :: LSig name -> Bool
isMinimalLSig :: LSig name -> Bool
hsSigDoc :: Sig name -> SDoc
ppr_sig :: OutputableBndr name => Sig name -> SDoc
pprPatSynSig :: (OutputableBndr name) => name -> Bool -> SDoc -> Maybe SDoc -> Maybe SDoc -> SDoc -> SDoc
pragBrackets :: SDoc -> SDoc
pprVarSig :: (OutputableBndr id) => [id] -> SDoc -> SDoc
pprSpec :: (OutputableBndr id) => id -> SDoc -> InlinePragma -> SDoc
pprTcSpecPrags :: TcSpecPrags -> SDoc
pprMinimalSig :: OutputableBndr name => BooleanFormula (Located name) -> SDoc
data HsPatSynDetails a
[InfixPatSyn] :: a -> a -> HsPatSynDetails a
[PrefixPatSyn] :: [a] -> HsPatSynDetails a
data HsPatSynDir id
[Unidirectional] :: HsPatSynDir id
[ImplicitBidirectional] :: HsPatSynDir id
[ExplicitBidirectional] :: (MatchGroup id (LHsExpr id)) -> HsPatSynDir id
instance Data a => Data (HsPatSynDetails a)
instance Data id => Data (ABExport id)
instance Data TcSpecPrags
instance Data TcSpecPrag
instance Data name => Data (FixitySig name)
instance (DataId idL, DataId idR) => Data (HsLocalBindsLR idL idR)
instance (DataId idL, DataId idR) => Data (HsValBindsLR idL idR)
instance (DataId idL, DataId idR) => Data (HsBindLR idL idR)
instance (DataId idL, DataId idR) => Data (PatSynBind idL idR)
instance DataId id => Data (HsIPBinds id)
instance DataId name => Data (IPBind name)
instance DataId name => Data (Sig name)
instance DataId id => Data (HsPatSynDir id)
instance (OutputableBndr idL, OutputableBndr idR) => Outputable (HsLocalBindsLR idL idR)
instance (OutputableBndr idL, OutputableBndr idR) => Outputable (HsValBindsLR idL idR)
instance (OutputableBndr idL, OutputableBndr idR) => Outputable (HsBindLR idL idR)
instance OutputableBndr id => Outputable (ABExport id)
instance (OutputableBndr idL, OutputableBndr idR) => Outputable (PatSynBind idL idR)
instance OutputableBndr id => Outputable (HsIPBinds id)
instance OutputableBndr id => Outputable (IPBind id)
instance OutputableBndr name => Outputable (Sig name)
instance OutputableBndr name => Outputable (FixitySig name)
instance Outputable TcSpecPrag
instance Functor HsPatSynDetails
instance Foldable HsPatSynDetails
instance Traversable HsPatSynDetails

module PatSyn

-- | A pattern synonym See Note [Pattern synonym representation]
data PatSyn

-- | Build a new pattern synonym
mkPatSyn :: Name -> Bool -> ([TyVar], ThetaType) -> ([TyVar], ThetaType) -> [Type] -> Type -> (Id, Bool) -> Maybe (Id, Bool) -> PatSyn

-- | The <a>Name</a> of the <a>PatSyn</a>, giving it a unique, rooted
--   identification
patSynName :: PatSyn -> Name

-- | Arity of the pattern synonym
patSynArity :: PatSyn -> Arity

-- | Should the <a>PatSyn</a> be presented infix?
patSynIsInfix :: PatSyn -> Bool
patSynArgs :: PatSyn -> [Type]
patSynTyDetails :: PatSyn -> HsPatSynDetails Type
patSynType :: PatSyn -> Type
patSynMatcher :: PatSyn -> (Id, Bool)
patSynBuilder :: PatSyn -> Maybe (Id, Bool)
patSynExTyVars :: PatSyn -> [TyVar]
patSynSig :: PatSyn -> ([TyVar], [TyVar], ThetaType, ThetaType, [Type], Type)
patSynInstArgTys :: PatSyn -> [Type] -> [Type]
patSynInstResTy :: PatSyn -> [Type] -> Type
tidyPatSynIds :: (Id -> Id) -> PatSyn -> PatSyn
instance Eq PatSyn
instance Ord PatSyn
instance Uniquable PatSyn
instance NamedThing PatSyn
instance Outputable PatSyn
instance OutputableBndr PatSyn
instance Data PatSyn

module HsPat

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnBang</a></li>
--   </ul>
data Pat id
[WildPat] :: (PostTc id Type) -> Pat id
[VarPat] :: id -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnTilde</a></li>
--   </ul>
[LazyPat] :: (LPat id) -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnAt</a></li>
--   </ul>
[AsPat] :: (Located id) -> (LPat id) -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'('</tt>, <a>AnnClose</a>
--   <tt>')'</tt></li>
--   </ul>
[ParPat] :: (LPat id) -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnBang</a></li>
--   </ul>
[BangPat] :: (LPat id) -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'['</tt>, <a>AnnClose</a>
--   <tt>']'</tt></li>
--   </ul>
[ListPat] :: [LPat id] -> (PostTc id Type) -> (Maybe (PostTc id Type, SyntaxExpr id)) -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'('</tt> or
--   <tt>'(#'</tt>, <a>AnnClose</a> <tt>')'</tt> or <tt>'#)'</tt></li>
--   </ul>
[TuplePat] :: [LPat id] -> Boxity -> [PostTc id Type] -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'[:'</tt>,
--   <a>AnnClose</a> <tt>':]'</tt></li>
--   </ul>
[PArrPat] :: [LPat id] -> (PostTc id Type) -> Pat id
[ConPatIn] :: (Located id) -> (HsConPatDetails id) -> Pat id
[ConPatOut] :: Located ConLike -> [Type] -> [TyVar] -> [EvVar] -> TcEvBinds -> HsConPatDetails id -> HsWrapper -> Pat id
[pat_con] :: Pat id -> Located ConLike
[pat_arg_tys] :: Pat id -> [Type]
[pat_tvs] :: Pat id -> [TyVar]
[pat_dicts] :: Pat id -> [EvVar]
[pat_binds] :: Pat id -> TcEvBinds
[pat_args] :: Pat id -> HsConPatDetails id
[pat_wrap] :: Pat id -> HsWrapper

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnRarrow</a></li>
--   </ul>
[ViewPat] :: (LHsExpr id) -> (LPat id) -> (PostTc id Type) -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'$('</tt> <a>AnnClose</a>
--   <tt>')'</tt></li>
--   </ul>
[SplicePat] :: (HsSplice id) -> Pat id
[QuasiQuotePat] :: (HsQuasiQuote id) -> Pat id
[LitPat] :: HsLit -> Pat id
[NPat] :: (Located (HsOverLit id)) -> (Maybe (SyntaxExpr id)) -> (SyntaxExpr id) -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnVal</a> <tt><a>+</a></tt></li>
--   </ul>
[NPlusKPat] :: (Located id) -> (Located (HsOverLit id)) -> (SyntaxExpr id) -> (SyntaxExpr id) -> Pat id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDcolon</a></li>
--   </ul>
[SigPatIn] :: (LPat id) -> (HsWithBndrs id (LHsType id)) -> Pat id
[SigPatOut] :: (LPat id) -> Type -> Pat id
[CoPat] :: HsWrapper -> (Pat id) -> Type -> Pat id
type InPat id = LPat id
type OutPat id = LPat id
type LPat id = Located (Pat id)
data HsConDetails arg rec
[PrefixCon] :: [arg] -> HsConDetails arg rec
[RecCon] :: rec -> HsConDetails arg rec
[InfixCon] :: arg -> arg -> HsConDetails arg rec
type HsConPatDetails id = HsConDetails (LPat id) (HsRecFields id (LPat id))
hsConPatArgs :: HsConPatDetails id -> [LPat id]
data HsRecFields id arg
[HsRecFields] :: [LHsRecField id arg] -> Maybe Int -> HsRecFields id arg
[rec_flds] :: HsRecFields id arg -> [LHsRecField id arg]
[rec_dotdot] :: HsRecFields id arg -> Maybe Int

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnEqual</a>,</li>
--   </ul>
data HsRecField id arg
[HsRecField] :: Located id -> arg -> Bool -> HsRecField id arg
[hsRecFieldId] :: HsRecField id arg -> Located id
[hsRecFieldArg] :: HsRecField id arg -> arg
[hsRecPun] :: HsRecField id arg -> Bool
type LHsRecField id arg = Located (HsRecField id arg)
hsRecFields :: HsRecFields id arg -> [id]
mkPrefixConPat :: DataCon -> [OutPat id] -> [Type] -> OutPat id
mkCharLitPat :: String -> Char -> OutPat id
mkNilPat :: Type -> OutPat id
isStrictHsBind :: HsBind id -> Bool
looksLazyPatBind :: HsBind id -> Bool
isStrictLPat :: LPat id -> Bool
hsPatNeedsParens :: Pat a -> Bool
isIrrefutableHsPat :: OutputableBndr id => LPat id -> Bool
pprParendLPat :: (OutputableBndr name) => LPat name -> SDoc
pprConArgs :: OutputableBndr id => HsConPatDetails id -> SDoc
instance (Data id, Data arg) => Data (HsRecField id arg)
instance (Data id, Data arg) => Data (HsRecFields id arg)
instance (Data arg, Data rec) => Data (HsConDetails arg rec)
instance DataId id => Data (Pat id)
instance OutputableBndr name => Outputable (Pat name)
instance (OutputableBndr id, Outputable arg) => Outputable (HsRecFields id arg)
instance (OutputableBndr id, Outputable arg) => Outputable (HsRecField id arg)


-- | Abstract syntax of global declarations.
--   
--   Definitions for: <tt>SynDecl</tt> and <tt>ConDecl</tt>,
--   <tt>ClassDecl</tt>, <tt>InstDecl</tt>, <tt>DefaultDecl</tt> and
--   <tt>ForeignDecl</tt>.
module HsDecls

-- | A Haskell Declaration
data HsDecl id

-- | A type or class declaration.
[TyClD] :: (TyClDecl id) -> HsDecl id

-- | An instance declaration.
[InstD] :: (InstDecl id) -> HsDecl id
[DerivD] :: (DerivDecl id) -> HsDecl id
[ValD] :: (HsBind id) -> HsDecl id
[SigD] :: (Sig id) -> HsDecl id
[DefD] :: (DefaultDecl id) -> HsDecl id
[ForD] :: (ForeignDecl id) -> HsDecl id
[WarningD] :: (WarnDecls id) -> HsDecl id
[AnnD] :: (AnnDecl id) -> HsDecl id
[RuleD] :: (RuleDecls id) -> HsDecl id
[VectD] :: (VectDecl id) -> HsDecl id
[SpliceD] :: (SpliceDecl id) -> HsDecl id
[DocD] :: (DocDecl) -> HsDecl id
[QuasiQuoteD] :: (HsQuasiQuote id) -> HsDecl id
[RoleAnnotD] :: (RoleAnnotDecl id) -> HsDecl id
type LHsDecl id = Located (HsDecl id)  When in a list this may have  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi'
data HsDataDefn name

-- | Declares a data type or newtype, giving its constructors <tt>
--   data/newtype T a = <a>constrs</a> data/newtype instance T [a] =
--   <a>constrs</a> </tt>
[HsDataDefn] :: NewOrData -> LHsContext name -> Maybe (Located CType) -> Maybe (LHsKind name) -> [LConDecl name] -> Maybe (Located [LHsType name]) -> HsDataDefn name
[dd_ND] :: HsDataDefn name -> NewOrData

-- | Context
[dd_ctxt] :: HsDataDefn name -> LHsContext name
[dd_cType] :: HsDataDefn name -> Maybe (Located CType)

-- | Optional kind signature.
--   
--   <tt>(Just k)</tt> for a GADT-style <tt>data</tt>, or <tt>data
--   instance</tt> decl, with explicit kind sig
--   
--   Always <tt>Nothing</tt> for H98-syntax decls
[dd_kindSig] :: HsDataDefn name -> Maybe (LHsKind name)

-- | Data constructors
--   
--   For <tt>data T a = T1 | T2 a</tt> the <a>LConDecl</a>s all have
--   <a>ResTyH98</a>. For <tt>data T a where { T1 :: T a }</tt> the
--   <tt>LConDecls</tt> all have <a>ResTyGADT</a>.
[dd_cons] :: HsDataDefn name -> [LConDecl name]

-- | Derivings; <tt>Nothing</tt> =&gt; not specified, <tt>Just []</tt>
--   =&gt; derive exactly what is asked
--   
--   These "types" must be of form <tt> forall ab. C ty1 ty2 </tt>
--   Typically the foralls and ty args are empty, but they are non-empty
--   for the newtype-deriving case
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDeriving</a>,
--   <a>AnnOpen</a>,<a>AnnClose</a></li>
--   </ul>
[dd_derivs] :: HsDataDefn name -> Maybe (Located [LHsType name])

-- | A type or class declaration.
data TyClDecl name

-- | <pre>
--   type/data family T :: *-&gt;*
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnType</a>, <a>AnnData</a>,
--   <a>AnnFamily</a>,<a>AnnWhere</a>, <a>AnnOpen</a>,<a>AnnDcolon</a>,
--   <a>AnnClose</a></li>
--   </ul>
[FamDecl] :: FamilyDecl name -> TyClDecl name
[tcdFam] :: TyClDecl name -> FamilyDecl name

-- | <tt>type</tt> declaration
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnType</a>, <a>AnnEqual</a>,</li>
--   </ul>
[SynDecl] :: Located name -> LHsTyVarBndrs name -> LHsType name -> PostRn name NameSet -> TyClDecl name

-- | Type constructor
[tcdLName] :: TyClDecl name -> Located name

-- | Type variables; for an associated type these include outer binders
[tcdTyVars] :: TyClDecl name -> LHsTyVarBndrs name

-- | RHS of type declaration
[tcdRhs] :: TyClDecl name -> LHsType name
[tcdFVs] :: TyClDecl name -> PostRn name NameSet

-- | <tt>data</tt> declaration
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnData</a>, <a>AnnFamily</a>,
--   <a>AnnNewType</a>, <a>AnnNewType</a>,<a>AnnWhere</a></li>
--   </ul>
[DataDecl] :: Located name -> LHsTyVarBndrs name -> HsDataDefn name -> PostRn name NameSet -> TyClDecl name

-- | Type constructor
[tcdLName] :: TyClDecl name -> Located name

-- | Type variables; for an associated type these include outer binders
[tcdTyVars] :: TyClDecl name -> LHsTyVarBndrs name
[tcdDataDefn] :: TyClDecl name -> HsDataDefn name
[tcdFVs] :: TyClDecl name -> PostRn name NameSet

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnClass</a>,
--   <a>AnnWhere</a>,<a>AnnOpen</a>, <a>AnnClose</a></li>
--   <li>The tcdFDs will have <a>AnnVbar</a>, <a>AnnComma</a>
--   <a>AnnRarrow</a></li>
--   </ul>
[ClassDecl] :: LHsContext name -> Located name -> LHsTyVarBndrs name -> [Located (FunDep (Located name))] -> [LSig name] -> LHsBinds name -> [LFamilyDecl name] -> [LTyFamDefltEqn name] -> [LDocDecl] -> PostRn name NameSet -> TyClDecl name

-- | Context...
[tcdCtxt] :: TyClDecl name -> LHsContext name

-- | Type constructor
[tcdLName] :: TyClDecl name -> Located name

-- | Type variables; for an associated type these include outer binders
[tcdTyVars] :: TyClDecl name -> LHsTyVarBndrs name

-- | Functional deps
[tcdFDs] :: TyClDecl name -> [Located (FunDep (Located name))]

-- | Methods' signatures
[tcdSigs] :: TyClDecl name -> [LSig name]

-- | Default methods
[tcdMeths] :: TyClDecl name -> LHsBinds name

-- | Associated types;
[tcdATs] :: TyClDecl name -> [LFamilyDecl name]

-- | Associated type defaults
[tcdATDefs] :: TyClDecl name -> [LTyFamDefltEqn name]

-- | Haddock docs
[tcdDocs] :: TyClDecl name -> [LDocDecl]
[tcdFVs] :: TyClDecl name -> PostRn name NameSet
type LTyClDecl name = Located (TyClDecl name)
data TyClGroup name
[TyClGroup] :: [LTyClDecl name] -> [LRoleAnnotDecl name] -> TyClGroup name
[group_tyclds] :: TyClGroup name -> [LTyClDecl name]
[group_roles] :: TyClGroup name -> [LRoleAnnotDecl name]
tyClGroupConcat :: [TyClGroup name] -> [LTyClDecl name]
mkTyClGroup :: [LTyClDecl name] -> TyClGroup name

-- | type class
isClassDecl :: TyClDecl name -> Bool

-- | <tt>True</tt> <a>=</a> argument is a <tt>data</tt>/<tt>newtype</tt>
--   declaration.
isDataDecl :: TyClDecl name -> Bool

-- | type or type instance declaration
isSynDecl :: TyClDecl name -> Bool
tcdName :: TyClDecl name -> name

-- | type/data family declaration
isFamilyDecl :: TyClDecl name -> Bool

-- | type family declaration
isTypeFamilyDecl :: TyClDecl name -> Bool

-- | data family declaration
isDataFamilyDecl :: TyClDecl name -> Bool

-- | open type family info
isOpenTypeFamilyInfo :: FamilyInfo name -> Bool

-- | closed type family info
isClosedTypeFamilyInfo :: FamilyInfo name -> Bool
tyFamInstDeclName :: OutputableBndr name => TyFamInstDecl name -> name
tyFamInstDeclLName :: OutputableBndr name => TyFamInstDecl name -> Located name
countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int, Int)
pprTyClDeclFlavour :: TyClDecl a -> SDoc
tyClDeclLName :: TyClDecl name -> Located name
tyClDeclTyVars :: OutputableBndr name => TyClDecl name -> LHsTyVarBndrs name

-- | Does this declaration have a complete, user-supplied kind signature?
--   See Note [Complete user-supplied kind signatures]
hsDeclHasCusk :: TyClDecl name -> Bool

-- | Does this family declaration have a complete, user-supplied kind
--   signature?
famDeclHasCusk :: FamilyDecl name -> Bool
data FamilyDecl name
[FamilyDecl] :: FamilyInfo name -> Located name -> LHsTyVarBndrs name -> Maybe (LHsKind name) -> FamilyDecl name
[fdInfo] :: FamilyDecl name -> FamilyInfo name
[fdLName] :: FamilyDecl name -> Located name
[fdTyVars] :: FamilyDecl name -> LHsTyVarBndrs name
[fdKindSig] :: FamilyDecl name -> Maybe (LHsKind name)
type LFamilyDecl name = Located (FamilyDecl name)
data InstDecl name
[ClsInstD] :: ClsInstDecl name -> InstDecl name
[cid_inst] :: InstDecl name -> ClsInstDecl name
[DataFamInstD] :: DataFamInstDecl name -> InstDecl name
[dfid_inst] :: InstDecl name -> DataFamInstDecl name
[TyFamInstD] :: TyFamInstDecl name -> InstDecl name
[tfid_inst] :: InstDecl name -> TyFamInstDecl name
type LInstDecl name = Located (InstDecl name)
data NewOrData

-- | <pre>
--   newtype Blah ...
--   </pre>
[NewType] :: NewOrData

-- | <pre>
--   data Blah ...
--   </pre>
[DataType] :: NewOrData
data FamilyInfo name
[DataFamily] :: FamilyInfo name
[OpenTypeFamily] :: FamilyInfo name
[ClosedTypeFamily] :: [LTyFamInstEqn name] -> FamilyInfo name
data TyFamInstDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnType</a>, <a>AnnInstance</a>,</li>
--   </ul>
[TyFamInstDecl] :: LTyFamInstEqn name -> PostRn name NameSet -> TyFamInstDecl name
[tfid_eqn] :: TyFamInstDecl name -> LTyFamInstEqn name
[tfid_fvs] :: TyFamInstDecl name -> PostRn name NameSet
type LTyFamInstDecl name = Located (TyFamInstDecl name)
instDeclDataFamInsts :: [LInstDecl name] -> [DataFamInstDecl name]
data DataFamInstDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnData</a>,
--   <a>AnnNewType</a>,<a>AnnInstance</a>, <a>AnnWhere</a>,<a>AnnOpen</a>,
--   <a>AnnClose</a></li>
--   </ul>
[DataFamInstDecl] :: Located name -> HsTyPats name -> HsDataDefn name -> PostRn name NameSet -> DataFamInstDecl name
[dfid_tycon] :: DataFamInstDecl name -> Located name
[dfid_pats] :: DataFamInstDecl name -> HsTyPats name
[dfid_defn] :: DataFamInstDecl name -> HsDataDefn name
[dfid_fvs] :: DataFamInstDecl name -> PostRn name NameSet
type LDataFamInstDecl name = Located (DataFamInstDecl name)
pprDataFamInstFlavour :: DataFamInstDecl name -> SDoc

-- | One equation in a type family instance declaration See Note [Type
--   family instance declarations in HsSyn]
data TyFamEqn name pats

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnEqual</a></li>
--   </ul>
[TyFamEqn] :: Located name -> pats -> LHsType name -> TyFamEqn name pats
[tfe_tycon] :: TyFamEqn name pats -> Located name
[tfe_pats] :: TyFamEqn name pats -> pats
[tfe_rhs] :: TyFamEqn name pats -> LHsType name
type TyFamInstEqn name = TyFamEqn name (HsTyPats name)
type LTyFamInstEqn name = Located (TyFamInstEqn name)  May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a list
type TyFamDefltEqn name = TyFamEqn name (LHsTyVarBndrs name)
type LTyFamDefltEqn name = Located (TyFamDefltEqn name)
type HsTyPats name = HsWithBndrs name [LHsType name]  Type patterns (with kind and type bndrs) See Note [Family instance declaration binders]
type LClsInstDecl name = Located (ClsInstDecl name)
data ClsInstDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnInstance</a>, <a>AnnWhere</a>,
--   <a>AnnOpen</a>,<a>AnnClose</a>,</li>
--   </ul>
[ClsInstDecl] :: LHsType name -> LHsBinds name -> [LSig name] -> [LTyFamInstDecl name] -> [LDataFamInstDecl name] -> Maybe (Located OverlapMode) -> ClsInstDecl name
[cid_poly_ty] :: ClsInstDecl name -> LHsType name
[cid_binds] :: ClsInstDecl name -> LHsBinds name
[cid_sigs] :: ClsInstDecl name -> [LSig name]
[cid_tyfam_insts] :: ClsInstDecl name -> [LTyFamInstDecl name]
[cid_datafam_insts] :: ClsInstDecl name -> [LDataFamInstDecl name]

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnClose</a>,</li>
--   </ul>
[cid_overlap_mode] :: ClsInstDecl name -> Maybe (Located OverlapMode)
data DerivDecl name
[DerivDecl] :: LHsType name -> Maybe (Located OverlapMode) -> DerivDecl name
[deriv_type] :: DerivDecl name -> LHsType name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnClose</a>,
--   <a>AnnDeriving</a>, <a>AnnInstance</a></li>
--   </ul>
[deriv_overlap_mode] :: DerivDecl name -> Maybe (Located OverlapMode)
type LDerivDecl name = Located (DerivDecl name)
type LRuleDecls name = Located (RuleDecls name)
data RuleDecls name
[HsRules] :: SourceText -> [LRuleDecl name] -> RuleDecls name
[rds_src] :: RuleDecls name -> SourceText
[rds_rules] :: RuleDecls name -> [LRuleDecl name]
data RuleDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,<a>AnnTilde</a>,
--   <a>AnnVal</a>, <a>AnnClose</a>, <a>AnnForall</a>,<a>AnnDot</a>,
--   <a>AnnEqual</a>,</li>
--   </ul>
[HsRule] :: (Located RuleName) -> Activation -> [LRuleBndr name] -> (Located (HsExpr name)) -> (PostRn name NameSet) -> (Located (HsExpr name)) -> (PostRn name NameSet) -> RuleDecl name
type LRuleDecl name = Located (RuleDecl name)
data RuleBndr name
[RuleBndr] :: (Located name) -> RuleBndr name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnDcolon</a>,<a>AnnClose</a></li>
--   </ul>
[RuleBndrSig] :: (Located name) -> (HsWithBndrs name (LHsType name)) -> RuleBndr name
type LRuleBndr name = Located (RuleBndr name)
collectRuleBndrSigTys :: [RuleBndr name] -> [HsWithBndrs name (LHsType name)]
flattenRuleDecls :: [LRuleDecls name] -> [LRuleDecl name]
data VectDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnEqual</a>,<a>AnnClose</a></li>
--   </ul>
[HsVect] :: SourceText -> (Located name) -> (LHsExpr name) -> VectDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnClose</a></li>
--   </ul>
[HsNoVect] :: SourceText -> (Located name) -> VectDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnType</a>,<a>AnnClose</a>, <a>AnnEqual</a></li>
--   </ul>
[HsVectTypeIn] :: SourceText -> Bool -> (Located name) -> (Maybe (Located name)) -> VectDecl name
[HsVectTypeOut] :: Bool -> TyCon -> (Maybe TyCon) -> VectDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnClass</a>,<a>AnnClose</a>,</li>
--   </ul>
[HsVectClassIn] :: SourceText -> (Located name) -> VectDecl name
[HsVectClassOut] :: Class -> VectDecl name
[HsVectInstIn] :: (LHsType name) -> VectDecl name
[HsVectInstOut] :: ClsInst -> VectDecl name
type LVectDecl name = Located (VectDecl name)
lvectDeclName :: NamedThing name => LVectDecl name -> Name
lvectInstDecl :: LVectDecl name -> Bool
data DefaultDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a>s : <a>AnnDefault</a>,
--   <a>AnnOpen</a>,<a>AnnClose</a></li>
--   </ul>
[DefaultDecl] :: [LHsType name] -> DefaultDecl name
type LDefaultDecl name = Located (DefaultDecl name)
data SpliceExplicitFlag
[ExplicitSplice] :: SpliceExplicitFlag
[ImplicitSplice] :: SpliceExplicitFlag
data SpliceDecl id
[SpliceDecl] :: (Located (HsSplice id)) -> SpliceExplicitFlag -> SpliceDecl id
type LSpliceDecl name = Located (SpliceDecl name)
data ForeignDecl name
[ForeignImport] :: (Located name) -> (LHsType name) -> (PostTc name Coercion) -> ForeignImport -> ForeignDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnForeign</a>,
--   <a>AnnImport</a>,<a>AnnExport</a>, <a>AnnDcolon</a></li>
--   </ul>
[ForeignExport] :: (Located name) -> (LHsType name) -> (PostTc name Coercion) -> ForeignExport -> ForeignDecl name
type LForeignDecl name = Located (ForeignDecl name)
data ForeignImport
[CImport] :: (Located CCallConv) -> (Located Safety) -> (Maybe Header) -> CImportSpec -> (Located SourceText) -> ForeignImport
data ForeignExport
[CExport] :: (Located CExportSpec) -> (Located SourceText) -> ForeignExport
noForeignImportCoercionYet :: PlaceHolder
noForeignExportCoercionYet :: PlaceHolder
data CImportSpec
[CLabel] :: CLabelString -> CImportSpec
[CFunction] :: CCallTarget -> CImportSpec
[CWrapper] :: CImportSpec

-- | <pre>
--   data T b = forall a. Eq a =&gt; MkT a b
--     MkT :: forall b a. Eq a =&gt; MkT a b
--   
--   data T b where
--        MkT1 :: Int -&gt; T Int
--   
--   data T = Int <tt>MkT</tt> Int
--          | MkT2
--   
--   data T a where
--        Int <tt>MkT</tt> Int :: T Int
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a>s : <a>AnnOpen</a>,
--   <a>AnnDotdot</a>,<a>AnnCLose</a>, <a>AnnEqual</a>,<a>AnnVbar</a>,
--   <a>AnnDarrow</a>,<a>AnnDarrow</a>, <a>AnnForall</a>,<a>AnnDot</a></li>
--   </ul>
data ConDecl name
[ConDecl] :: [Located name] -> HsExplicitFlag -> LHsTyVarBndrs name -> LHsContext name -> HsConDeclDetails name -> ResType (LHsType name) -> Maybe LHsDocString -> Bool -> ConDecl name

-- | Constructor names. This is used for the DataCon itself, and for the
--   user-callable wrapper Id. It is a list to deal with GADT constructors
--   of the form T1, T2, T3 :: <a>payload</a>
[con_names] :: ConDecl name -> [Located name]

-- | Is there an user-written forall? (cf. <a>HsForAllTy</a>)
[con_explicit] :: ConDecl name -> HsExplicitFlag

-- | Type variables. Depending on <a>con_res</a> this describes the
--   following entities
--   
--   <ul>
--   <li>ResTyH98: the constructor's *existential* type variables</li>
--   <li>ResTyGADT: *all* the constructor's quantified type variables</li>
--   </ul>
--   
--   If con_explicit is Implicit, then con_qvars is irrelevant until after
--   renaming.
[con_qvars] :: ConDecl name -> LHsTyVarBndrs name

-- | The context. This <i>does not</i> include the "stupid theta" which
--   lives only in the <tt>TyData</tt> decl.
[con_cxt] :: ConDecl name -> LHsContext name

-- | The main payload
[con_details] :: ConDecl name -> HsConDeclDetails name

-- | Result type of the constructor
[con_res] :: ConDecl name -> ResType (LHsType name)

-- | A possible Haddock comment.
[con_doc] :: ConDecl name -> Maybe LHsDocString

-- | TEMPORARY field; True <a>=</a> user has employed now-deprecated syntax
--   for GADT-style record decl C { blah } :: T a b Remove this when we no
--   longer parse this stuff, and hence do not need to report decprecated
--   use
[con_old_rec] :: ConDecl name -> Bool
type LConDecl name = Located (ConDecl name)  May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a GADT constructor list
data ResType ty
[ResTyH98] :: ResType ty
[ResTyGADT] :: SrcSpan -> ty -> ResType ty
type HsConDeclDetails name = HsConDetails (LBangType name) (Located [LConDeclField name])
hsConDeclArgTys :: HsConDeclDetails name -> [LBangType name]
data DocDecl
[DocCommentNext] :: HsDocString -> DocDecl
[DocCommentPrev] :: HsDocString -> DocDecl
[DocCommentNamed] :: String -> HsDocString -> DocDecl
[DocGroup] :: Int -> HsDocString -> DocDecl
type LDocDecl = Located (DocDecl)
docDeclDoc :: DocDecl -> HsDocString
data WarnDecl name
[Warning] :: [Located name] -> WarningTxt -> WarnDecl name
type LWarnDecl name = Located (WarnDecl name)
data WarnDecls name
[Warnings] :: SourceText -> [LWarnDecl name] -> WarnDecls name
[wd_src] :: WarnDecls name -> SourceText
[wd_warnings] :: WarnDecls name -> [LWarnDecl name]
type LWarnDecls name = Located (WarnDecls name)
data AnnDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnType</a>
--   <a>AnnModule</a> <a>AnnClose</a></li>
--   </ul>
[HsAnnotation] :: SourceText -> (AnnProvenance name) -> (Located (HsExpr name)) -> AnnDecl name
type LAnnDecl name = Located (AnnDecl name)
data AnnProvenance name
[ValueAnnProvenance] :: (Located name) -> AnnProvenance name
[TypeAnnProvenance] :: (Located name) -> AnnProvenance name
[ModuleAnnProvenance] :: AnnProvenance name
annProvenanceName_maybe :: AnnProvenance name -> Maybe name
data RoleAnnotDecl name

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnType</a>, <a>AnnRole</a></li>
--   </ul>
[RoleAnnotDecl] :: (Located name) -> [Located (Maybe Role)] -> RoleAnnotDecl name
type LRoleAnnotDecl name = Located (RoleAnnotDecl name)
roleAnnotDeclName :: RoleAnnotDecl name -> name

-- | A <a>HsDecl</a> is categorised into a <a>HsGroup</a> before being fed
--   to the renamer.
data HsGroup id
[HsGroup] :: HsValBinds id -> [LSpliceDecl id] -> [TyClGroup id] -> [LInstDecl id] -> [LDerivDecl id] -> [LFixitySig id] -> [LDefaultDecl id] -> [LForeignDecl id] -> [LWarnDecls id] -> [LAnnDecl id] -> [LRuleDecls id] -> [LVectDecl id] -> [LDocDecl] -> HsGroup id
[hs_valds] :: HsGroup id -> HsValBinds id
[hs_splcds] :: HsGroup id -> [LSpliceDecl id]
[hs_tyclds] :: HsGroup id -> [TyClGroup id]
[hs_instds] :: HsGroup id -> [LInstDecl id]
[hs_derivds] :: HsGroup id -> [LDerivDecl id]
[hs_fixds] :: HsGroup id -> [LFixitySig id]
[hs_defds] :: HsGroup id -> [LDefaultDecl id]
[hs_fords] :: HsGroup id -> [LForeignDecl id]
[hs_warnds] :: HsGroup id -> [LWarnDecls id]
[hs_annds] :: HsGroup id -> [LAnnDecl id]
[hs_ruleds] :: HsGroup id -> [LRuleDecls id]
[hs_vects] :: HsGroup id -> [LVectDecl id]
[hs_docs] :: HsGroup id -> [LDocDecl]
emptyRdrGroup :: HsGroup a
emptyRnGroup :: HsGroup a
appendGroups :: HsGroup a -> HsGroup a -> HsGroup a
instance Data name => Data (RoleAnnotDecl name)
instance Functor AnnProvenance
instance Data name => Data (AnnProvenance name)
instance Data name => Data (WarnDecls name)
instance Data name => Data (WarnDecl name)
instance Data DocDecl
instance Data ForeignExport
instance Data ForeignImport
instance Data CImportSpec
instance Data ty => Data (ResType ty)
instance Data NewOrData
instance Eq NewOrData
instance Data SpliceExplicitFlag
instance DataId id => Data (HsDecl id)
instance DataId id => Data (HsGroup id)
instance DataId id => Data (SpliceDecl id)
instance DataId id => Data (TyClDecl id)
instance DataId id => Data (TyClGroup id)
instance DataId id => Data (FamilyDecl id)
instance DataId name => Data (FamilyInfo name)
instance DataId id => Data (HsDataDefn id)
instance DataId name => Data (ConDecl name)
instance (DataId name, Data pats) => Data (TyFamEqn name pats)
instance DataId name => Data (TyFamInstDecl name)
instance DataId name => Data (DataFamInstDecl name)
instance DataId id => Data (ClsInstDecl id)
instance DataId id => Data (InstDecl id)
instance DataId name => Data (DerivDecl name)
instance DataId name => Data (DefaultDecl name)
instance DataId name => Data (ForeignDecl name)
instance DataId name => Data (RuleDecls name)
instance DataId name => Data (RuleDecl name)
instance DataId name => Data (RuleBndr name)
instance DataId name => Data (VectDecl name)
instance DataId name => Data (AnnDecl name)
instance Foldable AnnProvenance
instance Traversable AnnProvenance
instance OutputableBndr name => Outputable (HsDecl name)
instance OutputableBndr name => Outputable (HsGroup name)
instance OutputableBndr name => Outputable (SpliceDecl name)
instance OutputableBndr name => Outputable (TyClDecl name)
instance OutputableBndr name => Outputable (TyClGroup name)
instance OutputableBndr name => Outputable (FamilyDecl name)
instance Outputable (FamilyInfo name)
instance Outputable ty => Outputable (ResType ty)
instance OutputableBndr name => Outputable (HsDataDefn name)
instance Outputable NewOrData
instance OutputableBndr name => Outputable (ConDecl name)
instance Outputable name => OutputableBndr [Located name]
instance OutputableBndr name => Outputable (TyFamInstDecl name)
instance OutputableBndr name => Outputable (DataFamInstDecl name)
instance OutputableBndr name => Outputable (ClsInstDecl name)
instance OutputableBndr name => Outputable (InstDecl name)
instance OutputableBndr name => Outputable (DerivDecl name)
instance OutputableBndr name => Outputable (DefaultDecl name)
instance OutputableBndr name => Outputable (ForeignDecl name)
instance Outputable ForeignImport
instance Outputable ForeignExport
instance OutputableBndr name => Outputable (RuleDecls name)
instance OutputableBndr name => Outputable (RuleDecl name)
instance OutputableBndr name => Outputable (RuleBndr name)
instance OutputableBndr name => Outputable (VectDecl name)
instance Outputable DocDecl
instance OutputableBndr name => Outputable (WarnDecls name)
instance OutputableBndr name => Outputable (WarnDecl name)
instance OutputableBndr name => Outputable (AnnDecl name)
instance OutputableBndr name => Outputable (RoleAnnotDecl name)


-- | Abstract Haskell syntax for expressions.
module HsExpr
type LHsExpr id = Located (HsExpr id)  May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list

-- | PostTcExpr is an evidence expression attached to the syntax tree by
--   the type checker (c.f. postTcType).
type PostTcExpr = HsExpr Id

-- | We use a PostTcTable where there are a bunch of pieces of evidence,
--   more than is convenient to keep individually.
type PostTcTable = [(Name, PostTcExpr)]
noPostTcExpr :: PostTcExpr
noPostTcTable :: PostTcTable

-- | SyntaxExpr is like <a>PostTcExpr</a>, but it's filled in a little
--   earlier, by the renamer. It's used for rebindable syntax.
--   
--   E.g. <tt>(&gt;&gt;=)</tt> is filled in before the renamer by the
--   appropriate <a>Name</a> for <tt>(&gt;&gt;=)</tt>, and then
--   instantiated by the type checker with its type args etc
type SyntaxExpr id = HsExpr id
noSyntaxExpr :: SyntaxExpr id
type CmdSyntaxTable id = [(Name, SyntaxExpr id)]

-- | A Haskell expression.
data HsExpr id

-- | Variable
[HsVar] :: id -> HsExpr id

-- | Implicit parameter
[HsIPVar] :: HsIPName -> HsExpr id

-- | Overloaded literals
[HsOverLit] :: (HsOverLit id) -> HsExpr id

-- | Simple (non-overloaded) literals
[HsLit] :: HsLit -> HsExpr id

-- | Lambda abstraction. Currently always a single match
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnLam</a>, <a>AnnRarrow</a>,</li>
--   </ul>
[HsLam] :: (MatchGroup id (LHsExpr id)) -> HsExpr id

-- | Lambda-case
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnLam</a>,
--   <a>AnnCase</a>,<a>AnnOpen</a>, <a>AnnClose</a></li>
--   </ul>
[HsLamCase] :: (PostTc id Type) -> (MatchGroup id (LHsExpr id)) -> HsExpr id

-- | Application
[HsApp] :: (LHsExpr id) -> (LHsExpr id) -> HsExpr id

-- | Operator applications: NB Bracketed ops such as (+) come out as Vars.
[OpApp] :: (LHsExpr id) -> (LHsExpr id) -> (PostRn id Fixity) -> (LHsExpr id) -> HsExpr id

-- | Negation operator. Contains the negated expression and the name of
--   <a>negate</a>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnMinus</a></li>
--   </ul>
[NegApp] :: (LHsExpr id) -> (SyntaxExpr id) -> HsExpr id

-- | Parenthesised expr; see Note [Parens in HsSyn]
[HsPar] :: (LHsExpr id) -> HsExpr id
[SectionL] :: (LHsExpr id) -> (LHsExpr id) -> HsExpr id
[SectionR] :: (LHsExpr id) -> (LHsExpr id) -> HsExpr id

-- | Used for explicit tuples and sections thereof
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnClose</a></li>
--   </ul>
[ExplicitTuple] :: [LHsTupArg id] -> Boxity -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnCase</a>, <a>AnnOf</a>,<a>AnnOpen</a>
--   <tt>'{'</tt>, <a>AnnClose</a> <tt>'}'</tt></li>
--   </ul>
[HsCase] :: (LHsExpr id) -> (MatchGroup id (LHsExpr id)) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnIf</a>, <a>AnnSemi</a>,
--   <a>AnnThen</a>,<a>AnnSemi</a>, <a>AnnElse</a>,</li>
--   </ul>
[HsIf] :: (Maybe (SyntaxExpr id)) -> (LHsExpr id) -> (LHsExpr id) -> (LHsExpr id) -> HsExpr id

-- | Multi-way if
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnIf</a>
--   <a>AnnOpen</a>,<a>AnnClose</a>,</li>
--   </ul>
[HsMultiIf] :: (PostTc id Type) -> [LGRHS id (LHsExpr id)] -> HsExpr id

-- | let(rec)
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnLet</a>, <a>AnnOpen</a> <tt>'{'</tt>,
--   <a>AnnClose</a> <tt>'}'</tt>,<a>AnnIn</a></li>
--   </ul>
[HsLet] :: (HsLocalBinds id) -> (LHsExpr id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDo</a>, <a>AnnOpen</a>,
--   <a>AnnSemi</a>, <a>AnnVbar</a>, <a>AnnClose</a></li>
--   </ul>
[HsDo] :: (HsStmtContext Name) -> [ExprLStmt id] -> (PostTc id Type) -> HsExpr id

-- | Syntactic list: [a,b,c,...]
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'['</tt>, <a>AnnClose</a>
--   <tt>']'</tt></li>
--   </ul>
[ExplicitList] :: (PostTc id Type) -> (Maybe (SyntaxExpr id)) -> [LHsExpr id] -> HsExpr id

-- | Syntactic parallel array: [:e1, ..., en:]
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'[:'</tt>,
--   <a>AnnDotdot</a>,<a>AnnComma</a>, <a>AnnVbar</a> <a>AnnClose</a>
--   <tt>':]'</tt></li>
--   </ul>
[ExplicitPArr] :: (PostTc id Type) -> [LHsExpr id] -> HsExpr id

-- | Record construction
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{'</tt>,
--   <a>AnnDotdot</a>,<a>AnnClose</a> <tt>'}'</tt></li>
--   </ul>
[RecordCon] :: (Located id) -> PostTcExpr -> (HsRecordBinds id) -> HsExpr id

-- | Record update
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{'</tt>,
--   <a>AnnDotdot</a>,<a>AnnClose</a> <tt>'}'</tt></li>
--   </ul>
[RecordUpd] :: (LHsExpr id) -> (HsRecordBinds id) -> [DataCon] -> [PostTc id Type] -> [PostTc id Type] -> HsExpr id

-- | Expression with an explicit type signature. <tt>e :: type</tt>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDcolon</a></li>
--   </ul>
[ExprWithTySig] :: (LHsExpr id) -> (LHsType id) -> (PostRn id [Name]) -> HsExpr id
[ExprWithTySigOut] :: (LHsExpr id) -> (LHsType Name) -> HsExpr id

-- | Arithmetic sequence
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'['</tt>,
--   <a>AnnComma</a>,<a>AnnDotdot</a>, <a>AnnClose</a> <tt>']'</tt></li>
--   </ul>
[ArithSeq] :: PostTcExpr -> (Maybe (SyntaxExpr id)) -> (ArithSeqInfo id) -> HsExpr id

-- | Arithmetic sequence for parallel array
--   
--   <pre>
--   [:e1..e2:] or [:e1, e2..e3:]
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'[:'</tt>,
--   <a>AnnComma</a>,<a>AnnDotdot</a>, <a>AnnVbar</a>, <a>AnnClose</a>
--   <tt>':]'</tt></li>
--   </ul>
[PArrSeq] :: PostTcExpr -> (ArithSeqInfo id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{-# SCC'</tt>,
--   <a>AnnVal</a> or <a>AnnValStr</a>, <a>AnnClose</a> <tt>'#-}'</tt></li>
--   </ul>
[HsSCC] :: SourceText -> FastString -> (LHsExpr id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'{-# CORE'</tt>,
--   <a>AnnVal</a>, <a>AnnClose</a> <tt>'#-}'</tt></li>
--   </ul>
[HsCoreAnn] :: SourceText -> FastString -> (LHsExpr id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnOpen</a>,<a>AnnClose</a>, <a>AnnClose</a></li>
--   </ul>
[HsBracket] :: (HsBracket id) -> HsExpr id
[HsRnBracketOut] :: (HsBracket Name) -> [PendingRnSplice] -> HsExpr id
[HsTcBracketOut] :: (HsBracket Name) -> [PendingTcSplice] -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnClose</a></li>
--   </ul>
[HsSpliceE] :: Bool -> (HsSplice id) -> HsExpr id
[HsQuasiQuoteE] :: (HsQuasiQuote id) -> HsExpr id

-- | <tt>proc</tt> notation for Arrows
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnProc</a>, <a>AnnRarrow</a></li>
--   </ul>
[HsProc] :: (LPat id) -> (LHsCmdTop id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnStatic</a>,</li>
--   </ul>
[HsStatic] :: (LHsExpr id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>Annlarrowtail</a>,
--   <a>Annrarrowtail</a>,<a>AnnLarrowtail</a>, <a>AnnRarrowtail</a></li>
--   </ul>
[HsArrApp] :: (LHsExpr id) -> (LHsExpr id) -> (PostTc id Type) -> HsArrAppType -> Bool -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'(|'</tt>,
--   <a>AnnClose</a> <tt>'|)'</tt></li>
--   </ul>
[HsArrForm] :: (LHsExpr id) -> (Maybe Fixity) -> [LHsCmdTop id] -> HsExpr id
[HsTick] :: (Tickish id) -> (LHsExpr id) -> HsExpr id
[HsBinTick] :: Int -> Int -> (LHsExpr id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>, <a>AnnOpen</a> <tt>'{-#
--   GENERATED'</tt>, <a>AnnVal</a>,<a>AnnVal</a>,
--   <a>AnnColon</a>,<a>AnnVal</a>, <a>AnnMinus</a>,
--   <a>AnnVal</a>,<a>AnnColon</a>, <a>AnnVal</a>, <a>AnnClose</a>
--   <tt>'#-}'</tt></li>
--   </ul>
[HsTickPragma] :: SourceText -> (FastString, (Int, Int), (Int, Int)) -> (LHsExpr id) -> HsExpr id
[EWildPat] :: HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnAt</a></li>
--   </ul>
[EAsPat] :: (Located id) -> (LHsExpr id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnRarrow</a></li>
--   </ul>
[EViewPat] :: (LHsExpr id) -> (LHsExpr id) -> HsExpr id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnTilde</a></li>
--   </ul>
[ELazyPat] :: (LHsExpr id) -> HsExpr id
[HsType] :: (LHsType id) -> HsExpr id
[HsWrap] :: HsWrapper -> (HsExpr id) -> HsExpr id
[HsUnboundVar] :: RdrName -> HsExpr id

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

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnComma</a></li>
--   </ul>
data HsTupArg id

-- | The argument
[Present] :: (LHsExpr id) -> HsTupArg id

-- | The argument is missing, but this is its type
[Missing] :: (PostTc id Type) -> HsTupArg id
tupArgPresent :: LHsTupArg id -> Bool
pprLExpr :: OutputableBndr id => LHsExpr id -> SDoc
pprExpr :: OutputableBndr id => HsExpr id -> SDoc
isQuietHsExpr :: HsExpr id -> Bool
pprBinds :: (OutputableBndr idL, OutputableBndr idR) => HsLocalBindsLR idL idR -> SDoc
ppr_lexpr :: OutputableBndr id => LHsExpr id -> SDoc
ppr_expr :: OutputableBndr id => HsExpr id -> SDoc
pprDebugParendExpr :: OutputableBndr id => LHsExpr id -> SDoc
pprParendExpr :: OutputableBndr id => LHsExpr id -> SDoc
hsExprNeedsParens :: HsExpr id -> Bool
isAtomicHsExpr :: HsExpr id -> Bool
type LHsCmd id = Located (HsCmd id)
data HsCmd id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>Annlarrowtail</a>,
--   <a>Annrarrowtail</a>,<a>AnnLarrowtail</a>, <a>AnnRarrowtail</a></li>
--   </ul>
[HsCmdArrApp] :: (LHsExpr id) -> (LHsExpr id) -> (PostTc id Type) -> HsArrAppType -> Bool -> HsCmd id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'(|'</tt>,
--   <a>AnnClose</a> <tt>'|)'</tt></li>
--   </ul>
[HsCmdArrForm] :: (LHsExpr id) -> (Maybe Fixity) -> [LHsCmdTop id] -> HsCmd id
[HsCmdApp] :: (LHsCmd id) -> (LHsExpr id) -> HsCmd id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnLam</a>, <a>AnnRarrow</a>,</li>
--   </ul>
[HsCmdLam] :: (MatchGroup id (LHsCmd id)) -> HsCmd id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a> <tt>'('</tt>, <a>AnnClose</a>
--   <tt>')'</tt></li>
--   </ul>
[HsCmdPar] :: (LHsCmd id) -> HsCmd id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnCase</a>, <a>AnnOf</a>,<a>AnnOpen</a>
--   <tt>'{'</tt>, <a>AnnClose</a> <tt>'}'</tt></li>
--   </ul>
[HsCmdCase] :: (LHsExpr id) -> (MatchGroup id (LHsCmd id)) -> HsCmd id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnIf</a>, <a>AnnSemi</a>,
--   <a>AnnThen</a>,<a>AnnSemi</a>, <a>AnnElse</a>,</li>
--   </ul>
[HsCmdIf] :: (Maybe (SyntaxExpr id)) -> (LHsExpr id) -> (LHsCmd id) -> (LHsCmd id) -> HsCmd id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnLet</a>, <a>AnnOpen</a> <tt>'{'</tt>,
--   <a>AnnClose</a> <tt>'}'</tt>,<a>AnnIn</a></li>
--   </ul>
[HsCmdLet] :: (HsLocalBinds id) -> (LHsCmd id) -> HsCmd id

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnDo</a>, <a>AnnOpen</a>,
--   <a>AnnSemi</a>, <a>AnnVbar</a>, <a>AnnClose</a></li>
--   </ul>
[HsCmdDo] :: [CmdLStmt id] -> (PostTc id Type) -> HsCmd id
[HsCmdCast] :: TcCoercion -> (HsCmd id) -> HsCmd id
data HsArrAppType
[HsHigherOrderApp] :: HsArrAppType
[HsFirstOrderApp] :: HsArrAppType

-- | Top-level command, introducing a new arrow. This may occur inside a
--   proc (where the stack is empty) or as an argument of a command-forming
--   operator.
type LHsCmdTop id = Located (HsCmdTop id)
data HsCmdTop id
[HsCmdTop] :: (LHsCmd id) -> (PostTc id Type) -> (PostTc id Type) -> (CmdSyntaxTable id) -> HsCmdTop id
pprLCmd :: OutputableBndr id => LHsCmd id -> SDoc
pprCmd :: OutputableBndr id => HsCmd id -> SDoc
isQuietHsCmd :: HsCmd id -> Bool
ppr_lcmd :: OutputableBndr id => LHsCmd id -> SDoc
ppr_cmd :: OutputableBndr id => HsCmd id -> SDoc
pprCmdArg :: OutputableBndr id => HsCmdTop id -> SDoc
type HsRecordBinds id = HsRecFields id (LHsExpr id)
data MatchGroup id body
[MG] :: [LMatch id body] -> [PostTc id Type] -> PostTc id Type -> Origin -> MatchGroup id body
[mg_alts] :: MatchGroup id body -> [LMatch id body]
[mg_arg_tys] :: MatchGroup id body -> [PostTc id Type]
[mg_res_ty] :: MatchGroup id body -> PostTc id Type
[mg_origin] :: MatchGroup id body -> Origin

-- | May have <a>AnnKeywordId</a> : <a>AnnSemi</a> when in a list
type LMatch id body = Located (Match id body)
data Match id body
[Match] :: (Maybe (Located id, Bool)) -> [LPat id] -> (Maybe (LHsType id)) -> (GRHSs id body) -> Match id body
[m_fun_id_infix] :: Match id body -> (Maybe (Located id, Bool))
[m_pats] :: Match id body -> [LPat id]
[m_type] :: Match id body -> (Maybe (LHsType id))
[m_grhss] :: Match id body -> (GRHSs id body)
isEmptyMatchGroup :: MatchGroup id body -> Bool
matchGroupArity :: MatchGroup id body -> Arity
hsLMatchPats :: LMatch id body -> [LPat id]

-- | GRHSs are used both for pattern bindings and for Matches
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnVbar</a>,
--   <a>AnnEqual</a>,<a>AnnWhere</a>, <a>AnnOpen</a>,<a>AnnClose</a>
--   <a>AnnRarrow</a>,<a>AnnSemi</a></li>
--   </ul>
data GRHSs id body
[GRHSs] :: [LGRHS id body] -> (HsLocalBinds id) -> GRHSs id body

-- | Guarded RHSs
[grhssGRHSs] :: GRHSs id body -> [LGRHS id body]

-- | The where clause
[grhssLocalBinds] :: GRHSs id body -> (HsLocalBinds id)
type LGRHS id body = Located (GRHS id body)

-- | Guarded Right Hand Side.
data GRHS id body
[GRHS] :: [GuardLStmt id] -> body -> GRHS id body
pprMatches :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => HsMatchContext idL -> MatchGroup idR body -> SDoc
pprFunBind :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => idL -> Bool -> MatchGroup idR body -> SDoc
pprPatBind :: (OutputableBndr bndr, OutputableBndr id, Outputable body) => LPat bndr -> GRHSs id body -> SDoc
pprMatch :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => HsMatchContext idL -> Match idR body -> SDoc
pprGRHSs :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => HsMatchContext idL -> GRHSs idR body -> SDoc
pprGRHS :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => HsMatchContext idL -> GRHS idR body -> SDoc
pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc
type LStmt id body = Located (StmtLR id id body)
type LStmtLR idL idR body = Located (StmtLR idL idR body)
type Stmt id body = StmtLR id id body
type CmdLStmt id = LStmt id (LHsCmd id)
type CmdStmt id = Stmt id (LHsCmd id)
type ExprLStmt id = LStmt id (LHsExpr id)
type ExprStmt id = Stmt id (LHsExpr id)
type GuardLStmt id = LStmt id (LHsExpr id)
type GuardStmt id = Stmt id (LHsExpr id)
type GhciLStmt id = LStmt id (LHsExpr id)
type GhciStmt id = Stmt id (LHsExpr id)

-- | API Annotations when in qualifier lists or guards -
--   <a>AnnKeywordId</a> : <a>AnnVbar</a>, <a>AnnComma</a>,<a>AnnThen</a>,
--   <a>AnnBy</a>,<a>AnnBy</a>, <a>AnnGroup</a>,<a>AnnUsing</a>
data StmtLR idL idR body
[LastStmt] :: body -> (SyntaxExpr idR) -> StmtLR idL idR body

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnLarrow</a></li>
--   </ul>
[BindStmt] :: (LPat idL) -> body -> (SyntaxExpr idR) -> (SyntaxExpr idR) -> StmtLR idL idR body
[BodyStmt] :: body -> (SyntaxExpr idR) -> (SyntaxExpr idR) -> (PostTc idR Type) -> StmtLR idL idR body

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnLet</a> <a>AnnOpen</a>
--   <tt>'{'</tt>,<a>AnnClose</a> <tt>'}'</tt>,</li>
--   </ul>
[LetStmt] :: (HsLocalBindsLR idL idR) -> StmtLR idL idR body
[ParStmt] :: [ParStmtBlock idL idR] -> (SyntaxExpr idR) -> (SyntaxExpr idR) -> StmtLR idL idR body
[TransStmt] :: TransForm -> [ExprLStmt idL] -> [(idR, idR)] -> LHsExpr idR -> Maybe (LHsExpr idR) -> SyntaxExpr idR -> SyntaxExpr idR -> SyntaxExpr idR -> StmtLR idL idR body
[trS_form] :: StmtLR idL idR body -> TransForm
[trS_stmts] :: StmtLR idL idR body -> [ExprLStmt idL]
[trS_bndrs] :: StmtLR idL idR body -> [(idR, idR)]
[trS_using] :: StmtLR idL idR body -> LHsExpr idR
[trS_by] :: StmtLR idL idR body -> Maybe (LHsExpr idR)
[trS_ret] :: StmtLR idL idR body -> SyntaxExpr idR
[trS_bind] :: StmtLR idL idR body -> SyntaxExpr idR
[trS_fmap] :: StmtLR idL idR body -> SyntaxExpr idR

-- | <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnRec</a></li>
--   </ul>
[RecStmt] :: [LStmtLR idL idR body] -> [idR] -> [idR] -> SyntaxExpr idR -> SyntaxExpr idR -> SyntaxExpr idR -> [PostTcExpr] -> [PostTcExpr] -> PostTc idR Type -> StmtLR idL idR body
[recS_stmts] :: StmtLR idL idR body -> [LStmtLR idL idR body]
[recS_later_ids] :: StmtLR idL idR body -> [idR]
[recS_rec_ids] :: StmtLR idL idR body -> [idR]
[recS_bind_fn] :: StmtLR idL idR body -> SyntaxExpr idR
[recS_ret_fn] :: StmtLR idL idR body -> SyntaxExpr idR
[recS_mfix_fn] :: StmtLR idL idR body -> SyntaxExpr idR
[recS_later_rets] :: StmtLR idL idR body -> [PostTcExpr]
[recS_rec_rets] :: StmtLR idL idR body -> [PostTcExpr]
[recS_ret_ty] :: StmtLR idL idR body -> PostTc idR Type
data TransForm
[ThenForm] :: TransForm
[GroupForm] :: TransForm
data ParStmtBlock idL idR
[ParStmtBlock] :: [ExprLStmt idL] -> [idR] -> (SyntaxExpr idR) -> ParStmtBlock idL idR
pprStmt :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => (StmtLR idL idR body) -> SDoc
pprTransformStmt :: OutputableBndr id => [id] -> LHsExpr id -> Maybe (LHsExpr id) -> SDoc
pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> SDoc
pprBy :: Outputable body => Maybe body -> SDoc
pprDo :: (OutputableBndr id, Outputable body) => HsStmtContext any -> [LStmt id body] -> SDoc
ppr_do_stmts :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => [LStmtLR idL idR body] -> SDoc
pprComp :: (OutputableBndr id, Outputable body) => [LStmt id body] -> SDoc
pprQuals :: (OutputableBndr id, Outputable body) => [LStmt id body] -> SDoc
data HsSplice id
[HsSplice] :: id -> (LHsExpr id) -> HsSplice id
data PendingSplice id
[PendSplice] :: Name -> (LHsExpr id) -> PendingSplice id
data PendingRnSplice
[PendingRnExpSplice] :: (PendingSplice Name) -> PendingRnSplice
[PendingRnPatSplice] :: (PendingSplice Name) -> PendingRnSplice
[PendingRnTypeSplice] :: (PendingSplice Name) -> PendingRnSplice
[PendingRnDeclSplice] :: (PendingSplice Name) -> PendingRnSplice
[PendingRnCrossStageSplice] :: Name -> PendingRnSplice
type PendingTcSplice = PendingSplice Id
pprUntypedSplice :: OutputableBndr id => HsSplice id -> SDoc
pprTypedSplice :: OutputableBndr id => HsSplice id -> SDoc
pprSplice :: OutputableBndr id => Bool -> HsSplice id -> SDoc
data HsBracket id
[ExpBr] :: (LHsExpr id) -> HsBracket id
[PatBr] :: (LPat id) -> HsBracket id
[DecBrL] :: [LHsDecl id] -> HsBracket id
[DecBrG] :: (HsGroup id) -> HsBracket id
[TypBr] :: (LHsType id) -> HsBracket id
[VarBr] :: Bool -> id -> HsBracket id
[TExpBr] :: (LHsExpr id) -> HsBracket id
isTypedBracket :: HsBracket id -> Bool
pprHsBracket :: OutputableBndr id => HsBracket id -> SDoc
thBrackets :: SDoc -> SDoc -> SDoc
thTyBrackets :: SDoc -> SDoc
data ArithSeqInfo id
[From] :: (LHsExpr id) -> ArithSeqInfo id
[FromThen] :: (LHsExpr id) -> (LHsExpr id) -> ArithSeqInfo id
[FromTo] :: (LHsExpr id) -> (LHsExpr id) -> ArithSeqInfo id
[FromThenTo] :: (LHsExpr id) -> (LHsExpr id) -> (LHsExpr id) -> ArithSeqInfo id
pp_dotdot :: SDoc
data HsMatchContext id
[FunRhs] :: id -> Bool -> HsMatchContext id
[LambdaExpr] :: HsMatchContext id
[CaseAlt] :: HsMatchContext id
[IfAlt] :: HsMatchContext id
[ProcExpr] :: HsMatchContext id
[PatBindRhs] :: HsMatchContext id
[RecUpd] :: HsMatchContext id
[StmtCtxt] :: (HsStmtContext id) -> HsMatchContext id
[ThPatSplice] :: HsMatchContext id
[ThPatQuote] :: HsMatchContext id
[PatSyn] :: HsMatchContext id
data HsStmtContext id
[ListComp] :: HsStmtContext id
[MonadComp] :: HsStmtContext id
[PArrComp] :: HsStmtContext id
[DoExpr] :: HsStmtContext id
[MDoExpr] :: HsStmtContext id
[ArrowExpr] :: HsStmtContext id
[GhciStmtCtxt] :: HsStmtContext id
[PatGuard] :: (HsMatchContext id) -> HsStmtContext id
[ParStmtCtxt] :: (HsStmtContext id) -> HsStmtContext id
[TransStmtCtxt] :: (HsStmtContext id) -> HsStmtContext id
isListCompExpr :: HsStmtContext id -> Bool
isMonadCompExpr :: HsStmtContext id -> Bool
matchSeparator :: HsMatchContext id -> SDoc
pprMatchContext :: Outputable id => HsMatchContext id -> SDoc
pprMatchContextNoun :: Outputable id => HsMatchContext id -> SDoc
pprAStmtContext :: Outputable id => HsStmtContext id -> SDoc
pprStmtContext :: Outputable id => HsStmtContext id -> SDoc
matchContextErrString :: Outputable id => HsMatchContext id -> SDoc
pprMatchInCtxt :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => HsMatchContext idL -> Match idR body -> SDoc
pprStmtInCtxt :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => HsStmtContext idL -> StmtLR idL idR body -> SDoc
instance Data PendingRnSplice
instance Data id => Data (HsMatchContext id)
instance Data id => Data (HsStmtContext id)
instance Data TransForm
instance Data HsArrAppType
instance DataId id => Data (HsExpr id)
instance DataId id => Data (HsTupArg id)
instance DataId id => Data (HsCmd id)
instance DataId id => Data (HsCmdTop id)
instance (Data body, DataId id) => Data (MatchGroup id body)
instance (Data body, DataId id) => Data (Match id body)
instance (Data body, DataId id) => Data (GRHSs id body)
instance (Data body, DataId id) => Data (GRHS id body)
instance (Data body, DataId idL, DataId idR) => Data (StmtLR idL idR body)
instance (DataId idL, DataId idR) => Data (ParStmtBlock idL idR)
instance DataId id => Data (HsSplice id)
instance DataId id => Data (PendingSplice id)
instance DataId id => Data (HsBracket id)
instance DataId id => Data (ArithSeqInfo id)
instance OutputableBndr id => Outputable (HsExpr id)
instance OutputableBndr id => Outputable (HsCmd id)
instance OutputableBndr id => Outputable (HsCmdTop id)
instance (OutputableBndr idL, OutputableBndr idR) => Outputable (ParStmtBlock idL idR)
instance (OutputableBndr idL, OutputableBndr idR, Outputable body) => Outputable (StmtLR idL idR body)
instance OutputableBndr id => Outputable (HsSplice id)
instance OutputableBndr id => Outputable (PendingSplice id)
instance OutputableBndr id => Outputable (HsBracket id)
instance Outputable PendingRnSplice
instance OutputableBndr id => Outputable (ArithSeqInfo id)

module HsUtils
mkHsPar :: LHsExpr id -> LHsExpr id
mkHsApp :: LHsExpr name -> LHsExpr name -> LHsExpr name
mkHsConApp :: DataCon -> [Type] -> [HsExpr Id] -> LHsExpr Id
mkSimpleHsAlt :: LPat id -> (Located (body id)) -> LMatch id (Located (body id))
mkSimpleMatch :: [LPat id] -> Located (body id) -> LMatch id (Located (body id))
unguardedGRHSs :: Located (body id) -> GRHSs id (Located (body id))
unguardedRHS :: SrcSpan -> Located (body id) -> [LGRHS id (Located (body id))]
mkMatchGroup :: Origin -> [LMatch RdrName (Located (body RdrName))] -> MatchGroup RdrName (Located (body RdrName))
mkMatchGroupName :: Origin -> [LMatch Name (Located (body Name))] -> MatchGroup Name (Located (body Name))
mkMatch :: [LPat id] -> LHsExpr id -> HsLocalBinds id -> LMatch id (LHsExpr id)
mkHsLam :: [LPat RdrName] -> LHsExpr RdrName -> LHsExpr RdrName
mkHsIf :: LHsExpr id -> LHsExpr id -> LHsExpr id -> HsExpr id
mkHsWrap :: HsWrapper -> HsExpr id -> HsExpr id
mkLHsWrap :: HsWrapper -> LHsExpr id -> LHsExpr id
mkHsWrapCo :: TcCoercion -> HsExpr id -> HsExpr id
mkHsWrapCoR :: TcCoercion -> HsExpr id -> HsExpr id
mkLHsWrapCo :: TcCoercion -> LHsExpr id -> LHsExpr id
coToHsWrapper :: TcCoercion -> HsWrapper
mkHsDictLet :: TcEvBinds -> LHsExpr Id -> LHsExpr Id
mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr Id -> LHsExpr Id
mkHsOpApp :: LHsExpr id -> id -> LHsExpr id -> HsExpr id
mkHsDo :: HsStmtContext Name -> [ExprLStmt RdrName] -> HsExpr RdrName
mkHsComp :: HsStmtContext Name -> [ExprLStmt RdrName] -> LHsExpr RdrName -> HsExpr RdrName
mkHsWrapPat :: HsWrapper -> Pat id -> Type -> Pat id
mkHsWrapPatCo :: TcCoercion -> Pat id -> Type -> Pat id
mkLHsPar :: LHsExpr name -> LHsExpr name
mkHsCmdCast :: TcCoercion -> HsCmd id -> HsCmd id
nlHsTyApp :: name -> [Type] -> LHsExpr name
nlHsTyApps :: name -> [Type] -> [LHsExpr name] -> LHsExpr name
nlHsVar :: id -> LHsExpr id
nlHsLit :: HsLit -> LHsExpr id
nlHsApp :: LHsExpr id -> LHsExpr id -> LHsExpr id
nlHsApps :: id -> [LHsExpr id] -> LHsExpr id
nlHsIntLit :: Integer -> LHsExpr id
nlHsVarApps :: id -> [id] -> LHsExpr id
nlHsDo :: HsStmtContext Name -> [LStmt RdrName (LHsExpr RdrName)] -> LHsExpr RdrName
nlHsOpApp :: LHsExpr id -> id -> LHsExpr id -> LHsExpr id
nlHsLam :: LMatch RdrName (LHsExpr RdrName) -> LHsExpr RdrName
nlHsPar :: LHsExpr id -> LHsExpr id
nlHsIf :: LHsExpr id -> LHsExpr id -> LHsExpr id -> LHsExpr id
nlHsCase :: LHsExpr RdrName -> [LMatch RdrName (LHsExpr RdrName)] -> LHsExpr RdrName
nlList :: [LHsExpr RdrName] -> LHsExpr RdrName
mkLHsTupleExpr :: [LHsExpr a] -> LHsExpr a
mkLHsVarTuple :: [a] -> LHsExpr a
missingTupArg :: HsTupArg RdrName
toHsType :: Type -> LHsType RdrName
toHsKind :: Kind -> LHsKind RdrName
mkFunBind :: Located RdrName -> [LMatch RdrName (LHsExpr RdrName)] -> HsBind RdrName
mkVarBind :: id -> LHsExpr id -> LHsBind id
mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr RdrName -> LHsBind RdrName
mk_easy_FunBind :: SrcSpan -> RdrName -> [LPat RdrName] -> LHsExpr RdrName -> LHsBind RdrName
mkTopFunBind :: Origin -> Located Name -> [LMatch Name (LHsExpr Name)] -> HsBind Name
mkPatSynBind :: Located RdrName -> HsPatSynDetails (Located RdrName) -> LPat RdrName -> HsPatSynDir RdrName -> HsBind RdrName
mkHsIntegral :: String -> Integer -> PostTc RdrName Type -> HsOverLit RdrName
mkHsFractional :: FractionalLit -> PostTc RdrName Type -> HsOverLit RdrName
mkHsIsString :: String -> FastString -> PostTc RdrName Type -> HsOverLit RdrName
mkHsString :: String -> HsLit
mkNPat :: Located (HsOverLit id) -> Maybe (SyntaxExpr id) -> Pat id
mkNPlusKPat :: Located id -> Located (HsOverLit id) -> Pat id
nlVarPat :: id -> LPat id
nlLitPat :: HsLit -> LPat id
nlConVarPat :: RdrName -> [RdrName] -> LPat RdrName
nlConPat :: RdrName -> [LPat RdrName] -> LPat RdrName
nlConPatName :: Name -> [LPat Name] -> LPat Name
nlInfixConPat :: id -> LPat id -> LPat id -> LPat id
nlNullaryConPat :: id -> LPat id
nlWildConPat :: DataCon -> LPat RdrName
nlWildPat :: LPat RdrName
nlWildPatName :: LPat Name
nlWildPatId :: LPat Id
nlTuplePat :: [LPat id] -> Boxity -> LPat id
mkParPat :: LPat name -> LPat name
mkHsAppTy :: LHsType name -> LHsType name -> LHsType name
userHsTyVarBndrs :: SrcSpan -> [name] -> [Located (HsTyVarBndr name)]
nlHsAppTy :: LHsType name -> LHsType name -> LHsType name
nlHsTyVar :: name -> LHsType name
nlHsFunTy :: LHsType name -> LHsType name -> LHsType name
nlHsTyConApp :: name -> [LHsType name] -> LHsType name
mkTransformStmt :: [ExprLStmt idL] -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
mkTransformByStmt :: [ExprLStmt idL] -> LHsExpr idR -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
mkBodyStmt :: Located (bodyR RdrName) -> StmtLR idL RdrName (Located (bodyR RdrName))
mkBindStmt :: LPat idL -> Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))
mkLastStmt :: Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))
emptyTransStmt :: StmtLR idL idR (LHsExpr idR)
mkGroupUsingStmt :: [ExprLStmt idL] -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
mkGroupByUsingStmt :: [ExprLStmt idL] -> LHsExpr idR -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
emptyRecStmt :: StmtLR idL RdrName bodyR
emptyRecStmtName :: StmtLR Name Name bodyR
emptyRecStmtId :: StmtLR Id Id bodyR
mkRecStmt :: [LStmtLR idL RdrName bodyR] -> StmtLR idL RdrName bodyR
mkHsSpliceTy :: LHsExpr RdrName -> HsType RdrName
mkHsSpliceE :: LHsExpr RdrName -> HsExpr RdrName
mkHsSpliceTE :: LHsExpr RdrName -> HsExpr RdrName
mkHsSplice :: LHsExpr RdrName -> HsSplice RdrName
mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsQuasiQuote RdrName
unqualQuasiQuote :: RdrName
noRebindableInfo :: PlaceHolder
collectLocalBinders :: HsLocalBindsLR idL idR -> [idL]
collectHsValBinders :: HsValBindsLR idL idR -> [idL]
collectHsBindListBinders :: [LHsBindLR idL idR] -> [idL]
collectHsIdBinders :: HsValBindsLR idL idR -> [idL]
collectHsBindsBinders :: LHsBindsLR idL idR -> [idL]
collectHsBindBinders :: HsBindLR idL idR -> [idL]
collectMethodBinders :: LHsBindsLR RdrName idR -> [Located RdrName]
collectPatBinders :: LPat a -> [a]
collectPatsBinders :: [LPat a] -> [a]
collectLStmtsBinders :: [LStmtLR idL idR body] -> [idL]
collectStmtsBinders :: [StmtLR idL idR body] -> [idL]
collectLStmtBinders :: LStmtLR idL idR body -> [idL]
collectStmtBinders :: StmtLR idL idR body -> [idL]

-- | Returns all the <i>binding</i> names of the decl. The first one is
--   guaranteed to be the name of the decl. For record fields mentioned in
--   multiple constructors, the SrcLoc will be from the first occurrence.
--   We use the equality to filter out duplicate field names.
--   
--   Each returned (Located name) has a SrcSpan for the <i>whole</i>
--   declaration. See Note [SrcSpan for binders]
hsLTyClDeclBinders :: Eq name => Located (TyClDecl name) -> [Located name]
hsTyClForeignBinders :: [TyClGroup Name] -> [LInstDecl Name] -> [LForeignDecl Name] -> [Name]
hsPatSynBinders :: LHsBindsLR idL idR -> [Located idL]
hsForeignDeclsBinders :: [LForeignDecl name] -> [Located name]
hsGroupBinders :: HsGroup Name -> [Name]
hsDataFamInstBinders :: Eq name => DataFamInstDecl name -> [Located name]
lStmtsImplicits :: [LStmtLR Name idR (Located (body idR))] -> NameSet
hsValBindsImplicits :: HsValBindsLR Name idR -> NameSet
lPatImplicits :: LPat Name -> NameSet

module HsSyn
data Fixity

-- | All we actually declare here is the top-level structure for a module.
data HsModule name

-- | <a>AnnKeywordId</a>s
--   
--   <ul>
--   <li><a>AnnModule</a>,<a>AnnWhere</a></li>
--   <li><a>AnnOpen</a>,<a>AnnSemi</a>, <a>AnnClose</a> for explicit braces
--   and semi around hsmodImports,hsmodDecls if this style is used.</li>
--   </ul>
[HsModule] :: Maybe (Located ModuleName) -> Maybe (Located [LIE name]) -> [LImportDecl name] -> [LHsDecl name] -> Maybe (Located WarningTxt) -> Maybe LHsDocString -> HsModule name

-- | <tt>Nothing</tt>: "module X where" is omitted (in which case the next
--   field is Nothing too)
[hsmodName] :: HsModule name -> Maybe (Located ModuleName)

-- | Export list
--   
--   <ul>
--   <li><tt>Nothing</tt>: export list omitted, so export everything</li>
--   <li><tt>Just []</tt>: export <i>nothing</i></li>
--   <li><tt>Just [...]</tt>: as you would expect...</li>
--   <li><a>AnnKeywordId</a>s : <a>AnnOpen</a> ,<a>AnnClose</a></li>
--   </ul>
[hsmodExports] :: HsModule name -> Maybe (Located [LIE name])

-- | We snaffle interesting stuff out of the imported interfaces early on,
--   adding that info to TyDecls/etc; so this list is often empty,
--   downstream.
[hsmodImports] :: HsModule name -> [LImportDecl name]

-- | Type, class, value, and interface signature decls
[hsmodDecls] :: HsModule name -> [LHsDecl name]

-- | reason/explanation for warning/deprecation of this module
--   
--   <ul>
--   <li><a>AnnKeywordId</a>s : <a>AnnOpen</a> ,<a>AnnClose</a></li>
--   </ul>
[hsmodDeprecMessage] :: HsModule name -> Maybe (Located WarningTxt)

-- | Haddock module info and description, unparsed
--   
--   <ul>
--   <li><a>AnnKeywordId</a>s : <a>AnnOpen</a> ,<a>AnnClose</a></li>
--   </ul>
[hsmodHaddockModHeader] :: HsModule name -> Maybe LHsDocString
instance DataId name => Data (HsModule name)
instance (OutputableBndr name, HasOccName name) => Outputable (HsModule name)


-- | Statistics for per-module compilations
--   
--   (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
module HscStats

-- | Source Statistics
ppSourceStats :: Bool -> Located (HsModule RdrName) -> SDoc

module HaddockUtils
addFieldDoc :: LConDeclField a -> Maybe LHsDocString -> LConDeclField a
addFieldDocs :: [LConDeclField a] -> Maybe LHsDocString -> [LConDeclField a]
addConDoc :: LConDecl a -> Maybe LHsDocString -> LConDecl a
addConDocs :: [LConDecl a] -> Maybe LHsDocString -> [LConDecl a]
addConDocFirst :: [LConDecl a] -> Maybe LHsDocString -> [LConDecl a]

module IfaceType
type IfExtName = Name
type IfLclName = FastString
data IfaceType
[IfaceTyVar] :: IfLclName -> IfaceType
[IfaceAppTy] :: IfaceType -> IfaceType -> IfaceType
[IfaceFunTy] :: IfaceType -> IfaceType -> IfaceType
[IfaceDFunTy] :: IfaceType -> IfaceType -> IfaceType
[IfaceForAllTy] :: IfaceTvBndr -> IfaceType -> IfaceType
[IfaceTyConApp] :: IfaceTyCon -> IfaceTcArgs -> IfaceType
[IfaceLitTy] :: IfaceTyLit -> IfaceType
type IfacePredType = IfaceType
type IfaceKind = IfaceType
data IfaceTyCon
[IfaceTc] :: IfExtName -> IfaceTyCon
[ifaceTyConName] :: IfaceTyCon -> IfExtName
[IfacePromotedDataCon] :: IfExtName -> IfaceTyCon
[ifaceTyConName] :: IfaceTyCon -> IfExtName
[IfacePromotedTyCon] :: IfExtName -> IfaceTyCon
[ifaceTyConName] :: IfaceTyCon -> IfExtName
data IfaceCoercion
[IfaceReflCo] :: Role -> IfaceType -> IfaceCoercion
[IfaceFunCo] :: Role -> IfaceCoercion -> IfaceCoercion -> IfaceCoercion
[IfaceTyConAppCo] :: Role -> IfaceTyCon -> [IfaceCoercion] -> IfaceCoercion
[IfaceAppCo] :: IfaceCoercion -> IfaceCoercion -> IfaceCoercion
[IfaceForAllCo] :: IfaceTvBndr -> IfaceCoercion -> IfaceCoercion
[IfaceCoVarCo] :: IfLclName -> IfaceCoercion
[IfaceAxiomInstCo] :: IfExtName -> BranchIndex -> [IfaceCoercion] -> IfaceCoercion
[IfaceUnivCo] :: FastString -> Role -> IfaceType -> IfaceType -> IfaceCoercion
[IfaceSymCo] :: IfaceCoercion -> IfaceCoercion
[IfaceTransCo] :: IfaceCoercion -> IfaceCoercion -> IfaceCoercion
[IfaceNthCo] :: Int -> IfaceCoercion -> IfaceCoercion
[IfaceLRCo] :: LeftOrRight -> IfaceCoercion -> IfaceCoercion
[IfaceInstCo] :: IfaceCoercion -> IfaceType -> IfaceCoercion
[IfaceSubCo] :: IfaceCoercion -> IfaceCoercion
[IfaceAxiomRuleCo] :: IfLclName -> [IfaceType] -> [IfaceCoercion] -> IfaceCoercion
data IfaceTyLit
[IfaceNumTyLit] :: Integer -> IfaceTyLit
[IfaceStrTyLit] :: FastString -> IfaceTyLit
data IfaceTcArgs
[ITC_Nil] :: IfaceTcArgs
[ITC_Type] :: IfaceType -> IfaceTcArgs -> IfaceTcArgs
[ITC_Kind] :: IfaceKind -> IfaceTcArgs -> IfaceTcArgs
type IfaceContext = [IfacePredType]
data IfaceBndr
[IfaceIdBndr] :: {-# UNPACK #-} !IfaceIdBndr -> IfaceBndr
[IfaceTvBndr] :: {-# UNPACK #-} !IfaceTvBndr -> IfaceBndr
data IfaceOneShot
[IfaceNoOneShot] :: IfaceOneShot
[IfaceOneShot] :: IfaceOneShot
type IfaceLamBndr = (IfaceBndr, IfaceOneShot)
type IfaceTvBndr = (IfLclName, IfaceKind)
type IfaceIdBndr = (IfLclName, IfaceType)
toIfaceType :: Type -> IfaceType
toIfaceTypes :: [Type] -> [IfaceType]
toIfaceKind :: Type -> IfaceType
toIfaceTyVar :: TyVar -> FastString
toIfaceContext :: ThetaType -> IfaceContext
toIfaceBndr :: Var -> IfaceBndr
toIfaceIdBndr :: Id -> (IfLclName, IfaceType)
toIfaceTvBndrs :: [TyVar] -> [(IfLclName, IfaceType)]
toIfaceTyCon :: TyCon -> IfaceTyCon
toIfaceTyCon_name :: Name -> IfaceTyCon
toIfaceTcArgs :: TyCon -> [Type] -> IfaceTcArgs
tcArgsIfaceTypes :: IfaceTcArgs -> [IfaceType]
toIfaceCoercion :: Coercion -> IfaceCoercion
pprIfaceType :: IfaceType -> SDoc
pprParendIfaceType :: IfaceType -> SDoc
pprIfaceContext :: Outputable a => [a] -> SDoc
pprIfaceContextArr :: Outputable a => [a] -> SDoc
pprIfaceContextMaybe :: Outputable a => [a] -> Maybe SDoc
pprIfaceIdBndr :: (IfLclName, IfaceType) -> SDoc
pprIfaceLamBndr :: IfaceLamBndr -> SDoc
pprIfaceTvBndr :: IfaceTvBndr -> SDoc
pprIfaceTvBndrs :: [IfaceTvBndr] -> SDoc
pprIfaceBndrs :: [IfaceBndr] -> SDoc
pprIfaceTcArgs :: IfaceTcArgs -> SDoc
pprParendIfaceTcArgs :: IfaceTcArgs -> SDoc
pprIfaceForAllPart :: Outputable a => [IfaceTvBndr] -> [a] -> SDoc -> SDoc
pprIfaceForAll :: [IfaceTvBndr] -> SDoc
pprIfaceSigmaType :: IfaceType -> SDoc
pprIfaceCoercion :: IfaceCoercion -> SDoc
pprParendIfaceCoercion :: IfaceCoercion -> SDoc
splitIfaceSigmaTy :: IfaceType -> ([IfaceTvBndr], [IfacePredType], IfaceType)
pprIfaceTypeApp :: IfaceTyCon -> IfaceTcArgs -> SDoc
pprUserIfaceForAll :: [IfaceTvBndr] -> SDoc
suppressIfaceKinds :: DynFlags -> [IfaceTvBndr] -> [a] -> [a]
stripIfaceKindVars :: DynFlags -> [IfaceTvBndr] -> [IfaceTvBndr]
stripKindArgs :: DynFlags -> IfaceTcArgs -> IfaceTcArgs
substIfaceType :: IfaceTySubst -> IfaceType -> IfaceType
substIfaceTyVar :: IfaceTySubst -> IfLclName -> IfaceType
substIfaceTcArgs :: IfaceTySubst -> IfaceTcArgs -> IfaceTcArgs
mkIfaceTySubst :: [IfaceTvBndr] -> [IfaceType] -> IfaceTySubst
instance Outputable IfaceBndr
instance Binary IfaceBndr
instance Binary IfaceOneShot
instance Outputable IfaceType
instance Outputable IfaceTcArgs
instance Outputable IfaceTyCon
instance Outputable IfaceCoercion
instance Binary IfaceTyCon
instance Outputable IfaceTyLit
instance Binary IfaceTyLit
instance Binary IfaceTcArgs
instance Binary IfaceType
instance Binary IfaceCoercion

module IfaceSyn
data IfaceDecl
[IfaceId] :: IfaceTopBndr -> IfaceType -> IfaceIdDetails -> IfaceIdInfo -> IfaceDecl
[ifName] :: IfaceDecl -> IfaceTopBndr
[ifType] :: IfaceDecl -> IfaceType
[ifIdDetails] :: IfaceDecl -> IfaceIdDetails
[ifIdInfo] :: IfaceDecl -> IfaceIdInfo
[IfaceData] :: IfaceTopBndr -> Maybe CType -> [IfaceTvBndr] -> [Role] -> IfaceContext -> IfaceConDecls -> RecFlag -> Bool -> Bool -> IfaceTyConParent -> IfaceDecl
[ifName] :: IfaceDecl -> IfaceTopBndr
[ifCType] :: IfaceDecl -> Maybe CType
[ifTyVars] :: IfaceDecl -> [IfaceTvBndr]
[ifRoles] :: IfaceDecl -> [Role]
[ifCtxt] :: IfaceDecl -> IfaceContext
[ifCons] :: IfaceDecl -> IfaceConDecls
[ifRec] :: IfaceDecl -> RecFlag
[ifPromotable] :: IfaceDecl -> Bool
[ifGadtSyntax] :: IfaceDecl -> Bool
[ifParent] :: IfaceDecl -> IfaceTyConParent
[IfaceSynonym] :: IfaceTopBndr -> [IfaceTvBndr] -> [Role] -> IfaceKind -> IfaceType -> IfaceDecl
[ifName] :: IfaceDecl -> IfaceTopBndr
[ifTyVars] :: IfaceDecl -> [IfaceTvBndr]
[ifRoles] :: IfaceDecl -> [Role]
[ifSynKind] :: IfaceDecl -> IfaceKind
[ifSynRhs] :: IfaceDecl -> IfaceType
[IfaceFamily] :: IfaceTopBndr -> [IfaceTvBndr] -> IfaceKind -> IfaceFamTyConFlav -> IfaceDecl
[ifName] :: IfaceDecl -> IfaceTopBndr
[ifTyVars] :: IfaceDecl -> [IfaceTvBndr]
[ifFamKind] :: IfaceDecl -> IfaceKind
[ifFamFlav] :: IfaceDecl -> IfaceFamTyConFlav
[IfaceClass] :: IfaceContext -> IfaceTopBndr -> [IfaceTvBndr] -> [Role] -> [FunDep FastString] -> [IfaceAT] -> [IfaceClassOp] -> BooleanFormula IfLclName -> RecFlag -> IfaceDecl
[ifCtxt] :: IfaceDecl -> IfaceContext
[ifName] :: IfaceDecl -> IfaceTopBndr
[ifTyVars] :: IfaceDecl -> [IfaceTvBndr]
[ifRoles] :: IfaceDecl -> [Role]
[ifFDs] :: IfaceDecl -> [FunDep FastString]
[ifATs] :: IfaceDecl -> [IfaceAT]
[ifSigs] :: IfaceDecl -> [IfaceClassOp]
[ifMinDef] :: IfaceDecl -> BooleanFormula IfLclName
[ifRec] :: IfaceDecl -> RecFlag
[IfaceAxiom] :: IfaceTopBndr -> IfaceTyCon -> Role -> [IfaceAxBranch] -> IfaceDecl
[ifName] :: IfaceDecl -> IfaceTopBndr
[ifTyCon] :: IfaceDecl -> IfaceTyCon
[ifRole] :: IfaceDecl -> Role
[ifAxBranches] :: IfaceDecl -> [IfaceAxBranch]
[IfacePatSyn] :: IfaceTopBndr -> Bool -> (IfExtName, Bool) -> Maybe (IfExtName, Bool) -> [IfaceTvBndr] -> [IfaceTvBndr] -> IfaceContext -> IfaceContext -> [IfaceType] -> IfaceType -> IfaceDecl
[ifName] :: IfaceDecl -> IfaceTopBndr
[ifPatIsInfix] :: IfaceDecl -> Bool
[ifPatMatcher] :: IfaceDecl -> (IfExtName, Bool)
[ifPatBuilder] :: IfaceDecl -> Maybe (IfExtName, Bool)
[ifPatUnivTvs] :: IfaceDecl -> [IfaceTvBndr]
[ifPatExTvs] :: IfaceDecl -> [IfaceTvBndr]
[ifPatProvCtxt] :: IfaceDecl -> IfaceContext
[ifPatReqCtxt] :: IfaceDecl -> IfaceContext
[ifPatArgs] :: IfaceDecl -> [IfaceType]
[ifPatTy] :: IfaceDecl -> IfaceType
data IfaceFamTyConFlav
[IfaceOpenSynFamilyTyCon] :: IfaceFamTyConFlav
[IfaceClosedSynFamilyTyCon] :: IfExtName -> [IfaceAxBranch] -> IfaceFamTyConFlav
[IfaceAbstractClosedSynFamilyTyCon] :: IfaceFamTyConFlav
[IfaceBuiltInSynFamTyCon] :: IfaceFamTyConFlav
data IfaceClassOp
[IfaceClassOp] :: IfaceTopBndr -> DefMethSpec -> IfaceType -> IfaceClassOp
data IfaceAT
[IfaceAT] :: IfaceDecl -> (Maybe IfaceType) -> IfaceAT
data IfaceConDecl
[IfCon] :: IfaceTopBndr -> Bool -> Bool -> [IfaceTvBndr] -> IfaceEqSpec -> IfaceContext -> [IfaceType] -> [IfaceTopBndr] -> [IfaceBang] -> IfaceConDecl
[ifConOcc] :: IfaceConDecl -> IfaceTopBndr
[ifConWrapper] :: IfaceConDecl -> Bool
[ifConInfix] :: IfaceConDecl -> Bool
[ifConExTvs] :: IfaceConDecl -> [IfaceTvBndr]
[ifConEqSpec] :: IfaceConDecl -> IfaceEqSpec
[ifConCtxt] :: IfaceConDecl -> IfaceContext
[ifConArgTys] :: IfaceConDecl -> [IfaceType]
[ifConFields] :: IfaceConDecl -> [IfaceTopBndr]
[ifConStricts] :: IfaceConDecl -> [IfaceBang]
data IfaceConDecls
[IfAbstractTyCon] :: Bool -> IfaceConDecls
[IfDataFamTyCon] :: IfaceConDecls
[IfDataTyCon] :: [IfaceConDecl] -> IfaceConDecls
[IfNewTyCon] :: IfaceConDecl -> IfaceConDecls
type IfaceEqSpec = [(IfLclName, IfaceType)]
data IfaceExpr
[IfaceLcl] :: IfLclName -> IfaceExpr
[IfaceExt] :: IfExtName -> IfaceExpr
[IfaceType] :: IfaceType -> IfaceExpr
[IfaceCo] :: IfaceCoercion -> IfaceExpr
[IfaceTuple] :: TupleSort -> [IfaceExpr] -> IfaceExpr
[IfaceLam] :: IfaceLamBndr -> IfaceExpr -> IfaceExpr
[IfaceApp] :: IfaceExpr -> IfaceExpr -> IfaceExpr
[IfaceCase] :: IfaceExpr -> IfLclName -> [IfaceAlt] -> IfaceExpr
[IfaceECase] :: IfaceExpr -> IfaceType -> IfaceExpr
[IfaceLet] :: IfaceBinding -> IfaceExpr -> IfaceExpr
[IfaceCast] :: IfaceExpr -> IfaceCoercion -> IfaceExpr
[IfaceLit] :: Literal -> IfaceExpr
[IfaceFCall] :: ForeignCall -> IfaceType -> IfaceExpr
[IfaceTick] :: IfaceTickish -> IfaceExpr -> IfaceExpr
type IfaceAlt = (IfaceConAlt, [IfLclName], IfaceExpr)
data IfaceLetBndr
[IfLetBndr] :: IfLclName -> IfaceType -> IfaceIdInfo -> IfaceLetBndr
data IfaceBinding
[IfaceNonRec] :: IfaceLetBndr -> IfaceExpr -> IfaceBinding
[IfaceRec] :: [(IfaceLetBndr, IfaceExpr)] -> IfaceBinding
data IfaceConAlt
[IfaceDefault] :: IfaceConAlt
[IfaceDataAlt] :: IfExtName -> IfaceConAlt
[IfaceLitAlt] :: Literal -> IfaceConAlt
data IfaceIdInfo
[NoInfo] :: IfaceIdInfo
[HasInfo] :: [IfaceInfoItem] -> IfaceIdInfo
data IfaceIdDetails
[IfVanillaId] :: IfaceIdDetails
[IfRecSelId] :: IfaceTyCon -> Bool -> IfaceIdDetails
[IfDFunId] :: Int -> IfaceIdDetails
data IfaceUnfolding
[IfCoreUnfold] :: Bool -> IfaceExpr -> IfaceUnfolding
[IfCompulsory] :: IfaceExpr -> IfaceUnfolding
[IfInlineRule] :: Arity -> Bool -> Bool -> IfaceExpr -> IfaceUnfolding
[IfDFunUnfold] :: [IfaceBndr] -> [IfaceExpr] -> IfaceUnfolding
data IfaceInfoItem
[HsArity] :: Arity -> IfaceInfoItem
[HsStrictness] :: StrictSig -> IfaceInfoItem
[HsInline] :: InlinePragma -> IfaceInfoItem
[HsUnfold] :: Bool -> IfaceUnfolding -> IfaceInfoItem
[HsNoCafRefs] :: IfaceInfoItem
data IfaceRule
[IfaceRule] :: RuleName -> Activation -> [IfaceBndr] -> IfExtName -> [IfaceExpr] -> IfaceExpr -> Bool -> IsOrphan -> IfaceRule
[ifRuleName] :: IfaceRule -> RuleName
[ifActivation] :: IfaceRule -> Activation
[ifRuleBndrs] :: IfaceRule -> [IfaceBndr]
[ifRuleHead] :: IfaceRule -> IfExtName
[ifRuleArgs] :: IfaceRule -> [IfaceExpr]
[ifRuleRhs] :: IfaceRule -> IfaceExpr
[ifRuleAuto] :: IfaceRule -> Bool
[ifRuleOrph] :: IfaceRule -> IsOrphan
data IfaceAnnotation
[IfaceAnnotation] :: IfaceAnnTarget -> AnnPayload -> IfaceAnnotation
[ifAnnotatedTarget] :: IfaceAnnotation -> IfaceAnnTarget
[ifAnnotatedValue] :: IfaceAnnotation -> AnnPayload
type IfaceAnnTarget = AnnTarget OccName
data IfaceClsInst
[IfaceClsInst] :: IfExtName -> [Maybe IfaceTyCon] -> IfExtName -> OverlapFlag -> IsOrphan -> IfaceClsInst
[ifInstCls] :: IfaceClsInst -> IfExtName
[ifInstTys] :: IfaceClsInst -> [Maybe IfaceTyCon]
[ifDFun] :: IfaceClsInst -> IfExtName
[ifOFlag] :: IfaceClsInst -> OverlapFlag
[ifInstOrph] :: IfaceClsInst -> IsOrphan
data IfaceFamInst
[IfaceFamInst] :: IfExtName -> [Maybe IfaceTyCon] -> IfExtName -> IsOrphan -> IfaceFamInst
[ifFamInstFam] :: IfaceFamInst -> IfExtName
[ifFamInstTys] :: IfaceFamInst -> [Maybe IfaceTyCon]
[ifFamInstAxiom] :: IfaceFamInst -> IfExtName
[ifFamInstOrph] :: IfaceFamInst -> IsOrphan
data IfaceTickish
[IfaceHpcTick] :: Module -> Int -> IfaceTickish
[IfaceSCC] :: CostCentre -> Bool -> Bool -> IfaceTickish
[IfaceSource] :: RealSrcSpan -> String -> IfaceTickish
data IfaceBang
[IfNoBang] :: IfaceBang
[IfStrict] :: IfaceBang
[IfUnpack] :: IfaceBang
[IfUnpackCo] :: IfaceCoercion -> IfaceBang
data IfaceAxBranch
[IfaceAxBranch] :: [IfaceTvBndr] -> IfaceTcArgs -> [Role] -> IfaceType -> [BranchIndex] -> IfaceAxBranch
[ifaxbTyVars] :: IfaceAxBranch -> [IfaceTvBndr]
[ifaxbLHS] :: IfaceAxBranch -> IfaceTcArgs
[ifaxbRoles] :: IfaceAxBranch -> [Role]
[ifaxbRHS] :: IfaceAxBranch -> IfaceType
[ifaxbIncomps] :: IfaceAxBranch -> [BranchIndex]
data IfaceTyConParent
[IfNoParent] :: IfaceTyConParent
[IfDataInstance] :: IfExtName -> IfaceTyCon -> IfaceTcArgs -> IfaceTyConParent
ifaceDeclImplicitBndrs :: IfaceDecl -> [OccName]
visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
ifaceDeclFingerprints :: Fingerprint -> IfaceDecl -> [(OccName, Fingerprint)]
freeNamesIfDecl :: IfaceDecl -> NameSet
freeNamesIfRule :: IfaceRule -> NameSet
freeNamesIfFamInst :: IfaceFamInst -> NameSet

-- | Pretty Print an IfaceExpre
--   
--   The first argument should be a function that adds parens in context
--   that need an atomic value (e.g. function args)
pprIfaceExpr :: (SDoc -> SDoc) -> IfaceExpr -> SDoc
pprIfaceDecl :: ShowSub -> IfaceDecl -> SDoc
data ShowSub
[ShowSub] :: (OccName -> SDoc) -> ShowHowMuch -> ShowSub
[ss_ppr_bndr] :: ShowSub -> OccName -> SDoc
[ss_how_much] :: ShowSub -> ShowHowMuch
data ShowHowMuch
[ShowHeader] :: ShowHowMuch
[ShowSome] :: [OccName] -> ShowHowMuch
[ShowIface] :: ShowHowMuch
instance Outputable IfaceAnnotation
instance HasOccName IfaceClassOp
instance HasOccName IfaceConDecl
instance HasOccName IfaceDecl
instance Outputable IfaceDecl
instance Outputable IfaceClassOp
instance Outputable IfaceAT
instance Outputable IfaceTyConParent
instance Outputable IfaceRule
instance Outputable IfaceClsInst
instance Outputable IfaceFamInst
instance Outputable IfaceExpr
instance Outputable IfaceConAlt
instance Outputable IfaceIdDetails
instance Outputable IfaceIdInfo
instance Outputable IfaceInfoItem
instance Outputable IfaceUnfolding
instance Binary IfaceDecl
instance Binary IfaceFamTyConFlav
instance Binary IfaceClassOp
instance Binary IfaceAT
instance Binary IfaceAxBranch
instance Binary IfaceConDecls
instance Binary IfaceConDecl
instance Binary IfaceBang
instance Binary IfaceClsInst
instance Binary IfaceFamInst
instance Binary IfaceRule
instance Binary IfaceAnnotation
instance Binary IfaceIdDetails
instance Binary IfaceIdInfo
instance Binary IfaceInfoItem
instance Binary IfaceUnfolding
instance Binary IfaceExpr
instance Binary IfaceTickish
instance Binary IfaceConAlt
instance Binary IfaceBinding
instance Binary IfaceLetBndr
instance Binary IfaceTyConParent


-- | Types for the per-module compiler
module HscTypes

-- | Hscenv is like <tt>Session</tt>, except that some of the fields are
--   immutable. An HscEnv is used to compile a single module from plain
--   Haskell source code (after preprocessing) to either C, assembly or
--   C--. Things like the module graph don't change during a single
--   compilation.
--   
--   Historical note: "hsc" used to be the name of the compiler binary,
--   when there was a separate driver and compiler. To compile a single
--   module, the driver would invoke hsc on the source code... so nowadays
--   we think of hsc as the layer of the compiler that deals with compiling
--   a single module.
data HscEnv
[HscEnv] :: DynFlags -> [Target] -> ModuleGraph -> InteractiveContext -> HomePackageTable -> {-# UNPACK #-} !(IORef ExternalPackageState) -> {-# UNPACK #-} !(IORef NameCache) -> {-# UNPACK #-} !(IORef FinderCache) -> {-# UNPACK #-} !(IORef ModLocationCache) -> Maybe (Module, IORef TypeEnv) -> HscEnv

-- | The dynamic flag settings
[hsc_dflags] :: HscEnv -> DynFlags

-- | The targets (or roots) of the current session
[hsc_targets] :: HscEnv -> [Target]

-- | The module graph of the current session
[hsc_mod_graph] :: HscEnv -> ModuleGraph

-- | The context for evaluating interactive statements
[hsc_IC] :: HscEnv -> InteractiveContext

-- | The home package table describes already-compiled home-package
--   modules, <i>excluding</i> the module we are compiling right now. (In
--   one-shot mode the current module is the only home-package module, so
--   hsc_HPT is empty. All other modules count as "external-package"
--   modules. However, even in GHCi mode, hi-boot interfaces are
--   demand-loaded into the external-package table.)
--   
--   <a>hsc_HPT</a> is not mutable because we only demand-load external
--   packages; the home package is eagerly loaded, module by module, by the
--   compilation manager.
--   
--   The HPT may contain modules compiled earlier by <tt>--make</tt> but
--   not actually below the current module in the dependency graph.
--   
--   (This changes a previous invariant: changed Jan 05.)
[hsc_HPT] :: HscEnv -> HomePackageTable

-- | Information about the currently loaded external packages. This is
--   mutable because packages will be demand-loaded during a compilation
--   run as required.
[hsc_EPS] :: HscEnv -> {-# UNPACK #-} !(IORef ExternalPackageState)

-- | As with <a>hsc_EPS</a>, this is side-effected by compiling to reflect
--   sucking in interface files. They cache the state of external interface
--   files, in effect.
[hsc_NC] :: HscEnv -> {-# UNPACK #-} !(IORef NameCache)

-- | The cached result of performing finding in the file system
[hsc_FC] :: HscEnv -> {-# UNPACK #-} !(IORef FinderCache)

-- | This caches the location of modules, so we don't have to search the
--   filesystem multiple times. See also <a>hsc_FC</a>.
[hsc_MLC] :: HscEnv -> {-# UNPACK #-} !(IORef ModLocationCache)

-- | Used for one-shot compilation only, to initialise the
--   <tt>IfGblEnv</tt>. See <a>tcg_type_env_var</a> for <a>TcGblEnv</a>
[hsc_type_env_var] :: HscEnv -> Maybe (Module, IORef TypeEnv)

-- | Retrieve the ExternalPackageState cache.
hscEPS :: HscEnv -> IO ExternalPackageState

-- | The <a>FinderCache</a> maps home module names to the result of
--   searching for that module. It records the results of searching for
--   modules along the search path. On <tt>:load</tt>, we flush the entire
--   contents of this cache.
--   
--   Although the <tt>FinderCache</tt> range is <a>FindResult</a> for
--   convenience, in fact it will only ever contain <a>Found</a> or
--   <a>NotFound</a> entries.
type FinderCache = ModuleNameEnv FindResult

-- | The result of searching for an imported module.
data FindResult

-- | The module was found
[Found] :: ModLocation -> Module -> FindResult

-- | The requested package was not found
[NoPackage] :: PackageKey -> FindResult

-- | _Error_: both in multiple packages
[FoundMultiple] :: [(Module, ModuleOrigin)] -> FindResult

-- | Not found
[NotFound] :: [FilePath] -> Maybe PackageKey -> [PackageKey] -> [PackageKey] -> [ModuleSuggestion] -> FindResult
[fr_paths] :: FindResult -> [FilePath]
[fr_pkg] :: FindResult -> Maybe PackageKey
[fr_mods_hidden] :: FindResult -> [PackageKey]
[fr_pkgs_hidden] :: FindResult -> [PackageKey]
[fr_suggestions] :: FindResult -> [ModuleSuggestion]

-- | Cache that remembers where we found a particular module. Contains both
--   home modules and package modules. On <tt>:load</tt>, only home modules
--   are purged from this cache.
type ModLocationCache = ModuleEnv ModLocation

-- | 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).
data Target
[Target] :: TargetId -> Bool -> Maybe (StringBuffer, UTCTime) -> Target

-- | module or filename
[targetId] :: Target -> TargetId

-- | object code allowed?
[targetAllowObjCode] :: Target -> Bool

-- | in-memory text buffer?
[targetContents] :: Target -> Maybe (StringBuffer, UTCTime)
data TargetId

-- | A module name: search for the file
[TargetModule] :: ModuleName -> TargetId

-- | A filename: preprocess &amp; 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.
[TargetFile] :: FilePath -> (Maybe Phase) -> TargetId
pprTarget :: Target -> SDoc
pprTargetId :: TargetId -> SDoc

-- | 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
--   <a>topSortModuleGraph</a> and <a>flattenSCC</a> to achieve this.
type ModuleGraph = [ModSummary]
emptyMG :: ModuleGraph

-- | Status of a compilation to hard-code
data HscStatus
[HscNotGeneratingCode] :: HscStatus
[HscUpToDate] :: HscStatus
[HscUpdateBoot] :: HscStatus
[HscUpdateSig] :: HscStatus
[HscRecomp] :: CgGuts -> ModSummary -> HscStatus
newtype Hsc a
[Hsc] :: (HscEnv -> WarningMessages -> IO (a, WarningMessages)) -> Hsc a
runHsc :: HscEnv -> Hsc a -> IO a
runInteractiveHsc :: HscEnv -> Hsc a -> IO a

-- | The <a>ModDetails</a> is essentially a cache for information in the
--   <a>ModIface</a> for home modules only. Information relating to
--   packages will be loaded into global environments in
--   <a>ExternalPackageState</a>.
data ModDetails
[ModDetails] :: [AvailInfo] -> !TypeEnv -> ![ClsInst] -> ![FamInst] -> ![CoreRule] -> ![Annotation] -> !VectInfo -> ModDetails
[md_exports] :: ModDetails -> [AvailInfo]

-- | Local type environment for this particular module Includes Ids,
--   TyCons, PatSyns
[md_types] :: ModDetails -> !TypeEnv

-- | <a>DFunId</a>s for the instances in this module
[md_insts] :: ModDetails -> ![ClsInst]
[md_fam_insts] :: ModDetails -> ![FamInst]

-- | Domain may include <a>Id</a>s from other modules
[md_rules] :: ModDetails -> ![CoreRule]

-- | Annotations present in this module: currently they only annotate
--   things also declared in this module
[md_anns] :: ModDetails -> ![Annotation]

-- | Module vectorisation information
[md_vect_info] :: ModDetails -> !VectInfo

-- | Constructs an empty ModDetails
emptyModDetails :: ModDetails

-- | A ModGuts is carried through the compiler, accumulating stuff as it
--   goes There is only one ModGuts at any time, the one for the module
--   being compiled right now. Once it is compiled, a <a>ModIface</a> and
--   <a>ModDetails</a> are extracted and the ModGuts is discarded.
data ModGuts
[ModGuts] :: !Module -> IsBootInterface -> ![AvailInfo] -> !Dependencies -> !ImportedMods -> !NameSet -> !Bool -> !GlobalRdrEnv -> !FixityEnv -> ![TyCon] -> ![ClsInst] -> ![FamInst] -> ![PatSyn] -> ![CoreRule] -> !CoreProgram -> !ForeignStubs -> !Warnings -> [Annotation] -> !HpcInfo -> !ModBreaks -> ![CoreVect] -> !VectInfo -> InstEnv -> FamInstEnv -> SafeHaskellMode -> Bool -> [FilePath] -> ModGuts

-- | Module being compiled
[mg_module] :: ModGuts -> !Module

-- | Whether it's an hs-boot module
[mg_boot] :: ModGuts -> IsBootInterface

-- | What it exports
[mg_exports] :: ModGuts -> ![AvailInfo]

-- | What it depends on, directly or otherwise
[mg_deps] :: ModGuts -> !Dependencies

-- | Directly-imported modules; used to generate initialisation code
[mg_dir_imps] :: ModGuts -> !ImportedMods

-- | What the module needed (used in <a>mkIface</a>)
[mg_used_names] :: ModGuts -> !NameSet

-- | Did we run a TH splice?
[mg_used_th] :: ModGuts -> !Bool

-- | Top-level lexical environment
[mg_rdr_env] :: ModGuts -> !GlobalRdrEnv

-- | Fixities declared in this module. Used for creating interface files.
[mg_fix_env] :: ModGuts -> !FixityEnv

-- | TyCons declared in this module (includes TyCons for classes)
[mg_tcs] :: ModGuts -> ![TyCon]

-- | Class instances declared in this module
[mg_insts] :: ModGuts -> ![ClsInst]

-- | Family instances declared in this module
[mg_fam_insts] :: ModGuts -> ![FamInst]

-- | Pattern synonyms declared in this module
[mg_patsyns] :: ModGuts -> ![PatSyn]

-- | Before the core pipeline starts, contains See Note [Overall plumbing
--   for rules] in Rules.lhs
[mg_rules] :: ModGuts -> ![CoreRule]

-- | Bindings for this module
[mg_binds] :: ModGuts -> !CoreProgram

-- | Foreign exports declared in this module
[mg_foreign] :: ModGuts -> !ForeignStubs

-- | Warnings declared in the module
[mg_warns] :: ModGuts -> !Warnings

-- | Annotations declared in this module
[mg_anns] :: ModGuts -> [Annotation]

-- | Coverage tick boxes in the module
[mg_hpc_info] :: ModGuts -> !HpcInfo

-- | Breakpoints for the module
[mg_modBreaks] :: ModGuts -> !ModBreaks

-- | Vectorisation declarations in this module (produced by desugarer &amp;
--   consumed by vectoriser)
[mg_vect_decls] :: ModGuts -> ![CoreVect]

-- | Pool of vectorised declarations in the module
[mg_vect_info] :: ModGuts -> !VectInfo

-- | Class instance environment from <i>home-package</i> modules (including
--   this one); c.f. <tt>tcg_inst_env</tt>
[mg_inst_env] :: ModGuts -> InstEnv

-- | Type-family instance environment for <i>home-package</i> modules
--   (including this one); c.f. <tt>tcg_fam_inst_env</tt>
[mg_fam_inst_env] :: ModGuts -> FamInstEnv

-- | Safe Haskell mode
[mg_safe_haskell] :: ModGuts -> SafeHaskellMode

-- | Do we need to trust our own package for Safe Haskell? See Note
--   [RnNames . Trust Own Package]
[mg_trust_pkg] :: ModGuts -> Bool

-- | dependencies from addDependentFile
[mg_dependent_files] :: ModGuts -> [FilePath]

-- | A restricted form of <a>ModGuts</a> for code generation purposes
data CgGuts
[CgGuts] :: !Module -> [TyCon] -> CoreProgram -> !ForeignStubs -> ![PackageKey] -> !HpcInfo -> !ModBreaks -> CgGuts

-- | Module being compiled
[cg_module] :: CgGuts -> !Module

-- | Algebraic data types (including ones that started life as classes);
--   generate constructors and info tables. Includes newtypes, just for the
--   benefit of External Core
[cg_tycons] :: CgGuts -> [TyCon]

-- | The tidied main bindings, including previously-implicit bindings for
--   record and class selectors, and data constructor wrappers. But *not*
--   data constructor workers; reason: we we regard them as part of the
--   code-gen of tycons
[cg_binds] :: CgGuts -> CoreProgram

-- | Foreign export stubs
[cg_foreign] :: CgGuts -> !ForeignStubs

-- | Dependent packages, used to generate #includes for C code gen
[cg_dep_pkgs] :: CgGuts -> ![PackageKey]

-- | Program coverage tick box information
[cg_hpc_info] :: CgGuts -> !HpcInfo

-- | Module breakpoints
[cg_modBreaks] :: CgGuts -> !ModBreaks

-- | Foreign export stubs
data ForeignStubs

-- | We don't have any stubs
[NoStubs] :: ForeignStubs

-- | There are some stubs. Parameters:
--   
--   1) Header file prototypes for "foreign exported" functions
--   
--   2) C stubs to use when calling "foreign exported" functions
[ForeignStubs] :: SDoc -> SDoc -> ForeignStubs
appendStubC :: ForeignStubs -> SDoc -> ForeignStubs

-- | Records the modules directly imported by a module for extracting e.g.
--   usage information
type ImportedMods = ModuleEnv [ImportedModsVal]
type ImportedModsVal = (ModuleName, Bool, SrcSpan, IsSafeImport)

-- | A single node in a <a>ModuleGraph</a>. The nodes of the module graph
--   are one of:
--   
--   <ul>
--   <li>A regular Haskell source module</li>
--   <li>A hi-boot source module</li>
--   <li>An external-core source module</li>
--   </ul>
data ModSummary
[ModSummary] :: Module -> HscSource -> ModLocation -> UTCTime -> Maybe UTCTime -> Maybe UTCTime -> [Located (ImportDecl RdrName)] -> [Located (ImportDecl RdrName)] -> FilePath -> DynFlags -> Maybe StringBuffer -> ModSummary

-- | Identity of the module
[ms_mod] :: ModSummary -> Module

-- | The module source either plain Haskell, hs-boot or external core
[ms_hsc_src] :: ModSummary -> HscSource

-- | Location of the various files belonging to the module
[ms_location] :: ModSummary -> ModLocation

-- | Timestamp of source file
[ms_hs_date] :: ModSummary -> UTCTime

-- | Timestamp of object, if we have one
[ms_obj_date] :: ModSummary -> Maybe UTCTime

-- | Timestamp of hi file, if we *only* are typechecking (it is
--   <a>Nothing</a> otherwise. See Note [Recompilation checking when
--   typechecking only] and #9243
[ms_iface_date] :: ModSummary -> Maybe UTCTime

-- | Source imports of the module
[ms_srcimps] :: ModSummary -> [Located (ImportDecl RdrName)]

-- | Non-source imports of the module from the module *text*
[ms_textual_imps] :: ModSummary -> [Located (ImportDecl RdrName)]

-- | Filename of preprocessed source file
[ms_hspp_file] :: ModSummary -> FilePath

-- | Cached flags from <tt>OPTIONS</tt>, <tt>INCLUDE</tt> and
--   <tt>LANGUAGE</tt> pragmas in the modules source code
[ms_hspp_opts] :: ModSummary -> DynFlags

-- | The actual preprocessed source, if we have it
[ms_hspp_buf] :: ModSummary -> Maybe StringBuffer
ms_imps :: ModSummary -> [Located (ImportDecl RdrName)]
ms_mod_name :: ModSummary -> ModuleName
showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String

-- | Did this <a>ModSummary</a> originate from a hs-boot file?
isBootSummary :: ModSummary -> Bool
msHsFilePath :: ModSummary -> FilePath
msHiFilePath :: ModSummary -> FilePath
msObjFilePath :: ModSummary -> FilePath

-- | Indicates whether a given module's source has been modified since it
--   was last compiled.
data SourceModified

-- | the source has been modified
[SourceModified] :: SourceModified

-- | the source has not been modified. Compilation may or may not be
--   necessary, depending on whether any dependencies have changed since we
--   last compiled.
[SourceUnmodified] :: SourceModified

-- | the source has not been modified, and furthermore all of its
--   (transitive) dependencies are up to date; it definitely does not need
--   to be recompiled. This is important for two reasons: (a) we can omit
--   the version check in checkOldIface, and (b) if the module used TH
--   splices we don't need to force recompilation.
[SourceUnmodifiedAndStable] :: SourceModified
data HscSource
[HsSrcFile] :: HscSource
[HsBootFile] :: HscSource
[HsigFile] :: HscSource
isHsBootOrSig :: HscSource -> Bool
hscSourceString :: HscSource -> String

-- | Helps us find information about modules in the home package
type HomePackageTable = ModuleNameEnv HomeModInfo

-- | Information about modules in the package being compiled
data HomeModInfo
[HomeModInfo] :: !ModIface -> !ModDetails -> !(Maybe Linkable) -> HomeModInfo

-- | The basic loaded interface file: every loaded module has one of these,
--   even if it is imported from another package
[hm_iface] :: HomeModInfo -> !ModIface

-- | Extra information that has been created from the <a>ModIface</a> for
--   the module, typically during typechecking
[hm_details] :: HomeModInfo -> !ModDetails

-- | The actual artifact we would like to link to access things in this
--   module.
--   
--   <a>hm_linkable</a> might be Nothing:
--   
--   <ol>
--   <li>If this is an .hs-boot module</li>
--   <li>Temporarily during compilation if we pruned away the old linkable
--   because it was out of date.</li>
--   </ol>
--   
--   After a complete compilation (<a>load</a>), all <a>hm_linkable</a>
--   fields in the <a>HomePackageTable</a> will be <tt>Just</tt>.
--   
--   When re-linking a module (<a>HscNoRecomp</a>), we construct the
--   <a>HomeModInfo</a> by building a new <a>ModDetails</a> from the old
--   <a>ModIface</a> (only).
[hm_linkable] :: HomeModInfo -> !(Maybe Linkable)

-- | Constructs an empty HomePackageTable
emptyHomePackageTable :: HomePackageTable

-- | Find all the instance declarations (of classes and families) from the
--   Home Package Table filtered by the provided predicate function. Used
--   in <tt>tcRnImports</tt>, to select the instances that are in the
--   transitive closure of imports from the currently compiled module.
hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])

-- | Get rules from modules "below" this one (in the dependency sense)
hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]

-- | Get the combined VectInfo of all modules in the home package table. In
--   contrast to instances and rules, we don't care whether the modules are
--   "below" us in the dependency sense. The VectInfo of those modules not
--   "below" us does not affect the compilation of the current module.
hptVectInfo :: HscEnv -> VectInfo
pprHPT :: HomePackageTable -> SDoc
hptObjs :: HomePackageTable -> [FilePath]

-- | Information about other packages that we have slurped in by reading
--   their interface files
data ExternalPackageState
[EPS] :: !(ModuleNameEnv (ModuleName, IsBootInterface)) -> !PackageIfaceTable -> !PackageTypeEnv -> !PackageInstEnv -> !PackageFamInstEnv -> !PackageRuleBase -> !PackageVectInfo -> !PackageAnnEnv -> !(ModuleEnv FamInstEnv) -> !EpsStats -> ExternalPackageState

-- | In OneShot mode (only), home-package modules accumulate in the
--   external package state, and are sucked in lazily. For these home-pkg
--   modules (only) we need to record which are boot modules. We set this
--   field after loading all the explicitly-imported interfaces, but before
--   doing anything else
--   
--   The <a>ModuleName</a> part is not necessary, but it's useful for debug
--   prints, and it's convenient because this field comes direct from
--   <a>imp_dep_mods</a>
[eps_is_boot] :: ExternalPackageState -> !(ModuleNameEnv (ModuleName, IsBootInterface))

-- | The <a>ModIface</a>s for modules in external packages whose interfaces
--   we have opened. The declarations in these interface files are held in
--   the <tt>eps_decls</tt>, <a>eps_inst_env</a>, <a>eps_fam_inst_env</a>
--   and <tt>eps_rules</tt> fields of this record, not in the
--   <a>mi_decls</a> fields of the interface we have sucked in.
--   
--   What <i>is</i> in the PIT is:
--   
--   <ul>
--   <li>The Module</li>
--   <li>Fingerprint info</li>
--   <li>Its exports</li>
--   <li>Fixities</li>
--   <li>Deprecations and warnings</li>
--   </ul>
[eps_PIT] :: ExternalPackageState -> !PackageIfaceTable

-- | Result of typechecking all the external package interface files we
--   have sucked in. The domain of the mapping is external-package modules
[eps_PTE] :: ExternalPackageState -> !PackageTypeEnv

-- | The total <a>InstEnv</a> accumulated from all the external-package
--   modules
[eps_inst_env] :: ExternalPackageState -> !PackageInstEnv

-- | The total <a>FamInstEnv</a> accumulated from all the external-package
--   modules
[eps_fam_inst_env] :: ExternalPackageState -> !PackageFamInstEnv

-- | The total <tt>RuleEnv</tt> accumulated from all the external-package
--   modules
[eps_rule_base] :: ExternalPackageState -> !PackageRuleBase

-- | The total <a>VectInfo</a> accumulated from all the external-package
--   modules
[eps_vect_info] :: ExternalPackageState -> !PackageVectInfo

-- | The total <a>AnnEnv</a> accumulated from all the external-package
--   modules
[eps_ann_env] :: ExternalPackageState -> !PackageAnnEnv

-- | The family instances accumulated from external packages, keyed off the
--   module that declared them
[eps_mod_fam_inst_env] :: ExternalPackageState -> !(ModuleEnv FamInstEnv)

-- | Stastics about what was loaded from external packages
[eps_stats] :: ExternalPackageState -> !EpsStats

-- | Accumulated statistics about what we are putting into the
--   <a>ExternalPackageState</a>. "In" means stuff that is just <i>read</i>
--   from interface files, "Out" means actually sucked in and type-checked
data EpsStats
[EpsStats] :: !Int -> EpsStats
[n_ifaces_in, n_decls_in, n_decls_out, n_rules_in, n_rules_out, n_insts_in, n_insts_out] :: EpsStats -> !Int

-- | Add stats for one newly-read interface
addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
type PackageTypeEnv = TypeEnv

-- | Helps us find information about modules in the imported packages
type PackageIfaceTable = ModuleEnv ModIface

-- | Constructs an empty PackageIfaceTable
emptyPackageIfaceTable :: PackageIfaceTable

-- | Find the <a>ModIface</a> for a <a>Module</a>, searching in both the
--   loaded home and external package module information
lookupIfaceByModule :: DynFlags -> HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface

-- | Constructs an empty ModIface
emptyModIface :: Module -> ModIface
lookupHptByModule :: HomePackageTable -> Module -> Maybe HomeModInfo
type PackageInstEnv = InstEnv
type PackageFamInstEnv = FamInstEnv
type PackageRuleBase = RuleBase
mkSOName :: Platform -> FilePath -> FilePath
mkHsSOName :: Platform -> FilePath -> FilePath
soExt :: Platform -> FilePath

-- | The supported metaprogramming result types
data MetaRequest
[MetaE] :: (LHsExpr RdrName -> MetaResult) -> MetaRequest
[MetaP] :: (LPat RdrName -> MetaResult) -> MetaRequest
[MetaT] :: (LHsType RdrName -> MetaResult) -> MetaRequest
[MetaD] :: ([LHsDecl RdrName] -> MetaResult) -> MetaRequest
[MetaAW] :: (Serialized -> MetaResult) -> MetaRequest

-- | data constructors not exported to ensure correct result type
data MetaResult
metaRequestE :: Functor f => MetaHook f -> LHsExpr Id -> f (LHsExpr RdrName)
metaRequestP :: Functor f => MetaHook f -> LHsExpr Id -> f (LPat RdrName)
metaRequestT :: Functor f => MetaHook f -> LHsExpr Id -> f (LHsType RdrName)
metaRequestD :: Functor f => MetaHook f -> LHsExpr Id -> f [LHsDecl RdrName]
metaRequestAW :: Functor f => MetaHook f -> LHsExpr Id -> f Serialized
type MetaHook f = MetaRequest -> LHsExpr Id -> f MetaResult

-- | Deal with gathering annotations in from all possible places and
--   combining them into a single <a>AnnEnv</a>
prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv

-- | Interactive context, recording information about the state of the
--   context in which statements are executed in a GHC session.
data InteractiveContext
[InteractiveContext] :: DynFlags -> Int -> [InteractiveImport] -> [TyThing] -> GlobalRdrEnv -> ([ClsInst], [FamInst]) -> FixityEnv -> Maybe [Type] -> [Resume] -> Name -> Name -> Maybe FilePath -> InteractiveContext

-- | The <a>DynFlags</a> used to evaluate interative expressions and
--   statements.
[ic_dflags] :: InteractiveContext -> DynFlags

-- | Each GHCi stmt or declaration brings some new things into scope. We
--   give them names like interactive:Ghci9.T, where the ic_index is the
--   '9'. The ic_mod_index is incremented whenever we add something to
--   ic_tythings See Note [The interactive package]
[ic_mod_index] :: InteractiveContext -> Int

-- | The GHCi top-level scope (ic_rn_gbl_env) is extended with these
--   imports
--   
--   This field is only stored here so that the client can retrieve it with
--   GHC.getContext. GHC itself doesn't use it, but does reset it to empty
--   sometimes (such as before a GHC.load). The context is set with
--   GHC.setContext.
[ic_imports] :: InteractiveContext -> [InteractiveImport]

-- | TyThings defined by the user, in reverse order of definition (ie most
--   recent at the front) See Note [ic_tythings]
[ic_tythings] :: InteractiveContext -> [TyThing]

-- | The cached <a>GlobalRdrEnv</a>, built by <a>setContext</a> and updated
--   regularly It contains everything in scope at the command line,
--   including everything in ic_tythings
[ic_rn_gbl_env] :: InteractiveContext -> GlobalRdrEnv

-- | All instances and family instances created during this session. These
--   are grabbed en masse after each update to be sure that proper
--   overlapping is retained. That is, rather than re-check the overlapping
--   each time we update the context, we just take the results from the
--   instance code that already does that.
[ic_instances] :: InteractiveContext -> ([ClsInst], [FamInst])

-- | Fixities declared in let statements
[ic_fix_env] :: InteractiveContext -> FixityEnv

-- | The current default types, set by a 'default' declaration
[ic_default] :: InteractiveContext -> Maybe [Type]

-- | The stack of breakpoint contexts
[ic_resume] :: InteractiveContext -> [Resume]

-- | The monad that GHCi is executing in
[ic_monad] :: InteractiveContext -> Name

-- | The function that is used for printing results of expressions in ghci
--   and -e mode.
[ic_int_print] :: InteractiveContext -> Name
[ic_cwd] :: InteractiveContext -> Maybe FilePath

-- | Constructs an empty InteractiveContext.
emptyInteractiveContext :: DynFlags -> InteractiveContext

-- | Get the PrintUnqualified function based on the flags and this
--   InteractiveContext
icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified

-- | This function returns the list of visible TyThings (useful for e.g.
--   showBindings)
icInScopeTTs :: InteractiveContext -> [TyThing]

-- | Add TyThings to the GlobalRdrEnv, earlier ones in the list shadowing
--   later ones, and shadowing existing entries in the GlobalRdrEnv.
icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv

-- | extendInteractiveContext is called with new TyThings recently defined
--   to update the InteractiveContext to include them. Ids are easily
--   removed when shadowed, but Classes and TyCons are not. Some work could
--   be done to determine whether they are entirely shadowed, but as you
--   could still have references to them (e.g. instances for classes or
--   values of the type for TyCons), it's not clear whether removing them
--   is even the appropriate behavior.
extendInteractiveContext :: InteractiveContext -> [Id] -> [TyCon] -> [ClsInst] -> [FamInst] -> Maybe [Type] -> [PatSyn] -> InteractiveContext
extendInteractiveContextWithIds :: InteractiveContext -> [Id] -> InteractiveContext
substInteractiveContext :: InteractiveContext -> TvSubst -> InteractiveContext
setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext
icInteractiveModule :: InteractiveContext -> Module
data InteractiveImport

-- | Bring the exports of a particular module (filtered by an import decl)
--   into scope
[IIDecl] :: (ImportDecl RdrName) -> InteractiveImport

-- | Bring into scope the entire top-level envt of of this module,
--   including the things imported into it.
[IIModule] :: ModuleName -> InteractiveImport
setInteractivePackage :: HscEnv -> HscEnv

-- | Creates some functions that work out the best ways to format names for
--   the user according to a set of heuristics.
mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified
pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc

-- | Creates a function for formatting packages based on two heuristics:
--   (1) don't qualify if the package in question is "main", and (2) only
--   qualify with a package key if the package ID would be ambiguous.
mkQualPackage :: DynFlags -> QueryQualifyPackage

-- | Creates a function for formatting modules based on two heuristics: (1)
--   if the module is the current module, don't qualify, and (2) if there
--   is only one exposed package which exports this module, don't qualify.
mkQualModule :: DynFlags -> QueryQualifyModule

-- | A function which only qualifies package names if necessary; but
--   qualifies all other identifiers.
pkgQual :: DynFlags -> PrintUnqualified

-- | A <a>ModIface</a> plus a <a>ModDetails</a> summarises everything we
--   know about a compiled module. The <a>ModIface</a> 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 <a>ModIface</a>.
--   
--   When we read an interface file, we also construct a <a>ModIface</a>
--   from it, except that we explicitly make the <a>mi_decls</a> and a few
--   other fields empty; as when reading we consolidate the declarations
--   etc. into a number of indexed maps and environments in the
--   <a>ExternalPackageState</a>.
data ModIface
[ModIface] :: !Module -> !(Maybe Module) -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !WhetherHasOrphans -> !WhetherHasFamInst -> !IsBootInterface -> Dependencies -> [Usage] -> ![IfaceExport] -> !Fingerprint -> !Bool -> [(OccName, Fixity)] -> Warnings -> [IfaceAnnotation] -> [(Fingerprint, IfaceDecl)] -> !(Maybe GlobalRdrEnv) -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> !Fingerprint -> !IfaceVectInfo -> (Name -> Maybe WarningTxt) -> (OccName -> Fixity) -> (OccName -> Maybe (OccName, Fingerprint)) -> !AnyHpcUsage -> !IfaceTrustInfo -> !Bool -> ModIface

-- | Name of the module we are for
[mi_module] :: ModIface -> !Module

-- | Are we a sig of another mod?
[mi_sig_of] :: ModIface -> !(Maybe Module)

-- | Hash of the whole interface
[mi_iface_hash] :: ModIface -> !Fingerprint

-- | Hash of the ABI only
[mi_mod_hash] :: ModIface -> !Fingerprint

-- | Hash of the important flags used when compiling this module
[mi_flag_hash] :: ModIface -> !Fingerprint

-- | Whether this module has orphans
[mi_orphan] :: ModIface -> !WhetherHasOrphans

-- | Whether this module has family instances
[mi_finsts] :: ModIface -> !WhetherHasFamInst

-- | Read from an hi-boot file?
[mi_boot] :: ModIface -> !IsBootInterface

-- | The dependencies of the module. This is consulted for
--   directly-imported modules, but not for anything else (hence lazy)
[mi_deps] :: ModIface -> Dependencies

-- | 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_usages] :: ModIface -> [Usage]

-- | 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 <a>OccName</a>s of those things
[mi_exports] :: ModIface -> ![IfaceExport]

-- | Hash of export list
[mi_exp_hash] :: ModIface -> !Fingerprint

-- | Module required TH splices when it was compiled. This disables
--   recompilation avoidance (see #481).
[mi_used_th] :: ModIface -> !Bool

-- | Fixities NOT STRICT! we read this field lazily from the interface file
[mi_fixities] :: ModIface -> [(OccName, Fixity)]

-- | Warnings NOT STRICT! we read this field lazily from the interface file
[mi_warns] :: ModIface -> Warnings

-- | Annotations NOT STRICT! we read this field lazily from the interface
--   file
[mi_anns] :: ModIface -> [IfaceAnnotation]

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

-- | Binds all the things defined at the top level in the <i>original
--   source</i> 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
--   <tt>Nothing</tt>).
--   
--   Strictly speaking this field should live in the <a>HomeModInfo</a>,
--   but that leads to more plumbing.
[mi_globals] :: ModIface -> !(Maybe GlobalRdrEnv)

-- | Sorted class instance
[mi_insts] :: ModIface -> [IfaceClsInst]

-- | Sorted family instances
[mi_fam_insts] :: ModIface -> [IfaceFamInst]

-- | Sorted rules
[mi_rules] :: ModIface -> [IfaceRule]

-- | Hash for orphan rules, class and family instances, and vectorise
--   pragmas combined
[mi_orphan_hash] :: ModIface -> !Fingerprint

-- | Vectorisation information
[mi_vect_info] :: ModIface -> !IfaceVectInfo

-- | Cached lookup for <a>mi_warns</a>
[mi_warn_fn] :: ModIface -> Name -> Maybe WarningTxt

-- | Cached lookup for <a>mi_fixities</a>
[mi_fix_fn] :: ModIface -> OccName -> Fixity

-- | Cached lookup for <a>mi_decls</a>. The <tt>Nothing</tt> in
--   <a>mi_hash_fn</a> 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
--   <a>OccName</a> is the parent of the name, if it has one.
[mi_hash_fn] :: ModIface -> OccName -> Maybe (OccName, Fingerprint)

-- | True if this program uses Hpc at any point in the program.
[mi_hpc] :: ModIface -> !AnyHpcUsage

-- | Safe Haskell Trust information for this module.
[mi_trust] :: ModIface -> !IfaceTrustInfo

-- | 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_trust_pkg] :: ModIface -> !Bool

-- | Constructs the cache for the <a>mi_warn_fn</a> field of a
--   <a>ModIface</a>
mkIfaceWarnCache :: Warnings -> Name -> Maybe WarningTxt

-- | Constructs cache for the <a>mi_hash_fn</a> field of a <a>ModIface</a>
mkIfaceHashCache :: [(Fingerprint, IfaceDecl)] -> (OccName -> Maybe (OccName, Fingerprint))

-- | Creates cached lookup for the <a>mi_fix_fn</a> field of
--   <a>ModIface</a>
mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
emptyIfaceWarnCache :: Name -> Maybe WarningTxt

-- | Fixity environment mapping names to their fixities
type FixityEnv = NameEnv FixItem

-- | Fixity information for an <a>Name</a>. We keep the OccName in the
--   range so that we can generate an interface from it
data FixItem
[FixItem] :: OccName -> Fixity -> FixItem
lookupFixity :: FixityEnv -> Name -> Fixity
emptyFixityEnv :: FixityEnv

-- | A typecheckable-thing, essentially anything that has a name
data TyThing
[AnId] :: Id -> TyThing
[AConLike] :: ConLike -> TyThing
[ATyCon] :: TyCon -> TyThing
[ACoAxiom] :: (CoAxiom Branched) -> TyThing

-- | The Names that a TyThing should bring into scope. Used to build the
--   GlobalRdrEnv for the InteractiveContext.
tyThingAvailInfo :: TyThing -> AvailInfo

-- | Get the <a>TyCon</a> from a <a>TyThing</a> if it is a type constructor
--   thing. Panics otherwise
tyThingTyCon :: TyThing -> TyCon

-- | Get the <a>DataCon</a> from a <a>TyThing</a> if it is a data
--   constructor thing. Panics otherwise
tyThingDataCon :: TyThing -> DataCon

-- | Get the <a>Id</a> from a <a>TyThing</a> if it is a id *or* data
--   constructor thing. Panics otherwise
tyThingId :: TyThing -> Id

-- | Get the <a>CoAxiom</a> from a <a>TyThing</a> if it is a coercion axiom
--   thing. Panics otherwise
tyThingCoAxiom :: TyThing -> CoAxiom Branched

-- | tyThingParent_maybe x returns (Just p) when pprTyThingInContext sould
--   print a declaration for p (albeit with some "..." in it) when asked to
--   show x It returns the *immediate* parent. So a datacon returns its
--   tycon but the tycon could be the associated type of a class, so it in
--   turn might have a parent.
tyThingParent_maybe :: TyThing -> Maybe TyThing
tyThingsTyVars :: [TyThing] -> TyVarSet

-- | Determine the <a>TyThing</a>s brought into scope by another
--   <a>TyThing</a> <i>other</i> than itself. For example, Id's don't have
--   any implicit TyThings as they just bring themselves into scope, but
--   classes bring their dictionary datatype, type constructor and some
--   selector functions into scope, just for a start!
implicitTyThings :: TyThing -> [TyThing]
implicitTyConThings :: TyCon -> [TyThing]
implicitClassThings :: Class -> [TyThing]

-- | Returns <tt>True</tt> if there should be no interface-file declaration
--   for this thing on its own: either it is built-in, or it is part of
--   some other declaration, or it is generated implicitly by some other
--   declaration.
isImplicitTyThing :: TyThing -> Bool

-- | A map from <a>Name</a>s to <a>TyThing</a>s, constructed by
--   typechecking local declarations or interface files
type TypeEnv = NameEnv TyThing

-- | Find the <a>TyThing</a> for the given <a>Name</a> by using all the
--   resources at our disposal: the compiled modules in the
--   <a>HomePackageTable</a> and the compiled modules in other packages
--   that live in <a>PackageTypeEnv</a>. Note that this does NOT look up
--   the <a>TyThing</a> in the module being compiled: you have to do that
--   yourself, if desired
lookupType :: DynFlags -> HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing

-- | As <a>lookupType</a>, but with a marginally easier-to-use interface if
--   you have a <a>HscEnv</a>
lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)
mkTypeEnv :: [TyThing] -> TypeEnv
emptyTypeEnv :: TypeEnv
typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv
mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv
extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing
typeEnvElts :: TypeEnv -> [TyThing]
typeEnvTyCons :: TypeEnv -> [TyCon]
typeEnvIds :: TypeEnv -> [Id]
typeEnvPatSyns :: TypeEnv -> [PatSyn]
typeEnvDataCons :: TypeEnv -> [DataCon]
typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]
typeEnvClasses :: TypeEnv -> [Class]

-- | Class that abstracts out the common ability of the monads in GHC to
--   lookup a <a>TyThing</a> in the monadic environment by <a>Name</a>.
--   Provides a number of related convenience functions for accessing
--   particular kinds of <a>TyThing</a>
class Monad m => MonadThings m where lookupId = liftM tyThingId . lookupThing lookupDataCon = liftM tyThingDataCon . lookupThing lookupTyCon = liftM tyThingTyCon . lookupThing
lookupThing :: MonadThings m => Name -> m TyThing
lookupId :: MonadThings m => Name -> m Id
lookupDataCon :: MonadThings m => Name -> m DataCon
lookupTyCon :: MonadThings m => Name -> m TyCon

-- | Records whether a module has orphans. An "orphan" is one of:
--   
--   <ul>
--   <li>An instance declaration in a module other than the definition
--   module for one of the type constructors or classes in the instance
--   head</li>
--   <li>A transformation rule in a module other than the one defining the
--   function in the head of the rule</li>
--   <li>A vectorisation pragma</li>
--   </ul>
type WhetherHasOrphans = Bool

-- | Did this module originate from a *-boot file?
type IsBootInterface = Bool

-- | Records modules for which changes may force recompilation of this
--   module See wiki:
--   <a>http://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/RecompilationAvoidance</a>
--   
--   This differs from Dependencies. A module X may be in the dep_mods of
--   this module (via an import chain) but if we don't use anything from X
--   it won't appear in our Usage
data Usage

-- | Module from another package
[UsagePackageModule] :: Module -> Fingerprint -> IsSafeImport -> Usage

-- | External package module depended on
[usg_mod] :: Usage -> Module

-- | Cached module fingerprint
[usg_mod_hash] :: Usage -> Fingerprint

-- | Was this module imported as a safe import
[usg_safe] :: Usage -> IsSafeImport

-- | Module from the current package | A file upon which the module
--   depends, e.g. a CPP #include, or using TH's <tt>addDependentFile</tt>
[UsageHomeModule] :: ModuleName -> Fingerprint -> [(OccName, Fingerprint)] -> Maybe Fingerprint -> IsSafeImport -> Usage

-- | Name of the module
[usg_mod_name] :: Usage -> ModuleName

-- | Cached module fingerprint
[usg_mod_hash] :: Usage -> Fingerprint

-- | Entities we depend on, sorted by occurrence name and fingerprinted.
--   NB: usages are for parent names only, e.g. type constructors but not
--   the associated data constructors.
[usg_entities] :: Usage -> [(OccName, Fingerprint)]

-- | Fingerprint for the export list of this module, if we directly
--   imported it (and hence we depend on its export list)
[usg_exports] :: Usage -> Maybe Fingerprint

-- | Was this module imported as a safe import
[usg_safe] :: Usage -> IsSafeImport
[UsageFile] :: FilePath -> Fingerprint -> Usage

-- | External file dependency. From a CPP #include or TH addDependentFile.
--   Should be absolute.
[usg_file_path] :: Usage -> FilePath

-- | <a>Fingerprint</a> of the file contents.
[usg_file_hash] :: Usage -> Fingerprint

-- | Dependency information about ALL modules and packages below this one
--   in the import hierarchy.
--   
--   Invariant: the dependencies of a module <tt>M</tt> never includes
--   <tt>M</tt>.
--   
--   Invariant: none of the lists contain duplicates.
data Dependencies
[Deps] :: [(ModuleName, IsBootInterface)] -> [(PackageKey, Bool)] -> [Module] -> [Module] -> Dependencies

-- | All home-package modules transitively below this one I.e. modules that
--   this one imports, or that are in the dep_mods of those
--   directly-imported modules
[dep_mods] :: Dependencies -> [(ModuleName, IsBootInterface)]

-- | All packages transitively below this module I.e. packages to which
--   this module's direct imports belong, or that are in the dep_pkgs of
--   those modules The bool indicates if the package is required to be
--   trusted when the module is imported as a safe import (Safe Haskell).
--   See Note [RnNames . Tracking Trust Transitively]
[dep_pkgs] :: Dependencies -> [(PackageKey, Bool)]

-- | Transitive closure of orphan modules (whether home or external pkg).
--   
--   (Possible optimization: don't include family instance orphans as they
--   are anyway included in <a>dep_finsts</a>. But then be careful about
--   code which relies on dep_orphs having the complete list!)
[dep_orphs] :: Dependencies -> [Module]

-- | Modules that contain family instances (whether the instances are from
--   the home or an external package)
[dep_finsts] :: Dependencies -> [Module]
noDependencies :: Dependencies

-- | The NameCache makes sure that there is just one Unique assigned for
--   each original name; i.e. (module-name, occ-name) pair and provides
--   something of a lookup mechanism for those names.
data NameCache
[NameCache] :: !UniqSupply -> !OrigNameCache -> NameCache

-- | Supply of uniques
[nsUniqs] :: NameCache -> !UniqSupply

-- | Ensures that one original name gets one unique
[nsNames] :: NameCache -> !OrigNameCache

-- | Per-module cache of original <a>OccName</a>s given <a>Name</a>s
type OrigNameCache = ModuleEnv (OccEnv Name)

-- | The original names declared of a certain module that are exported
type IfaceExport = AvailInfo

-- | Warning information for a module
data Warnings

-- | Nothing deprecated
[NoWarnings] :: Warnings

-- | Whole module deprecated
[WarnAll] :: WarningTxt -> Warnings

-- | Some specific things deprecated
[WarnSome] :: [(OccName, WarningTxt)] -> Warnings
data WarningTxt
[WarningTxt] :: (Located SourceText) -> [Located FastString] -> WarningTxt
[DeprecatedTxt] :: (Located SourceText) -> [Located FastString] -> WarningTxt
plusWarns :: Warnings -> Warnings -> Warnings

-- | Information we can use to dynamically link modules into the compiler
data Linkable
[LM] :: UTCTime -> Module -> [Unlinked] -> Linkable

-- | Time at which this linkable was built (i.e. when the bytecodes were
--   produced, or the mod date on the files)
[linkableTime] :: Linkable -> UTCTime

-- | The linkable module itself
[linkableModule] :: Linkable -> Module

-- | Those files and chunks of code we have yet to link.
--   
--   INVARIANT: A valid linkable always has at least one <a>Unlinked</a>
--   item. If this list is empty, the Linkable represents a fake linkable,
--   which is generated in HscNothing mode to avoid recompiling modules.
--   
--   ToDo: Do items get removed from this list when they get linked?
[linkableUnlinked] :: Linkable -> [Unlinked]
isObjectLinkable :: Linkable -> Bool
linkableObjs :: Linkable -> [FilePath]

-- | Objects which have yet to be linked by the compiler
data Unlinked

-- | An object file (.o)
[DotO] :: FilePath -> Unlinked

-- | Static archive file (.a)
[DotA] :: FilePath -> Unlinked

-- | Dynamically linked library file (.so, .dll, .dylib)
[DotDLL] :: FilePath -> Unlinked

-- | A byte-code object, lives only in memory
[BCOs] :: CompiledByteCode -> ModBreaks -> Unlinked
data CompiledByteCode

-- | Is this an actual file on disk we can link in somehow?
isObject :: Unlinked -> Bool

-- | Retrieve the filename of the linkable if possible. Panic if it is a
--   byte-code object
nameOfObject :: Unlinked -> FilePath

-- | Is this a bytecode linkable with no file on disk?
isInterpretable :: Unlinked -> Bool

-- | Retrieve the compiled byte-code if possible. Panic if it is a
--   file-based linkable
byteCodeOfObject :: Unlinked -> CompiledByteCode

-- | Information about a modules use of Haskell Program Coverage
data HpcInfo
[HpcInfo] :: Int -> Int -> HpcInfo
[hpcInfoTickCount] :: HpcInfo -> Int
[hpcInfoHash] :: HpcInfo -> Int
[NoHpcInfo] :: AnyHpcUsage -> HpcInfo

-- | Is hpc used anywhere on the module *tree*?
[hpcUsed] :: HpcInfo -> AnyHpcUsage
emptyHpcInfo :: AnyHpcUsage -> HpcInfo

-- | Find out if HPC is used by this module or any of the modules it
--   depends upon
isHpcUsed :: HpcInfo -> AnyHpcUsage

-- | This is used to signal if one of my imports used HPC instrumentation
--   even if there is no module-local HPC usage
type AnyHpcUsage = Bool

-- | All the information about the breakpoints for a given module
data ModBreaks
[ModBreaks] :: BreakArray -> !(Array BreakIndex SrcSpan) -> !(Array BreakIndex [OccName]) -> !(Array BreakIndex [String]) -> ModBreaks

-- | The array of flags, one per breakpoint, indicating which breakpoints
--   are enabled.
[modBreaks_flags] :: ModBreaks -> BreakArray

-- | An array giving the source span of each breakpoint.
[modBreaks_locs] :: ModBreaks -> !(Array BreakIndex SrcSpan)

-- | An array giving the names of the free variables at each breakpoint.
[modBreaks_vars] :: ModBreaks -> !(Array BreakIndex [OccName])

-- | An array giving the names of the declarations enclosing each
--   breakpoint.
[modBreaks_decls] :: ModBreaks -> !(Array BreakIndex [String])

-- | Breakpoint index
type BreakIndex = Int

-- | Construct an empty ModBreaks
emptyModBreaks :: ModBreaks

-- | Vectorisation information for <a>ModGuts</a>, <a>ModDetails</a> and
--   <a>ExternalPackageState</a>; see also documentation at
--   <a>GlobalEnv</a>.
--   
--   NB: The following tables may also include <a>Var</a>s, <a>TyCon</a>s
--   and <a>DataCon</a>s from imported modules, which have been
--   subsequently vectorised in the current module.
data VectInfo
[VectInfo] :: VarEnv (Var, Var) -> NameEnv (TyCon, TyCon) -> NameEnv (DataCon, DataCon) -> VarSet -> NameSet -> VectInfo

-- | <tt>(f, f_v)</tt> keyed on <tt>f</tt>
[vectInfoVar] :: VectInfo -> VarEnv (Var, Var)

-- | <tt>(T, T_v)</tt> keyed on <tt>T</tt>
[vectInfoTyCon] :: VectInfo -> NameEnv (TyCon, TyCon)

-- | <tt>(C, C_v)</tt> keyed on <tt>C</tt>
[vectInfoDataCon] :: VectInfo -> NameEnv (DataCon, DataCon)

-- | set of parallel variables
[vectInfoParallelVars] :: VectInfo -> VarSet

-- | set of parallel type constructors
[vectInfoParallelTyCons] :: VectInfo -> NameSet

-- | Vectorisation information for <a>ModIface</a>; i.e, the vectorisation
--   information propagated across module boundaries.
--   
--   NB: The field <a>ifaceVectInfoVar</a> explicitly contains the workers
--   of data constructors as well as class selectors — i.e., their mappings
--   are <i>not</i> implicitly generated from the data types. Moreover,
--   whether the worker of a data constructor is in <a>ifaceVectInfoVar</a>
--   determines whether that data constructor was vectorised (or is part of
--   an abstractly vectorised type constructor).
data IfaceVectInfo
[IfaceVectInfo] :: [Name] -> [Name] -> [Name] -> [Name] -> [Name] -> IfaceVectInfo

-- | All variables in here have a vectorised variant
[ifaceVectInfoVar] :: IfaceVectInfo -> [Name]

-- | All <a>TyCon</a>s in here have a vectorised variant; the name of the
--   vectorised variant and those of its data constructors are determined
--   by <a>mkVectTyConOcc</a> and <a>mkVectDataConOcc</a>; the names of the
--   isomorphisms are determined by <a>mkVectIsoOcc</a>
[ifaceVectInfoTyCon] :: IfaceVectInfo -> [Name]

-- | The vectorised form of all the <a>TyCon</a>s in here coincides with
--   the unconverted form; the name of the isomorphisms is determined by
--   <a>mkVectIsoOcc</a>
[ifaceVectInfoTyConReuse] :: IfaceVectInfo -> [Name]
[ifaceVectInfoParallelVars] :: IfaceVectInfo -> [Name]
[ifaceVectInfoParallelTyCons] :: IfaceVectInfo -> [Name]
noVectInfo :: VectInfo
plusVectInfo :: VectInfo -> VectInfo -> VectInfo
noIfaceVectInfo :: IfaceVectInfo
isNoIfaceVectInfo :: IfaceVectInfo -> Bool

-- | Safe Haskell information for <a>ModIface</a> Simply a wrapper around
--   SafeHaskellMode to sepperate iface and flags
data IfaceTrustInfo
getSafeMode :: IfaceTrustInfo -> SafeHaskellMode
setSafeMode :: SafeHaskellMode -> IfaceTrustInfo
noIfaceTrustInfo :: IfaceTrustInfo
trustInfoToNum :: IfaceTrustInfo -> Word8
numToTrustInfo :: Word8 -> IfaceTrustInfo

-- | Is an import a safe import?
type IsSafeImport = Bool
data HsParsedModule
[HsParsedModule] :: Located (HsModule RdrName) -> [FilePath] -> ApiAnns -> HsParsedModule
[hpm_module] :: HsParsedModule -> Located (HsModule RdrName)

-- | extra source files (e.g. from #includes). The lexer collects these
--   from '# <a>file</a> <a>line</a>' pragmas, which the C preprocessor
--   leaves behind. These files and their timestamps are stored in the .hi
--   file, so that we can force recompilation if any of them change (#3589)
[hpm_src_files] :: HsParsedModule -> [FilePath]
[hpm_annotations] :: HsParsedModule -> ApiAnns

-- | A source error is an error that is caused by one or more errors in the
--   source code. A <a>SourceError</a> is thrown by many functions in the
--   compilation pipeline. Inside GHC these errors are merely printed via
--   <a>log_action</a>, but API clients may treat them differently, for
--   example, insert them into a list box. If you want the default
--   behaviour, use the idiom:
--   
--   <pre>
--   handleSourceError printExceptionAndWarnings $ do
--     ... api calls that may fail ...
--   </pre>
--   
--   The <a>SourceError</a>s error messages can be accessed via
--   <a>srcErrorMessages</a>. This list may be empty if the compiler failed
--   due to <tt>-Werror</tt> (<a>Opt_WarnIsError</a>).
--   
--   See <tt>printExceptionAndWarnings</tt> for more information on what to
--   take care of when writing a custom error handler.
data SourceError

-- | An error thrown if the GHC API is used in an incorrect fashion.
data GhcApiError
mkSrcErr :: ErrorMessages -> SourceError
srcErrorMessages :: SourceError -> ErrorMessages
mkApiErr :: DynFlags -> SDoc -> GhcApiError
throwOneError :: MonadIO m => ErrMsg -> m ab

-- | Perform the given action and call the exception handler if the action
--   throws a <a>SourceError</a>. See <a>SourceError</a> for more
--   information.
handleSourceError :: (ExceptionMonad m) => (SourceError -> m a) -> m a -> m a
handleFlagWarnings :: DynFlags -> [Located String] -> IO ()

-- | Given a bag of warnings, turn them into an exception if -Werror is
--   enabled, or print them out otherwise.
printOrThrowWarnings :: DynFlags -> Bag WarnMsg -> IO ()
instance Eq Usage
instance Eq Dependencies
instance Eq Warnings
instance Eq TargetId
instance Functor Hsc
instance Applicative Hsc
instance Monad Hsc
instance MonadIO Hsc
instance HasDynFlags Hsc
instance Show SourceError
instance Exception SourceError
instance Show GhcApiError
instance Exception GhcApiError
instance ContainsDynFlags HscEnv
instance Outputable Target
instance Outputable TargetId
instance Binary ModIface
instance Outputable InteractiveImport
instance Binary Warnings
instance Outputable FixItem
instance Binary Dependencies
instance Binary Usage
instance Outputable ModSummary
instance Outputable VectInfo
instance Outputable IfaceVectInfo
instance Binary IfaceVectInfo
instance Outputable IfaceTrustInfo
instance Binary IfaceTrustInfo
instance Outputable Linkable
instance Outputable Unlinked

module GhcMonad

-- | A monad that has all the features needed by GHC API calls.
--   
--   In short, a GHC monad
--   
--   <ul>
--   <li>allows embedding of IO actions,</li>
--   <li>can log warnings,</li>
--   <li>allows handling of (extensible) exceptions, and</li>
--   <li>maintains a current session.</li>
--   </ul>
--   
--   If you do not use <a>Ghc</a> or <a>GhcT</a>, make sure to call
--   <a>initGhcMonad</a> before any call to the GHC API functions can
--   occur.
class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m
getSession :: GhcMonad m => m HscEnv
setSession :: GhcMonad m => HscEnv -> m ()

-- | A minimal implementation of a <a>GhcMonad</a>. If you need a custom
--   monad, e.g., to maintain additional state consider wrapping this monad
--   or using <a>GhcT</a>.
newtype Ghc a
[Ghc] :: (Session -> IO a) -> Ghc a
[unGhc] :: Ghc a -> Session -> IO a

-- | A monad transformer to add GHC specific features to another monad.
--   
--   Note that the wrapped monad must support IO and handling of
--   exceptions.
newtype GhcT m a
[GhcT] :: (Session -> m a) -> GhcT m a
[unGhcT] :: GhcT m a -> Session -> m a
liftGhcT :: Monad m => m a -> GhcT m a

-- | Reflect a computation in the <a>Ghc</a> monad into the <a>IO</a>
--   monad.
--   
--   You can use this to call functions returning an action in the
--   <a>Ghc</a> monad inside an <a>IO</a> action. This is needed for some
--   (too restrictive) callback arguments of some library functions:
--   
--   <pre>
--   libFunc :: String -&gt; (Int -&gt; IO a) -&gt; IO a
--   ghcFunc :: Int -&gt; Ghc a
--   
--   ghcFuncUsingLibFunc :: String -&gt; Ghc a -&gt; Ghc a
--   ghcFuncUsingLibFunc str =
--     reifyGhc $ \s -&gt;
--       libFunc $ \i -&gt; do
--         reflectGhc (ghcFunc i) s
--   </pre>
reflectGhc :: Ghc a -> Session -> IO a
reifyGhc :: (Session -> IO a) -> Ghc a

-- | Grabs the DynFlags from the Session
getSessionDynFlags :: GhcMonad m => m DynFlags

-- | Lift a computation from the <a>IO</a> monad.
liftIO :: MonadIO m => forall a. IO a -> m a

-- | The Session is a handle to the complete state of a compilation
--   session. A compilation session consists of a set of modules
--   constituting the current program or library, the context for
--   interactive evaluation, and various caches.
data Session
[Session] :: !(IORef HscEnv) -> Session

-- | Call the argument with the current session.
withSession :: GhcMonad m => (HscEnv -> m a) -> m a

-- | Set the current session to the result of applying the current session
--   to the argument.
modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()

-- | Call an action with a temporarily modified Session.
withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a

-- | A monad that allows logging of warnings.
logWarnings :: GhcMonad m => WarningMessages -> m ()

-- | Print the error message and all warnings. Useful inside exception
--   handlers. Clears warnings after printing.
printException :: GhcMonad m => SourceError -> m ()

-- | A function called to log warnings and errors.
type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> m ()
defaultWarnErrLogger :: WarnErrLogger
instance Functor Ghc
instance Applicative Ghc
instance Monad Ghc
instance MonadIO Ghc
instance MonadFix Ghc
instance ExceptionMonad Ghc
instance HasDynFlags Ghc
instance GhcMonad Ghc
instance Functor m => Functor (GhcT m)
instance Applicative m => Applicative (GhcT m)
instance Monad m => Monad (GhcT m)
instance MonadIO m => MonadIO (GhcT m)
instance ExceptionMonad m => ExceptionMonad (GhcT m)
instance (Functor m, ExceptionMonad m, MonadIO m) => HasDynFlags (GhcT m)
instance (Functor m, ExceptionMonad m, MonadIO m) => GhcMonad (GhcT m)


-- | The CompPipeline monad and associated ops
--   
--   Defined in separate module so that it can safely be imported from
--   Hooks
module PipelineMonad
newtype CompPipeline a
[P] :: (PipeEnv -> PipeState -> IO (PipeState, a)) -> CompPipeline a
[unP] :: CompPipeline a -> PipeEnv -> PipeState -> IO (PipeState, a)
evalP :: CompPipeline a -> PipeEnv -> PipeState -> IO a
data PhasePlus
[RealPhase] :: Phase -> PhasePlus
[HscOut] :: HscSource -> ModuleName -> HscStatus -> PhasePlus
data PipeEnv
[PipeEnv] :: Bool -> Phase -> String -> String -> String -> PipelineOutput -> PipeEnv
[pe_isHaskellishFile] :: PipeEnv -> Bool

-- | Stop just before this phase
[stop_phase] :: PipeEnv -> Phase

-- | basename of original input source
[src_filename] :: PipeEnv -> String

-- | basename of original input source
[src_basename] :: PipeEnv -> String

-- | its extension
[src_suffix] :: PipeEnv -> String

-- | says where to put the pipeline output
[output_spec] :: PipeEnv -> PipelineOutput
data PipeState
[PipeState] :: HscEnv -> Maybe ModLocation -> Maybe FilePath -> PipeState

-- | only the DynFlags change in the HscEnv. The DynFlags change at various
--   points, for example when we read the OPTIONS_GHC pragmas in the Cpp
--   phase.
[hsc_env] :: PipeState -> HscEnv

-- | the ModLocation. This is discovered during compilation, in the Hsc
--   phase where we read the module header.
[maybe_loc] :: PipeState -> Maybe ModLocation

-- | the stub object. This is set by the Hsc phase if a stub object was
--   created. The stub object will be joined with the main compilation
--   object using "ld -r" at the end.
[maybe_stub_o] :: PipeState -> Maybe FilePath
data PipelineOutput

-- | Output should be to a temporary file: we're going to run more
--   compilation steps on this output later.
[Temporary] :: PipelineOutput

-- | We want a persistent file, i.e. a file in the current directory
--   derived from the input filename, but with the appropriate extension.
--   eg. in "ghc -c Foo.hs" the output goes into ./Foo.o.
[Persistent] :: PipelineOutput

-- | The output must go into the specific outputFile in DynFlags. We don't
--   store the filename in the constructor as it changes when doing
--   -dynamic-too.
[SpecificFile] :: PipelineOutput
getPipeEnv :: CompPipeline PipeEnv
getPipeState :: CompPipeline PipeState
setDynFlags :: DynFlags -> CompPipeline ()
setModLocation :: ModLocation -> CompPipeline ()
setStubO :: FilePath -> CompPipeline ()
instance Show PipelineOutput
instance Functor CompPipeline
instance Applicative CompPipeline
instance Monad CompPipeline
instance MonadIO CompPipeline
instance Outputable PhasePlus
instance HasDynFlags CompPipeline

module TcRnTypes
type TcRnIf a b = IOEnv (Env a b)
type TcRn = TcRnIf TcGblEnv TcLclEnv

-- | Historical "type-checking monad" (now it's just <a>TcRn</a>).
type TcM = TcRn

-- | Historical "renaming monad" (now it's just <a>TcRn</a>).
type RnM = TcRn
type IfM lcl = TcRnIf IfGblEnv lcl
type IfL = IfM IfLclEnv
type IfG = IfM ()

-- | Type alias for <a>IORef</a>; the convention is we'll use this for
--   mutable bits of data in <a>TcGblEnv</a> which are updated during
--   typechecking and returned at the end.
type TcRef a = IORef a
data Env gbl lcl
[Env] :: HscEnv -> {-# UNPACK #-} !(IORef UniqSupply) -> gbl -> lcl -> Env gbl lcl
[env_top] :: Env gbl lcl -> HscEnv
[env_us] :: Env gbl lcl -> {-# UNPACK #-} !(IORef UniqSupply)
[env_gbl] :: Env gbl lcl -> gbl
[env_lcl] :: Env gbl lcl -> lcl

-- | <a>TcGblEnv</a> describes the top-level of the module at the point at
--   which the typechecker is finished work. It is this structure that is
--   handed on to the desugarer For state that needs to be updated during
--   the typechecking phase and returned at end, use a <a>TcRef</a> (=
--   <a>IORef</a>).
data TcGblEnv
[TcGblEnv] :: Module -> HscSource -> Maybe Module -> Maybe GlobalRdrEnv -> GlobalRdrEnv -> Maybe [Type] -> FixityEnv -> RecFieldEnv -> TypeEnv -> TcRef TypeEnv -> InstEnv -> FamInstEnv -> AnnEnv -> ModuleSet -> [AvailInfo] -> ImportAvails -> DefUses -> TcRef (Set RdrName) -> TcRef NameSet -> TcRef Bool -> TcRef Bool -> TcRef OccSet -> Maybe [Located (IE Name)] -> [LImportDecl Name] -> Maybe (HsGroup Name) -> TcRef [FilePath] -> TcRef [LHsDecl RdrName] -> TcRef NameSet -> TcRef [Q ()] -> TcRef (Map TypeRep Dynamic) -> Bag EvBind -> LHsBinds Id -> NameSet -> [LTcSpecPrag] -> Warnings -> [Annotation] -> [TyCon] -> [ClsInst] -> [FamInst] -> [LRuleDecl Id] -> [LForeignDecl Id] -> [LVectDecl Id] -> [PatSyn] -> Maybe LHsDocString -> AnyHpcUsage -> Maybe Name -> TcRef Bool -> [TcPluginSolver] -> TcRef WantedConstraints -> TcGblEnv

-- | Module being compiled
[tcg_mod] :: TcGblEnv -> Module

-- | What kind of module (regular Haskell, hs-boot, ext-core)
[tcg_src] :: TcGblEnv -> HscSource

-- | Are we being compiled as a signature of an implementation?
[tcg_sig_of] :: TcGblEnv -> Maybe Module

-- | Environment used only during -sig-of for resolving top level bindings.
--   See Note [Signature parameters in TcGblEnv and DynFlags]
[tcg_impl_rdr_env] :: TcGblEnv -> Maybe GlobalRdrEnv

-- | Top level envt; used during renaming
[tcg_rdr_env] :: TcGblEnv -> GlobalRdrEnv

-- | Types used for defaulting. <tt>Nothing</tt> =&gt; no <tt>default</tt>
--   decl
[tcg_default] :: TcGblEnv -> Maybe [Type]

-- | Just for things in this module
[tcg_fix_env] :: TcGblEnv -> FixityEnv

-- | Just for things in this module See Note [The interactive package] in
--   HscTypes
[tcg_field_env] :: TcGblEnv -> RecFieldEnv

-- | Global type env for the module we are compiling now. All TyCons and
--   Classes (for this module) end up in here right away, along with their
--   derived constructors, selectors.
--   
--   (Ids defined in this module start in the local envt, though they move
--   to the global envt during zonking)
--   
--   NB: for what "things in this module" means, see Note [The interactive
--   package] in HscTypes
[tcg_type_env] :: TcGblEnv -> TypeEnv
[tcg_type_env_var] :: TcGblEnv -> TcRef TypeEnv

-- | Instance envt for all <i>home-package</i> modules; Includes the dfuns
--   in tcg_insts
[tcg_inst_env] :: TcGblEnv -> InstEnv

-- | Ditto for family instances
[tcg_fam_inst_env] :: TcGblEnv -> FamInstEnv

-- | And for annotations
[tcg_ann_env] :: TcGblEnv -> AnnEnv

-- | The set of orphan modules which transitively reachable from direct
--   imports. We use this to figure out if an orphan instance in the global
--   InstEnv should be considered visible. See Note [Instance lookup and
--   orphan instances] in InstEnv
[tcg_visible_orphan_mods] :: TcGblEnv -> ModuleSet

-- | What is exported
[tcg_exports] :: TcGblEnv -> [AvailInfo]

-- | Information about what was imported from where, including things bound
--   in this module. Also store Safe Haskell info here about transative
--   trusted packaage requirements.
[tcg_imports] :: TcGblEnv -> ImportAvails

-- | What is defined in this module and what is used.
[tcg_dus] :: TcGblEnv -> DefUses
[tcg_used_rdrnames] :: TcGblEnv -> TcRef (Set RdrName)

-- | Locally-defined top-level names to keep alive.
--   
--   "Keep alive" means give them an Exported flag, so that the simplifier
--   does not discard them as dead code, and so that they are exposed in
--   the interface file (but not to export to the user).
--   
--   Some things, like dict-fun Ids and default-method Ids are "born" with
--   the Exported flag on, for exactly the above reason, but some we only
--   discover as we go. Specifically:
--   
--   <ul>
--   <li>The to/from functions for generic data types</li>
--   <li>Top-level variables appearing free in the RHS of an orphan
--   rule</li>
--   <li>Top-level variables appearing free in a TH bracket</li>
--   </ul>
[tcg_keep] :: TcGblEnv -> TcRef NameSet

-- | <tt>True</tt> <a>=</a> Template Haskell syntax used.
--   
--   We need this so that we can generate a dependency on the Template
--   Haskell package, because the desugarer is going to emit loads of
--   references to TH symbols. The reference is implicit rather than
--   explicit, so we have to zap a mutable variable.
[tcg_th_used] :: TcGblEnv -> TcRef Bool

-- | <tt>True</tt> <a>=</a> A Template Haskell splice was used.
--   
--   Splices disable recompilation avoidance (see #481)
[tcg_th_splice_used] :: TcGblEnv -> TcRef Bool

-- | Allows us to choose unique DFun names.
[tcg_dfun_n] :: TcGblEnv -> TcRef OccSet
[tcg_rn_exports] :: TcGblEnv -> Maybe [Located (IE Name)]
[tcg_rn_imports] :: TcGblEnv -> [LImportDecl Name]

-- | Renamed decls, maybe. <tt>Nothing</tt> <a>=</a> Don't retain renamed
--   decls.
[tcg_rn_decls] :: TcGblEnv -> Maybe (HsGroup Name)

-- | dependencies from addDependentFile
[tcg_dependent_files] :: TcGblEnv -> TcRef [FilePath]

-- | Top-level declarations from addTopDecls
[tcg_th_topdecls] :: TcGblEnv -> TcRef [LHsDecl RdrName]

-- | Exact names bound in top-level declarations in tcg_th_topdecls
[tcg_th_topnames] :: TcGblEnv -> TcRef NameSet

-- | Template Haskell module finalizers
[tcg_th_modfinalizers] :: TcGblEnv -> TcRef [Q ()]

-- | Template Haskell state
[tcg_th_state] :: TcGblEnv -> TcRef (Map TypeRep Dynamic)
[tcg_ev_binds] :: TcGblEnv -> Bag EvBind
[tcg_binds] :: TcGblEnv -> LHsBinds Id
[tcg_sigs] :: TcGblEnv -> NameSet
[tcg_imp_specs] :: TcGblEnv -> [LTcSpecPrag]
[tcg_warns] :: TcGblEnv -> Warnings
[tcg_anns] :: TcGblEnv -> [Annotation]
[tcg_tcs] :: TcGblEnv -> [TyCon]
[tcg_insts] :: TcGblEnv -> [ClsInst]
[tcg_fam_insts] :: TcGblEnv -> [FamInst]
[tcg_rules] :: TcGblEnv -> [LRuleDecl Id]
[tcg_fords] :: TcGblEnv -> [LForeignDecl Id]
[tcg_vects] :: TcGblEnv -> [LVectDecl Id]
[tcg_patsyns] :: TcGblEnv -> [PatSyn]

-- | Maybe Haddock header docs
[tcg_doc_hdr] :: TcGblEnv -> Maybe LHsDocString

-- | <tt>True</tt> if any part of the prog uses hpc instrumentation.
[tcg_hpc] :: TcGblEnv -> AnyHpcUsage

-- | The Name of the main function, if this module is the main module.
[tcg_main] :: TcGblEnv -> Maybe Name
[tcg_safeInfer] :: TcGblEnv -> TcRef Bool

-- | A list of user-defined plugins for the constraint solver.
[tcg_tc_plugins] :: TcGblEnv -> [TcPluginSolver]

-- | Wanted constraints of static forms.
[tcg_static_wc] :: TcGblEnv -> TcRef WantedConstraints
data TcLclEnv
[TcLclEnv] :: SrcSpan -> [ErrCtxt] -> TcLevel -> ThStage -> ThBindEnv -> ArrowCtxt -> LocalRdrEnv -> TcTypeEnv -> [TcIdBinder] -> TidyEnv -> TcRef TcTyVarSet -> TcRef WantedConstraints -> TcRef Messages -> TcLclEnv
[tcl_loc] :: TcLclEnv -> SrcSpan
[tcl_ctxt] :: TcLclEnv -> [ErrCtxt]
[tcl_tclvl] :: TcLclEnv -> TcLevel
[tcl_th_ctxt] :: TcLclEnv -> ThStage
[tcl_th_bndrs] :: TcLclEnv -> ThBindEnv
[tcl_arrow_ctxt] :: TcLclEnv -> ArrowCtxt
[tcl_rdr] :: TcLclEnv -> LocalRdrEnv
[tcl_env] :: TcLclEnv -> TcTypeEnv
[tcl_bndrs] :: TcLclEnv -> [TcIdBinder]
[tcl_tidy] :: TcLclEnv -> TidyEnv
[tcl_tyvars] :: TcLclEnv -> TcRef TcTyVarSet
[tcl_lie] :: TcLclEnv -> TcRef WantedConstraints
[tcl_errs] :: TcLclEnv -> TcRef Messages
data IfGblEnv
[IfGblEnv] :: Maybe (Module, IfG TypeEnv) -> IfGblEnv
[if_rec_types] :: IfGblEnv -> Maybe (Module, IfG TypeEnv)
data IfLclEnv
[IfLclEnv] :: Module -> SDoc -> UniqFM TyVar -> UniqFM Id -> IfLclEnv
[if_mod] :: IfLclEnv -> Module
[if_loc] :: IfLclEnv -> SDoc
[if_tv_env] :: IfLclEnv -> UniqFM TyVar
[if_id_env] :: IfLclEnv -> UniqFM Id
type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, MsgDoc))
data RecFieldEnv
[RecFields] :: (NameEnv [Name]) -> NameSet -> RecFieldEnv

-- | <a>ImportAvails</a> summarises what was imported from where,
--   irrespective of whether the imported things are actually used or not.
--   It is used:
--   
--   <ul>
--   <li>when processing the export list,</li>
--   <li>when constructing usage info for the interface file,</li>
--   <li>to identify the list of directly imported modules for
--   initialisation purposes and for optimised overlap checking of family
--   instances,</li>
--   <li>when figuring out what things are really unused</li>
--   </ul>
data ImportAvails
[ImportAvails] :: ImportedMods -> ModuleNameEnv (ModuleName, IsBootInterface) -> [PackageKey] -> [PackageKey] -> Bool -> [Module] -> [Module] -> ImportAvails

-- | Domain is all directly-imported modules The <a>ModuleName</a> is what
--   the module was imported as, e.g. in <tt> import Foo as Bar </tt> it is
--   <tt>Bar</tt>.
--   
--   The <a>Bool</a> means:
--   
--   <ul>
--   <li><tt>True</tt> =&gt; import was <tt>import Foo ()</tt></li>
--   <li><tt>False</tt> =&gt; import was some other form</li>
--   </ul>
--   
--   Used
--   
--   (a) to help construct the usage information in the interface file; if
--   we import something we need to recompile if the export version changes
--   
--   (b) to specify what child modules to initialise
--   
--   We need a full ModuleEnv rather than a ModuleNameEnv here, because we
--   might be importing modules of the same name from different packages.
--   (currently not the case, but might be in the future).
[imp_mods] :: ImportAvails -> ImportedMods

-- | Home-package modules needed by the module being compiled
--   
--   It doesn't matter whether any of these dependencies are actually
--   <i>used</i> when compiling the module; they are listed if they are
--   below it at all. For example, suppose M imports A which imports X.
--   Then compiling M might not need to consult X.hi, but X is still listed
--   in M's dependencies.
[imp_dep_mods] :: ImportAvails -> ModuleNameEnv (ModuleName, IsBootInterface)

-- | Packages needed by the module being compiled, whether directly, or via
--   other modules in this package, or via modules imported from other
--   packages.
[imp_dep_pkgs] :: ImportAvails -> [PackageKey]

-- | This is strictly a subset of imp_dep_pkgs and records the packages the
--   current module needs to trust for Safe Haskell compilation to succeed.
--   A package is required to be trusted if we are dependent on a
--   trustworthy module in that package. While perhaps making imp_dep_pkgs
--   a tuple of (PackageKey, Bool) where True for the bool indicates the
--   package is required to be trusted is the more logical design, doing so
--   complicates a lot of code not concerned with Safe Haskell. See Note
--   [RnNames . Tracking Trust Transitively]
[imp_trust_pkgs] :: ImportAvails -> [PackageKey]

-- | Do we require that our own package is trusted? This is to handle
--   efficiently the case where a Safe module imports a Trustworthy module
--   that resides in the same package as it. See Note [RnNames . Trust Own
--   Package]
[imp_trust_own_pkg] :: ImportAvails -> Bool

-- | Orphan modules below us in the import tree (and maybe including us for
--   imported modules)
[imp_orphs] :: ImportAvails -> [Module]

-- | Family instance modules below us in the import tree (and maybe
--   including us for imported modules)
[imp_finsts] :: ImportAvails -> [Module]
emptyImportAvails :: ImportAvails

-- | Union two ImportAvails
--   
--   This function is a key part of Import handling, basically for each
--   import we create a separate ImportAvails structure and then union them
--   all together with this function.
plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails
data WhereFrom
[ImportByUser] :: IsBootInterface -> WhereFrom
[ImportBySystem] :: WhereFrom
[ImportByPlugin] :: WhereFrom
mkModDeps :: [(ModuleName, IsBootInterface)] -> ModuleNameEnv (ModuleName, IsBootInterface)
type TcTypeEnv = NameEnv TcTyThing
data TcIdBinder
[TcIdBndr] :: TcId -> TopLevelFlag -> TcIdBinder
data TcTyThing
[AGlobal] :: TyThing -> TcTyThing
[ATcId] :: TcId -> TopLevelFlag -> TcTyThing
[tct_id] :: TcTyThing -> TcId
[tct_closed] :: TcTyThing -> TopLevelFlag
[ATyVar] :: Name -> TcTyVar -> TcTyThing
[AThing] :: TcKind -> TcTyThing
[APromotionErr] :: PromotionErr -> TcTyThing
data PromotionErr
[TyConPE] :: PromotionErr
[ClassPE] :: PromotionErr
[FamDataConPE] :: PromotionErr
[RecDataConPE] :: PromotionErr
[NoDataKinds] :: PromotionErr
pprTcTyThingCategory :: TcTyThing -> SDoc
pprPECategory :: PromotionErr -> SDoc
type DsM = TcRnIf DsGblEnv DsLclEnv
data DsLclEnv
[DsLclEnv] :: DsMetaEnv -> SrcSpan -> DsLclEnv
[dsl_meta] :: DsLclEnv -> DsMetaEnv
[dsl_loc] :: DsLclEnv -> SrcSpan
data DsGblEnv
[DsGblEnv] :: Module -> FamInstEnv -> PrintUnqualified -> IORef Messages -> (IfGblEnv, IfLclEnv) -> GlobalRdrEnv -> PArrBuiltin -> IORef [(Fingerprint, (Id, CoreExpr))] -> DsGblEnv
[ds_mod] :: DsGblEnv -> Module
[ds_fam_inst_env] :: DsGblEnv -> FamInstEnv
[ds_unqual] :: DsGblEnv -> PrintUnqualified
[ds_msgs] :: DsGblEnv -> IORef Messages
[ds_if_env] :: DsGblEnv -> (IfGblEnv, IfLclEnv)
[ds_dph_env] :: DsGblEnv -> GlobalRdrEnv
[ds_parr_bi] :: DsGblEnv -> PArrBuiltin

-- | Bindings resulted from floating static forms
[ds_static_binds] :: DsGblEnv -> IORef [(Fingerprint, (Id, CoreExpr))]
data PArrBuiltin
[PArrBuiltin] :: Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> PArrBuiltin

-- | lengthP
[lengthPVar] :: PArrBuiltin -> Var

-- | replicateP
[replicatePVar] :: PArrBuiltin -> Var

-- | singletonP
[singletonPVar] :: PArrBuiltin -> Var

-- | mapP
[mapPVar] :: PArrBuiltin -> Var

-- | filterP
[filterPVar] :: PArrBuiltin -> Var

-- | zipP
[zipPVar] :: PArrBuiltin -> Var

-- | crossMapP
[crossMapPVar] :: PArrBuiltin -> Var

-- | (!:)
[indexPVar] :: PArrBuiltin -> Var

-- | emptyP
[emptyPVar] :: PArrBuiltin -> Var

-- | (+:+)
[appPVar] :: PArrBuiltin -> Var

-- | enumFromToP
[enumFromToPVar] :: PArrBuiltin -> Var

-- | enumFromThenToP
[enumFromThenToPVar] :: PArrBuiltin -> Var
type DsMetaEnv = NameEnv DsMetaVal
data DsMetaVal
[DsBound] :: Id -> DsMetaVal
[DsSplice] :: (HsExpr Id) -> DsMetaVal
data ThStage
[Splice] :: Bool -> ThStage
[Comp] :: ThStage
[Brack] :: ThStage -> PendingStuff -> ThStage
data PendingStuff
[RnPendingUntyped] :: (TcRef [PendingRnSplice]) -> PendingStuff
[RnPendingTyped] :: PendingStuff
[TcPending] :: (TcRef [PendingTcSplice]) -> (TcRef WantedConstraints) -> PendingStuff
topStage :: ThStage
topAnnStage :: ThStage
topSpliceStage :: ThStage
type ThLevel = Int
impLevel :: ThLevel
outerLevel :: ThLevel
thLevel :: ThStage -> ThLevel
data ArrowCtxt
[NoArrowCtxt] :: ArrowCtxt
[ArrowCtxt] :: LocalRdrEnv -> (TcRef WantedConstraints) -> ArrowCtxt
type Xi = Type
data Ct
[CDictCan] :: CtEvidence -> Class -> [Xi] -> Ct
[cc_ev] :: Ct -> CtEvidence
[cc_class] :: Ct -> Class
[cc_tyargs] :: Ct -> [Xi]
[CIrredEvCan] :: CtEvidence -> Ct
[cc_ev] :: Ct -> CtEvidence
[CTyEqCan] :: CtEvidence -> TcTyVar -> TcType -> EqRel -> Ct
[cc_ev] :: Ct -> CtEvidence
[cc_tyvar] :: Ct -> TcTyVar
[cc_rhs] :: Ct -> TcType
[cc_eq_rel] :: Ct -> EqRel
[CFunEqCan] :: CtEvidence -> TyCon -> [Xi] -> TcTyVar -> Ct
[cc_ev] :: Ct -> CtEvidence
[cc_fun] :: Ct -> TyCon
[cc_tyargs] :: Ct -> [Xi]
[cc_fsk] :: Ct -> TcTyVar
[CNonCanonical] :: CtEvidence -> Ct
[cc_ev] :: Ct -> CtEvidence
[CHoleCan] :: CtEvidence -> OccName -> HoleSort -> Ct
[cc_ev] :: Ct -> CtEvidence
[cc_occ] :: Ct -> OccName
[cc_hole] :: Ct -> HoleSort
type Cts = Bag Ct
emptyCts :: Cts
andCts :: Cts -> Cts -> Cts
andManyCts :: [Cts] -> Cts
pprCts :: Cts -> SDoc
singleCt :: Ct -> Cts
listToCts :: [Ct] -> Cts
ctsElts :: Cts -> [Ct]
consCts :: Ct -> Cts -> Cts
snocCts :: Cts -> Ct -> Cts
extendCtsList :: Cts -> [Ct] -> Cts
isEmptyCts :: Cts -> Bool
isCTyEqCan :: Ct -> Bool
isCFunEqCan :: Ct -> Bool
isCDictCan_Maybe :: Ct -> Maybe Class
isCFunEqCan_maybe :: Ct -> Maybe (TyCon, [Type])
isCIrredEvCan :: Ct -> Bool
isCNonCanonical :: Ct -> Bool
isWantedCt :: Ct -> Bool
isDerivedCt :: Ct -> Bool
isGivenCt :: Ct -> Bool
isHoleCt :: Ct -> Bool
isTypedHoleCt :: Ct -> Bool
isPartialTypeSigCt :: Ct -> Bool
ctEvidence :: Ct -> CtEvidence
ctLoc :: Ct -> CtLoc
ctPred :: Ct -> PredType

-- | Get the flavour of the given <a>Ct</a>
ctFlavour :: Ct -> CtFlavour

-- | Get the equality relation for the given <a>Ct</a>
ctEqRel :: Ct -> EqRel
mkNonCanonical :: CtEvidence -> Ct
mkNonCanonicalCt :: Ct -> Ct
ctEvPred :: CtEvidence -> TcPredType
ctEvLoc :: CtEvidence -> CtLoc

-- | Get the equality relation relevant for a <a>CtEvidence</a>
ctEvEqRel :: CtEvidence -> EqRel
ctEvTerm :: CtEvidence -> EvTerm
ctEvCoercion :: CtEvidence -> TcCoercion
ctEvId :: CtEvidence -> TcId

-- | Checks whether the evidence can be used to solve a goal with the given
--   minimum depth See Note [Preventing recursive dictionaries]
ctEvCheckDepth :: Class -> CtLoc -> CtEvidence -> Bool
data WantedConstraints
[WC] :: Cts -> Bag Implication -> Cts -> WantedConstraints
[wc_simple] :: WantedConstraints -> Cts
[wc_impl] :: WantedConstraints -> Bag Implication
[wc_insol] :: WantedConstraints -> Cts
insolubleWC :: WantedConstraints -> Bool
emptyWC :: WantedConstraints
isEmptyWC :: WantedConstraints -> Bool
andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints
unionsWC :: [WantedConstraints] -> WantedConstraints
addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints
addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints
mkSimpleWC :: [Ct] -> WantedConstraints
addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints
dropDerivedWC :: WantedConstraints -> WantedConstraints
data Implication
[Implic] :: TcLevel -> [TcTyVar] -> SkolemInfo -> [EvVar] -> Bool -> TcLclEnv -> WantedConstraints -> Bool -> EvBindsVar -> Implication
[ic_tclvl] :: Implication -> TcLevel
[ic_skols] :: Implication -> [TcTyVar]
[ic_info] :: Implication -> SkolemInfo
[ic_given] :: Implication -> [EvVar]
[ic_no_eqs] :: Implication -> Bool
[ic_env] :: Implication -> TcLclEnv
[ic_wanted] :: Implication -> WantedConstraints
[ic_insol] :: Implication -> Bool
[ic_binds] :: Implication -> EvBindsVar
data SubGoalCounter
[CountConstraints] :: SubGoalCounter
[CountTyFunApps] :: SubGoalCounter
data SubGoalDepth
initialSubGoalDepth :: SubGoalDepth
maxSubGoalDepth :: DynFlags -> SubGoalDepth
bumpSubGoalDepth :: SubGoalCounter -> SubGoalDepth -> SubGoalDepth
subGoalCounterValue :: SubGoalCounter -> SubGoalDepth -> Int
subGoalDepthExceeded :: SubGoalDepth -> SubGoalDepth -> Maybe SubGoalCounter
data CtLoc
[CtLoc] :: CtOrigin -> TcLclEnv -> !SubGoalDepth -> CtLoc
[ctl_origin] :: CtLoc -> CtOrigin
[ctl_env] :: CtLoc -> TcLclEnv
[ctl_depth] :: CtLoc -> !SubGoalDepth
ctLocSpan :: CtLoc -> SrcSpan
ctLocEnv :: CtLoc -> TcLclEnv
ctLocOrigin :: CtLoc -> CtOrigin
ctLocDepth :: CtLoc -> SubGoalDepth
bumpCtLocDepth :: SubGoalCounter -> CtLoc -> CtLoc
setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc
setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc
setCtLocSpan :: CtLoc -> SrcSpan -> CtLoc
data CtOrigin
[GivenOrigin] :: SkolemInfo -> CtOrigin
[OccurrenceOf] :: Name -> CtOrigin
[AppOrigin] :: CtOrigin
[SpecPragOrigin] :: Name -> CtOrigin
[TypeEqOrigin] :: TcType -> TcType -> CtOrigin
[uo_actual] :: CtOrigin -> TcType
[uo_expected] :: CtOrigin -> TcType
[KindEqOrigin] :: TcType -> TcType -> CtOrigin -> CtOrigin
[CoercibleOrigin] :: TcType -> TcType -> CtOrigin
[IPOccOrigin] :: HsIPName -> CtOrigin
[LiteralOrigin] :: (HsOverLit Name) -> CtOrigin
[NegateOrigin] :: CtOrigin
[ArithSeqOrigin] :: (ArithSeqInfo Name) -> CtOrigin
[PArrSeqOrigin] :: (ArithSeqInfo Name) -> CtOrigin
[SectionOrigin] :: CtOrigin
[TupleOrigin] :: CtOrigin
[ExprSigOrigin] :: CtOrigin
[PatSigOrigin] :: CtOrigin
[PatOrigin] :: CtOrigin
[RecordUpdOrigin] :: CtOrigin
[ViewPatOrigin] :: CtOrigin
[ScOrigin] :: CtOrigin
[DerivOrigin] :: CtOrigin
[DerivOriginDC] :: DataCon -> Int -> CtOrigin
[DerivOriginCoerce] :: Id -> Type -> Type -> CtOrigin
[StandAloneDerivOrigin] :: CtOrigin
[DefaultOrigin] :: CtOrigin
[DoOrigin] :: CtOrigin
[MCompOrigin] :: CtOrigin
[IfOrigin] :: CtOrigin
[ProcOrigin] :: CtOrigin
[AnnOrigin] :: CtOrigin
[FunDepOrigin1] :: PredType -> CtLoc -> PredType -> CtLoc -> CtOrigin
[FunDepOrigin2] :: PredType -> CtOrigin -> PredType -> SrcSpan -> CtOrigin
[HoleOrigin] :: CtOrigin
[UnboundOccurrenceOf] :: RdrName -> CtOrigin
[ListOrigin] :: CtOrigin
[StaticOrigin] :: CtOrigin
pprCtOrigin :: CtOrigin -> SDoc
pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc
pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc
data SkolemInfo
[SigSkol] :: UserTypeCtxt -> Type -> SkolemInfo
[ClsSkol] :: Class -> SkolemInfo
[InstSkol] :: SkolemInfo
[DataSkol] :: SkolemInfo
[FamInstSkol] :: SkolemInfo
[PatSkol] :: ConLike -> (HsMatchContext Name) -> SkolemInfo
[ArrowSkol] :: SkolemInfo
[IPSkol] :: [HsIPName] -> SkolemInfo
[RuleSkol] :: RuleName -> SkolemInfo
[InferSkol] :: [(Name, TcType)] -> SkolemInfo
[BracketSkol] :: SkolemInfo
[UnifyForAllSkol] :: [TcTyVar] -> TcType -> SkolemInfo
[UnkSkol] :: SkolemInfo
data CtEvidence
[CtGiven] :: TcPredType -> EvTerm -> CtLoc -> CtEvidence
[ctev_pred] :: CtEvidence -> TcPredType
[ctev_evtm] :: CtEvidence -> EvTerm
[ctev_loc] :: CtEvidence -> CtLoc
[CtWanted] :: TcPredType -> EvVar -> CtLoc -> CtEvidence
[ctev_pred] :: CtEvidence -> TcPredType
[ctev_evar] :: CtEvidence -> EvVar
[ctev_loc] :: CtEvidence -> CtLoc
[CtDerived] :: TcPredType -> CtLoc -> CtEvidence
[ctev_pred] :: CtEvidence -> TcPredType
[ctev_loc] :: CtEvidence -> CtLoc
mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
isWanted :: CtEvidence -> Bool
isGiven :: CtEvidence -> Bool
isDerived :: CtEvidence -> Bool

-- | Get the role relevant for a <a>CtEvidence</a>
ctEvRole :: CtEvidence -> Role
data TcPlugin
[TcPlugin] :: TcPluginM s -> (s -> TcPluginSolver) -> (s -> TcPluginM ()) -> TcPlugin

-- | Initialize plugin, when entering type-checker.
[tcPluginInit] :: TcPlugin -> TcPluginM s

-- | Solve some constraints. TODO: WRITE MORE DETAILS ON HOW THIS WORKS.
[tcPluginSolve] :: TcPlugin -> s -> TcPluginSolver

-- | Clean up after the plugin, when exiting the type-checker.
[tcPluginStop] :: TcPlugin -> s -> TcPluginM ()
data TcPluginResult

-- | The plugin found a contradiction. The returned constraints are removed
--   from the inert set, and recorded as insoluable.
[TcPluginContradiction] :: [Ct] -> TcPluginResult

-- | The first field is for constraints that were solved. These are removed
--   from the inert set, and the evidence for them is recorded. The second
--   field contains new work, that should be processed by the constraint
--   solver.
[TcPluginOk] :: [(EvTerm, Ct)] -> [Ct] -> TcPluginResult
type TcPluginSolver = [Ct] -> [Ct] -> [Ct] -> TcPluginM TcPluginResult
data TcPluginM a
runTcPluginM :: TcPluginM a -> TcM a

-- | This function provides an escape for direct access to the <a>TcM</a>
--   monad. It should not be used lightly, and the provided
--   <a>TcPluginM</a> API should be favoured instead.
unsafeTcPluginTcM :: TcM a -> TcPluginM a
data CtFlavour
[Given] :: CtFlavour
[Wanted] :: CtFlavour
[Derived] :: CtFlavour
ctEvFlavour :: CtEvidence -> CtFlavour
pprEvVarTheta :: [EvVar] -> SDoc
pprEvVars :: [EvVar] -> SDoc
pprEvVarWithType :: EvVar -> SDoc
pprArising :: CtOrigin -> SDoc
pprArisingAt :: CtLoc -> SDoc
type TcId = Id
type TcIdSet = IdSet

-- | Used to indicate which sort of hole we have.
data HoleSort

-- | A hole in an expression (TypedHoles)
[ExprHole] :: HoleSort

-- | A hole in a type (PartialTypeSignatures)
[TypeHole] :: HoleSort
instance Ord SubGoalDepth
instance Eq SubGoalDepth
instance Eq CtFlavour
instance ContainsDynFlags (Env gbl lcl)
instance ContainsModule gbl => ContainsModule (Env gbl lcl)
instance ContainsModule DsGblEnv
instance ContainsModule TcGblEnv
instance Outputable ThStage
instance Outputable TcTyThing
instance Outputable PromotionErr
instance Outputable WhereFrom
instance Outputable Ct
instance Outputable WantedConstraints
instance Outputable Implication
instance Outputable CtEvidence
instance Outputable CtFlavour
instance Outputable SubGoalDepth
instance Outputable SkolemInfo
instance Functor TcPluginM
instance Applicative TcPluginM
instance Monad TcPluginM

module Hooks
data Hooks

-- | Hooks can be used by GHC API clients to replace parts of the compiler
--   pipeline. If a hook is not installed, GHC uses the default built-in
--   behaviour
emptyHooks :: Hooks
lookupHook :: (Hooks -> Maybe a) -> a -> DynFlags -> a
getHooked :: (Functor f, HasDynFlags f) => (Hooks -> Maybe a) -> a -> f a
dsForeignsHook :: Hooks -> Maybe ([LForeignDecl Id] -> DsM (ForeignStubs, OrdList (Id, CoreExpr)))
tcForeignImportsHook :: Hooks -> Maybe ([LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt))
tcForeignExportsHook :: Hooks -> Maybe ([LForeignDecl Name] -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt))
hscFrontendHook :: Hooks -> Maybe (ModSummary -> Hsc TcGblEnv)
hscCompileOneShotHook :: Hooks -> Maybe (HscEnv -> ModSummary -> SourceModified -> IO HscStatus)
hscCompileCoreExprHook :: Hooks -> Maybe (HscEnv -> SrcSpan -> CoreExpr -> IO HValue)
ghcPrimIfaceHook :: Hooks -> Maybe ModIface
runPhaseHook :: Hooks -> Maybe (PhasePlus -> FilePath -> DynFlags -> CompPipeline (PhasePlus, FilePath))
runMetaHook :: Hooks -> Maybe (MetaHook TcM)
linkHook :: Hooks -> Maybe (GhcLink -> DynFlags -> Bool -> HomePackageTable -> IO SuccessFlag)
runQuasiQuoteHook :: Hooks -> Maybe (HsQuasiQuote Name -> RnM (HsQuasiQuote Name))
runRnSpliceHook :: Hooks -> Maybe (LHsExpr Name -> RnM (LHsExpr Name))
getValueSafelyHook :: Hooks -> Maybe (HscEnv -> Name -> Type -> IO (Maybe HValue))

module RnHsDoc
rnHsDoc :: HsDocString -> RnM HsDocString
rnLHsDoc :: LHsDocString -> RnM LHsDocString
rnMbLHsDoc :: Maybe LHsDocString -> RnM (Maybe LHsDocString)


-- | Handy functions for creating much Core syntax
module MkCore

-- | Bind a binding group over an expression, using a <tt>let</tt> or
--   <tt>case</tt> as appropriate (see <a>CoreSyn#let_app_invariant</a>)
mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr

-- | Bind a list of binding groups over an expression. The leftmost binding
--   group becomes the outermost group in the resulting expression
mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr

-- | Construct an expression which represents the application of one
--   expression to the other
mkCoreApp :: CoreExpr -> CoreExpr -> CoreExpr

-- | Construct an expression which represents the application of a number
--   of expressions to another. The leftmost expression in the list is
--   applied first Respects the let/app invariant by building a case
--   expression where necessary See CoreSyn Note [CoreSyn let/app
--   invariant]
mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr

-- | Construct an expression which represents the application of a number
--   of expressions to that of a data constructor expression. The leftmost
--   expression in the list is applied first
mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr

-- | Create a lambda where the given expression has a number of variables
--   bound over it. The leftmost binder is that bound by the outermost
--   lambda in the result
mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr
mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr
mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr

-- | Make a <i>wildcard binder</i>. This is typically used when you need a
--   binder that you expect to use only at a *binding* site. Do not use it
--   at occurrence sites because it has a single, fixed unique, and it's
--   very easy to get into difficulties with shadowing. That's why it is
--   used so little. See Note [WildCard binders] in SimplEnv
mkWildValBinder :: Type -> Id
mkWildEvBinder :: PredType -> EvVar
sortQuantVars :: [Var] -> [Var]
castBottomExpr :: CoreExpr -> Type -> CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the a <tt>Word</tt>
--   with the given value
mkWordExpr :: DynFlags -> Integer -> CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the given
--   <tt>Word</tt>
mkWordExprWord :: DynFlags -> Word -> CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the given <tt>Int</tt>
mkIntExpr :: DynFlags -> Integer -> CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the given <tt>Int</tt>
mkIntExprInt :: DynFlags -> Int -> CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the given
--   <tt>Integer</tt>
mkIntegerExpr :: MonadThings m => Integer -> m CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the given
--   <tt>Float</tt>
mkFloatExpr :: Float -> CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the given
--   <tt>Double</tt>
mkDoubleExpr :: Double -> CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the given
--   <tt>Char</tt>
mkCharExpr :: Char -> CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to the given
--   <tt>String</tt>
mkStringExpr :: MonadThings m => String -> m CoreExpr

-- | Create a <a>CoreExpr</a> which will evaluate to a string morally
--   equivalent to the given <tt>FastString</tt>
mkStringExprFS :: MonadThings m => FastString -> m CoreExpr
data FloatBind
[FloatLet] :: CoreBind -> FloatBind
[FloatCase] :: CoreExpr -> Id -> AltCon -> [Var] -> FloatBind
wrapFloat :: FloatBind -> CoreExpr -> CoreExpr
mkEqBox :: Coercion -> CoreExpr

-- | Lifts a "small" constructor into a "big" constructor by recursive
--   decompositon
mkChunkified :: ([a] -> a) -> [a] -> a

-- | Build a small tuple holding the specified variables
mkCoreVarTup :: [Id] -> CoreExpr

-- | Bulid the type of a small tuple that holds the specified variables
mkCoreVarTupTy :: [Id] -> Type

-- | Build a small tuple holding the specified expressions
mkCoreTup :: [CoreExpr] -> CoreExpr

-- | Build a big tuple holding the specified variables
mkBigCoreVarTup :: [Id] -> CoreExpr

-- | Build the type of a big tuple that holds the specified variables
mkBigCoreVarTupTy :: [Id] -> Type

-- | Build a big tuple holding the specified expressions
mkBigCoreTup :: [CoreExpr] -> CoreExpr

-- | Build the type of a big tuple that holds the specified type of thing
mkBigCoreTupTy :: [Type] -> Type

-- | Like <a>mkTupleSelector</a> but for tuples that are guaranteed never
--   to be "big".
--   
--   <pre>
--   mkSmallTupleSelector [x] x v e = [| e |]
--   mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -&gt; x } |]
--   </pre>
mkSmallTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

-- | As <a>mkTupleCase</a>, but for a tuple that is small enough to be
--   guaranteed not to need nesting.
mkSmallTupleCase :: [Id] -> CoreExpr -> Id -> CoreExpr -> CoreExpr

-- | Builds a selector which scrutises the given expression and extracts
--   the one name from the list given. If you want the no-shadowing rule to
--   apply, the caller is responsible for making sure that none of these
--   names are in scope.
--   
--   If there is just one <a>Id</a> in the tuple, then the selector is just
--   the identity.
--   
--   If necessary, we pattern match on a "big" tuple.
mkTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

-- | A generalization of <a>mkTupleSelector</a>, allowing the body of the
--   case to be an arbitrary expression.
--   
--   To avoid shadowing, we use uniques to invent new variables.
--   
--   If necessary we pattern match on a "big" tuple.
mkTupleCase :: UniqSupply -> [Id] -> CoreExpr -> Id -> CoreExpr -> CoreExpr

-- | Makes a list <tt>[]</tt> for lists of the specified type
mkNilExpr :: Type -> CoreExpr

-- | Makes a list <tt>(:)</tt> for lists of the specified type
mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr

-- | Make a list containing the given expressions, where the list has the
--   given type
mkListExpr :: Type -> [CoreExpr] -> CoreExpr

-- | Make a fully applied <a>foldr</a> expression
mkFoldrExpr :: MonadThings m => Type -> Type -> CoreExpr -> CoreExpr -> CoreExpr -> m CoreExpr

-- | Make a <tt>build</tt> expression applied to a locally-bound worker
--   function
mkBuildExpr :: (MonadThings m, MonadUnique m) => Type -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -> m CoreExpr
mkRuntimeErrorApp :: Id -> Type -> String -> CoreExpr
mkImpossibleExpr :: Type -> CoreExpr
errorIds :: [Id]
rEC_CON_ERROR_ID :: Id
iRREFUT_PAT_ERROR_ID :: Id
rUNTIME_ERROR_ID :: Id
nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id
nO_METHOD_BINDING_ERROR_ID :: Id
pAT_ERROR_ID :: Id
eRROR_ID :: Id
rEC_SEL_ERROR_ID :: Id
aBSENT_ERROR_ID :: Id
uNDEFINED_ID :: Id
undefinedName :: Name
instance Outputable FloatBind

module PrelRules
primOpRules :: Name -> PrimOp -> Maybe CoreRule
builtinRules :: [CoreRule]
instance Functor RuleM
instance Applicative RuleM
instance Monad RuleM
instance Alternative RuleM
instance MonadPlus RuleM
instance HasDynFlags RuleM

module MkId
mkDictFunId :: Name -> [TyVar] -> ThetaType -> Class -> [Type] -> Id
mkDictFunTy :: [TyVar] -> ThetaType -> Class -> [Type] -> (Int, Type)
mkDictSelId :: Name -> Class -> Id
mkDictSelRhs :: Class -> Int -> CoreExpr
mkPrimOpId :: PrimOp -> Id
mkFCallId :: DynFlags -> Unique -> ForeignCall -> Type -> Id
wrapNewTypeBody :: TyCon -> [Type] -> CoreExpr -> CoreExpr
unwrapNewTypeBody :: TyCon -> [Type] -> CoreExpr -> CoreExpr
wrapFamInstBody :: TyCon -> [Type] -> CoreExpr -> CoreExpr
unwrapFamInstScrut :: TyCon -> [Type] -> CoreExpr -> CoreExpr
wrapTypeFamInstBody :: CoAxiom br -> Int -> [Type] -> CoreExpr -> CoreExpr
wrapTypeUnbranchedFamInstBody :: CoAxiom Unbranched -> [Type] -> CoreExpr -> CoreExpr
unwrapTypeFamInstScrut :: CoAxiom br -> Int -> [Type] -> CoreExpr -> CoreExpr
unwrapTypeUnbranchedFamInstScrut :: CoAxiom Unbranched -> [Type] -> CoreExpr -> CoreExpr
newtype DataConBoxer
[DCB] :: ([Type] -> [Var] -> UniqSM ([Var], [CoreBind])) -> DataConBoxer
mkDataConRep :: DynFlags -> FamInstEnvs -> Name -> DataCon -> UniqSM DataConRep
mkDataConWorkId :: Name -> DataCon -> Id
wiredInIds :: [Id]
ghcPrimIds :: [Id]
unsafeCoerceName :: Name
unsafeCoerceId :: Id
realWorldPrimId :: Id
voidPrimId :: Id
voidArgId :: Id
nullAddrId :: Id
seqId :: Id
lazyId :: Id
lazyIdKey :: Unique
coercionTokenId :: Id
magicDictId :: Id
coerceId :: Id
proxyHashId :: Id

module CoreToStg
coreToStg :: DynFlags -> Module -> CoreProgram -> IO [StgBinding]
coreExprToStg :: CoreExpr -> StgExpr
instance Functor LneM
instance Applicative LneM
instance Monad LneM
instance MonadFix LneM

module UnariseStg
unarise :: UniqSupply -> [StgBinding] -> [StgBinding]

module SimplStg
stg2stg :: DynFlags -> Module -> [StgBinding] -> IO ([StgBinding], CollectedCCs)

module FloatIn
floatInwards :: DynFlags -> CoreProgram -> CoreProgram

module WwLib
mkWwBodies :: DynFlags -> FamInstEnvs -> Type -> [Demand] -> DmdResult -> [OneShotInfo] -> UniqSM (Maybe ([Demand], Id -> CoreExpr, CoreExpr -> CoreExpr))
mkWWstr :: DynFlags -> FamInstEnvs -> [Var] -> UniqSM (Bool, [Var], CoreExpr -> CoreExpr, CoreExpr -> CoreExpr)
mkWorkerArgs :: DynFlags -> [Var] -> OneShotInfo -> Type -> ([Var], [Var])
deepSplitProductType_maybe :: FamInstEnvs -> Type -> Maybe (DataCon, [Type], [Type], Coercion)
findTypeShape :: FamInstEnvs -> Type -> TypeShape

module DmdAnal
dmdAnalProgram :: DynFlags -> FamInstEnvs -> CoreProgram -> IO CoreProgram
instance Outputable AnalEnv

module WorkWrap
wwTopBinds :: DynFlags -> FamInstEnvs -> UniqSupply -> CoreProgram -> CoreProgram

module CmmPipeline

-- | Top level driver for C-- pipeline
cmmPipeline :: HscEnv -> TopSRT -> CmmGroup -> IO (TopSRT, CmmGroup)

module StgCmmHpc
initHpc :: Module -> HpcInfo -> FCode ()
mkTickBox :: DynFlags -> Module -> Int -> CmmAGraph

module PrelInfo
wiredInIds :: [Id]
ghcPrimIds :: [Id]
primOpRules :: Name -> PrimOp -> Maybe CoreRule
builtinRules :: [CoreRule]
ghcPrimExports :: [IfaceExport]
wiredInThings :: [TyThing]
basicKnownKeyNames :: [Name]
primOpId :: PrimOp -> Id
maybeCharLikeCon :: DataCon -> Bool
maybeIntLikeCon :: DataCon -> Bool
isNumericClass :: Class -> Bool
isStandardClass :: Class -> Bool

module StgCmmCon
cgTopRhsCon :: DynFlags -> Id -> DataCon -> [StgArg] -> (CgIdInfo, FCode ())
buildDynCon :: Id -> Bool -> CostCentreStack -> DataCon -> [StgArg] -> FCode (CgIdInfo, FCode CmmAGraph)
bindConArgs :: AltCon -> LocalReg -> [Id] -> FCode [LocalReg]

module StgCmmExpr
cgExpr :: StgExpr -> FCode ReturnKind

module StgCmmBind
cgTopRhsClosure :: DynFlags -> RecFlag -> Id -> CostCentreStack -> StgBinderInfo -> UpdateFlag -> [Id] -> StgExpr -> (CgIdInfo, FCode ())
cgBind :: StgBinding -> FCode ()
emitBlackHoleCode :: CmmExpr -> FCode ()
pushUpdateFrame :: CLabel -> CmmExpr -> FCode () -> FCode ()
emitUpdateFrame :: DynFlags -> CmmExpr -> CLabel -> CmmExpr -> FCode ()

module CmmParse
parseCmmFile :: DynFlags -> FilePath -> IO (Messages, Maybe CmmGroup)

module StgCmm
codeGen :: DynFlags -> Module -> [TyCon] -> CollectedCCs -> [StgBinding] -> HpcInfo -> Stream IO CmmGroup ()

module TcRnMonad

-- | Setup the initial typechecking environment
initTc :: HscEnv -> HscSource -> Bool -> Module -> TcM r -> IO (Messages, Maybe r)
initTcInteractive :: HscEnv -> TcM a -> IO (Messages, Maybe a)
initTcForLookup :: HscEnv -> TcM a -> IO a
initTcRnIf :: Char -> HscEnv -> gbl -> lcl -> TcRnIf gbl lcl a -> IO a
discardResult :: TcM a -> TcM ()
getTopEnv :: TcRnIf gbl lcl HscEnv
getGblEnv :: TcRnIf gbl lcl gbl
updGblEnv :: (gbl -> gbl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
setGblEnv :: gbl -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
getLclEnv :: TcRnIf gbl lcl lcl
updLclEnv :: (lcl -> lcl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
setLclEnv :: lcl' -> TcRnIf gbl lcl' a -> TcRnIf gbl lcl a
getEnvs :: TcRnIf gbl lcl (gbl, lcl)
setEnvs :: (gbl', lcl') -> TcRnIf gbl' lcl' a -> TcRnIf gbl lcl a
xoptM :: ExtensionFlag -> TcRnIf gbl lcl Bool
doptM :: DumpFlag -> TcRnIf gbl lcl Bool
goptM :: GeneralFlag -> TcRnIf gbl lcl Bool
woptM :: WarningFlag -> TcRnIf gbl lcl Bool
setXOptM :: ExtensionFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
unsetGOptM :: GeneralFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
unsetWOptM :: WarningFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

-- | Do it flag is true
whenDOptM :: DumpFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
whenGOptM :: GeneralFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
whenWOptM :: WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
whenXOptM :: ExtensionFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
getGhcMode :: TcRnIf gbl lcl GhcMode
withDoDynamicToo :: TcRnIf gbl lcl a -> TcRnIf gbl lcl a
getEpsVar :: TcRnIf gbl lcl (TcRef ExternalPackageState)
getEps :: TcRnIf gbl lcl ExternalPackageState

-- | Update the external package state. Returns the second result of the
--   modifier function.
--   
--   This is an atomic operation and forces evaluation of the modified EPS
--   in order to avoid space leaks.
updateEps :: (ExternalPackageState -> (ExternalPackageState, a)) -> TcRnIf gbl lcl a

-- | Update the external package state.
--   
--   This is an atomic operation and forces evaluation of the modified EPS
--   in order to avoid space leaks.
updateEps_ :: (ExternalPackageState -> ExternalPackageState) -> TcRnIf gbl lcl ()
getHpt :: TcRnIf gbl lcl HomePackageTable
getEpsAndHpt :: TcRnIf gbl lcl (ExternalPackageState, HomePackageTable)
newArrowScope :: TcM a -> TcM a
escapeArrowScope :: TcM a -> TcM a
newUnique :: TcRnIf gbl lcl Unique
newUniqueSupply :: TcRnIf gbl lcl UniqSupply
newLocalName :: Name -> TcM Name
newName :: OccName -> TcM Name
newSysName :: OccName -> TcM Name
newSysLocalId :: FastString -> TcType -> TcRnIf gbl lcl TcId
newSysLocalIds :: FastString -> [TcType] -> TcRnIf gbl lcl [TcId]
newTcRef :: a -> TcRnIf gbl lcl (TcRef a)
readTcRef :: TcRef a -> TcRnIf gbl lcl a
writeTcRef :: TcRef a -> a -> TcRnIf gbl lcl ()
updTcRef :: TcRef a -> (a -> a) -> TcRnIf gbl lcl ()
updTcRefX :: TcRef a -> (a -> a) -> TcRnIf gbl lcl a
traceTc :: String -> SDoc -> TcRn ()

-- | Typechecker trace
traceTcN :: Int -> SDoc -> TcRn ()
traceRn :: SDoc -> TcRn ()

-- | Output a doc if the given <a>DumpFlag</a> is set.
--   
--   By default this logs to stdout However, if the `-ddump-to-file` flag
--   is set, then this will dump output to a file
--   
--   Just a wrapper for <a>dumpSDoc</a>
traceOptTcRn :: DumpFlag -> SDoc -> TcRn ()

-- | Unconditionally dump some trace output
--   
--   The DumpFlag is used only to set the output filename for
--   --dump-to-file, not to decide whether or not to output That part is
--   done by the caller
traceTcRn :: DumpFlag -> SDoc -> TcRn ()
getPrintUnqualified :: DynFlags -> TcRn PrintUnqualified

-- | Like logInfoTcRn, but for user consumption
printForUserTcRn :: SDoc -> TcRn ()

-- | Typechecker debug
debugDumpTcRn :: SDoc -> TcRn ()
traceIf :: SDoc -> TcRnIf m n ()
traceHiDiffs :: SDoc -> TcRnIf m n ()
traceOptIf :: DumpFlag -> SDoc -> TcRnIf m n ()
setModule :: Module -> TcRn a -> TcRn a
getIsGHCi :: TcRn Bool
getGHCiMonad :: TcRn Name
getInteractivePrintName :: TcRn Name
tcIsHsBootOrSig :: TcRn Bool
getGlobalRdrEnv :: TcRn GlobalRdrEnv
getRdrEnvs :: TcRn (GlobalRdrEnv, LocalRdrEnv)
getImports :: TcRn ImportAvails
getFixityEnv :: TcRn FixityEnv
extendFixityEnv :: [(Name, FixItem)] -> RnM a -> RnM a
getRecFieldEnv :: TcRn RecFieldEnv
getDeclaredDefaultTys :: TcRn (Maybe [Type])
addDependentFiles :: [FilePath] -> TcRn ()
getSrcSpanM :: TcRn SrcSpan
setSrcSpan :: SrcSpan -> TcRn a -> TcRn a
addLocM :: (a -> TcM b) -> Located a -> TcM b
wrapLocM :: (a -> TcM b) -> Located a -> TcM (Located b)
wrapLocFstM :: (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)
wrapLocSndM :: (a -> TcM (b, c)) -> Located a -> TcM (b, Located c)
getErrsVar :: TcRn (TcRef Messages)
setErrsVar :: TcRef Messages -> TcRn a -> TcRn a
addErr :: MsgDoc -> TcRn ()
failWith :: MsgDoc -> TcRn a
addErrAt :: SrcSpan -> MsgDoc -> TcRn ()
addErrs :: [(SrcSpan, MsgDoc)] -> TcRn ()
checkErr :: Bool -> MsgDoc -> TcRn ()
warnIf :: Bool -> MsgDoc -> TcRn ()
addMessages :: Messages -> TcRn ()
discardWarnings :: TcRn a -> TcRn a
mkLongErrAt :: SrcSpan -> MsgDoc -> MsgDoc -> TcRn ErrMsg
addLongErrAt :: SrcSpan -> MsgDoc -> MsgDoc -> TcRn ()
reportErrors :: [ErrMsg] -> TcM ()
reportError :: ErrMsg -> TcRn ()
reportWarning :: ErrMsg -> TcRn ()
try_m :: TcRn r -> TcRn (Either IOEnvFailure r)
recoverM :: TcRn r -> TcRn r -> TcRn r
mapAndRecoverM :: (a -> TcRn b) -> [a] -> TcRn [b]

-- | Succeeds if applying the argument to all members of the lists
--   succeeds, but nevertheless runs it on all arguments, to collect all
--   errors.
mapAndReportM :: (a -> TcRn b) -> [a] -> TcRn [b]
tryTc :: TcRn a -> TcRn (Messages, Maybe a)
tryTcErrs :: TcRn a -> TcRn (Messages, Maybe a)
tryTcLIE :: TcM a -> TcM (Messages, Maybe a)
tryTcLIE_ :: TcM r -> TcM r -> TcM r
checkNoErrs :: TcM r -> TcM r
whenNoErrs :: TcM () -> TcM ()
ifErrsM :: TcRn r -> TcRn r -> TcRn r
failIfErrsM :: TcRn ()
checkTH :: Outputable a => a -> String -> TcRn ()
failTH :: Outputable a => a -> String -> TcRn x
getErrCtxt :: TcM [ErrCtxt]
setErrCtxt :: [ErrCtxt] -> TcM a -> TcM a
addErrCtxt :: MsgDoc -> TcM a -> TcM a
addErrCtxtM :: (TidyEnv -> TcM (TidyEnv, MsgDoc)) -> TcM a -> TcM a
addLandmarkErrCtxt :: MsgDoc -> TcM a -> TcM a
updCtxt :: ([ErrCtxt] -> [ErrCtxt]) -> TcM a -> TcM a
popErrCtxt :: TcM a -> TcM a
getCtLoc :: CtOrigin -> TcM CtLoc
setCtLoc :: CtLoc -> TcM a -> TcM a
addErrTc :: MsgDoc -> TcM ()
addErrsTc :: [MsgDoc] -> TcM ()
addErrTcM :: (TidyEnv, MsgDoc) -> TcM ()
mkErrTcM :: (TidyEnv, MsgDoc) -> TcM ErrMsg
failWithTc :: MsgDoc -> TcM a
failWithTcM :: (TidyEnv, MsgDoc) -> TcM a
checkTc :: Bool -> MsgDoc -> TcM ()
warnTc :: Bool -> MsgDoc -> TcM ()
addWarnTc :: MsgDoc -> TcM ()
addWarnTcM :: (TidyEnv, MsgDoc) -> TcM ()
addWarn :: MsgDoc -> TcRn ()
addWarnAt :: SrcSpan -> MsgDoc -> TcRn ()
add_warn :: MsgDoc -> MsgDoc -> TcRn ()
add_warn_at :: SrcSpan -> MsgDoc -> MsgDoc -> TcRn ()
tcInitTidyEnv :: TcM TidyEnv
add_err_tcm :: TidyEnv -> MsgDoc -> SrcSpan -> [ErrCtxt] -> TcM ()
mkErrInfo :: TidyEnv -> [ErrCtxt] -> TcM SDoc
mAX_CONTEXTS :: Int
debugTc :: TcM () -> TcM ()
newTcEvBinds :: TcM EvBindsVar
addTcEvBind :: EvBindsVar -> EvVar -> EvTerm -> TcM ()
getTcEvBinds :: EvBindsVar -> TcM (Bag EvBind)
chooseUniqueOccTc :: (OccSet -> OccName) -> TcM OccName
getConstraintVar :: TcM (TcRef WantedConstraints)
setConstraintVar :: TcRef WantedConstraints -> TcM a -> TcM a
emitConstraints :: WantedConstraints -> TcM ()
emitSimple :: Ct -> TcM ()
emitSimples :: Cts -> TcM ()
emitImplication :: Implication -> TcM ()
emitImplications :: Bag Implication -> TcM ()
emitInsoluble :: Ct -> TcM ()
captureConstraints :: TcM a -> TcM (a, WantedConstraints)
captureTcLevel :: TcM a -> TcM (a, TcLevel)
pushTcLevelM :: TcM a -> TcM a
getTcLevel :: TcM TcLevel
setTcLevel :: TcLevel -> TcM a -> TcM a
isTouchableTcM :: TcTyVar -> TcM Bool
getLclTypeEnv :: TcM TcTypeEnv
setLclTypeEnv :: TcLclEnv -> TcM a -> TcM a
traceTcConstraints :: String -> TcM ()
emitWildcardHoleConstraints :: [(Name, TcTyVar)] -> TcM ()
recordThUse :: TcM ()
recordThSpliceUse :: TcM ()
keepAlive :: Name -> TcRn ()
getStage :: TcM ThStage
getStageAndBindLevel :: Name -> TcRn (Maybe (TopLevelFlag, ThLevel, ThStage))
setStage :: ThStage -> TcM a -> TcRn a

-- | Mark that safe inference has failed
recordUnsafeInfer :: TcM ()

-- | Figure out the final correct safe haskell mode
finalSafeMode :: DynFlags -> TcGblEnv -> IO SafeHaskellMode
getLocalRdrEnv :: RnM LocalRdrEnv
setLocalRdrEnv :: LocalRdrEnv -> RnM a -> RnM a
mkIfLclEnv :: Module -> SDoc -> IfLclEnv

-- | Run an <a>IfG</a> (top-level interface monad) computation inside an
--   existing <a>TcRn</a> (typecheck-renaming monad) computation by
--   initializing an <a>IfGblEnv</a> based on <a>TcGblEnv</a>.
initIfaceTcRn :: IfG a -> TcRn a
initIfaceCheck :: HscEnv -> IfG a -> IO a
initIfaceTc :: ModIface -> (TcRef TypeEnv -> IfL a) -> TcRnIf gbl lcl a
initIfaceLcl :: Module -> SDoc -> IfL a -> IfM lcl a
getIfModule :: IfL Module
failIfM :: MsgDoc -> IfL a
forkM_maybe :: SDoc -> IfL a -> IfL (Maybe a)
forkM :: SDoc -> IfL a -> IfL a
instance MonadUnique (IOEnv (Env gbl lcl))

module TcMType
type TcTyVar = TyVar
type TcKind = Kind
type TcType = Type
type TcTauType = TcType
type TcThetaType = ThetaType
type TcTyVarSet = TyVarSet
newFlexiTyVar :: Kind -> TcM TcTyVar
newFlexiTyVarTy :: Kind -> TcM TcType
newFlexiTyVarTys :: Int -> Kind -> TcM [TcType]
newReturnTyVar :: Kind -> TcM TcTyVar
newReturnTyVarTy :: Kind -> TcM TcType
newMetaKindVar :: TcM TcKind
newMetaKindVars :: Int -> TcM [TcKind]
mkTcTyVarName :: Unique -> FastString -> Name
cloneMetaTyVar :: TcTyVar -> TcM TcTyVar
newMetaTyVar :: MetaInfo -> Kind -> TcM TcTyVar
readMetaTyVar :: TyVar -> TcM MetaDetails
writeMetaTyVar :: TcTyVar -> TcType -> TcM ()
writeMetaTyVarRef :: TcTyVar -> TcRef MetaDetails -> TcType -> TcM ()
newMetaDetails :: MetaInfo -> TcM TcTyVarDetails
isFilledMetaTyVar :: TyVar -> TcM Bool
isUnfilledMetaTyVar :: TyVar -> TcM Bool
newEvVar :: TcPredType -> TcM EvVar
newEvVars :: TcThetaType -> TcM [EvVar]
newEq :: TcType -> TcType -> TcM EvVar
newDict :: Class -> [TcType] -> TcM DictId
newTcEvBinds :: TcM EvBindsVar
addTcEvBind :: EvBindsVar -> EvVar -> EvTerm -> TcM ()
newSimpleWanted :: CtOrigin -> PredType -> TcM Ct
newSimpleWanteds :: CtOrigin -> ThetaType -> TcM [Ct]
tcInstTyVars :: [TKVar] -> TcM (TvSubst, [TcTyVar])
newSigTyVar :: Name -> Kind -> TcM TcTyVar
tcInstType :: ([TyVar] -> TcM (TvSubst, [TcTyVar])) -> TcType -> TcM ([TcTyVar], TcThetaType, TcType)
tcInstSkolTyVars :: [TyVar] -> TcM (TvSubst, [TcTyVar])
tcInstSuperSkolTyVarsX :: TvSubst -> [TyVar] -> TcM (TvSubst, [TcTyVar])
tcInstSigTyVarsLoc :: SrcSpan -> [TyVar] -> TcRnIf gbl lcl (TvSubst, [TcTyVar])
tcInstSigTyVars :: [TyVar] -> TcRnIf gbl lcl (TvSubst, [TcTyVar])
tcInstSkolType :: TcType -> TcM ([TcTyVar], TcThetaType, TcType)
tcSkolDFunType :: Type -> TcM ([TcTyVar], TcThetaType, TcType)
tcSuperSkolTyVars :: [TyVar] -> (TvSubst, [TcTyVar])
instSkolTyVars :: (Unique -> Name -> Kind -> TyVar) -> [TyVar] -> TcRnIf gbl lcl (TvSubst, [TyVar])

-- | Give fresh uniques to a bunch of TyVars, but they stay as TyVars,
--   rather than becoming TcTyVars Used in FamInst.newFamInst, and
--   Inst.newClsInst
freshenTyVarBndrs :: [TyVar] -> TcRnIf gbl lcl (TvSubst, [TyVar])
zonkTcPredType :: TcPredType -> TcM TcPredType
zonkTidyTcType :: TidyEnv -> TcType -> TcM (TidyEnv, TcType)
zonkTidyOrigin :: TidyEnv -> CtOrigin -> TcM (TidyEnv, CtOrigin)
tidyEvVar :: TidyEnv -> EvVar -> EvVar
tidyCt :: TidyEnv -> Ct -> Ct
tidySkolemInfo :: TidyEnv -> SkolemInfo -> (TidyEnv, SkolemInfo)
skolemiseUnboundMetaTyVar :: TcTyVar -> TcTyVarDetails -> TcM TyVar
zonkTcTyVar :: TcTyVar -> TcM TcType
zonkTcTyVars :: [TcTyVar] -> TcM [TcType]
zonkTyVarsAndFV :: TyVarSet -> TcM TyVarSet
zonkTcTypeAndFV :: TcType -> TcM TyVarSet
zonkQuantifiedTyVar :: TcTyVar -> TcM TcTyVar
quantifyTyVars :: TcTyVarSet -> TcTyVarSet -> TcM [TcTyVar]
zonkTcTyVarBndr :: TcTyVar -> TcM TcTyVar
zonkTcType :: TcType -> TcM TcType
zonkTcTypes :: [TcType] -> TcM [TcType]
zonkTcThetaType :: TcThetaType -> TcM TcThetaType
zonkTcKind :: TcKind -> TcM TcKind
defaultKindVarToStar :: TcTyVar -> TcM Kind
zonkEvVar :: EvVar -> TcM EvVar
zonkWC :: WantedConstraints -> TcM WantedConstraints
zonkSimples :: Cts -> TcM Cts
zonkId :: TcId -> TcM TcId
zonkCt :: Ct -> TcM Ct
zonkSkolemInfo :: SkolemInfo -> TcM SkolemInfo
tcGetGlobalTyVars :: TcM TcTyVarSet

-- | Create a new meta var with the given kind. This meta var should be
--   used to replace a wildcard in a type. Such a wildcard meta var can be
--   distinguished from other meta vars with the <a>isWildcardVar</a>
--   function.
newWildcardVar :: Name -> Kind -> TcM TcTyVar

-- | Create a new meta var (which can unify with a type of any kind). This
--   meta var should be used to replace a wildcard in a type. Such a
--   wildcard meta var can be distinguished from other meta vars with the
--   <a>isWildcardVar</a> function.
newWildcardVarMetaKind :: Name -> TcM TcTyVar

module TcHsSyn
mkHsConApp :: DataCon -> [Type] -> [HsExpr Id] -> LHsExpr Id
mkHsDictLet :: TcEvBinds -> LHsExpr Id -> LHsExpr Id
mkHsApp :: LHsExpr name -> LHsExpr name -> LHsExpr name
hsLitType :: HsLit -> TcType
hsLPatType :: OutPat Id -> Type
hsPatType :: Pat Id -> Type
mkHsAppTy :: LHsType name -> LHsType name -> LHsType name
mkSimpleHsAlt :: LPat id -> (Located (body id)) -> LMatch id (Located (body id))
nlHsIntLit :: Integer -> LHsExpr id
shortCutLit :: DynFlags -> OverLitVal -> TcType -> Maybe (HsExpr TcId)
hsOverLitName :: OverLitVal -> Name
conLikeResTy :: ConLike -> [Type] -> Type
type TcId = Id
type TcIdSet = IdSet
zonkTopDecls :: Bag EvBind -> LHsBinds TcId -> Bag OccName -> NameSet -> [LRuleDecl TcId] -> [LVectDecl TcId] -> [LTcSpecPrag] -> [LForeignDecl TcId] -> TcM ([Id], Bag EvBind, LHsBinds Id, [LForeignDecl Id], [LTcSpecPrag], [LRuleDecl Id], [LVectDecl Id])
zonkTopExpr :: HsExpr TcId -> TcM (HsExpr Id)
zonkTopLExpr :: LHsExpr TcId -> TcM (LHsExpr Id)
zonkTopBndrs :: [TcId] -> TcM [Id]
zonkTyBndrsX :: ZonkEnv -> [TyVar] -> TcM (ZonkEnv, [TyVar])
emptyZonkEnv :: ZonkEnv
mkEmptyZonkEnv :: UnboundTyVarZonker -> ZonkEnv
mkTyVarZonkEnv :: [TyVar] -> ZonkEnv
zonkTcTypeToType :: ZonkEnv -> TcType -> TcM Type
zonkTcTypeToTypes :: ZonkEnv -> [TcType] -> TcM [Type]
zonkTyVarOcc :: ZonkEnv -> TyVar -> TcM TcType
instance Outputable ZonkEnv

module TcAnnotations
tcAnnotations :: [LAnnDecl Name] -> TcM [Annotation]
annCtxt :: OutputableBndr id => AnnDecl id -> SDoc

module Coverage
addTicksToBinds :: DynFlags -> Module -> ModLocation -> NameSet -> [TyCon] -> LHsBinds Id -> IO (LHsBinds Id, HpcInfo, ModBreaks)
hpcInitCode :: Module -> HpcInfo -> SDoc
instance Eq TickishType
instance Eq TickDensity
instance Functor TM
instance Applicative TM
instance Monad TM
instance HasDynFlags TM
instance MonadUnique TM

module Finder
flushFinderCaches :: HscEnv -> IO ()

-- | The result of searching for an imported module.
data FindResult

-- | The module was found
[Found] :: ModLocation -> Module -> FindResult

-- | The requested package was not found
[NoPackage] :: PackageKey -> FindResult

-- | _Error_: both in multiple packages
[FoundMultiple] :: [(Module, ModuleOrigin)] -> FindResult

-- | Not found
[NotFound] :: [FilePath] -> Maybe PackageKey -> [PackageKey] -> [PackageKey] -> [ModuleSuggestion] -> FindResult
[fr_paths] :: FindResult -> [FilePath]
[fr_pkg] :: FindResult -> Maybe PackageKey
[fr_mods_hidden] :: FindResult -> [PackageKey]
[fr_pkgs_hidden] :: FindResult -> [PackageKey]
[fr_suggestions] :: FindResult -> [ModuleSuggestion]

-- | Locate a module that was imported by the user. We have the module's
--   name, and possibly a package name. Without a package name, this
--   function will use the search path and the known exposed packages to
--   find the module, if a package is specified then only that package is
--   searched for the module.
findImportedModule :: HscEnv -> ModuleName -> Maybe FastString -> IO FindResult

-- | Locate a specific <a>Module</a>. The purpose of this function is to
--   create a <a>ModLocation</a> for a given <a>Module</a>, that is to find
--   out where the files associated with this module live. It is used when
--   reading the interface for a module mentioned by another interface, for
--   example (a "system import").
findExactModule :: HscEnv -> Module -> IO FindResult

-- | Implements the search for a module name in the home package only.
--   Calling this function directly is usually *not* what you want;
--   currently, it's used as a building block for the following operations:
--   
--   <ol>
--   <li>When you do a normal package lookup, we first check if the module
--   is available in the home module, before looking it up in the package
--   database.</li>
--   <li>When you have a package qualified import with package name "this",
--   we shortcut to the home module.</li>
--   <li>When we look up an exact <a>Module</a>, if the package key
--   associated with the module is the current home module do a look up in
--   the home module.</li>
--   <li>Some special-case code in GHCi (ToDo: Figure out why that needs to
--   call this.)</li>
--   </ol>
findHomeModule :: HscEnv -> ModuleName -> IO FindResult
findExposedPackageModule :: HscEnv -> ModuleName -> Maybe FastString -> IO FindResult
mkHomeModLocation :: DynFlags -> ModuleName -> FilePath -> IO ModLocation
mkHomeModLocation2 :: DynFlags -> ModuleName -> FilePath -> String -> IO ModLocation
mkHiOnlyModLocation :: DynFlags -> Suffix -> FilePath -> String -> IO ModLocation
addHomeModuleToFinder :: HscEnv -> ModuleName -> ModLocation -> IO Module
uncacheModule :: HscEnv -> ModuleName -> IO ()
mkStubPaths :: DynFlags -> ModuleName -> ModLocation -> FilePath
findObjectLinkableMaybe :: Module -> ModLocation -> IO (Maybe Linkable)
findObjectLinkable :: Module -> FilePath -> UTCTime -> IO Linkable
cannotFindModule :: DynFlags -> ModuleName -> FindResult -> SDoc
cannotFindInterface :: DynFlags -> ModuleName -> FindResult -> SDoc

module IfaceEnv
newGlobalBinder :: Module -> OccName -> SrcSpan -> TcRnIf a b Name
newImplicitBinder :: Name -> (OccName -> OccName) -> TcRnIf m n Name
lookupIfaceTop :: OccName -> IfL Name
lookupOrig :: Module -> OccName -> TcRnIf a b Name
lookupOrigNameCache :: OrigNameCache -> Module -> OccName -> Maybe Name
extendNameCache :: OrigNameCache -> Module -> OccName -> Name -> OrigNameCache
newIfaceName :: OccName -> IfL Name
newIfaceNames :: [OccName] -> IfL [Name]
extendIfaceIdEnv :: [Id] -> IfL a -> IfL a
extendIfaceTyVarEnv :: [TyVar] -> IfL a -> IfL a
tcIfaceLclId :: FastString -> IfL Id
tcIfaceTyVar :: FastString -> IfL TyVar
lookupIfaceTyVar :: FastString -> IfL (Maybe TyVar)
ifaceExportNames :: [IfaceExport] -> TcRnIf gbl lcl [AvailInfo]
allocateGlobalBinder :: NameCache -> Module -> OccName -> SrcSpan -> (NameCache, Name)
initNameCache :: UniqSupply -> [Name] -> NameCache
updNameCache :: (NameCache -> (NameCache, c)) -> TcRnIf a b c
getNameCache :: TcRnIf a b NameCache

-- | Return a function to atomically update the name cache.
mkNameCacheUpdater :: TcRnIf a b NameCacheUpdater

-- | A function that atomically updates the name cache given a modifier
--   function. The second result of the modifier function will be the
--   result of the IO action.
newtype NameCacheUpdater
[NCU] :: (forall c. (NameCache -> (NameCache, c)) -> IO c) -> NameCacheUpdater
[updateNameCache] :: NameCacheUpdater -> forall c. (NameCache -> (NameCache, c)) -> IO c


-- | Binary interface file support.
module BinIface

-- | Write an interface file
writeBinIface :: DynFlags -> FilePath -> ModIface -> IO ()

-- | Read an interface file
readBinIface :: CheckHiWay -> TraceBinIFaceReading -> FilePath -> TcRnIf a b ModIface
getSymtabName :: NameCacheUpdater -> Dictionary -> SymbolTable -> BinHandle -> IO Name
getDictFastString :: Dictionary -> BinHandle -> IO FastString
data CheckHiWay
[CheckHiWay] :: CheckHiWay
[IgnoreHiWay] :: CheckHiWay
data TraceBinIFaceReading
[TraceBinIFaceReading] :: TraceBinIFaceReading
[QuietBinIFaceReading] :: TraceBinIFaceReading
instance Eq TraceBinIFaceReading
instance Eq CheckHiWay

module BuildTyCl
buildSynonymTyCon :: Name -> [TyVar] -> [Role] -> Type -> Kind -> TcRnIf m n TyCon
buildFamilyTyCon :: Name -> [TyVar] -> FamTyConFlav -> Kind -> TyConParent -> TcRnIf m n TyCon
buildAlgTyCon :: Name -> [TyVar] -> [Role] -> Maybe CType -> ThetaType -> AlgTyConRhs -> RecFlag -> Bool -> Bool -> TyConParent -> TyCon
buildDataCon :: FamInstEnvs -> Name -> Bool -> [HsBang] -> [Name] -> [TyVar] -> [TyVar] -> [(TyVar, Type)] -> ThetaType -> [Type] -> Type -> TyCon -> TcRnIf m n DataCon
buildPatSyn :: Name -> Bool -> (Id, Bool) -> Maybe (Id, Bool) -> ([TyVar], ThetaType) -> ([TyVar], ThetaType) -> [Type] -> Type -> PatSyn
type TcMethInfo = (Name, DefMethSpec, Type)
buildClass :: Name -> [TyVar] -> [Role] -> ThetaType -> [FunDep TyVar] -> [ClassATItem] -> [TcMethInfo] -> ClassMinimalDef -> RecFlag -> TcRnIf m n Class
distinctAbstractTyConRhs :: AlgTyConRhs
totallyAbstractTyConRhs :: AlgTyConRhs

-- | Monadic because it makes a Name for the coercion TyCon We pass the
--   Name of the parent TyCon, as well as the TyCon itself, because the
--   latter is part of a knot, whereas the former is not.
mkNewTyConRhs :: Name -> TyCon -> DataCon -> TcRnIf m n AlgTyConRhs
mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
newImplicitBinder :: Name -> (OccName -> OccName) -> TcRnIf m n Name

module DebuggerUtils

-- | Given a data constructor in the heap, find its Name. The info tables
--   for data constructors have a field which records the source name of
--   the constructor as a Ptr Word8 (UTF-8 encoded string). The format is:
--   
--   <pre>
--   Package:Module.Name
--   </pre>
--   
--   We use this string to lookup the interpreter's internal representation
--   of the name using the lookupOrig.
dataConInfoPtrToName :: Ptr () -> TcM (Either String Name)


-- | This module manages storing the various GHC option flags in a modules
--   interface file as part of the recompilation checking infrastructure.
module FlagChecker

-- | Produce a fingerprint of a <tt>DynFlags</tt> value. We only base the
--   finger print on important fields in <tt>DynFlags</tt> so that the
--   recompilation checker can use this fingerprint.
fingerprintDynFlags :: DynFlags -> Module -> (BinHandle -> Name -> IO ()) -> IO Fingerprint

module CodeOutput
codeOutput :: DynFlags -> Module -> FilePath -> ModLocation -> ForeignStubs -> [PackageKey] -> Stream IO RawCmmGroup () -> IO (FilePath, (Bool, Maybe FilePath))
outputForeignStubs :: DynFlags -> Module -> ModLocation -> ForeignStubs -> IO (Bool, Maybe FilePath)


-- | ByteCodeGen: Generate bytecode from Core
module ByteCodeGen
data UnlinkedBCO
byteCodeGen :: DynFlags -> Module -> CoreProgram -> [TyCon] -> ModBreaks -> IO CompiledByteCode
coreExprToBCOs :: DynFlags -> Module -> CoreExpr -> IO UnlinkedBCO
instance Ord Discr
instance Eq Discr
instance Outputable Discr
instance Functor BcM
instance Applicative BcM
instance Monad BcM
instance HasDynFlags BcM

module TcTyDecls
calcRecFlags :: ModDetails -> Bool -> RoleAnnots -> [TyThing] -> RecTyInfo
data RecTyInfo
[RTI] :: Bool -> (Name -> [Role]) -> (Name -> RecFlag) -> RecTyInfo
[rti_promotable] :: RecTyInfo -> Bool
[rti_roles] :: RecTyInfo -> Name -> [Role]
[rti_is_rec] :: RecTyInfo -> Name -> RecFlag
calcSynCycles :: [LTyClDecl Name] -> [SCC (LTyClDecl Name)]
calcClassCycles :: Class -> [[TyCon]]
type RoleAnnots = NameEnv (LRoleAnnotDecl Name)
extractRoleAnnots :: TyClGroup Name -> RoleAnnots
emptyRoleAnnots :: RoleAnnots
lookupRoleAnnots :: RoleAnnots -> Name -> Maybe (LRoleAnnotDecl Name)
instance Functor RoleM
instance Applicative RoleM
instance Monad RoleM

module Vectorise.Env

-- | Indicates what scope something (a variable) is in.
data Scope a b
[Global] :: a -> Scope a b
[Local] :: b -> Scope a b

-- | The local environment.
data LocalEnv
[LocalEnv] :: VarEnv (Var, Var) -> [TyVar] -> VarEnv CoreExpr -> FastString -> LocalEnv

-- | Mapping from local variables to their vectorised and lifted versions.
[local_vars] :: LocalEnv -> VarEnv (Var, Var)

-- | In-scope type variables.
[local_tyvars] :: LocalEnv -> [TyVar]

-- | Mapping from tyvars to their PA dictionaries.
[local_tyvar_pa] :: LocalEnv -> VarEnv CoreExpr

-- | Local binding name. This is only used to generate better names for
--   hoisted expressions.
[local_bind_name] :: LocalEnv -> FastString

-- | Create an empty local environment.
emptyLocalEnv :: LocalEnv

-- | The global environment: entities that exist at top-level.
data GlobalEnv
[GlobalEnv] :: Bool -> VarEnv Var -> VarSet -> VarEnv (Maybe (Type, CoreExpr)) -> NameEnv TyCon -> NameSet -> NameEnv DataCon -> NameEnv Var -> NameEnv Var -> InstEnvs -> FamInstEnvs -> [(Var, CoreExpr)] -> GlobalEnv

-- | <a>True</a> implies to avoid vectorisation as far as possible.
[global_vect_avoid] :: GlobalEnv -> Bool

-- | Mapping from global variables to their vectorised versions — aka the
--   /vectorisation map/.
[global_vars] :: GlobalEnv -> VarEnv Var

-- | The domain of <a>global_vars</a>.
--   
--   This information is not redundant as it is impossible to extract the
--   domain from a <a>VarEnv</a> (which is keyed on uniques alone).
--   Moreover, we have mapped variables that do not involve parallelism —
--   e.g., the workers of vectorised, but scalar data types. In addition,
--   workers of parallel data types that we could not vectorise also need
--   to be tracked.
[global_parallel_vars] :: GlobalEnv -> VarSet

-- | Mapping from global variables that have a vectorisation declaration to
--   the right-hand side of that declaration and its type and mapping
--   variables that have NOVECTORISE declarations to <a>Nothing</a>.
[global_vect_decls] :: GlobalEnv -> VarEnv (Maybe (Type, CoreExpr))

-- | Mapping from TyCons to their vectorised versions. The vectorised
--   version will be identical to the original version if it is not changed
--   by vectorisation. In any case, if a tycon appears in the domain of
--   this mapping, it was successfully vectorised.
[global_tycons] :: GlobalEnv -> NameEnv TyCon

-- | Type constructors whose definition directly or indirectly includes a
--   parallel type, such as '[::]'.
--   
--   NB: This information is not redundant as some types have got a mapping
--   in <a>global_tycons</a> (to a type other than themselves) and are
--   still not parallel. An example is '(-&gt;)'. Moreover, some types have
--   *not* got a mapping in <a>global_tycons</a> (because they couldn't be
--   vectorised), but still contain parallel types.
[global_parallel_tycons] :: GlobalEnv -> NameSet

-- | Mapping from DataCons to their vectorised versions.
[global_datacons] :: GlobalEnv -> NameEnv DataCon

-- | Mapping from TyCons to their PA dfuns.
[global_pa_funs] :: GlobalEnv -> NameEnv Var

-- | Mapping from TyCons to their PR dfuns.
[global_pr_funs] :: GlobalEnv -> NameEnv Var

-- | External package inst-env &amp; home-package inst-env for class
--   instances.
[global_inst_env] :: GlobalEnv -> InstEnvs

-- | External package inst-env &amp; home-package inst-env for family
--   instances.
[global_fam_inst_env] :: GlobalEnv -> FamInstEnvs

-- | Hoisted bindings — temporary storage for toplevel bindings during code
--   gen.
[global_bindings] :: GlobalEnv -> [(Var, CoreExpr)]

-- | Create an initial global environment.
--   
--   We add scalar variables and type constructors identified by
--   vectorisation pragmas already here to the global table, so that we can
--   query scalarness during vectorisation, and especially, when
--   vectorising the scalar entities' definitions themselves.
initGlobalEnv :: Bool -> VectInfo -> [CoreVect] -> InstEnvs -> FamInstEnvs -> GlobalEnv

-- | Extend the list of global variables in an environment.
extendImportedVarsEnv :: [(Var, Var)] -> GlobalEnv -> GlobalEnv

-- | Extend the list of type family instances.
extendFamEnv :: [FamInst] -> GlobalEnv -> GlobalEnv

-- | Set the list of PA functions in an environment.
setPAFunsEnv :: [(Name, Var)] -> GlobalEnv -> GlobalEnv

-- | Set the list of PR functions in an environment.
setPRFunsEnv :: [(Name, Var)] -> GlobalEnv -> GlobalEnv

-- | Compute vectorisation information that goes into <a>ModGuts</a> (and
--   is stored in interface files). The incoming <tt>vectInfo</tt> is that
--   from the <a>HscEnv</a> and <a>EPS</a>. The outgoing one contains only
--   the declarations for the currently compiled module; this includes
--   variables, type constructors, and data constructors referenced in
--   VECTORISE pragmas, even if they are defined in an imported module.
--   
--   The variables explicitly include class selectors and dfuns.
modVectInfo :: GlobalEnv -> [Id] -> [TyCon] -> [CoreVect] -> VectInfo -> VectInfo

module LoadIface
tcLookupImported_maybe :: Name -> TcM (MaybeErr MsgDoc TyThing)
importDecl :: Name -> IfM lcl (MaybeErr MsgDoc TyThing)
checkWiredInTyCon :: TyCon -> TcM ()
ifCheckWiredInThing :: TyThing -> IfL ()

-- | Load interface directly for a fully qualified <a>Module</a>. (This is
--   a fairly rare operation, but in particular it is used to load orphan
--   modules in order to pull their instances into the global package table
--   and to handle some operations in GHCi).
loadModuleInterface :: SDoc -> Module -> TcM ModIface

-- | Load interfaces for a collection of modules.
loadModuleInterfaces :: SDoc -> [Module] -> TcM ()

-- | Load the interface corresponding to an <tt>import</tt> directive in
--   source code. On a failure, fail in the monad with an error message.
--   See Note [Un-ambiguous multiple interfaces] for why the return type is
--   <tt>[ModIface]</tt>
loadSrcInterface :: SDoc -> ModuleName -> IsBootInterface -> Maybe FastString -> RnM [ModIface]

-- | Like <a>loadSrcInterface</a>, but returns a <a>MaybeErr</a>. See also
--   Note [Un-ambiguous multiple interfaces]
loadSrcInterface_maybe :: SDoc -> ModuleName -> IsBootInterface -> Maybe FastString -> RnM (MaybeErr MsgDoc [ModIface])

-- | Loads the interface for a given Name. Should only be called for an
--   imported name; otherwise loadSysInterface may not find the interface
loadInterfaceForName :: SDoc -> Name -> TcRn ModIface

-- | Loads the interface for a given Module.
loadInterfaceForModule :: SDoc -> Module -> TcRn ModIface
loadInterface :: SDoc -> Module -> WhereFrom -> IfM lcl (MaybeErr MsgDoc ModIface)

-- | An <a>IfM</a> function to load the home interface for a wired-in
--   thing, so that we're sure that we see its instance declarations and
--   rules See Note [Loading instances for wired-in things] in TcIface
loadWiredInHomeIface :: Name -> IfM lcl ()

-- | Loads a system interface and throws an exception if it fails
loadSysInterface :: SDoc -> Module -> IfM lcl ModIface

-- | Loads a user interface and throws an exception if it fails. The first
--   parameter indicates whether we should import the boot variant of the
--   module
loadUserInterface :: Bool -> SDoc -> Module -> IfM lcl ModIface
loadPluginInterface :: SDoc -> Module -> IfM lcl ModIface
findAndReadIface :: SDoc -> Module -> IsBootInterface -> TcRnIf gbl lcl (MaybeErr MsgDoc (ModIface, FilePath))
readIface :: Module -> FilePath -> TcRnIf gbl lcl (MaybeErr MsgDoc ModIface)
loadDecls :: Bool -> [(Fingerprint, IfaceDecl)] -> IfL [(Name, TyThing)]
initExternalPackageState :: ExternalPackageState
ifaceStats :: ExternalPackageState -> SDoc
pprModIface :: ModIface -> SDoc

-- | Read binary interface, and print it out
showIface :: HscEnv -> FilePath -> IO ()
instance Outputable Warnings

module TcEnv

-- | A typecheckable-thing, essentially anything that has a name
data TyThing
[AnId] :: Id -> TyThing
[AConLike] :: ConLike -> TyThing
[ATyCon] :: TyCon -> TyThing
[ACoAxiom] :: (CoAxiom Branched) -> TyThing
data TcTyThing
[AGlobal] :: TyThing -> TcTyThing
[ATcId] :: TcId -> TopLevelFlag -> TcTyThing
[tct_id] :: TcTyThing -> TcId
[tct_closed] :: TcTyThing -> TopLevelFlag
[ATyVar] :: Name -> TcTyVar -> TcTyThing
[AThing] :: TcKind -> TcTyThing
[APromotionErr] :: PromotionErr -> TcTyThing
type TcId = Id
data InstInfo a
[InstInfo] :: ClsInst -> InstBindings a -> InstInfo a
[iSpec] :: InstInfo a -> ClsInst
[iBinds] :: InstInfo a -> InstBindings a
iDFunId :: InstInfo a -> DFunId
pprInstInfoDetails :: OutputableBndr a => InstInfo a -> SDoc
simpleInstInfoClsTy :: InstInfo a -> (Class, Type)
simpleInstInfoTy :: InstInfo a -> Type
simpleInstInfoTyCon :: InstInfo a -> TyCon
data InstBindings a
[InstBindings] :: [Name] -> (LHsBinds a) -> [LSig a] -> [ExtensionFlag] -> Bool -> InstBindings a
[ib_tyvars] :: InstBindings a -> [Name]
[ib_binds] :: InstBindings a -> (LHsBinds a)
[ib_pragmas] :: InstBindings a -> [LSig a]
[ib_extensions] :: InstBindings a -> [ExtensionFlag]
[ib_derived] :: InstBindings a -> Bool
tcExtendGlobalEnv :: [TyThing] -> TcM r -> TcM r
tcExtendGlobalEnvImplicit :: [TyThing] -> TcM r -> TcM r
setGlobalTypeEnv :: TcGblEnv -> TypeEnv -> TcM TcGblEnv
tcExtendGlobalValEnv :: [Id] -> TcM a -> TcM a
tcLookupLocatedGlobal :: Located Name -> TcM TyThing
tcLookupGlobal :: Name -> TcM TyThing
tcLookupField :: Name -> TcM Id
tcLookupTyCon :: Name -> TcM TyCon
tcLookupClass :: Name -> TcM Class
tcLookupDataCon :: Name -> TcM DataCon
tcLookupPatSyn :: Name -> TcM PatSyn
tcLookupConLike :: Name -> TcM ConLike
tcLookupLocatedGlobalId :: Located Name -> TcM Id
tcLookupLocatedTyCon :: Located Name -> TcM TyCon
tcLookupLocatedClass :: Located Name -> TcM Class
tcLookupAxiom :: Name -> TcM (CoAxiom Branched)
tcExtendKindEnv :: [(Name, TcKind)] -> TcM r -> TcM r
tcExtendKindEnv2 :: [(Name, TcTyThing)] -> TcM r -> TcM r
tcExtendTyVarEnv :: [TyVar] -> TcM r -> TcM r
tcExtendTyVarEnv2 :: [(Name, TcTyVar)] -> TcM r -> TcM r
tcExtendLetEnv :: TopLevelFlag -> TopLevelFlag -> [TcId] -> TcM a -> TcM a
tcExtendIdEnv :: [TcId] -> TcM a -> TcM a
tcExtendIdEnv1 :: Name -> TcId -> TcM a -> TcM a
tcExtendIdEnv2 :: [(Name, TcId)] -> TcM a -> TcM a

-- | <a>tcExtendIdEnv2</a>, but don't bind the <a>TcId</a>s in the
--   <a>TyVarSet</a> argument.
tcExtendIdEnv3 :: [(Name, TcId)] -> TyVarSet -> TcM a -> TcM a
tcExtendIdBndrs :: [TcIdBinder] -> TcM a -> TcM a
tcExtendGhciIdEnv :: [TyThing] -> TcM a -> TcM a
tcLookup :: Name -> TcM TcTyThing
tcLookupLocated :: Located Name -> TcM TcTyThing
tcLookupLocalIds :: [Name] -> TcM [TcId]
tcLookupId :: Name -> TcM Id
tcLookupTyVar :: Name -> TcM TcTyVar
tcLookupLcl_maybe :: Name -> TcM (Maybe TcTyThing)
getScopedTyVarBinds :: TcM [(Name, TcTyVar)]
getInLocalScope :: TcM (Name -> Bool)
wrongThingErr :: String -> TcTyThing -> Name -> TcM a
pprBinders :: [Name] -> SDoc
tcExtendRecEnv :: [(Name, TyThing)] -> TcM r -> TcM r
tcLookupInstance :: Class -> [Type] -> TcM ClsInst
tcGetInstEnvs :: TcM InstEnvs
tcExtendRules :: [LRuleDecl Id] -> TcM a -> TcM a
tcGetDefaultTys :: TcM ([Type], (Bool, Bool))
tcGetGlobalTyVars :: TcM TcTyVarSet
zapLclTypeEnv :: TcM a -> TcM a
checkWellStaged :: SDoc -> ThLevel -> ThLevel -> TcM ()
tcMetaTy :: Name -> TcM Type
thLevel :: ThStage -> ThLevel
topIdLvl :: Id -> ThLevel
isBrackStage :: ThStage -> Bool
newLocalName :: Name -> TcM Name
newDFunName :: Class -> [Type] -> SrcSpan -> TcM Name
newFamInstTyConName :: Located Name -> [Type] -> TcM Name
newFamInstAxiomName :: SrcSpan -> Name -> [CoAxBranch] -> TcM Name
mkStableIdFromString :: String -> Type -> SrcSpan -> (OccName -> OccName) -> TcM TcId
mkStableIdFromName :: Name -> Type -> SrcSpan -> (OccName -> OccName) -> TcM TcId
mkWrapperName :: (MonadIO m, HasDynFlags m, HasModule m) => String -> String -> m FastString
instance MonadThings (IOEnv (Env TcGblEnv TcLclEnv))
instance OutputableBndr a => Outputable (InstInfo a)

module Inst
deeplySkolemise :: TcSigmaType -> TcM (HsWrapper, [TyVar], [EvVar], TcRhoType)
deeplyInstantiate :: CtOrigin -> TcSigmaType -> TcM (HsWrapper, TcRhoType)
instCall :: CtOrigin -> [TcType] -> TcThetaType -> TcM HsWrapper
instStupidTheta :: CtOrigin -> TcThetaType -> TcM ()
emitWanted :: CtOrigin -> TcPredType -> TcM EvVar
emitWanteds :: CtOrigin -> TcThetaType -> TcM [EvVar]
newOverloadedLit :: CtOrigin -> HsOverLit Name -> TcRhoType -> TcM (HsOverLit TcId)
mkOverLit :: OverLitVal -> TcM HsLit
newClsInst :: Maybe OverlapMode -> Name -> [TyVar] -> ThetaType -> Class -> [Type] -> TcM ClsInst
tcGetInsts :: TcM [ClsInst]
tcGetInstEnvs :: TcM InstEnvs
getOverlapFlag :: Maybe OverlapMode -> TcM OverlapFlag
tcExtendLocalInstEnv :: [ClsInst] -> TcM a -> TcM a
instCallConstraints :: CtOrigin -> TcThetaType -> TcM HsWrapper
newMethodFromName :: CtOrigin -> Name -> TcRhoType -> TcM (HsExpr TcId)
tcSyntaxName :: CtOrigin -> TcType -> (Name, HsExpr Name) -> TcM (Name, HsExpr TcId)
tyVarsOfWC :: WantedConstraints -> TyVarSet
tyVarsOfBag :: (a -> TyVarSet) -> Bag a -> TyVarSet
tyVarsOfCt :: Ct -> TcTyVarSet
tyVarsOfCts :: Cts -> TcTyVarSet

module TcUnify
tcWrapResult :: HsExpr TcId -> TcRhoType -> TcRhoType -> TcM (HsExpr TcId)
tcGen :: UserTypeCtxt -> TcType -> ([TcTyVar] -> TcRhoType -> TcM result) -> TcM (HsWrapper, result)
tcSubType :: UserTypeCtxt -> TcSigmaType -> TcSigmaType -> TcM HsWrapper
tcSubType_NC :: UserTypeCtxt -> TcSigmaType -> TcSigmaType -> TcM HsWrapper
tcSubTypeDS :: UserTypeCtxt -> TcSigmaType -> TcRhoType -> TcM HsWrapper
tcSubTypeDS_NC :: UserTypeCtxt -> TcSigmaType -> TcRhoType -> TcM HsWrapper
checkConstraints :: SkolemInfo -> [TcTyVar] -> [EvVar] -> TcM result -> TcM (TcEvBinds, result)
newImplication :: SkolemInfo -> [TcTyVar] -> [EvVar] -> TcM result -> TcM (TcEvBinds, result)
unifyType :: TcTauType -> TcTauType -> TcM TcCoercion
unifyTypeList :: [TcTauType] -> TcM ()
unifyTheta :: TcThetaType -> TcThetaType -> TcM [TcCoercion]
unifyKindX :: TcKind -> TcKind -> TcM (Maybe Ordering)

-- | Infer a type using a type "checking" function by passing in a
--   ReturnTv, which can unify with *anything*. See also Note [ReturnTv] in
--   TcType
tcInfer :: (TcType -> TcM a) -> TcM (a, TcType)
matchExpectedListTy :: TcRhoType -> TcM (TcCoercion, TcRhoType)
matchExpectedPArrTy :: TcRhoType -> TcM (TcCoercion, TcRhoType)
matchExpectedTyConApp :: TyCon -> TcRhoType -> TcM (TcCoercion, [TcSigmaType])
matchExpectedAppTy :: TcRhoType -> TcM (TcCoercion, (TcSigmaType, TcSigmaType))
matchExpectedFunTys :: SDoc -> Arity -> TcRhoType -> TcM (TcCoercion, [TcSigmaType], TcRhoType)
matchExpectedFunKind :: TcKind -> TcM (Maybe (TcKind, TcKind))
wrapFunResCoercion :: [TcType] -> HsWrapper -> TcM HsWrapper

module RtClosureInspect
cvObtainTerm :: HscEnv -> Int -> Bool -> RttiType -> HValue -> IO Term
cvReconstructType :: HscEnv -> Int -> GhciType -> HValue -> IO (Maybe Type)
improveRTTIType :: HscEnv -> RttiType -> RttiType -> Maybe TvSubst
data Term
[Term] :: RttiType -> Either String DataCon -> HValue -> [Term] -> Term
[ty] :: Term -> RttiType
[dc] :: Term -> Either String DataCon
[val] :: Term -> HValue
[subTerms] :: Term -> [Term]
[Prim] :: RttiType -> [Word] -> Term
[ty] :: Term -> RttiType
[value] :: Term -> [Word]
[Suspension] :: ClosureType -> RttiType -> HValue -> Maybe Name -> Term
[ctype] :: Term -> ClosureType
[ty] :: Term -> RttiType
[val] :: Term -> HValue
[bound_to] :: Term -> Maybe Name
[NewtypeWrap] :: RttiType -> Either String DataCon -> Term -> Term
[ty] :: Term -> RttiType
[dc] :: Term -> Either String DataCon
[wrapped_term] :: Term -> Term
[RefWrap] :: RttiType -> Term -> Term
[ty] :: Term -> RttiType
[wrapped_term] :: Term -> Term
isTerm :: Term -> Bool
isSuspension :: Term -> Bool
isPrim :: Term -> Bool
isFun :: Term -> Bool
isFunLike :: Term -> Bool
isNewtypeWrap :: Term -> Bool
isFullyEvaluated :: DynFlags -> a -> IO Bool
isFullyEvaluatedTerm :: Term -> Bool
termType :: Term -> RttiType
mapTermType :: (RttiType -> Type) -> Term -> Term
termTyVars :: Term -> TyVarSet
foldTerm :: TermFold a -> Term -> a
data TermFold a
[TermFold] :: TermProcessor a a -> (RttiType -> [Word] -> a) -> (ClosureType -> RttiType -> HValue -> Maybe Name -> a) -> (RttiType -> Either String DataCon -> a -> a) -> (RttiType -> a -> a) -> TermFold a
[fTerm] :: TermFold a -> TermProcessor a a
[fPrim] :: TermFold a -> RttiType -> [Word] -> a
[fSuspension] :: TermFold a -> ClosureType -> RttiType -> HValue -> Maybe Name -> a
[fNewtypeWrap] :: TermFold a -> RttiType -> Either String DataCon -> a -> a
[fRefWrap] :: TermFold a -> RttiType -> a -> a
foldTermM :: Monad m => TermFoldM m a -> Term -> m a
data TermFoldM m a
[TermFoldM] :: TermProcessor a (m a) -> (RttiType -> [Word] -> m a) -> (ClosureType -> RttiType -> HValue -> Maybe Name -> m a) -> (RttiType -> Either String DataCon -> a -> m a) -> (RttiType -> a -> m a) -> TermFoldM m a
[fTermM] :: TermFoldM m a -> TermProcessor a (m a)
[fPrimM] :: TermFoldM m a -> RttiType -> [Word] -> m a
[fSuspensionM] :: TermFoldM m a -> ClosureType -> RttiType -> HValue -> Maybe Name -> m a
[fNewtypeWrapM] :: TermFoldM m a -> RttiType -> Either String DataCon -> a -> m a
[fRefWrapM] :: TermFoldM m a -> RttiType -> a -> m a
idTermFold :: TermFold Term
pprTerm :: TermPrinter -> TermPrinter

-- | Takes a list of custom printers with a explicit recursion knot and a
--   term, and returns the output of the first successful printer, or the
--   default printer
cPprTerm :: Monad m => CustomTermPrinter m -> Term -> m SDoc
cPprTermBase :: Monad m => CustomTermPrinter m
type CustomTermPrinter m = TermPrinterM m -> [Precedence -> Term -> (m (Maybe SDoc))]
data Closure
[Closure] :: ClosureType -> Ptr () -> StgInfoTable -> Array Int HValue -> [Word] -> Closure
[tipe] :: Closure -> ClosureType
[infoPtr] :: Closure -> Ptr ()
[infoTable] :: Closure -> StgInfoTable
[ptrs] :: Closure -> Array Int HValue
[nonPtrs] :: Closure -> [Word]
getClosureData :: DynFlags -> a -> IO Closure
data ClosureType
[Constr] :: ClosureType
[Fun] :: ClosureType
[Thunk] :: Int -> ClosureType
[ThunkSelector] :: ClosureType
[Blackhole] :: ClosureType
[AP] :: ClosureType
[PAP] :: ClosureType
[Indirection] :: Int -> ClosureType
[MutVar] :: Int -> ClosureType
[MVar] :: Int -> ClosureType
[Other] :: Int -> ClosureType
isConstr :: ClosureType -> Bool
isIndirection :: ClosureType -> Bool
instance Eq ClosureType
instance Show ClosureType
instance Outputable Term
instance Outputable ClosureType

module TcGenDeriv
type BagDerivStuff = Bag DerivStuff
data DerivStuff
[DerivAuxBind] :: AuxBindSpec -> DerivStuff
[DerivTyCon] :: TyCon -> DerivStuff
[DerivFamInst] :: FamInst -> DerivStuff
[DerivHsBind] :: (LHsBind RdrName, LSig RdrName) -> DerivStuff
[DerivInst] :: (InstInfo RdrName) -> DerivStuff
canDeriveAnyClass :: DynFlags -> TyCon -> Class -> Maybe SDoc
genDerivedBinds :: DynFlags -> (Name -> Fixity) -> Class -> SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)
data FFoldType a
[FT] :: a -> a -> a -> (a -> a -> a) -> (TupleSort -> [a] -> a) -> (Type -> a -> a) -> a -> (TcTyVar -> a -> a) -> FFoldType a
[ft_triv] :: FFoldType a -> a
[ft_var] :: FFoldType a -> a
[ft_co_var] :: FFoldType a -> a
[ft_fun] :: FFoldType a -> a -> a -> a
[ft_tup] :: FFoldType a -> TupleSort -> [a] -> a
[ft_ty_app] :: FFoldType a -> Type -> a -> a
[ft_bad_app] :: FFoldType a -> a
[ft_forall] :: FFoldType a -> TcTyVar -> a -> a
functorLikeTraverse :: TyVar -> FFoldType a -> Type -> a
deepSubtypesContaining :: TyVar -> Type -> [TcType]
foldDataConArgs :: FFoldType a -> DataCon -> [a]
mkCoerceClassMethEqn :: Class -> [TyVar] -> [Type] -> Type -> Id -> Pair Type
gen_Newtype_binds :: SrcSpan -> Class -> [TyVar] -> [Type] -> Type -> LHsBinds RdrName
genAuxBinds :: SrcSpan -> BagDerivStuff -> SeparateBagsDerivStuff
ordOpTbl :: [(Type, (RdrName, RdrName, RdrName, RdrName, RdrName))]
boxConTbl :: [(Type, RdrName)]
mkRdrFunBind :: Located RdrName -> [LMatch RdrName (LHsExpr RdrName)] -> LHsBind RdrName
instance Eq AuxBindSpec


-- | Module for constructing <tt>ModIface</tt> values (interface files),
--   writing them to disk and comparing two versions to see if
--   recompilation is required.
module MkIface
mkUsedNames :: TcGblEnv -> NameSet

-- | Extract information from the rename and typecheck phases to produce a
--   dependencies information for the module being compiled.
mkDependencies :: TcGblEnv -> IO Dependencies
mkIface :: HscEnv -> Maybe Fingerprint -> ModDetails -> ModGuts -> IO (Messages, Maybe (ModIface, Bool))

-- | make an interface from the results of typechecking only. Useful for
--   non-optimising compilation, or where we aren't generating any object
--   code at all (<a>HscNothing</a>).
mkIfaceTc :: HscEnv -> Maybe Fingerprint -> SafeHaskellMode -> ModDetails -> TcGblEnv -> IO (Messages, Maybe (ModIface, Bool))
writeIfaceFile :: DynFlags -> FilePath -> ModIface -> IO ()

-- | Top level function to check if the version of an old interface file is
--   equivalent to the current source file the user asked us to compile. If
--   the same, we can avoid recompilation. We return a tuple where the
--   first element is a bool saying if we should recompile the object file
--   and the second is maybe the interface file, where Nothng means to
--   rebuild the interface file not use the exisitng one.
checkOldIface :: HscEnv -> ModSummary -> SourceModified -> Maybe ModIface -> IO (RecompileRequired, Maybe ModIface)
data RecompileRequired

-- | everything is up to date, recompilation is not required
[UpToDate] :: RecompileRequired

-- | The .hs file has been touched, or the .o/.hi file does not exist
[MustCompile] :: RecompileRequired

-- | The .o/.hi files are up to date, but something else has changed to
--   force recompilation; the String says what (one-line summary)
[RecompBecause] :: String -> RecompileRequired
recompileRequired :: RecompileRequired -> Bool
tyThingToIfaceDecl :: TyThing -> IfaceDecl
instance Eq RecompileRequired
instance Outputable IfaceDeclExtras
instance Binary IfaceDeclExtras
instance Binary IfaceIdExtras


-- | The dynamic linker for GHCi.
--   
--   This module deals with the top-level issues of dynamic linking,
--   calling the object-code linker and the byte-code linker where
--   necessary.
module Linker

-- | Get the <a>HValue</a> associated with the given name.
--   
--   May cause loading the module that contains the name.
--   
--   Throws a <a>ProgramError</a> if loading fails or the name cannot be
--   found.
getHValue :: HscEnv -> Name -> IO HValue

-- | Display the persistent linker state.
showLinkerState :: DynFlags -> IO ()

-- | Link a single expression, <i>including</i> first linking packages and
--   modules that this expression depends on.
--   
--   Raises an IO exception (<a>ProgramError</a>) if it can't find a
--   compiled version of the dependents to link.
linkExpr :: HscEnv -> SrcSpan -> UnlinkedBCO -> IO HValue
linkDecls :: HscEnv -> SrcSpan -> CompiledByteCode -> IO ()

-- | Unloading old objects ready for a new compilation sweep.
--   
--   The compilation manager provides us with a list of linkables that it
--   considers "stable", i.e. won't be recompiled this time around. For
--   each of the modules current linked in memory,
--   
--   <ul>
--   <li>if the linkable is stable (and it's the same one -- the user may
--   have recompiled the module on the side), we keep it,</li>
--   <li>otherwise, we unload it.</li>
--   <li>we also implicitly unload all temporary bindings at this
--   point.</li>
--   </ul>
unload :: DynFlags -> [Linkable] -> IO ()

-- | Temporarily extend the linker state.
withExtendedLinkEnv :: (MonadIO m, ExceptionMonad m) => [(Name, HValue)] -> m a -> m a
extendLinkEnv :: [(Name, HValue)] -> IO ()
deleteFromLinkEnv :: [Name] -> IO ()
extendLoadedPkgs :: [PackageKey] -> IO ()

-- | Link exactly the specified packages, and their dependents (unless of
--   course they are already linked). The dependents are linked
--   automatically, and it doesn't matter what order you specify the input
--   packages.
linkPackages :: DynFlags -> [PackageKey] -> IO ()

-- | Initialise the dynamic linker. This entails
--   
--   a) Calling the C initialisation procedure,
--   
--   b) Loading any packages specified on the command line,
--   
--   c) Loading any packages specified on the command line, now held in the
--   <tt>-l</tt> options in <tt>v_Opt_l</tt>,
--   
--   d) Loading any <tt>.o/.dll</tt> files specified on the command line,
--   now held in <tt>ldInputs</tt>,
--   
--   e) Loading any MacOS frameworks.
--   
--   NOTE: This function is idempotent; if called more than once, it does
--   nothing. This is useful in Template Haskell, where we call it before
--   trying to link.
initDynLinker :: DynFlags -> IO ()
linkModule :: HscEnv -> Module -> IO ()
linkCmdLineLibs :: DynFlags -> IO ()
data PersistentLinkerState
saveLinkerGlobals :: IO (MVar PersistentLinkerState, Bool)
restoreLinkerGlobals :: (MVar PersistentLinkerState, Bool) -> IO ()

module CoreMonad
data CoreToDo
[CoreDoSimplify] :: Int -> SimplifierMode -> CoreToDo
[CoreDoPluginPass] :: String -> PluginPass -> CoreToDo
[CoreDoFloatInwards] :: CoreToDo
[CoreDoFloatOutwards] :: FloatOutSwitches -> CoreToDo
[CoreLiberateCase] :: CoreToDo
[CoreDoPrintCore] :: CoreToDo
[CoreDoStaticArgs] :: CoreToDo
[CoreDoCallArity] :: CoreToDo
[CoreDoStrictness] :: CoreToDo
[CoreDoWorkerWrapper] :: CoreToDo
[CoreDoSpecialising] :: CoreToDo
[CoreDoSpecConstr] :: CoreToDo
[CoreCSE] :: CoreToDo
[CoreDoRuleCheck] :: CompilerPhase -> String -> CoreToDo
[CoreDoVectorisation] :: CoreToDo
[CoreDoNothing] :: CoreToDo
[CoreDoPasses] :: [CoreToDo] -> CoreToDo
[CoreDesugar] :: CoreToDo
[CoreDesugarOpt] :: CoreToDo
[CoreTidy] :: CoreToDo
[CorePrep] :: CoreToDo
runWhen :: Bool -> CoreToDo -> CoreToDo
runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo
data SimplifierMode
[SimplMode] :: [String] -> CompilerPhase -> Bool -> Bool -> Bool -> Bool -> SimplifierMode
[sm_names] :: SimplifierMode -> [String]
[sm_phase] :: SimplifierMode -> CompilerPhase
[sm_rules] :: SimplifierMode -> Bool
[sm_inline] :: SimplifierMode -> Bool
[sm_case_case] :: SimplifierMode -> Bool
[sm_eta_expand] :: SimplifierMode -> Bool
data FloatOutSwitches
[FloatOutSwitches] :: Maybe Int -> Bool -> Bool -> FloatOutSwitches

-- | Just n <a>=</a> float lambdas to top level, if doing so will abstract
--   over n or fewer value variables Nothing <a>=</a> float all lambdas to
--   top level, regardless of how many free variables Just 0 is the vanilla
--   case: float a lambda iff it has no free vars
[floatOutLambdas] :: FloatOutSwitches -> Maybe Int

-- | True <a>=</a> float constants to top level, even if they do not escape
--   a lambda
[floatOutConstants] :: FloatOutSwitches -> Bool

-- | True <a>=</a> float out over-saturated applications based on arity
--   information. See Note [Floating over-saturated applications] in
--   SetLevels
[floatOutOverSatApps] :: FloatOutSwitches -> Bool
pprPassDetails :: CoreToDo -> SDoc

-- | A description of the plugin pass itself
type PluginPass = ModGuts -> CoreM ModGuts
bindsOnlyPass :: (CoreProgram -> CoreM CoreProgram) -> ModGuts -> CoreM ModGuts
data SimplCount
doSimplTick :: DynFlags -> Tick -> SimplCount -> SimplCount
doFreeSimplTick :: Tick -> SimplCount -> SimplCount
simplCountN :: SimplCount -> Int
pprSimplCount :: SimplCount -> SDoc
plusSimplCount :: SimplCount -> SimplCount -> SimplCount
zeroSimplCount :: DynFlags -> SimplCount
isZeroSimplCount :: SimplCount -> Bool
hasDetailedCounts :: SimplCount -> Bool
data Tick
[PreInlineUnconditionally] :: Id -> Tick
[PostInlineUnconditionally] :: Id -> Tick
[UnfoldingDone] :: Id -> Tick
[RuleFired] :: FastString -> Tick
[LetFloatFromLet] :: Tick
[EtaExpansion] :: Id -> Tick
[EtaReduction] :: Id -> Tick
[BetaReduction] :: Id -> Tick
[CaseOfCase] :: Id -> Tick
[KnownBranch] :: Id -> Tick
[CaseMerge] :: Id -> Tick
[AltMerge] :: Id -> Tick
[CaseElim] :: Id -> Tick
[CaseIdentity] :: Id -> Tick
[FillInCaseDefault] :: Id -> Tick
[BottomFound] :: Tick
[SimplifierDone] :: Tick

-- | The monad used by Core-to-Core passes to access common state, register
--   simplification statistics and so on
data CoreM a
runCoreM :: HscEnv -> RuleBase -> UniqSupply -> Module -> PrintUnqualified -> CoreM a -> IO (a, SimplCount)
getHscEnv :: CoreM HscEnv
getRuleBase :: CoreM RuleBase
getModule :: HasModule m => m Module
getDynFlags :: HasDynFlags m => m DynFlags

-- | The original name cache is the current mapping from <a>Module</a> and
--   <tt>OccName</tt> to a compiler-wide unique <a>Name</a>
getOrigNameCache :: CoreM OrigNameCache
getPackageFamInstEnv :: CoreM PackageFamInstEnv
getPrintUnqualified :: CoreM PrintUnqualified
addSimplCount :: SimplCount -> CoreM ()

-- | Lift a computation from the <a>IO</a> monad.
liftIO :: MonadIO m => forall a. IO a -> m a

-- | Lift an <a>IO</a> operation into <a>CoreM</a> while consuming its
--   <a>SimplCount</a>
liftIOWithCount :: IO (SimplCount, a) -> CoreM a

-- | Lift an <a>IO</a> operation with 1 argument into another monad
liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b

-- | Lift an <a>IO</a> operation with 2 arguments into another monad
liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c

-- | Lift an <a>IO</a> operation with 3 arguments into another monad
liftIO3 :: MonadIO m => (a -> b -> c -> IO d) -> a -> b -> c -> m d

-- | Lift an <a>IO</a> operation with 4 arguments into another monad
liftIO4 :: MonadIO m => (a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> m e
reinitializeGlobals :: CoreM ()

-- | Get all annotations of a given type. This happens lazily, that is no
--   deserialization will take place until the [a] is actually demanded and
--   the [a] can also be empty (the UniqFM is not filtered).
--   
--   This should be done once at the start of a Core-to-Core pass that uses
--   annotations.
--   
--   See Note [Annotations]
getAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (UniqFM [a])

-- | Get at most one annotation of a given type per Unique.
getFirstAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (UniqFM a)

-- | Output a message to the screen
putMsg :: SDoc -> CoreM ()

-- | Output a String message to the screen
putMsgS :: String -> CoreM ()

-- | Output an error to the screen
errorMsg :: SDoc -> CoreM ()

-- | Output a string error to the screen
errorMsgS :: String -> CoreM ()

-- | Output a fatal error to the screen. Note this does not by itself cause
--   the compiler to die
fatalErrorMsg :: SDoc -> CoreM ()

-- | Output a fatal string error to the screen. Note this does not by
--   itself cause the compiler to die
fatalErrorMsgS :: String -> CoreM ()

-- | Outputs a debugging message at verbosity level of <tt>-v</tt> or
--   higher
debugTraceMsg :: SDoc -> CoreM ()

-- | Output a string debugging message at verbosity level of <tt>-v</tt> or
--   higher
debugTraceMsgS :: String -> CoreM ()

-- | Show some labelled <a>SDoc</a> if a particular flag is set or at a
--   verbosity level of <tt>-v -ddump-most</tt> or higher
dumpIfSet_dyn :: DumpFlag -> String -> SDoc -> CoreM ()

-- | Attempt to convert a Template Haskell name to one that GHC can
--   understand. Original TH names such as those you get when you use the
--   <tt>'foo</tt> syntax will be translated to their equivalent GHC name
--   exactly. Qualified or unqualifed TH names will be dynamically bound to
--   names in the module being compiled, if possible. Exact TH names will
--   be bound to the name they represent, exactly.
thNameToGhcName :: Name -> CoreM (Maybe Name)
instance Outputable CoreToDo
instance Outputable SimplifierMode
instance Outputable FloatOutSwitches
instance Outputable Tick
instance Eq Tick
instance Ord Tick
instance Functor CoreM
instance Monad CoreM
instance Applicative CoreM
instance MonadPlus IO => Alternative CoreM
instance MonadPlus IO => MonadPlus CoreM
instance MonadUnique CoreM
instance MonadIO CoreM
instance HasDynFlags CoreM
instance HasModule CoreM
instance MonadThings CoreM

module Plugins

-- | <a>Plugin</a> is the core compiler plugin data type. Try to avoid
--   constructing one of these directly, and just modify some fields of
--   <a>defaultPlugin</a> instead: this is to try and preserve source-code
--   compatability when we add fields to this.
--   
--   Nonetheless, this API is preliminary and highly likely to change in
--   the future.
data Plugin
[Plugin] :: ([CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]) -> ([CommandLineOption] -> Maybe TcPlugin) -> Plugin

-- | Modify the Core pipeline that will be used for compilation. This is
--   called as the Core pipeline is built for every module being compiled,
--   and plugins get the opportunity to modify the pipeline in a
--   nondeterministic order.
[installCoreToDos] :: Plugin -> [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]

-- | An optional typechecker plugin, which may modify the behaviour of the
--   constraint solver.
[tcPlugin] :: Plugin -> [CommandLineOption] -> Maybe TcPlugin

-- | Command line options gathered from the -PModule.Name:stuff syntax are
--   given to you as this type
type CommandLineOption = String

-- | Default plugin: does nothing at all! For compatability reasons you
--   should base all your plugin definitions on this default value.
defaultPlugin :: Plugin

module CoreLint
lintCoreBindings :: CoreToDo -> [Var] -> CoreProgram -> (Bag MsgDoc, Bag MsgDoc)
lintUnfolding :: SrcLoc -> [Var] -> CoreExpr -> Maybe MsgDoc
lintPassResult :: HscEnv -> CoreToDo -> CoreProgram -> IO ()
lintInteractiveExpr :: String -> HscEnv -> CoreExpr -> IO ()
lintExpr :: [Var] -> CoreExpr -> Maybe MsgDoc

-- | This checks whether a pass correctly looks through debug annotations
--   (<tt>SourceNote</tt>). This works a bit different from other
--   consistency checks: We check this by running the given task twice,
--   noting all differences between the results.
lintAnnots :: SDoc -> (ModGuts -> CoreM ModGuts) -> ModGuts -> CoreM ModGuts
showPass :: CoreToDo -> CoreM ()
showPassIO :: DynFlags -> CoreToDo -> IO ()
endPass :: CoreToDo -> CoreProgram -> [CoreRule] -> CoreM ()
endPassIO :: HscEnv -> PrintUnqualified -> CoreToDo -> CoreProgram -> [CoreRule] -> IO ()
dumpPassResult :: DynFlags -> PrintUnqualified -> Maybe DumpFlag -> SDoc -> SDoc -> CoreProgram -> [CoreRule] -> IO ()
dumpIfSet :: DynFlags -> Bool -> CoreToDo -> SDoc -> SDoc -> IO ()
instance Functor LintM
instance Applicative LintM
instance Monad LintM

module CorePrep
corePrepPgm :: HscEnv -> ModLocation -> CoreProgram -> [TyCon] -> IO CoreProgram
corePrepExpr :: DynFlags -> HscEnv -> CoreExpr -> IO CoreExpr
cvtLitInteger :: DynFlags -> Id -> Maybe DataCon -> Integer -> CoreExpr
lookupMkIntegerName :: DynFlags -> HscEnv -> IO Id
lookupIntegerSDataConName :: DynFlags -> HscEnv -> IO (Maybe DataCon)
instance Outputable FloatingBind
instance Outputable Floats
instance Outputable OkToSpec

module TidyPgm
mkBootModDetailsTc :: HscEnv -> TcGblEnv -> IO ModDetails
tidyProgram :: HscEnv -> ModGuts -> IO (CgGuts, ModDetails)
globaliseAndTidyId :: Id -> Id
instance Functor DFFV
instance Applicative DFFV
instance Monad DFFV


-- | This module is not used by GHC itself. Rather, it exports all of the
--   functions and types you are likely to need when writing a plugin for
--   GHC. So authors of plugins can probably get away simply with saying
--   "import GhcPlugins".
--   
--   Particularly interesting modules for plugin writers include
--   <a>CoreSyn</a> and <a>CoreMonad</a>.
module GhcPlugins

module SetLevels
setLevels :: FloatOutSwitches -> CoreProgram -> UniqSupply -> [LevelledBind]
data Level
[Level] :: Int -> Int -> Level
tOP_LEVEL :: Level
type LevelledBind = TaggedBind FloatSpec
type LevelledExpr = TaggedExpr FloatSpec
type LevelledBndr = TaggedBndr FloatSpec
data FloatSpec
[FloatMe] :: Level -> FloatSpec
[StayPut] :: Level -> FloatSpec
floatSpecLevel :: FloatSpec -> Level
incMinorLvl :: Level -> Level
ltMajLvl :: Level -> Level -> Bool
ltLvl :: Level -> Level -> Bool
isTopLvl :: Level -> Bool
instance Outputable FloatSpec
instance Outputable Level
instance Eq Level

module FloatOut
floatOutwards :: FloatOutSwitches -> DynFlags -> UniqSupply -> CoreProgram -> IO CoreProgram
instance Outputable FloatBinds

module SimplMonad
data SimplM result
initSmpl :: DynFlags -> RuleBase -> (FamInstEnv, FamInstEnv) -> UniqSupply -> Int -> SimplM a -> IO (a, SimplCount)
traceSmpl :: String -> SDoc -> SimplM ()
getSimplRules :: SimplM RuleBase
getFamEnvs :: SimplM (FamInstEnv, FamInstEnv)

-- | A monad for generating unique identifiers
class Monad m => MonadUnique m where getUniqueM = liftM uniqFromSupply getUniqueSupplyM getUniquesM = liftM uniqsFromSupply getUniqueSupplyM
getUniqueSupplyM :: MonadUnique m => m UniqSupply
getUniqueM :: MonadUnique m => m Unique
getUniquesM :: MonadUnique m => m [Unique]
newId :: FastString -> Type -> SimplM Id
data SimplCount
tick :: Tick -> SimplM ()
freeTick :: Tick -> SimplM ()
checkedTick :: Tick -> SimplM ()
getSimplCount :: SimplM SimplCount
zeroSimplCount :: DynFlags -> SimplCount
pprSimplCount :: SimplCount -> SDoc
plusSimplCount :: SimplCount -> SimplCount -> SimplCount
isZeroSimplCount :: SimplCount -> Bool
instance Functor SimplM
instance Applicative SimplM
instance Monad SimplM
instance MonadUnique SimplM
instance HasDynFlags SimplM
instance MonadIO SimplM

module SimplEnv
type InId = Id
type InBind = CoreBind
type InExpr = CoreExpr
type InAlt = CoreAlt
type InArg = CoreArg
type InType = Type
type InBndr = CoreBndr
type InVar = Var
type OutId = Id
type OutTyVar = TyVar
type OutBind = CoreBind
type OutExpr = CoreExpr
type OutAlt = CoreAlt
type OutArg = CoreArg
type OutType = Type
type OutBndr = CoreBndr
type OutVar = Var
type InCoercion = Coercion
type OutCoercion = Coercion
setMode :: SimplifierMode -> SimplEnv -> SimplEnv
getMode :: SimplEnv -> SimplifierMode
updMode :: (SimplifierMode -> SimplifierMode) -> SimplEnv -> SimplEnv
data SimplEnv
[SimplEnv] :: SimplifierMode -> TvSubstEnv -> CvSubstEnv -> SimplIdSubst -> InScopeSet -> Floats -> SimplEnv
[seMode] :: SimplEnv -> SimplifierMode
[seTvSubst] :: SimplEnv -> TvSubstEnv
[seCvSubst] :: SimplEnv -> CvSubstEnv
[seIdSubst] :: SimplEnv -> SimplIdSubst
[seInScope] :: SimplEnv -> InScopeSet
[seFloats] :: SimplEnv -> Floats
type StaticEnv = SimplEnv
pprSimplEnv :: SimplEnv -> SDoc
mkSimplEnv :: SimplifierMode -> SimplEnv
extendIdSubst :: SimplEnv -> Id -> SimplSR -> SimplEnv
extendTvSubst :: SimplEnv -> TyVar -> Type -> SimplEnv
extendCvSubst :: SimplEnv -> CoVar -> Coercion -> SimplEnv
zapSubstEnv :: SimplEnv -> SimplEnv
setSubstEnv :: SimplEnv -> TvSubstEnv -> CvSubstEnv -> SimplIdSubst -> SimplEnv
getInScope :: SimplEnv -> InScopeSet
setInScope :: SimplEnv -> SimplEnv -> SimplEnv
setInScopeSet :: SimplEnv -> InScopeSet -> SimplEnv
modifyInScope :: SimplEnv -> CoreBndr -> SimplEnv
addNewInScopeIds :: SimplEnv -> [CoreBndr] -> SimplEnv
getSimplRules :: SimplM RuleBase
data SimplSR
[DoneEx] :: OutExpr -> SimplSR
[DoneId] :: OutId -> SimplSR
[ContEx] :: TvSubstEnv -> CvSubstEnv -> SimplIdSubst -> InExpr -> SimplSR
mkContEx :: SimplEnv -> InExpr -> SimplSR
substId :: SimplEnv -> InId -> SimplSR
lookupRecBndr :: SimplEnv -> InId -> OutId
simplNonRecBndr :: SimplEnv -> InBndr -> SimplM (SimplEnv, OutBndr)
simplRecBndrs :: SimplEnv -> [InBndr] -> SimplM SimplEnv
simplLamBndr :: SimplEnv -> Var -> SimplM (SimplEnv, Var)
simplLamBndrs :: SimplEnv -> [InBndr] -> SimplM (SimplEnv, [OutBndr])
simplBinder :: SimplEnv -> InBndr -> SimplM (SimplEnv, OutBndr)
simplBinders :: SimplEnv -> [InBndr] -> SimplM (SimplEnv, [OutBndr])
addBndrRules :: SimplEnv -> InBndr -> OutBndr -> (SimplEnv, OutBndr)
substExpr :: SDoc -> SimplEnv -> CoreExpr -> CoreExpr
substTy :: SimplEnv -> Type -> Type
substTyVar :: SimplEnv -> TyVar -> Type
getTvSubst :: SimplEnv -> TvSubst
getCvSubst :: SimplEnv -> CvSubst
substCo :: SimplEnv -> Coercion -> Coercion
substCoVar :: SimplEnv -> CoVar -> Coercion
mkCoreSubst :: SDoc -> SimplEnv -> Subst
data Floats
emptyFloats :: Floats
isEmptyFloats :: SimplEnv -> Bool
addNonRec :: SimplEnv -> OutId -> OutExpr -> SimplEnv
addFloats :: SimplEnv -> SimplEnv -> SimplEnv
extendFloats :: SimplEnv -> OutBind -> SimplEnv
wrapFloats :: SimplEnv -> OutExpr -> OutExpr
setFloats :: SimplEnv -> SimplEnv -> SimplEnv
zapFloats :: SimplEnv -> SimplEnv
addRecFloats :: SimplEnv -> SimplEnv -> SimplEnv
mapFloats :: SimplEnv -> ((Id, CoreExpr) -> (Id, CoreExpr)) -> SimplEnv
doFloatFromRhs :: TopLevelFlag -> RecFlag -> Bool -> OutExpr -> SimplEnv -> Bool
getFloatBinds :: SimplEnv -> [CoreBind]
instance Outputable SimplSR
instance Outputable Floats
instance Outputable FloatFlag

module SimplUtils
mkLam :: [OutBndr] -> OutExpr -> SimplCont -> SimplM OutExpr
mkCase :: DynFlags -> OutExpr -> OutId -> OutType -> [OutAlt] -> SimplM OutExpr
prepareAlts :: OutExpr -> OutId -> [InAlt] -> SimplM ([AltCon], [InAlt])
tryEtaExpandRhs :: SimplEnv -> OutId -> OutExpr -> SimplM (Arity, OutExpr)
preInlineUnconditionally :: DynFlags -> SimplEnv -> TopLevelFlag -> InId -> InExpr -> Bool
postInlineUnconditionally :: DynFlags -> SimplEnv -> TopLevelFlag -> OutId -> OccInfo -> OutExpr -> Unfolding -> Bool
activeUnfolding :: SimplEnv -> Id -> Bool
activeRule :: SimplEnv -> Activation -> Bool
getUnfoldingInRuleMatch :: SimplEnv -> InScopeEnv
simplEnvForGHCi :: DynFlags -> SimplEnv
updModeForStableUnfoldings :: Activation -> SimplifierMode -> SimplifierMode
data SimplCont
[Stop] :: OutType -> CallCtxt -> SimplCont
[CastIt] :: OutCoercion -> SimplCont -> SimplCont
[ApplyToVal] :: DupFlag -> InExpr -> StaticEnv -> SimplCont -> SimplCont
[sc_dup] :: SimplCont -> DupFlag
[sc_arg] :: SimplCont -> InExpr
[sc_env] :: SimplCont -> StaticEnv
[sc_cont] :: SimplCont -> SimplCont
[ApplyToTy] :: OutType -> OutType -> SimplCont -> SimplCont
[sc_arg_ty] :: SimplCont -> OutType
[sc_hole_ty] :: SimplCont -> OutType
[sc_cont] :: SimplCont -> SimplCont
[Select] :: DupFlag -> InId -> [InAlt] -> StaticEnv -> SimplCont -> SimplCont
[StrictBind] :: InId -> [InBndr] -> InExpr -> StaticEnv -> SimplCont -> SimplCont
[StrictArg] :: ArgInfo -> CallCtxt -> SimplCont -> SimplCont
[TickIt] :: (Tickish Id) -> SimplCont -> SimplCont
data DupFlag
[NoDup] :: DupFlag
[Simplified] :: DupFlag
[OkToDup] :: DupFlag
isSimplified :: DupFlag -> Bool
contIsDupable :: SimplCont -> Bool
contResultType :: SimplCont -> OutType
contHoleType :: SimplCont -> OutType
contIsTrivial :: SimplCont -> Bool
contArgs :: SimplCont -> (Bool, [ArgSummary], SimplCont)
countValArgs :: SimplCont -> Int
countArgs :: SimplCont -> Int
mkBoringStop :: OutType -> SimplCont
mkRhsStop :: OutType -> SimplCont
mkLazyArgStop :: OutType -> CallCtxt -> SimplCont
contIsRhsOrArg :: SimplCont -> Bool
interestingCallContext :: SimplCont -> CallCtxt
interestingArg :: CoreExpr -> ArgSummary
data ArgInfo
[ArgInfo] :: OutId -> [ArgSpec] -> OutType -> [CoreRule] -> Bool -> [Bool] -> [Int] -> ArgInfo
[ai_fun] :: ArgInfo -> OutId
[ai_args] :: ArgInfo -> [ArgSpec]
[ai_type] :: ArgInfo -> OutType
[ai_rules] :: ArgInfo -> [CoreRule]
[ai_encl] :: ArgInfo -> Bool
[ai_strs] :: ArgInfo -> [Bool]
[ai_discs] :: ArgInfo -> [Int]
data ArgSpec
[ValArg] :: OutExpr -> ArgSpec
[TyArg] :: OutType -> OutType -> ArgSpec
[as_arg_ty] :: ArgSpec -> OutType
[as_hole_ty] :: ArgSpec -> OutType
[CastBy] :: OutCoercion -> ArgSpec
mkArgInfo :: Id -> [CoreRule] -> Int -> SimplCont -> ArgInfo
addValArgTo :: ArgInfo -> OutExpr -> ArgInfo
addCastTo :: ArgInfo -> OutCoercion -> ArgInfo
addTyArgTo :: ArgInfo -> OutType -> ArgInfo
argInfoExpr :: OutId -> [ArgSpec] -> OutExpr
argInfoAppArgs :: [ArgSpec] -> [OutExpr]
pushSimplifiedArgs :: SimplEnv -> [ArgSpec] -> SimplCont -> SimplCont
abstractFloats :: [OutTyVar] -> SimplEnv -> OutExpr -> SimplM ([OutBind], OutExpr)
instance Outputable DupFlag
instance Outputable SimplCont
instance Outputable ArgSpec

module Simplify
simplTopBinds :: SimplEnv -> [InBind] -> SimplM SimplEnv
simplExpr :: SimplEnv -> CoreExpr -> SimplM CoreExpr

module Specialise
specProgram :: ModGuts -> CoreM ModGuts
specUnfolding :: DynFlags -> Subst -> [Var] -> [CoreExpr] -> Unfolding -> Unfolding
instance Outputable UsageDetails
instance Outputable CallInfoSet
instance Outputable CallKey
instance Eq CallKey
instance Ord CallKey
instance Functor SpecM
instance Applicative SpecM
instance Monad SpecM
instance MonadUnique SpecM
instance HasDynFlags SpecM

module SpecConstr
specConstrProgram :: ModGuts -> CoreM ModGuts
data SpecConstrAnnotation :: *
[NoSpecConstr] :: SpecConstrAnnotation
[ForceSpecConstr] :: SpecConstrAnnotation
instance Outputable Value
instance Outputable HowBound
instance Outputable Call
instance Outputable ArgOcc

module RnEnv
newTopSrcBinder :: Located RdrName -> RnM Name
lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
lookupTopBndrRn :: RdrName -> RnM Name
lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
lookupOccRn :: RdrName -> RnM Name
lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
lookupInfoOccRn :: RdrName -> RnM [Name]
lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, ThLevel))
lookupTypeOccRn :: RdrName -> RnM Name
lookupKindOccRn :: RdrName -> RnM Name
lookupGlobalOccRn :: RdrName -> RnM Name
lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
reportUnboundName :: RdrName -> RnM Name
data HsSigCtxt
[TopSigCtxt] :: NameSet -> Bool -> HsSigCtxt
[LocalBindCtxt] :: NameSet -> HsSigCtxt
[ClsDeclCtxt] :: Name -> HsSigCtxt
[InstDeclCtxt] :: Name -> HsSigCtxt
[HsBootCtxt] :: HsSigCtxt
lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [Name]
lookupSigOccRn :: HsSigCtxt -> Sig RdrName -> Located RdrName -> RnM (Located Name)
lookupFixityRn :: Name -> RnM Fixity
lookupTyFixityRn :: Located Name -> RnM Fixity
lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
lookupSubBndrOcc :: Bool -> Parent -> SDoc -> RdrName -> RnM Name
lookupFamInstName :: Maybe Name -> Located RdrName -> RnM (Located Name)
greRdrName :: GlobalRdrElt -> RdrName
lookupSubBndrGREs :: GlobalRdrEnv -> Parent -> RdrName -> [GlobalRdrElt]
lookupConstructorFields :: Name -> RnM [Name]
lookupSyntaxName :: Name -> RnM (SyntaxExpr Name, FreeVars)
lookupSyntaxNames :: [Name] -> RnM ([HsExpr Name], FreeVars)
lookupIfThenElse :: RnM (Maybe (SyntaxExpr Name), FreeVars)
lookupGreRn :: RdrName -> RnM GlobalRdrElt
lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
lookupGreLocalRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
getLookupOccRn :: RnM (Name -> Maybe Name)
addUsedRdrNames :: [RdrName] -> RnM ()
newLocalBndrRn :: Located RdrName -> RnM Name
newLocalBndrsRn :: [Located RdrName] -> RnM [Name]
bindLocalNames :: [Name] -> RnM a -> RnM a
bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
type MiniFixityEnv = FastStringEnv (Located Fixity)
addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a
bindLocatedLocalsFV :: [Located RdrName] -> ([Name] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
bindLocatedLocalsRn :: [Located RdrName] -> ([Name] -> RnM a) -> RnM a
extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
checkDupRdrNames :: [Located RdrName] -> RnM ()
checkShadowedRdrNames :: [Located RdrName] -> RnM ()
checkDupNames :: [Name] -> RnM ()
checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
checkTupSize :: Int -> RnM ()
addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c) -> [a] -> ([b] -> RnM c) -> RnM c
warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
warnUnusedLocalBinds :: [Name] -> FreeVars -> RnM ()
dataTcOccs :: RdrName -> [RdrName]
kindSigErr :: Outputable a => a -> SDoc
perhapsForallMsg :: SDoc
data HsDocContext
[TypeSigCtx] :: SDoc -> HsDocContext
[PatCtx] :: HsDocContext
[SpecInstSigCtx] :: HsDocContext
[DefaultDeclCtx] :: HsDocContext
[ForeignDeclCtx] :: (Located RdrName) -> HsDocContext
[DerivDeclCtx] :: HsDocContext
[RuleCtx] :: FastString -> HsDocContext
[TyDataCtx] :: (Located RdrName) -> HsDocContext
[TySynCtx] :: (Located RdrName) -> HsDocContext
[TyFamilyCtx] :: (Located RdrName) -> HsDocContext
[ConDeclCtx] :: [Located RdrName] -> HsDocContext
[ClassDeclCtx] :: (Located RdrName) -> HsDocContext
[ExprWithTySigCtx] :: HsDocContext
[TypBrCtx] :: HsDocContext
[HsTypeCtx] :: HsDocContext
[GHCiCtx] :: HsDocContext
[SpliceTypeCtx] :: (LHsType RdrName) -> HsDocContext
[ClassInstanceCtx] :: HsDocContext
[VectDeclCtx] :: (Located RdrName) -> HsDocContext
[GenericCtx] :: SDoc -> HsDocContext
docOfHsDocContext :: HsDocContext -> SDoc

module RnNames

-- | Process Import Decls Do the non SOURCE ones first, so that we get a
--   helpful warning for SOURCE ones that are unnecessary
rnImports :: [LImportDecl RdrName] -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails, AnyHpcUsage)
getLocalNonValBinders :: MiniFixityEnv -> HsGroup RdrName -> RnM ((TcGblEnv, TcLclEnv), NameSet)
rnExports :: Bool -> Maybe (Located [LIE RdrName]) -> TcGblEnv -> RnM TcGblEnv
extendGlobalRdrEnvRn :: [AvailInfo] -> MiniFixityEnv -> RnM (TcGblEnv, TcLclEnv)

-- | make a <a>GlobalRdrEnv</a> where all the elements point to the same
--   Provenance (useful for "hiding" imports, or imports with no details).
gresFromAvails :: Provenance -> [AvailInfo] -> [GlobalRdrElt]

-- | Calculate the <a>ImportAvails</a> induced by an import of a particular
--   interface, but without <a>imp_mods</a>.
calculateAvails :: DynFlags -> ModIface -> IsSafeImport -> IsBootInterface -> ImportAvails
reportUnusedNames :: Maybe (Located [LIE RdrName]) -> TcGblEnv -> RnM ()
checkConName :: RdrName -> TcRn ()


-- | Dynamically lookup up values from modules and loading them.
module DynamicLoading
loadPlugins :: HscEnv -> IO [(ModuleName, Plugin, [CommandLineOption])]

-- | Force the interfaces for the given modules to be loaded. The
--   <a>SDoc</a> parameter is used for debugging (<tt>-ddump-if-trace</tt>)
--   only: it is shown as the reason why the module is being loaded.
forceLoadModuleInterfaces :: HscEnv -> SDoc -> [Module] -> IO ()

-- | Force the interface for the module containing the name to be loaded.
--   The <a>SDoc</a> parameter is used for debugging
--   (<tt>-ddump-if-trace</tt>) only: it is shown as the reason why the
--   module is being loaded.
forceLoadNameModuleInterface :: HscEnv -> SDoc -> Name -> IO ()

-- | Load the <a>TyCon</a> associated with the given name, come hell or
--   high water. Fails if:
--   
--   <ul>
--   <li>The interface could not be loaded</li>
--   <li>The name is not that of a <a>TyCon</a></li>
--   <li>The name did not exist in the loaded module</li>
--   </ul>
forceLoadTyCon :: HscEnv -> Name -> IO TyCon

-- | Finds the <a>Name</a> corresponding to the given <a>RdrName</a> in the
--   context of the <a>ModuleName</a>. Returns <tt>Nothing</tt> if no such
--   <a>Name</a> could be found. Any other condition results in an
--   exception:
--   
--   <ul>
--   <li>If the module could not be found</li>
--   <li>If we could not determine the imports of the module</li>
--   </ul>
--   
--   Can only be used for looking up names while loading plugins (and is
--   *not* suitable for use within plugins). The interface file is loaded
--   very partially: just enough that it can be used, without its rules and
--   instances affecting (and being linked from!) the module being
--   compiled. This was introduced by 57d6798.
--   
--   See Note [Care with plugin imports] in LoadIface.
lookupRdrNameInModuleForPlugins :: HscEnv -> ModuleName -> RdrName -> IO (Maybe Name)

-- | Loads the value corresponding to a <a>Name</a> if that value has the
--   given <a>Type</a>. This only provides limited safety in that it is up
--   to the user to ensure that that type corresponds to the type you try
--   to use the return value at!
--   
--   If the value found was not of the correct type, returns
--   <tt>Nothing</tt>. Any other condition results in an exception:
--   
--   <ul>
--   <li>If we could not load the names module</li>
--   <li>If the thing being loaded is not a value</li>
--   <li>If the Name does not exist in the module</li>
--   <li>If the link failed</li>
--   </ul>
getValueSafely :: HscEnv -> Name -> Type -> IO (Maybe a)
getHValueSafely :: HscEnv -> Name -> Type -> IO (Maybe HValue)

-- | Coerce a value as usual, but:
--   
--   1) Evaluate it immediately to get a segfault early if the coercion was
--   wrong
--   
--   2) Wrap it in some debug messages at verbosity 3 or higher so we can
--   see what happened if it <i>does</i> segfault
lessUnsafeCoerce :: DynFlags -> String -> a -> IO b

module RnTypes
rnHsType :: HsDocContext -> HsType RdrName -> RnM (HsType Name, FreeVars)
rnLHsType :: HsDocContext -> LHsType RdrName -> RnM (LHsType Name, FreeVars)
rnLHsTypes :: HsDocContext -> [LHsType RdrName] -> RnM ([LHsType Name], FreeVars)
rnContext :: HsDocContext -> LHsContext RdrName -> RnM (LHsContext Name, FreeVars)
rnHsKind :: HsDocContext -> HsKind RdrName -> RnM (HsKind Name, FreeVars)
rnLHsKind :: HsDocContext -> LHsKind RdrName -> RnM (LHsKind Name, FreeVars)
rnLHsMaybeKind :: HsDocContext -> Maybe (LHsKind RdrName) -> RnM (Maybe (LHsKind Name), FreeVars)
rnHsSigType :: SDoc -> LHsType RdrName -> RnM (LHsType Name, FreeVars)
rnLHsInstType :: SDoc -> LHsType RdrName -> RnM (LHsType Name, FreeVars)
rnConDeclFields :: HsDocContext -> [LConDeclField RdrName] -> RnM ([LConDeclField Name], FreeVars)
newTyVarNameRn :: Maybe a -> LocalRdrEnv -> SrcSpan -> RdrName -> RnM Name
mkOpAppRn :: LHsExpr Name -> LHsExpr Name -> Fixity -> LHsExpr Name -> RnM (HsExpr Name)
mkNegAppRn :: LHsExpr id -> SyntaxExpr id -> RnM (HsExpr id)
mkOpFormRn :: LHsCmdTop Name -> LHsExpr Name -> Fixity -> LHsCmdTop Name -> RnM (HsCmd Name)
mkConOpPatRn :: Located Name -> Fixity -> LPat Name -> LPat Name -> RnM (Pat Name)
checkPrecMatch :: Name -> MatchGroup Name body -> RnM ()
checkSectionPrec :: FixityDirection -> HsExpr RdrName -> LHsExpr Name -> LHsExpr Name -> RnM ()
warnContextQuantification :: SDoc -> [LHsTyVarBndr RdrName] -> TcM ()
warnUnusedForAlls :: SDoc -> LHsTyVarBndrs RdrName -> [RdrName] -> TcM ()
bindSigTyVarsFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
bindHsTyVars :: HsDocContext -> Maybe a -> [RdrName] -> LHsTyVarBndrs RdrName -> (LHsTyVarBndrs Name -> RnM (b, FreeVars)) -> RnM (b, FreeVars)
rnHsBndrSig :: HsDocContext -> HsWithBndrs RdrName (LHsType RdrName) -> (HsWithBndrs Name (LHsType Name) -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
extractHsTyRdrTyVars :: LHsType RdrName -> FreeKiTyVars
extractHsTysRdrTyVars :: [LHsType RdrName] -> FreeKiTyVars
extractRdrKindSigVars :: Maybe (LHsKind RdrName) -> [RdrName]
extractDataDefnKindVars :: HsDataDefn RdrName -> [RdrName]

-- | Replace all unnamed wildcards in the given type with named wildcards.
--   These names are freshly generated, based on "_". Return a tuple of the
--   named wildcards that weren't already in scope (amongst them the named
--   wildcards the unnamed ones were converted into), and the type in which
--   the unnamed wildcards are replaced by named wildcards.
extractWildcards :: LHsType RdrName -> RnM ([Located RdrName], LHsType RdrName)
filterInScope :: LocalRdrEnv -> FreeKiTyVars -> FreeKiTyVars

module RnPat
rnPat :: HsMatchContext Name -> LPat RdrName -> (LPat Name -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
rnPats :: HsMatchContext Name -> [LPat RdrName] -> ([LPat Name] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
rnBindPat :: NameMaker -> LPat RdrName -> RnM (LPat Name, FreeVars)
rnPatAndThen :: NameMaker -> Pat RdrName -> CpsRn (Pat Name)
data NameMaker
applyNameMaker :: NameMaker -> Located RdrName -> RnM (Located Name)
localRecNameMaker :: MiniFixityEnv -> NameMaker
topRecNameMaker :: MiniFixityEnv -> NameMaker
isTopRecNameMaker :: NameMaker -> Bool
rnHsRecFields :: HsRecFieldContext -> (RdrName -> arg) -> HsRecFields RdrName (Located arg) -> RnM ([LHsRecField Name (Located arg)], FreeVars)
data HsRecFieldContext
[HsRecFieldCon] :: Name -> HsRecFieldContext
[HsRecFieldPat] :: Name -> HsRecFieldContext
[HsRecFieldUpd] :: HsRecFieldContext
data CpsRn b
liftCps :: RnM a -> CpsRn a
rnLit :: HsLit -> RnM ()
rnOverLit :: HsOverLit t -> RnM (HsOverLit Name, FreeVars)
checkTupSize :: Int -> RnM ()
patSigErr :: Outputable a => a -> SDoc
instance Functor CpsRn
instance Applicative CpsRn
instance Monad CpsRn

module RnBinds
rnTopBindsLHS :: MiniFixityEnv -> HsValBinds RdrName -> RnM (HsValBindsLR Name RdrName)
rnTopBindsRHS :: NameSet -> HsValBindsLR Name RdrName -> RnM (HsValBinds Name, DefUses)
rnValBindsRHS :: HsSigCtxt -> HsValBindsLR Name RdrName -> RnM (HsValBinds Name, DefUses)
rnLocalBindsAndThen :: HsLocalBinds RdrName -> (HsLocalBinds Name -> RnM (result, FreeVars)) -> RnM (result, FreeVars)
rnLocalValBindsLHS :: MiniFixityEnv -> HsValBinds RdrName -> RnM ([Name], HsValBindsLR Name RdrName)
rnLocalValBindsRHS :: NameSet -> HsValBindsLR Name RdrName -> RnM (HsValBinds Name, DefUses)
rnMethodBinds :: Name -> (Name -> [Name]) -> LHsBinds RdrName -> RnM (LHsBinds Name, FreeVars)
renameSigs :: HsSigCtxt -> [LSig RdrName] -> RnM ([LSig Name], FreeVars)
mkSigTvFn :: [LSig Name] -> (Name -> [Name])
rnMatchGroup :: Outputable (body RdrName) => HsMatchContext Name -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars)) -> MatchGroup RdrName (Located (body RdrName)) -> RnM (MatchGroup Name (Located (body Name)), FreeVars)
rnGRHSs :: HsMatchContext Name -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars)) -> GRHSs RdrName (Located (body RdrName)) -> RnM (GRHSs Name (Located (body Name)), FreeVars)
rnGRHS :: HsMatchContext Name -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars)) -> LGRHS RdrName (Located (body RdrName)) -> RnM (LGRHS Name (Located (body Name)), FreeVars)
makeMiniFixityEnv :: [LFixitySig RdrName] -> RnM MiniFixityEnv
type MiniFixityEnv = FastStringEnv (Located Fixity)
data HsSigCtxt
[TopSigCtxt] :: NameSet -> Bool -> HsSigCtxt
[LocalBindCtxt] :: NameSet -> HsSigCtxt
[ClsDeclCtxt] :: Name -> HsSigCtxt
[InstDeclCtxt] :: Name -> HsSigCtxt
[HsBootCtxt] :: HsSigCtxt

module RnSource
rnSrcDecls :: [Name] -> HsGroup RdrName -> RnM (TcGblEnv, HsGroup Name)
addTcgDUs :: TcGblEnv -> DefUses -> TcGblEnv
rnTyClDecls :: [Name] -> [TyClGroup RdrName] -> RnM ([TyClGroup Name], FreeVars)
findSplice :: [LHsDecl RdrName] -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))

module TcTypeNats
typeNatTyCons :: [TyCon]
typeNatCoAxiomRules :: Map FastString CoAxiomRule
data BuiltInSynFamily
[BuiltInSynFamily] :: ([Type] -> Maybe (CoAxiomRule, [Type], Type)) -> ([Type] -> Type -> [Eqn]) -> ([Type] -> Type -> [Type] -> Type -> [Eqn]) -> BuiltInSynFamily
[sfMatchFam] :: BuiltInSynFamily -> [Type] -> Maybe (CoAxiomRule, [Type], Type)
[sfInteractTop] :: BuiltInSynFamily -> [Type] -> Type -> [Eqn]
[sfInteractInert] :: BuiltInSynFamily -> [Type] -> Type -> [Type] -> Type -> [Eqn]
typeNatAddTyCon :: TyCon
typeNatMulTyCon :: TyCon
typeNatExpTyCon :: TyCon
typeNatLeqTyCon :: TyCon
typeNatSubTyCon :: TyCon
typeNatCmpTyCon :: TyCon
typeSymbolCmpTyCon :: TyCon

module TcIface
tcLookupImported_maybe :: Name -> TcM (MaybeErr MsgDoc TyThing)
importDecl :: Name -> IfM lcl (MaybeErr MsgDoc TyThing)
checkWiredInTyCon :: TyCon -> TcM ()
tcHiBootIface :: HscSource -> Module -> TcRn ModDetails
typecheckIface :: ModIface -> TcRnIf gbl lcl ModDetails
tcIfaceDecl :: Bool -> IfaceDecl -> IfL TyThing
tcIfaceInst :: IfaceClsInst -> IfL ClsInst
tcIfaceFamInst :: IfaceFamInst -> IfL FamInst
tcIfaceRules :: Bool -> [IfaceRule] -> IfL [CoreRule]
tcIfaceVectInfo :: Module -> TypeEnv -> IfaceVectInfo -> IfL VectInfo
tcIfaceAnnotations :: [IfaceAnnotation] -> IfL [Annotation]
tcIfaceExpr :: IfaceExpr -> IfL CoreExpr
tcIfaceGlobal :: Name -> IfL TyThing

module DsMonad
type DsM = TcRnIf DsGblEnv DsLclEnv

-- | Map each element of a structure to a monadic action, evaluate these
--   actions from left to right, and collect the results. For a version
--   that ignores the results see <a>mapM_</a>.
mapM :: Traversable t => forall a (m :: * -> *) b. Monad m => (a -> m b) -> t a -> m (t b)

-- | The <a>mapAndUnzipM</a> function maps its first argument over a list,
--   returning the result as a pair of lists. This function is mainly used
--   with complicated data structures or a state-transforming monad.
mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c])
initDs :: HscEnv -> Module -> GlobalRdrEnv -> TypeEnv -> FamInstEnv -> DsM a -> IO (Messages, Maybe a)
initDsTc :: DsM a -> TcM a
fixDs :: (a -> DsM a) -> DsM a

-- | Monadic version of foldl
foldlM :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a

-- | Monadic version of foldr
foldrM :: (Monad m) => (b -> a -> m a) -> a -> [b] -> m a
whenGOptM :: GeneralFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
unsetGOptM :: GeneralFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
unsetWOptM :: WarningFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

-- | A functor with application, providing operations to
--   
--   <ul>
--   <li>embed pure expressions (<a>pure</a>), and</li>
--   <li>sequence computations and combine their results
--   (<a>&lt;*&gt;</a>).</li>
--   </ul>
--   
--   A minimal complete definition must include implementations of these
--   functions satisfying the following laws:
--   
--   <ul>
--   <li><i><i>identity</i></i> <pre><a>pure</a> <a>id</a> <a>&lt;*&gt;</a>
--   v = v</pre></li>
--   <li><i><i>composition</i></i> <pre><a>pure</a> (.) <a>&lt;*&gt;</a> u
--   <a>&lt;*&gt;</a> v <a>&lt;*&gt;</a> w = u <a>&lt;*&gt;</a> (v
--   <a>&lt;*&gt;</a> w)</pre></li>
--   <li><i><i>homomorphism</i></i> <pre><a>pure</a> f <a>&lt;*&gt;</a>
--   <a>pure</a> x = <a>pure</a> (f x)</pre></li>
--   <li><i><i>interchange</i></i> <pre>u <a>&lt;*&gt;</a> <a>pure</a> y =
--   <a>pure</a> (<a>$</a> y) <a>&lt;*&gt;</a> u</pre></li>
--   </ul>
--   
--   The other methods have the following default definitions, which may be
--   overridden with equivalent specialized implementations:
--   
--   <ul>
--   <li><pre>u <a>*&gt;</a> v = <a>pure</a> (<a>const</a> <a>id</a>)
--   <a>&lt;*&gt;</a> u <a>&lt;*&gt;</a> v</pre></li>
--   <li><pre>u <a>&lt;*</a> v = <a>pure</a> <a>const</a> <a>&lt;*&gt;</a>
--   u <a>&lt;*&gt;</a> v</pre></li>
--   </ul>
--   
--   As a consequence of these laws, the <a>Functor</a> instance for
--   <tt>f</tt> will satisfy
--   
--   <ul>
--   <li><pre><a>fmap</a> f x = <a>pure</a> f <a>&lt;*&gt;</a> x</pre></li>
--   </ul>
--   
--   If <tt>f</tt> is also a <a>Monad</a>, it should satisfy
--   
--   <ul>
--   <li><pre><a>pure</a> = <a>return</a></pre></li>
--   <li><pre>(<a>&lt;*&gt;</a>) = <a>ap</a></pre></li>
--   </ul>
--   
--   (which implies that <a>pure</a> and <a>&lt;*&gt;</a> satisfy the
--   applicative functor laws).
class Functor f => Applicative (f :: * -> *)
pure :: Applicative f => a -> f a
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
(*>) :: Applicative f => f a -> f b -> f b
(<*) :: Applicative f => f a -> f b -> f a

-- | An infix synonym for <a>fmap</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Convert from a <tt><tt>Maybe</tt> <tt>Int</tt></tt> to a
--   <tt><tt>Maybe</tt> <tt>String</tt></tt> using <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Nothing
--   Nothing
--   
--   &gt;&gt;&gt; show &lt;$&gt; Just 3
--   Just "3"
--   </pre>
--   
--   Convert from an <tt><tt>Either</tt> <tt>Int</tt> <tt>Int</tt></tt> to
--   an <tt><tt>Either</tt> <tt>Int</tt></tt> <tt>String</tt> using
--   <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Left 17
--   Left 17
--   
--   &gt;&gt;&gt; show &lt;$&gt; Right 17
--   Right "17"
--   </pre>
--   
--   Double each element of a list:
--   
--   <pre>
--   &gt;&gt;&gt; (*2) &lt;$&gt; [1,2,3]
--   [2,4,6]
--   </pre>
--   
--   Apply <tt>even</tt> to the second element of a pair:
--   
--   <pre>
--   &gt;&gt;&gt; even &lt;$&gt; (2,2)
--   (2,True)
--   </pre>
(<$>) :: Functor f => (a -> b) -> f a -> f b
newLocalName :: Name -> TcM Name
duplicateLocalDs :: Id -> DsM Id
newSysLocalDs :: Type -> DsM Id
newSysLocalsDs :: [Type] -> DsM [Id]
newUniqueId :: Id -> Type -> DsM Id
newFailLocalDs :: Type -> DsM Id
newPredVarDs :: PredType -> DsM Var
getSrcSpanDs :: DsM SrcSpan
putSrcSpanDs :: SrcSpan -> DsM a -> DsM a
mkPrintUnqualifiedDs :: DsM PrintUnqualified
newUnique :: TcRnIf gbl lcl Unique

-- | A value of type <a>UniqSupply</a> is unique, and it can supply
--   <i>one</i> distinct <a>Unique</a>. Also, from the supply, one can also
--   manufacture an arbitrary number of further <tt>UniqueSupply</tt>
--   values, which will be distinct from the first and from all others.
data UniqSupply
newUniqueSupply :: TcRnIf gbl lcl UniqSupply
getGhcModeDs :: DsM GhcMode
dsGetFamInstEnvs :: DsM FamInstEnvs

-- | Gets a reference to the SPT entries created so far.
dsGetStaticBindsVar :: DsM (IORef [(Fingerprint, (Id, CoreExpr))])
dsLookupGlobal :: Name -> DsM TyThing
dsLookupGlobalId :: Name -> DsM Id

-- | Get a name from <a>Data.Array.Parallel</a> for the desugarer, from the
--   <a>ds_parr_bi</a> component of the global desugerar environment.
dsDPHBuiltin :: (PArrBuiltin -> a) -> DsM a
dsLookupTyCon :: Name -> DsM TyCon
dsLookupDataCon :: Name -> DsM DataCon
data PArrBuiltin
[PArrBuiltin] :: Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> Var -> PArrBuiltin

-- | lengthP
[lengthPVar] :: PArrBuiltin -> Var

-- | replicateP
[replicatePVar] :: PArrBuiltin -> Var

-- | singletonP
[singletonPVar] :: PArrBuiltin -> Var

-- | mapP
[mapPVar] :: PArrBuiltin -> Var

-- | filterP
[filterPVar] :: PArrBuiltin -> Var

-- | zipP
[zipPVar] :: PArrBuiltin -> Var

-- | crossMapP
[crossMapPVar] :: PArrBuiltin -> Var

-- | (!:)
[indexPVar] :: PArrBuiltin -> Var

-- | emptyP
[emptyPVar] :: PArrBuiltin -> Var

-- | (+:+)
[appPVar] :: PArrBuiltin -> Var

-- | enumFromToP
[enumFromToPVar] :: PArrBuiltin -> Var

-- | enumFromThenToP
[enumFromThenToPVar] :: PArrBuiltin -> Var

-- | Lookup a name exported by <a>Prim</a> or <a>Prim</a>. Panic if there
--   isn't one, or if it is defined multiple times.
dsLookupDPHRdrEnv :: OccName -> DsM Name

-- | Lookup a name exported by <a>Prim</a> or <a>Prim</a>, returning
--   <a>Nothing</a> if it's not defined. Panic if it's defined multiple
--   times.
dsLookupDPHRdrEnv_maybe :: OccName -> DsM (Maybe Name)
dsInitPArrBuiltin :: DsM a -> DsM a
type DsMetaEnv = NameEnv DsMetaVal
data DsMetaVal
[DsBound] :: Id -> DsMetaVal
[DsSplice] :: (HsExpr Id) -> DsMetaVal
dsGetMetaEnv :: DsM (NameEnv DsMetaVal)
dsLookupMetaEnv :: Name -> DsM (Maybe DsMetaVal)
dsExtendMetaEnv :: DsMetaEnv -> DsM a -> DsM a
type DsWarning = (SrcSpan, SDoc)
warnDs :: SDoc -> DsM ()
failWithDs :: SDoc -> DsM a
discardWarningsDs :: DsM a -> DsM a
data DsMatchContext
[DsMatchContext] :: (HsMatchContext Name) -> SrcSpan -> DsMatchContext
data EquationInfo
[EqnInfo] :: [Pat Id] -> MatchResult -> EquationInfo
[eqn_pats] :: EquationInfo -> [Pat Id]
[eqn_rhs] :: EquationInfo -> MatchResult
data MatchResult
[MatchResult] :: CanItFail -> (CoreExpr -> DsM CoreExpr) -> MatchResult
type DsWrapper = CoreExpr -> CoreExpr
idDsWrapper :: DsWrapper
data CanItFail
[CanFail] :: CanItFail
[CantFail] :: CanItFail
orFail :: CanItFail -> CanItFail -> CanItFail
instance Outputable EquationInfo
instance MonadThings (IOEnv (Env DsGblEnv DsLclEnv))


-- | Utility functions for constructing Core syntax, principally for
--   desugaring
module DsUtils
data EquationInfo
[EqnInfo] :: [Pat Id] -> MatchResult -> EquationInfo
[eqn_pats] :: EquationInfo -> [Pat Id]
[eqn_rhs] :: EquationInfo -> MatchResult
firstPat :: EquationInfo -> Pat Id
shiftEqns :: [EquationInfo] -> [EquationInfo]
data MatchResult
[MatchResult] :: CanItFail -> (CoreExpr -> DsM CoreExpr) -> MatchResult
data CanItFail
[CanFail] :: CanItFail
[CantFail] :: CanItFail
data CaseAlt a
[MkCaseAlt] :: a -> [CoreBndr] -> HsWrapper -> MatchResult -> CaseAlt a
[alt_pat] :: CaseAlt a -> a
[alt_bndrs] :: CaseAlt a -> [CoreBndr]
[alt_wrapper] :: CaseAlt a -> HsWrapper
[alt_result] :: CaseAlt a -> MatchResult
cantFailMatchResult :: CoreExpr -> MatchResult
alwaysFailMatchResult :: MatchResult
extractMatchResult :: MatchResult -> CoreExpr -> DsM CoreExpr
combineMatchResults :: MatchResult -> MatchResult -> MatchResult
adjustMatchResult :: DsWrapper -> MatchResult -> MatchResult
adjustMatchResultDs :: (CoreExpr -> DsM CoreExpr) -> MatchResult -> MatchResult
mkCoLetMatchResult :: CoreBind -> MatchResult -> MatchResult
mkViewMatchResult :: Id -> CoreExpr -> Id -> MatchResult -> MatchResult
mkGuardedMatchResult :: CoreExpr -> MatchResult -> MatchResult
matchCanFail :: MatchResult -> Bool
mkEvalMatchResult :: Id -> Type -> MatchResult -> MatchResult
mkCoPrimCaseMatchResult :: Id -> Type -> [(Literal, MatchResult)] -> MatchResult
mkCoAlgCaseMatchResult :: DynFlags -> Id -> Type -> [CaseAlt DataCon] -> MatchResult
mkCoSynCaseMatchResult :: Id -> Type -> CaseAlt PatSyn -> MatchResult
wrapBind :: Var -> Var -> CoreExpr -> CoreExpr
wrapBinds :: [(Var, Var)] -> CoreExpr -> CoreExpr
mkErrorAppDs :: Id -> Type -> SDoc -> DsM CoreExpr
mkCoreAppDs :: CoreExpr -> CoreExpr -> CoreExpr
mkCoreAppsDs :: CoreExpr -> [CoreExpr] -> CoreExpr
seqVar :: Var -> CoreExpr -> CoreExpr
mkLHsVarPatTup :: [Id] -> LPat Id
mkLHsPatTup :: [LPat Id] -> LPat Id
mkVanillaTuplePat :: [OutPat Id] -> Boxity -> Pat Id
mkBigLHsVarTup :: [Id] -> LHsExpr Id
mkBigLHsTup :: [LHsExpr Id] -> LHsExpr Id
mkBigLHsVarPatTup :: [Id] -> LPat Id
mkBigLHsPatTup :: [LPat Id] -> LPat Id
mkSelectorBinds :: [[Tickish Id]] -> LPat Id -> CoreExpr -> DsM [(Id, CoreExpr)]
selectSimpleMatchVarL :: LPat Id -> DsM Id
selectMatchVars :: [Pat Id] -> DsM [Id]
selectMatchVar :: Pat Id -> DsM Id
mkOptTickBox :: [Tickish Id] -> CoreExpr -> CoreExpr
mkBinaryTickBox :: Int -> Int -> CoreExpr -> DsM CoreExpr

module MatchLit
dsLit :: HsLit -> DsM CoreExpr
dsOverLit :: HsOverLit Id -> DsM CoreExpr
hsLitKey :: DynFlags -> HsLit -> Literal
hsOverLitKey :: OutputableBndr a => HsOverLit a -> Bool -> Literal
tidyLitPat :: HsLit -> Pat Id
tidyNPat :: (HsLit -> Pat Id) -> HsOverLit Id -> Maybe (SyntaxExpr Id) -> SyntaxExpr Id -> Pat Id
matchLiterals :: [Id] -> Type -> [[EquationInfo]] -> DsM MatchResult
matchNPlusKPats :: [Id] -> Type -> [EquationInfo] -> DsM MatchResult
matchNPats :: [Id] -> Type -> [EquationInfo] -> DsM MatchResult
warnAboutIdentities :: DynFlags -> CoreExpr -> Type -> DsM ()
warnAboutEmptyEnumerations :: DynFlags -> LHsExpr Id -> Maybe (LHsExpr Id) -> LHsExpr Id -> DsM ()

module Check
check :: [EquationInfo] -> ([ExhaustivePat], [EquationInfo])
type ExhaustivePat = ([WarningPat], [(Name, [HsLit])])

module DsGRHSs
dsGuarded :: GRHSs Id (LHsExpr Id) -> Type -> DsM CoreExpr
dsGRHSs :: HsMatchContext Name -> [Pat Id] -> GRHSs Id (LHsExpr Id) -> Type -> DsM MatchResult
dsGRHS :: HsMatchContext Name -> Type -> LGRHS Id (LHsExpr Id) -> DsM MatchResult

module DsBinds
dsTopLHsBinds :: LHsBinds Id -> DsM (OrdList (Id, CoreExpr))
dsLHsBinds :: LHsBinds Id -> DsM [(Id, CoreExpr)]
decomposeRuleLhs :: [Var] -> CoreExpr -> Either SDoc ([Var], Id, [CoreExpr])
dsSpec :: Maybe CoreExpr -> Located TcSpecPrag -> DsM (Maybe (OrdList (Id, CoreExpr), CoreRule))
dsHsWrapper :: HsWrapper -> CoreExpr -> DsM CoreExpr
dsTcEvBinds :: TcEvBinds -> DsM [CoreBind]
dsEvBinds :: Bag EvBind -> DsM [CoreBind]

module DsCCall
dsCCall :: CLabelString -> [CoreExpr] -> Safety -> Type -> DsM CoreExpr
mkFCall :: DynFlags -> Unique -> ForeignCall -> [CoreExpr] -> Type -> CoreExpr
unboxArg :: CoreExpr -> DsM (CoreExpr, CoreExpr -> CoreExpr)
boxResult :: Type -> DsM (Type, CoreExpr -> CoreExpr)
resultWrapper :: Type -> DsM (Maybe Type, CoreExpr -> CoreExpr)

module DsForeign
dsForeigns :: [LForeignDecl Id] -> DsM (ForeignStubs, OrdList Binding)
dsForeigns' :: [LForeignDecl Id] -> DsM (ForeignStubs, OrdList Binding)
dsFImport :: Id -> Coercion -> ForeignImport -> DsM ([Binding], SDoc, SDoc)
dsCImport :: Id -> Coercion -> CImportSpec -> CCallConv -> Safety -> Maybe Header -> DsM ([Binding], SDoc, SDoc)
dsFCall :: Id -> Coercion -> ForeignCall -> Maybe Header -> DsM ([(Id, Expr TyVar)], SDoc, SDoc)
dsPrimCall :: Id -> Coercion -> ForeignCall -> DsM ([(Id, Expr TyVar)], SDoc, SDoc)
dsFExport :: Id -> Coercion -> CLabelString -> CCallConv -> Bool -> DsM (SDoc, SDoc, String, Int)
dsFExportDynamic :: Id -> Coercion -> CCallConv -> DsM ([Binding], SDoc, SDoc)
mkFExportCBits :: DynFlags -> FastString -> Maybe Id -> [Type] -> Type -> Bool -> CCallConv -> (SDoc, SDoc, String, Int)
toCType :: Type -> (Maybe Header, SDoc)
foreignExportInitialiser :: Id -> SDoc

module DsMeta
dsBracket :: HsBracket Name -> [PendingTcSplice] -> DsM CoreExpr
templateHaskellNames :: [Name]
qTyConName :: Name
nameTyConName :: Name
liftName :: Name
liftStringName :: Name
expQTyConName :: Name
patQTyConName :: Name
decQTyConName :: Name
decsQTyConName :: Name
typeQTyConName :: Name
decTyConName :: Name
typeTyConName :: Name
mkNameG_dName :: Name
mkNameG_vName :: Name
mkNameG_tcName :: Name
quoteExpName :: Name
quotePatName :: Name
quoteDecName :: Name
quoteTypeName :: Name
tExpTyConName :: Name
tExpDataConName :: Name
unTypeName :: Name
unTypeQName :: Name
unsafeTExpCoerceName :: Name

module RnSplice
rnTopSpliceDecls :: HsSplice RdrName -> RnM ([LHsDecl RdrName], FreeVars)
rnSpliceType :: HsSplice RdrName -> PostTc Name Kind -> RnM (HsType Name, FreeVars)
rnSpliceExpr :: Bool -> HsSplice RdrName -> RnM (HsExpr Name, FreeVars)

-- | Rename a splice pattern. See Note [rnSplicePat]
rnSplicePat :: HsSplice RdrName -> RnM (Either (Pat RdrName) (Pat Name), FreeVars)
rnSpliceDecl :: SpliceDecl RdrName -> RnM (SpliceDecl Name, FreeVars)
rnBracket :: HsExpr RdrName -> HsBracket RdrName -> RnM (HsExpr Name, FreeVars)
checkThLocalName :: Name -> RnM ()

module RnExpr
rnLExpr :: LHsExpr RdrName -> RnM (LHsExpr Name, FreeVars)
rnExpr :: HsExpr RdrName -> RnM (HsExpr Name, FreeVars)
rnStmts :: Outputable (body RdrName) => HsStmtContext Name -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars)) -> [LStmt RdrName (Located (body RdrName))] -> ([Name] -> RnM (thing, FreeVars)) -> RnM (([LStmt Name (Located (body Name))], thing), FreeVars)

module MatchCon
matchConFamily :: [Id] -> Type -> [[EquationInfo]] -> DsM MatchResult
matchPatSyn :: [Id] -> Type -> [EquationInfo] -> DsM MatchResult

module Match
match :: [Id] -> Type -> [EquationInfo] -> DsM MatchResult
matchEquations :: HsMatchContext Name -> [Id] -> [EquationInfo] -> Type -> DsM CoreExpr
matchWrapper :: HsMatchContext Name -> MatchGroup Id (LHsExpr Id) -> DsM ([Id], CoreExpr)
matchSimply :: CoreExpr -> HsMatchContext Name -> LPat Id -> CoreExpr -> CoreExpr -> DsM CoreExpr
matchSinglePat :: CoreExpr -> HsMatchContext Name -> LPat Id -> Type -> MatchResult -> DsM MatchResult

module DsArrows
dsProcExpr :: LPat Id -> LHsCmdTop Id -> DsM CoreExpr

module DsListComp
dsListComp :: [ExprLStmt Id] -> Type -> DsM CoreExpr
dsPArrComp :: [ExprStmt Id] -> DsM CoreExpr
dsMonadComp :: [ExprLStmt Id] -> DsM CoreExpr

module DsExpr
dsExpr :: HsExpr Id -> DsM CoreExpr
dsLExpr :: LHsExpr Id -> DsM CoreExpr
dsLocalBinds :: HsLocalBinds Id -> CoreExpr -> DsM CoreExpr
dsValBinds :: HsValBinds Id -> CoreExpr -> DsM CoreExpr
dsLit :: HsLit -> DsM CoreExpr

module Desugar

-- | Main entry point to the desugarer.
deSugar :: HscEnv -> ModLocation -> TcGblEnv -> IO (Messages, Maybe ModGuts)
deSugarExpr :: HscEnv -> LHsExpr Id -> IO (Messages, Maybe CoreExpr)

module Vectorise.Builtins.Initialise

-- | Create the initial map of builtin types and functions.
initBuiltins :: DsM Builtins

-- | Get the mapping of names in the Prelude to names in the DPH library.
initBuiltinVars :: Builtins -> DsM [(Var, Var)]

module Vectorise.Builtins
mAX_DPH_SCALAR_ARGS :: Int

-- | Holds the names of the types and functions from <a>Prim</a> that are
--   used by the vectoriser.
data Builtins
[Builtins] :: TyCon -> TyCon -> TyCon -> Class -> TyCon -> TyCon -> Class -> TyCon -> DataCon -> Var -> Var -> NameEnv Var -> Var -> NameEnv Var -> Var -> NameEnv Var -> Array Int Var -> Array Int (NameEnv Var) -> Class -> Array Int Var -> TyCon -> Var -> Var -> Array Int TyCon -> TyCon -> Var -> Var -> TyCon -> Var -> Var -> Var -> Var -> Array Int Var -> Array Int Type -> Array Int Type -> Array Int CoreExpr -> Array Int CoreExpr -> Array Int CoreExpr -> Array (Int, Int) CoreExpr -> Var -> Builtins

-- | PArray
[parrayTyCon] :: Builtins -> TyCon

-- | PData
[pdataTyCon] :: Builtins -> TyCon

-- | PDatas
[pdatasTyCon] :: Builtins -> TyCon

-- | PR
[prClass] :: Builtins -> Class

-- | PR
[prTyCon] :: Builtins -> TyCon

-- | PRepr
[preprTyCon] :: Builtins -> TyCon

-- | PA
[paClass] :: Builtins -> Class

-- | PA
[paTyCon] :: Builtins -> TyCon

-- | PA
[paDataCon] :: Builtins -> DataCon

-- | PA
[paPRSel] :: Builtins -> Var

-- | replicatePD
[replicatePDVar] :: Builtins -> Var

-- | replicatePD_Int# etc.
[replicatePD_PrimVars] :: Builtins -> NameEnv Var

-- | emptyPD
[emptyPDVar] :: Builtins -> Var

-- | emptyPD_Int# etc.
[emptyPD_PrimVars] :: Builtins -> NameEnv Var

-- | packByTagPD
[packByTagPDVar] :: Builtins -> Var

-- | packByTagPD_Int# etc.
[packByTagPD_PrimVars] :: Builtins -> NameEnv Var

-- | combinePD
[combinePDVars] :: Builtins -> Array Int Var

-- | combine2PD_Int# etc.
[combinePD_PrimVarss] :: Builtins -> Array Int (NameEnv Var)

-- | Scalar
[scalarClass] :: Builtins -> Class

-- | map, zipWith, zipWith3
[scalarZips] :: Builtins -> Array Int Var

-- | Void
[voidTyCon] :: Builtins -> TyCon

-- | void
[voidVar] :: Builtins -> Var

-- | fromVoid
[fromVoidVar] :: Builtins -> Var

-- | Sum2 .. Sum3
[sumTyCons] :: Builtins -> Array Int TyCon

-- | Wrap
[wrapTyCon] :: Builtins -> TyCon

-- | pvoid
[pvoidVar] :: Builtins -> Var

-- | pvoids
[pvoidsVar] :: Builtins -> Var

-- | :-&gt;
[closureTyCon] :: Builtins -> TyCon

-- | closure
[closureVar] :: Builtins -> Var

-- | liftedClosure
[liftedClosureVar] :: Builtins -> Var

-- | $:
[applyVar] :: Builtins -> Var

-- | liftedApply
[liftedApplyVar] :: Builtins -> Var

-- | closure1 .. closure3
[closureCtrFuns] :: Builtins -> Array Int Var

-- | Sel2
[selTys] :: Builtins -> Array Int Type

-- | Sels2
[selsTys] :: Builtins -> Array Int Type

-- | lengthSels2
[selsLengths] :: Builtins -> Array Int CoreExpr

-- | replicate2
[selReplicates] :: Builtins -> Array Int CoreExpr

-- | tagsSel2
[selTagss] :: Builtins -> Array Int CoreExpr

-- | elementsSel2_0 .. elementsSel_2_1
[selElementss] :: Builtins -> Array (Int, Int) CoreExpr

-- | lc
[liftingContext] :: Builtins -> Var
selTy :: Int -> Builtins -> Type
selsTy :: Int -> Builtins -> Type
selReplicate :: Int -> Builtins -> CoreExpr
selTags :: Int -> Builtins -> CoreExpr
selElements :: Int -> Int -> Builtins -> CoreExpr
selsLength :: Int -> Builtins -> CoreExpr
sumTyCon :: Int -> Builtins -> TyCon
prodTyCon :: Int -> Builtins -> TyCon
prodDataCon :: Int -> Builtins -> DataCon
replicatePD_PrimVar :: TyCon -> Builtins -> Var
emptyPD_PrimVar :: TyCon -> Builtins -> Var
packByTagPD_PrimVar :: TyCon -> Builtins -> Var
combinePDVar :: Int -> Builtins -> Var
combinePD_PrimVar :: Int -> TyCon -> Builtins -> Var
scalarZip :: Int -> Builtins -> Var
closureCtrFun :: Int -> Builtins -> Var

-- | Create the initial map of builtin types and functions.
initBuiltins :: DsM Builtins

-- | Get the mapping of names in the Prelude to names in the DPH library.
initBuiltinVars :: Builtins -> DsM [(Var, Var)]


-- | The Vectorisation monad.
module Vectorise.Monad.Base

-- | Vectorisation can either succeed with new envionment and a value, or
--   return with failure (including a description of the reason for
--   failure).
data VResult a
[Yes] :: GlobalEnv -> LocalEnv -> a -> VResult a
[No] :: SDoc -> VResult a
newtype VM a
[VM] :: (Builtins -> GlobalEnv -> LocalEnv -> DsM (VResult a)) -> VM a
[runVM] :: VM a -> Builtins -> GlobalEnv -> LocalEnv -> DsM (VResult a)

-- | Lift a desugaring computation into the vectorisation monad.
liftDs :: DsM a -> VM a

-- | Throw a <a>pgmError</a> saying we can't vectorise something.
cantVectorise :: DynFlags -> String -> SDoc -> a

-- | Like <tt>fromJust</tt>, but <a>pgmError</a> on Nothing.
maybeCantVectorise :: DynFlags -> String -> SDoc -> Maybe a -> a

-- | Like <a>maybeCantVectorise</a> but in a <a>Monad</a>.
maybeCantVectoriseM :: (Monad m, HasDynFlags m) => String -> SDoc -> m (Maybe a) -> m a

-- | Output a trace message if -ddump-vt-trace is active.
emitVt :: String -> SDoc -> VM ()

-- | Output a trace message if -ddump-vt-trace is active.
traceVt :: String -> SDoc -> VM ()

-- | Dump the given program conditionally.
dumpOptVt :: DumpFlag -> String -> SDoc -> VM ()

-- | Dump the given program unconditionally.
dumpVt :: String -> SDoc -> VM ()

-- | Return some result saying we've failed.
noV :: SDoc -> VM a

-- | Like <a>traceNoV</a> but also emit some trace message to stderr.
traceNoV :: String -> SDoc -> VM a

-- | If <a>True</a> then carry on, otherwise fail.
ensureV :: SDoc -> Bool -> VM ()

-- | Like <a>ensureV</a> but if we fail then emit some trace message to
--   stderr.
traceEnsureV :: String -> SDoc -> Bool -> VM ()

-- | If <a>True</a> then return the first argument, otherwise fail.
onlyIfV :: SDoc -> Bool -> VM a -> VM a

-- | Try some vectorisation computaton.
--   
--   If it succeeds then return <a>Just</a> the result; otherwise, return
--   <a>Nothing</a> without emitting a failure message.
tryV :: VM a -> VM (Maybe a)

-- | Try some vectorisation computaton.
--   
--   If it succeeds then return <a>Just</a> the result; otherwise, return
--   <a>Nothing</a> after emitting a failure message.
tryErrV :: VM a -> VM (Maybe a)

-- | If <a>Just</a> then return the value, otherwise fail.
maybeV :: SDoc -> VM (Maybe a) -> VM a

-- | Like <a>maybeV</a> but emit a message to stderr if we fail.
traceMaybeV :: String -> SDoc -> VM (Maybe a) -> VM a

-- | Try the first computation,
--   
--   <ul>
--   <li>if it succeeds then take the returned value,</li>
--   <li>if it fails then run the second computation instead without
--   emitting a failure message.</li>
--   </ul>
orElseV :: VM a -> VM a -> VM a

-- | Try the first computation,
--   
--   <ul>
--   <li>if it succeeds then take the returned value,</li>
--   <li>if it fails then run the second computation instead while emitting
--   a failure message.</li>
--   </ul>
orElseErrV :: VM a -> VM a -> VM a

-- | Fixpoint in the vectorisation monad.
fixV :: (a -> VM a) -> VM a
instance Monad VM
instance Applicative VM
instance Functor VM
instance MonadIO VM
instance HasDynFlags VM

module Vectorise.Monad.Local

-- | Project something from the local environment.
readLEnv :: (LocalEnv -> a) -> VM a

-- | Set the local environment.
setLEnv :: LocalEnv -> VM ()

-- | Update the environment using the provided function.
updLEnv :: (LocalEnv -> LocalEnv) -> VM ()

-- | Perform a computation in its own local environment. This does not
--   alter the environment of the current state.
localV :: VM a -> VM a

-- | Perform a computation in an empty local environment.
closedV :: VM a -> VM a

-- | Get the name of the local binding currently being vectorised.
getBindName :: VM FastString

-- | Run a vectorisation computation in a local environment, with this id
--   set as the current binding.
inBind :: Id -> VM a -> VM a

-- | Lookup a PA tyvars from the local environment.
lookupTyVarPA :: Var -> VM (Maybe CoreExpr)

-- | Add a tyvar to the local environment.
defLocalTyVar :: TyVar -> VM ()

-- | Add mapping between a tyvar and pa dictionary to the local
--   environment.
defLocalTyVarWithPA :: TyVar -> CoreExpr -> VM ()

-- | Get the set of tyvars from the local environment.
localTyVars :: VM [TyVar]

module Vectorise.Monad.Global

-- | Project something from the global environment.
readGEnv :: (GlobalEnv -> a) -> VM a

-- | Set the value of the global environment.
setGEnv :: GlobalEnv -> VM ()

-- | Update the global environment using the provided function.
updGEnv :: (GlobalEnv -> GlobalEnv) -> VM ()

-- | Should we avoid as much vectorisation as possible?
--   
--   Set by '-f[no]-vectorisation-avoidance'
isVectAvoidanceAggressive :: VM Bool

-- | Add a mapping between a global var and its vectorised version to the
--   state.
defGlobalVar :: Var -> Var -> VM ()

-- | Remove the mapping of a variable in the vectorisation map.
undefGlobalVar :: Var -> VM ()

-- | Check whether a variable has a vectorisation declaration.
--   
--   The first component of the result indicates whether the variable has a
--   <tt>NOVECTORISE</tt> declaration. The second component contains the
--   given type and expression in case of a <tt>VECTORISE</tt> declaration.
lookupVectDecl :: Var -> VM (Bool, Maybe (Type, CoreExpr))

-- | Get the set of global parallel variables.
globalParallelVars :: VM VarSet

-- | Get the set of all parallel type constructors (those that may embed
--   parallelism) including both both those parallel type constructors
--   declared in an imported module and those declared in the current
--   module.
globalParallelTyCons :: VM NameSet

-- | Determine the vectorised version of a <a>TyCon</a>. The vectorisation
--   map in the global environment contains a vectorised version if the
--   original <a>TyCon</a> embeds any parallel arrays.
lookupTyCon :: TyCon -> VM (Maybe TyCon)

-- | Add a mapping between plain and vectorised <a>TyCon</a>s to the global
--   environment.
--   
--   The second argument is only to enable tracing for (mutually)
--   recursively defined type constructors, where we <i>must not</i> pull
--   at the vectorised type constructors (because that would pull too early
--   at the recursive knot).
defTyConName :: TyCon -> Name -> TyCon -> VM ()

-- | Add a mapping between plain and vectorised <a>TyCon</a>s to the global
--   environment.
defTyCon :: TyCon -> TyCon -> VM ()

-- | Get the set of all vectorised type constructors.
globalVectTyCons :: VM (NameEnv TyCon)

-- | Lookup the vectorised version of a <a>DataCon</a> from the global
--   environment.
lookupDataCon :: DataCon -> VM (Maybe DataCon)

-- | Add the mapping between plain and vectorised <a>DataCon</a>s to the
--   global environment.
defDataCon :: DataCon -> DataCon -> VM ()

-- | Lookup the <tt>PA</tt> dfun of a vectorised type constructor in the
--   global environment.
lookupTyConPA :: TyCon -> VM (Maybe Var)

-- | Associate vectorised type constructors with the dfun of their
--   <tt>PA</tt> instances in the global environment.
defTyConPAs :: [(TyCon, Var)] -> VM ()
lookupTyConPR :: TyCon -> VM (Maybe Var)

module Vectorise.Monad.InstEnv
existsInst :: Class -> [Type] -> VM Bool
lookupInst :: Class -> [Type] -> VM (DFunId, [Type])
lookupFamInst :: TyCon -> [Type] -> VM FamInstMatch


-- | Computations in the vectorisation monad concerned with naming and
--   fresh variable generation.
module Vectorise.Monad.Naming

-- | Create a localised variant of a name, using the provided function to
--   transform its <a>OccName</a>.
--   
--   If the name external, encode the orignal name's module into the new
--   <a>OccName</a>. The result is always an internal system name.
mkLocalisedName :: (Maybe String -> OccName -> OccName) -> Name -> VM Name
mkDerivedName :: (OccName -> OccName) -> Name -> VM Name

-- | Produce the vectorised variant of an <a>Id</a> with the given
--   vectorised type, while taking care that vectorised dfun ids must be
--   dfuns again.
--   
--   Force the new name to be a system name and, if the original was an
--   external name, disambiguate the new name with the module name of the
--   original.
mkVectId :: Id -> Type -> VM Id

-- | Make a fresh instance of this var, with a new unique.
cloneVar :: Var -> VM Var

-- | Make a fresh exported variable with the given type.
newExportedVar :: OccName -> Type -> VM Var

-- | Make a fresh local variable with the given type. The variable's name
--   is formed using the given string as the prefix.
newLocalVar :: FastString -> Type -> VM Var

-- | Make several fresh local variables with the given types. The
--   variable's names are formed using the given string as the prefix.
newLocalVars :: FastString -> [Type] -> VM [Var]

-- | Make a new local dummy variable.
newDummyVar :: Type -> VM Var

-- | Make a fresh type variable with the given kind. The variable's name is
--   formed using the given string as the prefix.
newTyVar :: FastString -> Kind -> VM Var

module Vectorise.Monad

-- | Run a vectorisation computation.
initV :: HscEnv -> ModGuts -> VectInfo -> VM a -> IO (Maybe (VectInfo, a))

-- | Lift a desugaring computation using the <a>Builtins</a> into the
--   vectorisation monad.
liftBuiltinDs :: (Builtins -> DsM a) -> VM a

-- | Project something from the set of builtins.
builtin :: (Builtins -> a) -> VM a

-- | Lift a function using the <a>Builtins</a> into the vectorisation
--   monad.
builtins :: (a -> Builtins -> b) -> VM (a -> b)

-- | Lookup the vectorised, and if local, also the lifted version of a
--   variable.
--   
--   <ul>
--   <li>If it's in the global environment we get the vectorised
--   version.</li>
--   <li>If it's in the local environment we get both the vectorised and
--   lifted version.</li>
--   </ul>
lookupVar :: Var -> VM (Scope Var (Var, Var))
lookupVar_maybe :: Var -> VM (Maybe (Scope Var (Var, Var)))

-- | Mark the given variable as parallel — i.e., executing the associated
--   code might involve parallel array computations.
addGlobalParallelVar :: Var -> VM ()

-- | Mark the given type constructor as parallel — i.e., its values might
--   embed parallel arrays.
addGlobalParallelTyCon :: TyCon -> VM ()

module Vectorise.Utils.Base
voidType :: VM Type
newLocalVVar :: FastString -> Type -> VM VVar
mkDataConTag :: DynFlags -> DataCon -> CoreExpr
dataConTagZ :: DataCon -> Int

-- | Make an application of the <tt>Wrap</tt> type constructor.
mkWrapType :: Type -> VM Type

-- | Make an application of the closure type constructor.
mkClosureTypes :: [Type] -> Type -> VM Type

-- | Make an application of the <tt>PRepr</tt> type constructor.
mkPReprType :: Type -> VM Type

-- | Make an appliction of the <tt>PData</tt> tycon to some argument.
mkPDataType :: Type -> VM Type

-- | Make an application of the <tt>PDatas</tt> tycon to some argument.
mkPDatasType :: Type -> VM Type

-- | Checks if a type constructor is defined in <a>Prim</a> (e.g., 'Int#');
--   if so, returns it.
splitPrimTyCon :: Type -> Maybe TyCon

-- | Make a representational coersion to some builtin type.
mkBuiltinCo :: (Builtins -> TyCon) -> VM Coercion

-- | Apply the constructor wrapper of the <tt>Wrap</tt> <i>newtype</i>.
wrapNewTypeBodyOfWrap :: CoreExpr -> Type -> VM CoreExpr

-- | Strip the constructor wrapper of the <tt>Wrap</tt> <i>newtype</i>.
unwrapNewTypeBodyOfWrap :: CoreExpr -> Type -> VM CoreExpr

-- | Apply the constructor wrapper of the <tt>PData</tt> <i>newtype</i>
--   instance of <tt>Wrap</tt>.
wrapNewTypeBodyOfPDataWrap :: CoreExpr -> Type -> VM CoreExpr

-- | Strip the constructor wrapper of the <tt>PData</tt> <i>newtype</i>
--   instance of <tt>Wrap</tt>.
unwrapNewTypeBodyOfPDataWrap :: CoreExpr -> Type -> VM CoreExpr

-- | Apply the constructor wrapper of the <tt>PDatas</tt> <i>newtype</i>
--   instance of <tt>Wrap</tt>.
wrapNewTypeBodyOfPDatasWrap :: CoreExpr -> Type -> VM CoreExpr

-- | Strip the constructor wrapper of the <tt>PDatas</tt> <i>newtype</i>
--   instance of <tt>Wrap</tt>.
unwrapNewTypeBodyOfPDatasWrap :: CoreExpr -> Type -> VM CoreExpr

-- | Get the representation tycon of the <tt>PData</tt> data family for a
--   given type.
--   
--   This tycon does not appear explicitly in the source program — see Note
--   [PData TyCons] in <a>Description</a>:
--   
--   <pre>
--   pdataReprTyCon {Sum2} = {PDataSum2}
--   </pre>
--   
--   The type for which we look up a <tt>PData</tt> instance may be more
--   specific than the type in the instance declaration. In that case the
--   second component of the result will be more specific than a set of
--   distinct type variables.
pdataReprTyCon :: Type -> VM (TyCon, [Type])

-- | Get the representation tycon of the <tt>PData</tt> data family for a
--   given type constructor.
--   
--   For example, for a binary type constructor <tt>T</tt>, we determine
--   the representation type constructor for 'PData (T a b)'.
pdataReprTyConExact :: TyCon -> VM TyCon

-- | Get the representation tycon of the <tt>PDatas</tt> data family for a
--   given type constructor.
--   
--   For example, for a binary type constructor <tt>T</tt>, we determine
--   the representation type constructor for 'PDatas (T a b)'.
pdatasReprTyConExact :: TyCon -> VM TyCon

-- | Unwrap a <tt>PData</tt> representation scrutinee.
pdataUnwrapScrut :: VExpr -> VM (CoreExpr, CoreExpr, DataCon)

-- | Get the representation tycon of the <tt>PRepr</tt> type family for a
--   given type.
preprFamInst :: Type -> VM FamInstMatch

module FamInst
type FamInstEnvs = (FamInstEnv, FamInstEnv)
tcGetFamInstEnvs :: TcM FamInstEnvs
checkFamInstConsistency :: [Module] -> [Module] -> TcM ()
tcExtendLocalFamInstEnv :: [FamInst] -> TcM a -> TcM a
tcLookupFamInst :: FamInstEnvs -> TyCon -> [Type] -> Maybe FamInstMatch

-- | Like <a>tcLookupDataFamInst_maybe</a>, but returns the arguments back
--   if there is no data family to unwrap.
tcLookupDataFamInst :: FamInstEnvs -> TyCon -> [TcType] -> (TyCon, [TcType], TcCoercion)

-- | Converts a data family type (eg F [a]) to its representation type (eg
--   FList a) and returns a coercion between the two: co :: F [a] ~R FList
--   a
tcLookupDataFamInst_maybe :: FamInstEnvs -> TyCon -> [TcType] -> Maybe (TyCon, [TcType], Coercion)

-- | If <tt>co :: T ts ~ rep_ty</tt> then:
--   
--   <pre>
--   instNewTyCon_maybe T ts = Just (rep_ty, co)
--   </pre>
--   
--   Checks for a newtype, and for being saturated Just like
--   Coercion.instNewTyCon_maybe, but returns a TcCoercion
tcInstNewTyCon_maybe :: TyCon -> [TcType] -> Maybe (TcType, TcCoercion)

-- | Get rid of top-level newtypes, potentially looking through newtype
--   instances. Only unwraps newtypes that are in scope. This is used for
--   solving for <tt>Coercible</tt> in the solver. This version is careful
--   not to unwrap data/newtype instances if it can't continue unwrapping.
--   Such care is necessary for proper error messages.
--   
--   Does not look through type families. Does not normalise arguments to a
--   tycon.
--   
--   Always produces a representational coercion.
tcTopNormaliseNewTypeTF_maybe :: FamInstEnvs -> GlobalRdrEnv -> Type -> Maybe (TcCoercion, Type)
newFamInst :: FamFlavor -> CoAxiom Unbranched -> TcRnIf gbl lcl FamInst
instance Eq ModulePair
instance Ord ModulePair
instance Outputable ModulePair

module TcSMonad
data WorkList
[WL] :: [Ct] -> [Ct] -> [Ct] -> Bag Implication -> WorkList
[wl_eqs] :: WorkList -> [Ct]
[wl_funeqs] :: WorkList -> [Ct]
[wl_rest] :: WorkList -> [Ct]
[wl_implics] :: WorkList -> Bag Implication
isEmptyWorkList :: WorkList -> Bool
emptyWorkList :: WorkList
extendWorkListNonEq :: Ct -> WorkList -> WorkList
extendWorkListCt :: Ct -> WorkList -> WorkList
extendWorkListCts :: [Ct] -> WorkList -> WorkList
appendWorkList :: WorkList -> WorkList -> WorkList
selectWorkItem :: WorkList -> (Maybe Ct, WorkList)
workListSize :: WorkList -> Int
updWorkListTcS :: (WorkList -> WorkList) -> TcS ()
updWorkListTcS_return :: (WorkList -> (a, WorkList)) -> TcS a
runFlatten :: TcS a -> TcS a
emitFlatWork :: Ct -> TcS ()
data TcS a
runTcS :: TcS a -> TcM (a, Bag EvBind)
runTcSWithEvBinds :: EvBindsVar -> TcS a -> TcM a
failTcS :: SDoc -> TcS a
tryTcS :: TcS a -> TcS a
nestTcS :: TcS a -> TcS a
nestImplicTcS :: EvBindsVar -> TcLevel -> TcS a -> TcS a
recoverTcS :: TcS a -> TcS a -> TcS a
runTcPluginTcS :: TcPluginM a -> TcS a
addUsedRdrNamesTcS :: [RdrName] -> TcS ()
deferTcSForAllEq :: Role -> CtLoc -> ([TyVar], TcType) -> ([TyVar], TcType) -> TcS EvTerm
panicTcS :: SDoc -> TcS a
traceTcS :: String -> SDoc -> TcS ()
traceFireTcS :: CtEvidence -> SDoc -> TcS ()
bumpStepCountTcS :: TcS ()
csTraceTcS :: SDoc -> TcS ()
wrapErrTcS :: TcM a -> TcS a
wrapWarnTcS :: TcM a -> TcS a
data XEvTerm
[XEvTerm] :: [PredType] -> ([EvTerm] -> EvTerm) -> (EvTerm -> [EvTerm]) -> XEvTerm
[ev_preds] :: XEvTerm -> [PredType]
[ev_comp] :: XEvTerm -> [EvTerm] -> EvTerm
[ev_decomp] :: XEvTerm -> EvTerm -> [EvTerm]
data Freshness
[Fresh] :: Freshness
[Cached] :: Freshness
freshGoals :: [(CtEvidence, Freshness)] -> [CtEvidence]
isFresh :: Freshness -> Bool
newTcEvBinds :: TcS EvBindsVar
newWantedEvVar :: CtLoc -> TcPredType -> TcS (CtEvidence, Freshness)
newWantedEvVarNC :: CtLoc -> TcPredType -> TcS CtEvidence
setWantedTyBind :: TcTyVar -> TcType -> TcS ()
reportUnifications :: TcS a -> TcS (Bool, a)
setEvBind :: EvVar -> EvTerm -> TcS ()
newEvVar :: TcPredType -> TcS EvVar
newGivenEvVar :: CtLoc -> (TcPredType, EvTerm) -> TcS CtEvidence
newGivenEvVars :: CtLoc -> [(TcPredType, EvTerm)] -> TcS [CtEvidence]
newDerived :: CtLoc -> TcPredType -> TcS (Maybe CtEvidence)
emitNewDerived :: CtLoc -> TcPredType -> TcS ()
instDFunConstraints :: CtLoc -> TcThetaType -> TcS [(CtEvidence, Freshness)]
getInstEnvs :: TcS InstEnvs
getFamInstEnvs :: TcS (FamInstEnv, FamInstEnv)
getTopEnv :: TcS HscEnv
getGblEnv :: TcS TcGblEnv
getTcEvBinds :: TcS EvBindsVar
getTcLevel :: TcS TcLevel
getTcEvBindsMap :: TcS EvBindMap
data InertSet
[IS] :: InertCans -> FunEqMap (TcCoercion, TcType, CtFlavour) -> DictMap CtEvidence -> InertSet
[inert_cans] :: InertSet -> InertCans
[inert_flat_cache] :: InertSet -> FunEqMap (TcCoercion, TcType, CtFlavour)
[inert_solved_dicts] :: InertSet -> DictMap CtEvidence
data InertCans
[IC] :: TyVarEnv EqualCtList -> FunEqMap Ct -> DictMap Ct -> Cts -> Cts -> InertCans
[inert_eqs] :: InertCans -> TyVarEnv EqualCtList
[inert_funeqs] :: InertCans -> FunEqMap Ct
[inert_dicts] :: InertCans -> DictMap Ct
[inert_irreds] :: InertCans -> Cts
[inert_insols] :: InertCans -> Cts
updInertTcS :: (InertSet -> InertSet) -> TcS ()
updInertCans :: (InertCans -> InertCans) -> TcS ()
updInertDicts :: (DictMap Ct -> DictMap Ct) -> TcS ()
updInertIrreds :: (Cts -> Cts) -> TcS ()
getNoGivenEqs :: TcLevel -> [TcTyVar] -> TcS Bool
setInertCans :: InertCans -> TcS ()
getInertEqs :: TcS (TyVarEnv EqualCtList)
getInertCans :: TcS InertCans
emptyInert :: InertSet
getTcSInerts :: TcS InertSet
setTcSInerts :: InertSet -> TcS ()
getUnsolvedInerts :: TcS (Bag Implication, Cts, Cts, Cts, Cts)
checkAllSolved :: TcS Bool

-- | Extract the (given, derived, wanted) inert constraints
splitInertCans :: InertCans -> ([Ct], [Ct], [Ct])

-- | Remove inert constraints from the <a>InertCans</a>, for use when a
--   typechecker plugin wishes to discard a given.
removeInertCts :: [Ct] -> InertCans -> InertCans
prepareInertsForImplications :: InertSet -> (InertSet)
addInertCan :: InertCans -> Ct -> InertCans
insertInertItemTcS :: Ct -> TcS ()
insertFunEq :: FunEqMap a -> TyCon -> [Type] -> a -> FunEqMap a
emitInsoluble :: Ct -> TcS ()
emitWorkNC :: [CtEvidence] -> TcS ()
type EqualCtList = [Ct]
lookupInertDict :: InertCans -> CtLoc -> Class -> [Type] -> Maybe CtEvidence
findDictsByClass :: DictMap a -> Class -> Bag a
addDict :: DictMap a -> Class -> [Type] -> a -> DictMap a
addDictsByClass :: DictMap Ct -> Class -> Bag Ct -> DictMap Ct
delDict :: DictMap a -> Class -> [Type] -> DictMap a
partitionDicts :: (Ct -> Bool) -> DictMap Ct -> (Bag Ct, DictMap Ct)
findTyEqs :: InertCans -> TyVar -> EqualCtList
addSolvedDict :: CtEvidence -> Class -> [Type] -> TcS ()
lookupSolvedDict :: InertSet -> CtLoc -> Class -> [Type] -> Maybe CtEvidence
lookupFlatCache :: TyCon -> [Type] -> TcS (Maybe (TcCoercion, TcType, CtFlavour))
extendFlatCache :: TyCon -> [Type] -> (TcCoercion, TcType, CtFlavour) -> TcS ()
newFlattenSkolem :: CtFlavour -> CtLoc -> TcType -> TcS (CtEvidence, TcTyVar)
updInertFunEqs :: (FunEqMap Ct -> FunEqMap Ct) -> TcS ()
findFunEq :: FunEqMap a -> TyCon -> [Type] -> Maybe a
sizeFunEqMap :: FunEqMap a -> Int
findFunEqsByTyCon :: FunEqMap a -> TyCon -> [a]
findFunEqs :: FunEqMap a -> TyCon -> [Type] -> Maybe a
partitionFunEqs :: (Ct -> Bool) -> FunEqMap Ct -> ([Ct], FunEqMap Ct)
instDFunType :: DFunId -> [DFunInstType] -> TcS ([TcType], TcType)
newFlexiTcSTy :: Kind -> TcS TcType
instFlexiTcS :: [TKVar] -> TcS (TvSubst, [TcType])
instFlexiTcSHelperTcS :: Name -> Kind -> TcS TcType
cloneMetaTyVar :: TcTyVar -> TcS TcTyVar
demoteUnfilledFmv :: TcTyVar -> TcS ()
data TcLevel
isTouchableMetaTyVarTcS :: TcTyVar -> TcS Bool
isFilledMetaTyVar_maybe :: TcTyVar -> TcS (Maybe Type)
isFilledMetaTyVar :: TcTyVar -> TcS Bool
zonkTyVarsAndFV :: TcTyVarSet -> TcS TcTyVarSet
zonkTcType :: TcType -> TcS TcType
zonkTcTyVar :: TcTyVar -> TcS TcType
zonkSimples :: Cts -> TcS Cts
newTcRef :: a -> TcS (TcRef a)
readTcRef :: TcRef a -> TcS a
updTcRef :: TcRef a -> (a -> a) -> TcS ()
getDefaultInfo :: TcS ([Type], (Bool, Bool))
getDynFlags :: HasDynFlags m => m DynFlags
getGlobalRdrEnvTcS :: TcS GlobalRdrEnv
matchFam :: TyCon -> [Type] -> TcS (Maybe (TcCoercion, TcType))
matchFamTcM :: TyCon -> [Type] -> TcM (Maybe (TcCoercion, TcType))
checkWellStagedDFun :: PredType -> DFunId -> CtLoc -> TcS ()
pprEq :: TcType -> TcType -> SDoc
instance Outputable WorkList
instance Outputable InertCans
instance Outputable InertSet
instance Functor TcS
instance Applicative TcS
instance Monad TcS
instance MonadUnique TcS
instance HasDynFlags TcS


-- | This module provides an interface for typechecker plugins to access
--   select functions of the <tt>TcM</tt>, principally those to do with
--   reading parts of the state.
module TcPluginM
data TcPluginM a

-- | Perform some IO, typically to interact with an external tool.
tcPluginIO :: IO a -> TcPluginM a

-- | Output useful for debugging the compiler.
tcPluginTrace :: String -> SDoc -> TcPluginM ()

-- | This function provides an escape for direct access to the <a>TcM</a>
--   monad. It should not be used lightly, and the provided
--   <a>TcPluginM</a> API should be favoured instead.
unsafeTcPluginTcM :: TcM a -> TcPluginM a

-- | The result of searching for an imported module.
data FindResult

-- | The module was found
[Found] :: ModLocation -> Module -> FindResult

-- | The requested package was not found
[NoPackage] :: PackageKey -> FindResult

-- | _Error_: both in multiple packages
[FoundMultiple] :: [(Module, ModuleOrigin)] -> FindResult

-- | Not found
[NotFound] :: [FilePath] -> Maybe PackageKey -> [PackageKey] -> [PackageKey] -> [ModuleSuggestion] -> FindResult
[fr_paths] :: FindResult -> [FilePath]
[fr_pkg] :: FindResult -> Maybe PackageKey
[fr_mods_hidden] :: FindResult -> [PackageKey]
[fr_pkgs_hidden] :: FindResult -> [PackageKey]
[fr_suggestions] :: FindResult -> [ModuleSuggestion]
findImportedModule :: ModuleName -> Maybe FastString -> TcPluginM FindResult
lookupOrig :: Module -> OccName -> TcPluginM Name
tcLookupGlobal :: Name -> TcPluginM TyThing
tcLookupTyCon :: Name -> TcPluginM TyCon
tcLookupDataCon :: Name -> TcPluginM DataCon
tcLookupClass :: Name -> TcPluginM Class
tcLookup :: Name -> TcPluginM TcTyThing
tcLookupId :: Name -> TcPluginM Id
getTopEnv :: TcPluginM HscEnv
getEnvs :: TcPluginM (TcGblEnv, TcLclEnv)
getInstEnvs :: TcPluginM InstEnvs
getFamInstEnvs :: TcPluginM (FamInstEnv, FamInstEnv)
matchFam :: TyCon -> [Type] -> TcPluginM (Maybe (TcCoercion, TcType))
newFlexiTyVar :: Kind -> TcPluginM TcTyVar
isTouchableTcPluginM :: TcTyVar -> TcPluginM Bool
zonkTcType :: TcType -> TcPluginM TcType
zonkCt :: Ct -> TcPluginM Ct

module TcFlatten
data FlattenEnv
[FE] :: FlattenMode -> CtLoc -> CtFlavour -> EqRel -> FlattenEnv
[fe_mode] :: FlattenEnv -> FlattenMode
[fe_loc] :: FlattenEnv -> CtLoc
[fe_flavour] :: FlattenEnv -> CtFlavour
[fe_eq_rel] :: FlattenEnv -> EqRel
data FlattenMode
[FM_FlattenAll] :: FlattenMode
[FM_Avoid] :: TcTyVar -> Bool -> FlattenMode
[FM_SubstOnly] :: FlattenMode
mkFlattenEnv :: FlattenMode -> CtEvidence -> FlattenEnv
flatten :: FlattenMode -> CtEvidence -> TcType -> TcS (Xi, TcCoercion)
flattenMany :: FlattenMode -> CtEvidence -> [Role] -> [TcType] -> TcS ([Xi], [TcCoercion])
flatten_many :: FlattenEnv -> [Role] -> [Type] -> TcS ([Xi], [TcCoercion])
flattenFamApp :: FlattenMode -> CtEvidence -> TyCon -> [TcType] -> TcS (Xi, TcCoercion)
flattenTyVarOuter :: FlattenEnv -> TcTyVar -> TcS (Either TyVar (TcType, TcCoercion))
unflatten :: Cts -> Cts -> TcS Cts
eqCanRewrite :: CtEvidence -> CtEvidence -> Bool
eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
canRewriteOrSame :: CtEvidence -> CtEvidence -> Bool

-- | Whether or not one <a>Ct</a> can rewrite another is determined by its
--   flavour and its equality relation
type CtFlavourRole = (CtFlavour, EqRel)

-- | Extract the flavour and role from a <a>CtEvidence</a>
ctEvFlavourRole :: CtEvidence -> CtFlavourRole

-- | Extract the flavour and role from a <a>Ct</a>
ctFlavourRole :: Ct -> CtFlavourRole

module TcErrors
reportUnsolved :: WantedConstraints -> TcM (Bag EvBind)
reportAllUnsolved :: WantedConstraints -> TcM ()
warnDefaulting :: Cts -> Type -> TcM ()
solverDepthErrorTcS :: SubGoalCounter -> CtEvidence -> TcM a

module TcGenGenerics
canDoGenerics :: TyCon -> [Type] -> Validity
canDoGenerics1 :: TyCon -> [Type] -> Validity
data GenericKind
[Gen0] :: GenericKind
[Gen1] :: GenericKind
data MetaTyCons
genGenericMetaTyCons :: TyCon -> Module -> TcM (MetaTyCons, BagDerivStuff)
gen_Generic_binds :: GenericKind -> TyCon -> MetaTyCons -> Module -> TcM (LHsBinds RdrName, FamInst)
get_gen1_constrained_tys :: TyVar -> Type -> [Type]
instance Outputable MetaTyCons

module TcCanonical
canonicalize :: Ct -> TcS (StopOrContinue Ct)
unifyDerived :: CtLoc -> Role -> Pair TcType -> TcS ()
data StopOrContinue a
[ContinueWith] :: a -> StopOrContinue a
[Stop] :: CtEvidence -> SDoc -> StopOrContinue a
stopWith :: CtEvidence -> String -> TcS (StopOrContinue a)
continueWith :: a -> TcS (StopOrContinue a)
instance Functor StopOrContinue
instance Outputable a => Outputable (StopOrContinue a)

module PprTyThing

-- | Pretty-prints a <a>TyThing</a>.
pprTyThing :: TyThing -> SDoc

-- | Pretty-prints a <a>TyThing</a> in context: that is, if the entity is a
--   data constructor, record selector, or class method, then the entity's
--   parent declaration is pretty-printed with irrelevant parts omitted.
pprTyThingInContext :: TyThing -> SDoc

-- | Pretty-prints a <a>TyThing</a> with its defining location.
pprTyThingLoc :: TyThing -> SDoc

-- | Like <a>pprTyThingInContext</a>, but adds the defining location.
pprTyThingInContextLoc :: TyThing -> SDoc

-- | Pretty-prints the <a>TyThing</a> header. For functions and data
--   constructors the function is equivalent to <a>pprTyThing</a> but for
--   type constructors and classes it prints only the header part of the
--   declaration.
pprTyThingHdr :: TyThing -> SDoc
pprTypeForUser :: Type -> SDoc

-- | Pretty-prints a <a>FamInst</a> (type/data family instance) with its
--   defining location.
pprFamInst :: FamInst -> SDoc

module RdrHsSyn
mkHsOpApp :: LHsExpr id -> id -> LHsExpr id -> HsExpr id
mkHsIntegral :: String -> Integer -> PostTc RdrName Type -> HsOverLit RdrName
mkHsFractional :: FractionalLit -> PostTc RdrName Type -> HsOverLit RdrName
mkHsIsString :: String -> FastString -> PostTc RdrName Type -> HsOverLit RdrName
mkHsDo :: HsStmtContext Name -> [ExprLStmt RdrName] -> HsExpr RdrName
mkSpliceDecl :: LHsExpr RdrName -> HsDecl RdrName
mkRoleAnnotDecl :: SrcSpan -> Located RdrName -> [Located (Maybe FastString)] -> P (LRoleAnnotDecl RdrName)
mkClassDecl :: SrcSpan -> Located (Maybe (LHsContext RdrName), LHsType RdrName) -> Located (a, [Located (FunDep (Located RdrName))]) -> OrdList (LHsDecl RdrName) -> P (LTyClDecl RdrName)
mkTyData :: SrcSpan -> NewOrData -> Maybe (Located CType) -> Located (Maybe (LHsContext RdrName), LHsType RdrName) -> Maybe (LHsKind RdrName) -> [LConDecl RdrName] -> Maybe (Located [LHsType RdrName]) -> P (LTyClDecl RdrName)
mkDataFamInst :: SrcSpan -> NewOrData -> Maybe (Located CType) -> Located (Maybe (LHsContext RdrName), LHsType RdrName) -> Maybe (LHsKind RdrName) -> [LConDecl RdrName] -> Maybe (Located [LHsType RdrName]) -> P (LInstDecl RdrName)
mkTySynonym :: SrcSpan -> LHsType RdrName -> LHsType RdrName -> P (LTyClDecl RdrName)
mkTyFamInstEqn :: LHsType RdrName -> LHsType RdrName -> P (TyFamInstEqn RdrName, [AddAnn])
mkTyFamInst :: SrcSpan -> LTyFamInstEqn RdrName -> P (LInstDecl RdrName)
mkFamDecl :: SrcSpan -> FamilyInfo RdrName -> LHsType RdrName -> Maybe (LHsKind RdrName) -> P (LTyClDecl RdrName)
splitCon :: LHsType RdrName -> P (Located RdrName, HsConDeclDetails RdrName)
mkInlinePragma :: String -> (InlineSpec, RuleMatchInfo) -> Maybe Activation -> InlinePragma
mkPatSynMatchGroup :: Located RdrName -> Located (OrdList (LHsDecl RdrName)) -> P (MatchGroup RdrName (LHsExpr RdrName))
mkRecConstrOrUpdate :: LHsExpr RdrName -> SrcSpan -> ([LHsRecField RdrName (LHsExpr RdrName)], Bool) -> P (HsExpr RdrName)

-- | mkClassDecl builds a RdrClassDecl, filling in the names for tycon and
--   datacon by deriving them from the name of the class. We fill in the
--   names for the tycon and datacon corresponding to the class, by
--   deriving them from the name of the class itself. This saves recording
--   the names in the interface file (which would be equally good).
mkTyClD :: LTyClDecl n -> LHsDecl n
mkInstD :: LInstDecl n -> LHsDecl n
cvBindGroup :: OrdList (LHsDecl RdrName) -> P (HsValBinds RdrName)
cvBindsAndSigs :: OrdList (LHsDecl RdrName) -> P (LHsBinds RdrName, [LSig RdrName], [LFamilyDecl RdrName], [LTyFamInstDecl RdrName], [LDataFamInstDecl RdrName], [LDocDecl])

-- | Function definitions are restructured here. Each is assumed to be
--   recursive initially, and non recursive definitions are discovered by
--   the dependency analyser.
cvTopDecls :: OrdList (LHsDecl RdrName) -> [LHsDecl RdrName]
placeHolderPunRhs :: LHsExpr RdrName
mkImport :: Located CCallConv -> Located Safety -> (Located FastString, Located RdrName, LHsType RdrName) -> P (HsDecl RdrName)
parseCImport :: Located CCallConv -> Located Safety -> FastString -> String -> Located SourceText -> Maybe ForeignImport
mkExport :: Located CCallConv -> (Located FastString, Located RdrName, LHsType RdrName) -> P (HsDecl RdrName)
mkExtName :: RdrName -> CLabelString
mkGadtDecl :: [Located RdrName] -> LHsType RdrName -> P (ConDecl RdrName)
mkSimpleConDecl :: Located RdrName -> [LHsTyVarBndr RdrName] -> LHsContext RdrName -> HsConDeclDetails RdrName -> ConDecl RdrName
mkDeprecatedGadtRecordDecl :: SrcSpan -> Located RdrName -> Located [LConDeclField RdrName] -> LHsType RdrName -> P (LConDecl RdrName)
mkATDefault :: LTyFamInstDecl RdrName -> Either (SrcSpan, SDoc) (LTyFamDefltEqn RdrName)
checkPrecP :: Located Int -> P (Located Int)
checkContext :: LHsType RdrName -> P (LHsContext RdrName)
checkPattern :: SDoc -> LHsExpr RdrName -> P (LPat RdrName)
bang_RDR :: RdrName
checkPatterns :: SDoc -> [LHsExpr RdrName] -> P [LPat RdrName]
checkMonadComp :: P (HsStmtContext Name)
checkCommand :: LHsExpr RdrName -> P (LHsCmd RdrName)
checkValDef :: SDoc -> LHsExpr RdrName -> Maybe (LHsType RdrName) -> Located (a, GRHSs RdrName (LHsExpr RdrName)) -> P (HsBind RdrName)
checkValSig :: LHsExpr RdrName -> LHsType RdrName -> P (Sig RdrName)

-- | Check the validity of a partial type signature. We check the following
--   things:
--   
--   <ul>
--   <li>There should only be one extra-constraints wildcard in the type
--   signature, i.e. the <tt>_</tt> in <tt>_ =&gt; a -&gt; String</tt>.
--   This would be invalid: <tt>(Eq a, _) =&gt; a -&gt; (Num a, _) =&gt; a
--   -&gt; Bool</tt>. Extra-constraints wildcards are only allowed in the
--   top-level context.</li>
--   <li>Named extra-constraints wildcards aren't allowed, e.g. invalid:
--   <tt>(Show a, _x) =&gt; a -&gt; String</tt>.</li>
--   <li>There is only one extra-constraints wildcard in the context and it
--   must come last, e.g. invalid: <tt>(_, Show a) =&gt; a -&gt;
--   String</tt> or <tt>(_, Show a, _) =&gt; a -&gt; String</tt>.</li>
--   <li>There should be no unnamed wildcards in the context.</li>
--   <li>Named wildcards occurring in the context must also occur in the
--   monotype.</li>
--   </ul>
--   
--   An error is reported when an invalid wildcard is found.
checkPartialTypeSignature :: LHsType RdrName -> P (LHsType RdrName)

-- | Check that the given type does not contain wildcards, and is thus not
--   a partial type. If it contains wildcards, report an error with the
--   given message.
checkNoPartialType :: SDoc -> LHsType RdrName -> P ()

-- | Check that the pattern synonym type signature does not contain
--   wildcards.
checkValidPatSynSig :: Sig RdrName -> P (Sig RdrName)
checkDoAndIfThenElse :: LHsExpr RdrName -> Bool -> LHsExpr RdrName -> Bool -> LHsExpr RdrName -> P ()
checkRecordSyntax :: Outputable a => Located a -> P (Located a)

-- | Check that the default declarations do not contain wildcards in their
--   types, which we do not want as the types in the default declarations
--   must be fully specified.
checkValidDefaults :: [LHsType RdrName] -> P (DefaultDecl RdrName)
parseErrorSDoc :: SrcSpan -> SDoc -> P a
data ImpExpSubSpec
[ImpExpAbs] :: ImpExpSubSpec
[ImpExpAll] :: ImpExpSubSpec
[ImpExpList] :: [Located RdrName] -> ImpExpSubSpec
mkModuleImpExp :: Located RdrName -> ImpExpSubSpec -> IE RdrName
mkTypeImpExp :: Located RdrName -> P (Located RdrName)


-- | This module provides the generated Happy parser for Haskell. It
--   exports a number of parsers which may be used in any library that uses
--   the GHC API. A common usage pattern is to initialize the parser state
--   with a given string and then parse that string:
--   
--   <pre>
--   runParser :: DynFlags -&gt; String -&gt; P a -&gt; ParseResult a
--   runParser flags str parser = unP parser parseState
--   where
--     filename = "&lt;interactive&gt;"
--     location = mkRealSrcLoc (mkFastString filename) 1 1
--     buffer = stringToStringBuffer str
--     parseState = mkPState flags buffer location in
--   </pre>
module Parser
parseModule :: P (Located (HsModule RdrName))
parseImport :: P (LImportDecl RdrName)
parseStatement :: P (LStmt RdrName (LHsExpr RdrName))
parseDeclaration :: P (OrdList (LHsDecl RdrName))
parseExpression :: P (LHsExpr RdrName)
parseTypeSignature :: P (Located (OrdList (LHsDecl RdrName)))
parseFullStmt :: P (LStmt RdrName (LHsExpr RdrName))
parseStmt :: P (Maybe (LStmt RdrName (LHsExpr RdrName)))
parseIdentifier :: P (Located RdrName)
parseType :: P (LHsType RdrName)
parseHeader :: P (Located (HsModule RdrName))


-- | Parsing the top of a Haskell source file to get its module name,
--   imports and options.
--   
--   (c) Simon Marlow 2005 (c) Lemmih 2006
module HeaderInfo

-- | Parse the imports of a source file.
--   
--   Throws a <a>SourceError</a> if parsing fails.
getImports :: DynFlags -> StringBuffer -> FilePath -> FilePath -> IO ([Located (ImportDecl RdrName)], [Located (ImportDecl RdrName)], Located ModuleName)
mkPrelImports :: ModuleName -> SrcSpan -> Bool -> [LImportDecl RdrName] -> [LImportDecl RdrName]

-- | Parse OPTIONS and LANGUAGE pragmas of the source file.
--   
--   Throws a <a>SourceError</a> if flag parsing fails (including
--   unsupported flags.)
getOptionsFromFile :: DynFlags -> FilePath -> IO [Located String]

-- | Parse OPTIONS and LANGUAGE pragmas of the source file.
--   
--   Throws a <a>SourceError</a> if flag parsing fails (including
--   unsupported flags.)
getOptions :: DynFlags -> StringBuffer -> FilePath -> [Located String]
optionsErrorMsgs :: DynFlags -> [String] -> [Located String] -> FilePath -> Messages

-- | Complain about non-dynamic flags in OPTIONS pragmas.
--   
--   Throws a <a>SourceError</a> if the input list is non-empty claiming
--   that the input flags are unknown.
checkProcessArgsResult :: MonadIO m => DynFlags -> [Located String] -> m ()

module Convert
convertToHsExpr :: SrcSpan -> Exp -> Either MsgDoc (LHsExpr RdrName)
convertToPat :: SrcSpan -> Pat -> Either MsgDoc (LPat RdrName)
convertToHsDecls :: SrcSpan -> [Dec] -> Either MsgDoc [LHsDecl RdrName]
convertToHsType :: SrcSpan -> Type -> Either MsgDoc (LHsType RdrName)
thRdrNameGuesses :: Name -> [RdrName]
instance Functor CvtM
instance Applicative CvtM
instance Monad CvtM

module TcInteract
solveSimpleGivens :: CtLoc -> [EvVar] -> TcS ()
solveSimpleWanteds :: Cts -> TcS WantedConstraints
instance Outputable InteractResult
instance Outputable LookupInstResult

module TcSimplify
simplifyInfer :: TcLevel -> Bool -> [(Name, TcTauType)] -> WantedConstraints -> TcM ([TcTyVar], [EvVar], Bool, TcEvBinds)
quantifyPred :: TyVarSet -> PredType -> Bool
growThetaTyVars :: ThetaType -> TyVarSet -> TyVarSet
simplifyAmbiguityCheck :: Type -> WantedConstraints -> TcM ()
simplifyDefault :: ThetaType -> TcM ()
simplifyRule :: RuleName -> WantedConstraints -> WantedConstraints -> TcM ([EvVar], WantedConstraints)
simplifyTop :: WantedConstraints -> TcM (Bag EvBind)
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
solveWantedsTcM :: WantedConstraints -> TcM (WantedConstraints, Bag EvBind)

module TcValidity
data Rank
data UserTypeCtxt
[FunSigCtxt] :: Name -> UserTypeCtxt
[InfSigCtxt] :: Name -> UserTypeCtxt
[ExprSigCtxt] :: UserTypeCtxt
[ConArgCtxt] :: Name -> UserTypeCtxt
[TySynCtxt] :: Name -> UserTypeCtxt
[PatSigCtxt] :: UserTypeCtxt
[RuleSigCtxt] :: Name -> UserTypeCtxt
[ResSigCtxt] :: UserTypeCtxt
[ForSigCtxt] :: Name -> UserTypeCtxt
[DefaultDeclCtxt] :: UserTypeCtxt
[InstDeclCtxt] :: UserTypeCtxt
[SpecInstCtxt] :: UserTypeCtxt
[ThBrackCtxt] :: UserTypeCtxt
[GenSigCtxt] :: UserTypeCtxt
[GhciCtxt] :: UserTypeCtxt
[ClassSCCtxt] :: Name -> UserTypeCtxt
[SigmaCtxt] :: UserTypeCtxt
[DataTyCtxt] :: Name -> UserTypeCtxt
checkValidType :: UserTypeCtxt -> Type -> TcM ()
checkValidMonoType :: Type -> TcM ()
expectedKindInCtxt :: UserTypeCtxt -> Maybe Kind
checkValidTheta :: UserTypeCtxt -> ThetaType -> TcM ()
checkValidFamPats :: TyCon -> [TyVar] -> [Type] -> TcM ()
checkValidInstance :: UserTypeCtxt -> LHsType Name -> Type -> TcM ([TyVar], ThetaType, Class, [Type])
validDerivPred :: TyVarSet -> PredType -> Bool
checkInstTermination :: [TcType] -> ThetaType -> TcM ()
checkValidTyFamInst :: Maybe (Class, VarEnv Type) -> TyCon -> CoAxBranch -> TcM ()
checkTyFamFreeness :: Type -> TcM ()
checkConsistentFamInst :: Maybe (Class, VarEnv Type) -> TyCon -> [TyVar] -> [Type] -> TcM ()
arityErr :: Outputable a => String -> a -> Int -> Int -> SDoc
badATErr :: Name -> Name -> SDoc

module TcHsType
tcHsSigType :: UserTypeCtxt -> LHsType Name -> TcM Type
tcHsSigTypeNC :: UserTypeCtxt -> LHsType Name -> TcM Type
tcHsDeriv :: HsType Name -> TcM ([TyVar], Class, [Type], Kind)
tcHsVectInst :: LHsType Name -> TcM (Class, [Type])
tcHsInstHead :: UserTypeCtxt -> LHsType Name -> TcM ([TyVar], ThetaType, Class, [Type])
data UserTypeCtxt
[FunSigCtxt] :: Name -> UserTypeCtxt
[InfSigCtxt] :: Name -> UserTypeCtxt
[ExprSigCtxt] :: UserTypeCtxt
[ConArgCtxt] :: Name -> UserTypeCtxt
[TySynCtxt] :: Name -> UserTypeCtxt
[PatSigCtxt] :: UserTypeCtxt
[RuleSigCtxt] :: Name -> UserTypeCtxt
[ResSigCtxt] :: UserTypeCtxt
[ForSigCtxt] :: Name -> UserTypeCtxt
[DefaultDeclCtxt] :: UserTypeCtxt
[InstDeclCtxt] :: UserTypeCtxt
[SpecInstCtxt] :: UserTypeCtxt
[ThBrackCtxt] :: UserTypeCtxt
[GenSigCtxt] :: UserTypeCtxt
[GhciCtxt] :: UserTypeCtxt
[ClassSCCtxt] :: Name -> UserTypeCtxt
[SigmaCtxt] :: UserTypeCtxt
[DataTyCtxt] :: Name -> UserTypeCtxt
kcLookupKind :: Name -> TcM Kind
kcTyClTyVars :: Name -> LHsTyVarBndrs Name -> TcM a -> TcM a
tcTyClTyVars :: Name -> LHsTyVarBndrs Name -> ([TyVar] -> Kind -> TcM a) -> TcM a
tcHsConArgType :: NewOrData -> LHsType Name -> TcM Type
tcDataKindSig :: Kind -> TcM [TyVar]
tcClassSigType :: LHsType Name -> TcM Type

-- | Kind-check a <a>LHsTyVarBndrs</a>. If the decl under consideration has
--   a complete, user-supplied kind signature (CUSK), generalise the
--   result. Used in <tt>getInitialKind</tt> and in kind-checking. See also
--   Note [Complete user-supplied kind signatures] in HsDecls.
kcHsTyVarBndrs :: Bool -> LHsTyVarBndrs Name -> TcM (Kind, r) -> TcM (Kind, r)
tcHsTyVarBndrs :: LHsTyVarBndrs Name -> ([TcTyVar] -> TcM r) -> TcM r
tcHsLiftedType :: LHsType Name -> TcM TcType
tcHsOpenType :: LHsType Name -> TcM TcType
tcLHsType :: LHsType Name -> TcM (TcType, TcKind)
tcCheckLHsType :: LHsType Name -> Kind -> TcM Type
tcHsContext :: LHsContext Name -> TcM [PredType]
tcInferApps :: Outputable a => a -> TcKind -> [LHsType Name] -> TcM ([TcType], TcKind)
tcHsArgTys :: SDoc -> [LHsType Name] -> [Kind] -> TcM [TcType]
kindGeneralize :: TyVarSet -> TcM [KindVar]
checkKind :: TcKind -> TcKind -> TcM ()
tcLHsKind :: LHsKind Name -> TcM Kind
tcHsPatSigType :: UserTypeCtxt -> HsWithBndrs Name (LHsType Name) -> TcM (Type, [(Name, TcTyVar)], [(Name, TcTyVar)])
tcPatSig :: Bool -> HsWithBndrs Name (LHsType Name) -> TcSigmaType -> TcM (TcType, [(Name, TcTyVar)], [(Name, TcTyVar)], HsWrapper)
instance Outputable ExpKind

module TcPat
tcLetPat :: TcSigFun -> LetBndrSpec -> LPat Name -> TcSigmaType -> TcM a -> TcM (LPat TcId, a)
type TcSigFun = Name -> Maybe TcSigInfo
type TcPragFun = Name -> [LSig Name]
data TcSigInfo
[TcSigInfo] :: TcId -> [(Maybe Name, TcTyVar)] -> [(Name, TcTyVar)] -> TcThetaType -> Maybe SrcSpan -> TcSigmaType -> SrcSpan -> Bool -> TcSigInfo
[sig_id] :: TcSigInfo -> TcId
[sig_tvs] :: TcSigInfo -> [(Maybe Name, TcTyVar)]
[sig_nwcs] :: TcSigInfo -> [(Name, TcTyVar)]
[sig_theta] :: TcSigInfo -> TcThetaType
[sig_extra_cts] :: TcSigInfo -> Maybe SrcSpan
[sig_tau] :: TcSigInfo -> TcSigmaType
[sig_loc] :: TcSigInfo -> SrcSpan
[sig_partial] :: TcSigInfo -> Bool
[TcPatSynInfo] :: TcPatSynInfo -> TcSigInfo
data TcPatSynInfo
[TPSI] :: Name -> TcSigmaType -> [TcTyVar] -> TcThetaType -> [TcTyVar] -> TcThetaType -> TcPatSynInfo
[patsig_name] :: TcPatSynInfo -> Name
[patsig_tau] :: TcPatSynInfo -> TcSigmaType
[patsig_ex] :: TcPatSynInfo -> [TcTyVar]
[patsig_prov] :: TcPatSynInfo -> TcThetaType
[patsig_univ] :: TcPatSynInfo -> [TcTyVar]
[patsig_req] :: TcPatSynInfo -> TcThetaType
findScopedTyVars :: LHsType Name -> TcType -> [TcTyVar] -> [(Maybe Name, TcTyVar)]
isPartialSig :: TcSigInfo -> Bool
data LetBndrSpec
[LetLclBndr] :: LetBndrSpec
[LetGblBndr] :: TcPragFun -> LetBndrSpec
addInlinePrags :: TcId -> [LSig Name] -> TcM TcId
warnPrags :: Id -> [LSig Name] -> SDoc -> TcM ()
tcPat :: HsMatchContext Name -> LPat Name -> TcSigmaType -> TcM a -> TcM (LPat TcId, a)
tcPats :: HsMatchContext Name -> [LPat Name] -> [TcSigmaType] -> TcM a -> TcM ([LPat TcId], a)
newNoSigLetBndr :: LetBndrSpec -> Name -> TcType -> TcM TcId
addDataConStupidTheta :: DataCon -> [TcType] -> TcM ()
badFieldCon :: ConLike -> Name -> SDoc
polyPatSig :: TcType -> SDoc
instance NamedThing TcSigInfo
instance Outputable TcSigInfo
instance Outputable TcPatSynInfo

module TcBinds
tcLocalBinds :: HsLocalBinds Name -> TcM thing -> TcM (HsLocalBinds TcId, thing)
tcTopBinds :: HsValBinds Name -> TcM (TcGblEnv, TcLclEnv)
tcRecSelBinds :: HsValBinds Name -> TcM TcGblEnv
tcHsBootSigs :: HsValBinds Name -> TcM [Id]
tcPolyCheck :: RecFlag -> PragFun -> TcSigInfo -> LHsBind Name -> TcM (LHsBinds TcId, [TcId], TopLevelFlag)
type PragFun = Name -> [LSig Name]
tcSpecPrags :: Id -> [LSig Name] -> TcM [LTcSpecPrag]
tcVectDecls :: [LVectDecl Name] -> TcM ([LVectDecl TcId])
mkPragFun :: [LSig Name] -> LHsBinds Name -> PragFun
data TcSigInfo
[TcSigInfo] :: TcId -> [(Maybe Name, TcTyVar)] -> [(Name, TcTyVar)] -> TcThetaType -> Maybe SrcSpan -> TcSigmaType -> SrcSpan -> Bool -> TcSigInfo
[sig_id] :: TcSigInfo -> TcId
[sig_tvs] :: TcSigInfo -> [(Maybe Name, TcTyVar)]
[sig_nwcs] :: TcSigInfo -> [(Name, TcTyVar)]
[sig_theta] :: TcSigInfo -> TcThetaType
[sig_extra_cts] :: TcSigInfo -> Maybe SrcSpan
[sig_tau] :: TcSigInfo -> TcSigmaType
[sig_loc] :: TcSigInfo -> SrcSpan
[sig_partial] :: TcSigInfo -> Bool
[TcPatSynInfo] :: TcPatSynInfo -> TcSigInfo
type TcSigFun = Name -> Maybe TcSigInfo
instTcTySig :: LHsType Name -> TcType -> Maybe SrcSpan -> [(Name, TcTyVar)] -> Name -> TcM TcSigInfo
instTcTySigFromId :: Id -> TcM TcSigInfo
findScopedTyVars :: LHsType Name -> TcType -> [TcTyVar] -> [(Maybe Name, TcTyVar)]
badBootDeclErr :: MsgDoc
mkExport :: PragFun -> [TyVar] -> TcThetaType -> MonoBindInfo -> TcM (ABExport Id)
instance Outputable GeneralisationPlan

module TcMatches
tcMatchesFun :: Name -> Bool -> MatchGroup Name (LHsExpr Name) -> TcSigmaType -> TcM (HsWrapper, MatchGroup TcId (LHsExpr TcId))
tcGRHS :: TcMatchCtxt body -> TcRhoType -> GRHS Name (Located (body Name)) -> TcM (GRHS TcId (Located (body TcId)))
tcGRHSsPat :: GRHSs Name (LHsExpr Name) -> TcRhoType -> TcM (GRHSs TcId (LHsExpr TcId))
tcMatchesCase :: (Outputable (body Name)) => TcMatchCtxt body -> TcRhoType -> MatchGroup Name (Located (body Name)) -> TcRhoType -> TcM (MatchGroup TcId (Located (body TcId)))
tcMatchLambda :: MatchGroup Name (LHsExpr Name) -> TcRhoType -> TcM (HsWrapper, MatchGroup TcId (LHsExpr TcId))
data TcMatchCtxt body
[MC] :: HsMatchContext Name -> (Located (body Name) -> TcRhoType -> TcM (Located (body TcId))) -> TcMatchCtxt body
[mc_what] :: TcMatchCtxt body -> HsMatchContext Name
[mc_body] :: TcMatchCtxt body -> Located (body Name) -> TcRhoType -> TcM (Located (body TcId))
type TcStmtChecker body = forall thing. HsStmtContext Name -> Stmt Name (Located (body Name)) -> TcRhoType -> (TcRhoType -> TcM thing) -> TcM (Stmt TcId (Located (body TcId)), thing)
type TcExprStmtChecker = TcStmtChecker HsExpr
type TcCmdStmtChecker = TcStmtChecker HsCmd
tcStmts :: (Outputable (body Name)) => HsStmtContext Name -> TcStmtChecker body -> [LStmt Name (Located (body Name))] -> TcRhoType -> TcM [LStmt TcId (Located (body TcId))]
tcStmtsAndThen :: (Outputable (body Name)) => HsStmtContext Name -> TcStmtChecker body -> [LStmt Name (Located (body Name))] -> TcRhoType -> (TcRhoType -> TcM thing) -> TcM ([LStmt TcId (Located (body TcId))], thing)
tcDoStmts :: HsStmtContext Name -> [LStmt Name (LHsExpr Name)] -> TcRhoType -> TcM (HsExpr TcId)
tcBody :: LHsExpr Name -> TcRhoType -> TcM (LHsExpr TcId)
tcDoStmt :: TcExprStmtChecker
tcGuardStmt :: TcExprStmtChecker

module TcArrows
tcProc :: InPat Name -> LHsCmdTop Name -> TcRhoType -> TcM (OutPat TcId, LHsCmdTop TcId, TcCoercion)

module TcPatSyn
tcInferPatSynDecl :: PatSynBind Name Name -> TcM (PatSyn, LHsBinds Id)
tcCheckPatSynDecl :: PatSynBind Name Name -> TcPatSynInfo -> TcM (PatSyn, LHsBinds Id)
tcPatSynBuilderBind :: PatSynBind Name Name -> TcM (LHsBinds Id)
tcPatSynBuilderOcc :: CtOrigin -> PatSyn -> TcM (HsExpr TcId, TcRhoType)

module TcExpr
tcPolyExpr :: LHsExpr Name -> TcSigmaType -> TcM (LHsExpr TcId)
tcPolyExprNC :: LHsExpr Name -> TcSigmaType -> TcM (LHsExpr TcId)
tcMonoExpr :: LHsExpr Name -> TcRhoType -> TcM (LHsExpr TcId)
tcMonoExprNC :: LHsExpr Name -> TcRhoType -> TcM (LHsExpr TcId)
tcInferRho :: LHsExpr Name -> TcM (LHsExpr TcId, TcRhoType)
tcInferRhoNC :: LHsExpr Name -> TcM (LHsExpr TcId, TcRhoType)
tcSyntaxOp :: CtOrigin -> HsExpr Name -> TcType -> TcM (HsExpr TcId)
tcCheckId :: Name -> TcRhoType -> TcM (HsExpr TcId)
addExprErrCtxt :: LHsExpr Name -> TcM a -> TcM a

module TcClassDcl
tcClassSigs :: Name -> [LSig Name] -> LHsBinds Name -> TcM ([TcMethInfo], NameEnv Type)
tcClassDecl2 :: LTyClDecl Name -> TcM (LHsBinds Id)
findMethodBind :: Name -> LHsBinds Name -> Maybe (LHsBind Name, SrcSpan)
instantiateMethod :: Class -> Id -> [TcType] -> TcType
tcInstanceMethodBody :: SkolemInfo -> [TcTyVar] -> [EvVar] -> Id -> TcSigInfo -> HsWrapper -> TcSpecPrags -> LHsBind Name -> TcM (LHsBind Id)
tcClassMinimalDef :: Name -> [LSig Name] -> [TcMethInfo] -> TcM ClassMinimalDef
type HsSigFun = NameEnv (LHsType Name)
mkHsSigFun :: [LSig Name] -> HsSigFun
lookupHsSig :: HsSigFun -> Name -> Maybe (LHsType Name)
emptyHsSigs :: HsSigFun
tcMkDeclCtxt :: TyClDecl Name -> SDoc
tcAddDeclCtxt :: TyClDecl Name -> TcM a -> TcM a
badMethodErr :: Outputable a => a -> Name -> SDoc

module TcForeign
tcForeignImports :: [LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt)
tcForeignExports :: [LForeignDecl Name] -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt)
isForeignImport :: LForeignDecl name -> Bool
isForeignExport :: LForeignDecl name -> Bool
tcFImport :: LForeignDecl Name -> TcM (Id, LForeignDecl Id, Bag GlobalRdrElt)
tcFExport :: ForeignDecl Name -> TcM (LHsBind Id, ForeignDecl Id, Bag GlobalRdrElt)
tcForeignImports' :: [LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt)
tcCheckFIType :: [Type] -> Type -> ForeignImport -> TcM ForeignImport
checkCTarget :: CCallTarget -> TcM ()
checkForeignArgs :: (Type -> Validity) -> [Type] -> TcM ()

-- | Check that the type has the form (IO t) or (t) , and that t satisfies
--   the given predicate. When calling this function, any newtype wrappers
--   (should) have been already dealt with by normaliseFfiType.
--   
--   We also check that the Safe Haskell condition of FFI imports having
--   results in the IO monad holds.
checkForeignRes :: Bool -> Bool -> (Type -> Validity) -> Type -> TcM ()
normaliseFfiType :: Type -> TcM (Coercion, Type, Bag GlobalRdrElt)
nonIOok :: Bool
mustBeIO :: Bool
checkSafe :: Bool
noCheckSafe :: Bool
tcForeignExports' :: [LForeignDecl Name] -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt)
tcCheckFEType :: Type -> ForeignExport -> TcM ForeignExport

module TcDefaults
tcDefaults :: [LDefaultDecl Name] -> TcM (Maybe [Type])

module TcTyClsDecls
tcTyAndClassDecls :: ModDetails -> [TyClGroup Name] -> TcM TcGblEnv
tcAddImplicits :: [TyThing] -> TcM TcGblEnv
kcDataDefn :: HsDataDefn Name -> TcKind -> TcM ()
tcConDecls :: NewOrData -> TyCon -> ([TyVar], Type) -> [LConDecl Name] -> TcM [DataCon]
dataDeclChecks :: Name -> NewOrData -> ThetaType -> [LConDecl Name] -> TcM Bool
checkValidTyCon :: TyCon -> TcM ()
tcFamTyPats :: FamTyConShape -> HsWithBndrs Name [LHsType Name] -> (TcKind -> TcM ()) -> ([TKVar] -> [TcType] -> Kind -> TcM a) -> TcM a
tcTyFamInstEqn :: FamTyConShape -> LTyFamInstEqn Name -> TcM CoAxBranch
famTyConShape :: TyCon -> FamTyConShape
tcAddTyFamInstCtxt :: TyFamInstDecl Name -> TcM a -> TcM a
tcAddDataFamInstCtxt :: DataFamInstDecl Name -> TcM a -> TcM a
wrongKindOfFamily :: TyCon -> SDoc
dataConCtxt :: Outputable a => a -> SDoc
badDataConTyCon :: DataCon -> Type -> Type -> SDoc

module TcDeriv
tcDeriving :: [LTyClDecl Name] -> [LInstDecl Name] -> [LDerivDecl Name] -> TcM (TcGblEnv, Bag (InstInfo Name), HsValBinds Name)
instance Outputable theta => Outputable (DerivSpec theta)
instance Outputable EarlyDerivSpec
instance Outputable PredOrigin

module TcInstDcls
tcInstDecls1 :: [LTyClDecl Name] -> [LInstDecl Name] -> [LDerivDecl Name] -> TcM (TcGblEnv, [InstInfo Name], HsValBinds Name)
tcInstDecls2 :: [LTyClDecl Name] -> [InstInfo Name] -> TcM (LHsBinds Id)

module TcRules
tcRules :: [LRuleDecls Name] -> TcM [LRuleDecls TcId]

module TcRnDriver

-- | The returned [Id] is the list of new Ids bound by this statement. It
--   can be used to extend the InteractiveContext via
--   extendInteractiveContext.
--   
--   The returned TypecheckedHsExpr is of type IO [ () ], a list of the
--   bound values, coerced to ().
tcRnStmt :: HscEnv -> GhciLStmt RdrName -> IO (Messages, Maybe ([Id], LHsExpr Id, FixityEnv))
tcRnExpr :: HscEnv -> LHsExpr RdrName -> IO (Messages, Maybe Type)
tcRnType :: HscEnv -> Bool -> LHsType RdrName -> IO (Messages, Maybe (Type, Kind))
tcRnImportDecls :: HscEnv -> [LImportDecl RdrName] -> IO (Messages, Maybe GlobalRdrEnv)

-- | Find all the Names that this RdrName could mean, in GHCi
tcRnLookupRdrName :: HscEnv -> RdrName -> IO (Messages, Maybe [Name])

-- | ASSUMES that the module is either in the <a>HomePackageTable</a> or is
--   a package module with an interface on disk. If neither of these is
--   true, then the result will be an error indicating the interface could
--   not be found.
getModuleInterface :: HscEnv -> Module -> IO (Messages, Maybe ModIface)
tcRnDeclsi :: HscEnv -> [LHsDecl RdrName] -> IO (Messages, Maybe TcGblEnv)
isGHCiMonad :: HscEnv -> String -> IO (Messages, Maybe Name)
runTcInteractive :: HscEnv -> TcRn a -> IO (Messages, Maybe a)
tcRnLookupName :: HscEnv -> Name -> IO (Messages, Maybe TyThing)
tcRnGetInfo :: HscEnv -> Name -> IO (Messages, Maybe (TyThing, Fixity, [ClsInst], [FamInst]))

-- | Top level entry point for typechecker and renamer
tcRnModule :: HscEnv -> HscSource -> Bool -> HsParsedModule -> IO (Messages, Maybe TcGblEnv)
tcRnModuleTcRnM :: HscEnv -> HscSource -> HsParsedModule -> (Module, SrcSpan) -> TcRn TcGblEnv
tcTopSrcDecls :: ModDetails -> HsGroup Name -> TcM (TcGblEnv, TcLclEnv)

module Vectorise.Utils.PADict

-- | Construct the PA argument type for the tyvar. For the tyvar (v :: *)
--   it's just PA v. For (v :: (* -&gt; *) -&gt; *) it's
--   
--   <pre>
--   forall (a :: * -&gt; *). (forall (b :: *). PA b -&gt; PA (a b)) -&gt; PA (v a)
--   </pre>
paDictArgType :: TyVar -> VM (Maybe Type)

-- | Get the PA dictionary for some type
paDictOfType :: Type -> VM CoreExpr

-- | Produce code that refers to a method of the <tt>PA</tt> class.
paMethod :: (Builtins -> Var) -> (TyCon -> Builtins -> Var) -> Type -> VM CoreExpr

-- | Get the PR dictionary for a type. The argument must be a
--   representation type.
prDictOfReprType :: Type -> VM CoreExpr

-- | Given a type <tt>ty</tt>, its PRepr synonym tycon and its type
--   arguments, return the PR <tt>PRepr ty</tt>. Suppose we have:
--   
--   <pre>
--   type instance PRepr (T a1 ... an) = t
--   </pre>
--   
--   which is internally translated into
--   
--   <pre>
--   type :R:PRepr a1 ... an = t
--   </pre>
--   
--   and the corresponding coercion. Then,
--   
--   <pre>
--   prDictOfPReprInstTyCon (T a1 ... an) :R:PRepr u1 ... un = PR (T u1 ... un)
--   </pre>
--   
--   Note that <tt>ty</tt> is only used for error messages
prDictOfPReprInstTyCon :: Type -> CoAxiom Unbranched -> [Type] -> VM CoreExpr


-- | Auxiliary functions to vectorise type abstractions.
module Vectorise.Utils.Poly

-- | Vectorise under the <tt>PA</tt> dictionary variables corresponding to
--   a set of type arguments.
--   
--   The dictionary variables are new local variables that are entered into
--   the local vectorisation map.
--   
--   The purpose of this function is to introduce the additional
--   <tt>PA</tt> dictionary arguments that are needed when vectorising type
--   abstractions.
polyAbstract :: [TyVar] -> ([Var] -> VM a) -> VM a

-- | Apply a expression to its type arguments as well as <tt>PA</tt>
--   dictionaries for these type arguments.
polyApply :: CoreExpr -> [Type] -> VM CoreExpr

-- | Apply a vectorised expression to a set of type arguments together with
--   <tt>PA</tt> dictionaries for these type arguments.
polyVApply :: VExpr -> [Type] -> VM VExpr

-- | Determine the number of <tt>PA</tt> dictionary arguments required for
--   a set of type variables (depends on their kinds).
polyArity :: [TyVar] -> VM Int

module Vectorise.Utils.Hoisting

-- | Records whether we should inline a particular binding.
data Inline
[Inline] :: Arity -> Inline
[DontInline] :: Inline

-- | Add to the arity contained within an <a>Inline</a>, if any.
addInlineArity :: Inline -> Int -> Inline

-- | Says to always inline a binding.
inlineMe :: Inline
hoistBinding :: Var -> CoreExpr -> VM ()
hoistExpr :: FastString -> CoreExpr -> Inline -> VM Var
hoistVExpr :: VExpr -> Inline -> VM VVar

-- | Hoist a polymorphic vectorised expression into a new top-level binding
--   (representing a closure function).
--   
--   The hoisted expression is parameterised by (1) a set of type variables
--   and (2) a set of value variables that are passed as conventional type
--   and value arguments. The latter is implicitly extended by the set of
--   <tt>PA</tt> dictionaries required for the type variables.
hoistPolyVExpr :: [TyVar] -> [Var] -> Inline -> VM VExpr -> VM VExpr
takeHoisted :: VM [(Var, CoreExpr)]


-- | Utils concerning closure construction and application.
module Vectorise.Utils.Closure

-- | Make a closure.
mkClosure :: Type -> Type -> Type -> VExpr -> VExpr -> VM VExpr

-- | Make a closure application.
mkClosureApp :: Type -> Type -> VExpr -> VExpr -> VM VExpr

-- | Build a set of <tt>n</tt> closures corresponding to an <tt>n</tt>-ary
--   vectorised function. The length of the list of types of arguments
--   determines the arity.
--   
--   In addition to a set of type variables, a set of value variables is
--   passed during closure <i>construction</i>. In contrast, the closure
--   environment and the arguments are passed during closure application.
buildClosures :: [TyVar] -> [Var] -> [VVar] -> [Type] -> Type -> VM VExpr -> VM VExpr

module Vectorise.Utils
collectAnnTypeArgs :: AnnExpr b ann -> (AnnExpr b ann, [Type])
collectAnnDictArgs :: AnnExpr Var ann -> (AnnExpr Var ann, [AnnExpr Var ann])
collectAnnTypeBinders :: AnnExpr Var ann -> ([Var], AnnExpr Var ann)

-- | Collect all consecutive value binders that are not dictionaries.
collectAnnValBinders :: AnnExpr Var ann -> ([Var], AnnExpr Var ann)
isAnnTypeArg :: AnnExpr b ann -> Bool

-- | Produce an array containing copies of a given element.
replicatePD :: CoreExpr -> CoreExpr -> VM CoreExpr

-- | An empty array of the given type.
emptyPD :: Type -> VM CoreExpr

-- | Select some elements from an array that correspond to a particular tag
--   value and pack them into a new array.
--   
--   <pre>
--   packByTagPD Int# [:23, 42, 95, 50, 27, 49:]  3 [:1, 2, 1, 2, 3, 2:] 2 
--     ==&gt; [:42, 50, 49:]
--   </pre>
packByTagPD :: Type -> CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr -> VM CoreExpr

-- | Combine some arrays based on a selector. The selector says which
--   source array to choose for each element of the resulting array.
combinePD :: Type -> CoreExpr -> CoreExpr -> [CoreExpr] -> VM CoreExpr

-- | Like <a>replicatePD</a> but use the lifting context in the vectoriser
--   state.
liftPD :: CoreExpr -> VM CoreExpr
isScalar :: Type -> VM Bool
zipScalars :: [Type] -> Type -> VM CoreExpr
scalarClosure :: [Type] -> Type -> CoreExpr -> CoreExpr -> VM CoreExpr

-- | Make a fresh local variable with the given type. The variable's name
--   is formed using the given string as the prefix.
newLocalVar :: FastString -> Type -> VM Var


-- | Compute a description of the generic representation that we use for a
--   user defined data type.
--   
--   During vectorisation, we generate a PRepr and PA instance for each
--   user defined data type. The PA dictionary contains methods to convert
--   the user type to and from our generic representation. This module
--   computes a description of what that generic representation is.
module Vectorise.Generic.Description

-- | Describes the representation type of a data constructor field.
data CompRepr
[Keep] :: Type -> CoreExpr -> CompRepr
[Wrap] :: Type -> CompRepr

-- | Describes the representation type of the fields / components of a
--   constructor. If the data constructor has multiple fields then we
--   bundle them together into a generic product type.
data ProdRepr

-- | Data constructor has no fields.
[EmptyProd] :: ProdRepr

-- | Data constructor has a single field.
[UnaryProd] :: CompRepr -> ProdRepr

-- | Data constructor has several fields.
[Prod] :: TyCon -> TyCon -> TyCon -> [Type] -> [CompRepr] -> ProdRepr

-- | Representation tycon for the product (eg Tuple2)
[repr_tup_tc] :: ProdRepr -> TyCon

-- | PData version of the product tycon (eg PDataTuple2)
[repr_ptup_tc] :: ProdRepr -> TyCon

-- | PDatas version of the product tycon (eg PDatasTuple2s) Not all lifted
--   backends use <tt>PDatas</tt>.
[repr_ptups_tc] :: ProdRepr -> TyCon

-- | Types of each field.
[repr_comp_tys] :: ProdRepr -> [Type]

-- | Generic representation types for each field.
[repr_comps] :: ProdRepr -> [CompRepr]

-- | Describes the representation type of a data constructor.
data ConRepr
[ConRepr] :: DataCon -> ProdRepr -> ConRepr
[repr_dc] :: ConRepr -> DataCon
[repr_prod] :: ConRepr -> ProdRepr

-- | Describes the generic representation of a data type. If the data type
--   has multiple constructors then we bundle them together into a generic
--   sum type.
data SumRepr

-- | Data type has no data constructors.
[EmptySum] :: SumRepr

-- | Data type has a single constructor.
[UnarySum] :: ConRepr -> SumRepr

-- | Data type has multiple constructors.
[Sum] :: TyCon -> TyCon -> TyCon -> Type -> Type -> CoreExpr -> [Type] -> [ConRepr] -> SumRepr

-- | Representation tycon for the sum (eg Sum2)
[repr_sum_tc] :: SumRepr -> TyCon

-- | PData version of the sum tycon (eg PDataSum2) This TyCon doesn't
--   appear explicitly in the source program. See Note [PData TyCons].
[repr_psum_tc] :: SumRepr -> TyCon

-- | PDatas version of the sum tycon (eg PDatasSum2)
[repr_psums_tc] :: SumRepr -> TyCon

-- | Type of the selector (eg Sel2)
[repr_sel_ty] :: SumRepr -> Type

-- | Type of multi-selector (eg Sel2s)
[repr_sels_ty] :: SumRepr -> Type

-- | Function to get the length of a Sels of this type.
[repr_selsLength_v] :: SumRepr -> CoreExpr

-- | Type of each data constructor.
[repr_con_tys] :: SumRepr -> [Type]

-- | Generic representation types of each data constructor.
[repr_cons] :: SumRepr -> [ConRepr]

-- | Determine the generic representation of a data type, given its tycon.
tyConRepr :: TyCon -> VM SumRepr

-- | Yield the type of this sum representation.
sumReprType :: SumRepr -> VM Type

-- | Yield the original component type of a data constructor component
--   representation.
compOrigType :: CompRepr -> Type
instance Outputable SumRepr
instance Outputable ConRepr
instance Outputable ProdRepr
instance Outputable CompRepr


-- | Build instance tycons for the PData and PDatas type families.
--   
--   TODO: the PData and PDatas cases are very similar. We should be able
--   to factor out the common parts.
module Vectorise.Generic.PData

-- | Build the PData instance tycon for a given type constructor.
buildPDataTyCon :: TyCon -> TyCon -> SumRepr -> VM FamInst

-- | Build the PDatas instance tycon for a given type constructor.
buildPDatasTyCon :: TyCon -> TyCon -> SumRepr -> VM FamInst

module Vectorise.Type.Type

-- | Vectorise a type constructor. Unless there is a vectorised version
--   (stripped of embedded parallel arrays), the vectorised version is the
--   same as the original.
vectTyCon :: TyCon -> VM TyCon

-- | Produce the vectorised and lifted versions of a type.
--   
--   NB: Here we are limited to properly handle predicates at the toplevel
--   only. Anything embedded in what is called the <tt>body_ty</tt> below
--   will end up as an argument to the type family <tt>PData</tt>.
vectAndLiftType :: Type -> VM (Type, Type)

-- | Vectorise a type.
--   
--   For each quantified var we need to add a PA dictionary out the front
--   of the type. So forall a. C a =&gt; a -&gt; a turns into forall a. PA
--   a =&gt; Cv a =&gt; a :-&gt; a
vectType :: Type -> VM Type

module Vectorise.Type.TyConDecl

-- | Vectorise some (possibly recursively defined) type constructors.
vectTyConDecls :: [TyCon] -> VM [TyCon]

module Vectorise.Convert

-- | Convert a vectorised expression such that it computes the
--   non-vectorised equivalent of its value.
--   
--   For functions, we eta expand the function and convert the arguments
--   and result:
fromVect :: Type -> CoreExpr -> VM CoreExpr


-- | Vectorise variables and literals.
module Vectorise.Var

-- | Vectorise a binder variable, along with its attached type.
vectBndr :: Var -> VM VVar

-- | Vectorise a binder variable, along with its attached type, but give
--   the result a new name.
vectBndrNew :: Var -> FastString -> VM VVar

-- | Vectorise a binder then run a computation with that binder in scope.
vectBndrIn :: Var -> VM a -> VM (VVar, a)

-- | Vectorise a binder, give it a new name, then run a computation with
--   that binder in scope.
vectBndrNewIn :: Var -> FastString -> VM a -> VM (VVar, a)

-- | Vectorise some binders, then run a computation with them in scope.
vectBndrsIn :: [Var] -> VM a -> VM ([VVar], a)

-- | Vectorise a variable, producing the vectorised and lifted versions.
vectVar :: Var -> VM VExpr

-- | Constants are lifted by replication along the integer context in the
--   <a>VM</a> state for the number of elements in the result array.
vectConst :: CoreExpr -> VM VExpr


-- | Vectorisation of expressions.
module Vectorise.Exp

-- | Vectorise a polymorphic expression that forms a *non-recursive*
--   binding.
--   
--   Return <a>Nothing</a> if the expression is scalar; otherwise, the
--   first component of the result (which is of type <a>Bool</a>) indicates
--   whether the expression is parallel (i.e., whether it is tagged as
--   <a>VIParr</a>).
--   
--   We have got the non-recursive case as a special case as it doesn't
--   require to compute vectorisation information twice.
vectTopExpr :: Var -> CoreExpr -> VM (Maybe (Bool, Inline, CoreExpr))

-- | Vectorise a recursive group of top-level polymorphic expressions.
--   
--   Return <a>Nothing</a> if the expression group is scalar; otherwise,
--   the first component of the result (which is of type <a>Bool</a>)
--   indicates whether the expressions are parallel (i.e., whether they are
--   tagged as <a>VIParr</a>).
vectTopExprs :: [(Var, CoreExpr)] -> VM (Maybe (Bool, [(Inline, CoreExpr)]))

-- | Vectorise an expression of functional type, where all arguments and
--   the result are of primitive types (i.e., <a>Int</a>, <a>Float</a>,
--   <a>Double</a> etc., which have instances of the <tt>Scalar</tt> type
--   class) and which does not contain any subcomputations that involve
--   parallel arrays. Such functionals do not require the full blown
--   vectorisation transformation; instead, they can be lifted by
--   application of a member of the zipWith family (i.e., <a>map</a>,
--   <a>zipWith</a>, zipWith3', etc.)
--   
--   Dictionary functions are also scalar functions (as dictionaries
--   themselves are not vectorised, instead they become dictionaries of
--   vectorised methods). We treat them differently, though see "Note
--   [Scalar dfuns]" in <tt>Vectorise</tt>.
vectScalarFun :: CoreExpr -> VM VExpr

-- | Vectorise a dictionary function that has a 'VECTORISE SCALAR instance'
--   pragma.
--   
--   In other words, all methods in that dictionary are scalar functions —
--   to be vectorised with <a>vectScalarFun</a>. The dictionary "function"
--   itself may be a constant, though.
--   
--   NB: You may think that we could implement this function guided by the
--   struture of the Core expression of the right-hand side of the
--   dictionary function. We cannot proceed like this as
--   <a>vectScalarDFun</a> must also work for *imported* dfuns, where we
--   don't necessarily have access to the Core code of the unvectorised
--   dfun.
--   
--   Here an example — assume,
--   
--   <pre>
--   class Eq a where { (==) :: a -&gt; a -&gt; Bool }
--   instance (Eq a, Eq b) =&gt; Eq (a, b) where { (==) = ... }
--   {-# VECTORISE SCALAR instance Eq (a, b) }
--   </pre>
--   
--   The unvectorised dfun for the above instance has the following
--   signature:
--   
--   <pre>
--   $dEqPair :: forall a b. Eq a -&gt; Eq b -&gt; Eq (a, b)
--   </pre>
--   
--   We generate the following (scalar) vectorised dfun (liberally using TH
--   notation):
--   
--   <pre>
--   $v$dEqPair :: forall a b. V:Eq a -&gt; V:Eq b -&gt; V:Eq (a, b)
--   $v$dEqPair = /\a b -&gt; \dEqa :: V:Eq a -&gt; \dEqb :: V:Eq b -&gt;
--                  D:V:Eq $(vectScalarFun True recFns 
--                           [| (==) @(a, b) ($dEqPair @a @b $(unVect dEqa) $(unVect dEqb)) |])
--   </pre>
--   
--   NB: * '(,)' vectorises to '(,)' — hence, the type constructor in the
--   result type remains the same. * We share the '$(unVect di)'
--   sub-expressions between the different selectors, but duplicate the
--   application of the unvectorised dfun, to enable the dictionary
--   selection rules to fire.
vectScalarDFun :: Var -> VM CoreExpr
instance Show VectAvoidInfo
instance Eq VectAvoidInfo


-- | Generate methods for the PA class.
--   
--   TODO: there is a large amount of redundancy here between the a, PData
--   a, and PDatas a forms. See if we can factor some of this out.
module Vectorise.Generic.PAMethods
buildPReprTyCon :: TyCon -> TyCon -> SumRepr -> VM FamInst
buildPAScAndMethods :: VM [(String, PAInstanceBuilder)]

module Vectorise.Generic.PADict

-- | Build the PA dictionary function for some type and hoist it to top
--   level.
--   
--   The PA dictionary holds fns that convert values to and from their
--   vectorised representations.
--   
--   @Recall the definition: class PR (PRepr a) =&gt; PA a where toPRepr ::
--   a -&gt; PRepr a fromPRepr :: PRepr a -&gt; a toArrPRepr :: PData a
--   -&gt; PData (PRepr a) fromArrPRepr :: PData (PRepr a) -&gt; PData a
--   toArrPReprs :: PDatas a -&gt; PDatas (PRepr a) fromArrPReprs :: PDatas
--   (PRepr a) -&gt; PDatas a
--   
--   Example: df :: forall a. PR (PRepr a) -&gt; PA a -&gt; PA (T a) df =
--   /a. (c:PR (PRepr a)) (d:PA a). MkPA c ($PR_df a d) ($toPRepr a d) ...
--   $dPR_df :: forall a. PA a -&gt; PR (PRepr (T a)) $dPR_df = ....
--   $toRepr :: forall a. PA a -&gt; T a -&gt; PRepr (T a) $toPRepr = ...
--   The "..." stuff is filled in by buildPAScAndMethods @
buildPADict :: TyCon -> CoAxiom Unbranched -> TyCon -> TyCon -> SumRepr -> VM Var

module Vectorise.Type.Env

-- | Vectorise type constructor including class type constructors.
vectTypeEnv :: [TyCon] -> [CoreVect] -> [CoreVect] -> VM ([TyCon], [FamInst], [(Var, CoreExpr)])

module Vectorise

-- | Vectorise a single module.
vectorise :: ModGuts -> CoreM ModGuts

module SimplCore
core2core :: HscEnv -> ModGuts -> IO ModGuts
simplifyExpr :: DynFlags -> CoreExpr -> IO CoreExpr


-- | Main API for compiling plain Haskell source code.
--   
--   This module implements compilation of a Haskell source. It is
--   <i>not</i> concerned with preprocessing of source files; this is
--   handled in <a>DriverPipeline</a>.
--   
--   There are various entry points depending on what mode we're in:
--   "batch" mode (<tt>--make</tt>), "one-shot" mode (<tt>-c</tt>,
--   <tt>-S</tt> etc.), and "interactive" mode (GHCi). There are also entry
--   points for individual passes: parsing, typechecking/renaming,
--   desugaring, and simplification.
--   
--   All the functions here take an <a>HscEnv</a> as a parameter, but none
--   of them return a new one: <a>HscEnv</a> is treated as an immutable
--   value from here on in (although it has mutable components, for the
--   caches).
--   
--   Warning messages are dealt with consistently throughout this API:
--   during compilation warnings are collected, and before any function in
--   <tt>HscMain</tt> returns, the warnings are either printed, or turned
--   into a real compialtion error if the <tt>-Werror</tt> flag is enabled.
--   
--   (c) The GRASP/AQUA Project, Glasgow University, 1993-2000
module HscMain
newHscEnv :: DynFlags -> IO HscEnv
type Messager = HscEnv -> (Int, Int) -> RecompileRequired -> ModSummary -> IO ()
batchMsg :: Messager

-- | Status of a compilation to hard-code
data HscStatus
[HscNotGeneratingCode] :: HscStatus
[HscUpToDate] :: HscStatus
[HscUpdateBoot] :: HscStatus
[HscUpdateSig] :: HscStatus
[HscRecomp] :: CgGuts -> ModSummary -> HscStatus
hscCompileOneShot :: HscEnv -> ModSummary -> SourceModified -> IO HscStatus
hscCompileCmmFile :: HscEnv -> FilePath -> FilePath -> IO ()
hscCompileCore :: HscEnv -> Bool -> SafeHaskellMode -> ModSummary -> CoreProgram -> FilePath -> IO ()
genericHscCompileGetFrontendResult :: Bool -> Maybe TcGblEnv -> Maybe Messager -> HscEnv -> ModSummary -> SourceModified -> Maybe ModIface -> (Int, Int) -> IO (Either ModIface (TcGblEnv, Maybe Fingerprint))
genModDetails :: HscEnv -> ModIface -> IO ModDetails
hscSimpleIface :: HscEnv -> TcGblEnv -> Maybe Fingerprint -> IO (ModIface, Bool, ModDetails)
hscWriteIface :: DynFlags -> ModIface -> Bool -> ModSummary -> IO ()
hscNormalIface :: HscEnv -> ModGuts -> Maybe Fingerprint -> IO (ModIface, Bool, ModDetails, CgGuts)

-- | Compile to hard-code.
hscGenHardCode :: HscEnv -> CgGuts -> ModSummary -> FilePath -> IO (FilePath, Maybe FilePath)
hscInteractive :: HscEnv -> CgGuts -> ModSummary -> IO (Maybe FilePath, CompiledByteCode, ModBreaks)

-- | parse a file, returning the abstract syntax
hscParse :: HscEnv -> ModSummary -> IO HsParsedModule

-- | Rename and typecheck a module, additionally returning the renamed
--   syntax
hscTypecheckRename :: HscEnv -> ModSummary -> HsParsedModule -> IO (TcGblEnv, RenamedStuff)

-- | Convert a typechecked module to Core
hscDesugar :: HscEnv -> ModSummary -> TcGblEnv -> IO ModGuts

-- | Make a <a>ModIface</a> from the results of typechecking. Used when not
--   optimising, and the interface doesn't need to contain any unfoldings
--   or other cross-module optimisation info. ToDo: the old interface is
--   only needed to get the version numbers, we should use fingerprint
--   versions instead.
makeSimpleIface :: HscEnv -> Maybe ModIface -> TcGblEnv -> ModDetails -> IO (ModIface, Bool)

-- | Make a <a>ModDetails</a> from the results of typechecking. Used when
--   typechecking only, as opposed to full compilation.
makeSimpleDetails :: HscEnv -> TcGblEnv -> IO ModDetails
hscSimplify :: HscEnv -> ModGuts -> IO ModGuts
hscParseIdentifier :: HscEnv -> String -> IO (Located RdrName)
hscTcRcLookupName :: HscEnv -> Name -> IO (Maybe TyThing)
hscTcRnGetInfo :: HscEnv -> Name -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))

-- | Check that a module is safe to import.
--   
--   We return True to indicate the import is safe and False otherwise
--   although in the False case an exception may be thrown first.
hscCheckSafe :: HscEnv -> Module -> SrcSpan -> IO Bool

-- | Return if a module is trusted and the pkgs it depends on to be
--   trusted.
hscGetSafe :: HscEnv -> Module -> SrcSpan -> IO (Bool, [PackageKey])
hscIsGHCiMonad :: HscEnv -> String -> IO Name
hscGetModuleInterface :: HscEnv -> Module -> IO ModIface

-- | Rename some import declarations
hscRnImportDecls :: HscEnv -> [LImportDecl RdrName] -> IO GlobalRdrEnv

-- | Lookup things in the compiler's environment
hscTcRnLookupRdrName :: HscEnv -> RdrName -> IO [Name]

-- | Compile a stmt all the way to an HValue, but don't run it
--   
--   We return Nothing to indicate an empty statement (or comment only),
--   not a parse error.
hscStmt :: HscEnv -> String -> IO (Maybe ([Id], IO [HValue], FixityEnv))

-- | Compile a stmt all the way to an HValue, but don't run it
--   
--   We return Nothing to indicate an empty statement (or comment only),
--   not a parse error.
hscStmtWithLocation :: HscEnv -> String -> String -> Int -> IO (Maybe ([Id], IO [HValue], FixityEnv))

-- | Compile a decls
hscDecls :: HscEnv -> String -> IO ([TyThing], InteractiveContext)

-- | Compile a decls
hscDeclsWithLocation :: HscEnv -> String -> String -> Int -> IO ([TyThing], InteractiveContext)

-- | Typecheck an expression (but don't run it) Returns its most general
--   type
hscTcExpr :: HscEnv -> String -> IO Type
hscImport :: HscEnv -> String -> IO (ImportDecl RdrName)

-- | Find the kind of a type Currently this does *not* generalise the kinds
--   of the type
hscKcType :: HscEnv -> Bool -> String -> IO (Type, Kind)
hscCompileCoreExpr :: HscEnv -> SrcSpan -> CoreExpr -> IO HValue
hscCompileCoreExpr' :: HscEnv -> SrcSpan -> CoreExpr -> IO HValue
hscParse' :: ModSummary -> Hsc HsParsedModule
hscSimplify' :: ModGuts -> Hsc ModGuts
hscDesugar' :: ModLocation -> TcGblEnv -> Hsc ModGuts
tcRnModule' :: HscEnv -> ModSummary -> Bool -> HsParsedModule -> Hsc TcGblEnv
getHscEnv :: Hsc HscEnv
hscSimpleIface' :: TcGblEnv -> Maybe Fingerprint -> Hsc (ModIface, Bool, ModDetails)
hscNormalIface' :: ModGuts -> Maybe Fingerprint -> Hsc (ModIface, Bool, ModDetails, CgGuts)
oneShotMsg :: HscEnv -> RecompileRequired -> IO ()
hscFileFrontEnd :: ModSummary -> Hsc TcGblEnv
genericHscFrontend :: ModSummary -> Hsc TcGblEnv
dumpIfaceStats :: HscEnv -> IO ()

module DriverPipeline
oneShot :: HscEnv -> Phase -> [(String, Maybe Phase)] -> IO ()
compileFile :: HscEnv -> Phase -> (FilePath, Maybe Phase) -> IO FilePath
linkBinary :: DynFlags -> [FilePath] -> [PackageKey] -> IO ()

-- | Just preprocess a file, put the result in a temp. file (used by the
--   compilation manager during the summary phase).
--   
--   We return the augmented DynFlags, because they contain the result of
--   slurping in the OPTIONS pragmas
preprocess :: HscEnv -> (FilePath, Maybe Phase) -> IO (DynFlags, FilePath)

-- | Compile
--   
--   Compile a single module, under the control of the compilation manager.
--   
--   This is the interface between the compilation manager and the compiler
--   proper (hsc), where we deal with tedious details like reading the
--   OPTIONS pragma from the source file, converting the C or assembly that
--   GHC produces into an object file, and compiling FFI stub files.
--   
--   NB. No old interface can also mean that the source has changed.
compileOne :: HscEnv -> ModSummary -> Int -> Int -> Maybe ModIface -> Maybe Linkable -> SourceModified -> IO HomeModInfo
compileOne' :: Maybe TcGblEnv -> Maybe Messager -> HscEnv -> ModSummary -> Int -> Int -> Maybe ModIface -> Maybe Linkable -> SourceModified -> IO HomeModInfo
link :: GhcLink -> DynFlags -> Bool -> HomePackageTable -> IO SuccessFlag
data PhasePlus
[RealPhase] :: Phase -> PhasePlus
[HscOut] :: HscSource -> ModuleName -> HscStatus -> PhasePlus
newtype CompPipeline a
[P] :: (PipeEnv -> PipeState -> IO (PipeState, a)) -> CompPipeline a
[unP] :: CompPipeline a -> PipeEnv -> PipeState -> IO (PipeState, a)
data PipeEnv
[PipeEnv] :: Bool -> Phase -> String -> String -> String -> PipelineOutput -> PipeEnv
[pe_isHaskellishFile] :: PipeEnv -> Bool

-- | Stop just before this phase
[stop_phase] :: PipeEnv -> Phase

-- | basename of original input source
[src_filename] :: PipeEnv -> String

-- | basename of original input source
[src_basename] :: PipeEnv -> String

-- | its extension
[src_suffix] :: PipeEnv -> String

-- | says where to put the pipeline output
[output_spec] :: PipeEnv -> PipelineOutput
data PipeState
[PipeState] :: HscEnv -> Maybe ModLocation -> Maybe FilePath -> PipeState

-- | only the DynFlags change in the HscEnv. The DynFlags change at various
--   points, for example when we read the OPTIONS_GHC pragmas in the Cpp
--   phase.
[hsc_env] :: PipeState -> HscEnv

-- | the ModLocation. This is discovered during compilation, in the Hsc
--   phase where we read the module header.
[maybe_loc] :: PipeState -> Maybe ModLocation

-- | the stub object. This is set by the Hsc phase if a stub object was
--   created. The stub object will be joined with the main compilation
--   object using "ld -r" at the end.
[maybe_stub_o] :: PipeState -> Maybe FilePath
phaseOutputFilename :: Phase -> CompPipeline FilePath
getPipeState :: CompPipeline PipeState
getPipeEnv :: CompPipeline PipeEnv

-- | What phase to run after one of the backend code generators has run
hscPostBackendPhase :: DynFlags -> HscSource -> HscTarget -> Phase
getLocation :: HscSource -> ModuleName -> CompPipeline ModLocation
setModLocation :: ModLocation -> CompPipeline ()
setDynFlags :: DynFlags -> CompPipeline ()

-- | Each phase in the pipeline returns the next phase to execute, and the
--   name of the file in which the output was placed.
--   
--   We must do things dynamically this way, because we often don't know
--   what the rest of the phases will be until part-way through the
--   compilation: for example, an {--} at the beginning of a source file
--   can change the latter stages of the pipeline from taking the LLVM
--   route to using the native code generator.
runPhase :: PhasePlus -> FilePath -> DynFlags -> CompPipeline (PhasePlus, FilePath)
exeFileName :: Bool -> DynFlags -> FilePath
mkExtraObjToLinkIntoBinary :: DynFlags -> IO FilePath
mkNoteObjsToLinkIntoBinary :: DynFlags -> [PackageKey] -> IO [FilePath]
maybeCreateManifest :: DynFlags -> FilePath -> IO [FilePath]
runPhase_MoveBinary :: DynFlags -> FilePath -> IO Bool
linkingNeeded :: DynFlags -> Bool -> [Linkable] -> [PackageKey] -> IO Bool
checkLinkInfo :: DynFlags -> [PackageKey] -> FilePath -> IO Bool
writeInterfaceOnlyMode :: DynFlags -> Bool

module GhcMake

-- | Perform a dependency analysis starting from the current targets and
--   update the session with the new module graph.
--   
--   Dependency analysis entails parsing the <tt>import</tt> directives and
--   may therefore require running certain preprocessors.
--   
--   Note that each <a>ModSummary</a> in the module graph caches its
--   <a>DynFlags</a>. These <a>DynFlags</a> are determined by the
--   <i>current</i> session <a>DynFlags</a> and the <tt>OPTIONS</tt> and
--   <tt>LANGUAGE</tt> pragmas of the parsed module. Thus if you want to
--   changes to the <a>DynFlags</a> to take effect you need to call this
--   function again.
depanal :: GhcMonad m => [ModuleName] -> Bool -> m ModuleGraph

-- | Try to load the program. See <a>LoadHowMuch</a> for the different
--   modes.
--   
--   This function implements the core of GHC's <tt>--make</tt> mode. It
--   preprocesses, compiles and loads the specified modules, avoiding
--   re-compilation wherever possible. Depending on the target (see
--   <a>hscTarget</a>) compilating and loading may result in files being
--   created on disk.
--   
--   Calls the <tt>reportModuleCompilationResult</tt> callback after each
--   compiling each module, whether successful or not.
--   
--   Throw a <a>SourceError</a> if errors are encountered before the actual
--   compilation starts (e.g., during dependency analysis). All other
--   errors are reported using the callback.
load :: GhcMonad m => LoadHowMuch -> m SuccessFlag

-- | Describes which modules of the module graph need to be loaded.
data LoadHowMuch

-- | Load all targets and its dependencies.
[LoadAllTargets] :: LoadHowMuch

-- | Load only the given module and its dependencies.
[LoadUpTo] :: ModuleName -> LoadHowMuch

-- | Load only the dependencies of the given module, but not the module
--   itself.
[LoadDependenciesOf] :: ModuleName -> LoadHowMuch

-- | 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)?
--   
--   <ul>
--   <li><tt>False</tt>: treat the hi-boot summaries as nodes of the graph,
--   so the graph must be acyclic</li>
--   <li><tt>True</tt>: 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</li>
--   </ul>
topSortModuleGraph :: Bool -> [ModSummary] -> Maybe ModuleName -> [SCC ModSummary]
noModError :: DynFlags -> SrcSpan -> ModuleName -> FindResult -> ErrMsg
cyclicModuleErr :: [ModSummary] -> SDoc
instance Read IsBoot
instance Show IsBoot
instance Eq IsBoot
instance Ord IsBoot

module InteractiveEval
data RunResult

-- | names bound by this evaluation
[RunOk] :: [Name] -> RunResult

-- | statement raised an exception
[RunException] :: SomeException -> RunResult
[RunBreak] :: ThreadId -> [Name] -> (Maybe BreakInfo) -> RunResult
data Status

-- | the computation hit a breakpoint (Bool <a>=</a> was an exception)
[Break] :: Bool -> HValue -> BreakInfo -> ThreadId -> Status

-- | the computation completed with either an exception or a value
[Complete] :: (Either SomeException [HValue]) -> Status
data Resume
[Resume] :: String -> ThreadId -> MVar () -> MVar Status -> ([TyThing], GlobalRdrEnv) -> [Id] -> HValue -> Maybe BreakInfo -> SrcSpan -> [History] -> Int -> Resume
[resumeStmt] :: Resume -> String
[resumeThreadId] :: Resume -> ThreadId
[resumeBreakMVar] :: Resume -> MVar ()
[resumeStatMVar] :: Resume -> MVar Status
[resumeBindings] :: Resume -> ([TyThing], GlobalRdrEnv)
[resumeFinalIds] :: Resume -> [Id]
[resumeApStack] :: Resume -> HValue
[resumeBreakInfo] :: Resume -> Maybe BreakInfo
[resumeSpan] :: Resume -> SrcSpan
[resumeHistory] :: Resume -> [History]
[resumeHistoryIx] :: Resume -> Int
data History
[History] :: HValue -> BreakInfo -> [String] -> History
[historyApStack] :: History -> HValue
[historyBreakInfo] :: History -> BreakInfo
[historyEnclosingDecls] :: History -> [String]

-- | Run a statement in the current interactive context. Statement may bind
--   multple values.
runStmt :: GhcMonad m => String -> SingleStep -> m RunResult

-- | Run a statement in the current interactive context. Passing debug
--   information Statement may bind multple values.
runStmtWithLocation :: GhcMonad m => String -> Int -> String -> SingleStep -> m RunResult
runDecls :: GhcMonad m => String -> m [Name]
runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name]
parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
data SingleStep
[RunToCompletion] :: SingleStep
[SingleStep] :: SingleStep
[RunAndLogSteps] :: SingleStep
resume :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> m RunResult
abandon :: GhcMonad m => m Bool
abandonAll :: GhcMonad m => m Bool
getResumeContext :: GhcMonad m => m [Resume]
getHistorySpan :: HscEnv -> History -> SrcSpan
getModBreaks :: HomeModInfo -> ModBreaks
getHistoryModule :: History -> Module
back :: GhcMonad m => m ([Name], Int, SrcSpan)
forward :: GhcMonad m => m ([Name], Int, SrcSpan)

-- | Set the interactive evaluation context.
--   
--   (setContext imports) sets the ic_imports field (which in turn
--   determines what is in scope at the prompt) to <tt>imports</tt>, 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.)
setContext :: GhcMonad m => [InteractiveImport] -> m ()

-- | 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.
getContext :: GhcMonad m => m [InteractiveImport]
availsToGlobalRdrEnv :: ModuleName -> [AvailInfo] -> GlobalRdrEnv

-- | Returns all names in scope in the current interactive context
getNamesInScope :: GhcMonad m => m [Name]
getRdrNamesInScope :: GhcMonad m => m [RdrName]

-- | Returns <tt>True</tt> if the specified module is interpreted, and
--   hence has its full top-level scope available.
moduleIsInterpreted :: GhcMonad m => Module -> m Bool

-- | 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)
getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))

-- | Get the type of an expression Returns its most general type
exprType :: GhcMonad m => String -> m Type

-- | Get the kind of a type
typeKind :: GhcMonad m => Bool -> String -> m (Type, Kind)

-- | Parses a string as an identifier, and returns the list of <a>Name</a>s
--   that the identifier can refer to in the current interactive context.
parseName :: GhcMonad m => String -> m [Name]
showModule :: GhcMonad m => ModSummary -> m String
isModuleInterpreted :: GhcMonad m => ModSummary -> m Bool
compileExpr :: GhcMonad m => String -> m HValue
dynCompileExpr :: GhcMonad m => String -> m Dynamic
data Term
[Term] :: RttiType -> Either String DataCon -> HValue -> [Term] -> Term
[ty] :: Term -> RttiType
[dc] :: Term -> Either String DataCon
[val] :: Term -> HValue
[subTerms] :: Term -> [Term]
[Prim] :: RttiType -> [Word] -> Term
[ty] :: Term -> RttiType
[value] :: Term -> [Word]
[Suspension] :: ClosureType -> RttiType -> HValue -> Maybe Name -> Term
[ctype] :: Term -> ClosureType
[ty] :: Term -> RttiType
[val] :: Term -> HValue
[bound_to] :: Term -> Maybe Name
[NewtypeWrap] :: RttiType -> Either String DataCon -> Term -> Term
[ty] :: Term -> RttiType
[dc] :: Term -> Either String DataCon
[wrapped_term] :: Term -> Term
[RefWrap] :: RttiType -> Term -> Term
[ty] :: Term -> RttiType
[wrapped_term] :: Term -> Term
obtainTermFromId :: HscEnv -> Int -> Bool -> Id -> IO Term
obtainTermFromVal :: HscEnv -> Int -> Bool -> Type -> a -> IO Term
reconstructType :: HscEnv -> Int -> Id -> IO (Maybe Type)

module GHC

-- | 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.
defaultErrorHandler :: (ExceptionMonad m, MonadIO m) => FatalMessager -> FlushOut -> m a -> m a

-- | Install a default cleanup handler to remove temporary files deposited
--   by a GHC run. This is separate from <a>defaultErrorHandler</a>,
--   because you might want to override the error handling, but still get
--   the ordinary cleanup behaviour.
defaultCleanupHandler :: (ExceptionMonad m, MonadIO m) => DynFlags -> m a -> m a
prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a

-- | A minimal implementation of a <a>GhcMonad</a>. If you need a custom
--   monad, e.g., to maintain additional state consider wrapping this monad
--   or using <a>GhcT</a>.
data Ghc a

-- | A monad transformer to add GHC specific features to another monad.
--   
--   Note that the wrapped monad must support IO and handling of
--   exceptions.
data GhcT m a

-- | A monad that has all the features needed by GHC API calls.
--   
--   In short, a GHC monad
--   
--   <ul>
--   <li>allows embedding of IO actions,</li>
--   <li>can log warnings,</li>
--   <li>allows handling of (extensible) exceptions, and</li>
--   <li>maintains a current session.</li>
--   </ul>
--   
--   If you do not use <a>Ghc</a> or <a>GhcT</a>, make sure to call
--   <a>initGhcMonad</a> before any call to the GHC API functions can
--   occur.
class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m
getSession :: GhcMonad m => m HscEnv
setSession :: GhcMonad m => HscEnv -> m ()

-- | Hscenv is like <tt>Session</tt>, except that some of the fields are
--   immutable. An HscEnv is used to compile a single module from plain
--   Haskell source code (after preprocessing) to either C, assembly or
--   C--. Things like the module graph don't change during a single
--   compilation.
--   
--   Historical note: "hsc" used to be the name of the compiler binary,
--   when there was a separate driver and compiler. To compile a single
--   module, the driver would invoke hsc on the source code... so nowadays
--   we think of hsc as the layer of the compiler that deals with compiling
--   a single module.
data HscEnv

-- | Run function for the <a>Ghc</a> monad.
--   
--   It initialises the GHC session and warnings via <a>initGhcMonad</a>.
--   Each call to this function will create a new session which should not
--   be shared among several threads.
--   
--   Any errors not handled inside the <a>Ghc</a> action are propagated as
--   IO exceptions.
runGhc :: Maybe FilePath -> Ghc a -> IO a

-- | Run function for <a>GhcT</a> monad transformer.
--   
--   It initialises the GHC session and warnings via <a>initGhcMonad</a>.
--   Each call to this function will create a new session which should not
--   be shared among several threads.
runGhcT :: (ExceptionMonad m, Functor m, MonadIO m) => Maybe FilePath -> GhcT m a -> m a

-- | Initialise a GHC session.
--   
--   If you implement a custom <a>GhcMonad</a> 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 <tt>ghc
--   --print-libdir</tt> of the version of GHC the module using this API is
--   compiled with. For portability, you should use the <tt>ghc-paths</tt>
--   package, available at
--   <a>http://hackage.haskell.org/package/ghc-paths</a>.
initGhcMonad :: GhcMonad m => Maybe FilePath -> m ()

-- | Generalised version of <a>catch</a>, allowing an arbitrary exception
--   handling monad instead of just <a>IO</a>.
gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a

-- | Generalised version of <a>bracket</a>, allowing an arbitrary exception
--   handling monad instead of just <a>IO</a>.
gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c

-- | Generalised version of <a>finally</a>, allowing an arbitrary exception
--   handling monad instead of just <a>IO</a>.
gfinally :: ExceptionMonad m => m a -> m b -> m a

-- | Print the error message and all warnings. Useful inside exception
--   handlers. Clears warnings after printing.
printException :: GhcMonad m => SourceError -> m ()

-- | Perform the given action and call the exception handler if the action
--   throws a <a>SourceError</a>. See <a>SourceError</a> for more
--   information.
handleSourceError :: (ExceptionMonad m) => (SourceError -> m a) -> m a -> m a

-- | Determines whether a set of modules requires Template Haskell.
--   
--   Note that if the session's <a>DynFlags</a> enabled Template Haskell
--   when <a>depanal</a> was called, then each module in the returned
--   module graph will have Template Haskell enabled whether it is actually
--   needed or not.
needsTemplateHaskell :: ModuleGraph -> Bool

-- | Contains not only a collection of <a>GeneralFlag</a>s but also a
--   plethora of information relating to the compilation of a single file
--   or GHC session
data DynFlags
[DynFlags] :: GhcMode -> GhcLink -> HscTarget -> Settings -> SigOf -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe Int -> Bool -> Maybe Int -> Maybe Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Int -> Maybe Int -> Int -> [String] -> [FilePath] -> Module -> Maybe String -> Int -> Int -> PackageKey -> [Way] -> String -> String -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> IORef Bool -> String -> String -> Maybe FilePath -> Maybe [Set String] -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Maybe FilePath -> Maybe FilePath -> [Option] -> [String] -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> String -> [ModuleName] -> [(ModuleName, String)] -> Hooks -> FilePath -> Bool -> [ModuleName] -> [String] -> ([PkgConfRef] -> [PkgConfRef]) -> [PackageFlag] -> Maybe FilePath -> Maybe [PackageConfig] -> PackageState -> IORef [FilePath] -> IORef (Map FilePath FilePath) -> IORef [FilePath] -> IORef Int -> IORef (Set FilePath) -> IntSet -> IntSet -> IntSet -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff ExtensionFlag] -> IntSet -> Int -> Int -> Int -> Int -> Float -> Int -> Int -> Int -> LogAction -> FlushOut -> FlushErr -> Maybe String -> [String] -> Int -> Int -> Int -> Bool -> ProfAuto -> Maybe String -> IORef Int -> IORef (ModuleEnv Int) -> Maybe SseVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IORef (Maybe LinkerInfo) -> IORef (Maybe CompilerInfo) -> Int -> Int -> Int -> DynFlags
[ghcMode] :: DynFlags -> GhcMode
[ghcLink] :: DynFlags -> GhcLink
[hscTarget] :: DynFlags -> HscTarget
[settings] :: DynFlags -> Settings

-- | Compiling an hs-boot against impl.
[sigOf] :: DynFlags -> SigOf

-- | Verbosity level: see Note [Verbosity levels]
[verbosity] :: DynFlags -> Int

-- | Optimisation level
[optLevel] :: DynFlags -> Int

-- | Number of simplifier phases
[simplPhases] :: DynFlags -> Int

-- | Max simplifier iterations
[maxSimplIterations] :: DynFlags -> Int
[ruleCheck] :: DynFlags -> Maybe String

-- | Additional demand analysis
[strictnessBefore] :: DynFlags -> [Int]

-- | The number of modules to compile in parallel in --make mode, where
--   Nothing ==&gt; compile as many in parallel as there are CPUs.
[parMakeCount] :: DynFlags -> Maybe Int

-- | Enable RTS timing statistics?
[enableTimeStats] :: DynFlags -> Bool

-- | The heap size to set.
[ghcHeapSize] :: DynFlags -> Maybe Int

-- | Maximum number of bindings from the type envt to show in type error
--   messages
[maxRelevantBinds] :: DynFlags -> Maybe Int

-- | Multiplier for simplifier ticks
[simplTickFactor] :: DynFlags -> Int

-- | Threshold for SpecConstr
[specConstrThreshold] :: DynFlags -> Maybe Int

-- | Max number of specialisations for any one function
[specConstrCount] :: DynFlags -> Maybe Int

-- | Max number of specialisations for recursive types Not optional;
--   otherwise ForceSpecConstr can diverge.
[specConstrRecursive] :: DynFlags -> Int

-- | Threshold for LiberateCase
[liberateCaseThreshold] :: DynFlags -> Maybe Int

-- | Arg count for lambda floating See CoreMonad.FloatOutSwitches
[floatLamArgs] :: DynFlags -> Maybe Int
[historySize] :: DynFlags -> Int

-- | <pre>
--   -#includes
--   </pre>
[cmdlineHcIncludes] :: DynFlags -> [String]
[importPaths] :: DynFlags -> [FilePath]
[mainModIs] :: DynFlags -> Module
[mainFunIs] :: DynFlags -> Maybe String

-- | Typechecker context stack depth
[ctxtStkDepth] :: DynFlags -> Int

-- | Typechecker type function stack depth
[tyFunStkDepth] :: DynFlags -> Int

-- | name of package currently being compiled
[thisPackage] :: DynFlags -> PackageKey

-- | Way flags from the command line
[ways] :: DynFlags -> [Way]

-- | The global "way" (e.g. "p" for prof)
[buildTag] :: DynFlags -> String

-- | The RTS "way"
[rtsBuildTag] :: DynFlags -> String
[splitInfo] :: DynFlags -> Maybe (String, Int)
[objectDir] :: DynFlags -> Maybe String
[dylibInstallName] :: DynFlags -> Maybe String
[hiDir] :: DynFlags -> Maybe String
[stubDir] :: DynFlags -> Maybe String
[dumpDir] :: DynFlags -> Maybe String
[objectSuf] :: DynFlags -> String
[hcSuf] :: DynFlags -> String
[hiSuf] :: DynFlags -> String
[canGenerateDynamicToo] :: DynFlags -> IORef Bool
[dynObjectSuf] :: DynFlags -> String
[dynHiSuf] :: DynFlags -> String
[dllSplitFile] :: DynFlags -> Maybe FilePath
[dllSplit] :: DynFlags -> Maybe [Set String]
[outputFile] :: DynFlags -> Maybe String
[dynOutputFile] :: DynFlags -> Maybe String
[outputHi] :: DynFlags -> Maybe String
[dynLibLoader] :: DynFlags -> DynLibLoader

-- | This is set by <a>runPipeline</a> based on where its output is going.
[dumpPrefix] :: DynFlags -> Maybe FilePath

-- | Override the <a>dumpPrefix</a> set by <a>runPipeline</a>. Set by
--   <tt>-ddump-file-prefix</tt>
[dumpPrefixForce] :: DynFlags -> Maybe FilePath
[ldInputs] :: DynFlags -> [Option]
[includePaths] :: DynFlags -> [String]
[libraryPaths] :: DynFlags -> [String]
[frameworkPaths] :: DynFlags -> [String]
[cmdlineFrameworks] :: DynFlags -> [String]
[rtsOpts] :: DynFlags -> Maybe String
[rtsOptsEnabled] :: DynFlags -> RtsOptsEnabled

-- | Path to store the .mix files
[hpcDir] :: DynFlags -> String
[pluginModNames] :: DynFlags -> [ModuleName]
[pluginModNameOpts] :: DynFlags -> [(ModuleName, String)]
[hooks] :: DynFlags -> Hooks
[depMakefile] :: DynFlags -> FilePath
[depIncludePkgDeps] :: DynFlags -> Bool
[depExcludeMods] :: DynFlags -> [ModuleName]
[depSuffixes] :: DynFlags -> [String]

-- | The <tt>-package-db</tt> flags given on the command line, in the order
--   they appeared.
[extraPkgConfs] :: DynFlags -> [PkgConfRef] -> [PkgConfRef]

-- | The <tt>-package</tt> and <tt>-hide-package</tt> flags from the
--   command-line
[packageFlags] :: DynFlags -> [PackageFlag]

-- | Filepath to the package environment file (if overriding default)
[packageEnv] :: DynFlags -> Maybe FilePath
[pkgDatabase] :: DynFlags -> Maybe [PackageConfig]
[pkgState] :: DynFlags -> PackageState
[filesToClean] :: DynFlags -> IORef [FilePath]
[dirsToClean] :: DynFlags -> IORef (Map FilePath FilePath)
[filesToNotIntermediateClean] :: DynFlags -> IORef [FilePath]
[nextTempSuffix] :: DynFlags -> IORef Int
[generatedDumps] :: DynFlags -> IORef (Set FilePath)
[dumpFlags] :: DynFlags -> IntSet
[generalFlags] :: DynFlags -> IntSet
[warningFlags] :: DynFlags -> IntSet
[language] :: DynFlags -> Maybe Language

-- | Safe Haskell mode
[safeHaskell] :: DynFlags -> SafeHaskellMode
[safeInfer] :: DynFlags -> Bool
[safeInferred] :: DynFlags -> Bool
[thOnLoc] :: DynFlags -> SrcSpan
[newDerivOnLoc] :: DynFlags -> SrcSpan
[overlapInstLoc] :: DynFlags -> SrcSpan
[incoherentOnLoc] :: DynFlags -> SrcSpan
[pkgTrustOnLoc] :: DynFlags -> SrcSpan
[warnSafeOnLoc] :: DynFlags -> SrcSpan
[warnUnsafeOnLoc] :: DynFlags -> SrcSpan
[trustworthyOnLoc] :: DynFlags -> SrcSpan
[extensions] :: DynFlags -> [OnOff ExtensionFlag]
[extensionFlags] :: DynFlags -> IntSet
[ufCreationThreshold] :: DynFlags -> Int
[ufUseThreshold] :: DynFlags -> Int
[ufFunAppDiscount] :: DynFlags -> Int
[ufDictDiscount] :: DynFlags -> Int
[ufKeenessFactor] :: DynFlags -> Float
[ufDearOp] :: DynFlags -> Int
[maxWorkerArgs] :: DynFlags -> Int
[ghciHistSize] :: DynFlags -> Int

-- | MsgDoc output action: use <a>ErrUtils</a> instead of this if you can
[log_action] :: DynFlags -> LogAction
[flushOut] :: DynFlags -> FlushOut
[flushErr] :: DynFlags -> FlushErr
[haddockOptions] :: DynFlags -> Maybe String
[ghciScripts] :: DynFlags -> [String]
[pprUserLength] :: DynFlags -> Int
[pprCols] :: DynFlags -> Int
[traceLevel] :: DynFlags -> Int
[useUnicode] :: DynFlags -> Bool

-- | what kind of {--} to add automatically
[profAuto] :: DynFlags -> ProfAuto
[interactivePrint] :: DynFlags -> Maybe String
[llvmVersion] :: DynFlags -> IORef Int
[nextWrapperNum] :: DynFlags -> IORef (ModuleEnv Int)

-- | Machine dependant flags (-m<a>blah</a> stuff)
[sseVersion] :: DynFlags -> Maybe SseVersion
[avx] :: DynFlags -> Bool
[avx2] :: DynFlags -> Bool
[avx512cd] :: DynFlags -> Bool
[avx512er] :: DynFlags -> Bool
[avx512f] :: DynFlags -> Bool
[avx512pf] :: DynFlags -> Bool

-- | Run-time linker information (what options we need, etc.)
[rtldInfo] :: DynFlags -> IORef (Maybe LinkerInfo)

-- | Run-time compiler information
[rtccInfo] :: DynFlags -> IORef (Maybe CompilerInfo)

-- | Max size, in bytes, of inline array allocations.
[maxInlineAllocSize] :: DynFlags -> Int

-- | Only inline memcpy if it generates no more than this many pseudo
--   (roughly: Cmm) instructions.
[maxInlineMemcpyInsns] :: DynFlags -> Int

-- | Only inline memset if it generates no more than this many pseudo
--   (roughly: Cmm) instructions.
[maxInlineMemsetInsns] :: DynFlags -> Int

-- | Enumerates the simple on-or-off dynamic flags
data GeneralFlag

-- | Append dump output to files instead of stdout.
[Opt_DumpToFile] :: GeneralFlag
[Opt_D_faststring_stats] :: GeneralFlag
[Opt_D_dump_minimal_imports] :: GeneralFlag
[Opt_DoCoreLinting] :: GeneralFlag
[Opt_DoStgLinting] :: GeneralFlag
[Opt_DoCmmLinting] :: GeneralFlag
[Opt_DoAsmLinting] :: GeneralFlag
[Opt_DoAnnotationLinting] :: GeneralFlag
[Opt_NoLlvmMangler] :: GeneralFlag
[Opt_WarnIsError] :: GeneralFlag
[Opt_PrintExplicitForalls] :: GeneralFlag
[Opt_PrintExplicitKinds] :: GeneralFlag
[Opt_CallArity] :: GeneralFlag
[Opt_Strictness] :: GeneralFlag
[Opt_LateDmdAnal] :: GeneralFlag
[Opt_KillAbsence] :: GeneralFlag
[Opt_KillOneShot] :: GeneralFlag
[Opt_FullLaziness] :: GeneralFlag
[Opt_FloatIn] :: GeneralFlag
[Opt_Specialise] :: GeneralFlag
[Opt_SpecialiseAggressively] :: GeneralFlag
[Opt_StaticArgumentTransformation] :: GeneralFlag
[Opt_CSE] :: GeneralFlag
[Opt_LiberateCase] :: GeneralFlag
[Opt_SpecConstr] :: GeneralFlag
[Opt_DoLambdaEtaExpansion] :: GeneralFlag
[Opt_IgnoreAsserts] :: GeneralFlag
[Opt_DoEtaReduction] :: GeneralFlag
[Opt_CaseMerge] :: GeneralFlag
[Opt_UnboxStrictFields] :: GeneralFlag
[Opt_UnboxSmallStrictFields] :: GeneralFlag
[Opt_DictsCheap] :: GeneralFlag
[Opt_EnableRewriteRules] :: GeneralFlag
[Opt_Vectorise] :: GeneralFlag
[Opt_VectorisationAvoidance] :: GeneralFlag
[Opt_RegsGraph] :: GeneralFlag
[Opt_RegsIterative] :: GeneralFlag
[Opt_PedanticBottoms] :: GeneralFlag
[Opt_LlvmTBAA] :: GeneralFlag
[Opt_LlvmPassVectorsInRegisters] :: GeneralFlag
[Opt_IrrefutableTuples] :: GeneralFlag
[Opt_CmmSink] :: GeneralFlag
[Opt_CmmElimCommonBlocks] :: GeneralFlag
[Opt_OmitYields] :: GeneralFlag
[Opt_SimpleListLiterals] :: GeneralFlag
[Opt_FunToThunk] :: GeneralFlag
[Opt_DictsStrict] :: GeneralFlag
[Opt_DmdTxDictSel] :: GeneralFlag
[Opt_Loopification] :: GeneralFlag
[Opt_IgnoreInterfacePragmas] :: GeneralFlag
[Opt_OmitInterfacePragmas] :: GeneralFlag
[Opt_ExposeAllUnfoldings] :: GeneralFlag
[Opt_WriteInterface] :: GeneralFlag
[Opt_AutoSccsOnIndividualCafs] :: GeneralFlag
[Opt_ProfCountEntries] :: GeneralFlag
[Opt_Pp] :: GeneralFlag
[Opt_ForceRecomp] :: GeneralFlag
[Opt_ExcessPrecision] :: GeneralFlag
[Opt_EagerBlackHoling] :: GeneralFlag
[Opt_NoHsMain] :: GeneralFlag
[Opt_SplitObjs] :: GeneralFlag
[Opt_StgStats] :: GeneralFlag
[Opt_HideAllPackages] :: GeneralFlag
[Opt_PrintBindResult] :: GeneralFlag
[Opt_Haddock] :: GeneralFlag
[Opt_HaddockOptions] :: GeneralFlag
[Opt_Hpc_No_Auto] :: GeneralFlag
[Opt_BreakOnException] :: GeneralFlag
[Opt_BreakOnError] :: GeneralFlag
[Opt_PrintEvldWithShow] :: GeneralFlag
[Opt_PrintBindContents] :: GeneralFlag
[Opt_GenManifest] :: GeneralFlag
[Opt_EmbedManifest] :: GeneralFlag
[Opt_EmitExternalCore] :: GeneralFlag
[Opt_SharedImplib] :: GeneralFlag
[Opt_BuildingCabalPackage] :: GeneralFlag
[Opt_IgnoreDotGhci] :: GeneralFlag
[Opt_GhciSandbox] :: GeneralFlag
[Opt_GhciHistory] :: GeneralFlag
[Opt_HelpfulErrors] :: GeneralFlag
[Opt_DeferTypeErrors] :: GeneralFlag
[Opt_DeferTypedHoles] :: GeneralFlag
[Opt_Parallel] :: GeneralFlag
[Opt_GranMacros] :: GeneralFlag
[Opt_PIC] :: GeneralFlag
[Opt_SccProfilingOn] :: GeneralFlag
[Opt_Ticky] :: GeneralFlag
[Opt_Ticky_Allocd] :: GeneralFlag
[Opt_Ticky_LNE] :: GeneralFlag
[Opt_Ticky_Dyn_Thunk] :: GeneralFlag
[Opt_Static] :: GeneralFlag
[Opt_RPath] :: GeneralFlag
[Opt_RelativeDynlibPaths] :: GeneralFlag
[Opt_Hpc] :: GeneralFlag
[Opt_FlatCache] :: GeneralFlag
[Opt_SimplPreInlining] :: GeneralFlag
[Opt_ErrorSpans] :: GeneralFlag
[Opt_PprCaseAsLet] :: GeneralFlag
[Opt_PprShowTicks] :: GeneralFlag
[Opt_SuppressCoercions] :: GeneralFlag
[Opt_SuppressVarKinds] :: GeneralFlag
[Opt_SuppressModulePrefixes] :: GeneralFlag
[Opt_SuppressTypeApplications] :: GeneralFlag
[Opt_SuppressIdInfo] :: GeneralFlag
[Opt_SuppressTypeSignatures] :: GeneralFlag
[Opt_SuppressUniques] :: GeneralFlag
[Opt_AutoLinkPackages] :: GeneralFlag
[Opt_ImplicitImportQualified] :: GeneralFlag
[Opt_KeepHiDiffs] :: GeneralFlag
[Opt_KeepHcFiles] :: GeneralFlag
[Opt_KeepSFiles] :: GeneralFlag
[Opt_KeepTmpFiles] :: GeneralFlag
[Opt_KeepRawTokenStream] :: GeneralFlag
[Opt_KeepLlvmFiles] :: GeneralFlag
[Opt_BuildDynamicToo] :: GeneralFlag
[Opt_DistrustAllPackages] :: GeneralFlag
[Opt_PackageTrust] :: GeneralFlag
[Opt_Debug] :: GeneralFlag
data Severity
[SevOutput] :: Severity
[SevDump] :: Severity
[SevInteractive] :: Severity
[SevInfo] :: Severity
[SevWarning] :: Severity
[SevError] :: Severity
[SevFatal] :: Severity

-- | The target code type of the compilation (if any).
--   
--   Whenever you change the target, also make sure to set <a>ghcLink</a>
--   to something sensible.
--   
--   <a>HscNothing</a> can be used to avoid generating any output, however,
--   note that:
--   
--   <ul>
--   <li>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 <a>needsTemplateHaskell</a> 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.)</li>
--   </ul>
data HscTarget

-- | Generate C code.
[HscC] :: HscTarget

-- | Generate assembly using the native code generator.
[HscAsm] :: HscTarget

-- | Generate assembly using the llvm code generator.
[HscLlvm] :: HscTarget

-- | Generate bytecode. (Requires <a>LinkInMemory</a>)
[HscInterpreted] :: HscTarget

-- | Don't generate any code. See notes above.
[HscNothing] :: HscTarget

-- | Test whether a <a>GeneralFlag</a> is set
gopt :: GeneralFlag -> DynFlags -> Bool

-- | The <a>GhcMode</a> tells us whether we're doing multi-module
--   compilation (controlled via the <a>GHC</a> API) or one-shot
--   (single-module) compilation. This makes a difference primarily to the
--   <a>Finder</a>: 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.
data GhcMode

-- | <tt>--make</tt>, GHCi, etc.
[CompManager] :: GhcMode

-- | <pre>
--   ghc -c Foo.hs
--   </pre>
[OneShot] :: GhcMode

-- | <tt>ghc -M</tt>, see <a>Finder</a> for why we need this
[MkDepend] :: GhcMode

-- | What to do in the link step, if there is one.
data GhcLink

-- | Don't link at all
[NoLink] :: GhcLink

-- | Link object code into a binary
[LinkBinary] :: GhcLink

-- | Use the in-memory dynamic linker (works for both bytecode and object
--   code).
[LinkInMemory] :: GhcLink

-- | Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
[LinkDynLib] :: GhcLink

-- | Link objects into a static lib
[LinkStaticLib] :: GhcLink

-- | The <a>HscTarget</a> value corresponding to the default way to create
--   object files on the current platform.
defaultObjectTarget :: Platform -> HscTarget
parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])

-- | Grabs the DynFlags from the Session
getSessionDynFlags :: GhcMonad m => m DynFlags

-- | 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 <tt>linkPackages</tt>) 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.
setSessionDynFlags :: GhcMonad m => DynFlags -> m [PackageKey]

-- | Returns the program <a>DynFlags</a>.
getProgramDynFlags :: GhcMonad m => m DynFlags

-- | Sets the program <a>DynFlags</a>.
setProgramDynFlags :: GhcMonad m => DynFlags -> m [PackageKey]

-- | Get the <a>DynFlags</a> used to evaluate interactive expressions.
getInteractiveDynFlags :: GhcMonad m => m DynFlags

-- | Set the <a>DynFlags</a> used to evaluate interactive expressions.
--   Note: this cannot be used for changes to packages. Use
--   <a>setSessionDynFlags</a>, or <a>setProgramDynFlags</a> and then copy
--   the <a>pkgState</a> into the interactive <tt>DynFlags</tt>.
setInteractiveDynFlags :: GhcMonad m => DynFlags -> m ()

-- | 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 <a>withGhc</a>.
--   
--   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?
parseStaticFlags :: [Located String] -> IO ([Located String], [Located String])

-- | 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).
data Target
[Target] :: TargetId -> Bool -> Maybe (StringBuffer, UTCTime) -> Target

-- | module or filename
[targetId] :: Target -> TargetId

-- | object code allowed?
[targetAllowObjCode] :: Target -> Bool

-- | in-memory text buffer?
[targetContents] :: Target -> Maybe (StringBuffer, UTCTime)
data TargetId

-- | A module name: search for the file
[TargetModule] :: ModuleName -> TargetId

-- | A filename: preprocess &amp; 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.
[TargetFile] :: FilePath -> (Maybe Phase) -> TargetId
data Phase

-- | 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 <a>load</a>.
setTargets :: GhcMonad m => [Target] -> m ()

-- | Returns the current set of targets
getTargets :: GhcMonad m => m [Target]

-- | Add another target.
addTarget :: GhcMonad m => Target -> m ()

-- | Remove a target
removeTarget :: GhcMonad m => TargetId -> m ()

-- | Attempts to guess what Target a string refers to. This function
--   implements the <tt>--make</tt>/GHCi command-line syntax for filenames:
--   
--   <ul>
--   <li>if the string looks like a Haskell source filename, then interpret
--   it as such</li>
--   <li>if adding a .hs or .lhs suffix yields the name of an existing
--   file, then use that</li>
--   <li>otherwise interpret the string as a module name</li>
--   </ul>
guessTarget :: GhcMonad m => String -> Maybe Phase -> m Target

-- | Perform a dependency analysis starting from the current targets and
--   update the session with the new module graph.
--   
--   Dependency analysis entails parsing the <tt>import</tt> directives and
--   may therefore require running certain preprocessors.
--   
--   Note that each <a>ModSummary</a> in the module graph caches its
--   <a>DynFlags</a>. These <a>DynFlags</a> are determined by the
--   <i>current</i> session <a>DynFlags</a> and the <tt>OPTIONS</tt> and
--   <tt>LANGUAGE</tt> pragmas of the parsed module. Thus if you want to
--   changes to the <a>DynFlags</a> to take effect you need to call this
--   function again.
depanal :: GhcMonad m => [ModuleName] -> Bool -> m ModuleGraph

-- | Try to load the program. See <a>LoadHowMuch</a> for the different
--   modes.
--   
--   This function implements the core of GHC's <tt>--make</tt> mode. It
--   preprocesses, compiles and loads the specified modules, avoiding
--   re-compilation wherever possible. Depending on the target (see
--   <a>hscTarget</a>) compilating and loading may result in files being
--   created on disk.
--   
--   Calls the <tt>reportModuleCompilationResult</tt> callback after each
--   compiling each module, whether successful or not.
--   
--   Throw a <a>SourceError</a> if errors are encountered before the actual
--   compilation starts (e.g., during dependency analysis). All other
--   errors are reported using the callback.
load :: GhcMonad m => LoadHowMuch -> m SuccessFlag

-- | Describes which modules of the module graph need to be loaded.
data LoadHowMuch

-- | Load all targets and its dependencies.
[LoadAllTargets] :: LoadHowMuch

-- | Load only the given module and its dependencies.
[LoadUpTo] :: ModuleName -> LoadHowMuch

-- | Load only the dependencies of the given module, but not the module
--   itself.
[LoadDependenciesOf] :: ModuleName -> LoadHowMuch
data InteractiveImport

-- | Bring the exports of a particular module (filtered by an import decl)
--   into scope
[IIDecl] :: (ImportDecl RdrName) -> InteractiveImport

-- | Bring into scope the entire top-level envt of of this module,
--   including the things imported into it.
[IIModule] :: ModuleName -> InteractiveImport
data SuccessFlag
[Succeeded] :: SuccessFlag
[Failed] :: SuccessFlag
succeeded :: SuccessFlag -> Bool
failed :: SuccessFlag -> Bool
defaultWarnErrLogger :: WarnErrLogger

-- | A function called to log warnings and errors.
type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> 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).
workingDirectoryChanged :: GhcMonad m => m ()

-- | Parse a module.
--   
--   Throws a <a>SourceError</a> on parse error.
parseModule :: GhcMonad m => ModSummary -> m ParsedModule

-- | Typecheck and rename a parsed module.
--   
--   Throws a <a>SourceError</a> if either fails.
typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule

-- | Desugar a typechecked module.
desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule

-- | 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 <a>ModIface</a> and, depending on
--   the <a>hscTarget</a>, may also include code generation.
--   
--   This function will always cause recompilation and will always
--   overwrite previous compilation results (potentially files on disk).
loadModule :: (TypecheckedMod mod, GhcMonad m) => mod -> m mod

-- | The result of successful parsing.
data ParsedModule
[ParsedModule] :: ModSummary -> ParsedSource -> [FilePath] -> ApiAnns -> ParsedModule
[pm_mod_summary] :: ParsedModule -> ModSummary
[pm_parsed_source] :: ParsedModule -> ParsedSource
[pm_extra_src_files] :: ParsedModule -> [FilePath]
[pm_annotations] :: ParsedModule -> ApiAnns

-- | The result of successful typechecking. It also contains the parser
--   result.
data TypecheckedModule
[TypecheckedModule] :: ParsedModule -> Maybe RenamedSource -> TypecheckedSource -> ModuleInfo -> (TcGblEnv, ModDetails) -> TypecheckedModule
[tm_parsed_module] :: TypecheckedModule -> ParsedModule
[tm_renamed_source] :: TypecheckedModule -> Maybe RenamedSource
[tm_typechecked_source] :: TypecheckedModule -> TypecheckedSource
[tm_checked_module_info] :: TypecheckedModule -> ModuleInfo
[tm_internals_] :: TypecheckedModule -> (TcGblEnv, ModDetails)

-- | The result of successful desugaring (i.e., translation to core). Also
--   contains all the information of a typechecked module.
data DesugaredModule
[DesugaredModule] :: TypecheckedModule -> ModGuts -> DesugaredModule
[dm_typechecked_module] :: DesugaredModule -> TypecheckedModule
[dm_core_module] :: DesugaredModule -> 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
renamedSource :: TypecheckedMod m => m -> Maybe RenamedSource
typecheckedSource :: TypecheckedMod m => m -> TypecheckedSource
moduleInfo :: TypecheckedMod m => m -> ModuleInfo
class ParsedMod m
parsedSource :: ParsedMod m => m -> ParsedSource
coreModule :: DesugaredMod m => m -> ModGuts

-- | A CoreModule consists of just the fields of a <a>ModGuts</a> that are
--   needed for the <a>compileToCoreModule</a> interface.
data CoreModule
[CoreModule] :: !Module -> !TypeEnv -> CoreProgram -> SafeHaskellMode -> CoreModule

-- | Module name
[cm_module] :: CoreModule -> !Module

-- | Type environment for types declared in this module
[cm_types] :: CoreModule -> !TypeEnv

-- | Declarations
[cm_binds] :: CoreModule -> CoreProgram

-- | Safe Haskell mode
[cm_safe] :: CoreModule -> SafeHaskellMode

-- | This is the way to get access to the Core bindings corresponding to a
--   module. <tt>compileToCore</tt> parses, typechecks, and desugars the
--   module, then returns the resulting Core module (consisting of the
--   module name, type declarations, and function declarations) if
--   successful.
compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule

-- | Like compileToCoreModule, but invokes the simplifier, so as to return
--   simplified and tidied Core.
compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule

-- | 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
--   <a>topSortModuleGraph</a> and <a>flattenSCC</a> to achieve this.
type ModuleGraph = [ModSummary]

-- | A single node in a <a>ModuleGraph</a>. The nodes of the module graph
--   are one of:
--   
--   <ul>
--   <li>A regular Haskell source module</li>
--   <li>A hi-boot source module</li>
--   <li>An external-core source module</li>
--   </ul>
data ModSummary
[ModSummary] :: Module -> HscSource -> ModLocation -> UTCTime -> Maybe UTCTime -> Maybe UTCTime -> [Located (ImportDecl RdrName)] -> [Located (ImportDecl RdrName)] -> FilePath -> DynFlags -> Maybe StringBuffer -> ModSummary

-- | Identity of the module
[ms_mod] :: ModSummary -> Module

-- | The module source either plain Haskell, hs-boot or external core
[ms_hsc_src] :: ModSummary -> HscSource

-- | Location of the various files belonging to the module
[ms_location] :: ModSummary -> ModLocation

-- | Timestamp of source file
[ms_hs_date] :: ModSummary -> UTCTime

-- | Timestamp of object, if we have one
[ms_obj_date] :: ModSummary -> Maybe UTCTime

-- | Timestamp of hi file, if we *only* are typechecking (it is
--   <a>Nothing</a> otherwise. See Note [Recompilation checking when
--   typechecking only] and #9243
[ms_iface_date] :: ModSummary -> Maybe UTCTime

-- | Source imports of the module
[ms_srcimps] :: ModSummary -> [Located (ImportDecl RdrName)]

-- | Non-source imports of the module from the module *text*
[ms_textual_imps] :: ModSummary -> [Located (ImportDecl RdrName)]

-- | Filename of preprocessed source file
[ms_hspp_file] :: ModSummary -> FilePath

-- | Cached flags from <tt>OPTIONS</tt>, <tt>INCLUDE</tt> and
--   <tt>LANGUAGE</tt> pragmas in the modules source code
[ms_hspp_opts] :: ModSummary -> DynFlags

-- | The actual preprocessed source, if we have it
[ms_hspp_buf] :: ModSummary -> Maybe StringBuffer
ms_mod_name :: ModSummary -> ModuleName

-- | Where a module lives on the file system: the actual locations of the
--   .hs, .hi and .o files, if we have them
data ModLocation
[ModLocation] :: Maybe FilePath -> FilePath -> FilePath -> ModLocation
[ml_hs_file] :: ModLocation -> Maybe FilePath
[ml_hi_file] :: ModLocation -> FilePath
[ml_obj_file] :: ModLocation -> FilePath

-- | Return the <a>ModSummary</a> of a module with the given name.
--   
--   The module must be part of the module graph (see <a>hsc_mod_graph</a>
--   and <a>ModuleGraph</a>). If this is not the case, this function will
--   throw a <a>GhcApiError</a>.
--   
--   This function ignores boot modules and requires that there is only one
--   non-boot module with the given name.
getModSummary :: GhcMonad m => ModuleName -> m ModSummary

-- | Get the module dependency graph.
getModuleGraph :: GhcMonad m => m ModuleGraph

-- | Return <tt>True</tt> <a>==</a> module is loaded.
isLoaded :: GhcMonad m => ModuleName -> m Bool

-- | 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)?
--   
--   <ul>
--   <li><tt>False</tt>: treat the hi-boot summaries as nodes of the graph,
--   so the graph must be acyclic</li>
--   <li><tt>True</tt>: 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</li>
--   </ul>
topSortModuleGraph :: Bool -> [ModSummary] -> Maybe ModuleName -> [SCC ModSummary]

-- | Container for information about a <a>Module</a>.
data ModuleInfo

-- | Request information about a loaded <a>Module</a>
getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo)

-- | The list of top-level entities defined in a module
modInfoTyThings :: ModuleInfo -> [TyThing]
modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]
modInfoExports :: ModuleInfo -> [Name]

-- | Returns the instances defined by the specified module. Warning:
--   currently unimplemented for package modules.
modInfoInstances :: ModuleInfo -> [ClsInst]
modInfoIsExportedName :: ModuleInfo -> Name -> Bool
modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing)
modInfoIface :: ModuleInfo -> Maybe ModIface

-- | Retrieve module safe haskell mode
modInfoSafe :: ModuleInfo -> SafeHaskellMode

-- | Looks up a global name: that is, any top-level name in any visible
--   module. Unlike <a>lookupName</a>, lookupGlobalName does not use the
--   interactive context, and therefore does not require a preceding
--   <a>setContext</a>.
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)

-- | A <a>ModIface</a> plus a <a>ModDetails</a> summarises everything we
--   know about a compiled module. The <a>ModIface</a> 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 <a>ModIface</a>.
--   
--   When we read an interface file, we also construct a <a>ModIface</a>
--   from it, except that we explicitly make the <a>mi_decls</a> and a few
--   other fields empty; as when reading we consolidate the declarations
--   etc. into a number of indexed maps and environments in the
--   <a>ExternalPackageState</a>.
data ModIface
[ModIface] :: !Module -> !(Maybe Module) -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !WhetherHasOrphans -> !WhetherHasFamInst -> !IsBootInterface -> Dependencies -> [Usage] -> ![IfaceExport] -> !Fingerprint -> !Bool -> [(OccName, Fixity)] -> Warnings -> [IfaceAnnotation] -> [(Fingerprint, IfaceDecl)] -> !(Maybe GlobalRdrEnv) -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> !Fingerprint -> !IfaceVectInfo -> (Name -> Maybe WarningTxt) -> (OccName -> Fixity) -> (OccName -> Maybe (OccName, Fingerprint)) -> !AnyHpcUsage -> !IfaceTrustInfo -> !Bool -> ModIface

-- | Name of the module we are for
[mi_module] :: ModIface -> !Module

-- | Are we a sig of another mod?
[mi_sig_of] :: ModIface -> !(Maybe Module)

-- | Hash of the whole interface
[mi_iface_hash] :: ModIface -> !Fingerprint

-- | Hash of the ABI only
[mi_mod_hash] :: ModIface -> !Fingerprint

-- | Hash of the important flags used when compiling this module
[mi_flag_hash] :: ModIface -> !Fingerprint

-- | Whether this module has orphans
[mi_orphan] :: ModIface -> !WhetherHasOrphans

-- | Whether this module has family instances
[mi_finsts] :: ModIface -> !WhetherHasFamInst

-- | Read from an hi-boot file?
[mi_boot] :: ModIface -> !IsBootInterface

-- | The dependencies of the module. This is consulted for
--   directly-imported modules, but not for anything else (hence lazy)
[mi_deps] :: ModIface -> Dependencies

-- | 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_usages] :: ModIface -> [Usage]

-- | 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 <a>OccName</a>s of those things
[mi_exports] :: ModIface -> ![IfaceExport]

-- | Hash of export list
[mi_exp_hash] :: ModIface -> !Fingerprint

-- | Module required TH splices when it was compiled. This disables
--   recompilation avoidance (see #481).
[mi_used_th] :: ModIface -> !Bool

-- | Fixities NOT STRICT! we read this field lazily from the interface file
[mi_fixities] :: ModIface -> [(OccName, Fixity)]

-- | Warnings NOT STRICT! we read this field lazily from the interface file
[mi_warns] :: ModIface -> Warnings

-- | Annotations NOT STRICT! we read this field lazily from the interface
--   file
[mi_anns] :: ModIface -> [IfaceAnnotation]

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

-- | Binds all the things defined at the top level in the <i>original
--   source</i> 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
--   <tt>Nothing</tt>).
--   
--   Strictly speaking this field should live in the <a>HomeModInfo</a>,
--   but that leads to more plumbing.
[mi_globals] :: ModIface -> !(Maybe GlobalRdrEnv)

-- | Sorted class instance
[mi_insts] :: ModIface -> [IfaceClsInst]

-- | Sorted family instances
[mi_fam_insts] :: ModIface -> [IfaceFamInst]

-- | Sorted rules
[mi_rules] :: ModIface -> [IfaceRule]

-- | Hash for orphan rules, class and family instances, and vectorise
--   pragmas combined
[mi_orphan_hash] :: ModIface -> !Fingerprint

-- | Vectorisation information
[mi_vect_info] :: ModIface -> !IfaceVectInfo

-- | Cached lookup for <a>mi_warns</a>
[mi_warn_fn] :: ModIface -> Name -> Maybe WarningTxt

-- | Cached lookup for <a>mi_fixities</a>
[mi_fix_fn] :: ModIface -> OccName -> Fixity

-- | Cached lookup for <a>mi_decls</a>. The <tt>Nothing</tt> in
--   <a>mi_hash_fn</a> 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
--   <a>OccName</a> is the parent of the name, if it has one.
[mi_hash_fn] :: ModIface -> OccName -> Maybe (OccName, Fingerprint)

-- | True if this program uses Hpc at any point in the program.
[mi_hpc] :: ModIface -> !AnyHpcUsage

-- | Safe Haskell Trust information for this module.
[mi_trust] :: ModIface -> !IfaceTrustInfo

-- | 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_trust_pkg] :: ModIface -> !Bool

-- | The various Safe Haskell modes
data SafeHaskellMode
[Sf_None] :: SafeHaskellMode
[Sf_Unsafe] :: SafeHaskellMode
[Sf_Trustworthy] :: SafeHaskellMode
[Sf_Safe] :: SafeHaskellMode

-- | 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 <a>SDoc</a>.
data PrintUnqualified
alwaysQualify :: PrintUnqualified

-- | Return the bindings for the current interactive session.
getBindings :: GhcMonad m => m [TyThing]

-- | Return the instances for the current interactive session.
getInsts :: GhcMonad m => m ([ClsInst], [FamInst])
getPrintUnqual :: GhcMonad m => m PrintUnqualified

-- | Takes a <a>ModuleName</a> and possibly a <a>PackageKey</a>, and
--   consults the filesystem and package database to find the corresponding
--   <a>Module</a>, using the algorithm that is used for an <tt>import</tt>
--   declaration.
findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module

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

-- | 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.
isModuleTrusted :: GhcMonad m => Module -> m Bool

-- | Return if a module is trusted and the pkgs it depends on to be
--   trusted.
moduleTrustReqs :: GhcMonad m => Module -> m (Bool, [PackageKey])

-- | Set the interactive evaluation context.
--   
--   (setContext imports) sets the ic_imports field (which in turn
--   determines what is in scope at the prompt) to <tt>imports</tt>, 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.)
setContext :: GhcMonad m => [InteractiveImport] -> m ()

-- | 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.
getContext :: GhcMonad m => m [InteractiveImport]

-- | Returns all names in scope in the current interactive context
getNamesInScope :: GhcMonad m => m [Name]
getRdrNamesInScope :: GhcMonad m => m [RdrName]

-- | get the GlobalRdrEnv for a session
getGRE :: GhcMonad m => m GlobalRdrEnv

-- | Returns <tt>True</tt> if the specified module is interpreted, and
--   hence has its full top-level scope available.
moduleIsInterpreted :: GhcMonad m => Module -> m Bool

-- | 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)
getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))

-- | Get the type of an expression Returns its most general type
exprType :: GhcMonad m => String -> m Type

-- | Get the kind of a type
typeKind :: GhcMonad m => Bool -> String -> m (Type, Kind)

-- | Parses a string as an identifier, and returns the list of <a>Name</a>s
--   that the identifier can refer to in the current interactive context.
parseName :: GhcMonad m => String -> m [Name]
data RunResult

-- | names bound by this evaluation
[RunOk] :: [Name] -> RunResult

-- | statement raised an exception
[RunException] :: SomeException -> RunResult
[RunBreak] :: ThreadId -> [Name] -> (Maybe BreakInfo) -> RunResult

-- | Run a statement in the current interactive context. Statement may bind
--   multple values.
runStmt :: GhcMonad m => String -> SingleStep -> m RunResult

-- | Run a statement in the current interactive context. Passing debug
--   information Statement may bind multple values.
runStmtWithLocation :: GhcMonad m => String -> Int -> String -> SingleStep -> m RunResult
runDecls :: GhcMonad m => String -> m [Name]
runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name]
runTcInteractive :: HscEnv -> TcRn a -> IO (Messages, Maybe a)
parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
data SingleStep
[RunToCompletion] :: SingleStep
[SingleStep] :: SingleStep
[RunAndLogSteps] :: SingleStep
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

-- | All the information about the breakpoints for a given module
data ModBreaks
[ModBreaks] :: BreakArray -> !(Array BreakIndex SrcSpan) -> !(Array BreakIndex [OccName]) -> !(Array BreakIndex [String]) -> ModBreaks

-- | The array of flags, one per breakpoint, indicating which breakpoints
--   are enabled.
[modBreaks_flags] :: ModBreaks -> BreakArray

-- | An array giving the source span of each breakpoint.
[modBreaks_locs] :: ModBreaks -> !(Array BreakIndex SrcSpan)

-- | An array giving the names of the free variables at each breakpoint.
[modBreaks_vars] :: ModBreaks -> !(Array BreakIndex [OccName])

-- | An array giving the names of the declarations enclosing each
--   breakpoint.
[modBreaks_decls] :: ModBreaks -> !(Array BreakIndex [String])

-- | Breakpoint index
type BreakIndex = Int
data BreakInfo
data BreakArray
setBreakOn :: DynFlags -> BreakArray -> Int -> IO Bool
setBreakOff :: DynFlags -> BreakArray -> Int -> IO Bool
getBreak :: DynFlags -> BreakArray -> Int -> IO (Maybe Word)

-- | Returns the <a>TyThing</a> for a <a>Name</a>. The <a>Name</a> may
--   refer to any entity known to GHC, including <a>Name</a>s defined using
--   <a>runStmt</a>.
lookupName :: GhcMonad m => Name -> m (Maybe TyThing)

-- | EXPERIMENTAL: DO NOT USE.
--   
--   Set the monad GHCi lifts user statements into.
--   
--   Checks that a type (in string form) is an instance of the
--   <tt>GHC.GHCi.GHCiSandboxIO</tt> type class. Sets it to be the GHCi
--   monad if it is, throws an error otherwise.

-- | <i>Warning: This is experimental! Don't use.</i>
setGHCiMonad :: GhcMonad m => String -> m ()

-- | A string which uniquely identifies a package. For wired-in packages,
--   it is just the package name, but for user compiled packages, it is a
--   hash. ToDo: when the key is a hash, we can do more clever things than
--   store the hex representation and hash-cons those strings.
data PackageKey

-- | A Module is a pair of a <a>PackageKey</a> and a <a>ModuleName</a>.
data Module
mkModule :: PackageKey -> ModuleName -> Module
pprModule :: Module -> SDoc
moduleName :: Module -> ModuleName
modulePackageKey :: Module -> PackageKey

-- | A ModuleName is essentially a simple string, e.g. <tt>Data.List</tt>.
data ModuleName
mkModuleName :: String -> ModuleName
moduleNameString :: ModuleName -> String

-- | A unique, unambigious name for something, containing information about
--   where that thing originated.
data Name
isExternalName :: Name -> Bool
nameModule :: Name -> Module

-- | print a <a>NamedThing</a>, adding parentheses if the name is an
--   operator.
pprParenSymName :: NamedThing a => a -> SDoc
nameSrcSpan :: Name -> SrcSpan

-- | A class allowing convenient access to the <a>Name</a> of various
--   datatypes
class NamedThing a where getOccName n = nameOccName (getName n)
getOccName :: NamedThing a => a -> OccName
getName :: NamedThing a => a -> Name

-- | Do not use the data constructors of RdrName directly: prefer the
--   family of functions that creates them, such as <a>mkRdrUnqual</a>
--   
--   <ul>
--   <li>Note: A Located RdrName will only have API Annotations if it is a
--   compound one, e.g.</li>
--   </ul>
--   
--   <pre>
--   `bar`
--   ( ~ )
--   </pre>
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnType</a>, <a>AnnOpen</a> <tt>'('</tt>
--   or <tt>'['</tt> or <tt>'[:'</tt>, <a>AnnClose</a> <tt>')'</tt> or
--   <tt>']'</tt> or <tt>':]'</tt>,, <a>AnnBackquote</a> <tt>'`'</tt>,
--   <a>AnnVal</a>,<a>AnnTildehsh</a>, <a>AnnTilde</a>,</li>
--   </ul>
data RdrName

-- | Used for ordinary, unqualified occurrences, e.g. <tt>x</tt>,
--   <tt>y</tt> or <tt>Foo</tt>. Create such a <a>RdrName</a> with
--   <a>mkRdrUnqual</a>
[Unqual] :: OccName -> RdrName

-- | A qualified name written by the user in <i>source</i> code. The module
--   isn't necessarily the module where the thing is defined; just the one
--   from which it is imported. Examples are <tt>Bar.x</tt>, <tt>Bar.y</tt>
--   or <tt>Bar.Foo</tt>. Create such a <a>RdrName</a> with
--   <a>mkRdrQual</a>
[Qual] :: ModuleName -> OccName -> RdrName
type Id = Var
idType :: Id -> Kind

-- | <a>isImplicitId</a> tells whether an <a>Id</a>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.
isImplicitId :: Id -> Bool
isDeadBinder :: Id -> Bool

-- | <tt>isExportedIdVar</tt> means "don't throw this away"
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

-- | Get from either the worker or the wrapper <a>Id</a> to the
--   <a>DataCon</a>. Currently used only in the desugarer.
--   
--   INVARIANT: <tt>idDataCon (dataConWrapId d) = d</tt>: remember,
--   <a>dataConWrapId</a> can return either the wrapper or the worker
idDataCon :: Id -> DataCon

-- | Returns true if an application to n args would diverge
isBottomingId :: Id -> Bool
isDictonaryId :: Id -> Bool

-- | If the <a>Id</a> is that for a record selector, extract the
--   <a>sel_tycon</a> and label. Panic otherwise
recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)

-- | TyCons represent type constructors. Type constructors are introduced
--   by things such as:
--   
--   1) Data declarations: <tt>data Foo = ...</tt> creates the <tt>Foo</tt>
--   type constructor of kind <tt>*</tt>
--   
--   2) Type synonyms: <tt>type Foo = ...</tt> creates the <tt>Foo</tt>
--   type constructor
--   
--   3) Newtypes: <tt>newtype Foo a = MkFoo ...</tt> creates the
--   <tt>Foo</tt> type constructor of kind <tt>* -&gt; *</tt>
--   
--   4) Class declarations: <tt>class Foo where</tt> creates the
--   <tt>Foo</tt> type constructor of kind <tt>*</tt>
--   
--   This data type also encodes a number of primitive, built in type
--   constructors such as those for function and tuple types.
data TyCon

-- | The kind and type variables used in the type constructor. Invariant:
--   length tyvars = arity Precisely, this list scopes over:
--   
--   <ol>
--   <li>The <a>algTcStupidTheta</a></li>
--   <li>The cached types in algTyConRhs.NewTyCon</li>
--   <li>The family instance types if present</li>
--   </ol>
--   
--   Note that it does <i>not</i> scope over the data constructors.
tyConTyVars :: TyCon -> [TyVar]

-- | As <a>tyConDataCons_maybe</a>, but returns the empty list of
--   constructors if no constructors could be found
tyConDataCons :: TyCon -> [DataCon]

-- | Number of arguments this TyCon must receive to be considered saturated
--   (including implicit kind variables)
tyConArity :: TyCon -> Arity

-- | Is this <a>TyCon</a> that for a class instance?
isClassTyCon :: TyCon -> Bool

-- | Is this a <a>TyCon</a> representing a regular H98 type synonym
--   (<tt>type</tt>)?
isTypeSynonymTyCon :: TyCon -> Bool

-- | Is this a synonym <a>TyCon</a> that can have may have further
--   instances appear?
isTypeFamilyTyCon :: TyCon -> Bool

-- | Is this <a>TyCon</a> that for a <tt>newtype</tt>
isNewTyCon :: TyCon -> Bool

-- | Does this <a>TyCon</a> represent something that cannot be defined in
--   Haskell?
isPrimTyCon :: TyCon -> Bool
isFunTyCon :: TyCon -> Bool

-- | Is this a <a>TyCon</a>, synonym or otherwise, that defines a family?
isFamilyTyCon :: TyCon -> Bool

-- | Is this a <a>TyCon</a>, synonym or otherwise, that defines a family
--   with instances?
isOpenFamilyTyCon :: TyCon -> Bool
isOpenTypeFamilyTyCon :: TyCon -> Bool

-- | If this <a>TyCon</a> is that for a class instance, return the class it
--   is for. Otherwise returns <tt>Nothing</tt>
tyConClass_maybe :: TyCon -> Maybe Class

-- | Extract the information pertaining to the right hand side of a type
--   synonym (<tt>type</tt>) declaration.
synTyConRhs_maybe :: TyCon -> Maybe Type

-- | Extract the <a>TyVar</a>s bound by a vanilla type synonym and the
--   corresponding (unsubstituted) right hand side.
synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)

-- | Find the result <a>Kind</a> of a type synonym, after applying it to
--   its <tt>arity</tt> number of type variables Actually this function
--   works fine on data types too, but they'd always return <a>*</a>, so we
--   never need to ask
synTyConResKind :: TyCon -> Kind
type TyVar = Var
alphaTyVars :: [TyVar]

-- | A data constructor
--   
--   <ul>
--   <li><a>AnnKeywordId</a> : <a>AnnOpen</a>,
--   <a>AnnClose</a>,<a>AnnComma</a></li>
--   </ul>
data DataCon

-- | The "signature" of the <a>DataCon</a> returns, in order:
--   
--   1) The result of <a>dataConAllTyVars</a>,
--   
--   2) All the <a>ThetaType</a>s relating to the <a>DataCon</a> (coercion,
--   dictionary, implicit parameter - whatever)
--   
--   3) The type arguments to the constructor
--   
--   4) The <i>original</i> result type of the <a>DataCon</a>
dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
dataConType :: DataCon -> Type

-- | The type constructor that we are building via this data constructor
dataConTyCon :: DataCon -> TyCon

-- | The labels for the fields of this particular <a>DataCon</a>
dataConFieldLabels :: DataCon -> [FieldLabel]

-- | Should the <a>DataCon</a> be presented infix?
dataConIsInfix :: DataCon -> Bool

-- | Vanilla <a>DataCon</a>s are those that are nice boring Haskell 98
--   constructors
isVanillaDataCon :: DataCon -> Bool

-- | The user-declared type of the data constructor in the nice-to-read
--   form:
--   
--   <pre>
--   T :: forall a b. a -&gt; b -&gt; T [a]
--   </pre>
--   
--   rather than:
--   
--   <pre>
--   T :: forall a c. forall b. (c~[a]) =&gt; a -&gt; b -&gt; T c
--   </pre>
--   
--   NB: If the constructor is part of a data instance, the result type
--   mentions the family tycon, not the internal one.
dataConUserType :: DataCon -> Type

-- | The strictness markings written by the porgrammer. The list is in
--   one-to-one correspondence with the arity of the <a>DataCon</a>
dataConSrcBangs :: DataCon -> [HsSrcBang]
data StrictnessMark
[MarkedStrict] :: StrictnessMark
[NotMarkedStrict] :: StrictnessMark
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

-- | Pretty-prints a <a>FamInst</a> (type/data family instance) with its
--   defining location.
pprFamInst :: FamInst -> SDoc
data FamInst

-- | The key representation of types within the compiler
data Type

-- | 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 <a>TyVar</a>s
splitForAllTys :: Type -> ([TyVar], Type)

-- | Extract the function result type and panic if that is not possible
funResultTy :: Type -> Type
pprParendType :: Type -> SDoc
pprTypeApp :: TyCon -> [Type] -> SDoc

-- | The key type representing kinds in the compiler. Invariant: a kind is
--   always in one of these forms:
--   
--   <pre>
--   FunTy k1 k2
--   TyConApp PrimTyCon [...]
--   TyVar kv   -- (during inference only)
--   ForAll ... -- (for top-level coercions)
--   </pre>
type Kind = Type

-- | A type of the form <tt>p</tt> of kind <tt>Constraint</tt> represents a
--   value whose type is the Haskell predicate <tt>p</tt>, where a
--   predicate is what occurs before the <tt>=&gt;</tt> in a Haskell type.
--   
--   We use <a>PredType</a> as documentation to mark those types that we
--   guarantee to have this kind.
--   
--   It can be expanded into its representation, but:
--   
--   <ul>
--   <li>The type checker must treat it as opaque</li>
--   <li>The rest of the compiler treats it as transparent</li>
--   </ul>
--   
--   Consider these examples:
--   
--   <pre>
--   f :: (Eq a) =&gt; a -&gt; Int
--   g :: (?x :: Int -&gt; Int) =&gt; a -&gt; Int
--   h :: (r\l) =&gt; {r} =&gt; {l::Int | r}
--   </pre>
--   
--   Here the <tt>Eq a</tt> and <tt>?x :: Int -&gt; Int</tt> and
--   <tt>rl</tt> are all called "predicates"
type PredType = Type

-- | A collection of <a>PredType</a>s
type ThetaType = [PredType]
pprForAll :: [TyVar] -> SDoc
pprThetaArrowTy :: ThetaType -> SDoc

-- | A typecheckable-thing, essentially anything that has a name
data TyThing
[AnId] :: Id -> TyThing
[AConLike] :: ConLike -> TyThing
[ATyCon] :: TyCon -> TyThing
[ACoAxiom] :: (CoAxiom Branched) -> TyThing
data FixityDirection
[InfixL] :: FixityDirection
[InfixR] :: FixityDirection
[InfixN] :: FixityDirection
defaultFixity :: Fixity
maxPrecedence :: Int
negateFixity :: Fixity
compareFixity :: Fixity -> Fixity -> (Bool, Bool)
data SrcLoc
[RealSrcLoc] :: {-# UNPACK #-} !RealSrcLoc -> SrcLoc
[UnhelpfulLoc] :: FastString -> SrcLoc

-- | Represents a single point within a file
data RealSrcLoc
mkSrcLoc :: FastString -> Int -> Int -> SrcLoc

-- | Built-in "bad" <a>SrcLoc</a> values for particular locations
noSrcLoc :: SrcLoc

-- | Gives the filename of the <a>RealSrcLoc</a>
srcLocFile :: RealSrcLoc -> FastString

-- | Raises an error when used on a "bad" <a>SrcLoc</a>
srcLocLine :: RealSrcLoc -> Int

-- | Raises an error when used on a "bad" <a>SrcLoc</a>
srcLocCol :: RealSrcLoc -> Int
data SrcSpan
[RealSrcSpan] :: !RealSrcSpan -> SrcSpan
[UnhelpfulSpan] :: !FastString -> SrcSpan

-- | 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 <i>after</i> 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.
data RealSrcSpan

-- | Create a <a>SrcSpan</a> between two points in a file
mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan

-- | Create a <a>SrcSpan</a> corresponding to a single point
srcLocSpan :: SrcLoc -> SrcSpan

-- | Test if a <a>SrcSpan</a> is "good", i.e. has precise location
--   information
isGoodSrcSpan :: SrcSpan -> Bool

-- | Built-in "bad" <a>SrcSpan</a>s for common sources of location
--   uncertainty
noSrcSpan :: SrcSpan

-- | Returns the location at the start of the <a>SrcSpan</a> or a "bad"
--   <a>SrcSpan</a> if that is unavailable
srcSpanStart :: SrcSpan -> SrcLoc

-- | Returns the location at the end of the <a>SrcSpan</a> or a "bad"
--   <a>SrcSpan</a> if that is unavailable
srcSpanEnd :: SrcSpan -> SrcLoc
srcSpanFile :: RealSrcSpan -> FastString
srcSpanStartLine :: RealSrcSpan -> Int
srcSpanEndLine :: RealSrcSpan -> Int
srcSpanStartCol :: RealSrcSpan -> Int
srcSpanEndCol :: RealSrcSpan -> Int

-- | We attach SrcSpans to lots of things, so let's have a datatype for it.
data GenLocated l e
[L] :: l -> e -> GenLocated 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

-- | Tests whether the two located things are equal
eqLocated :: Eq a => Located a -> Located a -> Bool

-- | Tests the ordering of the two located things
cmpLocated :: Ord a => Located a -> Located a -> Ordering
combineLocs :: Located a -> Located b -> SrcSpan

-- | Combine locations from two <a>Located</a> things and add them to a
--   third thing
addCLoc :: Located a -> Located b -> c -> Located c

-- | Alternative strategies for ordering <a>SrcSpan</a>s
leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering

-- | Alternative strategies for ordering <a>SrcSpan</a>s
leftmost_largest :: SrcSpan -> SrcSpan -> Ordering

-- | Alternative strategies for ordering <a>SrcSpan</a>s
rightmost :: SrcSpan -> SrcSpan -> Ordering

-- | Determines whether a span encloses a given line and column index
spans :: SrcSpan -> (Int, Int) -> Bool

-- | Determines whether a span is enclosed by another one
isSubspanOf :: SrcSpan -> SrcSpan -> Bool

-- | GHC's own exception type error messages all take the form:
--   
--   <pre>
--   <a>location</a>: <a>error</a>
--   
--   </pre>
--   
--   If the location is on the command line, or in GHC itself, then
--   <a>location</a>="ghc". All of the error types below correspond to a
--   <a>location</a> of "ghc", except for ProgramError (where the string is
--   assumed to contain a location already, so we don't print one).
data GhcException
[PhaseFailed] :: String -> ExitCode -> GhcException

-- | Some other fatal signal (SIGHUP,SIGTERM)
[Signal] :: Int -> GhcException

-- | Prints the short usage msg after the error
[UsageError] :: String -> GhcException

-- | A problem with the command line arguments, but don't print usage.
[CmdLineError] :: String -> GhcException

-- | The <tt>impossible</tt> happened.
[Panic] :: String -> GhcException
[PprPanic] :: String -> SDoc -> GhcException

-- | The user tickled something that's known not to work yet, but we're not
--   counting it as a bug.
[Sorry] :: String -> GhcException
[PprSorry] :: String -> SDoc -> GhcException

-- | An installation problem.
[InstallationError] :: String -> GhcException

-- | An error in the user's code, probably.
[ProgramError] :: String -> GhcException
[PprProgramError] :: String -> SDoc -> GhcException

-- | Append a description of the given exception to this string.
showGhcException :: GhcException -> String -> String
data 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 <a>SourceError</a> on parse error.
getTokenStream :: GhcMonad m => Module -> m [Located Token]

-- | Give even more information on the source than <a>getTokenStream</a>
--   This function allows reconstructing the source completely with
--   <a>showRichTokenStream</a>.
getRichTokenStream :: GhcMonad m => Module -> m [(Located Token, String)]

-- | Take a rich token stream such as produced from
--   <a>getRichTokenStream</a> and return source code almost identical to
--   the original code (except for insignificant whitespace.)
showRichTokenStream :: [(Located Token, String)] -> String

-- | Given a source location and a StringBuffer corresponding to this
--   location, return a rich token stream with the source associated to the
--   tokens.
addSourceToTokens :: RealSrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)]

-- | A pure interface to the module parser.
parser :: String -> DynFlags -> FilePath -> Either ErrorMessages (WarningMessages, Located (HsModule RdrName))
type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment])

-- | 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 <tt><tt>pm_annotations</tt></tt> field of
--   <tt><a>ParsedModule</a></tt>. Comments are only retained if
--   <tt><tt>Opt_KeepRawTokenStream</tt></tt> is set in
--   <tt><a>DynFlags</a></tt> before parsing.
--   
--   The wiki page describing this feature is
--   <a>https://ghc.haskell.org/trac/ghc/wiki/ApiAnnotations</a>
--   
--   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
data AnnKeywordId
[AnnAs] :: AnnKeywordId
[AnnAt] :: AnnKeywordId

-- | <tt>!</tt>
[AnnBang] :: AnnKeywordId

-- | '`'
[AnnBackquote] :: AnnKeywordId
[AnnBy] :: AnnKeywordId

-- | case or lambda case
[AnnCase] :: AnnKeywordId
[AnnClass] :: AnnKeywordId

-- | '#)' or '#-}' etc
[AnnClose] :: AnnKeywordId

-- | '}'
[AnnCloseC] :: AnnKeywordId

-- | ')'
[AnnCloseP] :: AnnKeywordId

-- | ']'
[AnnCloseS] :: AnnKeywordId
[AnnColon] :: AnnKeywordId

-- | as a list separator
[AnnComma] :: AnnKeywordId

-- | in a RdrName for a tuple
[AnnCommaTuple] :: AnnKeywordId

-- | '=&gt;'
[AnnDarrow] :: AnnKeywordId
[AnnData] :: AnnKeywordId

-- | '::'
[AnnDcolon] :: AnnKeywordId
[AnnDefault] :: AnnKeywordId
[AnnDeriving] :: AnnKeywordId
[AnnDo] :: AnnKeywordId

-- | <a>.</a>
[AnnDot] :: AnnKeywordId

-- | '..'
[AnnDotdot] :: AnnKeywordId
[AnnElse] :: AnnKeywordId
[AnnEqual] :: AnnKeywordId
[AnnExport] :: AnnKeywordId
[AnnFamily] :: AnnKeywordId
[AnnForall] :: AnnKeywordId
[AnnForeign] :: AnnKeywordId

-- | for function name in matches where there are multiple equations for
--   the function.
[AnnFunId] :: AnnKeywordId
[AnnGroup] :: AnnKeywordId

-- | for CType
[AnnHeader] :: AnnKeywordId
[AnnHiding] :: AnnKeywordId
[AnnIf] :: AnnKeywordId
[AnnImport] :: AnnKeywordId
[AnnIn] :: AnnKeywordId

-- | 'infix' or 'infixl' or 'infixr'
[AnnInfix] :: AnnKeywordId
[AnnInstance] :: AnnKeywordId
[AnnLam] :: AnnKeywordId

-- | '&lt;-'
[AnnLarrow] :: AnnKeywordId
[AnnLet] :: AnnKeywordId
[AnnMdo] :: AnnKeywordId

-- | <a>-</a>
[AnnMinus] :: AnnKeywordId
[AnnModule] :: AnnKeywordId
[AnnNewtype] :: AnnKeywordId
[AnnOf] :: AnnKeywordId

-- | '(#' or '{-# LANGUAGE' etc
[AnnOpen] :: AnnKeywordId

-- | '{'
[AnnOpenC] :: AnnKeywordId

-- | '('
[AnnOpenP] :: AnnKeywordId

-- | '['
[AnnOpenS] :: AnnKeywordId
[AnnPackageName] :: AnnKeywordId
[AnnPattern] :: AnnKeywordId
[AnnProc] :: AnnKeywordId
[AnnQualified] :: AnnKeywordId

-- | '-&gt;'
[AnnRarrow] :: AnnKeywordId
[AnnRec] :: AnnKeywordId
[AnnRole] :: AnnKeywordId
[AnnSafe] :: AnnKeywordId

-- | ';'
[AnnSemi] :: AnnKeywordId

-- | <tt>static</tt>
[AnnStatic] :: AnnKeywordId
[AnnThen] :: AnnKeywordId

-- | '~'
[AnnTilde] :: AnnKeywordId

-- | <tt>~#</tt>
[AnnTildehsh] :: AnnKeywordId
[AnnType] :: AnnKeywordId

-- | '()' for types
[AnnUnit] :: AnnKeywordId
[AnnUsing] :: AnnKeywordId

-- | e.g. INTEGER
[AnnVal] :: AnnKeywordId

-- | String value, will need quotes when output
[AnnValStr] :: AnnKeywordId

-- | '|'
[AnnVbar] :: AnnKeywordId
[AnnWhere] :: AnnKeywordId

-- | <tt>-&lt;</tt>
[Annlarrowtail] :: AnnKeywordId

-- | '-&gt;'
[Annrarrowtail] :: AnnKeywordId

-- | <tt>-&lt;&lt;</tt>
[AnnLarrowtail] :: AnnKeywordId

-- | <tt>&gt;&gt;-</tt>
[AnnRarrowtail] :: AnnKeywordId
[AnnEofPos] :: AnnKeywordId
data AnnotationComment

-- | something beginning '-- |'
[AnnDocCommentNext] :: String -> AnnotationComment

-- | something beginning '-- ^'
[AnnDocCommentPrev] :: String -> AnnotationComment

-- | something beginning '-- $'
[AnnDocCommentNamed] :: String -> AnnotationComment

-- | a section heading
[AnnDocSection] :: Int -> String -> AnnotationComment

-- | doc options (prune, ignore-exports, etc)
[AnnDocOptions] :: String -> AnnotationComment

-- | doc options declared "-- # ..."-style
[AnnDocOptionsOld] :: String -> AnnotationComment

-- | comment starting by "--"
[AnnLineComment] :: String -> AnnotationComment

-- | comment in {- -}
[AnnBlockComment] :: String -> AnnotationComment

-- | Retrieve a list of annotation <a>SrcSpan</a>s based on the
--   <a>SrcSpan</a> of the annotated AST element, and the known type of the
--   annotation.
getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]

-- | Retrieve a list of annotation <a>SrcSpan</a>s based on the
--   <a>SrcSpan</a> of the annotated AST element, and the known type of the
--   annotation. The list is removed from the annotations.
getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns)

-- | Retrieve the comments allocated to the current <a>SrcSpan</a>
--   
--   Note: A given <a>SrcSpan</a> may appear in multiple AST elements,
--   beware of duplicates
getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]

-- | Retrieve the comments allocated to the current <a>SrcSpan</a>, and
--   remove them from the annotations
getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns)
cyclicModuleErr :: [ModSummary] -> SDoc
instance ParsedMod ParsedModule
instance ParsedMod TypecheckedModule
instance TypecheckedMod TypecheckedModule
instance ParsedMod DesugaredModule
instance TypecheckedMod DesugaredModule
instance DesugaredMod DesugaredModule
instance Outputable CoreModule

module DriverMkDepend
doMkDependHS :: GhcMonad m => [FilePath] -> m ()

module Debugger

-- | The :print &amp; friends commands
pprintClosureCommand :: GhcMonad m => Bool -> Bool -> String -> m ()
showTerm :: GhcMonad m => Term -> m SDoc
pprTypeAndContents :: GhcMonad m => Id -> m SDoc

module TcSplice
tcSpliceExpr :: HsSplice Name -> TcRhoType -> TcM (HsExpr TcId)
tcTypedBracket :: HsBracket Name -> TcRhoType -> TcM (HsExpr TcId)
tcUntypedBracket :: HsBracket Name -> [PendingRnSplice] -> TcRhoType -> TcM (HsExpr TcId)
runQuasiQuoteExpr :: HsQuasiQuote RdrName -> RnM (LHsExpr RdrName)
runQuasiQuotePat :: HsQuasiQuote RdrName -> RnM (LPat RdrName)
runQuasiQuoteDecl :: HsQuasiQuote RdrName -> RnM [LHsDecl RdrName]
runQuasiQuoteType :: HsQuasiQuote RdrName -> RnM (LHsType RdrName)
runAnnotation :: CoreAnnTarget -> LHsExpr Name -> TcM Annotation
runMetaE :: LHsExpr Id -> TcM (LHsExpr RdrName)
runMetaP :: LHsExpr Id -> TcM (LPat RdrName)
runMetaT :: LHsExpr Id -> TcM (LHsType RdrName)
runMetaD :: LHsExpr Id -> TcM [LHsDecl RdrName]
runQuasi :: Q a -> TcM a
tcTopSpliceExpr :: Bool -> TcM (LHsExpr Id) -> TcM (LHsExpr Id)
lookupThName_maybe :: Name -> TcM (Maybe Name)

-- | outputs splice information for 2 flags which have different output
--   formats: `-ddump-splices` and `-dth-dec-file`
--   
--   This duplicates code in RnSplice.lhs
traceSplice :: SpliceInfo -> TcM ()

-- | The splice data to be logged
--   
--   duplicates code in RnSplice.lhs
data SpliceInfo
[SpliceInfo] :: Bool -> String -> Maybe SrcSpan -> Maybe SDoc -> SDoc -> SpliceInfo
[spliceIsDeclaration] :: SpliceInfo -> Bool
[spliceDescription] :: SpliceInfo -> String
[spliceLocation] :: SpliceInfo -> Maybe SrcSpan
[spliceSource] :: SpliceInfo -> Maybe SDoc
[spliceGenerated] :: SpliceInfo -> SDoc
defaultRunMeta :: MetaHook TcM
runMeta' :: Bool -> (hs_syn -> SDoc) -> (SrcSpan -> x -> TcM (Either MsgDoc hs_syn)) -> LHsExpr Id -> TcM hs_syn
instance Quasi (IOEnv (Env TcGblEnv TcLclEnv))
