ghc 9.12.4 → 9.14.1

+ GHC: LocalStep :: SrcSpan -> SingleStep

+ GHC: ModuleStep :: SrcSpan -> SingleStep

+ GHC: Opt_GhciBrowser :: GeneralFlag

+ GHC: Opt_GhciBrowserRedirectWasiConsole :: GeneralFlag

+ GHC: Opt_GhciDoLoadTargets :: GeneralFlag

+ GHC: Opt_WriteSelfRecompFlags :: GeneralFlag

+ GHC: Opt_WriteSelfRecompInfo :: GeneralFlag

+ GHC: StepOut :: Maybe SrcSpan -> SingleStep

+ GHC: [breakAt] :: SingleStep -> SrcSpan

+ GHC: [ghciBrowserHost] :: DynFlags -> String

+ GHC: [ghciBrowserPlaywrightBrowserType] :: DynFlags -> Maybe String

+ GHC: [ghciBrowserPlaywrightLaunchOpts] :: DynFlags -> Maybe String

+ GHC: [ghciBrowserPort] :: DynFlags -> Int

+ GHC: [ghciBrowserPuppeteerLaunchOpts] :: DynFlags -> Maybe String

+ GHC: [initiatedFrom] :: SingleStep -> Maybe SrcSpan

+ GHC: [unitSettings] :: DynFlags -> UnitSettings

+ GHC: guessTargetId :: GhcMonad m => String -> m TargetId

+ GHC: initialiseInteractiveDynFlags :: GhcMonad m => DynFlags -> HscEnv -> m HscEnv

+ GHC: isLoadedHomeModule :: GhcMonad m => Module -> m Bool

+ GHC: lookupAllQualifiedModuleNames :: GhcMonad m => PkgQual -> ModuleName -> m [Module]

+ GHC: lookupLoadedHomeModuleByModuleName :: GhcMonad m => ModuleName -> m (Maybe [Module])

+ GHC: normaliseInteractiveDynFlags :: MonadIO m => Logger -> DynFlags -> m DynFlags

+ GHC: setProgramHUG :: GhcMonad m => HomeUnitGraph -> m Bool

+ GHC: setProgramHUG_ :: GhcMonad m => Bool -> HomeUnitGraph -> m Bool

+ GHC: type BreakTickIndex = Int

+ GHC.Builtin.Names: gHC_INTERNAL_JS_PRIM :: Module

+ GHC.Builtin.Names: gHC_INTERNAL_WASM_PRIM_TYPES :: Module

+ GHC.Builtin.Names: unsafeUnpackJSStringUtf8ShShKey :: Unique

+ GHC.Builtin.Names: unsafeUnpackJSStringUtf8ShShName :: Name

+ GHC.Builtin.Names.TH: pragSpecEDIdKey :: Unique

+ GHC.Builtin.Names.TH: pragSpecEDName :: Name

+ GHC.Builtin.Names.TH: pragSpecInlEDIdKey :: Unique

+ GHC.Builtin.Names.TH: pragSpecInlEDName :: Name

+ GHC.Builtin.Names.TH: quasiQuoterTyConKey :: Unique

+ GHC.Builtin.Names.TH: quasiQuoterTyConName :: Name

+ GHC.Builtin.PrimOps: AnnotateStackOp :: PrimOp

+ GHC.Builtin.PrimOps: SetOtherThreadAllocationCounter :: PrimOp

+ GHC.Builtin.PrimOps: instance GHC.Internal.Classes.Eq GHC.Builtin.PrimOps.PrimOp

+ GHC.Builtin.PrimOps: instance GHC.Internal.Classes.Eq GHC.Builtin.PrimOps.PrimOpEffect

+ GHC.Builtin.PrimOps: instance GHC.Internal.Classes.Ord GHC.Builtin.PrimOps.PrimOp

+ GHC.Builtin.PrimOps: instance GHC.Internal.Classes.Ord GHC.Builtin.PrimOps.PrimOpEffect

+ GHC.Builtin.Types: isBuiltInOcc :: OccName -> Bool

+ GHC.Builtin.Types: isInfiniteFamilyOrigName_maybe :: Module -> OccName -> Maybe Name

+ GHC.Builtin.Types: isSumTyOrigName_maybe :: Module -> OccName -> Maybe Name

+ GHC.Builtin.Types: isTupleTyOrigName_maybe :: Module -> OccName -> Maybe Name

+ GHC.Builtin.Types: unboxedSoloDataConName :: Name

+ GHC.Builtin.Types: unboxedSoloTyCon :: TyCon

+ GHC.Builtin.Types: unboxedSoloTyConName :: Name

+ GHC.Builtin.Types: unboxedSumDataConName :: ConTag -> Arity -> Name

+ GHC.Builtin.Types: unboxedSumTyConName :: Arity -> Name

+ GHC.Builtin.Uniques: isCTupleTyConUnique :: Unique -> Maybe Arity

+ GHC.ByteCode.Asm: assembleBCO :: Platform -> ProtoBCO Name -> IO UnlinkedBCO

+ GHC.ByteCode.Asm: instance GHC.ByteCode.Asm.MonadAssembler GHC.ByteCode.Asm.InspectAsm

+ GHC.ByteCode.Asm: instance GHC.ByteCode.Asm.MonadAssembler GHC.ByteCode.Asm.RunAsm

+ GHC.ByteCode.Asm: instance GHC.Internal.Base.Applicative GHC.ByteCode.Asm.InspectAsm

+ GHC.ByteCode.Asm: instance GHC.Internal.Base.Applicative GHC.ByteCode.Asm.RunAsm

+ GHC.ByteCode.Asm: instance GHC.Internal.Base.Functor GHC.ByteCode.Asm.InspectAsm

+ GHC.ByteCode.Asm: instance GHC.Internal.Base.Functor GHC.ByteCode.Asm.OneOrTwo

+ GHC.ByteCode.Asm: instance GHC.Internal.Base.Functor GHC.ByteCode.Asm.RunAsm

+ GHC.ByteCode.Asm: instance GHC.Internal.Base.Monad GHC.ByteCode.Asm.InspectAsm

+ GHC.ByteCode.Asm: instance GHC.Internal.Base.Monad GHC.ByteCode.Asm.RunAsm

+ GHC.ByteCode.Asm: instance GHC.Utils.Outputable.Outputable GHC.ByteCode.Asm.InspectState

+ GHC.ByteCode.Breakpoints: CgBreakInfo :: [IfaceTvBndr] -> [Maybe (IfaceIdBndr, Word)] -> IfaceType -> Either InternalBreakLoc BreakpointId -> CgBreakInfo

+ GHC.ByteCode.Breakpoints: InternalBreakLoc :: BreakpointId -> InternalBreakLoc

+ GHC.ByteCode.Breakpoints: InternalBreakpointId :: Module -> BreakInfoIndex -> InternalBreakpointId

+ GHC.ByteCode.Breakpoints: InternalModBreaks :: IntMap CgBreakInfo -> ModBreaks -> InternalModBreaks

+ GHC.ByteCode.Breakpoints: [cgb_resty] :: CgBreakInfo -> IfaceType

+ GHC.ByteCode.Breakpoints: [cgb_tick_id] :: CgBreakInfo -> Either InternalBreakLoc BreakpointId

+ GHC.ByteCode.Breakpoints: [cgb_tyvars] :: CgBreakInfo -> [IfaceTvBndr]

+ GHC.ByteCode.Breakpoints: [cgb_vars] :: CgBreakInfo -> [Maybe (IfaceIdBndr, Word)]

+ GHC.ByteCode.Breakpoints: [ibi_info_index] :: InternalBreakpointId -> BreakInfoIndex

+ GHC.ByteCode.Breakpoints: [ibi_info_mod] :: InternalBreakpointId -> Module

+ GHC.ByteCode.Breakpoints: [imodBreaks_breakInfo] :: InternalModBreaks -> IntMap CgBreakInfo

+ GHC.ByteCode.Breakpoints: [imodBreaks_modBreaks] :: InternalModBreaks -> ModBreaks

+ GHC.ByteCode.Breakpoints: [internalBreakLoc] :: InternalBreakLoc -> BreakpointId

+ GHC.ByteCode.Breakpoints: data CgBreakInfo

+ GHC.ByteCode.Breakpoints: data InternalBreakpointId

+ GHC.ByteCode.Breakpoints: data InternalModBreaks

+ GHC.ByteCode.Breakpoints: getBreakCCS :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO (String, String)

+ GHC.ByteCode.Breakpoints: getBreakDecls :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [String]

+ GHC.ByteCode.Breakpoints: getBreakLoc :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO SrcSpan

+ GHC.ByteCode.Breakpoints: getBreakSourceId :: InternalBreakpointId -> InternalModBreaks -> BreakpointId

+ GHC.ByteCode.Breakpoints: getBreakSourceMod :: InternalBreakpointId -> InternalModBreaks -> Module

+ GHC.ByteCode.Breakpoints: getBreakVars :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [OccName]

+ GHC.ByteCode.Breakpoints: getInternalBreak :: InternalBreakpointId -> InternalModBreaks -> CgBreakInfo

+ GHC.ByteCode.Breakpoints: imodBreaks_module :: InternalModBreaks -> Module

+ GHC.ByteCode.Breakpoints: instance Control.DeepSeq.NFData GHC.ByteCode.Breakpoints.InternalBreakLoc

+ GHC.ByteCode.Breakpoints: instance Control.DeepSeq.NFData GHC.ByteCode.Breakpoints.InternalBreakpointId

+ GHC.ByteCode.Breakpoints: instance GHC.Internal.Classes.Eq GHC.ByteCode.Breakpoints.InternalBreakLoc

+ GHC.ByteCode.Breakpoints: instance GHC.Internal.Classes.Eq GHC.ByteCode.Breakpoints.InternalBreakpointId

+ GHC.ByteCode.Breakpoints: instance GHC.Internal.Classes.Ord GHC.ByteCode.Breakpoints.InternalBreakpointId

+ GHC.ByteCode.Breakpoints: instance GHC.Utils.Outputable.Outputable GHC.ByteCode.Breakpoints.CgBreakInfo

+ GHC.ByteCode.Breakpoints: instance GHC.Utils.Outputable.Outputable GHC.ByteCode.Breakpoints.InternalBreakLoc

+ GHC.ByteCode.Breakpoints: instance GHC.Utils.Outputable.Outputable GHC.ByteCode.Breakpoints.InternalBreakpointId

+ GHC.ByteCode.Breakpoints: mkInternalModBreaks :: Module -> IntMap CgBreakInfo -> ModBreaks -> InternalModBreaks

+ GHC.ByteCode.Breakpoints: newtype InternalBreakLoc

+ GHC.ByteCode.Breakpoints: seqInternalModBreaks :: InternalModBreaks -> ()

+ GHC.ByteCode.Breakpoints: type BreakInfoIndex = Int

+ GHC.ByteCode.Instr: instance GHC.Internal.Classes.Eq GHC.ByteCode.Instr.LocalLabel

+ GHC.ByteCode.Instr: instance GHC.Internal.Classes.Ord GHC.ByteCode.Instr.LocalLabel

+ GHC.ByteCode.Instr: instance GHC.Types.Unique.Uniquable GHC.ByteCode.Instr.LocalLabel

+ GHC.ByteCode.Types: BCONPtrCostCentre :: InternalBreakpointId -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrFFIInfo :: FFIInfo -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrFS :: FastString -> BCONPtr

+ GHC.ByteCode.Types: BreakpointId :: Module -> BreakTickIndex -> BreakpointId

+ GHC.ByteCode.Types: InternalBreakpointId :: Module -> BreakInfoIndex -> InternalBreakpointId

+ GHC.ByteCode.Types: InternalModBreaks :: IntMap CgBreakInfo -> ModBreaks -> InternalModBreaks

+ GHC.ByteCode.Types: [bi_tick_index] :: BreakpointId -> BreakTickIndex

+ GHC.ByteCode.Types: [bi_tick_mod] :: BreakpointId -> Module

+ GHC.ByteCode.Types: [cgb_tick_id] :: CgBreakInfo -> Either InternalBreakLoc BreakpointId

+ GHC.ByteCode.Types: [ffiInfoArgs] :: FFIInfo -> [FFIType]

+ GHC.ByteCode.Types: [ffiInfoRet] :: FFIInfo -> FFIType

+ GHC.ByteCode.Types: [ibi_info_index] :: InternalBreakpointId -> BreakInfoIndex

+ GHC.ByteCode.Types: [ibi_info_mod] :: InternalBreakpointId -> Module

+ GHC.ByteCode.Types: [imodBreaks_breakInfo] :: InternalModBreaks -> IntMap CgBreakInfo

+ GHC.ByteCode.Types: [imodBreaks_modBreaks] :: InternalModBreaks -> ModBreaks

+ GHC.ByteCode.Types: data BreakpointId

+ GHC.ByteCode.Types: data FFIInfo

+ GHC.ByteCode.Types: data InternalBreakpointId

+ GHC.ByteCode.Types: data InternalModBreaks

+ GHC.ByteCode.Types: fromSmallArray :: SmallArray a -> FlatBag a

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Eq GHC.ByteCode.Types.ByteOff

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Eq GHC.ByteCode.Types.HalfWord

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Eq GHC.ByteCode.Types.NativeCallType

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Eq GHC.ByteCode.Types.RegBitmap

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Eq GHC.ByteCode.Types.WordOff

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Ord GHC.ByteCode.Types.ByteOff

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Ord GHC.ByteCode.Types.HalfWord

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Ord GHC.ByteCode.Types.RegBitmap

+ GHC.ByteCode.Types: instance GHC.Internal.Classes.Ord GHC.ByteCode.Types.WordOff

+ GHC.ByteCode.Types: seqInternalModBreaks :: InternalModBreaks -> ()

+ GHC.ByteCode.Types: type BreakInfoIndex = Int

+ GHC.ByteCode.Types: type BreakTickIndex = Int

+ GHC.Cmm: instance GHC.Internal.Classes.Eq GHC.Cmm.CmmInfoTable

+ GHC.Cmm: instance GHC.Internal.Classes.Eq GHC.Cmm.ProfilingInfo

+ GHC.Cmm: instance GHC.Internal.Classes.Eq GHC.Cmm.SectionProtection

+ GHC.Cmm: instance GHC.Internal.Classes.Ord GHC.Cmm.CmmInfoTable

+ GHC.Cmm: instance GHC.Internal.Classes.Ord GHC.Cmm.ProfilingInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.CLabel

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.CmmLabelInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.ConInfoTableLocation

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.DynamicLinkerLabelInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.ForeignLabelSource

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.IdLabelInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.InfoProvEnt

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.ModuleLabelKind

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.NeedExternDecl

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.RtsLabelInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Eq GHC.Cmm.CLabel.TickyIdInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.CLabel

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.CmmLabelInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.ConInfoTableLocation

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.DynamicLinkerLabelInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.ForeignLabelSource

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.IdLabelInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.InfoProvEnt

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.ModuleLabelKind

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.NeedExternDecl

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.RtsLabelInfo

+ GHC.Cmm.CLabel: instance GHC.Internal.Classes.Ord GHC.Cmm.CLabel.TickyIdInfo

+ GHC.Cmm.Dataflow.Label: instance GHC.Internal.Classes.Eq GHC.Cmm.Dataflow.Label.Label

+ GHC.Cmm.Dataflow.Label: instance GHC.Internal.Classes.Eq GHC.Cmm.Dataflow.Label.LabelSet

+ GHC.Cmm.Dataflow.Label: instance GHC.Internal.Classes.Eq v => GHC.Internal.Classes.Eq (GHC.Cmm.Dataflow.Label.LabelMap v)

+ GHC.Cmm.Dataflow.Label: instance GHC.Internal.Classes.Ord GHC.Cmm.Dataflow.Label.Label

+ GHC.Cmm.Dataflow.Label: instance GHC.Internal.Classes.Ord GHC.Cmm.Dataflow.Label.LabelSet

+ GHC.Cmm.Dataflow.Label: instance GHC.Internal.Classes.Ord v => GHC.Internal.Classes.Ord (GHC.Cmm.Dataflow.Label.LabelMap v)

+ GHC.Cmm.Dataflow.Label: mapMapMaybe :: (a -> Maybe b) -> LabelMap a -> LabelMap b

+ GHC.Cmm.DebugBlock: instance GHC.Internal.Classes.Eq GHC.Cmm.DebugBlock.UnwindExpr

+ GHC.Cmm.Dominators: instance GHC.Internal.Classes.Eq GHC.Cmm.Dominators.DominatorSet

+ GHC.Cmm.Dominators: instance GHC.Internal.Classes.Eq GHC.Cmm.Dominators.RPNum

+ GHC.Cmm.Dominators: instance GHC.Internal.Classes.Ord GHC.Cmm.Dominators.RPNum

+ GHC.Cmm.Expr: instance (GHC.Internal.Classes.Ord r, GHC.Cmm.Expr.UserOfRegs r GHC.Cmm.Reg.CmmReg) => GHC.Cmm.Expr.UserOfRegs r GHC.Cmm.Expr.CmmExpr

+ GHC.Cmm.Expr: instance GHC.Internal.Classes.Eq GHC.Cmm.Expr.AlignmentSpec

+ GHC.Cmm.Expr: instance GHC.Internal.Classes.Eq GHC.Cmm.Expr.Area

+ GHC.Cmm.Expr: instance GHC.Internal.Classes.Eq GHC.Cmm.Expr.CmmExpr

+ GHC.Cmm.Expr: instance GHC.Internal.Classes.Eq GHC.Cmm.Expr.CmmLit

+ GHC.Cmm.Expr: instance GHC.Internal.Classes.Ord GHC.Cmm.Expr.AlignmentSpec

+ GHC.Cmm.Expr: instance GHC.Internal.Classes.Ord GHC.Cmm.Expr.Area

+ GHC.Cmm.Expr: instance GHC.Internal.Classes.Ord r => GHC.Cmm.Expr.DefinerOfRegs r r

+ GHC.Cmm.Expr: instance GHC.Internal.Classes.Ord r => GHC.Cmm.Expr.UserOfRegs r r

+ GHC.Cmm.Graph: instance GHC.Internal.Classes.Eq GHC.Cmm.Graph.Transfer

+ GHC.Cmm.Info.Build: instance GHC.Internal.Classes.Eq GHC.Cmm.Info.Build.CAFfyLabel

+ GHC.Cmm.Info.Build: instance GHC.Internal.Classes.Eq GHC.Cmm.Info.Build.SRTEntry

+ GHC.Cmm.Info.Build: instance GHC.Internal.Classes.Eq GHC.Cmm.Info.Build.SomeLabel

+ GHC.Cmm.Info.Build: instance GHC.Internal.Classes.Ord GHC.Cmm.Info.Build.CAFfyLabel

+ GHC.Cmm.Info.Build: instance GHC.Internal.Classes.Ord GHC.Cmm.Info.Build.SRTEntry

+ GHC.Cmm.Info.Build: instance GHC.Internal.Classes.Ord GHC.Cmm.Info.Build.SomeLabel

+ GHC.Cmm.MachOp: MO_I64X2_Max :: CallishMachOp

+ GHC.Cmm.MachOp: MO_I64X2_Min :: CallishMachOp

+ GHC.Cmm.MachOp: MO_W64X2_Max :: CallishMachOp

+ GHC.Cmm.MachOp: MO_W64X2_Min :: CallishMachOp

+ GHC.Cmm.MachOp: callishMachOpArgTys :: Platform -> CallishMachOp -> [CmmType]

+ GHC.Cmm.MachOp: instance GHC.Internal.Classes.Eq GHC.Cmm.MachOp.AtomicMachOp

+ GHC.Cmm.MachOp: instance GHC.Internal.Classes.Eq GHC.Cmm.MachOp.CallishMachOp

+ GHC.Cmm.MachOp: instance GHC.Internal.Classes.Eq GHC.Cmm.MachOp.FMASign

+ GHC.Cmm.MachOp: instance GHC.Internal.Classes.Eq GHC.Cmm.MachOp.MachOp

+ GHC.Cmm.MachOp: instance GHC.Internal.Classes.Eq GHC.Cmm.MachOp.MemoryOrdering

+ GHC.Cmm.MachOp: instance GHC.Internal.Classes.Ord GHC.Cmm.MachOp.MemoryOrdering

+ GHC.Cmm.Node: instance (GHC.Internal.Classes.Ord r, GHC.Cmm.Expr.UserOfRegs r GHC.Cmm.Reg.CmmReg) => GHC.Cmm.Expr.UserOfRegs r GHC.Cmm.Node.ForeignTarget

+ GHC.Cmm.Node: instance GHC.Internal.Classes.Eq (GHC.Cmm.Node.CmmNode e x)

+ GHC.Cmm.Node: instance GHC.Internal.Classes.Eq GHC.Cmm.Node.CmmReturnInfo

+ GHC.Cmm.Node: instance GHC.Internal.Classes.Eq GHC.Cmm.Node.CmmTickScope

+ GHC.Cmm.Node: instance GHC.Internal.Classes.Eq GHC.Cmm.Node.Convention

+ GHC.Cmm.Node: instance GHC.Internal.Classes.Eq GHC.Cmm.Node.ForeignConvention

+ GHC.Cmm.Node: instance GHC.Internal.Classes.Eq GHC.Cmm.Node.ForeignTarget

+ GHC.Cmm.Node: instance GHC.Internal.Classes.Ord GHC.Cmm.Node.CmmTickScope

+ GHC.Cmm.Reducibility: instance GHC.Internal.Classes.Eq GHC.Cmm.Reducibility.Reducibility

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Eq GHC.Cmm.Reg.CmmReg

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Eq GHC.Cmm.Reg.GlobalArgRegs

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Eq GHC.Cmm.Reg.GlobalReg

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Eq GHC.Cmm.Reg.GlobalRegUse

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Eq GHC.Cmm.Reg.LocalReg

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Ord GHC.Cmm.Reg.CmmReg

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Ord GHC.Cmm.Reg.GlobalArgRegs

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Ord GHC.Cmm.Reg.GlobalReg

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Ord GHC.Cmm.Reg.GlobalRegUse

+ GHC.Cmm.Reg: instance GHC.Internal.Classes.Ord GHC.Cmm.Reg.LocalReg

+ GHC.Cmm.Switch: instance GHC.Internal.Classes.Eq GHC.Cmm.Switch.SwitchTargets

+ GHC.Cmm.Type: instance GHC.Internal.Classes.Eq GHC.Cmm.Type.CmmCat

+ GHC.Cmm.Type: instance GHC.Internal.Classes.Eq GHC.Cmm.Type.ForeignHint

+ GHC.Cmm.Type: instance GHC.Internal.Classes.Eq GHC.Cmm.Type.Width

+ GHC.Cmm.Type: instance GHC.Internal.Classes.Ord GHC.Cmm.Type.Width

+ GHC.CmmToAsm.AArch64.Cond: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.AArch64.Cond.Cond

+ GHC.CmmToAsm.AArch64.Instr: J_TBL :: [Maybe BlockId] -> Maybe CLabel -> Reg -> Instr

+ GHC.CmmToAsm.AArch64.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.AArch64.Instr.DMBISHFlags

+ GHC.CmmToAsm.AArch64.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.AArch64.Instr.ExtMode

+ GHC.CmmToAsm.AArch64.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.AArch64.Instr.Operand

+ GHC.CmmToAsm.AArch64.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.AArch64.Instr.ShiftMode

+ GHC.CmmToAsm.AArch64.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.AArch64.Instr.Target

+ GHC.CmmToAsm.AArch64.Instr: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.AArch64.Instr.Target

+ GHC.CmmToAsm.AArch64.Regs: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.AArch64.Regs.AddrMode

+ GHC.CmmToAsm.AArch64.Regs: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.AArch64.Regs.Imm

+ GHC.CmmToAsm.BlockLayout: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.BlockLayout.BlockChain

+ GHC.CmmToAsm.BlockLayout: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.BlockLayout.BlockChain

+ GHC.CmmToAsm.CFG: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.CFG.BranchInfo

+ GHC.CmmToAsm.CFG: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.CFG.CfgEdge

+ GHC.CmmToAsm.CFG: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.CFG.EdgeInfo

+ GHC.CmmToAsm.CFG: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.CFG.EdgeWeight

+ GHC.CmmToAsm.CFG: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.CFG.TransitionSource

+ GHC.CmmToAsm.CFG: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.CFG.CfgEdge

+ GHC.CmmToAsm.CFG: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.CFG.EdgeWeight

+ GHC.CmmToAsm.Dwarf.Types: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Dwarf.Types.DwarfAbbrev

+ GHC.CmmToAsm.Format: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Format.Format

+ GHC.CmmToAsm.Format: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Format.ScalarFormat

+ GHC.CmmToAsm.Format: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.Format.Format

+ GHC.CmmToAsm.Format: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.Format.ScalarFormat

+ GHC.CmmToAsm.LA64: instance GHC.CmmToAsm.Instr.Instruction GHC.CmmToAsm.LA64.Instr.Instr

+ GHC.CmmToAsm.LA64: ncgLA64 :: NCGConfig -> NcgImpl RawCmmStatics Instr JumpDest

+ GHC.CmmToAsm.LA64.CodeGen: cmmTopCodeGen :: RawCmmDecl -> NatM [NatCmmDecl RawCmmStatics Instr]

+ GHC.CmmToAsm.LA64.CodeGen: generateJumpTableForInstr :: NCGConfig -> Instr -> Maybe (NatCmmDecl RawCmmStatics Instr)

+ GHC.CmmToAsm.LA64.CodeGen: makeFarBranches :: Platform -> LabelMap RawCmmStatics -> [NatBasicBlock Instr] -> UniqDSM [NatBasicBlock Instr]

+ GHC.CmmToAsm.LA64.Cond: EQ :: Cond

+ GHC.CmmToAsm.LA64.Cond: EQZ :: Cond

+ GHC.CmmToAsm.LA64.Cond: FGE :: Cond

+ GHC.CmmToAsm.LA64.Cond: FGT :: Cond

+ GHC.CmmToAsm.LA64.Cond: FLE :: Cond

+ GHC.CmmToAsm.LA64.Cond: FLT :: Cond

+ GHC.CmmToAsm.LA64.Cond: GE :: Cond

+ GHC.CmmToAsm.LA64.Cond: GEU :: Cond

+ GHC.CmmToAsm.LA64.Cond: LT :: Cond

+ GHC.CmmToAsm.LA64.Cond: LTU :: Cond

+ GHC.CmmToAsm.LA64.Cond: NE :: Cond

+ GHC.CmmToAsm.LA64.Cond: NEZ :: Cond

+ GHC.CmmToAsm.LA64.Cond: SGE :: Cond

+ GHC.CmmToAsm.LA64.Cond: SGT :: Cond

+ GHC.CmmToAsm.LA64.Cond: SLE :: Cond

+ GHC.CmmToAsm.LA64.Cond: SLT :: Cond

+ GHC.CmmToAsm.LA64.Cond: UGE :: Cond

+ GHC.CmmToAsm.LA64.Cond: UGT :: Cond

+ GHC.CmmToAsm.LA64.Cond: ULE :: Cond

+ GHC.CmmToAsm.LA64.Cond: ULT :: Cond

+ GHC.CmmToAsm.LA64.Cond: data Cond

+ GHC.CmmToAsm.LA64.Cond: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.LA64.Cond.Cond

+ GHC.CmmToAsm.LA64.Cond: instance GHC.Internal.Show.Show GHC.CmmToAsm.LA64.Cond.Cond

+ GHC.CmmToAsm.LA64.Instr: ADD :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: ALSL :: Operand -> Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: ALSLU :: Operand -> Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: AND :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: ANDN :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: ANN :: SDoc -> Instr -> Instr

+ GHC.CmmToAsm.LA64.Instr: B :: Target -> Instr

+ GHC.CmmToAsm.LA64.Instr: BCOND :: Cond -> Operand -> Operand -> Target -> Instr

+ GHC.CmmToAsm.LA64.Instr: BCOND1 :: Cond -> Operand -> Operand -> Target -> Instr

+ GHC.CmmToAsm.LA64.Instr: BEQZ :: Operand -> Target -> Instr

+ GHC.CmmToAsm.LA64.Instr: BITREV4B :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: BITREV8B :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: BITREVD :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: BITREVW :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: BL :: Target -> [Reg] -> Instr

+ GHC.CmmToAsm.LA64.Instr: BNEZ :: Operand -> Target -> Instr

+ GHC.CmmToAsm.LA64.Instr: BSTRINS :: Format -> Operand -> Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: BSTRPICK :: Format -> Operand -> Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: BYTEPICK :: Operand -> Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: CALL :: Target -> [Reg] -> Instr

+ GHC.CmmToAsm.LA64.Instr: CALL36 :: Target -> Instr

+ GHC.CmmToAsm.LA64.Instr: CLO :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: CLZ :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: COMMENT :: SDoc -> Instr

+ GHC.CmmToAsm.LA64.Instr: CSET :: Cond -> Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: CTO :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: CTZ :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: DBAR :: BarrierType -> Instr

+ GHC.CmmToAsm.LA64.Instr: DELTA :: Int -> Instr

+ GHC.CmmToAsm.LA64.Instr: DIV :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: DIVU :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: EXT :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FABS :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FCVT :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FCVTZS :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FMA :: FMASign -> Operand -> Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FMAX :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FMAXA :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FMIN :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FMINA :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FNEG :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: FSQRT :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: Hint0 :: BarrierType

+ GHC.CmmToAsm.LA64.Instr: IBAR :: BarrierType -> Instr

+ GHC.CmmToAsm.LA64.Instr: J :: Target -> Instr

+ GHC.CmmToAsm.LA64.Instr: J_TBL :: [Maybe BlockId] -> Maybe CLabel -> Reg -> Instr

+ GHC.CmmToAsm.LA64.Instr: LD :: Format -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: LDATA :: Section -> RawCmmStatics -> Instr

+ GHC.CmmToAsm.LA64.Instr: LDPTR :: Format -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: LDU :: Format -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: LDX :: Format -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: LDXU :: Format -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: LOCATION :: Int -> Int -> Int -> LexicalFastString -> Instr

+ GHC.CmmToAsm.LA64.Instr: LU12I :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: LU32I :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: LU52I :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MASKEQZ :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MASKNEZ :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MOD :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MODU :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MOV :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MUL :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MULH :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MULHU :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MULTILINE_COMMENT :: SDoc -> Instr

+ GHC.CmmToAsm.LA64.Instr: MULW :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: MULWU :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: NEG :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: NEWBLOCK :: BlockId -> Instr

+ GHC.CmmToAsm.LA64.Instr: NOP :: Instr

+ GHC.CmmToAsm.LA64.Instr: NOR :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: OR :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: ORN :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: OpAddr :: AddrMode -> Operand

+ GHC.CmmToAsm.LA64.Instr: OpImm :: Imm -> Operand

+ GHC.CmmToAsm.LA64.Instr: OpReg :: Width -> Reg -> Operand

+ GHC.CmmToAsm.LA64.Instr: PCADDI :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: PCADDU12I :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: PCADDU18I :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: PCALAU12I :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: POP_STACK_FRAME :: Instr

+ GHC.CmmToAsm.LA64.Instr: PRELD :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: PUSH_STACK_FRAME :: Instr

+ GHC.CmmToAsm.LA64.Instr: REVB2H :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: REVB2W :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: REVB4H :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: REVBD :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: REVH2W :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: REVHD :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: ROTR :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: SCVTF :: Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: SLL :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: SRA :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: SRL :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: SSLT :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: SSLTU :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: ST :: Format -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: STPTR :: Format -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: STX :: Format -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: SUB :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: TAIL36 :: Operand -> Target -> Instr

+ GHC.CmmToAsm.LA64.Instr: TBlock :: BlockId -> Target

+ GHC.CmmToAsm.LA64.Instr: TLabel :: CLabel -> Target

+ GHC.CmmToAsm.LA64.Instr: TReg :: Reg -> Target

+ GHC.CmmToAsm.LA64.Instr: XOR :: Operand -> Operand -> Operand -> Instr

+ GHC.CmmToAsm.LA64.Instr: allocMoreStack :: Platform -> Int -> NatCmmDecl statics Instr -> UniqDSM (NatCmmDecl statics Instr, [(BlockId, BlockId)])

+ GHC.CmmToAsm.LA64.Instr: callerSavedRegisters :: [Reg]

+ GHC.CmmToAsm.LA64.Instr: canFallthroughTo :: Instr -> BlockId -> Bool

+ GHC.CmmToAsm.LA64.Instr: d0 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d1 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d10 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d11 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d12 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d13 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d14 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d15 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d16 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d17 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d18 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d19 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d2 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d20 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d21 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d22 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d23 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d24 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d25 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d26 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d27 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d28 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d29 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d3 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d30 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d31 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d4 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d5 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d6 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d7 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d8 :: Operand

+ GHC.CmmToAsm.LA64.Instr: d9 :: Operand

+ GHC.CmmToAsm.LA64.Instr: data BarrierType

+ GHC.CmmToAsm.LA64.Instr: data Instr

+ GHC.CmmToAsm.LA64.Instr: data Operand

+ GHC.CmmToAsm.LA64.Instr: data Target

+ GHC.CmmToAsm.LA64.Instr: fitsInNbits :: Int -> Int -> Bool

+ GHC.CmmToAsm.LA64.Instr: fp :: Operand

+ GHC.CmmToAsm.LA64.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.LA64.Instr.Operand

+ GHC.CmmToAsm.LA64.Instr: instance GHC.Internal.Show.Show GHC.CmmToAsm.LA64.Instr.Operand

+ GHC.CmmToAsm.LA64.Instr: instance GHC.Utils.Outputable.Outputable GHC.CmmToAsm.Instr.RegUsage

+ GHC.CmmToAsm.LA64.Instr: instrCon :: Instr -> String

+ GHC.CmmToAsm.LA64.Instr: isEncodeableInWidth :: Width -> Integer -> Bool

+ GHC.CmmToAsm.LA64.Instr: isFloatOp :: Operand -> Bool

+ GHC.CmmToAsm.LA64.Instr: isFloatReg :: Reg -> Bool

+ GHC.CmmToAsm.LA64.Instr: isIntOp :: Operand -> Bool

+ GHC.CmmToAsm.LA64.Instr: isJumpishInstr :: Instr -> Bool

+ GHC.CmmToAsm.LA64.Instr: isMetaInstr :: Instr -> Bool

+ GHC.CmmToAsm.LA64.Instr: isNbitEncodeable :: Int -> Integer -> Bool

+ GHC.CmmToAsm.LA64.Instr: isUnsignOp :: Int -> Bool

+ GHC.CmmToAsm.LA64.Instr: jumpDestsOfInstr :: Instr -> [BlockId]

+ GHC.CmmToAsm.LA64.Instr: ldFormat :: Format -> Format

+ GHC.CmmToAsm.LA64.Instr: maxSpillSlots :: NCGConfig -> Int

+ GHC.CmmToAsm.LA64.Instr: mkJumpInstr :: BlockId -> [Instr]

+ GHC.CmmToAsm.LA64.Instr: mkLoadInstr :: NCGConfig -> RegWithFormat -> Int -> Int -> [Instr]

+ GHC.CmmToAsm.LA64.Instr: mkRegRegMoveInstr :: Reg -> Reg -> Instr

+ GHC.CmmToAsm.LA64.Instr: mkSpillInstr :: HasCallStack => NCGConfig -> RegWithFormat -> Int -> Int -> [Instr]

+ GHC.CmmToAsm.LA64.Instr: mkStackAllocInstr :: Platform -> Int -> [Instr]

+ GHC.CmmToAsm.LA64.Instr: mkStackDeallocInstr :: Platform -> Int -> [Instr]

+ GHC.CmmToAsm.LA64.Instr: opReg :: Reg -> Operand

+ GHC.CmmToAsm.LA64.Instr: opRegNo :: RegNo -> Operand

+ GHC.CmmToAsm.LA64.Instr: patchJumpInstr :: Instr -> (BlockId -> BlockId) -> Instr

+ GHC.CmmToAsm.LA64.Instr: patchRegsOfInstr :: Instr -> (Reg -> Reg) -> Instr

+ GHC.CmmToAsm.LA64.Instr: ra :: Operand

+ GHC.CmmToAsm.LA64.Instr: regUsageOfInstr :: Platform -> Instr -> RegUsage

+ GHC.CmmToAsm.LA64.Instr: sp :: Operand

+ GHC.CmmToAsm.LA64.Instr: spillSlotSize :: Int

+ GHC.CmmToAsm.LA64.Instr: spillSlotToOffset :: Int -> Int

+ GHC.CmmToAsm.LA64.Instr: stackAlign :: Int

+ GHC.CmmToAsm.LA64.Instr: stackFrameHeaderSize :: Int

+ GHC.CmmToAsm.LA64.Instr: takeDeltaInstr :: Instr -> Maybe Int

+ GHC.CmmToAsm.LA64.Instr: takeRegRegMoveInstr :: Instr -> Maybe (Reg, Reg)

+ GHC.CmmToAsm.LA64.Instr: tmp :: Operand

+ GHC.CmmToAsm.LA64.Instr: tp :: Operand

+ GHC.CmmToAsm.LA64.Instr: widthFromOpReg :: Operand -> Width

+ GHC.CmmToAsm.LA64.Instr: widthToInt :: Width -> Int

+ GHC.CmmToAsm.LA64.Instr: x0 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x1 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x10 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x11 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x12 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x13 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x14 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x15 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x16 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x17 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x18 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x19 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x2 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x20 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x21 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x22 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x23 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x24 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x25 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x26 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x27 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x28 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x29 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x3 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x30 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x31 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x4 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x5 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x6 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x7 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x8 :: Operand

+ GHC.CmmToAsm.LA64.Instr: x9 :: Operand

+ GHC.CmmToAsm.LA64.Instr: zero :: Operand

+ GHC.CmmToAsm.LA64.Ppr: pprInstr :: IsDoc doc => Platform -> Instr -> doc

+ GHC.CmmToAsm.LA64.Ppr: pprNatCmmDecl :: IsDoc doc => NCGConfig -> NatCmmDecl RawCmmStatics Instr -> doc

+ GHC.CmmToAsm.LA64.RegInfo: DestBlockId :: BlockId -> JumpDest

+ GHC.CmmToAsm.LA64.RegInfo: canShortcut :: Instr -> Maybe JumpDest

+ GHC.CmmToAsm.LA64.RegInfo: getJumpDestBlockId :: JumpDest -> Maybe BlockId

+ GHC.CmmToAsm.LA64.RegInfo: instance GHC.Utils.Outputable.Outputable GHC.CmmToAsm.LA64.RegInfo.JumpDest

+ GHC.CmmToAsm.LA64.RegInfo: newtype JumpDest

+ GHC.CmmToAsm.LA64.RegInfo: shortcutJump :: (BlockId -> Maybe JumpDest) -> Instr -> Instr

+ GHC.CmmToAsm.LA64.RegInfo: shortcutStatics :: (BlockId -> Maybe JumpDest) -> RawCmmStatics -> RawCmmStatics

+ GHC.CmmToAsm.LA64.Regs: AddrReg :: Reg -> AddrMode

+ GHC.CmmToAsm.LA64.Regs: AddrRegImm :: Reg -> Imm -> AddrMode

+ GHC.CmmToAsm.LA64.Regs: AddrRegReg :: Reg -> Reg -> AddrMode

+ GHC.CmmToAsm.LA64.Regs: ImmCLbl :: CLabel -> Imm

+ GHC.CmmToAsm.LA64.Regs: ImmConstantDiff :: Imm -> Imm -> Imm

+ GHC.CmmToAsm.LA64.Regs: ImmConstantSum :: Imm -> Imm -> Imm

+ GHC.CmmToAsm.LA64.Regs: ImmDouble :: Rational -> Imm

+ GHC.CmmToAsm.LA64.Regs: ImmFloat :: Rational -> Imm

+ GHC.CmmToAsm.LA64.Regs: ImmIndex :: CLabel -> Int -> Imm

+ GHC.CmmToAsm.LA64.Regs: ImmInt :: Int -> Imm

+ GHC.CmmToAsm.LA64.Regs: ImmInteger :: Integer -> Imm

+ GHC.CmmToAsm.LA64.Regs: ImmLit :: FastString -> Imm

+ GHC.CmmToAsm.LA64.Regs: allFpArgRegs :: [Reg]

+ GHC.CmmToAsm.LA64.Regs: allGpArgRegs :: [Reg]

+ GHC.CmmToAsm.LA64.Regs: allMachRegNos :: [RegNo]

+ GHC.CmmToAsm.LA64.Regs: allocatableRegs :: Platform -> [RealReg]

+ GHC.CmmToAsm.LA64.Regs: classOfRealReg :: RealReg -> RegClass

+ GHC.CmmToAsm.LA64.Regs: data AddrMode

+ GHC.CmmToAsm.LA64.Regs: data Imm

+ GHC.CmmToAsm.LA64.Regs: fpMachReg :: Reg

+ GHC.CmmToAsm.LA64.Regs: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.LA64.Regs.AddrMode

+ GHC.CmmToAsm.LA64.Regs: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.LA64.Regs.Imm

+ GHC.CmmToAsm.LA64.Regs: instance GHC.Internal.Show.Show GHC.CmmToAsm.LA64.Regs.AddrMode

+ GHC.CmmToAsm.LA64.Regs: instance GHC.Internal.Show.Show GHC.CmmToAsm.LA64.Regs.Imm

+ GHC.CmmToAsm.LA64.Regs: litToImm :: CmmLit -> Imm

+ GHC.CmmToAsm.LA64.Regs: mkVirtualReg :: Unique -> Format -> VirtualReg

+ GHC.CmmToAsm.LA64.Regs: raReg :: Reg

+ GHC.CmmToAsm.LA64.Regs: realRegSqueeze :: RegClass -> RealReg -> Int

+ GHC.CmmToAsm.LA64.Regs: regDotColor :: RealReg -> SDoc

+ GHC.CmmToAsm.LA64.Regs: spMachReg :: Reg

+ GHC.CmmToAsm.LA64.Regs: tmpReg :: Reg

+ GHC.CmmToAsm.LA64.Regs: tpMachReg :: Reg

+ GHC.CmmToAsm.LA64.Regs: virtualRegSqueeze :: RegClass -> VirtualReg -> Int

+ GHC.CmmToAsm.LA64.Regs: zeroReg :: Reg

+ GHC.CmmToAsm.PIC: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.PIC.ReferenceKind

+ GHC.CmmToAsm.PPC.Cond: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.PPC.Cond.Cond

+ GHC.CmmToAsm.RV64.Cond: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.RV64.Cond.Cond

+ GHC.CmmToAsm.RV64.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.RV64.Instr.Operand

+ GHC.CmmToAsm.RV64.Regs: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.RV64.Regs.AddrMode

+ GHC.CmmToAsm.RV64.Regs: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.RV64.Regs.Imm

+ GHC.CmmToAsm.Reg.Graph.Base: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Reg.Graph.Base.Reg

+ GHC.CmmToAsm.Reg.Graph.Base: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Reg.Graph.Base.RegClass

+ GHC.CmmToAsm.Reg.Graph.Base: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Reg.Graph.Base.RegSub

+ GHC.CmmToAsm.Reg.Graph.Base: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.Reg.Graph.Base.RegSub

+ GHC.CmmToAsm.Reg.Linear.Base: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Reg.Linear.Base.Loc

+ GHC.CmmToAsm.Reg.Linear.Base: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Reg.Linear.Base.ReadingOrWriting

+ GHC.CmmToAsm.Reg.Linear.Base: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Reg.Linear.Base.RealRegUsage

+ GHC.CmmToAsm.Reg.Linear.Base: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.Reg.Linear.Base.Loc

+ GHC.CmmToAsm.Reg.Linear.Base: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.Reg.Linear.Base.ReadingOrWriting

+ GHC.CmmToAsm.Reg.Linear.Base: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.Reg.Linear.Base.RealRegUsage

+ GHC.CmmToAsm.Reg.Linear.Base: instance GHC.Internal.Show.Show GHC.CmmToAsm.Reg.Linear.Base.Loc

+ GHC.CmmToAsm.Reg.Linear.FreeRegs: instance GHC.CmmToAsm.Reg.Linear.FreeRegs.FR GHC.CmmToAsm.Reg.Linear.LA64.FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: FreeRegs :: Word32 -> Word32 -> FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: allocateReg :: HasCallStack => RealReg -> FreeRegs -> FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: data FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: getFreeRegs :: RegClass -> FreeRegs -> [RealReg]

+ GHC.CmmToAsm.Reg.Linear.LA64: initFreeRegs :: Platform -> FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: instance GHC.Internal.Show.Show GHC.CmmToAsm.Reg.Linear.LA64.FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: instance GHC.Utils.Outputable.Outputable GHC.CmmToAsm.Reg.Linear.LA64.FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: noFreeRegs :: FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: releaseReg :: HasCallStack => RealReg -> FreeRegs -> FreeRegs

+ GHC.CmmToAsm.Reg.Linear.LA64: showBits :: Word32 -> String

+ GHC.CmmToAsm.Reg.Target: mapRegFormatSet :: HasDebugCallStack => (Reg -> Reg) -> UniqSet RegWithFormat -> UniqSet RegWithFormat

+ GHC.CmmToAsm.Wasm.Types: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Wasm.Types.SomeWasmType

+ GHC.CmmToAsm.Wasm.Types: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Wasm.Types.SymKind

+ GHC.CmmToAsm.Wasm.Types: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.Wasm.Types.SymName

+ GHC.CmmToAsm.Wasm.Types: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.Wasm.Types.SymName

+ GHC.CmmToAsm.X86.CodeGen: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.X86.CodeGen.Padding

+ GHC.CmmToAsm.X86.CodeGen: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.X86.CodeGen.StackRef

+ GHC.CmmToAsm.X86.CodeGen: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.X86.CodeGen.Padding

+ GHC.CmmToAsm.X86.CodeGen: instance GHC.Internal.Classes.Ord GHC.CmmToAsm.X86.CodeGen.StackRef

+ GHC.CmmToAsm.X86.Cond: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.X86.Cond.Cond

+ GHC.CmmToAsm.X86.Instr: BLEND :: Format -> Imm -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: MOVLHPS :: Format -> Reg -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PACKUSWB :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PADD :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PALIGNR :: Format -> Imm -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PAND :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PANDN :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PBLENDW :: Format -> Imm -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PCMPGT :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PEXTR :: Format -> Format -> Imm -> Reg -> Operand -> Instr

+ GHC.CmmToAsm.X86.Instr: PINSR :: Format -> Format -> Imm -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PMULL :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PMULUDQ :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: POR :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PSHUFB :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PSHUFHW :: Format -> Imm -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PSHUFLW :: Format -> Imm -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PSLL :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PSRL :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PSUB :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PUNPCKHBW :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PUNPCKHDQ :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PUNPCKHQDQ :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PUNPCKHWD :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PUNPCKLBW :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PUNPCKLDQ :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PUNPCKLWD :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: UNPCKH :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: VBLEND :: Format -> Imm -> Operand -> Reg -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: VINSERTPS :: Format -> Imm -> Operand -> Reg -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: VMOVHLPS :: Format -> Reg -> Reg -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: VMOVLHPS :: Format -> Reg -> Reg -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: VMOV_MERGE :: Format -> Reg -> Reg -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: VPBROADCAST :: Format -> Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: VUNPCKH :: Format -> Operand -> Reg -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: VUNPCKL :: Format -> Operand -> Reg -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.X86.Instr.MinMaxType

+ GHC.CmmToAsm.X86.Instr: instance GHC.Internal.Classes.Eq GHC.CmmToAsm.X86.Instr.MinOrMax

+ GHC.CmmToC: instance GHC.Internal.Classes.Eq GHC.CmmToC.Fixity

+ GHC.CmmToLlvm.CodeGen: instance GHC.Internal.Classes.Eq GHC.CmmToLlvm.CodeGen.Signage

+ GHC.CmmToLlvm.Version.Type: instance GHC.Internal.Classes.Eq GHC.CmmToLlvm.Version.Type.LlvmVersion

+ GHC.CmmToLlvm.Version.Type: instance GHC.Internal.Classes.Ord GHC.CmmToLlvm.Version.Type.LlvmVersion

+ GHC.Core: collectValArgs :: Expr b -> (Expr b, [Arg b])

+ GHC.Core: instance Control.DeepSeq.NFData GHC.Core.IsOrphan

+ GHC.Core: instance GHC.Internal.Classes.Eq GHC.Core.AltCon

+ GHC.Core: instance GHC.Internal.Classes.Eq GHC.Core.UnfoldingCache

+ GHC.Core: instance GHC.Internal.Classes.Eq GHC.Core.UnfoldingGuidance

+ GHC.Core: instance GHC.Internal.Classes.Ord GHC.Core.AltCon

+ GHC.Core: rhssOfBinds :: [Bind b] -> [Expr b]

+ GHC.Core: type InTyCoVar = TyCoVar

+ GHC.Core: type OutTyCoVar = TyCoVar

+ GHC.Core.Class: instance GHC.Internal.Classes.Eq GHC.Core.Class.Class

+ GHC.Core.Coercion: hasCoercionHole :: Type -> Bool

+ GHC.Core.Coercion: mkForAllVisCos :: HasDebugCallStack => [ForAllTyBinder] -> Coercion -> Coercion

+ GHC.Core.Coercion: updateLCSubst :: LiftingContext -> (Subst -> (Subst, a)) -> (LiftingContext, a)

+ GHC.Core.Coercion.Axiom: instance Control.DeepSeq.NFData Language.Haskell.Syntax.Basic.Role

+ GHC.Core.Coercion.Axiom: instance GHC.Internal.Classes.Eq (GHC.Core.Coercion.Axiom.CoAxiom br)

+ GHC.Core.Coercion.Axiom: instance GHC.Internal.Classes.Eq GHC.Core.Coercion.Axiom.CoAxiomRule

+ GHC.Core.ConLike: conLikeVisArity :: ConLike -> VisArity

+ GHC.Core.ConLike: instance GHC.Internal.Classes.Eq GHC.Core.ConLike.ConLike

+ GHC.Core.DataCon: dataConUserTyVarBindersNeedWrapper :: DataCon -> Bool

+ GHC.Core.DataCon: dataConVisArity :: DataCon -> VisArity

+ GHC.Core.DataCon: instance Control.DeepSeq.NFData Language.Haskell.Syntax.Basic.SrcStrictness

+ GHC.Core.DataCon: instance Control.DeepSeq.NFData Language.Haskell.Syntax.Basic.SrcUnpackedness

+ GHC.Core.DataCon: instance GHC.Internal.Classes.Eq GHC.Core.DataCon.DataCon

+ GHC.Core.DataCon: instance GHC.Internal.Classes.Eq GHC.Core.DataCon.StrictnessMark

+ GHC.Core.DataCon: instance GHC.Internal.Data.Data.Data GHC.Core.DataCon.HsSrcBang

+ GHC.Core.DataCon: isLazyDataConRep :: DataCon -> Bool

+ GHC.Core.DataCon: isUnaryClassDataCon :: DataCon -> Bool

+ GHC.Core.DataCon: isUnpacked :: HsImplBang -> Bool

+ GHC.Core.FVs: addBndrFV :: CoreBndr -> FV -> FV

+ GHC.Core.FVs: addBndrsFV :: [CoreBndr] -> FV -> FV

+ GHC.Core.FVs: exprLocalFVs :: CoreExpr -> FV

+ GHC.Core.Lint: instance GHC.Internal.Classes.Eq GHC.Core.Lint.StaticPtrCheck

+ GHC.Core.Make: mkCoreConWrapApps :: DataCon -> [CoreExpr] -> CoreExpr

+ GHC.Core.Make: mkCoreTyLams :: [TyVarBinder] -> CoreExpr -> CoreExpr

+ GHC.Core.Map.Expr: instance GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn GHC.Core.CoreAlt)

+ GHC.Core.Map.Expr: instance GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn GHC.Core.CoreExpr)

+ GHC.Core.Map.Expr: mapMaybeTM :: TrieMap m => (a -> Maybe b) -> m a -> m b

+ GHC.Core.Map.Type: instance GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn GHC.Core.TyCo.Rep.Coercion)

+ GHC.Core.Map.Type: instance GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn GHC.Core.TyCo.Rep.Type)

+ GHC.Core.Map.Type: instance GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn GHC.Types.Var.Var)

+ GHC.Core.Map.Type: instance GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn a) => GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn (GHC.Internal.Maybe.Maybe a))

+ GHC.Core.Map.Type: instance GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn a) => GHC.Internal.Classes.Eq (GHC.Core.Map.Type.DeBruijn [a])

+ GHC.Core.Map.Type: mapMaybeTM :: TrieMap m => (a -> Maybe b) -> m a -> m b

+ GHC.Core.Multiplicity: instance GHC.Internal.Classes.Eq GHC.Core.Multiplicity.IsSubmult

+ GHC.Core.Opt.Arity: instance GHC.Internal.Classes.Eq GHC.Core.Opt.Arity.ArityType

+ GHC.Core.Opt.Arity: instance GHC.Internal.Classes.Eq GHC.Core.Opt.Arity.Cost

+ GHC.Core.Opt.CallerCC.Types: instance Control.DeepSeq.NFData GHC.Core.Opt.CallerCC.Types.CallerCcFilter

+ GHC.Core.Opt.CallerCC.Types: instance Control.DeepSeq.NFData GHC.Core.Opt.CallerCC.Types.NamePattern

+ GHC.Core.Opt.SetLevels: instance GHC.Internal.Classes.Eq GHC.Core.Opt.SetLevels.Level

+ GHC.Core.Opt.Simplify.Env: checkSimplEnvIS :: SimplEnvIS -> Bool

+ GHC.Core.Opt.Simplify.Env: getFullSubst :: InScopeSet -> SimplEnv -> Subst

+ GHC.Core.Opt.Simplify.Env: getTCvSubst :: SimplEnv -> Subst

+ GHC.Core.Opt.Simplify.Env: pprBadSimplEnvIS :: SimplEnvIS -> SDoc

+ GHC.Core.Opt.Simplify.Env: type SimplEnvIS = SimplEnv

+ GHC.Core.Opt.Simplify.Utils: [ai_rules] :: ArgInfo -> [CoreRule]

+ GHC.Core.Opt.Simplify.Utils: argSpecArg :: ArgSpec -> OutExpr

+ GHC.Core.Opt.Simplify.Utils: contOutArgs :: SimplEnv -> SimplCont -> [OutExpr]

+ GHC.Core.Opt.Simplify.Utils: dropContArgs :: FullArgCount -> SimplCont -> SimplCont

+ GHC.Core.Opt.Stats: instance GHC.Internal.Classes.Eq GHC.Core.Opt.Stats.Tick

+ GHC.Core.Opt.Stats: instance GHC.Internal.Classes.Ord GHC.Core.Opt.Stats.Tick

+ GHC.Core.Opt.WorkWrap.Utils: canUnboxTyCon :: HasDebugCallStack => TyCon -> Maybe [DataCon]

+ GHC.Core.Opt.WorkWrap.Utils: canUnboxType :: HasDebugCallStack => Type -> Maybe [DataCon]

+ GHC.Core.Opt.WorkWrap.Utils: instance GHC.Internal.Classes.Eq GHC.Core.Opt.WorkWrap.Utils.IsRecDataConResult

+ GHC.Core.PatSyn: instance GHC.Internal.Classes.Eq GHC.Core.PatSyn.PatSyn

+ GHC.Core.PatSyn: patSynVisArity :: PatSyn -> VisArity

+ GHC.Core.Predicate: TyFamLHS :: TyCon -> [Type] -> CanEqLHS

+ GHC.Core.Predicate: TyVarLHS :: TyVar -> CanEqLHS

+ GHC.Core.Predicate: canEqLHSKind :: CanEqLHS -> Kind

+ GHC.Core.Predicate: canEqLHSType :: CanEqLHS -> Type

+ GHC.Core.Predicate: canEqLHS_maybe :: Type -> Maybe CanEqLHS

+ GHC.Core.Predicate: canTyFamEqLHS_maybe :: Type -> Maybe CanEqLHS

+ GHC.Core.Predicate: couldBeIPLike :: Type -> Bool

+ GHC.Core.Predicate: data CanEqLHS

+ GHC.Core.Predicate: decomposeIPPred :: Type -> (Id, [Type])

+ GHC.Core.Predicate: eqCanEqLHS :: CanEqLHS -> CanEqLHS -> Bool

+ GHC.Core.Predicate: instance GHC.Internal.Classes.Eq GHC.Core.Predicate.EqRel

+ GHC.Core.Predicate: instance GHC.Internal.Classes.Ord GHC.Core.Predicate.EqRel

+ GHC.Core.Predicate: instance GHC.Utils.Outputable.Outputable GHC.Core.Predicate.CanEqLHS

+ GHC.Core.Predicate: isEqClassPred :: PredType -> Bool

+ GHC.Core.Predicate: isEvId :: Var -> Bool

+ GHC.Core.Predicate: isReprEqPred :: PredType -> Bool

+ GHC.Core.Predicate: isSimplePredTy :: HasDebugCallStack => Type -> Bool

+ GHC.Core.Predicate: isUnaryClass :: Class -> Bool

+ GHC.Core.Predicate: mightMentionIP :: (Type -> Bool) -> (Type -> Bool) -> Class -> [Type] -> Bool

+ GHC.Core.Predicate: mkEqPred :: EqRel -> Type -> Type -> PredType

+ GHC.Core.Predicate: mkEqPredRole :: Role -> Type -> Type -> PredType

+ GHC.Core.Predicate: mkNomEqPred :: Type -> Type -> Type

+ GHC.Core.Predicate: mkReprEqPred :: Type -> Type -> Type

+ GHC.Core.Predicate: pprPredType :: PredType -> SDoc

+ GHC.Core.Predicate: scopedSort :: [Var] -> [Var]

+ GHC.Core.Predicate: tyCoVarsOfTypeWellScoped :: Type -> [TyVar]

+ GHC.Core.Predicate: tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]

+ GHC.Core.Rules: ruleIsOrphan :: CoreRule -> Bool

+ GHC.Core.Rules: ruleLhsIsMoreSpecific :: InScopeSet -> [Var] -> [CoreExpr] -> CoreRule -> Bool

+ GHC.Core.SimpleOpt: [so_inline] :: SimpleOpts -> Bool

+ GHC.Core.SimpleOpt: simpleOptExprNoInline :: HasDebugCallStack => SimpleOpts -> CoreExpr -> CoreExpr

+ GHC.Core.Subst: cloneBndrsM :: MonadUnique m => Subst -> [Var] -> m (Subst, [Var])

+ GHC.Core.Subst: cloneRecIdBndrsM :: MonadUnique m => Subst -> [Id] -> m (Subst, [Id])

+ GHC.Core.Subst: substInScopeSet :: Subst -> InScopeSet

+ GHC.Core.TyCo.Compare: instance GHC.Internal.Classes.Eq GHC.Core.TyCo.Compare.TypeOrdering

+ GHC.Core.TyCo.Compare: instance GHC.Internal.Classes.Ord GHC.Core.TyCo.Compare.TypeOrdering

+ GHC.Core.TyCo.Compare: tcEqTyConAppArgs :: [Type] -> [Type] -> Bool

+ GHC.Core.TyCo.Rep: instance Control.DeepSeq.NFData GHC.Core.TyCo.Rep.FunSel

+ GHC.Core.TyCo.Rep: instance GHC.Internal.Classes.Eq GHC.Core.TyCo.Rep.CoSel

+ GHC.Core.TyCo.Rep: instance GHC.Internal.Classes.Eq GHC.Core.TyCo.Rep.FunSel

+ GHC.Core.TyCo.Rep: instance GHC.Internal.Classes.Eq GHC.Core.TyCo.Rep.TyLit

+ GHC.Core.TyCo.Rep: instance GHC.Internal.Classes.Eq GHC.Core.TyCo.Rep.UnivCoProvenance

+ GHC.Core.TyCo.Rep: instance GHC.Internal.Classes.Ord GHC.Core.TyCo.Rep.CoSel

+ GHC.Core.TyCo.Rep: instance GHC.Internal.Classes.Ord GHC.Core.TyCo.Rep.FunSel

+ GHC.Core.TyCo.Rep: instance GHC.Internal.Classes.Ord GHC.Core.TyCo.Rep.UnivCoProvenance

+ GHC.Core.TyCo.Subst: mkSubst :: InScopeSet -> IdSubstEnv -> TvSubstEnv -> CvSubstEnv -> Subst

+ GHC.Core.TyCo.Subst: substInScopeSet :: Subst -> InScopeSet

+ GHC.Core.TyCon: UnaryClassTyCon :: DataCon -> AlgTyConRhs

+ GHC.Core.TyCon: instance Control.DeepSeq.NFData GHC.Core.TyCon.Injectivity

+ GHC.Core.TyCon: instance Control.DeepSeq.NFData GHC.Core.TyCon.TyConBndrVis

+ GHC.Core.TyCon: instance GHC.Internal.Classes.Eq GHC.Core.TyCon.Injectivity

+ GHC.Core.TyCon: instance GHC.Internal.Classes.Eq GHC.Core.TyCon.PrimElemRep

+ GHC.Core.TyCon: instance GHC.Internal.Classes.Eq GHC.Core.TyCon.PrimOrVoidRep

+ GHC.Core.TyCon: instance GHC.Internal.Classes.Eq GHC.Core.TyCon.PrimRep

+ GHC.Core.TyCon: instance GHC.Internal.Classes.Eq GHC.Core.TyCon.TyCon

+ GHC.Core.TyCon: instance GHC.Internal.Classes.Ord GHC.Core.TyCon.PrimElemRep

+ GHC.Core.TyCon: instance GHC.Internal.Classes.Ord GHC.Core.TyCon.PrimOrVoidRep

+ GHC.Core.TyCon: instance GHC.Internal.Classes.Ord GHC.Core.TyCon.PrimRep

+ GHC.Core.TyCon: isBoxedDataTyCon :: TyCon -> Bool

+ GHC.Core.TyCon: isInferredTyConBinder :: VarBndr var TyConBndrVis -> Bool

+ GHC.Core.TyCon: isInvisSpecTyConBinder :: VarBndr tv TyConBndrVis -> Bool

+ GHC.Core.TyCon: isUnaryClassTyCon :: TyCon -> Bool

+ GHC.Core.TyCon: isUnaryClassTyCon_maybe :: TyCon -> Maybe (Class, DataCon)

+ GHC.Core.Type: collectPiTyBinders :: Type -> [PiTyBinder]

+ GHC.Core.Type: invisibleBndrCount :: Type -> Int

+ GHC.Core.Type: isDataFamilyApp :: Type -> Bool

+ GHC.Core.Type: isSatTyFamApp :: Type -> Maybe (TyCon, [Type])

+ GHC.Core.Type: liftedTypeOrConstraintKind :: TypeOrConstraint -> Kind

+ GHC.Core.Type: splitVisibleFunTy_maybe :: Type -> Maybe (Type, Type)

+ GHC.Core.Type: substInScopeSet :: Subst -> InScopeSet

+ GHC.Core.Unify: DontBindMe :: BindFlag

+ GHC.Core.Unify: MARCast :: MaybeApartReason

+ GHC.Core.Unify: alwaysBindFam :: BindFamFun

+ GHC.Core.Unify: alwaysBindTv :: BindTvFun

+ GHC.Core.Unify: dontCareBindFam :: HasCallStack => BindFamFun

+ GHC.Core.Unify: instance GHC.Internal.Classes.Eq GHC.Core.Unify.BindFlag

+ GHC.Core.Unify: matchBindTv :: TyCoVarSet -> BindTvFun

+ GHC.Core.Unify: tcUnifyDebugger :: Type -> Type -> Maybe Subst

+ GHC.Core.Unify: tcUnifyFunDeps :: TyCoVarSet -> [Type] -> [Type] -> Maybe Subst

+ GHC.Core.Unify: tcUnifyTyForInjectivity :: AmIUnifying -> InScopeSet -> Type -> Type -> Maybe Subst

+ GHC.Core.Unify: type BindFamFun = TyCon -> [Type] -> Type -> BindFlag

+ GHC.Core.Unify: type BindTvFun = TyCoVar -> Type -> BindFlag

+ GHC.Core.Utils: exprIsUnaryClassFun :: CoreExpr -> Bool

+ GHC.Core.Utils: isUnaryClassId :: Id -> Bool

+ GHC.CoreToIface: toIfaceBooleanFormula :: BooleanFormula GhcRn -> IfaceBooleanFormula

+ GHC.CoreToStg: instance GHC.Internal.Classes.Eq GHC.CoreToStg.HowBound

+ GHC.CoreToStg: instance GHC.Internal.Classes.Eq GHC.CoreToStg.LetInfo

+ GHC.CoreToStg.AddImplicitBinds: addImplicitBinds :: CorePrepPgmConfig -> ModLocation -> [TyCon] -> CoreProgram -> IO CoreProgram

+ GHC.CoreToStg.Prep: instance GHC.Internal.Classes.Eq GHC.CoreToStg.Prep.BindInfo

+ GHC.CoreToStg.Prep: instance GHC.Internal.Classes.Eq GHC.CoreToStg.Prep.FloatInfo

+ GHC.CoreToStg.Prep: instance GHC.Utils.Outputable.Outputable GHC.CoreToStg.Prep.FloatDecision

+ GHC.Data.Bag: foldBag_flip :: (a -> b -> b) -> Bag a -> b -> b

+ GHC.Data.Bool: instance GHC.Internal.Classes.Eq GHC.Data.Bool.OverridingBool

+ GHC.Data.Bool: instance GHC.Internal.Classes.Ord GHC.Data.Bool.OverridingBool

+ GHC.Data.BooleanFormula: bfMap :: forall (p :: Pass) (p' :: Pass). (LIdP (GhcPass p) -> LIdP (GhcPass p')) -> BooleanFormula (GhcPass p) -> BooleanFormula (GhcPass p')

+ GHC.Data.BooleanFormula: bfTraverse :: forall f (p :: Pass) (p' :: Pass). Applicative f => (LIdP (GhcPass p) -> f (LIdP (GhcPass p'))) -> BooleanFormula (GhcPass p) -> f (BooleanFormula (GhcPass p'))

+ GHC.Data.BooleanFormula: instance GHC.Hs.Extension.OutputableBndrId p => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.BooleanFormula.BooleanFormula (GHC.Hs.Extension.GhcPass p))

+ GHC.Data.BooleanFormula: pprBooleanFormulaNormal :: forall (p :: Pass). OutputableBndrId p => BooleanFormula (GhcPass p) -> SDoc

+ GHC.Data.FastString: instance GHC.Internal.Classes.Eq GHC.Data.FastString.FastString

+ GHC.Data.FastString: instance GHC.Internal.Classes.Eq GHC.Data.FastString.LexicalFastString

+ GHC.Data.FastString: instance GHC.Internal.Classes.Eq GHC.Data.FastString.NonDetFastString

+ GHC.Data.FastString: instance GHC.Internal.Classes.Ord GHC.Data.FastString.LexicalFastString

+ GHC.Data.FastString: instance GHC.Internal.Classes.Ord GHC.Data.FastString.NonDetFastString

+ GHC.Data.FlatBag: fromSmallArray :: SmallArray a -> FlatBag a

+ GHC.Data.Graph.Directed: emptyGraph :: Graph a

+ GHC.Data.Graph.Directed: instance GHC.Internal.Classes.Eq GHC.Data.Graph.Directed.EdgeType

+ GHC.Data.Graph.Directed: instance GHC.Internal.Classes.Eq GHC.Data.Graph.Directed.Time

+ GHC.Data.Graph.Directed: instance GHC.Internal.Classes.Ord GHC.Data.Graph.Directed.EdgeType

+ GHC.Data.Graph.Directed: instance GHC.Internal.Classes.Ord GHC.Data.Graph.Directed.Time

+ GHC.Data.Graph.Directed.Internal: Edge :: node -> node -> Edge node

+ GHC.Data.Graph.Directed.Internal: Graph :: IntGraph -> (Vertex -> node) -> (node -> Maybe Vertex) -> Graph node

+ GHC.Data.Graph.Directed.Internal: [gr_int_graph] :: Graph node -> IntGraph

+ GHC.Data.Graph.Directed.Internal: [gr_node_to_vertex] :: Graph node -> node -> Maybe Vertex

+ GHC.Data.Graph.Directed.Internal: [gr_vertex_to_node] :: Graph node -> Vertex -> node

+ GHC.Data.Graph.Directed.Internal: data Edge node

+ GHC.Data.Graph.Directed.Internal: data Graph node

+ GHC.Data.Graph.Directed.Internal: edgesG :: Graph node -> [Edge node]

+ GHC.Data.Graph.Directed.Internal: instance GHC.Utils.Outputable.Outputable node => GHC.Utils.Outputable.Outputable (GHC.Data.Graph.Directed.Internal.Edge node)

+ GHC.Data.Graph.Directed.Internal: instance GHC.Utils.Outputable.Outputable node => GHC.Utils.Outputable.Outputable (GHC.Data.Graph.Directed.Internal.Graph node)

+ GHC.Data.Graph.Directed.Internal: preorderF :: Forest a -> [a]

+ GHC.Data.Graph.Directed.Internal: reachable :: IntGraph -> [Vertex] -> [Vertex]

+ GHC.Data.Graph.Directed.Internal: scc :: IntGraph -> [SCC Vertex]

+ GHC.Data.Graph.Directed.Internal: type IntGraph = Graph

+ GHC.Data.Graph.Directed.Internal: verticesG :: Graph node -> [node]

+ GHC.Data.Graph.Directed.Reachability: allReachable :: ReachabilityIndex node -> node -> [node]

+ GHC.Data.Graph.Directed.Reachability: allReachableMany :: ReachabilityIndex node -> [node] -> [node]

+ GHC.Data.Graph.Directed.Reachability: cyclicGraphReachability :: Graph node -> ReachabilityIndex node

+ GHC.Data.Graph.Directed.Reachability: data ReachabilityIndex node

+ GHC.Data.Graph.Directed.Reachability: graphReachability :: Graph node -> ReachabilityIndex node

+ GHC.Data.Graph.Directed.Reachability: isReachable :: ReachabilityIndex node -> node -> node -> Bool

+ GHC.Data.Graph.Directed.Reachability: isReachableMany :: ReachabilityIndex node -> [node] -> node -> Bool

+ GHC.Data.Graph.Directed.Reachability: reachabilityIndexMembers :: ReachabilityIndex node -> [node]

+ GHC.Data.Graph.Inductive.Graph: instance (GHC.Data.Graph.Inductive.Graph.Graph gr, GHC.Internal.Classes.Ord a, GHC.Internal.Classes.Ord b) => GHC.Internal.Classes.Eq (GHC.Data.Graph.Inductive.Graph.OrdGr gr a b)

+ GHC.Data.Graph.Inductive.Graph: instance (GHC.Data.Graph.Inductive.Graph.Graph gr, GHC.Internal.Classes.Ord a, GHC.Internal.Classes.Ord b) => GHC.Internal.Classes.Ord (GHC.Data.Graph.Inductive.Graph.OrdGr gr a b)

+ GHC.Data.Graph.Inductive.Graph: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Data.Graph.Inductive.Graph.LPath a)

+ GHC.Data.Graph.Inductive.Graph: instance GHC.Internal.Classes.Eq b => GHC.Internal.Classes.Eq (GHC.Data.Graph.Inductive.Graph.GroupEdges b)

+ GHC.Data.Graph.Inductive.Graph: instance GHC.Internal.Classes.Ord a => GHC.Internal.Classes.Ord (GHC.Data.Graph.Inductive.Graph.LPath a)

+ GHC.Data.Graph.Inductive.PatriciaTree: instance (GHC.Internal.Classes.Eq a, GHC.Internal.Classes.Ord b) => GHC.Internal.Classes.Eq (GHC.Data.Graph.Inductive.PatriciaTree.Gr a b)

+ GHC.Data.Graph.Inductive.PatriciaTree: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Data.Graph.Inductive.PatriciaTree.FromListCounting a)

+ GHC.Data.Graph.UnVar: instance GHC.Internal.Classes.Eq GHC.Data.Graph.UnVar.UnVarSet

+ GHC.Data.IOEnv: updEnvIO :: (env -> IO env') -> IOEnv env' a -> IOEnv env a

+ GHC.Data.List: mapAndUnzip :: (a -> (b, c)) -> [a] -> ([b], [c])

+ GHC.Data.List: mapAndUnzip3 :: (a -> (b, c, d)) -> [a] -> ([b], [c], [d])

+ GHC.Data.List: mapAndUnzip4 :: (a -> (b, c, d, e)) -> [a] -> ([b], [c], [d], [e])

+ GHC.Data.List.Infinite: enumFrom :: Enum a => a -> Infinite a

+ GHC.Data.List.Infinite: instance GHC.Internal.Base.Monad GHC.Data.List.Infinite.Infinite

+ GHC.Data.List.NonEmpty: (!!) :: HasCallStack => NonEmpty a -> Int -> a

+ GHC.Data.List.NonEmpty: (:|) :: a -> [a] -> NonEmpty a

+ GHC.Data.List.NonEmpty: (<|) :: a -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: append :: NonEmpty a -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: appendList :: NonEmpty a -> [a] -> NonEmpty a

+ GHC.Data.List.NonEmpty: break :: (a -> Bool) -> NonEmpty a -> ([a], [a])

+ GHC.Data.List.NonEmpty: compareLength :: NonEmpty a -> Int -> Ordering

+ GHC.Data.List.NonEmpty: cons :: a -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: cycle :: NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: data NonEmpty a

+ GHC.Data.List.NonEmpty: drop :: Int -> NonEmpty a -> [a]

+ GHC.Data.List.NonEmpty: dropWhile :: (a -> Bool) -> NonEmpty a -> [a]

+ GHC.Data.List.NonEmpty: filter :: (a -> Bool) -> NonEmpty a -> [a]

+ GHC.Data.List.NonEmpty: fromList :: HasCallStack => [a] -> NonEmpty a

+ GHC.Data.List.NonEmpty: group :: (Foldable f, Eq a) => f a -> [NonEmpty a]

+ GHC.Data.List.NonEmpty: group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)

+ GHC.Data.List.NonEmpty: groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]

+ GHC.Data.List.NonEmpty: groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)

+ GHC.Data.List.NonEmpty: groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]

+ GHC.Data.List.NonEmpty: groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)

+ GHC.Data.List.NonEmpty: groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]

+ GHC.Data.List.NonEmpty: groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)

+ GHC.Data.List.NonEmpty: head :: NonEmpty a -> a

+ GHC.Data.List.NonEmpty: infixl 9 !!

+ GHC.Data.List.NonEmpty: infixr 5 :|

+ GHC.Data.List.NonEmpty: init :: NonEmpty a -> [a]

+ GHC.Data.List.NonEmpty: inits :: Foldable f => f a -> NonEmpty [a]

+ GHC.Data.List.NonEmpty: inits1 :: NonEmpty a -> NonEmpty (NonEmpty a)

+ GHC.Data.List.NonEmpty: insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a

+ GHC.Data.List.NonEmpty: intersperse :: a -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool

+ GHC.Data.List.NonEmpty: isSingleton :: NonEmpty a -> Bool

+ GHC.Data.List.NonEmpty: iterate :: (a -> a) -> a -> NonEmpty a

+ GHC.Data.List.NonEmpty: last :: NonEmpty a -> a

+ GHC.Data.List.NonEmpty: length :: NonEmpty a -> Int

+ GHC.Data.List.NonEmpty: map :: (a -> b) -> NonEmpty a -> NonEmpty b

+ GHC.Data.List.NonEmpty: mapAndUnzip :: (a -> (b, c)) -> NonEmpty a -> (NonEmpty b, NonEmpty c)

+ GHC.Data.List.NonEmpty: mapAndUnzip3 :: (a -> (b, c, d)) -> NonEmpty a -> (NonEmpty b, NonEmpty c, NonEmpty d)

+ GHC.Data.List.NonEmpty: nonEmpty :: [a] -> Maybe (NonEmpty a)

+ GHC.Data.List.NonEmpty: nub :: Eq a => NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])

+ GHC.Data.List.NonEmpty: permutations :: [a] -> NonEmpty [a]

+ GHC.Data.List.NonEmpty: permutations1 :: NonEmpty a -> NonEmpty (NonEmpty a)

+ GHC.Data.List.NonEmpty: prependList :: [a] -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: repeat :: a -> NonEmpty a

+ GHC.Data.List.NonEmpty: reverse :: NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b

+ GHC.Data.List.NonEmpty: scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b

+ GHC.Data.List.NonEmpty: scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: singleton :: a -> NonEmpty a

+ GHC.Data.List.NonEmpty: some1 :: Alternative f => f a -> f (NonEmpty a)

+ GHC.Data.List.NonEmpty: sort :: Ord a => NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a

+ GHC.Data.List.NonEmpty: span :: (a -> Bool) -> NonEmpty a -> ([a], [a])

+ GHC.Data.List.NonEmpty: splitAt :: Int -> NonEmpty a -> ([a], [a])

+ GHC.Data.List.NonEmpty: tail :: NonEmpty a -> [a]

+ GHC.Data.List.NonEmpty: tails :: Foldable f => f a -> NonEmpty [a]

+ GHC.Data.List.NonEmpty: tails1 :: NonEmpty a -> NonEmpty (NonEmpty a)

+ GHC.Data.List.NonEmpty: take :: Int -> NonEmpty a -> [a]

+ GHC.Data.List.NonEmpty: takeWhile :: (a -> Bool) -> NonEmpty a -> [a]

+ GHC.Data.List.NonEmpty: toList :: Foldable t => t a -> [a]

+ GHC.Data.List.NonEmpty: transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)

+ GHC.Data.List.NonEmpty: uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))

+ GHC.Data.List.NonEmpty: unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b

+ GHC.Data.List.NonEmpty: unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b

+ GHC.Data.List.NonEmpty: unzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)

+ GHC.Data.List.NonEmpty: unzip3 :: NonEmpty (a, b, c) -> (NonEmpty a, NonEmpty b, NonEmpty c)

+ GHC.Data.List.NonEmpty: xor :: NonEmpty Bool -> Bool

+ GHC.Data.List.NonEmpty: zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)

+ GHC.Data.List.NonEmpty: zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

+ GHC.Data.List.NonEmpty: zipWithM :: Applicative f => (a -> b -> f c) -> NonEmpty a -> NonEmpty b -> f (NonEmpty c)

+ GHC.Data.Pair: instance Data.Foldable1.Foldable1 GHC.Data.Pair.Pair

+ GHC.Data.SmallArray: newSmallArrayIO :: Int -> a -> IO (SmallMutableArrayIO a)

+ GHC.Data.SmallArray: type SmallMutableArrayIO a = SmallMutableArray RealWorld a

+ GHC.Data.SmallArray: unsafeFreezeSmallArrayIO :: SmallMutableArrayIO a -> IO (SmallArray a)

+ GHC.Data.SmallArray: writeSmallArrayIO :: SmallMutableArrayIO a -> Int -> a -> IO ()

+ GHC.Data.Strict: instance (GHC.Internal.Classes.Eq a, GHC.Internal.Classes.Eq b) => GHC.Internal.Classes.Eq (GHC.Data.Strict.Pair a b)

+ GHC.Data.Strict: instance (GHC.Internal.Classes.Ord a, GHC.Internal.Classes.Ord b) => GHC.Internal.Classes.Ord (GHC.Data.Strict.Pair a b)

+ GHC.Data.Strict: instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (GHC.Data.Strict.Maybe a)

+ GHC.Data.Strict: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Data.Strict.Maybe a)

+ GHC.Data.Strict: instance GHC.Internal.Classes.Ord a => GHC.Internal.Classes.Ord (GHC.Data.Strict.Maybe a)

+ GHC.Data.TrieMap: instance (GHC.Internal.Classes.Eq (GHC.Data.TrieMap.Key m), GHC.Data.TrieMap.TrieMap m) => GHC.Data.TrieMap.TrieMap (GHC.Data.TrieMap.GenMap m)

+ GHC.Data.TrieMap: instance (GHC.Internal.Classes.Eq (GHC.Data.TrieMap.Key m), GHC.Data.TrieMap.TrieMap m) => GHC.Internal.Data.Foldable.Foldable (GHC.Data.TrieMap.GenMap m)

+ GHC.Data.TrieMap: instance GHC.Internal.Classes.Ord k => GHC.Data.TrieMap.TrieMap (Data.Map.Internal.Map k)

+ GHC.Data.TrieMap: mapMaybeTM :: TrieMap m => (a -> Maybe b) -> m a -> m b

+ GHC.Data.UnionFind: instance GHC.Internal.Classes.Eq (GHC.Data.UnionFind.Point s a)

+ GHC.Data.Word64Map.Internal: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Data.Word64Map.Internal.Word64Map a)

+ GHC.Data.Word64Map.Internal: instance GHC.Internal.Classes.Ord a => GHC.Internal.Classes.Ord (GHC.Data.Word64Map.Internal.Word64Map a)

+ GHC.Data.Word64Set.Internal: instance GHC.Internal.Classes.Eq GHC.Data.Word64Set.Internal.Word64Set

+ GHC.Data.Word64Set.Internal: instance GHC.Internal.Classes.Ord GHC.Data.Word64Set.Internal.Word64Set

+ GHC.Driver.Backend.Internal: instance GHC.Internal.Classes.Eq GHC.Driver.Backend.Internal.BackendName

+ GHC.Driver.Backpack: instance GHC.Internal.Classes.Eq GHC.Driver.Backpack.SessionType

+ GHC.Driver.Config: EvalStepNone :: EvalStep

+ GHC.Driver.Config: EvalStepOut :: EvalStep

+ GHC.Driver.Config: EvalStepSingle :: EvalStep

+ GHC.Driver.Config: data EvalStep

+ GHC.Driver.Config.Parser: supportedLanguagePragmas :: DynFlags -> [String]

+ GHC.Driver.Downsweep: DownsweepUseCompile :: DownsweepMode

+ GHC.Driver.Downsweep: DownsweepUseFixed :: DownsweepMode

+ GHC.Driver.Downsweep: External :: UnitId -> SummariseResult

+ GHC.Driver.Downsweep: FoundHome :: ModuleNodeInfo -> SummariseResult

+ GHC.Driver.Downsweep: FoundHomeWithError :: (UnitId, DriverMessages) -> SummariseResult

+ GHC.Driver.Downsweep: FoundInstantiation :: InstantiatedUnit -> SummariseResult

+ GHC.Driver.Downsweep: NotThere :: SummariseResult

+ GHC.Driver.Downsweep: checkHomeUnitsClosed :: UnitEnv -> [DriverMessages]

+ GHC.Driver.Downsweep: data DownsweepMode

+ GHC.Driver.Downsweep: data SummariseResult

+ GHC.Driver.Downsweep: downsweep :: HscEnv -> (GhcMessage -> AnyGhcDiagnostic) -> Maybe Messager -> [ModSummary] -> [ModuleName] -> Bool -> IO ([DriverMessages], ModuleGraph)

+ GHC.Driver.Downsweep: downsweepFromRootNodes :: HscEnv -> Map (UnitId, FilePath) ModSummary -> [ModuleName] -> Bool -> DownsweepMode -> [ModuleNodeInfo] -> [UnitId] -> IO ([DriverMessages], [ModuleGraphNode])

+ GHC.Driver.Downsweep: downsweepInstalledModules :: HscEnv -> [Module] -> IO ModuleGraph

+ GHC.Driver.Downsweep: downsweepInteractiveImports :: HscEnv -> InteractiveContext -> IO ModuleGraph

+ GHC.Driver.Downsweep: downsweepThunk :: HscEnv -> ModSummary -> IO ModuleGraph

+ GHC.Driver.Downsweep: instance GHC.Internal.Classes.Eq GHC.Driver.Downsweep.CodeGenEnable

+ GHC.Driver.Downsweep: instance GHC.Internal.Classes.Ord GHC.Driver.Downsweep.CodeGenEnable

+ GHC.Driver.Downsweep: instance GHC.Internal.Show.Show GHC.Driver.Downsweep.CodeGenEnable

+ GHC.Driver.Downsweep: instance GHC.Utils.Outputable.Outputable GHC.Driver.Downsweep.CodeGenEnable

+ GHC.Driver.Downsweep: instantiationNodes :: UnitId -> UnitState -> [(UnitId, InstantiatedUnit)]

+ GHC.Driver.Downsweep: summariseFile :: HscEnv -> HomeUnit -> Map (UnitId, FilePath) ModSummary -> FilePath -> Maybe Phase -> Maybe (StringBuffer, UTCTime) -> IO (Either DriverMessages ModSummary)

+ GHC.Driver.Downsweep: summariseModule :: HscEnv -> HomeUnit -> Map (UnitId, FilePath) ModSummary -> IsBootInterface -> Located ModuleName -> PkgQual -> Maybe (StringBuffer, UTCTime) -> [ModuleName] -> IO SummariseResult

+ GHC.Driver.Downsweep: summariseModuleInterface :: HscEnv -> HomeUnit -> IsBootInterface -> Located ModuleName -> PkgQual -> [ModuleName] -> IO SummariseResult

+ GHC.Driver.DynFlags: Opt_D_dump_stg_from_js_sinker :: DumpFlag

+ GHC.Driver.DynFlags: Opt_GhciBrowser :: GeneralFlag

+ GHC.Driver.DynFlags: Opt_GhciBrowserRedirectWasiConsole :: GeneralFlag

+ GHC.Driver.DynFlags: Opt_GhciDoLoadTargets :: GeneralFlag

+ GHC.Driver.DynFlags: Opt_WarnBadlyLevelledTypes :: WarningFlag

+ GHC.Driver.DynFlags: Opt_WarnDeprecatedPragmas :: WarningFlag

+ GHC.Driver.DynFlags: Opt_WarnPatternNamespaceSpecifier :: WarningFlag

+ GHC.Driver.DynFlags: Opt_WarnRuleLhsEqualities :: WarningFlag

+ GHC.Driver.DynFlags: Opt_WarnUnusableUnpackPragmas :: WarningFlag

+ GHC.Driver.DynFlags: Opt_WarnUselessSpecialisations :: WarningFlag

+ GHC.Driver.DynFlags: Opt_WriteSelfRecompFlags :: GeneralFlag

+ GHC.Driver.DynFlags: Opt_WriteSelfRecompInfo :: GeneralFlag

+ GHC.Driver.DynFlags: [ghciBrowserHost] :: DynFlags -> String

+ GHC.Driver.DynFlags: [ghciBrowserPlaywrightBrowserType] :: DynFlags -> Maybe String

+ GHC.Driver.DynFlags: [ghciBrowserPlaywrightLaunchOpts] :: DynFlags -> Maybe String

+ GHC.Driver.DynFlags: [ghciBrowserPort] :: DynFlags -> Int

+ GHC.Driver.DynFlags: [ghciBrowserPuppeteerLaunchOpts] :: DynFlags -> Maybe String

+ GHC.Driver.DynFlags: [unitSettings] :: DynFlags -> UnitSettings

+ GHC.Driver.DynFlags: baseUnitId :: DynFlags -> UnitId

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.DynLibLoader

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.DynamicTooState

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.GhcLink

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.GhcMode

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.IgnorePackageFlag

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.ModRenaming

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.PackageArg

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.PackageDBFlag

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.PackageFlag

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.PkgDbRef

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Eq GHC.Driver.DynFlags.TrustFlag

+ GHC.Driver.DynFlags: instance GHC.Internal.Classes.Ord GHC.Driver.DynFlags.DynamicTooState

+ GHC.Driver.DynFlags: isSse3Enabled :: DynFlags -> Bool

+ GHC.Driver.DynFlags: isSsse3Enabled :: DynFlags -> Bool

+ GHC.Driver.Env: hscInsertHPT :: HomeModInfo -> HscEnv -> IO ()

+ GHC.Driver.Env: hsc_mod_graph :: HscEnv -> ModuleGraph

+ GHC.Driver.Env: hugAnnsBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO AnnEnv

+ GHC.Driver.Env: hugCompleteSigsBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO CompleteMatches

+ GHC.Driver.Env: hugInstancesBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO (InstEnv, [FamInst])

+ GHC.Driver.Env: hugRulesBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO RuleBase

+ GHC.Driver.Env: lookupIfaceByModuleHsc :: HscEnv -> Module -> IO (Maybe ModIface)

+ GHC.Driver.Env: setModuleGraph :: ModuleGraph -> HscEnv -> HscEnv

+ GHC.Driver.Errors.Types: type AnyGhcDiagnostic = UnknownDiagnosticFor GhcMessage

+ GHC.Driver.Flags: Off :: a -> OnOff a

+ GHC.Driver.Flags: On :: a -> OnOff a

+ GHC.Driver.Flags: Opt_D_dump_stg_from_js_sinker :: DumpFlag

+ GHC.Driver.Flags: Opt_GhciBrowser :: GeneralFlag

+ GHC.Driver.Flags: Opt_GhciBrowserRedirectWasiConsole :: GeneralFlag

+ GHC.Driver.Flags: Opt_GhciDoLoadTargets :: GeneralFlag

+ GHC.Driver.Flags: Opt_WarnBadlyLevelledTypes :: WarningFlag

+ GHC.Driver.Flags: Opt_WarnDeprecatedPragmas :: WarningFlag

+ GHC.Driver.Flags: Opt_WarnPatternNamespaceSpecifier :: WarningFlag

+ GHC.Driver.Flags: Opt_WarnRuleLhsEqualities :: WarningFlag

+ GHC.Driver.Flags: Opt_WarnUnusableUnpackPragmas :: WarningFlag

+ GHC.Driver.Flags: Opt_WarnUselessSpecialisations :: WarningFlag

+ GHC.Driver.Flags: Opt_WriteSelfRecompFlags :: GeneralFlag

+ GHC.Driver.Flags: Opt_WriteSelfRecompInfo :: GeneralFlag

+ GHC.Driver.Flags: data OnOff a

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Eq GHC.Driver.Flags.Deprecation

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Eq GHC.Driver.Flags.DumpFlag

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Eq GHC.Driver.Flags.ExtensionDeprecation

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Eq GHC.Driver.Flags.GeneralFlag

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Eq GHC.Driver.Flags.Language

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Eq GHC.Driver.Flags.WarningFlag

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Eq GHC.Driver.Flags.WarningGroup

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Driver.Flags.OnOff a)

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Ord GHC.Driver.Flags.Deprecation

+ GHC.Driver.Flags: instance GHC.Internal.Classes.Ord GHC.Driver.Flags.WarningFlag

+ GHC.Driver.Flags: instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Driver.Flags.OnOff a)

+ GHC.Driver.Flags: instance GHC.Utils.Outputable.Outputable a => GHC.Utils.Outputable.Outputable (GHC.Driver.Flags.OnOff a)

+ GHC.Driver.IncludeSpecs: IncludeSpecs :: [String] -> [String] -> [String] -> IncludeSpecs

+ GHC.Driver.IncludeSpecs: [includePathsGlobal] :: IncludeSpecs -> [String]

+ GHC.Driver.IncludeSpecs: [includePathsQuoteImplicit] :: IncludeSpecs -> [String]

+ GHC.Driver.IncludeSpecs: [includePathsQuote] :: IncludeSpecs -> [String]

+ GHC.Driver.IncludeSpecs: addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs

+ GHC.Driver.IncludeSpecs: addImplicitQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs

+ GHC.Driver.IncludeSpecs: addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs

+ GHC.Driver.IncludeSpecs: data IncludeSpecs

+ GHC.Driver.IncludeSpecs: flattenIncludes :: IncludeSpecs -> [String]

+ GHC.Driver.IncludeSpecs: instance GHC.Internal.Show.Show GHC.Driver.IncludeSpecs.IncludeSpecs

+ GHC.Driver.Main: genModDetails :: HscEnv -> ModIface -> IO ModDetails

+ GHC.Driver.Main: loadIfaceByteCodeLazy :: HscEnv -> ModIface -> ModLocation -> TypeEnv -> IO (Maybe Linkable)

+ GHC.Driver.Make: summariseModuleInterface :: HscEnv -> HomeUnit -> IsBootInterface -> Located ModuleName -> PkgQual -> [ModuleName] -> IO SummariseResult

+ GHC.Driver.MakeAction: JSemLimit :: SemaphoreName -> WorkerLimit

+ GHC.Driver.MakeAction: MakeAction :: RunMakeM a -> MVar (Maybe a) -> MakeAction

+ GHC.Driver.MakeAction: MakeEnv :: HscEnv -> AbstractSem -> (forall a. () => Int -> ((Logger -> Logger) -> IO a) -> IO a) -> Maybe Messager -> (GhcMessage -> AnyGhcDiagnostic) -> MakeEnv

+ GHC.Driver.MakeAction: NumProcessorsLimit :: Int -> WorkerLimit

+ GHC.Driver.MakeAction: [compile_sem] :: MakeEnv -> AbstractSem

+ GHC.Driver.MakeAction: [diag_wrapper] :: MakeEnv -> GhcMessage -> AnyGhcDiagnostic

+ GHC.Driver.MakeAction: [env_messager] :: MakeEnv -> Maybe Messager

+ GHC.Driver.MakeAction: [hsc_env] :: MakeEnv -> HscEnv

+ GHC.Driver.MakeAction: [withLogger] :: MakeEnv -> forall a. () => Int -> ((Logger -> Logger) -> IO a) -> IO a

+ GHC.Driver.MakeAction: data MakeAction

+ GHC.Driver.MakeAction: data MakeEnv

+ GHC.Driver.MakeAction: data WorkerLimit

+ GHC.Driver.MakeAction: instance GHC.Internal.Classes.Eq GHC.Driver.MakeAction.WorkerLimit

+ GHC.Driver.MakeAction: mkWorkerLimit :: DynFlags -> IO WorkerLimit

+ GHC.Driver.MakeAction: runAllPipelines :: WorkerLimit -> MakeEnv -> [MakeAction] -> IO ()

+ GHC.Driver.MakeAction: runParPipelines :: WorkerLimit -> HscEnv -> (GhcMessage -> AnyGhcDiagnostic) -> Maybe Messager -> [MakeAction] -> IO ()

+ GHC.Driver.MakeAction: runPipelines :: WorkerLimit -> HscEnv -> (GhcMessage -> AnyGhcDiagnostic) -> Maybe Messager -> [MakeAction] -> IO ()

+ GHC.Driver.MakeAction: runSeqPipelines :: HscEnv -> (GhcMessage -> AnyGhcDiagnostic) -> Maybe Messager -> [MakeAction] -> IO ()

+ GHC.Driver.MakeAction: runWorkerLimit :: WorkerLimit -> (AbstractSem -> IO a) -> IO a

+ GHC.Driver.MakeAction: type RunMakeM a = ReaderT MakeEnv MaybeT IO a

+ GHC.Driver.MakeAction: withLocalTmpFS :: TmpFs -> (TmpFs -> IO a) -> IO a

+ GHC.Driver.MakeAction: withLocalTmpFSMake :: MakeEnv -> (MakeEnv -> IO a) -> IO a

+ GHC.Driver.MakeAction: withLoggerHsc :: Int -> MakeEnv -> (HscEnv -> IO a) -> IO a

+ GHC.Driver.MakeAction: withParLog :: TVar LogQueueQueue -> Int -> ((Logger -> Logger) -> IO b) -> IO b

+ GHC.Driver.MakeFile: doMkDependModuleGraph :: GhcMonad m => DynFlags -> ModuleGraph -> m ()

+ GHC.Driver.Messager: batchMsg :: Messager

+ GHC.Driver.Messager: batchMultiMsg :: Messager

+ GHC.Driver.Messager: oneShotMsg :: Logger -> RecompileRequired -> IO ()

+ GHC.Driver.Messager: showModuleIndex :: (Int, Int) -> SDoc

+ GHC.Driver.Messager: type Messager = HscEnv -> (Int, Int) -> RecompileRequired -> ModuleGraphNode -> IO ()

+ GHC.Driver.Phases: instance GHC.Internal.Classes.Eq GHC.Driver.Phases.Phase

+ GHC.Driver.Phases: isHaskellBootSuffix :: String -> Bool

+ GHC.Driver.Ppr: printForUserColoured :: DynFlags -> Handle -> NamePprCtx -> Depth -> SDoc -> IO ()

+ GHC.Driver.Session: Opt_D_dump_stg_from_js_sinker :: DumpFlag

+ GHC.Driver.Session: Opt_GhciBrowser :: GeneralFlag

+ GHC.Driver.Session: Opt_GhciBrowserRedirectWasiConsole :: GeneralFlag

+ GHC.Driver.Session: Opt_GhciDoLoadTargets :: GeneralFlag

+ GHC.Driver.Session: Opt_WarnBadlyLevelledTypes :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDeprecatedPragmas :: WarningFlag

+ GHC.Driver.Session: Opt_WarnPatternNamespaceSpecifier :: WarningFlag

+ GHC.Driver.Session: Opt_WarnRuleLhsEqualities :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusableUnpackPragmas :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUselessSpecialisations :: WarningFlag

+ GHC.Driver.Session: Opt_WriteSelfRecompFlags :: GeneralFlag

+ GHC.Driver.Session: Opt_WriteSelfRecompInfo :: GeneralFlag

+ GHC.Driver.Session: [ghciBrowserHost] :: DynFlags -> String

+ GHC.Driver.Session: [ghciBrowserPlaywrightBrowserType] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [ghciBrowserPlaywrightLaunchOpts] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [ghciBrowserPort] :: DynFlags -> Int

+ GHC.Driver.Session: [ghciBrowserPuppeteerLaunchOpts] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [sUnitSettings] :: Settings -> UnitSettings

+ GHC.Driver.Session: [unitSettings] :: DynFlags -> UnitSettings

+ GHC.Driver.Session: baseUnitId :: DynFlags -> UnitId

+ GHC.Driver.Session: isSse3Enabled :: DynFlags -> Bool

+ GHC.Driver.Session: isSse4_1Enabled :: DynFlags -> Bool

+ GHC.Driver.Session: isSsse3Enabled :: DynFlags -> Bool

+ GHC.Driver.Session: setHomeUnitId :: UnitId -> DynFlags -> DynFlags

+ GHC.Driver.Session.Inspect: ModuleInfo :: TypeEnv -> [AvailInfo] -> [ClsInst] -> Maybe ModIface -> SafeHaskellMode -> Maybe InternalModBreaks -> ModuleInfo

+ GHC.Driver.Session.Inspect: [minf_exports] :: ModuleInfo -> [AvailInfo]

+ GHC.Driver.Session.Inspect: [minf_iface] :: ModuleInfo -> Maybe ModIface

+ GHC.Driver.Session.Inspect: [minf_instances] :: ModuleInfo -> [ClsInst]

+ GHC.Driver.Session.Inspect: [minf_modBreaks] :: ModuleInfo -> Maybe InternalModBreaks

+ GHC.Driver.Session.Inspect: [minf_safe] :: ModuleInfo -> SafeHaskellMode

+ GHC.Driver.Session.Inspect: [minf_type_env] :: ModuleInfo -> TypeEnv

+ GHC.Driver.Session.Inspect: availsToGlobalRdrEnv :: HasDebugCallStack => HscEnv -> Module -> [AvailInfo] -> IfGlobalRdrEnv

+ GHC.Driver.Session.Inspect: data ModuleInfo

+ GHC.Driver.Session.Inspect: getBindings :: GhcMonad m => m [TyThing]

+ GHC.Driver.Session.Inspect: getHomeModuleInfo :: HscEnv -> Module -> IO (Maybe ModuleInfo)

+ GHC.Driver.Session.Inspect: getInsts :: GhcMonad m => m ([ClsInst], [FamInst])

+ GHC.Driver.Session.Inspect: getModuleGraph :: GhcMonad m => m ModuleGraph

+ GHC.Driver.Session.Inspect: getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo)

+ GHC.Driver.Session.Inspect: getNamePprCtx :: GhcMonad m => m NamePprCtx

+ GHC.Driver.Session.Inspect: getPackageModuleInfo :: HscEnv -> Module -> IO (Maybe ModuleInfo)

+ GHC.Driver.Session.Inspect: isLoaded :: GhcMonad m => ModuleName -> m Bool

+ GHC.Driver.Session.Inspect: isLoadedHomeModule :: GhcMonad m => Module -> m Bool

+ GHC.Driver.Session.Inspect: isLoadedModule :: GhcMonad m => UnitId -> ModuleName -> m Bool

+ GHC.Driver.Session.Inspect: mkNamePprCtxForModule :: GhcMonad m => Module -> ModuleInfo -> m NamePprCtx

+ GHC.Driver.Session.Inspect: modInfoExports :: ModuleInfo -> [Name]

+ GHC.Driver.Session.Inspect: modInfoExportsWithSelectors :: ModuleInfo -> [Name]

+ GHC.Driver.Session.Inspect: modInfoIface :: ModuleInfo -> Maybe ModIface

+ GHC.Driver.Session.Inspect: modInfoInstances :: ModuleInfo -> [ClsInst]

+ GHC.Driver.Session.Inspect: modInfoIsExportedName :: ModuleInfo -> Name -> Bool

+ GHC.Driver.Session.Inspect: modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing)

+ GHC.Driver.Session.Inspect: modInfoModBreaks :: ModuleInfo -> Maybe InternalModBreaks

+ GHC.Driver.Session.Inspect: modInfoSafe :: ModuleInfo -> SafeHaskellMode

+ GHC.Driver.Session.Inspect: modInfoTyThings :: ModuleInfo -> [TyThing]

+ GHC.Driver.Session.Units: initMake :: [(String, Maybe Phase)] -> Ghc [(String, Maybe Phase)]

+ GHC.Driver.Session.Units: initMulti :: NonEmpty String -> (DynFlags -> [(String, Maybe Phase)] -> [String] -> [String] -> IO ()) -> Ghc [(String, Maybe UnitId, Maybe Phase)]

+ GHC.Hs: instance GHC.Internal.Classes.Eq GHC.Hs.AnnsModule

+ GHC.Hs.Binds: HsRuleBndrsAnn :: Maybe (TokForall, EpToken ".") -> Maybe (TokForall, EpToken ".") -> HsRuleBndrsAnn

+ GHC.Hs.Binds: SpecPragE :: Name -> Id -> InlinePragma -> [Var] -> LHsExpr GhcTc -> TcSpecPrag

+ GHC.Hs.Binds: [rb_tmanns] :: HsRuleBndrsAnn -> Maybe (TokForall, EpToken ".")

+ GHC.Hs.Binds: [rb_tyanns] :: HsRuleBndrsAnn -> Maybe (TokForall, EpToken ".")

+ GHC.Hs.Binds: [spe_bndrs] :: TcSpecPrag -> [Var]

+ GHC.Hs.Binds: [spe_call] :: TcSpecPrag -> LHsExpr GhcTc

+ GHC.Hs.Binds: [spe_fn_id] :: TcSpecPrag -> Id

+ GHC.Hs.Binds: [spe_fn_nm] :: TcSpecPrag -> Name

+ GHC.Hs.Binds: [spe_inl] :: TcSpecPrag -> InlinePragma

+ GHC.Hs.Binds: data HsRuleBndrsAnn

+ GHC.Hs.Binds: instance GHC.Hs.Extension.OutputableBndrId p => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Binds.RuleBndr (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Binds: instance GHC.Hs.Extension.OutputableBndrId p => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Binds.RuleBndrs (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Binds: instance GHC.Internal.Classes.Eq GHC.Hs.Binds.ActivationAnn

+ GHC.Hs.Binds: instance GHC.Internal.Classes.Eq GHC.Hs.Binds.HsRuleBndrsAnn

+ GHC.Hs.Binds: instance GHC.Internal.Classes.Eq GHC.Hs.Binds.NamespaceSpecifier

+ GHC.Hs.Binds: instance GHC.Internal.Data.Data.Data GHC.Hs.Binds.HsRuleBndrsAnn

+ GHC.Hs.Binds: instance GHC.Parser.Annotation.NoAnn GHC.Hs.Binds.HsRuleBndrsAnn

+ GHC.Hs.Binds: instance GHC.Utils.Outputable.Outputable (GHC.Hs.Extension.XRecGhc (GHC.Hs.Extension.IdGhcP p)) => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Binds.RecordPatSynField (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Decls: [con_inner_bndrs] :: ConDecl pass -> [HsForAllTelescope pass]

+ GHC.Hs.Decls: [con_outer_bndrs] :: ConDecl pass -> XRec pass (HsOuterSigTyVarBndrs pass)

+ GHC.Hs.Decls: [rd_bndrs] :: RuleDecl pass -> RuleBndrs pass

+ GHC.Hs.Decls: instance GHC.Internal.Classes.Eq GHC.Hs.Decls.HsRuleAnn

+ GHC.Hs.Decls: tyClDeclFlavour :: forall (p :: Pass) tc. TyClDecl (GhcPass p) -> TyConFlavour tc

+ GHC.Hs.Doc: instance (GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.IdP pass), GHC.Internal.Classes.Eq a) => GHC.Internal.Classes.Eq (GHC.Hs.Doc.WithHsDocIdentifiers a pass)

+ GHC.Hs.DocString: instance GHC.Internal.Classes.Eq GHC.Hs.DocString.HsDocString

+ GHC.Hs.DocString: instance GHC.Internal.Classes.Eq GHC.Hs.DocString.HsDocStringChunk

+ GHC.Hs.DocString: instance GHC.Internal.Classes.Eq GHC.Hs.DocString.HsDocStringDecorator

+ GHC.Hs.DocString: instance GHC.Internal.Classes.Ord GHC.Hs.DocString.HsDocStringChunk

+ GHC.Hs.DocString: instance GHC.Internal.Classes.Ord GHC.Hs.DocString.HsDocStringDecorator

+ GHC.Hs.Dump: instance GHC.Internal.Classes.Eq GHC.Hs.Dump.BlankEpAnnotations

+ GHC.Hs.Dump: instance GHC.Internal.Classes.Eq GHC.Hs.Dump.BlankSrcSpan

+ GHC.Hs.Expr: HoleError :: HoleKind

+ GHC.Hs.Expr: HoleVar :: LIdP GhcPs -> HoleKind

+ GHC.Hs.Expr: HsImplicitLiftSplice :: Set ThLevelIndex -> ThLevelIndex -> Maybe GlobalRdrElt -> LIdOccP GhcRn -> HsImplicitLiftSplice

+ GHC.Hs.Expr: HsQuasiQuoteExt :: UntypedSpliceFlavour -> HsQuasiQuoteExt

+ GHC.Hs.Expr: HsTypedSpliceNested :: SplicePointName -> HsTypedSpliceResult

+ GHC.Hs.Expr: HsTypedSpliceTop :: HsTypedSpliceResult

+ GHC.Hs.Expr: HsUserSpliceExt :: UntypedSpliceFlavour -> HsUserSpliceExt

+ GHC.Hs.Expr: [implicit_lift_bind_lvl] :: HsImplicitLiftSplice -> Set ThLevelIndex

+ GHC.Hs.Expr: [implicit_lift_gre] :: HsImplicitLiftSplice -> Maybe GlobalRdrElt

+ GHC.Hs.Expr: [implicit_lift_lid] :: HsImplicitLiftSplice -> LIdOccP GhcRn

+ GHC.Hs.Expr: [implicit_lift_used_lvl] :: HsImplicitLiftSplice -> ThLevelIndex

+ GHC.Hs.Expr: [quasi_quote_flavour] :: HsQuasiQuoteExt -> UntypedSpliceFlavour

+ GHC.Hs.Expr: [user_splice_flavour] :: HsUserSpliceExt -> UntypedSpliceFlavour

+ GHC.Hs.Expr: data HoleKind

+ GHC.Hs.Expr: data HsImplicitLiftSplice

+ GHC.Hs.Expr: data HsQuasiQuoteExt

+ GHC.Hs.Expr: data HsTypedSpliceResult

+ GHC.Hs.Expr: data HsUserSpliceExt

+ GHC.Hs.Expr: instance (GHC.Hs.Extension.OutputableBndrId pl, GHC.Hs.Extension.OutputableBndrId pr, Language.Haskell.Syntax.Extension.Anno (Language.Haskell.Syntax.Expr.StmtLR (GHC.Hs.Extension.GhcPass pl) (GHC.Hs.Extension.GhcPass pr) body) GHC.Internal.Types.~ GHC.Parser.Annotation.SrcSpanAnnA, GHC.Utils.Outputable.Outputable body) => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Expr.StmtLR (GHC.Hs.Extension.GhcPass pl) (GHC.Hs.Extension.GhcPass pr) body)

+ GHC.Hs.Expr: instance GHC.Internal.Data.Data.Data GHC.Hs.Expr.HoleKind

+ GHC.Hs.Expr: isInfixMatch :: forall (p :: Pass) body. Match (GhcPass p) body -> Bool

+ GHC.Hs.Expr: mkHsVar :: forall (p :: Pass). IsPass p => LIdP (GhcPass p) -> HsExpr (GhcPass p)

+ GHC.Hs.Expr: mkHsVarWithUserRdr :: forall (p :: Pass). IsPass p => RdrName -> LIdP (GhcPass p) -> HsExpr (GhcPass p)

+ GHC.Hs.Expr: multAnnToHsExpr :: HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> Maybe (LocatedA (HsExpr GhcRn))

+ GHC.Hs.Expr: unnamedHoleRdrName :: RdrName

+ GHC.Hs.Extension: type LIdGhcP (p :: Pass) = XRecGhc IdGhcP p

+ GHC.Hs.Extension: type LIdOccGhcP (p :: Pass) = XRecGhc IdOccGhcP p

+ GHC.Hs.Extension: type XRecGhc a = GenLocated Anno a a

+ GHC.Hs.ImpExp: EpAnnLevelQuote :: EpToken "quote" -> EpAnnLevel

+ GHC.Hs.ImpExp: EpAnnLevelSplice :: EpToken "splice" -> EpAnnLevel

+ GHC.Hs.ImpExp: [importDeclAnnLevel] :: EpAnnImportDecl -> Maybe EpAnnLevel

+ GHC.Hs.ImpExp: data EpAnnLevel

+ GHC.Hs.ImpExp: ieLIEWrappedName :: forall (p :: Pass). IE (GhcPass p) -> LIEWrappedName (GhcPass p)

+ GHC.Hs.ImpExp: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.ImpExp.IEWrappedName GHC.Hs.Extension.GhcPs)

+ GHC.Hs.ImpExp: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.ImpExp.IEWrappedName GHC.Hs.Extension.GhcRn)

+ GHC.Hs.ImpExp: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.ImpExp.IEWrappedName GHC.Hs.Extension.GhcTc)

+ GHC.Hs.ImpExp: instance GHC.Internal.Data.Data.Data GHC.Hs.ImpExp.EpAnnLevel

+ GHC.Hs.ImpExp: instance GHC.Parser.Annotation.HasLoc GHC.Hs.ImpExp.EpAnnLevel

+ GHC.Hs.Instances: instance (GHC.Internal.Data.Typeable.Internal.Typeable p, GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Extension.Anno (GHC.Hs.Extension.IdGhcP p)), GHC.Internal.Data.Data.Data (GHC.Hs.Extension.IdGhcP p)) => GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.BooleanFormula.BooleanFormula (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Instances: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.ImpExp.IE GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Instances: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.ImpExp.IE GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Instances: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.ImpExp.IE GHC.Hs.Extension.GhcTc)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Binds.RuleBndr GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Binds.RuleBndr GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Binds.RuleBndr GHC.Hs.Extension.GhcTc)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Binds.RuleBndrs GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Binds.RuleBndrs GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Binds.RuleBndrs GHC.Hs.Extension.GhcTc)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Expr.HsTypedSplice GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Expr.HsTypedSplice GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Expr.HsTypedSplice GHC.Hs.Extension.GhcTc)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsConDeclField GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsConDeclField GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsConDeclField GHC.Hs.Extension.GhcTc)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsConDeclRecField GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsConDeclRecField GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsConDeclRecField GHC.Hs.Extension.GhcTc)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsMultAnnOf (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs)) GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsMultAnnOf (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcRn)) GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsMultAnnOf (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcTc)) GHC.Hs.Extension.GhcTc)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsMultAnnOf (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.HsType GHC.Hs.Extension.GhcPs)) GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsMultAnnOf (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.HsType GHC.Hs.Extension.GhcRn)) GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsMultAnnOf (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.HsType GHC.Hs.Extension.GhcRn)) GHC.Hs.Extension.GhcTc)

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data GHC.Hs.Binds.TcSpecPrag

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data GHC.Hs.Binds.TcSpecPrags

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data GHC.Hs.Expr.HsImplicitLiftSplice

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data GHC.Hs.Expr.HsQuasiQuoteExt

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data GHC.Hs.Expr.HsTypedSpliceResult

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data GHC.Hs.Expr.HsUserSpliceExt

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data GHC.Hs.Lit.HsLitTc

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data GHC.Hs.Type.HsTypeGhcPsExt

+ GHC.Hs.Instances: instance GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Types.Name.Reader.WithUserRdr a)

+ GHC.Hs.Lit: HsInteger :: SourceText -> Integer -> Type -> HsLitTc

+ GHC.Hs.Lit: HsRat :: FractionalLit -> Type -> HsLitTc

+ GHC.Hs.Lit: data HsLitTc

+ GHC.Hs.Lit: instance GHC.Hs.Extension.IsPass p => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Lit.HsLit (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Lit: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.XXOverLit p) => GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Lit.HsOverLit p)

+ GHC.Hs.Lit: instance GHC.Internal.Classes.Eq GHC.Hs.Lit.HsLitTc

+ GHC.Hs.Lit: instance GHC.Internal.Classes.Ord (Language.Haskell.Syntax.Extension.XXOverLit p) => GHC.Internal.Classes.Ord (Language.Haskell.Syntax.Lit.HsOverLit p)

+ GHC.Hs.Pat: instance (GHC.Utils.Outputable.Outputable arg, GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Extension.XRec p (Language.Haskell.Syntax.Pat.HsRecField p arg)), Language.Haskell.Syntax.Extension.XRec p Language.Haskell.Syntax.Pat.RecFieldsDotDot GHC.Internal.Types.~ GHC.Parser.Annotation.LocatedE Language.Haskell.Syntax.Pat.RecFieldsDotDot) => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Pat.HsRecFields p arg)

+ GHC.Hs.Pat: isInvisArgLPat :: UnXRec p => LPat p -> Bool

+ GHC.Hs.Pat: isVisArgLPat :: UnXRec p => LPat p -> Bool

+ GHC.Hs.Type: CDF :: XConDeclField pass -> SrcUnpackedness -> SrcStrictness -> HsMultAnn pass -> LHsType pass -> Maybe (LHsDoc pass) -> HsConDeclField pass

+ GHC.Hs.Type: EpArrow :: TokRarrow -> EpArrowOrColon

+ GHC.Hs.Type: EpColon :: TokDcolon -> EpArrowOrColon

+ GHC.Hs.Type: EpPatBind :: EpArrowOrColon

+ GHC.Hs.Type: HsConDeclRecField :: XConDeclRecField pass -> [LFieldOcc pass] -> HsConDeclField pass -> HsConDeclRecField pass

+ GHC.Hs.Type: HsCoreTy :: HsCoreTy -> HsTypeGhcPsExt

+ GHC.Hs.Type: HsLinearAnn :: XLinearAnn mult pass -> HsMultAnnOf mult pass

+ GHC.Hs.Type: HsUnannotated :: XUnannotated mult pass -> HsMultAnnOf mult pass

+ GHC.Hs.Type: XConDeclRecField :: XXConDeclRecField pass -> HsConDeclRecField pass

+ GHC.Hs.Type: XMultAnnOf :: XXMultAnnOf mult pass -> HsMultAnnOf mult pass

+ GHC.Hs.Type: [cdf_bang] :: HsConDeclField pass -> SrcStrictness

+ GHC.Hs.Type: [cdf_doc] :: HsConDeclField pass -> Maybe (LHsDoc pass)

+ GHC.Hs.Type: [cdf_ext] :: HsConDeclField pass -> XConDeclField pass

+ GHC.Hs.Type: [cdf_multiplicity] :: HsConDeclField pass -> HsMultAnn pass

+ GHC.Hs.Type: [cdf_type] :: HsConDeclField pass -> LHsType pass

+ GHC.Hs.Type: [cdf_unpack] :: HsConDeclField pass -> SrcUnpackedness

+ GHC.Hs.Type: [cdrf_ext] :: HsConDeclRecField pass -> XConDeclRecField pass

+ GHC.Hs.Type: [cdrf_names] :: HsConDeclRecField pass -> [LFieldOcc pass]

+ GHC.Hs.Type: [cdrf_spec] :: HsConDeclRecField pass -> HsConDeclField pass

+ GHC.Hs.Type: data EpArrowOrColon

+ GHC.Hs.Type: data EpLinear

+ GHC.Hs.Type: data HsConDeclField pass

+ GHC.Hs.Type: data HsConDeclRecField pass

+ GHC.Hs.Type: data HsMultAnnOf mult pass

+ GHC.Hs.Type: data HsTypeGhcPsExt

+ GHC.Hs.Type: expandHsMultAnnOf :: (LocatedN Name -> t GhcRn) -> HsMultAnnOf (LocatedA (t GhcRn)) GhcRn -> Maybe (LocatedA (t GhcRn))

+ GHC.Hs.Type: hsForAllTelescopeBndrs :: forall (p :: Pass). HsForAllTelescope (GhcPass p) -> [LHsTyVarBndr ForAllTyFlag (GhcPass p)]

+ GHC.Hs.Type: hsPlainTypeField :: LHsType GhcPs -> HsConDeclField GhcPs

+ GHC.Hs.Type: instance (GHC.Utils.Outputable.Outputable arg, GHC.Utils.Outputable.Outputable rec) => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Type.HsConDetails arg rec)

+ GHC.Hs.Type: instance (GHC.Utils.Outputable.Outputable mult, GHC.Hs.Extension.OutputableBndrId pass) => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Type.HsMultAnnOf mult (GHC.Hs.Extension.GhcPass pass))

+ GHC.Hs.Type: instance GHC.Hs.Extension.OutputableBndrId p => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Type.HsConDeclRecField (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Type: instance GHC.Hs.Type.OutputableBndrFlag Language.Haskell.Syntax.Specificity.ForAllTyFlag p

+ GHC.Hs.Type: instance GHC.Internal.Data.Data.Data GHC.Hs.Type.EpArrowOrColon

+ GHC.Hs.Type: instance GHC.Internal.Data.Data.Data GHC.Hs.Type.EpLinear

+ GHC.Hs.Type: instance GHC.Parser.Annotation.NoAnn GHC.Hs.Type.EpLinear

+ GHC.Hs.Type: instance GHC.Utils.Outputable.Outputable (GHC.Hs.Extension.XRecGhc (GHC.Hs.Extension.IdGhcP p)) => GHC.Utils.Outputable.Outputable (Language.Haskell.Syntax.Type.FieldOcc (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Type: mkConDeclField :: HsMultAnn GhcPs -> LHsType GhcPs -> HsConDeclField GhcPs

+ GHC.Hs.Type: multAnnToHsType :: HsMultAnn GhcRn -> Maybe (LHsType GhcRn)

+ GHC.Hs.Type: pprHsConDeclFieldNoMult :: forall (p :: Pass). OutputableBndrId p => HsConDeclField (GhcPass p) -> SDoc

+ GHC.Hs.Type: pprHsConDeclFieldWith :: forall (p :: Pass). OutputableBndrId p => (HsMultAnn (GhcPass p) -> SDoc -> SDoc) -> HsConDeclField (GhcPass p) -> SDoc

+ GHC.Hs.Type: pprHsConDeclRecFields :: forall (p :: Pass). OutputableBndrId p => [LHsConDeclRecField (GhcPass p)] -> SDoc

+ GHC.Hs.Type: pprHsForAllTelescope :: forall (p :: Pass). OutputableBndrId p => HsForAllTelescope (GhcPass p) -> SDoc

+ GHC.Hs.Type: pprHsMultAnn :: forall (id :: Pass). OutputableBndrId id => HsMultAnn (GhcPass id) -> SDoc

+ GHC.Hs.Type: type HsMultAnn pass = HsMultAnnOf LHsType NoGhcTc pass pass

+ GHC.Hs.Type: type LHsConDeclRecField pass = XRec pass HsConDeclRecField pass

+ GHC.Hs.Utils: forgetUserRdr :: forall (p :: Pass). IsPass p => IdOccP (GhcPass p) -> IdP (GhcPass p)

+ GHC.Hs.Utils: noUserRdr :: Name -> WithUserRdr Name

+ GHC.HsToCore.Binds: dsImpSpecs :: [LTcSpecPrag] -> DsM (OrdList (Id, CoreExpr), [CoreRule])

+ GHC.HsToCore.Breakpoints: BreakpointId :: Module -> BreakTickIndex -> BreakpointId

+ GHC.HsToCore.Breakpoints: ModBreaks :: Array BreakTickIndex SrcSpan -> Array BreakTickIndex [OccName] -> Array BreakTickIndex [String] -> Array BreakTickIndex (String, String) -> Module -> ModBreaks

+ GHC.HsToCore.Breakpoints: [bi_tick_index] :: BreakpointId -> BreakTickIndex

+ GHC.HsToCore.Breakpoints: [bi_tick_mod] :: BreakpointId -> Module

+ GHC.HsToCore.Breakpoints: [modBreaks_ccs] :: ModBreaks -> Array BreakTickIndex (String, String)

+ GHC.HsToCore.Breakpoints: [modBreaks_decls] :: ModBreaks -> Array BreakTickIndex [String]

+ GHC.HsToCore.Breakpoints: [modBreaks_locs] :: ModBreaks -> Array BreakTickIndex SrcSpan

+ GHC.HsToCore.Breakpoints: [modBreaks_module] :: ModBreaks -> Module

+ GHC.HsToCore.Breakpoints: [modBreaks_vars] :: ModBreaks -> Array BreakTickIndex [OccName]

+ GHC.HsToCore.Breakpoints: data BreakpointId

+ GHC.HsToCore.Breakpoints: data ModBreaks

+ GHC.HsToCore.Breakpoints: type BreakTickIndex = Int

+ GHC.HsToCore.Errors.Types: DsUselessSpecialisePragma :: Name -> Bool -> UselessSpecialisePragmaReason -> DsMessage

+ GHC.HsToCore.Errors.Types: ThDataConVisibleForall :: ThRejectionReason

+ GHC.HsToCore.Errors.Types: UselessSpecialiseForClassMethodSelector :: UselessSpecialisePragmaReason

+ GHC.HsToCore.Errors.Types: UselessSpecialiseForNoInlineFunction :: UselessSpecialisePragmaReason

+ GHC.HsToCore.Errors.Types: UselessSpecialiseNoSpecialisation :: UselessSpecialisePragmaReason

+ GHC.HsToCore.Errors.Types: data UselessSpecialisePragmaReason

+ GHC.HsToCore.Errors.Types: instance GHC.Internal.Generics.Generic GHC.HsToCore.Errors.Types.UselessSpecialisePragmaReason

+ GHC.HsToCore.Errors.Types: uselessSpecialisePragmaKeepAnyway :: UselessSpecialisePragmaReason -> Bool

+ GHC.HsToCore.Foreign.Wasm: instance GHC.Internal.Classes.Eq GHC.HsToCore.Foreign.Wasm.Synchronicity

+ GHC.HsToCore.Match.Literal: numericConversionNames :: [Name]

+ GHC.HsToCore.Monad: dsGetGlobalRdrEnv :: DsM GlobalRdrEnv

+ GHC.HsToCore.Monad: infixl 4 <$>

+ GHC.HsToCore.Monad: zapUnspecables :: DsM a -> DsM a

+ GHC.HsToCore.Pmc: instance GHC.Internal.Classes.Eq (GHC.HsToCore.Pmc.FormatReportWarningsMode ann)

+ GHC.HsToCore.Pmc.Solver: instance GHC.Internal.Classes.Eq GHC.HsToCore.Pmc.Solver.GenerateInhabitingPatternsMode

+ GHC.HsToCore.Pmc.Solver.Types: instance GHC.Internal.Classes.Eq GHC.HsToCore.Pmc.Solver.Types.BotInfo

+ GHC.HsToCore.Pmc.Solver.Types: instance GHC.Internal.Classes.Eq GHC.HsToCore.Pmc.Solver.Types.PmAltCon

+ GHC.HsToCore.Pmc.Solver.Types: instance GHC.Internal.Classes.Eq GHC.HsToCore.Pmc.Solver.Types.PmEquality

+ GHC.HsToCore.Pmc.Solver.Types: instance GHC.Internal.Classes.Eq GHC.HsToCore.Pmc.Solver.Types.PmLit

+ GHC.HsToCore.Pmc.Types: instance GHC.Internal.Classes.Eq GHC.HsToCore.Pmc.Types.Precision

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectBinders (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Pat.Pat GHC.Hs.Extension.GhcTc))

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectBinders (Language.Haskell.Syntax.Binds.HsLocalBinds GHC.Hs.Extension.GhcTc)

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectBinders [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.Stmt GHC.Hs.Extension.GhcTc (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsCmd GHC.Hs.Extension.GhcTc)))]

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectBinders [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.Stmt GHC.Hs.Extension.GhcTc (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcTc)))]

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectBinders [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Pat.Pat GHC.Hs.Extension.GhcTc)]

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders (GHC.Hs.Expr.ApplicativeArg GHC.Hs.Extension.GhcTc)

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders (Language.Haskell.Syntax.Binds.HsBind GHC.Hs.Extension.GhcTc)

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders (Language.Haskell.Syntax.Binds.HsLocalBinds GHC.Hs.Extension.GhcTc)

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders (Language.Haskell.Syntax.Binds.HsValBinds GHC.Hs.Extension.GhcTc)

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders (Language.Haskell.Syntax.Expr.Stmt GHC.Hs.Extension.GhcTc e)

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders (Language.Haskell.Syntax.Pat.Pat GHC.Hs.Extension.GhcTc)

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders GHC.Hs.Pat.XXPatGhcTc

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders a => GHC.HsToCore.Ticks.CollectFldBinders [a]

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders e => GHC.HsToCore.Ticks.CollectFldBinders (GHC.Types.SrcLoc.GenLocated l e)

+ GHC.HsToCore.Ticks: instance GHC.HsToCore.Ticks.CollectFldBinders r => GHC.HsToCore.Ticks.CollectFldBinders (Language.Haskell.Syntax.Pat.HsFieldBind l r)

+ GHC.HsToCore.Ticks: instance GHC.Internal.Classes.Eq GHC.HsToCore.Ticks.TickDensity

+ GHC.HsToCore.Ticks: instance GHC.Internal.Classes.Eq GHC.HsToCore.Ticks.TickishType

+ GHC.Iface.Binary: instance GHC.Internal.Classes.Eq GHC.Iface.Binary.CheckHiWay

+ GHC.Iface.Binary: instance GHC.Internal.Classes.Eq GHC.Iface.Binary.CompressionIFace

+ GHC.Iface.Binary: instance GHC.Internal.Classes.Ord GHC.Iface.Binary.CompressionIFace

+ GHC.Iface.Env: trace_hi_diffs_io :: Logger -> IO SDoc -> IO ()

+ GHC.Iface.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Errors.Types.BuildingCabalPackage

+ GHC.Iface.Ext.Ast: instance (GHC.Iface.Ext.Ast.HiePass p, GHC.Internal.Data.Data.Data (GHC.Hs.Extension.IdGhcP p)) => GHC.Iface.Ext.Ast.ToHie (GHC.Types.SrcLoc.GenLocated GHC.Parser.Annotation.SrcSpanAnnL (Language.Haskell.Syntax.BooleanFormula.BooleanFormula (GHC.Hs.Extension.GhcPass p)))

+ GHC.Iface.Ext.Ast: instance (GHC.Iface.Ext.Ast.ToHie arg, GHC.Iface.Ext.Ast.ToHie rec) => GHC.Iface.Ext.Ast.ToHie (Language.Haskell.Syntax.Type.HsConDetails arg rec)

+ GHC.Iface.Ext.Ast: instance GHC.Iface.Ext.Ast.HiePass p => GHC.Iface.Ext.Ast.ToHie (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsTypedSplice (GHC.Hs.Extension.GhcPass p)))

+ GHC.Iface.Ext.Ast: instance GHC.Iface.Ext.Ast.HiePass pass => GHC.Iface.Ext.Ast.ToHie (Language.Haskell.Syntax.Expr.HsUntypedSplice (GHC.Hs.Extension.GhcPass pass))

+ GHC.Iface.Ext.Ast: instance GHC.Iface.Ext.Ast.ToHie (GHC.Iface.Ext.Ast.Context (GHC.Types.SrcLoc.Located (GHC.Types.Name.Reader.WithUserRdr GHC.Types.Name.Name)))

+ GHC.Iface.Ext.Ast: instance GHC.Iface.Ext.Ast.ToHie (GHC.Iface.Ext.Ast.RScoped (GHC.Parser.Annotation.LocatedAn GHC.Parser.Annotation.NoEpAnns (Language.Haskell.Syntax.Binds.RuleBndr GHC.Hs.Extension.GhcRn)))

+ GHC.Iface.Ext.Ast: instance GHC.Iface.Ext.Ast.ToHie (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.HsConDeclRecField GHC.Hs.Extension.GhcRn))

+ GHC.Iface.Ext.Ast: instance GHC.Iface.Ext.Ast.ToHie (GHC.Parser.Annotation.LocatedL [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.HsConDeclRecField GHC.Hs.Extension.GhcRn)])

+ GHC.Iface.Ext.Ast: instance GHC.Iface.Ext.Ast.ToHie (Language.Haskell.Syntax.Type.HsConDeclField GHC.Hs.Extension.GhcRn)

+ GHC.Iface.Ext.Ast: instance GHC.Iface.Ext.Ast.ToHie a => GHC.Iface.Ext.Ast.ToHie (GHC.Types.Name.Reader.WithUserRdr a)

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.BindType

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.ContextInfo

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.DeclType

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.EntityInfo

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.EvBindDeps

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.EvVarSource

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.HieName

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.HieTypeFix

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.IEType

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.NodeAnnotation

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.NodeOrigin

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.RecFieldContext

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.Scope

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq GHC.Iface.Ext.Types.TyVarScope

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Iface.Ext.Types.HieArgs a)

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Iface.Ext.Types.HieType a)

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Iface.Ext.Types.IdentifierDetails a)

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.BindType

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.ContextInfo

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.DeclType

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.EntityInfo

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.EvBindDeps

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.EvVarSource

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.HieName

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.IEType

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.NodeAnnotation

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.NodeOrigin

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.RecFieldContext

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.Scope

+ GHC.Iface.Ext.Types: instance GHC.Internal.Classes.Ord GHC.Iface.Ext.Types.TyVarScope

+ GHC.Iface.Ext.Utils: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Iface.Ext.Utils.EvidenceInfo a)

+ GHC.Iface.Ext.Utils: instance GHC.Internal.Classes.Ord a => GHC.Internal.Classes.Ord (GHC.Iface.Ext.Utils.EvidenceInfo a)

+ GHC.Iface.Flags: IfaceCppOptions :: [FilePath] -> [String] -> ([String], Fingerprint) -> IfaceCppOptions

+ GHC.Iface.Flags: IfaceDynFlags :: Maybe (Maybe String) -> IfaceTrustInfo -> Maybe IfaceLanguage -> [IfaceExtension] -> IfaceCppOptions -> IfaceCppOptions -> IfaceCppOptions -> [String] -> Maybe IfaceProfAuto -> [IfaceGeneralFlag] -> [IfaceGeneralFlag] -> Bool -> Int -> [CallerCcFilter] -> IfaceDynFlags

+ GHC.Iface.Flags: IfaceExtension :: Extension -> IfaceExtension

+ GHC.Iface.Flags: IfaceGeneralFlag :: GeneralFlag -> IfaceGeneralFlag

+ GHC.Iface.Flags: IfaceLanguage :: Language -> IfaceLanguage

+ GHC.Iface.Flags: IfaceProfAuto :: ProfAuto -> IfaceProfAuto

+ GHC.Iface.Flags: [ifaceCallerCCFilters] :: IfaceDynFlags -> [CallerCcFilter]

+ GHC.Iface.Flags: [ifaceCmmOptions] :: IfaceDynFlags -> IfaceCppOptions

+ GHC.Iface.Flags: [ifaceCodeGen] :: IfaceDynFlags -> [IfaceGeneralFlag]

+ GHC.Iface.Flags: [ifaceCppIncludes] :: IfaceCppOptions -> [FilePath]

+ GHC.Iface.Flags: [ifaceCppOptions] :: IfaceDynFlags -> IfaceCppOptions

+ GHC.Iface.Flags: [ifaceCppOpts] :: IfaceCppOptions -> [String]

+ GHC.Iface.Flags: [ifaceCppSig] :: IfaceCppOptions -> ([String], Fingerprint)

+ GHC.Iface.Flags: [ifaceDebugLevel] :: IfaceDynFlags -> Int

+ GHC.Iface.Flags: [ifaceExts] :: IfaceDynFlags -> [IfaceExtension]

+ GHC.Iface.Flags: [ifaceFatIface] :: IfaceDynFlags -> Bool

+ GHC.Iface.Flags: [ifaceJsOptions] :: IfaceDynFlags -> IfaceCppOptions

+ GHC.Iface.Flags: [ifaceLang] :: IfaceDynFlags -> Maybe IfaceLanguage

+ GHC.Iface.Flags: [ifaceMainIs] :: IfaceDynFlags -> Maybe (Maybe String)

+ GHC.Iface.Flags: [ifacePaths] :: IfaceDynFlags -> [String]

+ GHC.Iface.Flags: [ifaceProf] :: IfaceDynFlags -> Maybe IfaceProfAuto

+ GHC.Iface.Flags: [ifaceSafeMode] :: IfaceDynFlags -> IfaceTrustInfo

+ GHC.Iface.Flags: [ifaceTicky] :: IfaceDynFlags -> [IfaceGeneralFlag]

+ GHC.Iface.Flags: data IfaceCppOptions

+ GHC.Iface.Flags: data IfaceDynFlags

+ GHC.Iface.Flags: instance Control.DeepSeq.NFData GHC.Iface.Flags.IfaceCppOptions

+ GHC.Iface.Flags: instance Control.DeepSeq.NFData GHC.Iface.Flags.IfaceDynFlags

+ GHC.Iface.Flags: instance Control.DeepSeq.NFData GHC.Iface.Flags.IfaceExtension

+ GHC.Iface.Flags: instance Control.DeepSeq.NFData GHC.Iface.Flags.IfaceGeneralFlag

+ GHC.Iface.Flags: instance Control.DeepSeq.NFData GHC.Iface.Flags.IfaceLanguage

+ GHC.Iface.Flags: instance Control.DeepSeq.NFData GHC.Iface.Flags.IfaceProfAuto

+ GHC.Iface.Flags: instance GHC.Utils.Binary.Binary GHC.Iface.Flags.IfaceCppOptions

+ GHC.Iface.Flags: instance GHC.Utils.Binary.Binary GHC.Iface.Flags.IfaceDynFlags

+ GHC.Iface.Flags: instance GHC.Utils.Binary.Binary GHC.Iface.Flags.IfaceExtension

+ GHC.Iface.Flags: instance GHC.Utils.Binary.Binary GHC.Iface.Flags.IfaceGeneralFlag

+ GHC.Iface.Flags: instance GHC.Utils.Binary.Binary GHC.Iface.Flags.IfaceLanguage

+ GHC.Iface.Flags: instance GHC.Utils.Binary.Binary GHC.Iface.Flags.IfaceProfAuto

+ GHC.Iface.Flags: instance GHC.Utils.Outputable.Outputable GHC.Iface.Flags.IfaceCppOptions

+ GHC.Iface.Flags: instance GHC.Utils.Outputable.Outputable GHC.Iface.Flags.IfaceExtension

+ GHC.Iface.Flags: instance GHC.Utils.Outputable.Outputable GHC.Iface.Flags.IfaceGeneralFlag

+ GHC.Iface.Flags: instance GHC.Utils.Outputable.Outputable GHC.Iface.Flags.IfaceLanguage

+ GHC.Iface.Flags: instance GHC.Utils.Outputable.Outputable GHC.Iface.Flags.IfaceProfAuto

+ GHC.Iface.Flags: missingExtraFlagInfo :: SDoc

+ GHC.Iface.Flags: newtype IfaceExtension

+ GHC.Iface.Flags: newtype IfaceGeneralFlag

+ GHC.Iface.Flags: newtype IfaceLanguage

+ GHC.Iface.Flags: newtype IfaceProfAuto

+ GHC.Iface.Flags: pprIfaceDynFlags :: IfaceDynFlags -> SDoc

+ GHC.Iface.Load: getGhcPrimIface :: Hooks -> ModIface

+ GHC.Iface.Make: mkRecompUsageInfo :: HscEnv -> TcGblEnv -> IO (Maybe [Usage])

+ GHC.Iface.Recomp: LinkFlagsChanged :: RecompReason

+ GHC.Iface.Recomp: NoSelfRecompInfo :: RecompReason

+ GHC.Iface.Recomp: instance GHC.Internal.Classes.Eq GHC.Iface.Recomp.CompileReason

+ GHC.Iface.Recomp: instance GHC.Internal.Classes.Eq GHC.Iface.Recomp.RecompReason

+ GHC.Iface.Recomp: instance GHC.Internal.Classes.Eq GHC.Iface.Recomp.RecompileRequired

+ GHC.Iface.Recomp: mkSelfRecomp :: HscEnv -> Module -> Fingerprint -> [Usage] -> IO IfaceSelfRecomp

+ GHC.Iface.Recomp.Types: IfaceDynFlags :: Maybe (Maybe String) -> IfaceTrustInfo -> Maybe IfaceLanguage -> [IfaceExtension] -> IfaceCppOptions -> IfaceCppOptions -> IfaceCppOptions -> [String] -> Maybe IfaceProfAuto -> [IfaceGeneralFlag] -> [IfaceGeneralFlag] -> Bool -> Int -> [CallerCcFilter] -> IfaceDynFlags

+ GHC.Iface.Recomp.Types: IfaceSelfRecomp :: Fingerprint -> [Usage] -> FingerprintWithValue IfaceDynFlags -> Fingerprint -> Fingerprint -> Fingerprint -> IfaceSelfRecomp

+ GHC.Iface.Recomp.Types: [ifaceCallerCCFilters] :: IfaceDynFlags -> [CallerCcFilter]

+ GHC.Iface.Recomp.Types: [ifaceCmmOptions] :: IfaceDynFlags -> IfaceCppOptions

+ GHC.Iface.Recomp.Types: [ifaceCodeGen] :: IfaceDynFlags -> [IfaceGeneralFlag]

+ GHC.Iface.Recomp.Types: [ifaceCppOptions] :: IfaceDynFlags -> IfaceCppOptions

+ GHC.Iface.Recomp.Types: [ifaceDebugLevel] :: IfaceDynFlags -> Int

+ GHC.Iface.Recomp.Types: [ifaceExts] :: IfaceDynFlags -> [IfaceExtension]

+ GHC.Iface.Recomp.Types: [ifaceFatIface] :: IfaceDynFlags -> Bool

+ GHC.Iface.Recomp.Types: [ifaceJsOptions] :: IfaceDynFlags -> IfaceCppOptions

+ GHC.Iface.Recomp.Types: [ifaceLang] :: IfaceDynFlags -> Maybe IfaceLanguage

+ GHC.Iface.Recomp.Types: [ifaceMainIs] :: IfaceDynFlags -> Maybe (Maybe String)

+ GHC.Iface.Recomp.Types: [ifacePaths] :: IfaceDynFlags -> [String]

+ GHC.Iface.Recomp.Types: [ifaceProf] :: IfaceDynFlags -> Maybe IfaceProfAuto

+ GHC.Iface.Recomp.Types: [ifaceSafeMode] :: IfaceDynFlags -> IfaceTrustInfo

+ GHC.Iface.Recomp.Types: [ifaceTicky] :: IfaceDynFlags -> [IfaceGeneralFlag]

+ GHC.Iface.Recomp.Types: [mi_sr_flag_hash] :: IfaceSelfRecomp -> FingerprintWithValue IfaceDynFlags

+ GHC.Iface.Recomp.Types: [mi_sr_hpc_hash] :: IfaceSelfRecomp -> Fingerprint

+ GHC.Iface.Recomp.Types: [mi_sr_opt_hash] :: IfaceSelfRecomp -> Fingerprint

+ GHC.Iface.Recomp.Types: [mi_sr_plugin_hash] :: IfaceSelfRecomp -> Fingerprint

+ GHC.Iface.Recomp.Types: [mi_sr_src_hash] :: IfaceSelfRecomp -> Fingerprint

+ GHC.Iface.Recomp.Types: [mi_sr_usages] :: IfaceSelfRecomp -> [Usage]

+ GHC.Iface.Recomp.Types: data IfaceDynFlags

+ GHC.Iface.Recomp.Types: data IfaceSelfRecomp

+ GHC.Iface.Recomp.Types: instance Control.DeepSeq.NFData GHC.Iface.Recomp.Types.IfaceSelfRecomp

+ GHC.Iface.Recomp.Types: instance GHC.Utils.Binary.Binary GHC.Iface.Recomp.Types.IfaceSelfRecomp

+ GHC.Iface.Recomp.Types: instance GHC.Utils.Outputable.Outputable GHC.Iface.Recomp.Types.IfaceSelfRecomp

+ GHC.Iface.Recomp.Types: missingExtraFlagInfo :: SDoc

+ GHC.Iface.Recomp.Types: pprIfaceDynFlags :: IfaceDynFlags -> SDoc

+ GHC.Iface.Syntax: [ifUnary] :: IfaceClassBody -> Bool

+ GHC.Iface.Syntax: [iil_avails] :: ImpIfaceList -> DetOrdAvails

+ GHC.Iface.Syntax: [iil_non_explicit_parents] :: ImpIfaceList -> [Name]

+ GHC.Iface.Syntax: ifImpModule :: IfaceImport -> Module

+ GHC.Iface.Syntax: instance (GHC.Internal.Classes.Eq b, GHC.Internal.Classes.Eq r) => GHC.Internal.Classes.Eq (GHC.Iface.Syntax.IfaceBindingX r b)

+ GHC.Iface.Syntax: instance (GHC.Internal.Classes.Ord b, GHC.Internal.Classes.Ord r) => GHC.Internal.Classes.Ord (GHC.Iface.Syntax.IfaceBindingX r b)

+ GHC.Iface.Syntax: instance Control.DeepSeq.NFData GHC.Iface.Syntax.IfaceLFInfo

+ GHC.Iface.Syntax: instance GHC.Internal.Classes.Eq GHC.Iface.Syntax.IfaceBooleanFormula

+ GHC.Iface.Syntax: instance GHC.Utils.Binary.Binary GHC.Iface.Syntax.IfaceImport

+ GHC.Iface.Syntax: instance GHC.Utils.Binary.Binary GHC.Iface.Syntax.ImpIfaceList

+ GHC.Iface.Syntax: type IfaceExport = AvailInfo

+ GHC.Iface.Tidy: instance GHC.Internal.Classes.Eq GHC.Iface.Tidy.UnfoldingExposure

+ GHC.Iface.Tidy: instance GHC.Internal.Classes.Ord GHC.Iface.Tidy.UnfoldingExposure

+ GHC.Iface.Type: MkPrintArityInvisibles :: Bool -> PrintArityInvisibles

+ GHC.Iface.Type: instance Control.DeepSeq.NFData (GHC.Types.Basic.DefMethSpec GHC.Iface.Type.IfaceType)

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfLclName

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceAppArgs

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceAxiomRule

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceBndr

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceCoercion

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceMCoercion

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceTyCon

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceTyConInfo

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceTyConSort

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceTyLit

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.IfaceType

+ GHC.Iface.Type: instance GHC.Internal.Classes.Eq GHC.Iface.Type.TupleOrSum

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfLclName

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceAppArgs

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceAxiomRule

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceBndr

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceCoercion

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceMCoercion

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceTyCon

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceTyConInfo

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceTyConSort

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceTyLit

+ GHC.Iface.Type: instance GHC.Internal.Classes.Ord GHC.Iface.Type.IfaceType

+ GHC.Iface.Type: newtype PrintArityInvisibles

+ GHC.Iface.Type: visibleTypeVarOccurencies :: IfaceType -> Set IfLclName

+ GHC.JS.Ident: instance GHC.Internal.Classes.Eq GHC.JS.Ident.Ident

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.JStg.Syntax.AOp

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.JStg.Syntax.JStgExpr

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.JStg.Syntax.JStgStat

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.JStg.Syntax.JVal

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.JStg.Syntax.Op

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.JStg.Syntax.UOp

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Ord GHC.JS.JStg.Syntax.AOp

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Ord GHC.JS.JStg.Syntax.Op

+ GHC.JS.JStg.Syntax: instance GHC.Internal.Classes.Ord GHC.JS.JStg.Syntax.UOp

+ GHC.JS.Make: instance (GHC.JS.Make.JVarMagic a, GHC.JS.Make.ToJExpr a) => GHC.JS.Make.JSArgument (GHC.Internal.Tuple.Solo a)

+ GHC.JS.Make: instance GHC.JS.Make.ToJExpr GHC.Internal.Bignum.Integer.Integer

+ GHC.JS.Make: instance GHC.JS.Make.ToJExpr GHC.Internal.Types.Bool

+ GHC.JS.Make: instance GHC.JS.Make.ToJExpr GHC.Internal.Types.Char

+ GHC.JS.Make: instance GHC.JS.Make.ToJExpr GHC.Internal.Types.Double

+ GHC.JS.Make: instance GHC.JS.Make.ToJExpr GHC.Internal.Types.Int

+ GHC.JS.Opt.Simple: instance GHC.Internal.Classes.Eq GHC.JS.Opt.Simple.Multiplicity

+ GHC.JS.Opt.Simple: instance GHC.Internal.Classes.Eq GHC.JS.Opt.Simple.VarDecl

+ GHC.JS.Opt.Simple: instance GHC.Internal.Classes.Ord GHC.JS.Opt.Simple.Multiplicity

+ GHC.JS.Opt.Simple: instance GHC.Internal.Classes.Ord GHC.JS.Opt.Simple.VarDecl

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.Syntax.AOp

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.Syntax.JExpr

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.Syntax.JStat

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.Syntax.JVal

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.Syntax.Op

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Eq GHC.JS.Syntax.UOp

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Ord GHC.JS.Syntax.AOp

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Ord GHC.JS.Syntax.Op

+ GHC.JS.Syntax: instance GHC.Internal.Classes.Ord GHC.JS.Syntax.UOp

+ GHC.Linker.Deps: [ldGetDependencies] :: LinkDepsOpts -> [Module] -> IO ([Module], UniqDSet UnitId)

+ GHC.Linker.Loader: [linked_breaks] :: LoaderState -> LinkedBreaks

+ GHC.Linker.Loader: allocateBreakArrays :: Interp -> ModuleEnv (ForeignRef BreakArray) -> [InternalModBreaks] -> IO (ModuleEnv (ForeignRef BreakArray))

+ GHC.Linker.Types: LinkedBreaks :: ModuleEnv (ForeignRef BreakArray) -> ModuleEnv (Array BreakTickIndex (RemotePtr CostCentre)) -> LinkedBreaks

+ GHC.Linker.Types: [breakarray_env] :: LinkedBreaks -> ModuleEnv (ForeignRef BreakArray)

+ GHC.Linker.Types: [ccs_env] :: LinkedBreaks -> ModuleEnv (Array BreakTickIndex (RemotePtr CostCentre))

+ GHC.Linker.Types: [linked_breaks] :: LoaderState -> LinkedBreaks

+ GHC.Linker.Types: data LinkedBreaks

+ GHC.Linker.Types: filterLinkedBreaks :: (Module -> Bool) -> LinkedBreaks -> LinkedBreaks

+ GHC.Llvm.MetaData: instance GHC.Internal.Classes.Eq GHC.Llvm.MetaData.MetaAnnot

+ GHC.Llvm.MetaData: instance GHC.Internal.Classes.Eq GHC.Llvm.MetaData.MetaExpr

+ GHC.Llvm.MetaData: instance GHC.Internal.Classes.Eq GHC.Llvm.MetaData.MetaId

+ GHC.Llvm.MetaData: instance GHC.Internal.Classes.Ord GHC.Llvm.MetaData.MetaId

+ GHC.Llvm.Syntax: instance GHC.Internal.Classes.Eq GHC.Llvm.Syntax.LlvmAtomicOp

+ GHC.Llvm.Syntax: instance GHC.Internal.Classes.Eq GHC.Llvm.Syntax.LlvmExpression

+ GHC.Llvm.Syntax: instance GHC.Internal.Classes.Eq GHC.Llvm.Syntax.LlvmStatement

+ GHC.Llvm.Syntax: instance GHC.Internal.Classes.Eq GHC.Llvm.Syntax.LlvmSyncOrdering

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LMConst

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmCallConvention

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmCallType

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmCastOp

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmCmpOp

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmFuncAttr

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmFunctionDecl

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmLinkageType

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmLit

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmMachOp

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmParamAttr

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmParameterListType

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmType

+ GHC.Llvm.Types: instance GHC.Internal.Classes.Eq GHC.Llvm.Types.LlvmVar

+ GHC.Parser.Annotation: getEpTokenBufSpan :: forall (tok :: Symbol). EpToken tok -> Maybe BufSpan

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq (GHC.Parser.Annotation.EpToken tok)

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq (GHC.Parser.Annotation.EpUniToken tok utok)

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.AnnListBrackets

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.AnnListItem

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.AnnPragma

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.BindTag

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.DeclTag

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.EpAnnComments

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.EpaComment

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.EpaCommentTok

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.HasE

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.IsUnicodeSyntax

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.NameAdornment

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.NameAnn

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.NoEpAnns

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq GHC.Parser.Annotation.TrailingAnn

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Parser.Annotation.AnnList a)

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq ann => GHC.Internal.Classes.Eq (GHC.Parser.Annotation.EpAnn ann)

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Eq tag => GHC.Internal.Classes.Eq (GHC.Parser.Annotation.AnnSortKey tag)

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Ord GHC.Parser.Annotation.BindTag

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Ord GHC.Parser.Annotation.DeclTag

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Ord GHC.Parser.Annotation.HasE

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Ord GHC.Parser.Annotation.IsUnicodeSyntax

+ GHC.Parser.Annotation: instance GHC.Internal.Classes.Ord GHC.Parser.Annotation.NoEpAnns

+ GHC.Parser.Annotation: instance GHC.Parser.Annotation.NoAnn GHC.Internal.Types.Bool

+ GHC.Parser.Errors.Types: PsErrSpecExprMultipleTypeAscription :: PsMessage

+ GHC.Parser.Errors.Types: PsErrSpliceOrQuoteTwice :: PsMessage

+ GHC.Parser.Errors.Types: PsWarnPatternNamespaceSpecifier :: Bool -> PsMessage

+ GHC.Parser.Errors.Types: PsWarnSpecMultipleTypeAscription :: PsMessage

+ GHC.Parser.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Parser.Errors.Types.LexErr

+ GHC.Parser.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Parser.Errors.Types.LexErrKind

+ GHC.Parser.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Parser.Errors.Types.NumUnderscoreReason

+ GHC.Parser.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Parser.Errors.Types.ParseContext

+ GHC.Parser.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Parser.Errors.Types.PatIncompleteDoBlock

+ GHC.Parser.Errors.Types: instance GHC.Internal.Classes.Ord GHC.Parser.Errors.Types.LexErr

+ GHC.Parser.Errors.Types: instance GHC.Internal.Classes.Ord GHC.Parser.Errors.Types.LexErrKind

+ GHC.Parser.Errors.Types: instance GHC.Internal.Classes.Ord GHC.Parser.Errors.Types.NumUnderscoreReason

+ GHC.Parser.Lexer: ITquote :: Token

+ GHC.Parser.Lexer: ITsplice :: Token

+ GHC.Parser.Lexer: LevelImportsBit :: ExtBits

+ GHC.Parser.PostProcess: failSpliceOrQuoteTwice :: EpAnnLevel -> P ()

+ GHC.Parser.PostProcess: mkConDeclField :: HsMultAnn GhcPs -> LHsType GhcPs -> HsConDeclField GhcPs

+ GHC.Parser.PostProcess: mkDataImpExp :: EpToken "data" -> LocatedN RdrName -> P ImpExpQcSpec

+ GHC.Parser.PostProcess: mkMultField :: EpToken "%" -> LHsType GhcPs -> TokDcolon -> LHsType GhcPs -> HsConDeclField GhcPs

+ GHC.Parser.PostProcess: mkPlainImpExp :: LocatedN RdrName -> ImpExpQcSpec

+ GHC.Parser.PostProcess: mkSpecSig :: InlinePragma -> AnnSpecSig -> Maybe (RuleBndrs GhcPs) -> LHsExpr GhcPs -> Maybe (Located (TokDcolon, OrdList (LHsSigType GhcPs))) -> P (Sig GhcPs)

+ GHC.Parser.PostProcess: ruleBndrsOrDef :: Maybe (RuleBndrs GhcPs) -> RuleBndrs GhcPs

+ GHC.Parser.PostProcess: warnPatternNamespaceSpecifier :: MonadP m => SrcSpan -> m ()

+ GHC.Parser.PostProcess.Haddock: instance GHC.Parser.PostProcess.Haddock.HasHaddock (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.HsConDeclRecField GHC.Hs.Extension.GhcPs))

+ GHC.Parser.PostProcess.Haddock: instance GHC.Parser.PostProcess.Haddock.HasHaddock (Language.Haskell.Syntax.Type.HsConDeclField GHC.Hs.Extension.GhcPs)

+ GHC.Parser.String: instance GHC.Internal.Classes.Eq GHC.Parser.String.StringLexError

+ GHC.Parser.String: instance GHC.Parser.String.HasChar (GHC.Internal.Types.Char, x)

+ GHC.Parser.String: instance GHC.Parser.String.HasChar GHC.Internal.Types.Char

+ GHC.Parser.Types: ExplicitDataNamespace :: EpToken "data" -> ExplicitNamespaceKeyword

+ GHC.Parser.Types: ExplicitTypeNamespace :: EpToken "type" -> ExplicitNamespaceKeyword

+ GHC.Parser.Types: data ExplicitNamespaceKeyword

+ GHC.Platform: SSSE3 :: SseVersion

+ GHC.Platform: [pc_SIZEOF_StgAnnFrame_NoHdr] :: PlatformConstants -> Int

+ GHC.Platform: instance GHC.Internal.Classes.Eq GHC.Platform.BmiVersion

+ GHC.Platform: instance GHC.Internal.Classes.Eq GHC.Platform.Platform

+ GHC.Platform: instance GHC.Internal.Classes.Eq GHC.Platform.PlatformWordSize

+ GHC.Platform: instance GHC.Internal.Classes.Eq GHC.Platform.SseVersion

+ GHC.Platform: instance GHC.Internal.Classes.Ord GHC.Platform.BmiVersion

+ GHC.Platform: instance GHC.Internal.Classes.Ord GHC.Platform.Platform

+ GHC.Platform: instance GHC.Internal.Classes.Ord GHC.Platform.PlatformWordSize

+ GHC.Platform: instance GHC.Internal.Classes.Ord GHC.Platform.SseVersion

+ GHC.Platform.Constants: [pc_SIZEOF_StgAnnFrame_NoHdr] :: PlatformConstants -> Int

+ GHC.Platform.Constants: instance GHC.Internal.Classes.Eq GHC.Platform.Constants.PlatformConstants

+ GHC.Platform.Constants: instance GHC.Internal.Classes.Ord GHC.Platform.Constants.PlatformConstants

+ GHC.Platform.LA64: activeStgRegs :: [GlobalReg]

+ GHC.Platform.LA64: callerSaves :: GlobalReg -> Bool

+ GHC.Platform.LA64: freeReg :: RegNo -> Bool

+ GHC.Platform.LA64: globalRegMaybe :: GlobalReg -> Maybe RealReg

+ GHC.Platform.LA64: haveRegBase :: Bool

+ GHC.Platform.Profile: instance GHC.Internal.Classes.Eq GHC.Platform.Profile.Profile

+ GHC.Platform.Profile: instance GHC.Internal.Classes.Ord GHC.Platform.Profile.Profile

+ GHC.Platform.Reg: instance GHC.Internal.Classes.Eq GHC.Platform.Reg.RealReg

+ GHC.Platform.Reg: instance GHC.Internal.Classes.Eq GHC.Platform.Reg.Reg

+ GHC.Platform.Reg: instance GHC.Internal.Classes.Eq GHC.Platform.Reg.VirtualReg

+ GHC.Platform.Reg: instance GHC.Internal.Classes.Ord GHC.Platform.Reg.RealReg

+ GHC.Platform.Reg: instance GHC.Internal.Classes.Ord GHC.Platform.Reg.Reg

+ GHC.Platform.Reg: instance GHC.Internal.Classes.Ord GHC.Platform.Reg.VirtualReg

+ GHC.Platform.Reg.Class: instance GHC.Internal.Classes.Eq GHC.Platform.Reg.Class.RegArch

+ GHC.Platform.Reg.Class: instance GHC.Internal.Classes.Eq GHC.Platform.Reg.Class.RegClass

+ GHC.Platform.Reg.Class: instance GHC.Internal.Classes.Ord GHC.Platform.Reg.Class.RegArch

+ GHC.Platform.Reg.Class: instance GHC.Internal.Classes.Ord GHC.Platform.Reg.Class.RegClass

+ GHC.Platform.Ways: instance GHC.Internal.Classes.Eq GHC.Platform.Ways.Way

+ GHC.Platform.Ways: instance GHC.Internal.Classes.Ord GHC.Platform.Ways.Way

+ GHC.Plugins: cloneBndrsM :: MonadUnique m => Subst -> [Var] -> m (Subst, [Var])

+ GHC.Plugins: cloneRecIdBndrsM :: MonadUnique m => Subst -> [Id] -> m (Subst, [Id])

+ GHC.Plugins: collectPiTyBinders :: Type -> [PiTyBinder]

+ GHC.Plugins: dataConWrapUnfolding_maybe :: Id -> Maybe CoreExpr

+ GHC.Plugins: demoteOccTcClsName :: OccName -> Maybe OccName

+ GHC.Plugins: hasCoercionHole :: Type -> Bool

+ GHC.Plugins: invisibleBndrCount :: Type -> Int

+ GHC.Plugins: isDataFamilyApp :: Type -> Bool

+ GHC.Plugins: isSatTyFamApp :: Type -> Maybe (TyCon, [Type])

+ GHC.Plugins: liftedTypeOrConstraintKind :: TypeOrConstraint -> Kind

+ GHC.Plugins: mkForAllVisCos :: HasDebugCallStack => [ForAllTyBinder] -> Coercion -> Coercion

+ GHC.Plugins: pprFullNameWithUnique :: Module -> Name -> SDoc

+ GHC.Plugins: pprName_userQual :: IsLine doc => Maybe ModuleName -> Name -> doc

+ GHC.Plugins: sizeOccEnv :: OccEnv a -> Int

+ GHC.Plugins: splitVisibleFunTy_maybe :: Type -> Maybe (Type, Type)

+ GHC.Plugins: substInScopeSet :: Subst -> InScopeSet

+ GHC.Plugins: updateLCSubst :: LiftingContext -> (Subst -> (Subst, a)) -> (LiftingContext, a)

+ GHC.Prelude.Basic: class Foldable t => Foldable1 (t :: Type -> Type)

+ GHC.Prelude.Basic: fold1 :: (Foldable1 t, Semigroup m) => t m -> m

+ GHC.Prelude.Basic: foldMap1 :: (Foldable1 t, Semigroup m) => (a -> m) -> t a -> m

+ GHC.Prelude.Basic: foldMap1' :: (Foldable1 t, Semigroup m) => (a -> m) -> t a -> m

+ GHC.Prelude.Basic: foldl1' :: Foldable1 t => (a -> a -> a) -> t a -> a

+ GHC.Prelude.Basic: foldlM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a

+ GHC.Prelude.Basic: foldlMap1 :: Foldable1 t => (a -> b) -> (b -> a -> b) -> t a -> b

+ GHC.Prelude.Basic: foldlMap1' :: Foldable1 t => (a -> b) -> (b -> a -> b) -> t a -> b

+ GHC.Prelude.Basic: foldlMapM1 :: (Foldable1 t, Monad m) => (a -> m b) -> (b -> a -> m b) -> t a -> m b

+ GHC.Prelude.Basic: foldr1' :: Foldable1 t => (a -> a -> a) -> t a -> a

+ GHC.Prelude.Basic: foldrM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a

+ GHC.Prelude.Basic: foldrMap1 :: Foldable1 t => (a -> b) -> (a -> b -> b) -> t a -> b

+ GHC.Prelude.Basic: foldrMap1' :: Foldable1 t => (a -> b) -> (a -> b -> b) -> t a -> b

+ GHC.Prelude.Basic: foldrMapM1 :: (Foldable1 t, Monad m) => (a -> m b) -> (a -> b -> m b) -> t a -> m b

+ GHC.Prelude.Basic: infix 4 ~

+ GHC.Prelude.Basic: infixl 1 >>

+ GHC.Prelude.Basic: infixl 4 <*

+ GHC.Prelude.Basic: infixl 5 .|.

+ GHC.Prelude.Basic: infixl 6 `xor`

+ GHC.Prelude.Basic: infixl 7 .&.

+ GHC.Prelude.Basic: infixl 8 `rotateR`

+ GHC.Prelude.Basic: infixl 9 !!

+ GHC.Prelude.Basic: infixr 0 `seq`

+ GHC.Prelude.Basic: infixr 1 =<<

+ GHC.Prelude.Basic: infixr 2 ||

+ GHC.Prelude.Basic: infixr 3 &&

+ GHC.Prelude.Basic: infixr 5 ++

+ GHC.Prelude.Basic: infixr 8 **

+ GHC.Prelude.Basic: infixr 9 .

+ GHC.Prelude.Basic: intercalate1 :: (Foldable1 t, Semigroup m) => m -> t m -> m

+ GHC.Prelude.Basic: maximumBy :: Foldable1 t => (a -> a -> Ordering) -> t a -> a

+ GHC.Prelude.Basic: minimumBy :: Foldable1 t => (a -> a -> Ordering) -> t a -> a

+ GHC.Prelude.Basic: strictGenericLength :: Num a => [x] -> a

+ GHC.Prelude.Basic: toNonEmpty :: Foldable1 t => t a -> NonEmpty a

+ GHC.Rename.Bind: bindRuleBndrs :: HsDocContext -> RuleBndrs GhcPs -> ([Name] -> RuleBndrs GhcRn -> RnM (a, FreeVars)) -> RnM (a, FreeVars)

+ GHC.Rename.HsType: bindHsForAllTelescopes :: HsDocContext -> [HsForAllTelescope GhcPs] -> ([HsForAllTelescope GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)

+ GHC.Rename.HsType: extractHsForAllTelescopes :: [HsForAllTelescope GhcPs] -> FreeKiTyVars -> FreeKiTyVars

+ GHC.Rename.HsType: rnHsConDeclField :: HsDocContext -> HsConDeclField GhcPs -> RnM (HsConDeclField GhcRn, FreeVars)

+ GHC.Rename.HsType: rnHsConDeclRecFields :: HsDocContext -> [FieldLabel] -> [LHsConDeclRecField GhcPs] -> RnM ([LHsConDeclRecField GhcRn], FreeVars)

+ GHC.Rename.HsType: rnHsMultAnnWith :: (LocatedA (mult GhcPs) -> RnM (LocatedA (mult GhcRn), FreeVars)) -> HsMultAnnOf (LocatedA (mult GhcPs)) GhcPs -> RnM (HsMultAnnOf (LocatedA (mult GhcRn)) GhcRn, FreeVars)

+ GHC.Rename.Splice: checkThLocalNameNoLift :: LIdOccP GhcRn -> RnM ()

+ GHC.Rename.Splice: checkThLocalNameWithLift :: LIdOccP GhcRn -> RnM (HsExpr GhcRn)

+ GHC.Rename.Unbound: WL_ConLike :: WhatLooking

+ GHC.Rename.Unbound: WL_Term :: WhatLooking

+ GHC.Rename.Unbound: WL_TermVariable :: WhatLooking

+ GHC.Rename.Unbound: WL_TyCon :: WhatLooking

+ GHC.Rename.Unbound: WL_TyCon_or_TermVar :: WhatLooking

+ GHC.Rename.Unbound: WL_TyVar :: WhatLooking

+ GHC.Rename.Unbound: WL_Type :: WhatLooking

+ GHC.Rename.Unbound: relevantNameSpace :: Bool -> WhatLooking -> NameSpace -> Bool

+ GHC.Rename.Unbound: suggestionIsRelevant :: DynFlags -> WhatLooking -> OccName -> Bool

+ GHC.Rename.Unbound: unknownNameSuggestionsMessage :: TcRnMessage -> [ImportError] -> [GhcHint] -> RnM TcRnMessage

+ GHC.Rename.Utils: mkRnSyntaxExpr :: Name -> SyntaxExprRn

+ GHC.Runtime.Debugger.Breakpoints: enclosingTickSpan :: TickArray -> SrcSpan -> RealSrcSpan

+ GHC.Runtime.Debugger.Breakpoints: findBreakByCoord :: (Int, Int) -> TickArray -> Maybe (BreakTickIndex, RealSrcSpan)

+ GHC.Runtime.Debugger.Breakpoints: findBreakByLine :: Int -> TickArray -> Maybe (BreakTickIndex, RealSrcSpan)

+ GHC.Runtime.Debugger.Breakpoints: findBreakForBind :: String -> ModBreaks -> [(BreakTickIndex, RealSrcSpan)]

+ GHC.Runtime.Debugger.Breakpoints: getCurrentBreakModule :: GhcMonad m => m (Maybe Module)

+ GHC.Runtime.Debugger.Breakpoints: getCurrentBreakSpan :: GhcMonad m => m (Maybe SrcSpan)

+ GHC.Runtime.Debugger.Breakpoints: getModBreak :: GhcMonad m => Module -> m (Maybe ModBreaks)

+ GHC.Runtime.Debugger.Breakpoints: leftmostLargestRealSrcSpan :: RealSrcSpan -> RealSrcSpan -> Ordering

+ GHC.Runtime.Debugger.Breakpoints: lookupBreakpointOccurrences :: BreakpointOccurrences -> BreakpointId -> Maybe [InternalBreakpointId]

+ GHC.Runtime.Debugger.Breakpoints: makeModuleLineMap :: GhcMonad m => Module -> m (Maybe TickArray)

+ GHC.Runtime.Debugger.Breakpoints: mkBreakpointOccurrences :: GhcMonad m => m BreakpointOccurrences

+ GHC.Runtime.Debugger.Breakpoints: resolveFunctionBreakpoint :: GhcMonad m => String -> m (Either SDoc (Module, ModuleInfo, String))

+ GHC.Runtime.Debugger.Breakpoints: type BreakpointOccurrences = ModuleEnv IntMap [InternalBreakpointId]

+ GHC.Runtime.Debugger.Breakpoints: type TickArray = Array Int [(BreakTickIndex, RealSrcSpan)]

+ GHC.Runtime.Eval: LocalStep :: SrcSpan -> SingleStep

+ GHC.Runtime.Eval: ModuleStep :: SrcSpan -> SingleStep

+ GHC.Runtime.Eval: StepOut :: Maybe SrcSpan -> SingleStep

+ GHC.Runtime.Eval: [breakAt] :: SingleStep -> SrcSpan

+ GHC.Runtime.Eval: [infoprov] :: Term -> Maybe InfoProv

+ GHC.Runtime.Eval: [initiatedFrom] :: SingleStep -> Maybe SrcSpan

+ GHC.Runtime.Eval: mkTopLevImportedEnv :: HscEnv -> HomeModInfo -> IO GlobalRdrEnv

+ GHC.Runtime.Eval: readIModBreaks :: HomeUnitGraph -> InternalBreakpointId -> IO InternalModBreaks

+ GHC.Runtime.Eval: readIModModBreaks :: HomeUnitGraph -> Module -> IO ModBreaks

+ GHC.Runtime.Eval.Types: LocalStep :: SrcSpan -> SingleStep

+ GHC.Runtime.Eval.Types: ModuleStep :: SrcSpan -> SingleStep

+ GHC.Runtime.Eval.Types: StepOut :: Maybe SrcSpan -> SingleStep

+ GHC.Runtime.Eval.Types: [breakAt] :: SingleStep -> SrcSpan

+ GHC.Runtime.Eval.Types: [initiatedFrom] :: SingleStep -> Maybe SrcSpan

+ GHC.Runtime.Eval.Types: breakHere :: Bool -> SingleStep -> SrcSpan -> Bool

+ GHC.Runtime.Eval.Types: enableGhcStepMode :: SingleStep -> EvalStep

+ GHC.Runtime.Eval.Utils: combineModIdent :: String -> String -> String

+ GHC.Runtime.Eval.Utils: splitIdent :: String -> (String, String, String)

+ GHC.Runtime.Heap.Inspect: [infoprov] :: Term -> Maybe InfoProv

+ GHC.Runtime.Heap.Layout: instance GHC.Internal.Classes.Eq GHC.Runtime.Heap.Layout.ArgDescr

+ GHC.Runtime.Heap.Layout: instance GHC.Internal.Classes.Eq GHC.Runtime.Heap.Layout.ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: instance GHC.Internal.Classes.Eq GHC.Runtime.Heap.Layout.SMRep

+ GHC.Runtime.Heap.Layout: instance GHC.Internal.Classes.Eq GHC.Runtime.Heap.Layout.StgHalfWord

+ GHC.Runtime.Heap.Layout: instance GHC.Internal.Classes.Eq GHC.Runtime.Heap.Layout.StgWord

+ GHC.Runtime.Heap.Layout: instance GHC.Internal.Classes.Ord GHC.Runtime.Heap.Layout.ArgDescr

+ GHC.Runtime.Heap.Layout: instance GHC.Internal.Classes.Ord GHC.Runtime.Heap.Layout.ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: instance GHC.Internal.Classes.Ord GHC.Runtime.Heap.Layout.SMRep

+ GHC.Runtime.Interpreter: [WhereFrom] :: HValueRef -> Message (Maybe InfoProv)

+ GHC.Runtime.Interpreter: readIModBreaks :: HomeUnitGraph -> InternalBreakpointId -> IO InternalModBreaks

+ GHC.Runtime.Interpreter: readIModBreaksMaybe :: HomeUnitGraph -> Module -> IO (Maybe InternalModBreaks)

+ GHC.Runtime.Interpreter: readIModModBreaks :: HomeUnitGraph -> Module -> IO ModBreaks

+ GHC.Runtime.Interpreter: whereFrom :: Interp -> ForeignHValue -> IO (Maybe InfoProv)

+ GHC.Runtime.Interpreter.Process: [WhereFrom] :: HValueRef -> Message (Maybe InfoProv)

+ GHC.Runtime.Interpreter.Types: InterpSymbolCache :: MVar (SymbolCache "closure") -> MVar (SymbolCache "con_info") -> MVar (SymbolCache "static_info") -> MVar (SymbolCache "bytes") -> MVar (UniqFM FastString (Ptr ())) -> InterpSymbolCache

+ GHC.Runtime.Interpreter.Types: Interpreted :: SuffixOrInterpreted

+ GHC.Runtime.Interpreter.Types: Suffix :: Symbol -> SuffixOrInterpreted

+ GHC.Runtime.Interpreter.Types: [IBytesSymbol] :: Name -> InterpSymbol ('Suffix "bytes")

+ GHC.Runtime.Interpreter.Types: [IClosureSymbol] :: Name -> InterpSymbol ('Suffix "closure")

+ GHC.Runtime.Interpreter.Types: [IConInfoSymbol] :: Name -> InterpSymbol ('Suffix "con_info")

+ GHC.Runtime.Interpreter.Types: [IFaststringSymbol] :: FastString -> InterpSymbol 'Interpreted

+ GHC.Runtime.Interpreter.Types: [IStaticInfoSymbol] :: Name -> InterpSymbol ('Suffix "static_info")

+ GHC.Runtime.Interpreter.Types: [interpBytesCache] :: InterpSymbolCache -> MVar (SymbolCache "bytes")

+ GHC.Runtime.Interpreter.Types: [interpClosureCache] :: InterpSymbolCache -> MVar (SymbolCache "closure")

+ GHC.Runtime.Interpreter.Types: [interpConInfoCache] :: InterpSymbolCache -> MVar (SymbolCache "con_info")

+ GHC.Runtime.Interpreter.Types: [interpFaststringCache] :: InterpSymbolCache -> MVar (UniqFM FastString (Ptr ()))

+ GHC.Runtime.Interpreter.Types: [interpStaticInfoCache] :: InterpSymbolCache -> MVar (SymbolCache "static_info")

+ GHC.Runtime.Interpreter.Types: [interpSymbolCache] :: Interp -> InterpSymbolCache

+ GHC.Runtime.Interpreter.Types: [wasmInterpBrowserHost] :: WasmInterpConfig -> String

+ GHC.Runtime.Interpreter.Types: [wasmInterpBrowserPlaywrightBrowserType] :: WasmInterpConfig -> Maybe String

+ GHC.Runtime.Interpreter.Types: [wasmInterpBrowserPlaywrightLaunchOpts] :: WasmInterpConfig -> Maybe String

+ GHC.Runtime.Interpreter.Types: [wasmInterpBrowserPort] :: WasmInterpConfig -> Int

+ GHC.Runtime.Interpreter.Types: [wasmInterpBrowserPuppeteerLaunchOpts] :: WasmInterpConfig -> Maybe String

+ GHC.Runtime.Interpreter.Types: [wasmInterpBrowserRedirectWasiConsole] :: WasmInterpConfig -> Bool

+ GHC.Runtime.Interpreter.Types: [wasmInterpBrowser] :: WasmInterpConfig -> Bool

+ GHC.Runtime.Interpreter.Types: data InterpSymbol (s :: SuffixOrInterpreted)

+ GHC.Runtime.Interpreter.Types: data InterpSymbolCache

+ GHC.Runtime.Interpreter.Types: data SuffixOrInterpreted

+ GHC.Runtime.Interpreter.Types: eliminateInterpSymbol :: forall (s :: SuffixOrInterpreted) r. InterpSymbol s -> (InterpSymbol 'Interpreted -> r) -> (forall (x :: Symbol). () => InterpSymbol ('Suffix x) -> r) -> r

+ GHC.Runtime.Interpreter.Types: interpSymbolName :: forall (s :: Symbol). InterpSymbol ('Suffix s) -> Name

+ GHC.Runtime.Interpreter.Types: interpSymbolSuffix :: forall (s :: Symbol). InterpSymbol ('Suffix s) -> String

+ GHC.Runtime.Interpreter.Types: interpretedInterpSymbol :: InterpSymbol 'Interpreted -> FastString

+ GHC.Runtime.Interpreter.Types: interpreterDynamic :: Interp -> Bool

+ GHC.Runtime.Interpreter.Types: interpreterProfiled :: Interp -> Bool

+ GHC.Runtime.Interpreter.Types: lookupInterpSymbolCache :: forall (s :: SuffixOrInterpreted). InterpSymbol s -> InterpSymbolCache -> IO (Maybe (Ptr ()))

+ GHC.Runtime.Interpreter.Types: mkInterpSymbolCache :: IO InterpSymbolCache

+ GHC.Runtime.Interpreter.Types: purgeInterpSymbolCache :: InterpSymbolCache -> IO ()

+ GHC.Runtime.Interpreter.Types: updateInterpSymbolCache :: forall (s :: SuffixOrInterpreted). InterpSymbol s -> InterpSymbolCache -> Ptr () -> IO ()

+ GHC.Runtime.Interpreter.Types.SymbolCache: InterpSymbolCache :: MVar (SymbolCache "closure") -> MVar (SymbolCache "con_info") -> MVar (SymbolCache "static_info") -> MVar (SymbolCache "bytes") -> MVar (UniqFM FastString (Ptr ())) -> InterpSymbolCache

+ GHC.Runtime.Interpreter.Types.SymbolCache: Interpreted :: SuffixOrInterpreted

+ GHC.Runtime.Interpreter.Types.SymbolCache: Suffix :: Symbol -> SuffixOrInterpreted

+ GHC.Runtime.Interpreter.Types.SymbolCache: [IBytesSymbol] :: Name -> InterpSymbol ('Suffix "bytes")

+ GHC.Runtime.Interpreter.Types.SymbolCache: [IClosureSymbol] :: Name -> InterpSymbol ('Suffix "closure")

+ GHC.Runtime.Interpreter.Types.SymbolCache: [IConInfoSymbol] :: Name -> InterpSymbol ('Suffix "con_info")

+ GHC.Runtime.Interpreter.Types.SymbolCache: [IFaststringSymbol] :: FastString -> InterpSymbol 'Interpreted

+ GHC.Runtime.Interpreter.Types.SymbolCache: [IStaticInfoSymbol] :: Name -> InterpSymbol ('Suffix "static_info")

+ GHC.Runtime.Interpreter.Types.SymbolCache: [interpBytesCache] :: InterpSymbolCache -> MVar (SymbolCache "bytes")

+ GHC.Runtime.Interpreter.Types.SymbolCache: [interpClosureCache] :: InterpSymbolCache -> MVar (SymbolCache "closure")

+ GHC.Runtime.Interpreter.Types.SymbolCache: [interpConInfoCache] :: InterpSymbolCache -> MVar (SymbolCache "con_info")

+ GHC.Runtime.Interpreter.Types.SymbolCache: [interpFaststringCache] :: InterpSymbolCache -> MVar (UniqFM FastString (Ptr ()))

+ GHC.Runtime.Interpreter.Types.SymbolCache: [interpStaticInfoCache] :: InterpSymbolCache -> MVar (SymbolCache "static_info")

+ GHC.Runtime.Interpreter.Types.SymbolCache: data InterpSymbol (s :: SuffixOrInterpreted)

+ GHC.Runtime.Interpreter.Types.SymbolCache: data InterpSymbolCache

+ GHC.Runtime.Interpreter.Types.SymbolCache: data SuffixOrInterpreted

+ GHC.Runtime.Interpreter.Types.SymbolCache: eliminateInterpSymbol :: forall (s :: SuffixOrInterpreted) r. InterpSymbol s -> (InterpSymbol 'Interpreted -> r) -> (forall (x :: Symbol). () => InterpSymbol ('Suffix x) -> r) -> r

+ GHC.Runtime.Interpreter.Types.SymbolCache: instance GHC.Utils.Outputable.Outputable (GHC.Runtime.Interpreter.Types.SymbolCache.InterpSymbol s)

+ GHC.Runtime.Interpreter.Types.SymbolCache: interpSymbolName :: forall (s :: Symbol). InterpSymbol ('Suffix s) -> Name

+ GHC.Runtime.Interpreter.Types.SymbolCache: interpSymbolSuffix :: forall (s :: Symbol). InterpSymbol ('Suffix s) -> String

+ GHC.Runtime.Interpreter.Types.SymbolCache: interpretedInterpSymbol :: InterpSymbol 'Interpreted -> FastString

+ GHC.Runtime.Interpreter.Types.SymbolCache: lookupInterpSymbolCache :: forall (s :: SuffixOrInterpreted). InterpSymbol s -> InterpSymbolCache -> IO (Maybe (Ptr ()))

+ GHC.Runtime.Interpreter.Types.SymbolCache: mkInterpSymbolCache :: IO InterpSymbolCache

+ GHC.Runtime.Interpreter.Types.SymbolCache: purgeInterpSymbolCache :: InterpSymbolCache -> IO ()

+ GHC.Runtime.Interpreter.Types.SymbolCache: updateInterpSymbolCache :: forall (s :: SuffixOrInterpreted). InterpSymbol s -> InterpSymbolCache -> Ptr () -> IO ()

+ GHC.Settings: UnitSettings :: UnitId -> UnitSettings

+ GHC.Settings: [sUnitSettings] :: Settings -> UnitSettings

+ GHC.Settings: [unitSettings_baseUnitId] :: UnitSettings -> UnitId

+ GHC.Settings: data UnitSettings

+ GHC.Settings.Config: cGhcInternalUnitId :: String

+ GHC.Stg.EnforceEpt: enforceEpt :: StgPprOpts -> Bool -> Logger -> Module -> [CgStgTopBinding] -> IO ([TgStgTopBinding], NameEnv TagSig)

+ GHC.Stg.EnforceEpt.Rewrite: instance GHC.Internal.Base.Applicative GHC.Stg.EnforceEpt.Rewrite.RM

+ GHC.Stg.EnforceEpt.Rewrite: instance GHC.Internal.Base.Functor GHC.Stg.EnforceEpt.Rewrite.RM

+ GHC.Stg.EnforceEpt.Rewrite: instance GHC.Internal.Base.Monad GHC.Stg.EnforceEpt.Rewrite.RM

+ GHC.Stg.EnforceEpt.Rewrite: instance GHC.Types.Unique.Supply.MonadUnique GHC.Stg.EnforceEpt.Rewrite.RM

+ GHC.Stg.EnforceEpt.Rewrite: rewriteOpApp :: InferStgExpr -> RM TgStgExpr

+ GHC.Stg.EnforceEpt.Rewrite: rewriteTopBinds :: Module -> UniqSupply -> [GenStgTopBinding 'InferTaggedBinders] -> [TgStgTopBinding]

+ GHC.Stg.EnforceEpt.TagSig: TagDunno :: TagInfo

+ GHC.Stg.EnforceEpt.TagSig: TagProper :: TagInfo

+ GHC.Stg.EnforceEpt.TagSig: TagSig :: TagInfo -> TagSig

+ GHC.Stg.EnforceEpt.TagSig: TagTagged :: TagInfo

+ GHC.Stg.EnforceEpt.TagSig: TagTuple :: [TagInfo] -> TagInfo

+ GHC.Stg.EnforceEpt.TagSig: data TagInfo

+ GHC.Stg.EnforceEpt.TagSig: instance GHC.Internal.Classes.Eq GHC.Stg.EnforceEpt.TagSig.TagInfo

+ GHC.Stg.EnforceEpt.TagSig: instance GHC.Internal.Classes.Eq GHC.Stg.EnforceEpt.TagSig.TagSig

+ GHC.Stg.EnforceEpt.TagSig: instance GHC.Utils.Binary.Binary GHC.Stg.EnforceEpt.TagSig.TagInfo

+ GHC.Stg.EnforceEpt.TagSig: instance GHC.Utils.Binary.Binary GHC.Stg.EnforceEpt.TagSig.TagSig

+ GHC.Stg.EnforceEpt.TagSig: instance GHC.Utils.Outputable.Outputable GHC.Stg.EnforceEpt.TagSig.TagInfo

+ GHC.Stg.EnforceEpt.TagSig: instance GHC.Utils.Outputable.Outputable GHC.Stg.EnforceEpt.TagSig.TagSig

+ GHC.Stg.EnforceEpt.TagSig: instance GHC.Utils.Outputable.OutputableBndr (GHC.Types.Var.Id, GHC.Stg.EnforceEpt.TagSig.TagSig)

+ GHC.Stg.EnforceEpt.TagSig: isTaggedSig :: TagSig -> Bool

+ GHC.Stg.EnforceEpt.TagSig: newtype TagSig

+ GHC.Stg.EnforceEpt.TagSig: seqTagInfo :: TagInfo -> ()

+ GHC.Stg.EnforceEpt.TagSig: seqTagSig :: TagSig -> ()

+ GHC.Stg.EnforceEpt.TagSig: type StgCgInfos = NameEnv TagSig

+ GHC.Stg.EnforceEpt.Types: TE :: TagSigEnv -> (BinderP p -> Id) -> Bool -> TagEnv (p :: StgPass)

+ GHC.Stg.EnforceEpt.Types: [te_bytecode] :: TagEnv (p :: StgPass) -> Bool

+ GHC.Stg.EnforceEpt.Types: [te_env] :: TagEnv (p :: StgPass) -> TagSigEnv

+ GHC.Stg.EnforceEpt.Types: [te_get] :: TagEnv (p :: StgPass) -> BinderP p -> Id

+ GHC.Stg.EnforceEpt.Types: combineAltInfo :: TagInfo -> TagInfo -> TagInfo

+ GHC.Stg.EnforceEpt.Types: data TagEnv (p :: StgPass)

+ GHC.Stg.EnforceEpt.Types: extendSigEnv :: forall (p :: StgPass). TagEnv p -> [(Id, TagSig)] -> TagEnv p

+ GHC.Stg.EnforceEpt.Types: getBinderId :: forall (p :: StgPass). TagEnv p -> BinderP p -> Id

+ GHC.Stg.EnforceEpt.Types: initEnv :: Bool -> TagEnv 'CodeGen

+ GHC.Stg.EnforceEpt.Types: instance GHC.Utils.Outputable.Outputable (GHC.Stg.EnforceEpt.Types.TagEnv p)

+ GHC.Stg.EnforceEpt.Types: isDunnoSig :: TagSig -> Bool

+ GHC.Stg.EnforceEpt.Types: isTaggedInfo :: TagInfo -> Bool

+ GHC.Stg.EnforceEpt.Types: lookupInfo :: forall (p :: StgPass). TagEnv p -> StgArg -> TagInfo

+ GHC.Stg.EnforceEpt.Types: lookupSig :: forall (p :: StgPass). TagEnv p -> Id -> Maybe TagSig

+ GHC.Stg.EnforceEpt.Types: makeTagged :: forall (p :: StgPass). TagEnv p -> TagEnv 'InferTaggedBinders

+ GHC.Stg.EnforceEpt.Types: noSig :: forall (p :: StgPass). TagEnv p -> BinderP p -> (Id, TagSig)

+ GHC.Stg.EnforceEpt.Types: type InferStgAlt = GenStgAlt 'InferTaggedBinders

+ GHC.Stg.EnforceEpt.Types: type InferStgBinding = GenStgBinding 'InferTaggedBinders

+ GHC.Stg.EnforceEpt.Types: type InferStgExpr = GenStgExpr 'InferTaggedBinders

+ GHC.Stg.EnforceEpt.Types: type InferStgRhs = GenStgRhs 'InferTaggedBinders

+ GHC.Stg.EnforceEpt.Types: type InferStgTopBinding = GenStgTopBinding 'InferTaggedBinders

+ GHC.Stg.EnforceEpt.Types: type TagSigEnv = IdEnv TagSig

+ GHC.Stg.Lift.Config: instance GHC.Internal.Classes.Eq GHC.Stg.Lift.Config.StgLiftConfig

+ GHC.Stg.Lift.Config: instance GHC.Internal.Classes.Ord GHC.Stg.Lift.Config.StgLiftConfig

+ GHC.Stg.Pipeline: instance GHC.Internal.Classes.Eq GHC.Stg.Pipeline.StgToDo

+ GHC.Stg.Pipeline: instance GHC.Internal.Classes.Ord GHC.Stg.Pipeline.StgToDo

+ GHC.Stg.Stats: instance GHC.Internal.Classes.Eq GHC.Stg.Stats.CounterType

+ GHC.Stg.Stats: instance GHC.Internal.Classes.Ord GHC.Stg.Stats.CounterType

+ GHC.Stg.Syntax: instance GHC.Internal.Classes.Eq GHC.Stg.Syntax.NoExtFieldSilent

+ GHC.Stg.Syntax: instance GHC.Internal.Classes.Eq GHC.Stg.Syntax.UpdateFlag

+ GHC.Stg.Syntax: instance GHC.Internal.Classes.Ord GHC.Stg.Syntax.NoExtFieldSilent

+ GHC.StgToByteCode: instance GHC.Internal.Classes.Eq GHC.StgToByteCode.Discr

+ GHC.StgToByteCode: instance GHC.Internal.Classes.Ord GHC.StgToByteCode.Discr

+ GHC.StgToByteCode: instance GHC.Internal.Control.Monad.IO.Class.MonadIO GHC.StgToByteCode.BcM

+ GHC.StgToCmm.ArgRep: instance GHC.Internal.Classes.Eq GHC.StgToCmm.ArgRep.ArgRep

+ GHC.StgToCmm.ArgRep: instance GHC.Internal.Classes.Ord GHC.StgToCmm.ArgRep.ArgRep

+ GHC.StgToCmm.Closure: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.StgToCmm.Closure.NonVoid a)

+ GHC.StgToCmm.Config: [stgToCmmAllowIntWord64X2MinMax] :: StgToCmmConfig -> Bool

+ GHC.StgToCmm.Monad: [stgToCmmAllowIntWord64X2MinMax] :: StgToCmmConfig -> Bool

+ GHC.StgToCmm.Types: instance GHC.Internal.Classes.Eq GHC.StgToCmm.Types.StandardFormInfo

+ GHC.StgToJS.Apply: instance GHC.Internal.Classes.Eq GHC.StgToJS.Apply.ApplyConv

+ GHC.StgToJS.Apply: instance GHC.Internal.Classes.Eq GHC.StgToJS.Apply.ApplySpec

+ GHC.StgToJS.Apply: instance GHC.Internal.Classes.Ord GHC.StgToJS.Apply.ApplyConv

+ GHC.StgToJS.Apply: instance GHC.Internal.Classes.Ord GHC.StgToJS.Apply.ApplySpec

+ GHC.StgToJS.Expr: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.StgToJS.Expr.Branch a)

+ GHC.StgToJS.ExprCtx: instance GHC.Utils.Outputable.Outputable GHC.StgToJS.ExprCtx.ExprCtx

+ GHC.StgToJS.Linker.Linker: instance GHC.Utils.Outputable.Outputable GHC.StgToJS.Linker.Linker.ModuleCode

+ GHC.StgToJS.Monad: instance GHC.Utils.Outputable.Outputable GHC.StgToJS.Monad.GlobalOcc

+ GHC.StgToJS.Object: instance GHC.Internal.Classes.Eq GHC.StgToJS.Object.BlockRef

+ GHC.StgToJS.Object: instance GHC.Internal.Classes.Eq GHC.StgToJS.Object.ExportedFun

+ GHC.StgToJS.Object: instance GHC.Internal.Classes.Eq GHC.StgToJS.Object.JSOptions

+ GHC.StgToJS.Object: instance GHC.Internal.Classes.Eq GHC.StgToJS.Object.ObjectKind

+ GHC.StgToJS.Object: instance GHC.Internal.Classes.Ord GHC.StgToJS.Object.BlockRef

+ GHC.StgToJS.Object: instance GHC.Internal.Classes.Ord GHC.StgToJS.Object.ExportedFun

+ GHC.StgToJS.Object: instance GHC.Internal.Classes.Ord GHC.StgToJS.Object.JSOptions

+ GHC.StgToJS.Object: instance GHC.Internal.Classes.Ord GHC.StgToJS.Object.ObjectKind

+ GHC.StgToJS.Regs: instance GHC.Internal.Classes.Eq GHC.StgToJS.Regs.Special

+ GHC.StgToJS.Regs: instance GHC.Internal.Classes.Eq GHC.StgToJS.Regs.StgReg

+ GHC.StgToJS.Regs: instance GHC.Internal.Classes.Eq GHC.StgToJS.Regs.StgRet

+ GHC.StgToJS.Regs: instance GHC.Internal.Classes.Ord GHC.StgToJS.Regs.StgReg

+ GHC.StgToJS.Regs: instance GHC.Internal.Classes.Ord GHC.StgToJS.Regs.StgRet

+ GHC.StgToJS.Sinker.Collect: collectArgs :: CgStgBinding -> [Id]

+ GHC.StgToJS.Sinker.Collect: collectArgsTop :: CgStgBinding -> [Id]

+ GHC.StgToJS.Sinker.Collect: selectUsedOnce :: (Foldable t, Uniquable a) => t a -> UniqSet a

+ GHC.StgToJS.Sinker.Sinker: sinkPgm :: Module -> [CgStgTopBinding] -> (UniqFM Id CgStgExpr, [CgStgTopBinding])

+ GHC.StgToJS.Sinker.StringsUnfloat: unfloatStringLits :: UniqSet Name -> UniqFM Name ByteString -> [CgStgBinding] -> ([CgStgBinding], UniqSet Name)

+ GHC.StgToJS.Symbols: hdDecodeUtf8Z :: FastString

+ GHC.StgToJS.Types: SAKData :: StaticAppKind

+ GHC.StgToJS.Types: SAKFun :: StaticAppKind

+ GHC.StgToJS.Types: SAKThunk :: StaticAppKind

+ GHC.StgToJS.Types: StaticApp :: StaticAppKind -> FastString -> [StaticArg] -> StaticVal

+ GHC.StgToJS.Types: data StaticAppKind

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.CILayout

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.CIRegs

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.CIStatic

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.CIType

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.ClosureInfo

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.ClosureType

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.ExpFun

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.ExprResult

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.ExprValData

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.IdKey

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.IdType

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.JSFFIType

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.JSRep

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.OtherSymb

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.StackSlot

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.StaticAppKind

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.StaticArg

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.StaticInfo

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.StaticLit

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.StaticUnboxed

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.StaticVal

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Eq GHC.StgToJS.Types.ThreadStatus

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.CILayout

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.CIRegs

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.CIType

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.ClosureType

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.ExpFun

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.IdKey

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.IdType

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.JSFFIType

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.JSRep

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.OtherSymb

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.StackSlot

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.StaticUnboxed

+ GHC.StgToJS.Types: instance GHC.Internal.Classes.Ord GHC.StgToJS.Types.ThreadStatus

+ GHC.StgToJS.Types: instance GHC.Internal.Show.Show GHC.StgToJS.Types.ForeignJSRef

+ GHC.StgToJS.Types: instance GHC.Internal.Show.Show GHC.StgToJS.Types.StaticAppKind

+ GHC.StgToJS.Utils: instance GHC.Internal.Classes.Eq GHC.StgToJS.Utils.SlotCount

+ GHC.StgToJS.Utils: instance GHC.Internal.Classes.Ord GHC.StgToJS.Utils.SlotCount

+ GHC.SysTools.Ar: instance GHC.Internal.Classes.Eq GHC.SysTools.Ar.Archive

+ GHC.SysTools.Ar: instance GHC.Internal.Classes.Eq GHC.SysTools.Ar.ArchiveEntry

+ GHC.SysTools.Cpp: getGhcVersionIncludeFlags :: DynFlags -> UnitEnv -> IO [String]

+ GHC.SysTools.Tasks: instance GHC.Internal.Classes.Eq GHC.SysTools.Tasks.SourceCodePreprocessor

+ GHC.Tc.Errors.Hole: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Hole.HoleFitSortingAlg

+ GHC.Tc.Errors.Hole: instance GHC.Internal.Classes.Ord GHC.Tc.Errors.Hole.HoleFitSortingAlg

+ GHC.Tc.Errors.Hole.FitTypes: TcHoleFit :: TcHoleFit -> HoleFit

+ GHC.Tc.Errors.Hole.FitTypes: data TcHoleFit

+ GHC.Tc.Errors.Hole.FitTypes: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Hole.FitTypes.HoleFitCandidate

+ GHC.Tc.Errors.Hole.FitTypes: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Hole.FitTypes.TcHoleFit

+ GHC.Tc.Errors.Hole.FitTypes: instance GHC.Internal.Classes.Ord GHC.Tc.Errors.Hole.FitTypes.HoleFitCandidate

+ GHC.Tc.Errors.Hole.FitTypes: instance GHC.Internal.Classes.Ord GHC.Tc.Errors.Hole.FitTypes.TcHoleFit

+ GHC.Tc.Errors.Hole.FitTypes: instance GHC.Utils.Outputable.Outputable GHC.Tc.Errors.Hole.FitTypes.TcHoleFit

+ GHC.Tc.Errors.Ppr: pprErrCtxtMsg :: ErrCtxtMsg -> SDoc

+ GHC.Tc.Errors.Types: AmbiguityCheckCtxt :: UserTypeCtxt -> Bool -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: AnnCtxt :: AnnDecl (GhcPass p) -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: AssociatedTypeOfClass :: Subordinate

+ GHC.Tc.Errors.Types: BadImportNonDataSubordinates :: GlobalRdrElt -> NonEmpty GlobalRdrElt -> BadImportKind

+ GHC.Tc.Errors.Types: BadImportNonTypeSubordinates :: GlobalRdrElt -> NonEmpty GlobalRdrElt -> BadImportKind

+ GHC.Tc.Errors.Types: CheckImplementsCtxt :: UnitState -> Module -> InstantiatedModule -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: ClassMethodSigCtx :: LocatedN RdrName -> HsDocContext

+ GHC.Tc.Errors.Types: ClassOpCtxt :: Id -> Type -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: ClosedFamEqnCtxt :: TyCon -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: CmdCtxt :: HsCmd GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: DataConDefCtxt :: NonEmpty (LocatedN Name) -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: DataConResTyCtxt :: NonEmpty (LocatedN Name) -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: DataConVisibleForall :: UnrepresentableTypeDescr

+ GHC.Tc.Errors.Types: DefaultDeclErrCtxt :: Bool -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: DerivBindCtxt :: Id -> Class -> [Type] -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: DerivInstCtxt :: PredType -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: EmptyGuard :: ConversionFailReason

+ GHC.Tc.Errors.Types: EmptyParStmt :: ConversionFailReason

+ GHC.Tc.Errors.Types: ExportCtxt :: IE (GhcPass p) -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: ExprCtxt :: HsExpr GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: FieldCtxt :: FieldLabelString -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: FieldOfConstructor :: Subordinate

+ GHC.Tc.Errors.Types: ForeignDeclCtxt :: ForeignDecl GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: FunAppCtxt :: FunAppCtxtFunArg -> Int -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: FunResCtxt :: HsExpr GhcTc -> Int -> Type -> Type -> Int -> Int -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: FunTysCtxt :: ExpectedFunTyOrigin -> Type -> Int -> Int -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: ImportLookupExtensions :: Bool -> Bool -> ImportLookupExtensions

+ GHC.Tc.Errors.Types: InferredTypeCtxt :: Name -> TcType -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: InstDeclErrCtxt :: Either (LHsType GhcRn) PredType -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: InstHeadNonClassHead :: InstHeadNonClassHead -> IllegalInstanceHeadReason

+ GHC.Tc.Errors.Types: InstNonClassTyCon :: WithUserRdr Name -> TyConFlavour Name -> InstHeadNonClassHead

+ GHC.Tc.Errors.Types: InstNonTyCon :: InstHeadNonClassHead

+ GHC.Tc.Errors.Types: InvisPatMisplaced :: BadInvisPatReason

+ GHC.Tc.Errors.Types: InvisPatNoForall :: BadInvisPatReason

+ GHC.Tc.Errors.Types: InvisPatWithoutFlag :: BadInvisPatReason

+ GHC.Tc.Errors.Types: KindCtxt :: LHsKind GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: LevelCheckInstance :: InstanceWhat -> PredType -> LevelCheckReason

+ GHC.Tc.Errors.Types: LevelCheckSplice :: Name -> Maybe GlobalRdrElt -> LevelCheckReason

+ GHC.Tc.Errors.Types: MainCtxt :: Name -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: MatchCtxt :: HsMatchContextRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: MatchInCtxt :: Match GhcRn body -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: MergeSignaturesCtxt :: UnitState -> ModuleName -> [InstantiatedModule] -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: MethSigCtxt :: Name -> TcType -> TcType -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: MethodOfClass :: Subordinate

+ GHC.Tc.Errors.Types: MultiplicityCoercionsNotSupported :: TcSolverReportMsg

+ GHC.Tc.Errors.Types: PatCtxt :: Pat GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: PatMonoBindsCtxt :: LPat (GhcPass p) -> GRHSs GhcRn (LHsExpr GhcRn) -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: PatSigErrCtxt :: TcType -> TcType -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: PatSynDeclCtxt :: Name -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: PatSynExportCtxt :: PatSyn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: PatSynRecSelExportCtxt :: PatSyn -> Name -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: PatSynSigCtx :: [LocatedN RdrName] -> HsDocContext

+ GHC.Tc.Errors.Types: QuantifiedCtCtxt :: PredType -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: RecordUpdCtxt :: NonEmpty ConLike -> [Name] -> [TyCoVar] -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: ReifyInstancesCtx :: HsDocContext

+ GHC.Tc.Errors.Types: ReifyInstancesCtxt :: Name -> [Type] -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: ResolvedNameInfo :: [GlobalRdrElt] -> RdrName -> Name -> ResolvedNameInfo

+ GHC.Tc.Errors.Types: RoleAnnotErrCtxt :: Name -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: RuleCtxt :: FastString -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: SigCtxt :: Sig GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: SpecECtx :: RdrName -> HsDocContext

+ GHC.Tc.Errors.Types: SpecPragmaCtxt :: Sig GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: SpecialiseSigCtx :: LocatedN RdrName -> HsDocContext

+ GHC.Tc.Errors.Types: StandaloneDerivCtxt :: LHsSigWcType GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: StaticFormCtxt :: LHsExpr GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: StmtErrCtxt :: HsStmtContextRn -> StmtLR GhcRn GhcRn body -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: SubTypeCtxt :: TcType -> TcType -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: SupplementaryImportErrors :: NonEmpty ImportError -> SupplementaryInfo

+ GHC.Tc.Errors.Types: SyntaxNameCtxt :: HsExpr GhcRn -> CtOrigin -> TcType -> SrcSpan -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: TermLevelUseCtxt :: Name -> TermLevelUseCtxt -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: ThetaCtxt :: UserTypeCtxt -> ThetaType -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: TyConDeclCtxt :: Name -> TyConFlavour TyCon -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: TyConInstCtxt :: Name -> TyConInstFlavour -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: TySynErrCtxt :: TyCon -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: TypeCtxt :: LHsType GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: TypedSpliceCtxt :: Maybe SplicePointName -> HsTypedSplice (GhcPass p) -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: TypedSpliceResultCtxt :: LHsExpr GhcTc -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: TypedTHBracketCtxt :: LHsExpr (GhcPass p) -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: UntypedSpliceCtxt :: HsUntypedSplice GhcPs -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: UntypedTHBracketCtxt :: HsQuote GhcPs -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: UserSigCtxt :: UserTypeCtxt -> UserSigType GhcRn -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: VDQWarningCtxt :: TcTyCon -> ErrCtxtMsg

+ GHC.Tc.Errors.Types: WL_Anything :: WhatLooking

+ GHC.Tc.Errors.Types: WL_ConLike :: WhatLooking

+ GHC.Tc.Errors.Types: WL_Constructor :: WhatLooking

+ GHC.Tc.Errors.Types: WL_None :: WhatLooking

+ GHC.Tc.Errors.Types: WL_RecField :: WhatLooking

+ GHC.Tc.Errors.Types: WL_Term :: WhatLooking

+ GHC.Tc.Errors.Types: WL_TermVariable :: WhatLooking

+ GHC.Tc.Errors.Types: WL_TyCon :: WhatLooking

+ GHC.Tc.Errors.Types: WL_TyCon_or_TermVar :: WhatLooking

+ GHC.Tc.Errors.Types: WL_TyVar :: WhatLooking

+ GHC.Tc.Errors.Types: WL_Type :: WhatLooking

+ GHC.Tc.Errors.Types: [TcRnBadlyLevelledType] :: Name -> Set ThLevelIndex -> ThLevelIndex -> TcRnMessage

+ GHC.Tc.Errors.Types: [TcRnBadlyLevelled] :: LevelCheckReason -> Set ThLevelIndex -> ThLevelIndex -> Maybe ErrorItem -> DiagnosticReason -> TcRnMessage

+ GHC.Tc.Errors.Types: [TcRnDuplicateNamedDefaultExport] :: TyCon -> IE GhcPs -> IE GhcPs -> TcRnMessage

+ GHC.Tc.Errors.Types: [TcRnIllegalPunnedVarOccInTypeArgument] :: ResolvedNameInfo -> ResolvedNameInfo -> TcRnMessage

+ GHC.Tc.Errors.Types: [TcRnRuleLhsEqualities] :: FastString -> LHsExpr GhcRn -> NonEmpty Ct -> TcRnMessage

+ GHC.Tc.Errors.Types: [TcRnSpecSigShape] :: LHsExpr GhcPs -> TcRnMessage

+ GHC.Tc.Errors.Types: [UnusableUnpackPragma] :: BadFieldAnnotationReason

+ GHC.Tc.Errors.Types: [cannotResolve_relBinds] :: TcSolverReportMsg -> RelevantBindings

+ GHC.Tc.Errors.Types: [ddec_in_type_list] :: ErrCtxtMsg -> Bool

+ GHC.Tc.Errors.Types: [errInfoHints] :: ErrInfo -> [GhcHint]

+ GHC.Tc.Errors.Types: [frr_info_other_origin] :: FixedRuntimeRepErrorInfo -> Maybe CtOrigin

+ GHC.Tc.Errors.Types: [ile_explicit_namespaces] :: ImportLookupExtensions -> Bool

+ GHC.Tc.Errors.Types: [ile_pattern_synonyms] :: ImportLookupExtensions -> Bool

+ GHC.Tc.Errors.Types: [sr_hints] :: SolverReport -> [GhcHint]

+ GHC.Tc.Errors.Types: data BadInvisPatReason

+ GHC.Tc.Errors.Types: data ErrCtxtMsg

+ GHC.Tc.Errors.Types: data ImportLookupExtensions

+ GHC.Tc.Errors.Types: data InstHeadNonClassHead

+ GHC.Tc.Errors.Types: data LevelCheckReason

+ GHC.Tc.Errors.Types: data ResolvedNameInfo

+ GHC.Tc.Errors.Types: data Subordinate

+ GHC.Tc.Errors.Types: data SupplementaryInfo

+ GHC.Tc.Errors.Types: data WhatLooking

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.AssociatedTyLastVarInKind

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.AssociatedTyNotParamOverLastTyVar

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.DeriveAnyClassEnabled

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.Exported

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.HasAssociatedDataFamInsts

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.HasKinds

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.HasWildcard

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.SuggestPartialTypeSignatures

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.SuggestUndecidableInstances

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.UnsupportedCallConvention

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.UsingGeneralizedNewtypeDeriving

+ GHC.Tc.Errors.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Errors.Types.WhatLooking

+ GHC.Tc.Errors.Types: instance GHC.Internal.Generics.Generic GHC.Tc.Errors.Types.BadInvisPatReason

+ GHC.Tc.Errors.Types: instance GHC.Internal.Generics.Generic GHC.Tc.Errors.Types.ImportLookupExtensions

+ GHC.Tc.Errors.Types: instance GHC.Internal.Generics.Generic GHC.Tc.Errors.Types.Subordinate

+ GHC.Tc.Errors.Types: instance GHC.Internal.Show.Show GHC.Tc.Errors.Types.WhatLooking

+ GHC.Tc.Errors.Types: instance GHC.Utils.Outputable.Outputable GHC.Tc.Errors.Types.ResolvedNameInfo

+ GHC.Tc.Errors.Types: lookingForSubordinate :: GlobalRdrElt -> WhatLooking

+ GHC.Tc.Errors.Types: pprResolvedNameProvenance :: ResolvedNameInfo -> SDoc

+ GHC.Tc.Errors.Types: pprSubordinate :: Name -> Subordinate -> SDoc

+ GHC.Tc.Errors.Types.PromotionErr: TermLevelUseGRE :: GlobalRdrElt -> TermLevelUseCtxt

+ GHC.Tc.Errors.Types.PromotionErr: TermLevelUseTyVar :: TermLevelUseCtxt

+ GHC.Tc.Errors.Types.PromotionErr: data TermLevelUseCtxt

+ GHC.Tc.Errors.Types.PromotionErr: instance GHC.Internal.Generics.Generic GHC.Tc.Errors.Types.PromotionErr.TermLevelUseCtxt

+ GHC.Tc.Errors.Types.PromotionErr: pprTermLevelUseCtxt :: Name -> TermLevelUseCtxt -> SDoc

+ GHC.Tc.Gen.Default: extendDefaultEnvWithLocalDefaults :: [LocatedA ClassDefaults] -> TcM a -> TcM a

+ GHC.Tc.Gen.Default: tcDefaultDecls :: [LDefaultDecl GhcRn] -> TcM [LocatedA ClassDefaults]

+ GHC.Tc.Gen.Expr: tcInferExpr :: InferInstFlag -> LHsExpr GhcRn -> TcM (LHsExpr GhcTc, TcType)

+ GHC.Tc.Gen.Expr: tcInferSigma :: LHsExpr GhcRn -> TcM (LHsExpr GhcTc, TcSigmaType)

+ GHC.Tc.Gen.Head: tcInferConLike :: ConLike -> TcM (HsExpr GhcTc, TcSigmaType)

+ GHC.Tc.Gen.HsType: RuleBndrTypeCtxt :: Name -> UserTypeCtxt

+ GHC.Tc.Gen.HsType: maybeEtaExpandAlgTyCon :: TyConFlavour tc -> SkolemInfo -> [TcTyConBinder] -> Kind -> TcM ([TcTyConBinder], Kind)

+ GHC.Tc.Gen.HsType: tcGadtConTyVarBndrs :: SkolemInfo -> HsOuterSigTyVarBndrs GhcRn -> [HsForAllTelescope GhcRn] -> TcM a -> TcM ([TcTyVarBinder], a)

+ GHC.Tc.Gen.HsType: tcRuleBndrSig :: Name -> SkolemInfo -> HsPatSigType GhcRn -> TcM ([(Name, TcTyVar)], [(Name, TcTyVar)], TcType)

+ GHC.Tc.Gen.Match: tcGRHSNE :: AnnoBody body => HsMatchContextRn -> TcMatchAltChecker body -> NonEmpty (LGRHS GhcRn (LocatedA (body GhcRn))) -> ExpRhoType -> TcM (NonEmpty (LGRHS GhcTc (LocatedA (body GhcTc))))

+ GHC.Tc.Gen.Sig: tcRules :: [LRuleDecls GhcRn] -> TcM [LRuleDecls GhcTc]

+ GHC.Tc.Instance.Class: lookupHasFieldLabel :: FamInstEnvs -> GlobalRdrEnv -> [Type] -> Maybe (Name, GlobalRdrElt, Type, Type)

+ GHC.Tc.Module: tcRnTypeSkolemising :: HscEnv -> LHsType GhcPs -> IO (Messages TcRnMessage, Maybe (Type, Kind))

+ GHC.Tc.Plugin: lookupTHName :: Name -> TcPluginM (Maybe Name)

+ GHC.Tc.Solver: emitResidualConstraints :: TcLevel -> SkolemInfoAnon -> EvBindsVar -> CoVarSet -> [TcTyVar] -> [EvVar] -> WantedConstraints -> TcM ()

+ GHC.Tc.Solver.Default: instance GHC.Utils.Outputable.Outputable GHC.Tc.Solver.Default.Proposal

+ GHC.Tc.Solver.Default: instance GHC.Utils.Outputable.Outputable GHC.Tc.Solver.Default.ProposalSequence

+ GHC.Tc.Solver.Default: isInteractiveClass :: Bool -> Class -> Bool

+ GHC.Tc.Solver.Default: isNumClass :: Bool -> Class -> Bool

+ GHC.Tc.Solver.Default: tryDefaulting :: WantedConstraints -> TcS WantedConstraints

+ GHC.Tc.Solver.Default: tryDefaultingForAmbiguityCheck :: WantedConstraints -> TcS WantedConstraints

+ GHC.Tc.Solver.InertSet: [inert_givens] :: InertSet -> InertCans

+ GHC.Tc.Solver.InertSet: [inert_qcis] :: InertCans -> [QCInst]

+ GHC.Tc.Solver.InertSet: emptyInertCans :: TcLevel -> InertCans

+ GHC.Tc.Solver.InertSet: emptyInertSet :: TcLevel -> InertSet

+ GHC.Tc.Solver.InertSet: extendWorkListChildEqs :: CtEvidence -> Bag Ct -> WorkList -> WorkList

+ GHC.Tc.Solver.InertSet: extendWorkListRewrittenEqs :: [EqCt] -> WorkList -> WorkList

+ GHC.Tc.Solver.InertSet: filterFunEqs :: (EqCt -> Bool) -> InertFunEqs -> InertFunEqs

+ GHC.Tc.Solver.InertSet: filterInertEqs :: (EqCt -> Bool) -> InertEqs -> InertEqs

+ GHC.Tc.Solver.InertSet: instance GHC.Internal.Classes.Eq GHC.Tc.Solver.InertSet.WhereToLook

+ GHC.Tc.Solver.InertSet: lookupInertDict :: InertCans -> Class -> [Type] -> Maybe DictCt

+ GHC.Tc.Solver.InertSet: lookupSolvedDict :: InertSet -> Class -> [Type] -> Maybe CtEvidence

+ GHC.Tc.Solver.Monad: TcS :: (TcSEnv -> TcM a) -> TcS a

+ GHC.Tc.Solver.Monad: TcSEnv :: EvBindsVar -> IORef Int -> IORef (Maybe TcLevel) -> IORef Int -> IORef InertSet -> TcSMode -> IORef WorkList -> TcSEnv

+ GHC.Tc.Solver.Monad: TcSMode :: Bool -> Bool -> Bool -> Bool -> TcSMode

+ GHC.Tc.Solver.Monad: [qci_body] :: QCInst -> TcPredType

+ GHC.Tc.Solver.Monad: [qci_theta] :: QCInst -> TcThetaType

+ GHC.Tc.Solver.Monad: [tcs_count] :: TcSEnv -> IORef Int

+ GHC.Tc.Solver.Monad: [tcs_ev_binds] :: TcSEnv -> EvBindsVar

+ GHC.Tc.Solver.Monad: [tcs_inerts] :: TcSEnv -> IORef InertSet

+ GHC.Tc.Solver.Monad: [tcs_mode] :: TcSEnv -> TcSMode

+ GHC.Tc.Solver.Monad: [tcs_unif_lvl] :: TcSEnv -> IORef (Maybe TcLevel)

+ GHC.Tc.Solver.Monad: [tcs_unified] :: TcSEnv -> IORef Int

+ GHC.Tc.Solver.Monad: [tcs_worklist] :: TcSEnv -> IORef WorkList

+ GHC.Tc.Solver.Monad: [tcsmEarlyAbort] :: TcSMode -> Bool

+ GHC.Tc.Solver.Monad: [tcsmFullySolveQCIs] :: TcSMode -> Bool

+ GHC.Tc.Solver.Monad: [tcsmResumable] :: TcSMode -> Bool

+ GHC.Tc.Solver.Monad: [tcsmSkipOverlappable] :: TcSMode -> Bool

+ GHC.Tc.Solver.Monad: [unTcS] :: TcS a -> TcSEnv -> TcM a

+ GHC.Tc.Solver.Monad: addInertQCI :: QCInst -> TcS ()

+ GHC.Tc.Solver.Monad: checkWellLevelledDFun :: CtLoc -> InstanceWhat -> PredType -> TcS ()

+ GHC.Tc.Solver.Monad: data TcSEnv

+ GHC.Tc.Solver.Monad: data TcSMode

+ GHC.Tc.Solver.Monad: getTcSMode :: TcS TcSMode

+ GHC.Tc.Solver.Monad: getUnifiedRef :: TcS (IORef Int)

+ GHC.Tc.Solver.Monad: instance GHC.Utils.Outputable.Outputable GHC.Tc.Solver.Monad.TcSMode

+ GHC.Tc.Solver.Monad: newtype TcS a

+ GHC.Tc.Solver.Monad: setTcLevelTcS :: TcLevel -> TcS a -> TcS a

+ GHC.Tc.Solver.Monad: setTcSMode :: TcSMode -> TcS a -> TcS a

+ GHC.Tc.Solver.Monad: tryShortCutTcS :: TcS Bool -> TcS Bool

+ GHC.Tc.Solver.Monad: updInertDicts :: DictCt -> TcS ()

+ GHC.Tc.Solver.Monad: updInertIrreds :: IrredCt -> TcS ()

+ GHC.Tc.Solver.Monad: vanillaTcSMode :: TcSMode

+ GHC.Tc.Solver.Monad: wrapUnifierX :: CtEvidence -> Role -> (UnifyEnv -> TcM a) -> TcS (a, Bag Ct, [TcTyVar])

+ GHC.Tc.Solver.Solve: setImplicationStatus :: Implication -> TcS Implication

+ GHC.Tc.Solver.Solve: simplifyWantedsTcM :: [CtEvidence] -> TcM WantedConstraints

+ GHC.Tc.Solver.Solve: solveWanteds :: WantedConstraints -> TcS WantedConstraints

+ GHC.Tc.Solver.Solve: trySolveImplication :: Implication -> TcS Bool

+ GHC.Tc.Solver.Types: mapMaybeTcAppMap :: (a -> Maybe b) -> TcAppMap a -> TcAppMap b

+ GHC.Tc.TyCl: IsNotPrefixConGADT :: IsPrefixConGADT

+ GHC.Tc.TyCl: IsPrefixConGADT :: IsPrefixConGADT

+ GHC.Tc.TyCl: data IsPrefixConGADT

+ GHC.Tc.TyCl: instance GHC.Internal.Base.Monoid GHC.Tc.TyCl.TcTyClGroupsAccum

+ GHC.Tc.TyCl: instance GHC.Internal.Base.Semigroup GHC.Tc.TyCl.TcTyClGroupsAccum

+ GHC.Tc.TyCl: instance GHC.Internal.Classes.Eq GHC.Tc.TyCl.IsPrefixConGADT

+ GHC.Tc.TyCl: instance GHC.Utils.Outputable.Outputable GHC.Tc.TyCl.TcTyClGroupsStats

+ GHC.Tc.TyCl: tcAddOpenTyFamInstCtxt :: AssocInstInfo -> TyFamInstDecl GhcRn -> TcM a -> TcM a

+ GHC.Tc.TyCl: unannotatedMultIsLinear :: IsPrefixConGADT -> TcRnIf gbl lcl Bool

+ GHC.Tc.TyCl.Build: buildAbstractClass :: Name -> [TyConBinder] -> [Role] -> [FunDep TyVar] -> TcRnIf m n Class

+ GHC.Tc.Types: RnPending :: TcRef [PendingRnSplice] -> PendingStuff

+ GHC.Tc.Types: [iul_avails] :: ImpUserList -> [AvailInfo]

+ GHC.Tc.Types: [iul_non_explicit_parents] :: ImpUserList -> NameSet

+ GHC.Tc.Types: [tcg_complete_match_env] :: TcGblEnv -> CompleteMatches

+ GHC.Tc.Types: data ThLevel

+ GHC.Tc.Types: data ThLevelIndex

+ GHC.Tc.Types: instance GHC.Internal.Classes.Eq GHC.Tc.Types.DocLoc

+ GHC.Tc.Types: instance GHC.Internal.Classes.Ord GHC.Tc.Types.DocLoc

+ GHC.Tc.Types: pattern TypedBrack :: ThLevel -> ThLevel

+ GHC.Tc.Types: pattern UntypedBrack :: ThLevel -> TcRef [PendingRnSplice] -> ThLevel

+ GHC.Tc.Types: quoteLevelIndex :: ThLevelIndex

+ GHC.Tc.Types: spliceLevelIndex :: ThLevelIndex

+ GHC.Tc.Types: thLevelIndex :: ThLevel -> ThLevelIndex

+ GHC.Tc.Types: topAnnLevel :: ThLevel

+ GHC.Tc.Types: topLevel :: ThLevel

+ GHC.Tc.Types: topLevelIndex :: ThLevelIndex

+ GHC.Tc.Types: topSpliceLevel :: ThLevel

+ GHC.Tc.Types.Constraint: DE_Multiplicity :: TcCoercion -> CtLoc -> DelayedError

+ GHC.Tc.Types.Constraint: ENS :: VarSet -> VarSet -> EvNeedSet

+ GHC.Tc.Types.Constraint: GivenCt :: TcPredType -> EvVar -> CtLoc -> GivenCtEvidence

+ GHC.Tc.Types.Constraint: WantedCt :: TcPredType -> TcEvDest -> CtLoc -> RewriterSet -> WantedCtEvidence

+ GHC.Tc.Types.Constraint: [ens_dms] :: EvNeedSet -> VarSet

+ GHC.Tc.Types.Constraint: [ens_fvs] :: EvNeedSet -> VarSet

+ GHC.Tc.Types.Constraint: [ic_need] :: Implication -> EvNeedSet

+ GHC.Tc.Types.Constraint: [ic_need_implic] :: Implication -> EvNeedSet

+ GHC.Tc.Types.Constraint: [qci_body] :: QCInst -> TcPredType

+ GHC.Tc.Types.Constraint: [qci_theta] :: QCInst -> TcThetaType

+ GHC.Tc.Types.Constraint: addMultiplicityCoercionError :: WantedConstraints -> TcCoercion -> CtLoc -> WantedConstraints

+ GHC.Tc.Types.Constraint: approximateWC :: Bool -> WantedConstraints -> Bag Ct

+ GHC.Tc.Types.Constraint: approximateWCX :: Bool -> WantedConstraints -> ApproxWC

+ GHC.Tc.Types.Constraint: ctHasNoRewriters :: Ct -> Bool

+ GHC.Tc.Types.Constraint: data EvNeedSet

+ GHC.Tc.Types.Constraint: data GivenCtEvidence

+ GHC.Tc.Types.Constraint: data WantedCtEvidence

+ GHC.Tc.Types.Constraint: delGivensFromEvNeedSet :: EvNeedSet -> [Var] -> EvNeedSet

+ GHC.Tc.Types.Constraint: emptyEvNeedSet :: EvNeedSet

+ GHC.Tc.Types.Constraint: extendEvNeedSet :: EvNeedSet -> Var -> EvNeedSet

+ GHC.Tc.Types.Constraint: givenCtEvCoercion :: GivenCtEvidence -> TcCoercion

+ GHC.Tc.Types.Constraint: instance GHC.Internal.Classes.Eq GHC.Tc.Types.Constraint.CheckTyEqProblem

+ GHC.Tc.Types.Constraint: instance GHC.Internal.Classes.Eq GHC.Tc.Types.Constraint.CtFlavour

+ GHC.Tc.Types.Constraint: instance GHC.Internal.Classes.Eq GHC.Tc.Types.Constraint.HasGivenEqs

+ GHC.Tc.Types.Constraint: instance GHC.Utils.Outputable.Outputable GHC.Tc.Types.Constraint.EvNeedSet

+ GHC.Tc.Types.Constraint: instance GHC.Utils.Outputable.Outputable GHC.Tc.Types.Constraint.GivenCtEvidence

+ GHC.Tc.Types.Constraint: instance GHC.Utils.Outputable.Outputable GHC.Tc.Types.Constraint.WantedCtEvidence

+ GHC.Tc.Types.Constraint: setWantedCtEvRewriters :: WantedCtEvidence -> RewriterSet -> WantedCtEvidence

+ GHC.Tc.Types.Constraint: unionEvNeedSet :: EvNeedSet -> EvNeedSet -> EvNeedSet

+ GHC.Tc.Types.Constraint: wantedCtEvEvId :: WantedCtEvidence -> EvVar

+ GHC.Tc.Types.Constraint: wantedCtHasNoRewriters :: WantedCtEvidence -> Bool

+ GHC.Tc.Types.CtLoc: instance GHC.Internal.Classes.Eq GHC.Tc.Types.CtLoc.SubGoalDepth

+ GHC.Tc.Types.CtLoc: instance GHC.Internal.Classes.Ord GHC.Tc.Types.CtLoc.SubGoalDepth

+ GHC.Tc.Types.ErrCtxt: AmbiguityCheckCtxt :: UserTypeCtxt -> Bool -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: AnnCtxt :: AnnDecl (GhcPass p) -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: CheckImplementsCtxt :: UnitState -> Module -> InstantiatedModule -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: ClassOpCtxt :: Id -> Type -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: ClosedFamEqnCtxt :: TyCon -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: CmdCtxt :: HsCmd GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: DataConDefCtxt :: NonEmpty (LocatedN Name) -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: DataConResTyCtxt :: NonEmpty (LocatedN Name) -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: DefaultDeclErrCtxt :: Bool -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: DerivBindCtxt :: Id -> Class -> [Type] -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: DerivInstCtxt :: PredType -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: ExportCtxt :: IE (GhcPass p) -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: ExprCtxt :: HsExpr GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: FieldCtxt :: FieldLabelString -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: ForeignDeclCtxt :: ForeignDecl GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: FunAppCtxt :: FunAppCtxtFunArg -> Int -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: FunAppCtxtExpr :: HsExpr GhcRn -> HsExpr GhcRn -> FunAppCtxtFunArg

+ GHC.Tc.Types.ErrCtxt: FunAppCtxtTy :: LHsType GhcRn -> LHsType GhcRn -> FunAppCtxtFunArg

+ GHC.Tc.Types.ErrCtxt: FunResCtxt :: HsExpr GhcTc -> Int -> Type -> Type -> Int -> Int -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: FunTysCtxt :: ExpectedFunTyOrigin -> Type -> Int -> Int -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: InferredTypeCtxt :: Name -> TcType -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: InstDeclErrCtxt :: Either (LHsType GhcRn) PredType -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: KindCtxt :: LHsKind GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: MainCtxt :: Name -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: MatchCtxt :: HsMatchContextRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: MatchInCtxt :: Match GhcRn body -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: MergeSignaturesCtxt :: UnitState -> ModuleName -> [InstantiatedModule] -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: MethSigCtxt :: Name -> TcType -> TcType -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: PatCtxt :: Pat GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: PatMonoBindsCtxt :: LPat (GhcPass p) -> GRHSs GhcRn (LHsExpr GhcRn) -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: PatSigErrCtxt :: TcType -> TcType -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: PatSynDeclCtxt :: Name -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: PatSynExportCtxt :: PatSyn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: PatSynRecSelExportCtxt :: PatSyn -> Name -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: QuantifiedCtCtxt :: PredType -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: RecordUpdCtxt :: NonEmpty ConLike -> [Name] -> [TyCoVar] -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: ReifyInstancesCtxt :: Name -> [Type] -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: RoleAnnotErrCtxt :: Name -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: RuleCtxt :: FastString -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: SigCtxt :: Sig GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: SpecPragmaCtxt :: Sig GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: StandaloneDerivCtxt :: LHsSigWcType GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: StaticFormCtxt :: LHsExpr GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: StmtErrCtxt :: HsStmtContextRn -> StmtLR GhcRn GhcRn body -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: SubTypeCtxt :: TcType -> TcType -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: SyntaxNameCtxt :: HsExpr GhcRn -> CtOrigin -> TcType -> SrcSpan -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: TermLevelUseCtxt :: Name -> TermLevelUseCtxt -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: ThetaCtxt :: UserTypeCtxt -> ThetaType -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: TyConDeclCtxt :: Name -> TyConFlavour TyCon -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: TyConInstCtxt :: Name -> TyConInstFlavour -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: TyConInstFlavour :: TyConFlavour TyCon -> Bool -> TyConInstFlavour

+ GHC.Tc.Types.ErrCtxt: TySynErrCtxt :: TyCon -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: TypeCtxt :: LHsType GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: TypedSpliceCtxt :: Maybe SplicePointName -> HsTypedSplice (GhcPass p) -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: TypedSpliceResultCtxt :: LHsExpr GhcTc -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: TypedTHBracketCtxt :: LHsExpr (GhcPass p) -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: UntypedSpliceCtxt :: HsUntypedSplice GhcPs -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: UntypedTHBracketCtxt :: HsQuote GhcPs -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: UserLHsSigType :: LHsSigType p -> UserSigType p

+ GHC.Tc.Types.ErrCtxt: UserLHsType :: LHsType p -> UserSigType p

+ GHC.Tc.Types.ErrCtxt: UserSigCtxt :: UserTypeCtxt -> UserSigType GhcRn -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: VDQWarningCtxt :: TcTyCon -> ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: [ddec_in_type_list] :: ErrCtxtMsg -> Bool

+ GHC.Tc.Types.ErrCtxt: [tyConInstFlavour] :: TyConInstFlavour -> TyConFlavour TyCon

+ GHC.Tc.Types.ErrCtxt: [tyConInstIsDefault] :: TyConInstFlavour -> Bool

+ GHC.Tc.Types.ErrCtxt: data ErrCtxtMsg

+ GHC.Tc.Types.ErrCtxt: data FunAppCtxtFunArg

+ GHC.Tc.Types.ErrCtxt: data TyConInstFlavour

+ GHC.Tc.Types.ErrCtxt: data UserSigType p

+ GHC.Tc.Types.ErrCtxt: instance GHC.Hs.Extension.OutputableBndrId p => GHC.Utils.Outputable.Outputable (GHC.Tc.Types.ErrCtxt.UserSigType (GHC.Hs.Extension.GhcPass p))

+ GHC.Tc.Types.Evidence: evCastE :: EvExpr -> TcCoercion -> EvExpr

+ GHC.Tc.Types.Evidence: evDelayedError :: Type -> String -> EvTerm

+ GHC.Tc.Types.Evidence: evDictApp :: Class -> [Type] -> [EvExpr] -> EvTerm

+ GHC.Tc.Types.Evidence: evExprCoercion :: EvExpr -> TcCoercion

+ GHC.Tc.Types.Evidence: evExprCoercion_maybe :: EvExpr -> Maybe TcCoercion

+ GHC.Tc.Types.Evidence: evTermFVs :: EvTerm -> FV

+ GHC.Tc.Types.Evidence: evUnaryDictAppE :: Class -> [Type] -> EvExpr -> EvExpr

+ GHC.Tc.Types.Evidence: evUnwrapIPE :: PredType -> EvExpr -> EvExpr

+ GHC.Tc.Types.Evidence: evWrapIPE :: PredType -> EvExpr -> EvExpr

+ GHC.Tc.Types.Evidence: instance GHC.Internal.Data.Data.Data GHC.Tc.Types.Evidence.EvBind

+ GHC.Tc.Types.Evidence: nestedEvIdsOfTerm :: EvTerm -> VarSet

+ GHC.Tc.Types.Evidence: unionEvBindMap :: EvBindMap -> EvBindMap -> EvBindMap

+ GHC.Tc.Types.LclEnv: getLclEnvThLevel :: TcLclEnv -> ThLevel

+ GHC.Tc.Types.LclEnv: setLclEnvThLevel :: ThLevel -> TcLclEnv -> TcLclEnv

+ GHC.Tc.Types.Origin: DerivOrigin :: StandaloneDeriv -> CtOrigin

+ GHC.Tc.Types.Origin: FRRDeepSubsumption :: Bool -> Position p -> FixedRuntimeRepContext

+ GHC.Tc.Types.Origin: GetFieldOrigin :: FastString -> CtOrigin

+ GHC.Tc.Types.Origin: HsImplicitLiftSplice :: Set ThLevelIndex -> ThLevelIndex -> Maybe GlobalRdrElt -> LIdOccP GhcRn -> HsImplicitLiftSplice

+ GHC.Tc.Types.Origin: ImplicitLiftOrigin :: HsImplicitLiftSplice -> CtOrigin

+ GHC.Tc.Types.Origin: MethSkol :: Name -> Bool -> SkolemInfoAnon

+ GHC.Tc.Types.Origin: RuleBndrTypeCtxt :: Name -> UserTypeCtxt

+ GHC.Tc.Types.Origin: SpecESkol :: Name -> SkolemInfoAnon

+ GHC.Tc.Types.Origin: [frrDSExpected] :: FixedRuntimeRepContext -> Bool

+ GHC.Tc.Types.Origin: [frrDSPosition] :: FixedRuntimeRepContext -> Position p

+ GHC.Tc.Types.Origin: [implicit_lift_bind_lvl] :: HsImplicitLiftSplice -> Set ThLevelIndex

+ GHC.Tc.Types.Origin: [implicit_lift_gre] :: HsImplicitLiftSplice -> Maybe GlobalRdrElt

+ GHC.Tc.Types.Origin: [implicit_lift_lid] :: HsImplicitLiftSplice -> LIdOccP GhcRn

+ GHC.Tc.Types.Origin: [implicit_lift_used_lvl] :: HsImplicitLiftSplice -> ThLevelIndex

+ GHC.Tc.Types.Origin: data HsImplicitLiftSplice

+ GHC.Tc.Types.Origin: instance GHC.Internal.Classes.Eq GHC.Tc.Types.Origin.ReportRedundantConstraints

+ GHC.Tc.Types.Origin: instance GHC.Internal.Classes.Eq GHC.Tc.Types.Origin.UserTypeCtxt

+ GHC.Tc.Types.Origin: instance GHC.Internal.Show.Show (GHC.Tc.Types.Origin.Position p)

+ GHC.Tc.Types.Origin: instance GHC.Utils.Outputable.Outputable (GHC.Tc.Types.Origin.Position p)

+ GHC.Tc.Types.Origin: isPushCallStackOrigin_maybe :: CtOrigin -> Maybe FastString

+ GHC.Tc.Types.Origin: mkArgPos :: forall (p :: Polarity). Int -> Position p -> Position (FlipPolarity p)

+ GHC.Tc.Types.Origin: pprCtOriginBriefly :: CtOrigin -> SDoc

+ GHC.Tc.Types.Origin: type StandaloneDeriv = Bool

+ GHC.Tc.Types.TH: RnPending :: TcRef [PendingRnSplice] -> PendingStuff

+ GHC.Tc.Types.TH: data ThLevel

+ GHC.Tc.Types.TH: data ThLevelIndex

+ GHC.Tc.Types.TH: instance GHC.Utils.Outputable.Outputable GHC.Tc.Types.TH.ThLevel

+ GHC.Tc.Types.TH: pattern TypedBrack :: ThLevel -> ThLevel

+ GHC.Tc.Types.TH: pattern UntypedBrack :: ThLevel -> TcRef [PendingRnSplice] -> ThLevel

+ GHC.Tc.Types.TH: quoteLevelIndex :: ThLevelIndex

+ GHC.Tc.Types.TH: spliceLevelIndex :: ThLevelIndex

+ GHC.Tc.Types.TH: thLevelIndex :: ThLevel -> ThLevelIndex

+ GHC.Tc.Types.TH: thLevelIndexFromImportLevel :: ImportLevel -> ThLevelIndex

+ GHC.Tc.Types.TH: topAnnLevel :: ThLevel

+ GHC.Tc.Types.TH: topLevel :: ThLevel

+ GHC.Tc.Types.TH: topLevelIndex :: ThLevelIndex

+ GHC.Tc.Types.TH: topSpliceLevel :: ThLevel

+ GHC.Tc.Utils.Env: LevelCheckInstance :: InstanceWhat -> PredType -> LevelCheckReason

+ GHC.Tc.Utils.Env: LevelCheckSplice :: Name -> Maybe GlobalRdrElt -> LevelCheckReason

+ GHC.Tc.Utils.Env: data LevelCheckReason

+ GHC.Tc.Utils.Env: failIllegalTyVar :: WithUserRdr Name -> TcM a

+ GHC.Tc.Utils.Env: isBrackLevel :: ThLevel -> Bool

+ GHC.Tc.Utils.Env: thLevelIndex :: ThLevel -> ThLevelIndex

+ GHC.Tc.Utils.Monad: addTcEvBinds :: EvBindsVar -> EvBindMap -> TcM ()

+ GHC.Tc.Utils.Monad: checkJustTc :: TcRnMessage -> Maybe a -> TcM a

+ GHC.Tc.Utils.Monad: checkJustTcM :: (TidyEnv, TcRnMessage) -> Maybe a -> TcM a

+ GHC.Tc.Utils.Monad: ensureReflMultiplicityCo :: TcCoercion -> CtOrigin -> TcM ()

+ GHC.Tc.Utils.Monad: getCurrentAndBindLevel :: Name -> TcRn (Maybe (TopLevelFlag, Set ThLevelIndex, ThLevel))

+ GHC.Tc.Utils.Monad: getThLevel :: TcM ThLevel

+ GHC.Tc.Utils.Monad: mkErrCtxt :: TidyEnv -> [ErrCtxt] -> TcM [ErrCtxtMsg]

+ GHC.Tc.Utils.Monad: setThLevel :: ThLevel -> TcM a -> TcRn a

+ GHC.Tc.Utils.Monad: setWOptM :: WarningFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

+ GHC.Tc.Utils.Monad: tryTcDiscardingErrs' :: (WantedConstraints -> Messages TcRnMessage -> r -> Bool) -> TcM r -> TcM r -> TcM r -> TcM r

+ GHC.Tc.Utils.Monad: updTcEvBinds :: EvBindsVar -> EvBindsVar -> TcM ()

+ GHC.Tc.Utils.Monad: updTopEnvIO :: (HscEnv -> IO HscEnv) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

+ GHC.Tc.Utils.TcMType: runInfer :: InferInstFlag -> InferFRRFlag -> (ExpSigmaType -> TcM a) -> TcM (a, TcSigmaType)

+ GHC.Tc.Utils.TcMType: runInferKind :: (ExpSigmaType -> TcM a) -> TcM (a, TcSigmaType)

+ GHC.Tc.Utils.TcMType: runInferRho :: (ExpRhoType -> TcM a) -> TcM (a, TcRhoType)

+ GHC.Tc.Utils.TcMType: runInferRhoFRR :: FixedRuntimeRepContext -> (ExpRhoTypeFRR -> TcM a) -> TcM (a, TcRhoTypeFRR)

+ GHC.Tc.Utils.TcMType: runInferSigma :: (ExpSigmaType -> TcM a) -> TcM (a, TcSigmaType)

+ GHC.Tc.Utils.TcMType: runInferSigmaFRR :: FixedRuntimeRepContext -> (ExpSigmaTypeFRR -> TcM a) -> TcM (a, TcSigmaTypeFRR)

+ GHC.Tc.Utils.TcMType: weedOutCandidates :: (DTyVarSet -> DTyVarSet) -> CandidatesQTvs -> CandidatesQTvs

+ GHC.Tc.Utils.TcType: IFRR_Any :: InferFRRFlag

+ GHC.Tc.Utils.TcType: IFRR_Check :: FixedRuntimeRepContext -> InferFRRFlag

+ GHC.Tc.Utils.TcType: IIF_DeepRho :: InferInstFlag

+ GHC.Tc.Utils.TcType: IIF_ShallowRho :: InferInstFlag

+ GHC.Tc.Utils.TcType: IIF_Sigma :: InferInstFlag

+ GHC.Tc.Utils.TcType: [ir_inst] :: InferResult -> InferInstFlag

+ GHC.Tc.Utils.TcType: concreteInfo_maybe :: MetaInfo -> Maybe ConcreteTvOrigin

+ GHC.Tc.Utils.TcType: couldBeIPLike :: Type -> Bool

+ GHC.Tc.Utils.TcType: data InferFRRFlag

+ GHC.Tc.Utils.TcType: data InferInstFlag

+ GHC.Tc.Utils.TcType: isAnyTy :: Type -> Bool

+ GHC.Tc.Utils.TcType: isEqClassPred :: PredType -> Bool

+ GHC.Tc.Utils.TcType: isSimplePredTy :: HasDebugCallStack => Type -> Bool

+ GHC.Tc.Utils.TcType: isZonkAnyTy :: Type -> Bool

+ GHC.Tc.Utils.TcType: pSizeHead :: PredType -> PatersonSize

+ GHC.Tc.Utils.TcType: substInScopeSet :: Subst -> InScopeSet

+ GHC.Tc.Utils.TcType: type ExpRhoTypeFRR = ExpTypeFRR

+ GHC.Tc.Utils.TcType: type TcRhoTypeFRR = TcRhoType

+ GHC.Tc.Utils.Unify: SUC_CanUnify :: SimpleUnifyResult

+ GHC.Tc.Utils.Unify: SUC_CannotUnify :: SimpleUnifyResult

+ GHC.Tc.Utils.Unify: SUC_NotSure :: SimpleUnifyResult

+ GHC.Tc.Utils.Unify: TEFTyFam :: CheckTyEqProblem -> TyCon -> [Type] -> TyEqFamApp m a -> TyEqFlags (m :: Type -> Type) a

+ GHC.Tc.Utils.Unify: TEFTyVar :: OccursCheck -> LevelCheck m -> ConcreteCheck m -> TyEqFamApp m a -> TyEqFlags (m :: Type -> Type) a

+ GHC.Tc.Utils.Unify: [BreakGiven] :: FamAppBreaker (TcTyVar, TcType)

+ GHC.Tc.Utils.Unify: [BreakWanted] :: CtEvidence -> TcTyVar -> FamAppBreaker Ct

+ GHC.Tc.Utils.Unify: [CC_Check] :: forall (m :: Type -> Type). ConcreteCheck m

+ GHC.Tc.Utils.Unify: [CC_None] :: forall (m :: Type -> Type). ConcreteCheck m

+ GHC.Tc.Utils.Unify: [CC_Promote] :: ConcreteTvOrigin -> ConcreteCheck (IOEnv (Env TcGblEnv TcLclEnv))

+ GHC.Tc.Utils.Unify: [LC_Check] :: forall (m :: Type -> Type). TcLevel -> Bool -> LevelCheck m

+ GHC.Tc.Utils.Unify: [LC_None] :: forall (m :: Type -> Type). LevelCheck m

+ GHC.Tc.Utils.Unify: [LC_Promote] :: TcLevel -> Bool -> LevelCheck (IOEnv (Env TcGblEnv TcLclEnv))

+ GHC.Tc.Utils.Unify: [OC_Check] :: Name -> CheckTyEqProblem -> OccursCheck

+ GHC.Tc.Utils.Unify: [OC_None] :: OccursCheck

+ GHC.Tc.Utils.Unify: [TEFA_Break] :: forall a. FamAppBreaker a -> TyEqFamApp (IOEnv (Env TcGblEnv TcLclEnv)) a

+ GHC.Tc.Utils.Unify: [TEFA_Recurse] :: forall (m :: Type -> Type) a. TyEqFamApp m a

+ GHC.Tc.Utils.Unify: [tefTyFam_args] :: TyEqFlags (m :: Type -> Type) a -> [Type]

+ GHC.Tc.Utils.Unify: [tefTyFam_occursCheck] :: TyEqFlags (m :: Type -> Type) a -> CheckTyEqProblem

+ GHC.Tc.Utils.Unify: [tefTyFam_tyCon] :: TyEqFlags (m :: Type -> Type) a -> TyCon

+ GHC.Tc.Utils.Unify: [tefTyVar_concreteCheck] :: TyEqFlags (m :: Type -> Type) a -> ConcreteCheck m

+ GHC.Tc.Utils.Unify: [tefTyVar_levelCheck] :: TyEqFlags (m :: Type -> Type) a -> LevelCheck m

+ GHC.Tc.Utils.Unify: [tefTyVar_occursCheck] :: TyEqFlags (m :: Type -> Type) a -> OccursCheck

+ GHC.Tc.Utils.Unify: addSubTypeCtxt :: TcType -> ExpType -> TcM a -> TcM a

+ GHC.Tc.Utils.Unify: data ConcreteCheck (m :: Type -> Type)

+ GHC.Tc.Utils.Unify: data FamAppBreaker a

+ GHC.Tc.Utils.Unify: data OccursCheck

+ GHC.Tc.Utils.Unify: data SimpleUnifyResult

+ GHC.Tc.Utils.Unify: defaulting_TEFTask :: TcTyVar -> TyEqFlags TcM a

+ GHC.Tc.Utils.Unify: dsInstantiate :: CtOrigin -> TcType -> TcM (HsWrapper, Type)

+ GHC.Tc.Utils.Unify: fillInferResultNoInst :: TcType -> InferResult -> TcM TcCoercionN

+ GHC.Tc.Utils.Unify: instance GHC.Internal.Base.Monoid (GHC.Tc.Utils.Unify.TyVarCheckResult m)

+ GHC.Tc.Utils.Unify: instance GHC.Internal.Base.Semigroup (GHC.Tc.Utils.Unify.TyVarCheckResult m)

+ GHC.Tc.Utils.Unify: instance GHC.Internal.Base.Semigroup GHC.Tc.Utils.Unify.SimpleUnifyResult

+ GHC.Tc.Utils.Unify: instance GHC.Internal.Classes.Eq GHC.Tc.Utils.Unify.SimpleUnifyResult

+ GHC.Tc.Utils.Unify: instance GHC.Internal.Classes.Ord GHC.Tc.Utils.Unify.SimpleUnifyResult

+ GHC.Tc.Utils.Unify: instance GHC.Internal.Data.Foldable.Foldable (GHC.Tc.Utils.Unify.PuResult a)

+ GHC.Tc.Utils.Unify: instance GHC.Internal.Data.Traversable.Traversable (GHC.Tc.Utils.Unify.PuResult a)

+ GHC.Tc.Utils.Unify: instance GHC.Internal.Show.Show GHC.Tc.Utils.Unify.SimpleUnifyResult

+ GHC.Tc.Utils.Unify: instance GHC.Utils.Outputable.Outputable (GHC.Tc.Utils.Unify.ConcreteCheck m)

+ GHC.Tc.Utils.Unify: instance GHC.Utils.Outputable.Outputable (GHC.Tc.Utils.Unify.FamAppBreaker a)

+ GHC.Tc.Utils.Unify: instance GHC.Utils.Outputable.Outputable (GHC.Tc.Utils.Unify.LevelCheck m)

+ GHC.Tc.Utils.Unify: instance GHC.Utils.Outputable.Outputable (GHC.Tc.Utils.Unify.TyEqFamApp m a)

+ GHC.Tc.Utils.Unify: instance GHC.Utils.Outputable.Outputable (GHC.Tc.Utils.Unify.TyEqFlags m a)

+ GHC.Tc.Utils.Unify: instance GHC.Utils.Outputable.Outputable GHC.Tc.Utils.Unify.OccursCheck

+ GHC.Tc.Utils.Unify: instance GHC.Utils.Outputable.Outputable GHC.Tc.Utils.Unify.SimpleUnifyResult

+ GHC.Tc.Utils.Unify: makeTypeConcrete :: FastString -> ConcreteTvOrigin -> TcType -> TcM (TcCoercion, Cts)

+ GHC.Tc.Utils.Unify: mightEqualLater :: InertSet -> TcPredType -> CtLoc -> TcPredType -> CtLoc -> Maybe Subst

+ GHC.Tc.Utils.Unify: mkTEFA_Break :: CtEvidence -> EqRel -> FamAppBreaker a -> TyEqFamApp TcM a

+ GHC.Tc.Utils.Unify: notUnifying_TEFTask :: forall (m :: Type -> Type) a. CheckTyEqProblem -> CanEqLHS -> TyEqFlags m a

+ GHC.Tc.Utils.Unify: pureTyEqFlags_LHSMetaTyVar :: TyVar -> TyEqFlags Identity ()

+ GHC.Tc.Utils.Unify: recurseIntoFamTyConApp :: Monad m => TyEqFlags m a -> TyCon -> [TcType] -> m (PuResult a Reduction)

+ GHC.Tc.Utils.Unify: touchabilityTest :: TcLevel -> TcTyVar -> Bool

+ GHC.Tc.Utils.Unify: unifyingLHSMetaTyVar_TEFTask :: CtEvidence -> TcTyVar -> TyEqFlags TcM Ct

+ GHC.Tc.Validity: RuleBndrTypeCtxt :: Name -> UserTypeCtxt

+ GHC.Tc.Validity: instance GHC.Internal.Classes.Eq GHC.Tc.Validity.TypeOrKindCtxt

+ GHC.Tc.Zonk.TcType: instance GHC.Internal.Base.Monoid GHC.Tc.Zonk.TcType.UnfilledCoercionHoleMonoid

+ GHC.Tc.Zonk.TcType: instance GHC.Internal.Base.Semigroup GHC.Tc.Zonk.TcType.UnfilledCoercionHoleMonoid

+ GHC.Tc.Zonk.TcType: isFilledCoercionHole :: CoercionHole -> ZonkM Bool

+ GHC.Tc.Zonk.TcType: unpackCoercionHole :: CoercionHole -> ZonkM Coercion

+ GHC.Tc.Zonk.TcType: unpackCoercionHole_maybe :: CoercionHole -> ZonkM (Maybe Coercion)

+ GHC.Tc.Zonk.TcType: zonkCtEvRewriterSet :: CtEvidence -> ZonkM CtEvidence

+ GHC.Tc.Zonk.TcType: zonkCtRewriterSet :: Ct -> ZonkM Ct

+ GHC.Tc.Zonk.TcType: zonkRewriterSet :: RewriterSet -> ZonkM RewriterSet

+ GHC.Types.Annotations: instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (GHC.Types.Annotations.AnnTarget name)

+ GHC.Types.Avail: [getDetOrdAvails] :: DetOrdAvails -> Avails

+ GHC.Types.Avail: emptyDetOrdAvails :: DetOrdAvails

+ GHC.Types.Avail: instance GHC.Internal.Classes.Eq GHC.Types.Avail.DetOrdAvails

+ GHC.Types.Avail: instance GHC.Internal.Classes.Ord GHC.Types.Avail.DetOrdAvails

+ GHC.Types.Basic: DataType :: NewOrData

+ GHC.Types.Basic: NewType :: NewOrData

+ GHC.Types.Basic: NormalLevel :: ImportLevel

+ GHC.Types.Basic: QuoteLevel :: ImportLevel

+ GHC.Types.Basic: SpliceLevel :: ImportLevel

+ GHC.Types.Basic: activeInInitialPhase :: Activation -> Bool

+ GHC.Types.Basic: allImportLevels :: [ImportLevel]

+ GHC.Types.Basic: convImportLevel :: ImportDeclLevelStyle -> ImportLevel

+ GHC.Types.Basic: convImportLevelSpec :: ImportDeclLevel -> ImportLevel

+ GHC.Types.Basic: data ImportLevel

+ GHC.Types.Basic: data NewOrData

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.Activation

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.CbvMark

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.FunctionOrData

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.InlinePragma

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.InlineSpec

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.LeftOrRight

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.OverlapFlag

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.OverlapMode

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.RuleMatchInfo

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.TupleSort

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.TypeOrConstraint

+ GHC.Types.Basic: instance Control.DeepSeq.NFData GHC.Types.Basic.UnfoldingSource

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.Activation

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.Alignment

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.CbvMark

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.CompilerPhase

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.DoPmc

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.FunctionOrData

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.GenReason

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.ImportLevel

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.InlinePragma

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.InlineSpec

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.InsideLam

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.IntWithInf

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.InterestingCxt

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.LeftOrRight

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.Levity

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.NewOrData

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.OccInfo

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.OneShotInfo

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.Origin

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.OverlapFlag

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.OverlapMode

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.PprPrec

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.RecFlag

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.RuleMatchInfo

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.SwapFlag

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.TailCallInfo

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.TupleSort

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.TypeOrConstraint

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.TypeOrData

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.TypeOrKind

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq GHC.Types.Basic.UnboxedTupleOrSum

+ GHC.Types.Basic: instance GHC.Internal.Classes.Eq tc => GHC.Internal.Classes.Eq (GHC.Types.Basic.TyConFlavour tc)

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.Alignment

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.FunctionOrData

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.ImportLevel

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.IntWithInf

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.LeftOrRight

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.Levity

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.PprPrec

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.TupleSort

+ GHC.Types.Basic: instance GHC.Internal.Classes.Ord GHC.Types.Basic.TypeOrConstraint

+ GHC.Types.Basic: instance GHC.Internal.Data.Data.Data GHC.Types.Basic.ImportLevel

+ GHC.Types.Basic: instance GHC.Internal.Data.Data.Data GHC.Types.Basic.NewOrData

+ GHC.Types.Basic: instance GHC.Internal.Enum.Bounded GHC.Types.Basic.ImportLevel

+ GHC.Types.Basic: instance GHC.Internal.Enum.Enum GHC.Types.Basic.ImportLevel

+ GHC.Types.Basic: instance GHC.Internal.Show.Show GHC.Types.Basic.ImportLevel

+ GHC.Types.Basic: instance GHC.Utils.Binary.Binary GHC.Types.Basic.ImportLevel

+ GHC.Types.Basic: instance GHC.Utils.Binary.Binary GHC.Types.Basic.TypeOrConstraint

+ GHC.Types.Basic: instance GHC.Utils.Outputable.Outputable GHC.Types.Basic.ImportLevel

+ GHC.Types.Basic: instance GHC.Utils.Outputable.Outputable GHC.Types.Basic.NewOrData

+ GHC.Types.CompleteMatch: instance GHC.Internal.Classes.Eq (GHC.Types.CompleteMatch.CompleteMatchX con)

+ GHC.Types.CostCentre: instance Control.DeepSeq.NFData GHC.Types.CostCentre.CCFlavour

+ GHC.Types.CostCentre: instance Control.DeepSeq.NFData GHC.Types.CostCentre.CostCentre

+ GHC.Types.CostCentre: instance Control.DeepSeq.NFData GHC.Types.CostCentre.IndexedCCFlavour

+ GHC.Types.CostCentre: instance GHC.Internal.Classes.Eq GHC.Types.CostCentre.CCFlavour

+ GHC.Types.CostCentre: instance GHC.Internal.Classes.Eq GHC.Types.CostCentre.CostCentre

+ GHC.Types.CostCentre: instance GHC.Internal.Classes.Eq GHC.Types.CostCentre.CostCentreStack

+ GHC.Types.CostCentre: instance GHC.Internal.Classes.Eq GHC.Types.CostCentre.IndexedCCFlavour

+ GHC.Types.CostCentre: instance GHC.Internal.Classes.Ord GHC.Types.CostCentre.CCFlavour

+ GHC.Types.CostCentre: instance GHC.Internal.Classes.Ord GHC.Types.CostCentre.CostCentre

+ GHC.Types.CostCentre: instance GHC.Internal.Classes.Ord GHC.Types.CostCentre.CostCentreStack

+ GHC.Types.CostCentre: instance GHC.Internal.Classes.Ord GHC.Types.CostCentre.IndexedCCFlavour

+ GHC.Types.CostCentre.State: instance Control.DeepSeq.NFData GHC.Types.CostCentre.State.CostCentreIndex

+ GHC.Types.CostCentre.State: instance GHC.Internal.Classes.Eq GHC.Types.CostCentre.State.CostCentreIndex

+ GHC.Types.CostCentre.State: instance GHC.Internal.Classes.Ord GHC.Types.CostCentre.State.CostCentreIndex

+ GHC.Types.Cpr: instance GHC.Internal.Classes.Eq GHC.Types.Cpr.Cpr

+ GHC.Types.Cpr: instance GHC.Internal.Classes.Eq GHC.Types.Cpr.CprSig

+ GHC.Types.Cpr: instance GHC.Internal.Classes.Eq GHC.Types.Cpr.CprType

+ GHC.Types.DefaultEnv: DP_Builtin :: DefaultProvenance

+ GHC.Types.DefaultEnv: DP_Imported :: Module -> DefaultProvenance

+ GHC.Types.DefaultEnv: DP_Local :: SrcSpan -> Bool -> DefaultProvenance

+ GHC.Types.DefaultEnv: [cd_provenance] :: ClassDefaults -> DefaultProvenance

+ GHC.Types.DefaultEnv: [defaultDeclH98] :: DefaultProvenance -> Bool

+ GHC.Types.DefaultEnv: [defaultDeclLoc] :: DefaultProvenance -> SrcSpan

+ GHC.Types.DefaultEnv: data DefaultProvenance

+ GHC.Types.DefaultEnv: insertDefaultEnv :: ClassDefaults -> DefaultEnv -> DefaultEnv

+ GHC.Types.DefaultEnv: instance GHC.Internal.Classes.Eq GHC.Types.DefaultEnv.DefaultProvenance

+ GHC.Types.DefaultEnv: instance GHC.Internal.Data.Data.Data GHC.Types.DefaultEnv.DefaultProvenance

+ GHC.Types.DefaultEnv: instance GHC.Utils.Outputable.Outputable GHC.Types.DefaultEnv.DefaultProvenance

+ GHC.Types.DefaultEnv: isHaskell2010Default :: DefaultProvenance -> Bool

+ GHC.Types.Demand: instance GHC.Internal.Classes.Eq GHC.Types.Demand.Card

+ GHC.Types.Demand: instance GHC.Internal.Classes.Eq GHC.Types.Demand.Demand

+ GHC.Types.Demand: instance GHC.Internal.Classes.Eq GHC.Types.Demand.Divergence

+ GHC.Types.Demand: instance GHC.Internal.Classes.Eq GHC.Types.Demand.DmdEnv

+ GHC.Types.Demand: instance GHC.Internal.Classes.Eq GHC.Types.Demand.DmdSig

+ GHC.Types.Demand: instance GHC.Internal.Classes.Eq GHC.Types.Demand.DmdType

+ GHC.Types.Demand: instance GHC.Internal.Classes.Eq GHC.Types.Demand.SubDemand

+ GHC.Types.Error: -- <a>GhcHint</a>.

+ GHC.Types.Error: SuggestDataKeyword :: GhcHint

+ GHC.Types.Error: SuggestSplittingIntoSeveralSpecialisePragmas :: GhcHint

+ GHC.Types.Error: instance (GHC.Types.Error.HasDefaultDiagnosticOpts opts, GHC.Utils.Outputable.Outputable hint) => GHC.Types.Error.Diagnostic (GHC.Types.Error.UnknownDiagnostic opts hint)

+ GHC.Types.Error: instance GHC.Internal.Classes.Eq GHC.Types.Error.DiagnosticCode

+ GHC.Types.Error: instance GHC.Internal.Classes.Eq GHC.Types.Error.DiagnosticReason

+ GHC.Types.Error: instance GHC.Internal.Classes.Eq GHC.Types.Error.Severity

+ GHC.Types.Error: instance GHC.Internal.Classes.Ord GHC.Types.Error.DiagnosticCode

+ GHC.Types.Error: instance GHC.Internal.Classes.Ord GHC.Types.Error.Severity

+ GHC.Types.Error: type DiagnosticHint a = GhcHint;

+ GHC.Types.Error: type UnknownDiagnosticFor a = UnknownDiagnostic DiagnosticOpts a DiagnosticHint a

+ GHC.Types.Error.Codes: -- order to obtain a diagnostic code. See Note [Diagnostic codes].

+ GHC.Types.Error.Codes: -- | Specify that one should recur into an argument of a constructor in

+ GHC.Types.Error.Codes: class DiagnosticCodeNameSpace namespace where {

+ GHC.Types.Error.Codes: data GHC

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.ConRecursIntoFor namespace con GHC.Internal.Types.~ 'GHC.Internal.Maybe.Just (GHC.Types.Error.UnknownDiagnostic opts hint)) => GHC.Types.Error.Codes.ConstructorCodes namespace con f seen ('GHC.Internal.Maybe.Just (GHC.Types.Error.UnknownDiagnostic opts hint))

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.ConRecursIntoFor namespace con GHC.Internal.Types.~ 'GHC.Internal.Maybe.Just (GHC.Types.Error.UnknownDiagnostic opts hint), GHC.Types.Error.Codes.HasType namespace (GHC.Types.Error.UnknownDiagnostic opts hint) con f) => GHC.Types.Error.Codes.ConstructorCode namespace con f ('GHC.Internal.Maybe.Just (GHC.Types.Error.UnknownDiagnostic opts hint))

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.ConRecursIntoFor namespace con GHC.Internal.Types.~ 'GHC.Internal.Maybe.Just ty, GHC.Types.Error.Codes.HasType namespace ty con f, GHC.Internal.Generics.Generic ty, GHC.Types.Error.Codes.GDiagnosticCode namespace (GHC.Internal.Generics.Rep ty)) => GHC.Types.Error.Codes.ConstructorCode namespace con f ('GHC.Internal.Maybe.Just ty)

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.ConRecursIntoFor namespace con GHC.Internal.Types.~ 'GHC.Internal.Maybe.Just ty, GHC.Types.Error.Codes.HasType namespace ty con f, GHC.Internal.Generics.Generic ty, GHC.Types.Error.Codes.GDiagnosticCodes namespace (GHC.Types.Error.Codes.Insert ty seen) (GHC.Internal.Generics.Rep ty), GHC.Types.Error.Codes.Seen seen ty) => GHC.Types.Error.Codes.ConstructorCodes namespace con f seen ('GHC.Internal.Maybe.Just ty)

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.ConstructorCode namespace con f recur, recur GHC.Internal.Types.~ GHC.Types.Error.Codes.ConRecursIntoFor namespace con, GHC.Internal.TypeLits.KnownSymbol con) => GHC.Types.Error.Codes.GDiagnosticCode namespace (GHC.Internal.Generics.M1 i ('GHC.Internal.Generics.MetaCons con x y) f)

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.ConstructorCodes namespace con f seen recur, recur GHC.Internal.Types.~ GHC.Types.Error.Codes.ConRecursIntoFor namespace con, GHC.Internal.TypeLits.KnownSymbol con) => GHC.Types.Error.Codes.GDiagnosticCodes namespace seen (GHC.Internal.Generics.M1 i ('GHC.Internal.Generics.MetaCons con x y) f)

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.GDiagnosticCode namespace f, GHC.Types.Error.Codes.GDiagnosticCode namespace g) => GHC.Types.Error.Codes.GDiagnosticCode namespace (f GHC.Internal.Generics.:+: g)

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.GDiagnosticCodes namespace seen f, GHC.Types.Error.Codes.GDiagnosticCodes namespace seen g) => GHC.Types.Error.Codes.GDiagnosticCodes namespace seen (f GHC.Internal.Generics.:+: g)

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.KnownNameSpace namespace, GHC.Types.Error.Codes.KnownConstructor namespace con, GHC.Internal.TypeLits.KnownSymbol con) => GHC.Types.Error.Codes.ConstructorCode namespace con f 'GHC.Internal.Maybe.Nothing

+ GHC.Types.Error.Codes: instance (GHC.Types.Error.Codes.KnownNameSpace namespace, GHC.Types.Error.Codes.KnownConstructor namespace con, GHC.Internal.TypeLits.KnownSymbol con) => GHC.Types.Error.Codes.ConstructorCodes namespace con f seen 'GHC.Internal.Maybe.Nothing

+ GHC.Types.Error.Codes: instance (TypeError ...) => GHC.Types.Error.Codes.HasType namespace ty orig f

+ GHC.Types.Error.Codes: instance GHC.Types.Error.Codes.DiagnosticCodeNameSpace GHC.Types.Error.Codes.GHC

+ GHC.Types.Error.Codes: instance GHC.Types.Error.Codes.GDiagnosticCode namespace f => GHC.Types.Error.Codes.GDiagnosticCode namespace (GHC.Internal.Generics.M1 i ('GHC.Internal.Generics.MetaData nm mod pkg nt) f)

+ GHC.Types.Error.Codes: instance GHC.Types.Error.Codes.GDiagnosticCodes namespace seen f => GHC.Types.Error.Codes.GDiagnosticCodes namespace seen (GHC.Internal.Generics.M1 i ('GHC.Internal.Generics.MetaData nm mod pkg nt) f)

+ GHC.Types.Error.Codes: instance GHC.Types.Error.Codes.HasType namespace ty orig (GHC.Internal.Generics.M1 i s (GHC.Internal.Generics.K1 x ty))

+ GHC.Types.Error.Codes: instance GHC.Types.Error.Codes.HasType namespace ty orig g => GHC.Types.Error.Codes.HasTypeProd namespace ty 'GHC.Internal.Maybe.Nothing orig f g

+ GHC.Types.Error.Codes: instance GHC.Types.Error.Codes.HasTypeProd namespace ty (GHC.Types.Error.Codes.HasTypeQ ty f) orig f g => GHC.Types.Error.Codes.HasType namespace ty orig (f GHC.Internal.Generics.:*: g)

+ GHC.Types.Error.Codes: instance forall a namespace ty (orig :: GHC.Internal.Types.Symbol) (f :: * -> *) (l :: a) (g :: * -> *). GHC.Types.Error.Codes.HasType namespace ty orig f => GHC.Types.Error.Codes.HasTypeProd namespace ty ('GHC.Internal.Maybe.Just l) orig f g

+ GHC.Types.Error.Codes: type ConRecursIntoFor namespace (c :: Symbol) :: Maybe Type;

+ GHC.Types.Error.Codes: type DiagnosticCodeFor namespace (c :: Symbol) :: Nat;

+ GHC.Types.Error.Codes: type NameSpaceTag namespace = (r :: Symbol) | r -> namespace;

+ GHC.Types.Error.Codes: type Outdated (a :: k) = a

+ GHC.Types.Error.Codes: }

+ GHC.Types.FieldLabel: instance GHC.Internal.Classes.Eq GHC.Types.FieldLabel.DuplicateRecordFields

+ GHC.Types.FieldLabel: instance GHC.Internal.Classes.Eq GHC.Types.FieldLabel.FieldLabel

+ GHC.Types.FieldLabel: instance GHC.Internal.Classes.Eq GHC.Types.FieldLabel.FieldSelectors

+ GHC.Types.ForeignCall: instance Control.DeepSeq.NFData GHC.Types.ForeignCall.CCallConv

+ GHC.Types.ForeignCall: instance Control.DeepSeq.NFData GHC.Types.ForeignCall.CCallSpec

+ GHC.Types.ForeignCall: instance Control.DeepSeq.NFData GHC.Types.ForeignCall.CCallTarget

+ GHC.Types.ForeignCall: instance Control.DeepSeq.NFData GHC.Types.ForeignCall.CType

+ GHC.Types.ForeignCall: instance Control.DeepSeq.NFData GHC.Types.ForeignCall.ForeignCall

+ GHC.Types.ForeignCall: instance Control.DeepSeq.NFData GHC.Types.ForeignCall.Header

+ GHC.Types.ForeignCall: instance Control.DeepSeq.NFData GHC.Types.ForeignCall.Safety

+ GHC.Types.ForeignCall: instance GHC.Internal.Classes.Eq GHC.Types.ForeignCall.CCallConv

+ GHC.Types.ForeignCall: instance GHC.Internal.Classes.Eq GHC.Types.ForeignCall.CCallSpec

+ GHC.Types.ForeignCall: instance GHC.Internal.Classes.Eq GHC.Types.ForeignCall.CCallTarget

+ GHC.Types.ForeignCall: instance GHC.Internal.Classes.Eq GHC.Types.ForeignCall.CType

+ GHC.Types.ForeignCall: instance GHC.Internal.Classes.Eq GHC.Types.ForeignCall.ForeignCall

+ GHC.Types.ForeignCall: instance GHC.Internal.Classes.Eq GHC.Types.ForeignCall.Header

+ GHC.Types.ForeignCall: instance GHC.Internal.Classes.Eq GHC.Types.ForeignCall.Safety

+ GHC.Types.ForeignCall: instance GHC.Internal.Show.Show GHC.Types.ForeignCall.CCallConv

+ GHC.Types.GREInfo: instance GHC.Internal.Classes.Eq GHC.Types.GREInfo.ConFieldInfo

+ GHC.Types.GREInfo: instance GHC.Internal.Classes.Eq GHC.Types.GREInfo.ConInfo

+ GHC.Types.GREInfo: instance GHC.Internal.Classes.Eq GHC.Types.GREInfo.ConLikeInfo

+ GHC.Types.GREInfo: instance GHC.Internal.Classes.Eq GHC.Types.GREInfo.ConLikeName

+ GHC.Types.GREInfo: instance GHC.Internal.Classes.Eq GHC.Types.GREInfo.RecFieldInfo

+ GHC.Types.GREInfo: instance GHC.Types.Name.NamedThing GHC.Types.GREInfo.ConLikeName

+ GHC.Types.Hint: CouldChangeImportItem :: ModuleName -> ImportItemSuggestion -> ImportSuggestion

+ GHC.Types.Hint: ImportItemAddType :: ImportItemSuggestion

+ GHC.Types.Hint: ImportItemRemoveData :: ImportItemSuggestion

+ GHC.Types.Hint: ImportItemRemovePattern :: ImportItemSuggestion

+ GHC.Types.Hint: ImportItemRemoveSubordinateData :: NonEmpty OccName -> ImportItemSuggestion

+ GHC.Types.Hint: ImportItemRemoveSubordinateType :: NonEmpty OccName -> ImportItemSuggestion

+ GHC.Types.Hint: ImportItemRemoveType :: ImportItemSuggestion

+ GHC.Types.Hint: SigLikeDeprecation :: SigLike

+ GHC.Types.Hint: SigLikeFixitySig :: SigLike

+ GHC.Types.Hint: SigLikeRoleAnnotation :: SigLike

+ GHC.Types.Hint: SigLikeSig :: Sig GhcPs -> SigLike

+ GHC.Types.Hint: SigLikeStandaloneKindSig :: SigLike

+ GHC.Types.Hint: SuggestDataKeyword :: GhcHint

+ GHC.Types.Hint: SuggestSplittingIntoSeveralSpecialisePragmas :: GhcHint

+ GHC.Types.Hint: [ies_suggest_data_keyword] :: ImportSuggestion -> Bool

+ GHC.Types.Hint: [ies_suggest_pattern_keyword] :: ImportSuggestion -> Bool

+ GHC.Types.Hint: data ImportItemSuggestion

+ GHC.Types.Hint: data SigLike

+ GHC.Types.Hint: instance GHC.Internal.Classes.Eq GHC.Types.Hint.AssumedDerivingStrategy

+ GHC.Types.Hint: instance GHC.Internal.Classes.Ord GHC.Types.Hint.AssumedDerivingStrategy

+ GHC.Types.Hint.Ppr: pprSigLike :: SigLike -> SDoc

+ GHC.Types.Id: dataConWrapUnfolding_maybe :: Id -> Maybe CoreExpr

+ GHC.Types.Id.Info: RSI :: [ConLike] -> [ConLike] -> RecSelInfo

+ GHC.Types.Id.Info: [rsi_def] :: RecSelInfo -> [ConLike]

+ GHC.Types.Id.Info: [rsi_undef] :: RecSelInfo -> [ConLike]

+ GHC.Types.Id.Info: conLikesRecSelInfo :: [ConLike] -> [FieldLabelString] -> RecSelInfo

+ GHC.Types.Id.Info: data RecSelInfo

+ GHC.Types.Id.Info: instance GHC.Internal.Classes.Eq GHC.Types.Id.Info.CafInfo

+ GHC.Types.Id.Info: instance GHC.Internal.Classes.Eq GHC.Types.Id.Info.RecSelParent

+ GHC.Types.Id.Info: instance GHC.Internal.Classes.Ord GHC.Types.Id.Info.CafInfo

+ GHC.Types.Id.Make: wrapNewTypeBody :: TyCon -> [Type] -> CoreExpr -> CoreExpr

+ GHC.Types.Literal: instance Control.DeepSeq.NFData GHC.Types.Literal.LitNumType

+ GHC.Types.Literal: instance Control.DeepSeq.NFData GHC.Types.Literal.Literal

+ GHC.Types.Literal: instance GHC.Internal.Classes.Eq GHC.Types.Literal.LitNumType

+ GHC.Types.Literal: instance GHC.Internal.Classes.Eq GHC.Types.Literal.Literal

+ GHC.Types.Literal: instance GHC.Internal.Classes.Ord GHC.Types.Literal.LitNumType

+ GHC.Types.Literal: instance GHC.Internal.Classes.Ord GHC.Types.Literal.Literal

+ GHC.Types.Meta: instance GHC.Utils.Outputable.Outputable GHC.Types.Meta.MetaResult

+ GHC.Types.Name: instance GHC.Internal.Classes.Eq GHC.Types.Name.Name

+ GHC.Types.Name: instance GHC.Internal.Classes.Ord GHC.Types.Name.Name

+ GHC.Types.Name: pprFullNameWithUnique :: Module -> Name -> SDoc

+ GHC.Types.Name: pprName_userQual :: IsLine doc => Maybe ModuleName -> Name -> doc

+ GHC.Types.Name.Cache: isKnownOrigName_maybe :: Module -> OccName -> Maybe Name

+ GHC.Types.Name.Cache: knownKeysOrigNameCache :: OrigNameCache

+ GHC.Types.Name.Cache: newNameCache :: IO NameCache

+ GHC.Types.Name.Cache: newNameCacheWith :: Char -> OrigNameCache -> IO NameCache

+ GHC.Types.Name.Occurrence: demoteOccTcClsName :: OccName -> Maybe OccName

+ GHC.Types.Name.Occurrence: instance GHC.Internal.Classes.Eq GHC.Types.Name.Occurrence.NameSpace

+ GHC.Types.Name.Occurrence: instance GHC.Internal.Classes.Eq GHC.Types.Name.Occurrence.OccName

+ GHC.Types.Name.Occurrence: instance GHC.Internal.Classes.Ord GHC.Types.Name.Occurrence.NameSpace

+ GHC.Types.Name.Occurrence: instance GHC.Internal.Classes.Ord GHC.Types.Name.Occurrence.OccName

+ GHC.Types.Name.Occurrence: sizeOccEnv :: OccEnv a -> Int

+ GHC.Types.Name.Reader: NormalLevel :: ImportLevel

+ GHC.Types.Name.Reader: ParentGRE :: Name -> GREInfo -> ParentGRE

+ GHC.Types.Name.Reader: QuoteLevel :: ImportLevel

+ GHC.Types.Name.Reader: SpliceLevel :: ImportLevel

+ GHC.Types.Name.Reader: WithUserRdr :: RdrName -> a -> WithUserRdr a

+ GHC.Types.Name.Reader: [is_level] :: ImpDeclSpec -> ImportLevel

+ GHC.Types.Name.Reader: [parentGRE_info] :: ParentGRE -> GREInfo

+ GHC.Types.Name.Reader: [parentGRE_name] :: ParentGRE -> Name

+ GHC.Types.Name.Reader: data ImportLevel

+ GHC.Types.Name.Reader: data ParentGRE

+ GHC.Types.Name.Reader: data WithUserRdr a

+ GHC.Types.Name.Reader: demoteRdrNameTcCls :: RdrName -> Maybe RdrName

+ GHC.Types.Name.Reader: greLevels :: GlobalRdrEltX info -> Set ImportLevel

+ GHC.Types.Name.Reader: importSpecLevel :: ImportSpec -> ImportLevel

+ GHC.Types.Name.Reader: instance GHC.Internal.Base.Functor GHC.Types.Name.Reader.WithUserRdr

+ GHC.Types.Name.Reader: instance GHC.Internal.Classes.Eq GHC.Types.Name.Reader.FieldsOrSelectors

+ GHC.Types.Name.Reader: instance GHC.Internal.Classes.Eq GHC.Types.Name.Reader.ImpDeclSpec

+ GHC.Types.Name.Reader: instance GHC.Internal.Classes.Eq GHC.Types.Name.Reader.ImpItemSpec

+ GHC.Types.Name.Reader: instance GHC.Internal.Classes.Eq GHC.Types.Name.Reader.ImportSpec

+ GHC.Types.Name.Reader: instance GHC.Internal.Classes.Eq GHC.Types.Name.Reader.Parent

+ GHC.Types.Name.Reader: instance GHC.Internal.Classes.Eq GHC.Types.Name.Reader.ParentGRE

+ GHC.Types.Name.Reader: instance GHC.Internal.Classes.Eq GHC.Types.Name.Reader.RdrName

+ GHC.Types.Name.Reader: instance GHC.Internal.Classes.Ord GHC.Types.Name.Reader.RdrName

+ GHC.Types.Name.Reader: instance GHC.Internal.Data.Foldable.Foldable GHC.Types.Name.Reader.WithUserRdr

+ GHC.Types.Name.Reader: instance GHC.Internal.Data.Traversable.Traversable GHC.Types.Name.Reader.WithUserRdr

+ GHC.Types.Name.Reader: instance GHC.Types.Name.NamedThing a => GHC.Types.Name.NamedThing (GHC.Types.Name.Reader.WithUserRdr a)

+ GHC.Types.Name.Reader: instance GHC.Utils.Binary.Binary GHC.Types.Name.Reader.ImpDeclSpec

+ GHC.Types.Name.Reader: instance GHC.Utils.Outputable.Outputable (GHC.Types.Name.Reader.WithUserRdr GHC.Types.Name.Name)

+ GHC.Types.Name.Reader: instance GHC.Utils.Outputable.Outputable GHC.Types.Name.Reader.ParentGRE

+ GHC.Types.Name.Reader: instance GHC.Utils.Outputable.OutputableBndr (GHC.Types.Name.Reader.WithUserRdr GHC.Types.Name.Name)

+ GHC.Types.Name.Reader: noUserRdr :: Name -> WithUserRdr Name

+ GHC.Types.Name.Reader: pickLevelZeroGRE :: GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)

+ GHC.Types.Name.Reader: unLocWithUserRdr :: GenLocated l (WithUserRdr a) -> a

+ GHC.Types.Name.Reader: userRdrName :: WithUserRdr Name -> RdrName

+ GHC.Types.PkgQual: instance GHC.Internal.Classes.Eq GHC.Types.PkgQual.PkgQual

+ GHC.Types.PkgQual: instance GHC.Internal.Classes.Ord GHC.Types.PkgQual.PkgQual

+ GHC.Types.PkgQual: instance GHC.Utils.Binary.Binary GHC.Types.PkgQual.PkgQual

+ GHC.Types.ProfAuto: instance GHC.Internal.Classes.Eq GHC.Types.ProfAuto.ProfAuto

+ GHC.Types.ProfAuto: instance GHC.Internal.Show.Show GHC.Types.ProfAuto.ProfAuto

+ GHC.Types.RepType: instance GHC.Internal.Classes.Eq GHC.Types.RepType.SlotTy

+ GHC.Types.RepType: instance GHC.Internal.Classes.Ord GHC.Types.RepType.SlotTy

+ GHC.Types.SafeHaskell: instance Control.DeepSeq.NFData GHC.Types.SafeHaskell.IfaceTrustInfo

+ GHC.Types.SafeHaskell: instance Control.DeepSeq.NFData GHC.Types.SafeHaskell.SafeHaskellMode

+ GHC.Types.SafeHaskell: instance GHC.Internal.Classes.Eq GHC.Types.SafeHaskell.SafeHaskellMode

+ GHC.Types.SaneDouble: instance GHC.Internal.Classes.Eq GHC.Types.SaneDouble.SaneDouble

+ GHC.Types.SaneDouble: instance GHC.Internal.Classes.Ord GHC.Types.SaneDouble.SaneDouble

+ GHC.Types.SourceFile: instance Control.DeepSeq.NFData GHC.Types.SourceFile.HsBootOrSig

+ GHC.Types.SourceFile: instance Control.DeepSeq.NFData GHC.Types.SourceFile.HscSource

+ GHC.Types.SourceFile: instance GHC.Internal.Classes.Eq GHC.Types.SourceFile.HsBootOrSig

+ GHC.Types.SourceFile: instance GHC.Internal.Classes.Eq GHC.Types.SourceFile.HscSource

+ GHC.Types.SourceFile: instance GHC.Internal.Classes.Ord GHC.Types.SourceFile.HsBootOrSig

+ GHC.Types.SourceFile: instance GHC.Internal.Classes.Ord GHC.Types.SourceFile.HscSource

+ GHC.Types.SourceText: instance GHC.Internal.Classes.Eq GHC.Types.SourceText.FractionalExponentBase

+ GHC.Types.SourceText: instance GHC.Internal.Classes.Eq GHC.Types.SourceText.FractionalLit

+ GHC.Types.SourceText: instance GHC.Internal.Classes.Eq GHC.Types.SourceText.IntegralLit

+ GHC.Types.SourceText: instance GHC.Internal.Classes.Eq GHC.Types.SourceText.SourceText

+ GHC.Types.SourceText: instance GHC.Internal.Classes.Eq GHC.Types.SourceText.StringLiteral

+ GHC.Types.SourceText: instance GHC.Internal.Classes.Ord GHC.Types.SourceText.FractionalExponentBase

+ GHC.Types.SourceText: instance GHC.Internal.Classes.Ord GHC.Types.SourceText.FractionalLit

+ GHC.Types.SourceText: instance GHC.Internal.Classes.Ord GHC.Types.SourceText.IntegralLit

+ GHC.Types.SrcLoc: instance (GHC.Internal.Classes.Eq l, GHC.Internal.Classes.Eq e) => GHC.Internal.Classes.Eq (GHC.Types.SrcLoc.GenLocated l e)

+ GHC.Types.SrcLoc: instance (GHC.Internal.Classes.Ord l, GHC.Internal.Classes.Ord e) => GHC.Internal.Classes.Ord (GHC.Types.SrcLoc.GenLocated l e)

+ GHC.Types.SrcLoc: instance Control.DeepSeq.NFData GHC.Types.SrcLoc.BufPos

+ GHC.Types.SrcLoc: instance Control.DeepSeq.NFData GHC.Types.SrcLoc.BufSpan

+ GHC.Types.SrcLoc: instance Control.DeepSeq.NFData GHC.Types.SrcLoc.RealSrcSpan

+ GHC.Types.SrcLoc: instance Control.DeepSeq.NFData GHC.Types.SrcLoc.UnhelpfulSpanReason

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.BufPos

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.BufSpan

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.DeltaPos

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.NoComments

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.PsLoc

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.PsSpan

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.RealSrcLoc

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.RealSrcSpan

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.SrcLoc

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.SrcSpan

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq GHC.Types.SrcLoc.UnhelpfulSpanReason

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Types.SrcLoc.EpaLocation' a)

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Ord GHC.Types.SrcLoc.BufPos

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Ord GHC.Types.SrcLoc.BufSpan

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Ord GHC.Types.SrcLoc.DeltaPos

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Ord GHC.Types.SrcLoc.NoComments

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Ord GHC.Types.SrcLoc.PsLoc

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Ord GHC.Types.SrcLoc.PsSpan

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Ord GHC.Types.SrcLoc.RealSrcLoc

+ GHC.Types.SrcLoc: instance GHC.Internal.Classes.Ord GHC.Types.SrcLoc.RealSrcSpan

+ GHC.Types.Target: instance GHC.Internal.Classes.Eq GHC.Types.Target.TargetId

+ GHC.Types.ThLevelIndex: ThLevelIndex :: Int -> ThLevelIndex

+ GHC.Types.ThLevelIndex: decThLevelIndex :: ThLevelIndex -> ThLevelIndex

+ GHC.Types.ThLevelIndex: incThLevelIndex :: ThLevelIndex -> ThLevelIndex

+ GHC.Types.ThLevelIndex: instance GHC.Internal.Classes.Eq GHC.Types.ThLevelIndex.ThLevelIndex

+ GHC.Types.ThLevelIndex: instance GHC.Internal.Classes.Ord GHC.Types.ThLevelIndex.ThLevelIndex

+ GHC.Types.ThLevelIndex: instance GHC.Internal.Data.Data.Data GHC.Types.ThLevelIndex.ThLevelIndex

+ GHC.Types.ThLevelIndex: instance GHC.Utils.Outputable.Outputable GHC.Types.ThLevelIndex.ThLevelIndex

+ GHC.Types.ThLevelIndex: newtype ThLevelIndex

+ GHC.Types.ThLevelIndex: quoteLevelIndex :: ThLevelIndex

+ GHC.Types.ThLevelIndex: spliceLevelIndex :: ThLevelIndex

+ GHC.Types.ThLevelIndex: thLevelIndexFromImportLevel :: ImportLevel -> ThLevelIndex

+ GHC.Types.ThLevelIndex: topLevelIndex :: ThLevelIndex

+ GHC.Types.Tickish: BreakpointId :: Module -> BreakTickIndex -> BreakpointId

+ GHC.Types.Tickish: [bi_tick_index] :: BreakpointId -> BreakTickIndex

+ GHC.Types.Tickish: [bi_tick_mod] :: BreakpointId -> Module

+ GHC.Types.Tickish: data BreakpointId

+ GHC.Types.Tickish: instance Control.DeepSeq.NFData GHC.Types.Tickish.BreakpointId

+ GHC.Types.Tickish: instance GHC.Internal.Classes.Eq (GHC.Types.Tickish.GenTickish 'GHC.Types.Tickish.TickishPassCmm)

+ GHC.Types.Tickish: instance GHC.Internal.Classes.Eq (GHC.Types.Tickish.GenTickish 'GHC.Types.Tickish.TickishPassCore)

+ GHC.Types.Tickish: instance GHC.Internal.Classes.Eq GHC.Types.Tickish.BreakpointId

+ GHC.Types.Tickish: instance GHC.Internal.Classes.Eq GHC.Types.Tickish.TickishPlacement

+ GHC.Types.Tickish: instance GHC.Internal.Classes.Eq GHC.Types.Tickish.TickishScoping

+ GHC.Types.Tickish: instance GHC.Internal.Classes.Ord (GHC.Types.Tickish.GenTickish 'GHC.Types.Tickish.TickishPassCmm)

+ GHC.Types.Tickish: instance GHC.Internal.Classes.Ord (GHC.Types.Tickish.GenTickish 'GHC.Types.Tickish.TickishPassCore)

+ GHC.Types.Tickish: instance GHC.Internal.Classes.Ord GHC.Types.Tickish.BreakpointId

+ GHC.Types.Tickish: instance GHC.Internal.Data.Data.Data GHC.Types.Tickish.BreakpointId

+ GHC.Types.Tickish: instance GHC.Utils.Outputable.Outputable GHC.Types.Tickish.BreakpointId

+ GHC.Types.Tickish: type BreakTickIndex = Int

+ GHC.Types.Unique: instance GHC.Internal.Classes.Eq GHC.Types.Unique.Unique

+ GHC.Types.Unique: instance GHC.Types.Unique.Uniquable GHC.Internal.Types.Int

+ GHC.Types.Unique.DFM: instance GHC.Internal.Classes.Eq val => GHC.Internal.Classes.Eq (GHC.Types.Unique.DFM.TaggedVal val)

+ GHC.Types.Unique.DSet: instance GHC.Internal.Classes.Eq (GHC.Types.Unique.DSet.UniqDSet a)

+ GHC.Types.Unique.FM: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Types.Unique.FM.Edit a)

+ GHC.Types.Unique.FM: instance forall k (key :: k) ele. GHC.Internal.Classes.Eq ele => GHC.Internal.Classes.Eq (GHC.Types.Unique.FM.UniqFM key ele)

+ GHC.Types.Unique.Map: instance (GHC.Internal.Classes.Eq k, GHC.Internal.Classes.Eq a) => GHC.Internal.Classes.Eq (GHC.Types.Unique.Map.UniqMap k a)

+ GHC.Types.Unique.Set: instance GHC.Internal.Classes.Eq (GHC.Types.Unique.Set.UniqSet a)

+ GHC.Types.Unique.Set: instance GHC.Internal.Classes.Eq GHC.Types.Unique.Set.UniqueSet

+ GHC.Types.Unique.Set: instance GHC.Internal.Classes.Ord GHC.Types.Unique.Set.UniqueSet

+ GHC.Types.Var: idMult :: HasDebugCallStack => Id -> Mult

+ GHC.Types.Var: instance (Control.DeepSeq.NFData tv, Control.DeepSeq.NFData vis) => Control.DeepSeq.NFData (GHC.Types.Var.VarBndr tv vis)

+ GHC.Types.Var: instance (GHC.Internal.Classes.Eq var, GHC.Internal.Classes.Eq argf) => GHC.Internal.Classes.Eq (GHC.Types.Var.VarBndr var argf)

+ GHC.Types.Var: instance (GHC.Internal.Classes.Ord var, GHC.Internal.Classes.Ord argf) => GHC.Internal.Classes.Ord (GHC.Types.Var.VarBndr var argf)

+ GHC.Types.Var: instance Control.DeepSeq.NFData GHC.Types.Var.FunTyFlag

+ GHC.Types.Var: instance GHC.Internal.Classes.Eq GHC.Types.Var.FunTyFlag

+ GHC.Types.Var: instance GHC.Internal.Classes.Eq GHC.Types.Var.Var

+ GHC.Types.Var: instance GHC.Internal.Classes.Ord GHC.Types.Var.FunTyFlag

+ GHC.Types.Var: instance GHC.Internal.Classes.Ord GHC.Types.Var.Var

+ GHC.Types.Var: isInvisibleAnonPiTyBinder :: PiTyBinder -> Bool

+ GHC.Types.Var: type InTyCoVar = TyCoVar

+ GHC.Types.Var: type OutTyCoVar = TyCoVar

+ GHC.Types.Var.Env: mapMaybeDVarEnv :: (a -> Maybe b) -> DVarEnv a -> DVarEnv b

+ GHC.Unit.Env: [ue_module_graph] :: UnitEnv -> ModuleGraph

+ GHC.Unit.Env: hugAllAnns :: UnitEnv -> IO AnnEnv

+ GHC.Unit.Env: hugAllInstances :: UnitEnv -> IO (InstEnv, [FamInst])

+ GHC.Unit.Env: hugCompleteSigs :: UnitEnv -> IO CompleteMatches

+ GHC.Unit.Env: insertHpt :: HasDebugCallStack => HomeModInfo -> UnitEnv -> IO ()

+ GHC.Unit.Env: renameUnitId :: HasDebugCallStack => UnitId -> UnitId -> UnitEnv -> UnitEnv

+ GHC.Unit.Env: ue_homeUnitState :: HasDebugCallStack => UnitEnv -> UnitState

+ GHC.Unit.Env: ue_unitHomeUnit_maybe :: UnitId -> UnitEnv -> Maybe HomeUnit

+ GHC.Unit.Finder: findImportedModuleWithIsBoot :: HscEnv -> ModuleName -> IsBootInterface -> PkgQual -> IO FindResult

+ GHC.Unit.Home.Graph: HomeUnitEnv :: UnitState -> Maybe [UnitDatabase UnitId] -> DynFlags -> HomePackageTable -> Maybe HomeUnit -> HomeUnitEnv

+ GHC.Unit.Home.Graph: UnitEnvGraph :: Map UnitEnvGraphKey v -> UnitEnvGraph v

+ GHC.Unit.Home.Graph: [homeUnitEnv_dflags] :: HomeUnitEnv -> DynFlags

+ GHC.Unit.Home.Graph: [homeUnitEnv_home_unit] :: HomeUnitEnv -> Maybe HomeUnit

+ GHC.Unit.Home.Graph: [homeUnitEnv_hpt] :: HomeUnitEnv -> HomePackageTable

+ GHC.Unit.Home.Graph: [homeUnitEnv_unit_dbs] :: HomeUnitEnv -> Maybe [UnitDatabase UnitId]

+ GHC.Unit.Home.Graph: [homeUnitEnv_units] :: HomeUnitEnv -> UnitState

+ GHC.Unit.Home.Graph: [unitEnv_graph] :: UnitEnvGraph v -> Map UnitEnvGraphKey v

+ GHC.Unit.Home.Graph: addHomeModInfoToHug :: HomeModInfo -> HomeUnitGraph -> IO ()

+ GHC.Unit.Home.Graph: allAnns :: HomeUnitGraph -> IO AnnEnv

+ GHC.Unit.Home.Graph: allCompleteSigs :: HomeUnitGraph -> IO CompleteMatches

+ GHC.Unit.Home.Graph: allFamInstances :: HomeUnitGraph -> IO (ModuleEnv FamInstEnv)

+ GHC.Unit.Home.Graph: allInstances :: HomeUnitGraph -> IO (InstEnv, [FamInst])

+ GHC.Unit.Home.Graph: allUnits :: HomeUnitGraph -> Set UnitId

+ GHC.Unit.Home.Graph: data HomeUnitEnv

+ GHC.Unit.Home.Graph: hugFromList :: [(UnitId, HomeUnitEnv)] -> HomeUnitGraph

+ GHC.Unit.Home.Graph: hugSCCs :: HomeUnitGraph -> [SCC UnitId]

+ GHC.Unit.Home.Graph: instance GHC.Internal.Base.Functor GHC.Unit.Home.Graph.UnitEnvGraph

+ GHC.Unit.Home.Graph: instance GHC.Internal.Data.Foldable.Foldable GHC.Unit.Home.Graph.UnitEnvGraph

+ GHC.Unit.Home.Graph: instance GHC.Internal.Data.Traversable.Traversable GHC.Unit.Home.Graph.UnitEnvGraph

+ GHC.Unit.Home.Graph: lookupAllHug :: HomeUnitGraph -> ModuleName -> IO [HomeModInfo]

+ GHC.Unit.Home.Graph: lookupHug :: HomeUnitGraph -> UnitId -> ModuleName -> IO (Maybe HomeModInfo)

+ GHC.Unit.Home.Graph: lookupHugByModule :: Module -> HomeUnitGraph -> IO (Maybe HomeModInfo)

+ GHC.Unit.Home.Graph: lookupHugUnit :: Unit -> HomeUnitGraph -> Maybe HomeUnitEnv

+ GHC.Unit.Home.Graph: lookupHugUnitId :: UnitId -> HomeUnitGraph -> Maybe HomeUnitEnv

+ GHC.Unit.Home.Graph: memberHugUnit :: Unit -> HomeUnitGraph -> Bool

+ GHC.Unit.Home.Graph: memberHugUnitId :: UnitId -> HomeUnitGraph -> Bool

+ GHC.Unit.Home.Graph: mkHomeUnitEnv :: UnitState -> Maybe [UnitDatabase UnitId] -> DynFlags -> HomePackageTable -> Maybe HomeUnit -> HomeUnitEnv

+ GHC.Unit.Home.Graph: newtype UnitEnvGraph v

+ GHC.Unit.Home.Graph: pprHomeUnitEnv :: UnitId -> HomeUnitEnv -> IO SDoc

+ GHC.Unit.Home.Graph: pprHomeUnitGraph :: HomeUnitGraph -> IO SDoc

+ GHC.Unit.Home.Graph: renameUnitId :: UnitId -> UnitId -> HomeUnitGraph -> Maybe HomeUnitGraph

+ GHC.Unit.Home.Graph: restrictHug :: [(UnitId, [HomeModInfo])] -> HomeUnitGraph -> IO ()

+ GHC.Unit.Home.Graph: transitiveHomeDeps :: UnitId -> HomeUnitGraph -> Maybe [UnitId]

+ GHC.Unit.Home.Graph: type HomeUnitGraph = UnitEnvGraph HomeUnitEnv

+ GHC.Unit.Home.Graph: unitEnv_adjust :: (v -> v) -> UnitEnvGraphKey -> UnitEnvGraph v -> UnitEnvGraph v

+ GHC.Unit.Home.Graph: unitEnv_assocs :: UnitEnvGraph a -> [(UnitEnvGraphKey, a)]

+ GHC.Unit.Home.Graph: unitEnv_foldWithKey :: (b -> UnitEnvGraphKey -> a -> b) -> b -> UnitEnvGraph a -> b

+ GHC.Unit.Home.Graph: unitEnv_insert :: UnitEnvGraphKey -> v -> UnitEnvGraph v -> UnitEnvGraph v

+ GHC.Unit.Home.Graph: unitEnv_keys :: UnitEnvGraph v -> Set UnitEnvGraphKey

+ GHC.Unit.Home.Graph: unitEnv_lookup :: UnitEnvGraphKey -> UnitEnvGraph v -> v

+ GHC.Unit.Home.Graph: unitEnv_lookup_maybe :: UnitEnvGraphKey -> UnitEnvGraph v -> Maybe v

+ GHC.Unit.Home.Graph: unitEnv_new :: Map UnitEnvGraphKey v -> UnitEnvGraph v

+ GHC.Unit.Home.Graph: unitEnv_singleton :: UnitEnvGraphKey -> v -> UnitEnvGraph v

+ GHC.Unit.Home.Graph: unitEnv_traverseWithKey :: Applicative f => (UnitEnvGraphKey -> a -> f b) -> UnitEnvGraph a -> f (UnitEnvGraph b)

+ GHC.Unit.Home.Graph: updateUnitFlags :: UnitId -> (DynFlags -> DynFlags) -> HomeUnitGraph -> HomeUnitGraph

+ GHC.Unit.Home.PackageTable: HPT :: IORef (DModuleNameEnv HomeModInfo) -> HomePackageTable

+ GHC.Unit.Home.PackageTable: [table] :: HomePackageTable -> IORef (DModuleNameEnv HomeModInfo)

+ GHC.Unit.Home.PackageTable: addHomeModInfoToHpt :: HomeModInfo -> HomePackageTable -> IO ()

+ GHC.Unit.Home.PackageTable: addHomeModInfosToHpt :: HomePackageTable -> [HomeModInfo] -> IO ()

+ GHC.Unit.Home.PackageTable: addListToHpt :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> IO ()

+ GHC.Unit.Home.PackageTable: addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> IO ()

+ GHC.Unit.Home.PackageTable: concatHpt :: (HomeModInfo -> [a]) -> HomePackageTable -> IO [a]

+ GHC.Unit.Home.PackageTable: emptyHomePackageTable :: IO HomePackageTable

+ GHC.Unit.Home.PackageTable: hptAllAnnotations :: HomePackageTable -> IO AnnEnv

+ GHC.Unit.Home.PackageTable: hptAllFamInstances :: HomePackageTable -> IO (ModuleEnv FamInstEnv)

+ GHC.Unit.Home.PackageTable: hptAllInstances :: HomePackageTable -> IO (InstEnv, [FamInst])

+ GHC.Unit.Home.PackageTable: hptCollectDependencies :: HomePackageTable -> IO (Set (IfaceImportLevel, UnitId))

+ GHC.Unit.Home.PackageTable: hptCollectModules :: HomePackageTable -> IO [Module]

+ GHC.Unit.Home.PackageTable: hptCollectObjects :: HomePackageTable -> IO [Linkable]

+ GHC.Unit.Home.PackageTable: hptCompleteSigs :: HomePackageTable -> IO CompleteMatches

+ GHC.Unit.Home.PackageTable: hptInternalTableFromRef :: IORef (DModuleNameEnv HomeModInfo) -> IO HomePackageTable

+ GHC.Unit.Home.PackageTable: hptInternalTableRef :: HomePackageTable -> IORef (DModuleNameEnv HomeModInfo)

+ GHC.Unit.Home.PackageTable: lookupHpt :: HomePackageTable -> ModuleName -> IO (Maybe HomeModInfo)

+ GHC.Unit.Home.PackageTable: lookupHptByModule :: HomePackageTable -> Module -> IO (Maybe HomeModInfo)

+ GHC.Unit.Home.PackageTable: newtype HomePackageTable

+ GHC.Unit.Home.PackageTable: pprHPT :: HomePackageTable -> IO SDoc

+ GHC.Unit.Home.PackageTable: restrictHpt :: HomePackageTable -> [HomeModInfo] -> IO ()

+ GHC.Unit.Info: instance GHC.Internal.Classes.Eq GHC.Unit.Info.PackageId

+ GHC.Unit.Info: instance GHC.Internal.Classes.Eq GHC.Unit.Info.PackageName

+ GHC.Unit.Module.Deps: HMIA_Explicit :: DetOrdAvails -> NameSet -> HomeModImportedAvails

+ GHC.Unit.Module.Deps: HMIA_Implicit :: Fingerprint -> HomeModImportedAvails

+ GHC.Unit.Module.Deps: HomeModImport :: Fingerprint -> HomeModImportedAvails -> HomeModImport

+ GHC.Unit.Module.Deps: IfaceImportLevel :: ImportLevel -> IfaceImportLevel

+ GHC.Unit.Module.Deps: [hmia_exportedAvailsHash] :: HomeModImportedAvails -> Fingerprint

+ GHC.Unit.Module.Deps: [hmia_imported_avails] :: HomeModImportedAvails -> DetOrdAvails

+ GHC.Unit.Module.Deps: [hmia_parents_with_implicits] :: HomeModImportedAvails -> NameSet

+ GHC.Unit.Module.Deps: [hmiu_importedAvails] :: HomeModImport -> HomeModImportedAvails

+ GHC.Unit.Module.Deps: [hmiu_orphanLikeHash] :: HomeModImport -> Fingerprint

+ GHC.Unit.Module.Deps: data HomeModImport

+ GHC.Unit.Module.Deps: data HomeModImportedAvails

+ GHC.Unit.Module.Deps: instance Control.DeepSeq.NFData GHC.Unit.Module.Deps.Dependencies

+ GHC.Unit.Module.Deps: instance Control.DeepSeq.NFData GHC.Unit.Module.Deps.HomeModImport

+ GHC.Unit.Module.Deps: instance Control.DeepSeq.NFData GHC.Unit.Module.Deps.HomeModImportedAvails

+ GHC.Unit.Module.Deps: instance Control.DeepSeq.NFData GHC.Unit.Module.Deps.IfaceImportLevel

+ GHC.Unit.Module.Deps: instance Control.DeepSeq.NFData GHC.Unit.Module.Deps.Usage

+ GHC.Unit.Module.Deps: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Deps.Dependencies

+ GHC.Unit.Module.Deps: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Deps.HomeModImport

+ GHC.Unit.Module.Deps: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Deps.HomeModImportedAvails

+ GHC.Unit.Module.Deps: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Deps.IfaceImportLevel

+ GHC.Unit.Module.Deps: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Deps.Usage

+ GHC.Unit.Module.Deps: instance GHC.Internal.Classes.Ord GHC.Unit.Module.Deps.IfaceImportLevel

+ GHC.Unit.Module.Deps: instance GHC.Utils.Binary.Binary GHC.Unit.Module.Deps.HomeModImport

+ GHC.Unit.Module.Deps: instance GHC.Utils.Binary.Binary GHC.Unit.Module.Deps.HomeModImportedAvails

+ GHC.Unit.Module.Deps: instance GHC.Utils.Binary.Binary GHC.Unit.Module.Deps.IfaceImportLevel

+ GHC.Unit.Module.Deps: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Deps.HomeModImport

+ GHC.Unit.Module.Deps: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Deps.HomeModImportedAvails

+ GHC.Unit.Module.Deps: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Deps.IfaceImportLevel

+ GHC.Unit.Module.Deps: newtype IfaceImportLevel

+ GHC.Unit.Module.Deps: pattern Dependencies :: Set (IfaceImportLevel, UnitId, ModuleNameWithIsBoot) -> Set (IfaceImportLevel, UnitId) -> Set UnitId -> [ModuleName] -> Set UnitId -> Set (UnitId, ModuleNameWithIsBoot) -> [Module] -> [Module] -> Dependencies

+ GHC.Unit.Module.Deps: tcImportLevel :: IfaceImportLevel -> ImportLevel

+ GHC.Unit.Module.Env: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Env.NDModule

+ GHC.Unit.Module.Env: instance GHC.Internal.Classes.Ord GHC.Unit.Module.Env.NDModule

+ GHC.Unit.Module.Graph: DependencyNotInGraph :: NodeKey -> [NodeKey] -> ModuleGraphInvariantError

+ GHC.Unit.Module.Graph: DuplicateModuleNodeKey :: NodeKey -> ModuleGraphInvariantError

+ GHC.Unit.Module.Graph: FixedNodeDependsOnCompileNode :: ModNodeKeyWithUid -> [NodeKey] -> ModuleGraphInvariantError

+ GHC.Unit.Module.Graph: ModuleGraph :: [ModuleGraphNode] -> (ReachabilityIndex SummaryNode, NodeKey -> Maybe SummaryNode) -> (ReachabilityIndex SummaryNode, NodeKey -> Maybe SummaryNode) -> (ReachabilityIndex ZeroSummaryNode, ZeroScopeKey -> Maybe ZeroSummaryNode) -> Bool -> ModuleGraph

+ GHC.Unit.Module.Graph: ModuleNodeCompile :: ModSummary -> ModuleNodeInfo

+ GHC.Unit.Module.Graph: ModuleNodeEdge :: ImportLevel -> NodeKey -> ModuleNodeEdge

+ GHC.Unit.Module.Graph: ModuleNodeFixed :: ModNodeKeyWithUid -> ModLocation -> ModuleNodeInfo

+ GHC.Unit.Module.Graph: ModuleScope :: ModNodeKeyWithUid -> ImportLevel -> ZeroScopeKey

+ GHC.Unit.Module.Graph: NodeKey_ExternalUnit :: UnitId -> NodeKey

+ GHC.Unit.Module.Graph: NormalLevel :: ImportLevel

+ GHC.Unit.Module.Graph: QuoteLevel :: ImportLevel

+ GHC.Unit.Module.Graph: SpliceLevel :: ImportLevel

+ GHC.Unit.Module.Graph: UnitNode :: [UnitId] -> UnitId -> ModuleGraphNode

+ GHC.Unit.Module.Graph: UnitScope :: UnitId -> ZeroScopeKey

+ GHC.Unit.Module.Graph: [edgeLevel] :: ModuleNodeEdge -> ImportLevel

+ GHC.Unit.Module.Graph: [edgeTargetKey] :: ModuleNodeEdge -> NodeKey

+ GHC.Unit.Module.Graph: [mg_graph] :: ModuleGraph -> (ReachabilityIndex SummaryNode, NodeKey -> Maybe SummaryNode)

+ GHC.Unit.Module.Graph: [mg_has_holes] :: ModuleGraph -> Bool

+ GHC.Unit.Module.Graph: [mg_loop_graph] :: ModuleGraph -> (ReachabilityIndex SummaryNode, NodeKey -> Maybe SummaryNode)

+ GHC.Unit.Module.Graph: [mg_mss] :: ModuleGraph -> [ModuleGraphNode]

+ GHC.Unit.Module.Graph: [mg_zero_graph] :: ModuleGraph -> (ReachabilityIndex ZeroSummaryNode, ZeroScopeKey -> Maybe ZeroSummaryNode)

+ GHC.Unit.Module.Graph: checkModuleGraph :: ModuleGraph -> [ModuleGraphInvariantError]

+ GHC.Unit.Module.Graph: data ImportLevel

+ GHC.Unit.Module.Graph: data ModuleGraphInvariantError

+ GHC.Unit.Module.Graph: data ModuleNodeEdge

+ GHC.Unit.Module.Graph: data ModuleNodeInfo

+ GHC.Unit.Module.Graph: data ZeroScopeKey

+ GHC.Unit.Module.Graph: installedModuleToMnk :: InstalledModule -> ModNodeKeyWithUid

+ GHC.Unit.Module.Graph: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Graph.ModuleGraphInvariantError

+ GHC.Unit.Module.Graph: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Graph.ModuleGraphNode

+ GHC.Unit.Module.Graph: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Graph.NodeKey

+ GHC.Unit.Module.Graph: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Graph.ZeroScopeKey

+ GHC.Unit.Module.Graph: instance GHC.Internal.Classes.Ord GHC.Unit.Module.Graph.ModuleGraphInvariantError

+ GHC.Unit.Module.Graph: instance GHC.Internal.Classes.Ord GHC.Unit.Module.Graph.ModuleGraphNode

+ GHC.Unit.Module.Graph: instance GHC.Internal.Classes.Ord GHC.Unit.Module.Graph.NodeKey

+ GHC.Unit.Module.Graph: instance GHC.Internal.Classes.Ord GHC.Unit.Module.Graph.ZeroScopeKey

+ GHC.Unit.Module.Graph: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Graph.ModuleGraphInvariantError

+ GHC.Unit.Module.Graph: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Graph.ModuleNodeEdge

+ GHC.Unit.Module.Graph: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Graph.ModuleNodeType

+ GHC.Unit.Module.Graph: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Graph.ZeroScopeKey

+ GHC.Unit.Module.Graph: isBootModuleNodeInfo :: ModuleNodeInfo -> IsBootInterface

+ GHC.Unit.Module.Graph: isEmptyMG :: ModuleGraph -> Bool

+ GHC.Unit.Module.Graph: lengthMG :: ModuleGraph -> Int

+ GHC.Unit.Module.Graph: mgHasHoles :: ModuleGraph -> Bool

+ GHC.Unit.Module.Graph: mgLookupModuleName :: ModuleGraph -> ModuleNameWithIsBoot -> [ModuleNodeInfo]

+ GHC.Unit.Module.Graph: mgMapM :: (ModuleNodeInfo -> IO ModuleNodeInfo) -> ModuleGraph -> IO ModuleGraph

+ GHC.Unit.Module.Graph: mgMember :: ModuleGraph -> NodeKey -> Bool

+ GHC.Unit.Module.Graph: mgNodeDependencies :: Bool -> ModuleGraphNode -> [NodeKey]

+ GHC.Unit.Module.Graph: mgNodeIsModule :: ModuleGraphNode -> Maybe ModuleNodeInfo

+ GHC.Unit.Module.Graph: mgNodeUnitId :: ModuleGraphNode -> UnitId

+ GHC.Unit.Module.Graph: mgQuery :: ModuleGraph -> NodeKey -> NodeKey -> Bool

+ GHC.Unit.Module.Graph: mgQueryMany :: ModuleGraph -> [NodeKey] -> NodeKey -> Bool

+ GHC.Unit.Module.Graph: mgQueryManyZero :: ModuleGraph -> [ZeroScopeKey] -> ZeroScopeKey -> Bool

+ GHC.Unit.Module.Graph: mgQueryZero :: ModuleGraph -> ZeroScopeKey -> ZeroScopeKey -> Bool

+ GHC.Unit.Module.Graph: mgReachable :: ModuleGraph -> NodeKey -> Maybe [ModuleGraphNode]

+ GHC.Unit.Module.Graph: mgReachableLoop :: ModuleGraph -> [NodeKey] -> [ModuleGraphNode]

+ GHC.Unit.Module.Graph: miKey :: ModIface -> ModNodeKeyWithUid

+ GHC.Unit.Module.Graph: mkModuleEdge :: ImportLevel -> NodeKey -> ModuleNodeEdge

+ GHC.Unit.Module.Graph: mkModuleGraphChecked :: [ModuleGraphNode] -> Either [ModuleGraphInvariantError] ModuleGraph

+ GHC.Unit.Module.Graph: mkNormalEdge :: NodeKey -> ModuleNodeEdge

+ GHC.Unit.Module.Graph: mkStageDeps :: [ModuleGraphNode] -> (ReachabilityIndex StageSummaryNode, (NodeKey, ModuleStage) -> Maybe StageSummaryNode)

+ GHC.Unit.Module.Graph: mnKey :: ModuleNodeInfo -> ModNodeKeyWithUid

+ GHC.Unit.Module.Graph: mnkIsBoot :: ModNodeKeyWithUid -> IsBootInterface

+ GHC.Unit.Module.Graph: mnkToInstalledModule :: ModNodeKeyWithUid -> InstalledModule

+ GHC.Unit.Module.Graph: mnkToModule :: ModNodeKeyWithUid -> Module

+ GHC.Unit.Module.Graph: moduleGraphNodesZero :: [ModuleGraphNode] -> (Graph ZeroSummaryNode, ZeroScopeKey -> Maybe ZeroSummaryNode)

+ GHC.Unit.Module.Graph: moduleNodeInfoHscSource :: ModuleNodeInfo -> Maybe HscSource

+ GHC.Unit.Module.Graph: moduleNodeInfoLocation :: ModuleNodeInfo -> ModLocation

+ GHC.Unit.Module.Graph: moduleNodeInfoMnwib :: ModuleNodeInfo -> ModuleNameWithIsBoot

+ GHC.Unit.Module.Graph: moduleNodeInfoModNodeKeyWithUid :: ModuleNodeInfo -> ModNodeKeyWithUid

+ GHC.Unit.Module.Graph: moduleNodeInfoModule :: ModuleNodeInfo -> Module

+ GHC.Unit.Module.Graph: moduleNodeInfoModuleName :: ModuleNodeInfo -> ModuleName

+ GHC.Unit.Module.Graph: moduleNodeInfoUnitId :: ModuleNodeInfo -> UnitId

+ GHC.Unit.Module.Graph: moduleToMnk :: Module -> IsBootInterface -> ModNodeKeyWithUid

+ GHC.Unit.Module.Graph: stageSummaryNodeKey :: StageSummaryNode -> Int

+ GHC.Unit.Module.Graph: stageSummaryNodeSummary :: StageSummaryNode -> (NodeKey, ModuleStage)

+ GHC.Unit.Module.Graph: summaryNodeKey :: SummaryNode -> Int

+ GHC.Unit.Module.Graph: type StageSummaryNode = Node Int (NodeKey, ModuleStage)

+ GHC.Unit.Module.Imported: [imv_is_level] :: ImportedModsVal -> ImportLevel

+ GHC.Unit.Module.ModIface: IfaceAbiHashes :: Fingerprint -> WhetherHasOrphans -> WhetherHasFamInst -> Fingerprint -> Fingerprint -> Fingerprint -> IfaceAbiHashes

+ GHC.Unit.Module.ModIface: IfaceCache :: (OccName -> Maybe (WarningTxt GhcRn)) -> (Name -> Maybe (WarningTxt GhcRn)) -> (OccName -> Maybe Fixity) -> (OccName -> Maybe (OccName, Fingerprint)) -> IfaceCache

+ GHC.Unit.Module.ModIface: IfaceModInfo :: Module -> Maybe Module -> HscSource -> IfaceModInfo

+ GHC.Unit.Module.ModIface: IfacePublic :: [IfaceExport] -> [(OccName, Fixity)] -> IfaceWarnings -> [IfaceAnnotation] -> [IfaceDeclExts phase] -> [IfaceDefault] -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> IfaceTrustInfo -> Bool -> [IfaceCompleteMatch] -> IfaceCache -> IfaceAbiHashesExts phase -> IfacePublic_ (phase :: ModIfacePhase)

+ GHC.Unit.Module.ModIface: IfaceSelfRecomp :: Fingerprint -> [Usage] -> FingerprintWithValue IfaceDynFlags -> Fingerprint -> Fingerprint -> Fingerprint -> IfaceSelfRecomp

+ GHC.Unit.Module.ModIface: IfaceSimplifiedCore :: [IfaceBindingX IfaceMaybeRhs IfaceTopBndrInfo] -> IfaceForeign -> IfaceSimplifiedCore

+ GHC.Unit.Module.ModIface: [mi_abi_export_avails_hash] :: IfaceAbiHashes -> Fingerprint

+ GHC.Unit.Module.ModIface: [mi_abi_finsts] :: IfaceAbiHashes -> WhetherHasFamInst

+ GHC.Unit.Module.ModIface: [mi_abi_hashes_] :: IfacePublic_ (phase :: ModIfacePhase) -> IfaceAbiHashesExts phase

+ GHC.Unit.Module.ModIface: [mi_abi_mod_hash] :: IfaceAbiHashes -> Fingerprint

+ GHC.Unit.Module.ModIface: [mi_abi_orphan] :: IfaceAbiHashes -> WhetherHasOrphans

+ GHC.Unit.Module.ModIface: [mi_abi_orphan_hash] :: IfaceAbiHashes -> Fingerprint

+ GHC.Unit.Module.ModIface: [mi_abi_orphan_like_hash] :: IfaceAbiHashes -> Fingerprint

+ GHC.Unit.Module.ModIface: [mi_anns_] :: IfacePublic_ (phase :: ModIfacePhase) -> [IfaceAnnotation]

+ GHC.Unit.Module.ModIface: [mi_cache_decl_warn_fn] :: IfaceCache -> OccName -> Maybe (WarningTxt GhcRn)

+ GHC.Unit.Module.ModIface: [mi_cache_export_warn_fn] :: IfaceCache -> Name -> Maybe (WarningTxt GhcRn)

+ GHC.Unit.Module.ModIface: [mi_cache_fix_fn] :: IfaceCache -> OccName -> Maybe Fixity

+ GHC.Unit.Module.ModIface: [mi_cache_hash_fn] :: IfaceCache -> OccName -> Maybe (OccName, Fingerprint)

+ GHC.Unit.Module.ModIface: [mi_caches_] :: IfacePublic_ (phase :: ModIfacePhase) -> IfaceCache

+ GHC.Unit.Module.ModIface: [mi_complete_matches_] :: IfacePublic_ (phase :: ModIfacePhase) -> [IfaceCompleteMatch]

+ GHC.Unit.Module.ModIface: [mi_decls_] :: IfacePublic_ (phase :: ModIfacePhase) -> [IfaceDeclExts phase]

+ GHC.Unit.Module.ModIface: [mi_defaults_] :: IfacePublic_ (phase :: ModIfacePhase) -> [IfaceDefault]

+ GHC.Unit.Module.ModIface: [mi_exports_] :: IfacePublic_ (phase :: ModIfacePhase) -> [IfaceExport]

+ GHC.Unit.Module.ModIface: [mi_fam_insts_] :: IfacePublic_ (phase :: ModIfacePhase) -> [IfaceFamInst]

+ GHC.Unit.Module.ModIface: [mi_fixities_] :: IfacePublic_ (phase :: ModIfacePhase) -> [(OccName, Fixity)]

+ GHC.Unit.Module.ModIface: [mi_insts_] :: IfacePublic_ (phase :: ModIfacePhase) -> [IfaceClsInst]

+ GHC.Unit.Module.ModIface: [mi_mod_info_hsc_src] :: IfaceModInfo -> HscSource

+ GHC.Unit.Module.ModIface: [mi_mod_info_module] :: IfaceModInfo -> Module

+ GHC.Unit.Module.ModIface: [mi_mod_info_sig_of] :: IfaceModInfo -> Maybe Module

+ GHC.Unit.Module.ModIface: [mi_rules_] :: IfacePublic_ (phase :: ModIfacePhase) -> [IfaceRule]

+ GHC.Unit.Module.ModIface: [mi_sc_extra_decls] :: IfaceSimplifiedCore -> [IfaceBindingX IfaceMaybeRhs IfaceTopBndrInfo]

+ GHC.Unit.Module.ModIface: [mi_sc_foreign] :: IfaceSimplifiedCore -> IfaceForeign

+ GHC.Unit.Module.ModIface: [mi_sr_flag_hash] :: IfaceSelfRecomp -> FingerprintWithValue IfaceDynFlags

+ GHC.Unit.Module.ModIface: [mi_sr_hpc_hash] :: IfaceSelfRecomp -> Fingerprint

+ GHC.Unit.Module.ModIface: [mi_sr_opt_hash] :: IfaceSelfRecomp -> Fingerprint

+ GHC.Unit.Module.ModIface: [mi_sr_plugin_hash] :: IfaceSelfRecomp -> Fingerprint

+ GHC.Unit.Module.ModIface: [mi_sr_src_hash] :: IfaceSelfRecomp -> Fingerprint

+ GHC.Unit.Module.ModIface: [mi_sr_usages] :: IfaceSelfRecomp -> [Usage]

+ GHC.Unit.Module.ModIface: [mi_trust_] :: IfacePublic_ (phase :: ModIfacePhase) -> IfaceTrustInfo

+ GHC.Unit.Module.ModIface: [mi_trust_pkg_] :: IfacePublic_ (phase :: ModIfacePhase) -> Bool

+ GHC.Unit.Module.ModIface: [mi_warns_] :: IfacePublic_ (phase :: ModIfacePhase) -> IfaceWarnings

+ GHC.Unit.Module.ModIface: data IfaceAbiHashes

+ GHC.Unit.Module.ModIface: data IfaceCache

+ GHC.Unit.Module.ModIface: data IfaceModInfo

+ GHC.Unit.Module.ModIface: data IfacePublic_ (phase :: ModIfacePhase)

+ GHC.Unit.Module.ModIface: data IfaceSelfRecomp

+ GHC.Unit.Module.ModIface: data IfaceSimplifiedCore

+ GHC.Unit.Module.ModIface: instance (Control.DeepSeq.NFData (GHC.Unit.Module.ModIface.IfaceAbiHashesExts phase), Control.DeepSeq.NFData (GHC.Unit.Module.ModIface.IfaceDeclExts phase)) => Control.DeepSeq.NFData (GHC.Unit.Module.ModIface.IfacePublic_ phase)

+ GHC.Unit.Module.ModIface: instance (Control.DeepSeq.NFData (GHC.Unit.Module.ModIface.IfaceAbiHashesExts phase), Control.DeepSeq.NFData (GHC.Unit.Module.ModIface.IfaceDeclExts phase)) => Control.DeepSeq.NFData (GHC.Unit.Module.ModIface.ModIface_ phase)

+ GHC.Unit.Module.ModIface: instance Control.DeepSeq.NFData GHC.Unit.Module.ModIface.IfaceAbiHashes

+ GHC.Unit.Module.ModIface: instance Control.DeepSeq.NFData GHC.Unit.Module.ModIface.IfaceCache

+ GHC.Unit.Module.ModIface: instance Control.DeepSeq.NFData GHC.Unit.Module.ModIface.IfaceModInfo

+ GHC.Unit.Module.ModIface: instance Control.DeepSeq.NFData GHC.Unit.Module.ModIface.IfaceSimplifiedCore

+ GHC.Unit.Module.ModIface: instance GHC.Utils.Binary.Binary (GHC.Unit.Module.ModIface.IfacePublic_ 'GHC.Unit.Module.ModIface.ModIfaceFinal)

+ GHC.Unit.Module.ModIface: instance GHC.Utils.Binary.Binary GHC.Unit.Module.ModIface.IfaceAbiHashes

+ GHC.Unit.Module.ModIface: instance GHC.Utils.Binary.Binary GHC.Unit.Module.ModIface.IfaceModInfo

+ GHC.Unit.Module.ModIface: instance GHC.Utils.Binary.Binary GHC.Unit.Module.ModIface.IfaceSimplifiedCore

+ GHC.Unit.Module.ModIface: instance GHC.Utils.Binary.Binary GHC.Unit.Module.ModIface.IfaceTopEnv

+ GHC.Unit.Module.ModIface: mi_export_avails_hash :: ModIface -> Fingerprint

+ GHC.Unit.Module.ModIface: mi_finsts :: ModIface -> WhetherHasFamInst

+ GHC.Unit.Module.ModIface: mi_flag_hash :: forall (phase :: ModIfacePhase). ModIface_ phase -> Maybe (FingerprintWithValue IfaceDynFlags)

+ GHC.Unit.Module.ModIface: mi_hpc_hash :: forall (phase :: ModIfacePhase). ModIface_ phase -> Maybe Fingerprint

+ GHC.Unit.Module.ModIface: mi_mod_hash :: ModIface -> Fingerprint

+ GHC.Unit.Module.ModIface: mi_mod_info_semantic_module :: IfaceModInfo -> Module

+ GHC.Unit.Module.ModIface: mi_opt_hash :: forall (phase :: ModIfacePhase). ModIface_ phase -> Maybe Fingerprint

+ GHC.Unit.Module.ModIface: mi_orphan :: ModIface -> WhetherHasOrphans

+ GHC.Unit.Module.ModIface: mi_orphan_hash :: ModIface -> Fingerprint

+ GHC.Unit.Module.ModIface: mi_orphan_like_hash :: ModIface -> Fingerprint

+ GHC.Unit.Module.ModIface: mi_plugin_hash :: forall (phase :: ModIfacePhase). ModIface_ phase -> Maybe Fingerprint

+ GHC.Unit.Module.ModIface: mi_src_hash :: forall (phase :: ModIfacePhase). ModIface_ phase -> Maybe Fingerprint

+ GHC.Unit.Module.ModIface: mi_usages :: forall (phase :: ModIfacePhase). ModIface_ phase -> Maybe [Usage]

+ GHC.Unit.Module.ModIface: set_mi_abi_hashes :: forall (phase :: ModIfacePhase). IfaceAbiHashesExts phase -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: set_mi_caches :: forall (phase :: ModIfacePhase). IfaceCache -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: set_mi_decl_warn_fn :: forall (phase :: ModIfacePhase). (OccName -> Maybe (WarningTxt GhcRn)) -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: set_mi_export_warn_fn :: forall (phase :: ModIfacePhase). (Name -> Maybe (WarningTxt GhcRn)) -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: set_mi_fix_fn :: forall (phase :: ModIfacePhase). (OccName -> Maybe Fixity) -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: set_mi_hash_fn :: forall (phase :: ModIfacePhase). (OccName -> Maybe (OccName, Fingerprint)) -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: set_mi_mod_info :: forall (phase :: ModIfacePhase). IfaceModInfo -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: set_mi_self_recomp :: forall (phase :: ModIfacePhase). Maybe IfaceSelfRecomp -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: set_mi_simplified_core :: forall (phase :: ModIfacePhase). Maybe IfaceSimplifiedCore -> ModIface_ phase -> ModIface_ phase

+ GHC.Unit.Module.ModIface: type IfacePublic = IfacePublic_ 'ModIfaceFinal

+ GHC.Unit.Module.ModIface: type PartialIfacePublic = IfacePublic_ 'ModIfaceCore

+ GHC.Unit.Module.ModIface: withSelfRecomp :: forall (phase :: ModIfacePhase) r. ModIface_ phase -> r -> (IfaceSelfRecomp -> r) -> r

+ GHC.Unit.Module.ModNodeKey: ModNodeKeyWithUid :: ModuleNameWithIsBoot -> UnitId -> ModNodeKeyWithUid

+ GHC.Unit.Module.ModNodeKey: [mnkModuleName] :: ModNodeKeyWithUid -> ModuleNameWithIsBoot

+ GHC.Unit.Module.ModNodeKey: [mnkUnitId] :: ModNodeKeyWithUid -> UnitId

+ GHC.Unit.Module.ModNodeKey: data ModNodeKeyWithUid

+ GHC.Unit.Module.ModNodeKey: installedModuleToMnk :: InstalledModule -> ModNodeKeyWithUid

+ GHC.Unit.Module.ModNodeKey: instance GHC.Internal.Classes.Eq GHC.Unit.Module.ModNodeKey.ModNodeKeyWithUid

+ GHC.Unit.Module.ModNodeKey: instance GHC.Internal.Classes.Ord GHC.Unit.Module.ModNodeKey.ModNodeKeyWithUid

+ GHC.Unit.Module.ModNodeKey: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.ModNodeKey.ModNodeKeyWithUid

+ GHC.Unit.Module.ModNodeKey: mnkIsBoot :: ModNodeKeyWithUid -> IsBootInterface

+ GHC.Unit.Module.ModNodeKey: mnkToInstalledModule :: ModNodeKeyWithUid -> InstalledModule

+ GHC.Unit.Module.ModNodeKey: mnkToModule :: ModNodeKeyWithUid -> Module

+ GHC.Unit.Module.ModNodeKey: moduleToMnk :: Module -> IsBootInterface -> ModNodeKeyWithUid

+ GHC.Unit.Module.ModSummary: isTemplateHaskellOrQQNonBoot :: ModSummary -> Bool

+ GHC.Unit.Module.Stage: CompileStage :: ModuleStage

+ GHC.Unit.Module.Stage: RunStage :: ModuleStage

+ GHC.Unit.Module.Stage: allStages :: [ModuleStage]

+ GHC.Unit.Module.Stage: data ModuleStage

+ GHC.Unit.Module.Stage: decModuleStage :: ModuleStage -> ModuleStage

+ GHC.Unit.Module.Stage: incModuleStage :: ModuleStage -> ModuleStage

+ GHC.Unit.Module.Stage: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Stage.ModuleStage

+ GHC.Unit.Module.Stage: instance GHC.Internal.Classes.Ord GHC.Unit.Module.Stage.ModuleStage

+ GHC.Unit.Module.Stage: instance GHC.Internal.Enum.Bounded GHC.Unit.Module.Stage.ModuleStage

+ GHC.Unit.Module.Stage: instance GHC.Internal.Enum.Enum GHC.Unit.Module.Stage.ModuleStage

+ GHC.Unit.Module.Stage: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Stage.ModuleStage

+ GHC.Unit.Module.Stage: maxStage :: ModuleStage

+ GHC.Unit.Module.Stage: minStage :: ModuleStage

+ GHC.Unit.Module.Stage: nowAndFutureStages :: ModuleStage -> [ModuleStage]

+ GHC.Unit.Module.Stage: onlyFutureStages :: ModuleStage -> [ModuleStage]

+ GHC.Unit.Module.Stage: zeroStage :: ModuleStage

+ GHC.Unit.Module.Status: instance GHC.Utils.Outputable.Outputable GHC.Unit.Module.Status.HscRecompStatus

+ GHC.Unit.Module.Warnings: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.IdP pass) => GHC.Internal.Classes.Eq (GHC.Unit.Module.Warnings.WarningTxt pass)

+ GHC.Unit.Module.Warnings: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.IdP pass) => GHC.Internal.Classes.Eq (GHC.Unit.Module.Warnings.Warnings pass)

+ GHC.Unit.Module.Warnings: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Warnings.InWarningCategory

+ GHC.Unit.Module.Warnings: instance GHC.Internal.Classes.Eq GHC.Unit.Module.Warnings.WarningCategory

+ GHC.Unit.State: pprRawUnitIds :: SDoc -> SDoc

+ GHC.Unit.Types: instance Control.DeepSeq.NFData GHC.Unit.Types.UnitId

+ GHC.Unit.Types: instance Control.DeepSeq.NFData mod => Control.DeepSeq.NFData (GHC.Unit.Types.GenWithIsBoot mod)

+ GHC.Unit.Types: instance GHC.Internal.Classes.Eq (GHC.Unit.Types.GenInstantiatedUnit unit)

+ GHC.Unit.Types: instance GHC.Internal.Classes.Eq GHC.Unit.Types.UnitId

+ GHC.Unit.Types: instance GHC.Internal.Classes.Eq mod => GHC.Internal.Classes.Eq (GHC.Unit.Types.GenWithIsBoot mod)

+ GHC.Unit.Types: instance GHC.Internal.Classes.Eq unit => GHC.Internal.Classes.Eq (GHC.Unit.Types.Definite unit)

+ GHC.Unit.Types: instance GHC.Internal.Classes.Eq unit => GHC.Internal.Classes.Eq (GHC.Unit.Types.GenModule unit)

+ GHC.Unit.Types: instance GHC.Internal.Classes.Ord (GHC.Unit.Types.GenInstantiatedUnit unit)

+ GHC.Unit.Types: instance GHC.Internal.Classes.Ord GHC.Unit.Types.Unit

+ GHC.Unit.Types: instance GHC.Internal.Classes.Ord GHC.Unit.Types.UnitId

+ GHC.Unit.Types: instance GHC.Internal.Classes.Ord mod => GHC.Internal.Classes.Ord (GHC.Unit.Types.GenWithIsBoot mod)

+ GHC.Unit.Types: instance GHC.Internal.Classes.Ord unit => GHC.Internal.Classes.Ord (GHC.Unit.Types.Definite unit)

+ GHC.Unit.Types: instance GHC.Internal.Classes.Ord unit => GHC.Internal.Classes.Ord (GHC.Unit.Types.GenModule unit)

+ GHC.Unit.Types: instance GHC.Unit.Types.IsUnitId u => GHC.Internal.Classes.Eq (GHC.Unit.Types.GenUnit u)

+ GHC.Unit.Types: interactiveGhciUnit :: Unit

+ GHC.Unit.Types: interactiveGhciUnitId :: UnitId

+ GHC.Unit.Types: interactiveSessionUnit :: Unit

+ GHC.Unit.Types: interactiveSessionUnitId :: UnitId

+ GHC.Utils.Binary: EnumBinary :: a -> EnumBinary a

+ GHC.Utils.Binary: FingerprintWithValue :: Fingerprint -> Maybe a -> FingerprintWithValue a

+ GHC.Utils.Binary: [unEnumBinary] :: EnumBinary a -> a

+ GHC.Utils.Binary: data FingerprintWithValue a

+ GHC.Utils.Binary: instance (GHC.Utils.Binary.Binary a, GHC.Internal.Classes.Ord a) => GHC.Utils.Binary.Binary (Data.Set.Internal.Set a)

+ GHC.Utils.Binary: instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (GHC.Utils.Binary.FingerprintWithValue a)

+ GHC.Utils.Binary: instance GHC.Internal.Base.Functor GHC.Utils.Binary.FingerprintWithValue

+ GHC.Utils.Binary: instance GHC.Internal.Classes.Eq GHC.Utils.Binary.BindingName

+ GHC.Utils.Binary: instance GHC.Internal.Classes.Eq GHC.Utils.Binary.FullBinData

+ GHC.Utils.Binary: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (GHC.Utils.Binary.FixedLengthEncoding a)

+ GHC.Utils.Binary: instance GHC.Internal.Classes.Ord GHC.Utils.Binary.FullBinData

+ GHC.Utils.Binary: instance GHC.Internal.Classes.Ord a => GHC.Internal.Classes.Ord (GHC.Utils.Binary.FixedLengthEncoding a)

+ GHC.Utils.Binary: instance GHC.Internal.Enum.Enum a => GHC.Utils.Binary.Binary (GHC.Utils.Binary.EnumBinary a)

+ GHC.Utils.Binary: instance GHC.Utils.Binary.Binary Data.ByteString.Short.Internal.ShortByteString

+ GHC.Utils.Binary: instance GHC.Utils.Binary.Binary GHC.Internal.Bignum.Integer.Integer

+ GHC.Utils.Binary: instance GHC.Utils.Binary.Binary GHC.Internal.Types.Bool

+ GHC.Utils.Binary: instance GHC.Utils.Binary.Binary GHC.Internal.Types.Char

+ GHC.Utils.Binary: instance GHC.Utils.Binary.Binary GHC.Internal.Types.Int

+ GHC.Utils.Binary: instance GHC.Utils.Binary.Binary Language.Haskell.Syntax.ImpExp.IsBoot.IsBootInterface

+ GHC.Utils.Binary: instance GHC.Utils.Binary.Binary a => GHC.Utils.Binary.Binary (GHC.Utils.Binary.FingerprintWithValue a)

+ GHC.Utils.Binary: instance forall k (a :: k). GHC.Internal.Classes.Eq (GHC.Utils.Binary.Bin a)

+ GHC.Utils.Binary: instance forall k (a :: k). GHC.Internal.Classes.Eq (GHC.Utils.Binary.RelBin a)

+ GHC.Utils.Binary: instance forall k (a :: k). GHC.Internal.Classes.Eq (GHC.Utils.Binary.RelBinPtr a)

+ GHC.Utils.Binary: instance forall k (a :: k). GHC.Internal.Classes.Ord (GHC.Utils.Binary.Bin a)

+ GHC.Utils.Binary: instance forall k (a :: k). GHC.Internal.Classes.Ord (GHC.Utils.Binary.RelBin a)

+ GHC.Utils.Binary: instance forall k (a :: k). GHC.Internal.Classes.Ord (GHC.Utils.Binary.RelBinPtr a)

+ GHC.Utils.Binary: newtype EnumBinary a

+ GHC.Utils.Binary.Typeable: instance GHC.Utils.Binary.Binary GHC.Internal.Types.KindRep

+ GHC.Utils.Binary.Typeable: instance GHC.Utils.Binary.Binary GHC.Internal.Types.RuntimeRep

+ GHC.Utils.Binary.Typeable: instance GHC.Utils.Binary.Binary GHC.Internal.Types.TyCon

+ GHC.Utils.Binary.Typeable: instance GHC.Utils.Binary.Binary GHC.Internal.Types.TypeLitSort

+ GHC.Utils.Binary.Typeable: instance GHC.Utils.Binary.Binary GHC.Internal.Types.VecCount

+ GHC.Utils.Binary.Typeable: instance GHC.Utils.Binary.Binary GHC.Internal.Types.VecElem

+ GHC.Utils.CliOption: instance GHC.Internal.Classes.Eq GHC.Utils.CliOption.Option

+ GHC.Utils.Error: -- <a>GhcHint</a>.

+ GHC.Utils.Error: instance GHC.Internal.Classes.Eq GHC.Utils.Error.PrintTimings

+ GHC.Utils.Error: type DiagnosticHint a = GhcHint;

+ GHC.Utils.Exception: displayExceptionWithInfo :: SomeException -> String

+ GHC.Utils.Json: instance GHC.Utils.Json.ToJson GHC.Internal.Types.Int

+ GHC.Utils.Logger: defaultLogActionWithHandles :: Handle -> Handle -> LogAction

+ GHC.Utils.Logger: instance GHC.Internal.Classes.Eq GHC.Utils.Logger.DumpFormat

+ GHC.Utils.Misc: all2Prefix :: (a -> b -> Bool) -> [a] -> [b] -> Bool

+ GHC.Utils.Misc: all3Prefix :: (a -> b -> c -> Bool) -> [a] -> [b] -> [c] -> Bool

+ GHC.Utils.Misc: foldl1WithDefault' :: Foldable f => a -> (a -> a -> a) -> f a -> a

+ GHC.Utils.Misc: foldr1WithDefault :: Foldable f => a -> (a -> a -> a) -> f a -> a

+ GHC.Utils.Monad: infixl 4 <$>

+ GHC.Utils.Outputable: instance GHC.Internal.Classes.Eq GHC.Utils.Outputable.BindingSite

+ GHC.Utils.Outputable: instance GHC.Internal.Classes.Eq GHC.Utils.Outputable.JoinPointHood

+ GHC.Utils.Outputable: instance GHC.Utils.Outputable.Outputable GHC.Internal.Bignum.Integer.Integer

+ GHC.Utils.Outputable: instance GHC.Utils.Outputable.Outputable GHC.Internal.Types.Bool

+ GHC.Utils.Outputable: instance GHC.Utils.Outputable.Outputable GHC.Internal.Types.Double

+ GHC.Utils.Outputable: instance GHC.Utils.Outputable.Outputable GHC.Internal.Types.Float

+ GHC.Utils.Outputable: instance GHC.Utils.Outputable.Outputable GHC.Internal.Types.Int

+ GHC.Utils.Outputable: instance GHC.Utils.Outputable.Outputable GHC.Internal.Types.Ordering

+ GHC.Utils.Outputable: instance GHC.Utils.Outputable.Outputable GHC.Internal.Types.Word

+ GHC.Utils.Outputable: pluralSet :: Set a -> SDoc

+ GHC.Utils.Outputable: pprUnquotedSet :: Outputable a => Set a -> SDoc

+ Language.Haskell.Syntax.Basic: instance Control.DeepSeq.NFData Language.Haskell.Syntax.Basic.Fixity

+ Language.Haskell.Syntax.Basic: instance Control.DeepSeq.NFData Language.Haskell.Syntax.Basic.FixityDirection

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Basic.Boxity

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Basic.FieldLabelString

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Basic.Fixity

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Basic.FixityDirection

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Basic.LexicalFixity

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Basic.Role

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Basic.SrcStrictness

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Basic.SrcUnpackedness

+ Language.Haskell.Syntax.Basic: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Basic.Role

+ Language.Haskell.Syntax.Binds: RuleBndr :: XCRuleBndr pass -> LIdP pass -> RuleBndr pass

+ Language.Haskell.Syntax.Binds: RuleBndrSig :: XRuleBndrSig pass -> LIdP pass -> HsPatSigType pass -> RuleBndr pass

+ Language.Haskell.Syntax.Binds: RuleBndrs :: XCRuleBndrs pass -> Maybe [LHsTyVarBndr () (NoGhcTc pass)] -> [LRuleBndr (NoGhcTc pass)] -> RuleBndrs pass

+ Language.Haskell.Syntax.Binds: SpecSigE :: XSpecSigE pass -> RuleBndrs pass -> LHsExpr pass -> InlinePragma -> Sig pass

+ Language.Haskell.Syntax.Binds: XRuleBndr :: XXRuleBndr pass -> RuleBndr pass

+ Language.Haskell.Syntax.Binds: XRuleBndrs :: XXRuleBndrs pass -> RuleBndrs pass

+ Language.Haskell.Syntax.Binds: [rb_ext] :: RuleBndrs pass -> XCRuleBndrs pass

+ Language.Haskell.Syntax.Binds: [rb_tmvs] :: RuleBndrs pass -> [LRuleBndr (NoGhcTc pass)]

+ Language.Haskell.Syntax.Binds: [rb_tyvs] :: RuleBndrs pass -> Maybe [LHsTyVarBndr () (NoGhcTc pass)]

+ Language.Haskell.Syntax.Binds: collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass]

+ Language.Haskell.Syntax.Binds: data RuleBndr pass

+ Language.Haskell.Syntax.Binds: data RuleBndrs pass

+ Language.Haskell.Syntax.Binds: type LRuleBndr pass = XRec pass RuleBndr pass

+ Language.Haskell.Syntax.BooleanFormula: And :: [LBooleanFormula p] -> BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: Or :: [LBooleanFormula p] -> BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: Parens :: LBooleanFormula p -> BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: Var :: LIdP p -> BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: data BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: instance (GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.LIdP p), GHC.Internal.Classes.Eq (Language.Haskell.Syntax.BooleanFormula.LBooleanFormula p)) => GHC.Internal.Classes.Eq (Language.Haskell.Syntax.BooleanFormula.BooleanFormula p)

+ Language.Haskell.Syntax.BooleanFormula: mkAnd :: (UnXRec p, Eq (LIdP p), Eq (LBooleanFormula p)) => [LBooleanFormula p] -> BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: mkBool :: Bool -> BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: mkFalse :: BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: mkOr :: (UnXRec p, Eq (LIdP p), Eq (LBooleanFormula p)) => [LBooleanFormula p] -> BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: mkTrue :: BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: mkVar :: LIdP p -> BooleanFormula p

+ Language.Haskell.Syntax.BooleanFormula: type LBooleanFormula p = XRec p BooleanFormula p

+ Language.Haskell.Syntax.Decls: [con_inner_bndrs] :: ConDecl pass -> [HsForAllTelescope pass]

+ Language.Haskell.Syntax.Decls: [con_outer_bndrs] :: ConDecl pass -> XRec pass (HsOuterSigTyVarBndrs pass)

+ Language.Haskell.Syntax.Decls: [rd_bndrs] :: RuleDecl pass -> RuleBndrs pass

+ Language.Haskell.Syntax.Decls: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Decls.SpliceDecoration

+ Language.Haskell.Syntax.Decls: instance GHC.Internal.Classes.Eq a => GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Decls.DataDefnCons a)

+ Language.Haskell.Syntax.Expr: HsHole :: XHole p -> HsExpr p

+ Language.Haskell.Syntax.Expr: HsTypedSpliceExpr :: XTypedSpliceExpr id -> LHsExpr id -> HsTypedSplice id

+ Language.Haskell.Syntax.Expr: XTypedSplice :: XXTypedSplice id -> HsTypedSplice id

+ Language.Haskell.Syntax.Expr: data HsTypedSplice id

+ Language.Haskell.Syntax.Expr: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Expr.HsDoFlavour

+ Language.Haskell.Syntax.Expr: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Expr.HsLamVariant

+ Language.Haskell.Syntax.Extension: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Extension.DataConCantHappen

+ Language.Haskell.Syntax.Extension: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Extension.NoExtField

+ Language.Haskell.Syntax.Extension: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Extension.DataConCantHappen

+ Language.Haskell.Syntax.Extension: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Extension.NoExtField

+ Language.Haskell.Syntax.Extension: type LIdOccP p = XRec p IdOccP p

+ Language.Haskell.Syntax.ImpExp: IEData :: XIEData p -> LIdP p -> IEWrappedName p

+ Language.Haskell.Syntax.ImpExp: ImportDeclQuote :: ImportDeclLevel

+ Language.Haskell.Syntax.ImpExp: ImportDeclSplice :: ImportDeclLevel

+ Language.Haskell.Syntax.ImpExp: LevelStylePost :: ImportDeclLevel -> ImportDeclLevelStyle

+ Language.Haskell.Syntax.ImpExp: LevelStylePre :: ImportDeclLevel -> ImportDeclLevelStyle

+ Language.Haskell.Syntax.ImpExp: NotLevelled :: ImportDeclLevelStyle

+ Language.Haskell.Syntax.ImpExp: [ideclLevelSpec] :: ImportDecl pass -> ImportDeclLevelStyle

+ Language.Haskell.Syntax.ImpExp: data ImportDeclLevel

+ Language.Haskell.Syntax.ImpExp: data ImportDeclLevelStyle

+ Language.Haskell.Syntax.ImpExp: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.ImpExp.IEWildcard

+ Language.Haskell.Syntax.ImpExp: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.ImpExp.ImportDeclLevel

+ Language.Haskell.Syntax.ImpExp: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.ImpExp.ImportDeclLevelStyle

+ Language.Haskell.Syntax.ImpExp: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.ImpExp.ImportDeclQualifiedStyle

+ Language.Haskell.Syntax.ImpExp: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.ImpExp.ImportListInterpretation

+ Language.Haskell.Syntax.ImpExp: instance GHC.Internal.Data.Data.Data Language.Haskell.Syntax.ImpExp.ImportDeclLevel

+ Language.Haskell.Syntax.ImpExp: instance GHC.Internal.Data.Data.Data Language.Haskell.Syntax.ImpExp.ImportDeclLevelStyle

+ Language.Haskell.Syntax.ImpExp.IsBoot: IsBoot :: IsBootInterface

+ Language.Haskell.Syntax.ImpExp.IsBoot: NotBoot :: IsBootInterface

+ Language.Haskell.Syntax.ImpExp.IsBoot: data IsBootInterface

+ Language.Haskell.Syntax.ImpExp.IsBoot: instance Control.DeepSeq.NFData Language.Haskell.Syntax.ImpExp.IsBoot.IsBootInterface

+ Language.Haskell.Syntax.ImpExp.IsBoot: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.ImpExp.IsBoot.IsBootInterface

+ Language.Haskell.Syntax.ImpExp.IsBoot: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.ImpExp.IsBoot.IsBootInterface

+ Language.Haskell.Syntax.ImpExp.IsBoot: instance GHC.Internal.Data.Data.Data Language.Haskell.Syntax.ImpExp.IsBoot.IsBootInterface

+ Language.Haskell.Syntax.ImpExp.IsBoot: instance GHC.Internal.Show.Show Language.Haskell.Syntax.ImpExp.IsBoot.IsBootInterface

+ Language.Haskell.Syntax.Lit: instance GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.XXLit x) => GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Lit.HsLit x)

+ Language.Haskell.Syntax.Lit: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Lit.OverLitVal

+ Language.Haskell.Syntax.Lit: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Lit.OverLitVal

+ Language.Haskell.Syntax.Module.Name: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Module.Name.ModuleName

+ Language.Haskell.Syntax.Module.Name: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Module.Name.ModuleName

+ Language.Haskell.Syntax.Module.Name: instance GHC.Internal.Data.Data.Data Language.Haskell.Syntax.Module.Name.ModuleName

+ Language.Haskell.Syntax.Pat: dropHsConPatTyArgs :: UnXRec p => [LPat p] -> [LPat p]

+ Language.Haskell.Syntax.Pat: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Pat.RecFieldsDotDot

+ Language.Haskell.Syntax.Pat: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Pat.RecFieldsDotDot

+ Language.Haskell.Syntax.Pat: isInvisArgLPat :: UnXRec p => LPat p -> Bool

+ Language.Haskell.Syntax.Pat: isVisArgLPat :: UnXRec p => LPat p -> Bool

+ Language.Haskell.Syntax.Pat: takeHsConPatTyArgs :: UnXRec p => [LPat p] -> [HsTyPat (NoGhcTc p)]

+ Language.Haskell.Syntax.Specificity: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Specificity.ForAllTyFlag

+ Language.Haskell.Syntax.Specificity: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Specificity.Specificity

+ Language.Haskell.Syntax.Specificity: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Specificity.ForAllTyFlag

+ Language.Haskell.Syntax.Specificity: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Specificity.Specificity

+ Language.Haskell.Syntax.Type: CDF :: XConDeclField pass -> SrcUnpackedness -> SrcStrictness -> HsMultAnn pass -> LHsType pass -> Maybe (LHsDoc pass) -> HsConDeclField pass

+ Language.Haskell.Syntax.Type: HsConDeclRecField :: XConDeclRecField pass -> [LFieldOcc pass] -> HsConDeclField pass -> HsConDeclRecField pass

+ Language.Haskell.Syntax.Type: HsLinearAnn :: XLinearAnn mult pass -> HsMultAnnOf mult pass

+ Language.Haskell.Syntax.Type: HsUnannotated :: XUnannotated mult pass -> HsMultAnnOf mult pass

+ Language.Haskell.Syntax.Type: XConDeclRecField :: XXConDeclRecField pass -> HsConDeclRecField pass

+ Language.Haskell.Syntax.Type: XMultAnnOf :: XXMultAnnOf mult pass -> HsMultAnnOf mult pass

+ Language.Haskell.Syntax.Type: [cdf_bang] :: HsConDeclField pass -> SrcStrictness

+ Language.Haskell.Syntax.Type: [cdf_doc] :: HsConDeclField pass -> Maybe (LHsDoc pass)

+ Language.Haskell.Syntax.Type: [cdf_ext] :: HsConDeclField pass -> XConDeclField pass

+ Language.Haskell.Syntax.Type: [cdf_multiplicity] :: HsConDeclField pass -> HsMultAnn pass

+ Language.Haskell.Syntax.Type: [cdf_type] :: HsConDeclField pass -> LHsType pass

+ Language.Haskell.Syntax.Type: [cdf_unpack] :: HsConDeclField pass -> SrcUnpackedness

+ Language.Haskell.Syntax.Type: [cdrf_ext] :: HsConDeclRecField pass -> XConDeclRecField pass

+ Language.Haskell.Syntax.Type: [cdrf_names] :: HsConDeclRecField pass -> [LFieldOcc pass]

+ Language.Haskell.Syntax.Type: [cdrf_spec] :: HsConDeclRecField pass -> HsConDeclField pass

+ Language.Haskell.Syntax.Type: data HsConDeclField pass

+ Language.Haskell.Syntax.Type: data HsConDeclRecField pass

+ Language.Haskell.Syntax.Type: data HsMultAnnOf mult pass

+ Language.Haskell.Syntax.Type: instance (GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.LIdP pass), GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.XCFieldOcc pass), GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Extension.XXFieldOcc pass)) => GHC.Internal.Classes.Eq (Language.Haskell.Syntax.Type.FieldOcc pass)

+ Language.Haskell.Syntax.Type: instance (GHC.Internal.Data.Data.Data rec, GHC.Internal.Data.Data.Data arg) => GHC.Internal.Data.Data.Data (Language.Haskell.Syntax.Type.HsConDetails arg rec)

+ Language.Haskell.Syntax.Type: instance Control.DeepSeq.NFData Language.Haskell.Syntax.Type.PromotionFlag

+ Language.Haskell.Syntax.Type: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Type.HsIPName

+ Language.Haskell.Syntax.Type: instance GHC.Internal.Classes.Eq Language.Haskell.Syntax.Type.PromotionFlag

+ Language.Haskell.Syntax.Type: instance GHC.Internal.Classes.Ord Language.Haskell.Syntax.Type.PromotionFlag

+ Language.Haskell.Syntax.Type: type HsMultAnn pass = HsMultAnnOf LHsType NoGhcTc pass pass

+ Language.Haskell.Syntax.Type: type LHsConDeclRecField pass = XRec pass HsConDeclRecField pass

+ GHC: BreakpointId :: Module -> BreakTickIndex -> BreakpointId

+ GHC: CoreModule :: Module -> TypeEnv -> CoreProgram -> SafeHaskellMode -> CoreModule

+ GHC: DynFlags :: GhcMode -> GhcLink -> Backend -> GhcNameVersion -> FileSettings -> UnitSettings -> Platform -> ToolSettings -> PlatformMisc -> [(String, String)] -> TempDir -> Int -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe ParMakeCount -> Bool -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Int -> Int -> Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Word -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Bool -> Maybe Int -> Int -> [FilePath] -> ModuleName -> Maybe String -> IntWithInf -> IntWithInf -> Int -> Int -> Int -> UnitId -> Maybe UnitId -> [(ModuleName, Module)] -> Maybe FilePath -> Maybe String -> Set ModuleName -> [ReexportedModule] -> Ways -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> String -> String -> String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Bool -> FilePath -> Maybe FilePath -> [Option] -> IncludeSpecs -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> [ExternalPluginSpec] -> FilePath -> Bool -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> EnumSet DumpFlag -> EnumSet GeneralFlag -> EnumSet WarningFlag -> EnumSet WarningFlag -> WarningCategorySet -> WarningCategorySet -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff Extension] -> EnumSet Extension -> UnfoldingOpts -> Int -> Int -> Int -> String -> Int -> Maybe String -> Maybe String -> Maybe String -> FlushOut -> Maybe FilePath -> Maybe String -> [String] -> Int -> Int -> Bool -> OverridingBool -> Bool -> OverridingBool -> Bool -> Scheme -> ProfAuto -> [CallerCcFilter] -> Maybe String -> Maybe SseVersion -> Maybe BmiVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Int -> Int -> Int -> Bool -> Maybe Int -> Word64 -> Int -> Weights -> DynFlags

+ GHC: IIModule :: Module -> InteractiveImport

+ GHC: InternalBreakpointId :: Module -> BreakInfoIndex -> InternalBreakpointId

+ GHC: LoadUpTo :: [HomeUnitModule] -> LoadHowMuch

+ GHC: ModBreaks :: Array BreakTickIndex SrcSpan -> Array BreakTickIndex [OccName] -> Array BreakTickIndex [String] -> Array BreakTickIndex (String, String) -> Module -> ModBreaks

+ GHC: ModSummary :: Module -> HscSource -> ModLocation -> Fingerprint -> Maybe UTCTime -> Maybe UTCTime -> Maybe UTCTime -> Maybe UTCTime -> [Located ModuleName] -> [(ImportLevel, PkgQual, Located ModuleName)] -> Maybe HsParsedModule -> FilePath -> DynFlags -> Maybe StringBuffer -> ModSummary

+ GHC: OtherPkg :: UnitId -> PkgQual

+ GHC: RealSrcLoc :: RealSrcLoc -> Maybe BufPos -> SrcLoc

+ GHC: RealSrcSpan :: RealSrcSpan -> Maybe BufSpan -> SrcSpan

+ GHC: Target :: TargetId -> Bool -> UnitId -> Maybe (InputFileBuffer, UTCTime) -> Target

+ GHC: TargetFile :: FilePath -> Maybe Phase -> TargetId

+ GHC: TargetModule :: ModuleName -> TargetId

+ GHC: ThisPkg :: UnitId -> PkgQual

+ GHC: UnhelpfulLoc :: FastString -> SrcLoc

+ GHC: UnhelpfulSpan :: UnhelpfulSpanReason -> SrcSpan

+ GHC: [backend] :: DynFlags -> Backend

+ GHC: [bi_tick_index] :: BreakpointId -> BreakTickIndex

+ GHC: [bi_tick_mod] :: BreakpointId -> Module

+ GHC: [cm_module] :: CoreModule -> Module

+ GHC: [cm_types] :: CoreModule -> TypeEnv

+ GHC: [dmdUnboxWidth] :: DynFlags -> Int

+ GHC: [dynamicNow] :: DynFlags -> Bool

+ GHC: [fileSettings] :: DynFlags -> FileSettings

+ GHC: [ghcNameVersion] :: DynFlags -> GhcNameVersion

+ GHC: [ibi_info_index] :: InternalBreakpointId -> BreakInfoIndex

+ GHC: [ibi_info_mod] :: InternalBreakpointId -> Module

+ GHC: [modBreaks_ccs] :: ModBreaks -> Array BreakTickIndex (String, String)

+ GHC: [modBreaks_decls] :: ModBreaks -> Array BreakTickIndex [String]

+ GHC: [modBreaks_locs] :: ModBreaks -> Array BreakTickIndex SrcSpan

+ GHC: [modBreaks_module] :: ModBreaks -> Module

+ GHC: [modBreaks_vars] :: ModBreaks -> Array BreakTickIndex [OccName]

+ GHC: [ms_dyn_obj_date] :: ModSummary -> Maybe UTCTime

+ GHC: [ms_srcimps] :: ModSummary -> [Located ModuleName]

+ GHC: [ms_textual_imps] :: ModSummary -> [(ImportLevel, PkgQual, Located ModuleName)]

+ GHC: [platformMisc] :: DynFlags -> PlatformMisc

+ GHC: [targetAllowObjCode] :: Target -> Bool

+ GHC: [targetContents] :: Target -> Maybe (InputFileBuffer, UTCTime)

+ GHC: [targetId] :: Target -> TargetId

+ GHC: [targetUnitId] :: Target -> UnitId

+ GHC: [toolSettings] :: DynFlags -> ToolSettings

+ GHC: [unfoldingOpts] :: DynFlags -> UnfoldingOpts

+ GHC: back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan)

+ GHC: depanalE :: GhcMonad m => (GhcMessage -> AnyGhcDiagnostic) -> Maybe Messager -> [ModuleName] -> Bool -> m (DriverMessages, ModuleGraph)

+ GHC: forward :: GhcMonad m => Int -> m ([Name], Int, SrcSpan)

+ GHC: getHistoryModule :: HomeUnitGraph -> History -> IO Module

+ GHC: getModSummary :: GhcMonad m => Module -> m ModSummary

+ GHC: mgLookupModule :: ModuleGraph -> Module -> Maybe ModuleNodeInfo

+ GHC: modInfoModBreaks :: ModuleInfo -> Maybe InternalModBreaks

+ GHC: moduleIsBootOrNotObjectLinkable :: GhcMonad m => Module -> m Bool

+ GHC: pattern ModIface :: IfaceModInfo -> Module -> Maybe Module -> HscSource -> Fingerprint -> Dependencies -> IfacePublic_ phase -> [IfaceExport] -> [(OccName, Fixity)] -> IfaceWarnings -> [IfaceAnnotation] -> [IfaceDeclExts phase] -> Maybe IfaceSimplifiedCore -> [IfaceDefault] -> IfaceTopEnv -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> IfaceTrustInfo -> Bool -> [IfaceCompleteMatch] -> Maybe Docs -> IfaceAbiHashesExts phase -> ExtensibleFields -> IfaceBinHandle phase -> Maybe IfaceSelfRecomp -> (OccName -> Maybe Fixity) -> (OccName -> Maybe (OccName, Fingerprint)) -> (OccName -> Maybe (WarningTxt GhcRn)) -> (Name -> Maybe (WarningTxt GhcRn)) -> ModIface_ phase

+ GHC: resumeExec :: GhcMonad m => SingleStep -> Maybe Int -> m ExecResult

+ GHC: setupBreakpoint :: GhcMonad m => Interp -> InternalBreakpointId -> Int -> m ()

+ GHC: showModule :: GhcMonad m => ModuleNodeInfo -> m String

+ GHC: topSortModuleGraph :: Bool -> ModuleGraph -> Maybe [HomeUnitModule] -> [SCC ModuleGraphNode]

+ GHC.Builtin.Types: isBuiltInOcc_maybe :: Bool -> OccName -> Maybe Name

+ GHC.ByteCode.Asm: assembleBCOs :: Profile -> FlatBag (ProtoBCO Name) -> [TyCon] -> [(Name, ByteString)] -> Maybe InternalModBreaks -> [SptEntry] -> IO CompiledByteCode

+ GHC.ByteCode.InfoTable: mkITbls :: Profile -> [TyCon] -> [(Name, ConInfoTable)]

+ GHC.ByteCode.Instr: ALLOC_AP :: HalfWord -> BCInstr

+ GHC.ByteCode.Instr: ALLOC_AP_NOUPD :: HalfWord -> BCInstr

+ GHC.ByteCode.Instr: ALLOC_PAP :: HalfWord -> HalfWord -> BCInstr

+ GHC.ByteCode.Instr: BCO_NAME :: ByteString -> BCInstr

+ GHC.ByteCode.Instr: BRK_FUN :: InternalBreakpointId -> BCInstr

+ GHC.ByteCode.Instr: CCALL :: WordOff -> FFIInfo -> Word16 -> BCInstr

+ GHC.ByteCode.Instr: MKAP :: WordOff -> HalfWord -> BCInstr

+ GHC.ByteCode.Instr: MKPAP :: WordOff -> HalfWord -> BCInstr

+ GHC.ByteCode.Instr: OP_ADD :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_AND :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_ASR :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_EQ :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_INDEX_ADDR :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_LSR :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_MUL :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_NEG :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_NEQ :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_NOT :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_OR :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_SHL :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_SUB :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_S_GE :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_S_GT :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_S_LE :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_S_LT :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_U_GE :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_U_GT :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_U_LE :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_U_LT :: Width -> BCInstr

+ GHC.ByteCode.Instr: OP_XOR :: Width -> BCInstr

+ GHC.ByteCode.Instr: PACK :: DataCon -> WordOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH16 :: ByteOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH16_W :: ByteOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH32 :: ByteOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH32_W :: ByteOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH8 :: ByteOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH8_W :: ByteOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH_ALTS_TUPLE :: ProtoBCO Name -> NativeCallInfo -> ProtoBCO Name -> BCInstr

+ GHC.ByteCode.Instr: PUSH_L :: WordOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH_LL :: WordOff -> WordOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH_LLL :: WordOff -> WordOff -> WordOff -> BCInstr

+ GHC.ByteCode.Instr: PUSH_UBX :: Literal -> WordOff -> BCInstr

+ GHC.ByteCode.Instr: ProtoBCO :: a -> [BCInstr] -> [StgWord] -> Word -> Int -> Either [CgStgAlt] CgStgRhs -> ProtoBCO a

+ GHC.ByteCode.Instr: SLIDE :: WordOff -> WordOff -> BCInstr

+ GHC.ByteCode.Instr: STKCHECK :: Word -> BCInstr

+ GHC.ByteCode.Instr: SWIZZLE :: WordOff -> Int -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_D :: Double -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_F :: Float -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_I :: Int -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_I16 :: Int16 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_I32 :: Int32 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_I64 :: Int64 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_I8 :: Int16 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_P :: Word16 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_W :: Word -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_W16 :: Word16 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_W32 :: Word32 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_W64 :: Word64 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTEQ_W8 :: Word8 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_D :: Double -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_F :: Float -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_I :: Int -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_I16 :: Int16 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_I32 :: Int32 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_I64 :: Int64 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_I8 :: Int8 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_P :: Word16 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_W :: Word -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_W16 :: Word16 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_W32 :: Word32 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_W64 :: Word64 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: TESTLT_W8 :: Word8 -> LocalLabel -> BCInstr

+ GHC.ByteCode.Instr: UNPACK :: WordOff -> BCInstr

+ GHC.ByteCode.Linker: linkBCO :: Interp -> PkgsLoaded -> LinkerEnv -> LinkedBreaks -> NameEnv Int -> UnlinkedBCO -> IO ResolvedBCO

+ GHC.ByteCode.Linker: linkFail :: String -> SDoc -> IO a

+ GHC.ByteCode.Types: BCOByteArray :: ByteArray# -> BCOByteArray a

+ GHC.ByteCode.Types: BCONPtrAddr :: Name -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrItbl :: Name -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrLbl :: FastString -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrStr :: ByteString -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrWord :: Word -> BCONPtr

+ GHC.ByteCode.Types: BCOPtrBCO :: UnlinkedBCO -> BCOPtr

+ GHC.ByteCode.Types: BCOPtrBreakArray :: Module -> BCOPtr

+ GHC.ByteCode.Types: BCOPtrName :: Name -> BCOPtr

+ GHC.ByteCode.Types: BCOPtrPrimOp :: PrimOp -> BCOPtr

+ GHC.ByteCode.Types: CgBreakInfo :: [IfaceTvBndr] -> [Maybe (IfaceIdBndr, Word)] -> IfaceType -> Either InternalBreakLoc BreakpointId -> CgBreakInfo

+ GHC.ByteCode.Types: CompiledByteCode :: FlatBag UnlinkedBCO -> [(Name, ConInfoTable)] -> [(Name, ByteString)] -> Maybe InternalModBreaks -> [SptEntry] -> CompiledByteCode

+ GHC.ByteCode.Types: FFIInfo :: [FFIType] -> FFIType -> FFIInfo

+ GHC.ByteCode.Types: ModBreaks :: Array BreakTickIndex SrcSpan -> Array BreakTickIndex [OccName] -> Array BreakTickIndex [String] -> Array BreakTickIndex (String, String) -> Module -> ModBreaks

+ GHC.ByteCode.Types: NativeCallInfo :: NativeCallType -> WordOff -> GlobalRegSet -> WordOff -> NativeCallInfo

+ GHC.ByteCode.Types: UnlinkedBCO :: Name -> Int -> BCOByteArray Word16 -> BCOByteArray Word -> FlatBag BCONPtr -> FlatBag BCOPtr -> UnlinkedBCO

+ GHC.ByteCode.Types: [bc_breaks] :: CompiledByteCode -> Maybe InternalModBreaks

+ GHC.ByteCode.Types: [bc_itbls] :: CompiledByteCode -> [(Name, ConInfoTable)]

+ GHC.ByteCode.Types: [bc_spt_entries] :: CompiledByteCode -> [SptEntry]

+ GHC.ByteCode.Types: [bc_strs] :: CompiledByteCode -> [(Name, ByteString)]

+ GHC.ByteCode.Types: [cgb_resty] :: CgBreakInfo -> IfaceType

+ GHC.ByteCode.Types: [cgb_tyvars] :: CgBreakInfo -> [IfaceTvBndr]

+ GHC.ByteCode.Types: [cgb_vars] :: CgBreakInfo -> [Maybe (IfaceIdBndr, Word)]

+ GHC.ByteCode.Types: [getBCOByteArray] :: BCOByteArray a -> ByteArray#

+ GHC.ByteCode.Types: [modBreaks_ccs] :: ModBreaks -> Array BreakTickIndex (String, String)

+ GHC.ByteCode.Types: [modBreaks_decls] :: ModBreaks -> Array BreakTickIndex [String]

+ GHC.ByteCode.Types: [modBreaks_locs] :: ModBreaks -> Array BreakTickIndex SrcSpan

+ GHC.ByteCode.Types: [modBreaks_module] :: ModBreaks -> Module

+ GHC.ByteCode.Types: [modBreaks_vars] :: ModBreaks -> Array BreakTickIndex [OccName]

+ GHC.ByteCode.Types: [nativeCallRegs] :: NativeCallInfo -> GlobalRegSet

+ GHC.ByteCode.Types: [nativeCallSize] :: NativeCallInfo -> WordOff

+ GHC.ByteCode.Types: [nativeCallStackSpillSize] :: NativeCallInfo -> WordOff

+ GHC.ByteCode.Types: [nativeCallType] :: NativeCallInfo -> NativeCallType

+ GHC.ByteCode.Types: [unlinkedBCOArity] :: UnlinkedBCO -> Int

+ GHC.ByteCode.Types: [unlinkedBCOBitmap] :: UnlinkedBCO -> BCOByteArray Word

+ GHC.ByteCode.Types: [unlinkedBCOInstrs] :: UnlinkedBCO -> BCOByteArray Word16

+ GHC.ByteCode.Types: [unlinkedBCOLits] :: UnlinkedBCO -> FlatBag BCONPtr

+ GHC.ByteCode.Types: [unlinkedBCOName] :: UnlinkedBCO -> Name

+ GHC.ByteCode.Types: [unlinkedBCOPtrs] :: UnlinkedBCO -> FlatBag BCOPtr

+ GHC.Cmm: sectionProtection :: Section -> SectionProtection

+ GHC.Cmm.CLabel: InfoProvEnt :: CLabel -> Int -> String -> Module -> Maybe (RealSrcSpan, LexicalFastString) -> InfoProvEnt

+ GHC.Cmm.CLabel: [infoProvEntClosureType] :: InfoProvEnt -> Int

+ GHC.Cmm.CLabel: [infoProvModule] :: InfoProvEnt -> Module

+ GHC.Cmm.CLabel: [infoTableProv] :: InfoProvEnt -> Maybe (RealSrcSpan, LexicalFastString)

+ GHC.Cmm.CLabel: [infoTablePtr] :: InfoProvEnt -> CLabel

+ GHC.Cmm.CLabel: [infoTableType] :: InfoProvEnt -> String

+ GHC.Cmm.Config: CmmConfig :: Profile -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> CmmConfig

+ GHC.Cmm.Config: [cmmDoCmmSwitchPlans] :: CmmConfig -> Bool

+ GHC.Cmm.Config: [cmmDoLinting] :: CmmConfig -> Bool

+ GHC.Cmm.Config: [cmmExternalDynamicRefs] :: CmmConfig -> Bool

+ GHC.Cmm.Config: [cmmGenStackUnwindInstr] :: CmmConfig -> Bool

+ GHC.Cmm.Config: [cmmOptControlFlow] :: CmmConfig -> Bool

+ GHC.Cmm.Config: [cmmOptElimCommonBlks] :: CmmConfig -> Bool

+ GHC.Cmm.Config: [cmmOptSink] :: CmmConfig -> Bool

+ GHC.Cmm.Config: [cmmOptThreadSanitizer] :: CmmConfig -> Bool

+ GHC.Cmm.Config: [cmmProfile] :: CmmConfig -> Profile

+ GHC.Cmm.Config: [cmmSplitProcPoints] :: CmmConfig -> Bool

+ GHC.Cmm.Dataflow: Changed :: a -> JoinedFact a

+ GHC.Cmm.Dataflow: NotChanged :: a -> JoinedFact a

+ GHC.Cmm.DebugBlock: DebugBlock :: Label -> Label -> CLabel -> Bool -> Maybe DebugBlock -> [CmmTickish] -> Maybe CmmTickish -> Maybe Int -> [UnwindPoint] -> [DebugBlock] -> DebugBlock

+ GHC.Cmm.DebugBlock: UnwindPoint :: CLabel -> UnwindTable -> UnwindPoint

+ GHC.Cmm.DebugBlock: UwConst :: Int -> UnwindExpr

+ GHC.Cmm.DebugBlock: UwReg :: GlobalRegUse -> Int -> UnwindExpr

+ GHC.Cmm.DebugBlock: [dblBlocks] :: DebugBlock -> [DebugBlock]

+ GHC.Cmm.DebugBlock: [dblCLabel] :: DebugBlock -> CLabel

+ GHC.Cmm.DebugBlock: [dblHasInfoTbl] :: DebugBlock -> Bool

+ GHC.Cmm.DebugBlock: [dblLabel] :: DebugBlock -> Label

+ GHC.Cmm.DebugBlock: [dblParent] :: DebugBlock -> Maybe DebugBlock

+ GHC.Cmm.DebugBlock: [dblPosition] :: DebugBlock -> Maybe Int

+ GHC.Cmm.DebugBlock: [dblProcedure] :: DebugBlock -> Label

+ GHC.Cmm.DebugBlock: [dblSourceTick] :: DebugBlock -> Maybe CmmTickish

+ GHC.Cmm.DebugBlock: [dblTicks] :: DebugBlock -> [CmmTickish]

+ GHC.Cmm.DebugBlock: cmmDebugGen :: ModLocation -> [RawCmmDecl] -> [DebugBlock]

+ GHC.Cmm.Expr: CmmBlock :: BlockId -> CmmLit

+ GHC.Cmm.Expr: CmmFloat :: Rational -> Width -> CmmLit

+ GHC.Cmm.Expr: CmmInt :: Integer -> Width -> CmmLit

+ GHC.Cmm.Expr: CmmLabelDiffOff :: CLabel -> CLabel -> Int -> Width -> CmmLit

+ GHC.Cmm.Expr: CmmLabelOff :: CLabel -> Int -> CmmLit

+ GHC.Cmm.Expr: CmmLit :: CmmLit -> CmmExpr

+ GHC.Cmm.Expr: CmmLoad :: CmmExpr -> CmmType -> AlignmentSpec -> CmmExpr

+ GHC.Cmm.Expr: CmmLocal :: LocalReg -> CmmReg

+ GHC.Cmm.Expr: CmmReg :: CmmReg -> CmmExpr

+ GHC.Cmm.Expr: CmmRegOff :: CmmReg -> Int -> CmmExpr

+ GHC.Cmm.Expr: CmmStackSlot :: Area -> Int -> CmmExpr

+ GHC.Cmm.Expr: DoubleReg :: Int -> GlobalReg

+ GHC.Cmm.Expr: FloatReg :: Int -> GlobalReg

+ GHC.Cmm.Expr: GlobalRegUse :: GlobalReg -> CmmType -> GlobalRegUse

+ GHC.Cmm.Expr: LocalReg :: Unique -> CmmType -> LocalReg

+ GHC.Cmm.Expr: LongReg :: Int -> GlobalReg

+ GHC.Cmm.Expr: VanillaReg :: Int -> GlobalReg

+ GHC.Cmm.Expr: XmmReg :: Int -> GlobalReg

+ GHC.Cmm.Expr: YmmReg :: Int -> GlobalReg

+ GHC.Cmm.Expr: Young :: BlockId -> Area

+ GHC.Cmm.Expr: ZmmReg :: Int -> GlobalReg

+ GHC.Cmm.Expr: [globalRegUse_reg] :: GlobalRegUse -> GlobalReg

+ GHC.Cmm.Expr: [globalRegUse_type] :: GlobalRegUse -> CmmType

+ GHC.Cmm.MachOp: MO_VS_Quot :: Length -> Width -> CallishMachOp

+ GHC.Cmm.MachOp: MO_VS_Rem :: Length -> Width -> CallishMachOp

+ GHC.Cmm.MachOp: MO_VU_Quot :: Length -> Width -> CallishMachOp

+ GHC.Cmm.MachOp: MO_VU_Rem :: Length -> Width -> CallishMachOp

+ GHC.Cmm.Node: SubScope :: Unique -> CmmTickScope -> CmmTickScope

+ GHC.Cmm.Node: [CmmAssign] :: CmmReg -> CmmExpr -> CmmNode 'Open 'Open

+ GHC.Cmm.Node: [CmmBranch] :: Label -> CmmNode 'Open 'Closed

+ GHC.Cmm.Node: [CmmCondBranch] :: CmmExpr -> Label -> Label -> Maybe Bool -> CmmNode 'Open 'Closed

+ GHC.Cmm.Node: [CmmEntry] :: Label -> CmmTickScope -> CmmNode 'Closed 'Open

+ GHC.Cmm.Node: [CmmForeignCall] :: ForeignTarget -> [CmmFormal] -> [CmmActual] -> Label -> ByteOff -> ByteOff -> Bool -> CmmNode 'Open 'Closed

+ GHC.Cmm.Node: [CmmStore] :: CmmExpr -> CmmExpr -> AlignmentSpec -> CmmNode 'Open 'Open

+ GHC.Cmm.Node: [CmmTick] :: CmmTickish -> CmmNode 'Open 'Open

+ GHC.Cmm.Parser: CmmParserConfig :: ParserOpts -> PDConfig -> StgToCmmConfig -> CmmParserConfig

+ GHC.Cmm.Parser: [cmmpPDConfig] :: CmmParserConfig -> PDConfig

+ GHC.Cmm.Parser: [cmmpParserOpts] :: CmmParserConfig -> ParserOpts

+ GHC.Cmm.Parser: [cmmpStgToCmmConfig] :: CmmParserConfig -> StgToCmmConfig

+ GHC.Cmm.Parser.Config: CmmParserConfig :: ParserOpts -> PDConfig -> StgToCmmConfig -> CmmParserConfig

+ GHC.Cmm.Parser.Config: PDConfig :: Profile -> Bool -> PDConfig

+ GHC.Cmm.Parser.Config: [cmmpPDConfig] :: CmmParserConfig -> PDConfig

+ GHC.Cmm.Parser.Config: [cmmpParserOpts] :: CmmParserConfig -> ParserOpts

+ GHC.Cmm.Parser.Config: [cmmpStgToCmmConfig] :: CmmParserConfig -> StgToCmmConfig

+ GHC.Cmm.Parser.Config: [pdProfile] :: PDConfig -> Profile

+ GHC.Cmm.Parser.Config: [pdSanitizeAlignment] :: PDConfig -> Bool

+ GHC.Cmm.Parser.Monad: PDConfig :: Profile -> Bool -> PDConfig

+ GHC.Cmm.Parser.Monad: [pdProfile] :: PDConfig -> Profile

+ GHC.Cmm.Parser.Monad: [pdSanitizeAlignment] :: PDConfig -> Bool

+ GHC.Cmm.Reg: CmmLocal :: LocalReg -> CmmReg

+ GHC.Cmm.Reg: DoubleReg :: Int -> GlobalReg

+ GHC.Cmm.Reg: FloatReg :: Int -> GlobalReg

+ GHC.Cmm.Reg: GlobalRegUse :: GlobalReg -> CmmType -> GlobalRegUse

+ GHC.Cmm.Reg: LocalReg :: Unique -> CmmType -> LocalReg

+ GHC.Cmm.Reg: LongReg :: Int -> GlobalReg

+ GHC.Cmm.Reg: VanillaReg :: Int -> GlobalReg

+ GHC.Cmm.Reg: XmmReg :: Int -> GlobalReg

+ GHC.Cmm.Reg: YmmReg :: Int -> GlobalReg

+ GHC.Cmm.Reg: ZmmReg :: Int -> GlobalReg

+ GHC.Cmm.Reg: [globalRegUse_reg] :: GlobalRegUse -> GlobalReg

+ GHC.Cmm.Reg: [globalRegUse_type] :: GlobalRegUse -> CmmType

+ GHC.CmmToAsm: NcgImpl :: NCGConfig -> (RawCmmDecl -> NatM [NatCmmDecl statics instr]) -> (instr -> Maybe (NatCmmDecl statics instr)) -> (jumpDest -> Maybe BlockId) -> (instr -> Maybe jumpDest) -> ((BlockId -> Maybe jumpDest) -> statics -> statics) -> ((BlockId -> Maybe jumpDest) -> instr -> instr) -> (NatCmmDecl statics instr -> SDoc) -> (NatCmmDecl statics instr -> HDoc) -> Int -> [RealReg] -> (Int -> NatCmmDecl statics instr -> UniqDSM (NatCmmDecl statics instr, [(BlockId, BlockId)])) -> (Platform -> LabelMap RawCmmStatics -> [NatBasicBlock instr] -> UniqDSM [NatBasicBlock instr]) -> ([instr] -> [UnwindPoint]) -> (Maybe CFG -> LabelMap RawCmmStatics -> [NatBasicBlock instr] -> [NatBasicBlock instr]) -> NcgImpl statics instr jumpDest

+ GHC.CmmToAsm: [ncgConfig] :: NcgImpl statics instr jumpDest -> NCGConfig

+ GHC.CmmToAsm.CFG: CfgEdge :: BlockId -> BlockId -> EdgeInfo -> CfgEdge

+ GHC.CmmToAsm.CFG: EdgeInfo :: TransitionSource -> EdgeWeight -> EdgeInfo

+ GHC.CmmToAsm.CFG: [edgeFrom] :: CfgEdge -> BlockId

+ GHC.CmmToAsm.CFG: [edgeInfo] :: CfgEdge -> EdgeInfo

+ GHC.CmmToAsm.CFG: [edgeTo] :: CfgEdge -> BlockId

+ GHC.CmmToAsm.CFG: [edgeWeight] :: EdgeInfo -> EdgeWeight

+ GHC.CmmToAsm.CFG: [transitionSource] :: EdgeInfo -> TransitionSource

+ GHC.CmmToAsm.CFG: getCfgProc :: Platform -> Weights -> GenCmmDecl d h CmmGraph -> CFG

+ GHC.CmmToAsm.Config: NCGConfig :: Platform -> SDocContext -> Module -> Maybe Int -> Bool -> Bool -> Word -> Word -> Bool -> Bool -> Bool -> Bool -> Bool -> Maybe SseVersion -> Bool -> Bool -> Bool -> Maybe BmiVersion -> Bool -> Bool -> Bool -> Weights -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> NCGConfig

+ GHC.CmmToAsm.Config: [ncgAsmContext] :: NCGConfig -> SDocContext

+ GHC.CmmToAsm.Config: [ncgAsmLinting] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgAvx2Enabled] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgAvx512fEnabled] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgAvxEnabled] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgCfgBlockLayout] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgCfgWeightlessLayout] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgCfgWeights] :: NCGConfig -> Weights

+ GHC.CmmToAsm.Config: [ncgCmmStaticPred] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgComputeUnwinding] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgDoConstantFolding] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgDumpAsmConflicts] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgDumpAsmStats] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgDumpRegAllocStages] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgDwarfEnabled] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgDwarfSourceNotes] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgDwarfStripBlockInfo] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgDwarfUnwindings] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgEnableDeadCodeElimination] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgEnableInterModuleFarJumps] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgEnableShortcutting] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgExposeInternalSymbols] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgExternalDynamicRefs] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgInlineThresholdMemcpy] :: NCGConfig -> Word

+ GHC.CmmToAsm.Config: [ncgInlineThresholdMemset] :: NCGConfig -> Word

+ GHC.CmmToAsm.Config: [ncgPIC] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgPlatform] :: NCGConfig -> Platform

+ GHC.CmmToAsm.Config: [ncgProcAlignment] :: NCGConfig -> Maybe Int

+ GHC.CmmToAsm.Config: [ncgRegsGraph] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgRegsIterative] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgSplitSections] :: NCGConfig -> Bool

+ GHC.CmmToAsm.Config: [ncgThisModule] :: NCGConfig -> Module

+ GHC.CmmToAsm.Format: RegWithFormat :: Reg -> Format -> RegWithFormat

+ GHC.CmmToAsm.Format: VecFormat :: Length -> ScalarFormat -> Format

+ GHC.CmmToAsm.Format: VirtualRegWithFormat :: VirtualReg -> Format -> VirtualRegWithFormat

+ GHC.CmmToAsm.Format: [regWithFormat_format] :: RegWithFormat -> Format

+ GHC.CmmToAsm.Format: [regWithFormat_reg] :: RegWithFormat -> Reg

+ GHC.CmmToAsm.Format: [virtualRegWithFormat_format] :: VirtualRegWithFormat -> Format

+ GHC.CmmToAsm.Format: [virtualRegWithFormat_reg] :: VirtualRegWithFormat -> VirtualReg

+ GHC.CmmToAsm.Monad: NcgImpl :: NCGConfig -> (RawCmmDecl -> NatM [NatCmmDecl statics instr]) -> (instr -> Maybe (NatCmmDecl statics instr)) -> (jumpDest -> Maybe BlockId) -> (instr -> Maybe jumpDest) -> ((BlockId -> Maybe jumpDest) -> statics -> statics) -> ((BlockId -> Maybe jumpDest) -> instr -> instr) -> (NatCmmDecl statics instr -> SDoc) -> (NatCmmDecl statics instr -> HDoc) -> Int -> [RealReg] -> (Int -> NatCmmDecl statics instr -> UniqDSM (NatCmmDecl statics instr, [(BlockId, BlockId)])) -> (Platform -> LabelMap RawCmmStatics -> [NatBasicBlock instr] -> UniqDSM [NatBasicBlock instr]) -> ([instr] -> [UnwindPoint]) -> (Maybe CFG -> LabelMap RawCmmStatics -> [NatBasicBlock instr] -> [NatBasicBlock instr]) -> NcgImpl statics instr jumpDest

+ GHC.CmmToAsm.Monad: Reg64 :: Reg -> Reg -> Reg64

+ GHC.CmmToAsm.Monad: RegCode64 :: code -> Reg -> Reg -> RegCode64 code

+ GHC.CmmToAsm.Monad: [ncgConfig] :: NcgImpl statics instr jumpDest -> NCGConfig

+ GHC.CmmToAsm.Reg.Graph.Stats: RegAllocStatsColored :: [LiveCmmDecl statics instr] -> Graph VirtualReg RegClass RealReg -> Graph VirtualReg RegClass RealReg -> UniqFM VirtualReg VirtualReg -> [LiveCmmDecl statics instr] -> [LiveCmmDecl statics instr] -> [LiveCmmDecl statics instr] -> [NatCmmDecl statics instr] -> (Int, Int, Int) -> Platform -> RegAllocStats statics instr

+ GHC.CmmToAsm.Reg.Graph.Stats: RegAllocStatsSpill :: [LiveCmmDecl statics instr] -> Graph VirtualReg RegClass RealReg -> UniqFM VirtualReg VirtualReg -> SpillStats -> SpillCostInfo -> [LiveCmmDecl statics instr] -> Platform -> RegAllocStats statics instr

+ GHC.CmmToAsm.Reg.Graph.Stats: RegAllocStatsStart :: [LiveCmmDecl statics instr] -> Graph VirtualReg RegClass RealReg -> SpillCostInfo -> Platform -> RegAllocStats statics instr

+ GHC.CmmToAsm.Reg.Graph.Stats: [raPlatform] :: RegAllocStats statics instr -> Platform

+ GHC.CmmToAsm.Reg.Linear.AArch64: FreeRegs :: Word32 -> Word32 -> FreeRegs

+ GHC.CmmToAsm.Reg.Linear.Base: InBoth :: RealRegUsage -> StackSlot -> Loc

+ GHC.CmmToAsm.Reg.Linear.Base: InMem :: StackSlot -> Loc

+ GHC.CmmToAsm.Reg.Linear.Base: InReg :: RealRegUsage -> Loc

+ GHC.CmmToAsm.Reg.Linear.Base: RA_State :: BlockAssignment freeRegs -> freeRegs -> RegMap Loc -> Int -> StackMap -> DUniqSupply -> [SpillReason] -> NCGConfig -> [(BlockId, BlockId, BlockId)] -> RA_State freeRegs

+ GHC.CmmToAsm.Reg.Linear.Base: RealRegUsage :: RealReg -> Format -> RealRegUsage

+ GHC.CmmToAsm.Reg.Linear.Base: SpillAlloc :: Unique -> SpillReason

+ GHC.CmmToAsm.Reg.Linear.Base: SpillClobber :: Unique -> SpillReason

+ GHC.CmmToAsm.Reg.Linear.Base: SpillJoinRM :: Unique -> SpillReason

+ GHC.CmmToAsm.Reg.Linear.Base: SpillJoinRR :: Unique -> SpillReason

+ GHC.CmmToAsm.Reg.Linear.Base: SpillLoad :: Unique -> SpillReason

+ GHC.CmmToAsm.Reg.Linear.Base: [ra_config] :: RA_State freeRegs -> NCGConfig

+ GHC.CmmToAsm.Reg.Linear.Base: [ra_freeregs] :: RA_State freeRegs -> freeRegs

+ GHC.CmmToAsm.Reg.Linear.Base: [realRegFormat] :: RealRegUsage -> Format

+ GHC.CmmToAsm.Reg.Linear.Base: [realReg] :: RealRegUsage -> RealReg

+ GHC.CmmToAsm.Reg.Linear.Base: regsOfLoc :: Loc -> [RealRegUsage]

+ GHC.CmmToAsm.Reg.Linear.JoinToTargets: joinToTargets :: (FR freeRegs, Instruction instr) => BlockMap (UniqSet RegWithFormat) -> BlockId -> instr -> RegM freeRegs ([NatBasicBlock instr], instr)

+ GHC.CmmToAsm.Reg.Linear.PPC: FreeRegs :: Word32 -> Word32 -> FreeRegs

+ GHC.CmmToAsm.Reg.Linear.RV64: FreeRegs :: Word32 -> Word32 -> FreeRegs

+ GHC.CmmToAsm.Reg.Linear.StackMap: StackMap :: Int -> UniqFM Unique StackSlot -> StackMap

+ GHC.CmmToAsm.Reg.Linear.StackMap: [stackMapAssignment] :: StackMap -> UniqFM Unique StackSlot

+ GHC.CmmToAsm.Reg.Linear.StackMap: [stackMapNextFreeSlot] :: StackMap -> Int

+ GHC.CmmToAsm.Reg.Linear.State: RA_State :: BlockAssignment freeRegs -> freeRegs -> RegMap Loc -> Int -> StackMap -> DUniqSupply -> [SpillReason] -> NCGConfig -> [(BlockId, BlockId, BlockId)] -> RA_State freeRegs

+ GHC.CmmToAsm.Reg.Linear.State: [ra_config] :: RA_State freeRegs -> NCGConfig

+ GHC.CmmToAsm.Reg.Linear.State: [ra_freeregs] :: RA_State freeRegs -> freeRegs

+ GHC.CmmToAsm.Reg.Liveness: Instr :: instr -> InstrSR instr

+ GHC.CmmToAsm.Reg.Liveness: LiveInfo :: LabelMap RawCmmStatics -> [BlockId] -> BlockMap (UniqSet RegWithFormat) -> BlockMap IntSet -> LiveInfo

+ GHC.CmmToAsm.Reg.Liveness: Liveness :: UniqSet RegWithFormat -> UniqSet RegWithFormat -> UniqSet RegWithFormat -> Liveness

+ GHC.CmmToAsm.Reg.Liveness: RELOAD :: Int -> RegWithFormat -> InstrSR instr

+ GHC.CmmToAsm.Reg.Liveness: SPILL :: RegWithFormat -> Int -> InstrSR instr

+ GHC.CmmToAsm.Reg.Liveness: [liveBorn] :: Liveness -> UniqSet RegWithFormat

+ GHC.CmmToAsm.Reg.Liveness: [liveDieRead] :: Liveness -> UniqSet RegWithFormat

+ GHC.CmmToAsm.Reg.Liveness: [liveDieWrite] :: Liveness -> UniqSet RegWithFormat

+ GHC.CmmToAsm.Reg.Liveness: slurpConflicts :: Instruction instr => Platform -> LiveCmmDecl statics instr -> (Bag (UniqSet RegWithFormat), Bag (Reg, Reg))

+ GHC.CmmToAsm.Wasm.Types: WasmAsmConfig :: Bool -> Bool -> SymSet -> SymSet -> WasmAsmConfig

+ GHC.CmmToAsm.Wasm.Types: [mbrelSyms] :: WasmAsmConfig -> SymSet

+ GHC.CmmToAsm.Wasm.Types: [tbrelSyms] :: WasmAsmConfig -> SymSet

+ GHC.CmmToAsm.X86.Instr: FDIV :: Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: MINMAX :: MinOrMax -> MinMaxType -> Format -> Operand -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PSLLDQ :: Format -> Imm -> Reg -> Instr

+ GHC.CmmToAsm.X86.Instr: PSRLDQ :: Format -> Imm -> Reg -> Instr

+ GHC.CmmToLlvm.Config: LlvmCgConfig :: Platform -> SDocContext -> Bool -> Bool -> Bool -> Maybe BmiVersion -> Maybe LlvmVersion -> Bool -> String -> LlvmConfig -> LlvmCgConfig

+ GHC.CmmToLlvm.Config: [llvmCgAvxEnabled] :: LlvmCgConfig -> Bool

+ GHC.CmmToLlvm.Config: [llvmCgContext] :: LlvmCgConfig -> SDocContext

+ GHC.CmmToLlvm.Config: [llvmCgDoWarn] :: LlvmCgConfig -> Bool

+ GHC.CmmToLlvm.Config: [llvmCgFillUndefWithGarbage] :: LlvmCgConfig -> Bool

+ GHC.CmmToLlvm.Config: [llvmCgLlvmConfig] :: LlvmCgConfig -> LlvmConfig

+ GHC.CmmToLlvm.Config: [llvmCgLlvmTarget] :: LlvmCgConfig -> String

+ GHC.CmmToLlvm.Config: [llvmCgPlatform] :: LlvmCgConfig -> Platform

+ GHC.CmmToLlvm.Config: [llvmCgSplitSection] :: LlvmCgConfig -> Bool

+ GHC.Core: NotOrphan :: OccName -> IsOrphan

+ GHC.Core: Rule :: RuleName -> Activation -> Name -> [Maybe Name] -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> Bool -> Module -> IsOrphan -> Bool -> CoreRule

+ GHC.Core: UnfoldingCache :: Bool -> Bool -> Bool -> Bool -> UnfoldingCache

+ GHC.Core: [ru_origin] :: CoreRule -> Module

+ GHC.Core: [ru_orphan] :: CoreRule -> IsOrphan

+ GHC.Core: [uf_expandable] :: UnfoldingCache -> Bool

+ GHC.Core: [uf_is_conlike] :: UnfoldingCache -> Bool

+ GHC.Core: [uf_is_value] :: UnfoldingCache -> Bool

+ GHC.Core: [uf_is_work_free] :: UnfoldingCache -> Bool

+ GHC.Core: ruleArity :: CoreRule -> FullArgCount

+ GHC.Core.Class: type ClassMinimalDef = BooleanFormula GhcRn

+ GHC.Core.Coercion: CoercionHole :: CoVar -> IORef (Maybe Coercion) -> CoercionHole

+ GHC.Core.Coercion: liftCoSubstWithEx :: [TyVar] -> [Coercion] -> [TyCoVar] -> [Type] -> (Type -> CoercionR, [Type])

+ GHC.Core.ConLike: conLikeUserTyVarBinders :: ConLike -> [TyVarBinder]

+ GHC.Core.DataCon: DCR :: Id -> DataConBoxer -> [Scaled Type] -> DataConRep

+ GHC.Core.DataCon: HsSrcBang :: SourceText -> SrcUnpackedness -> SrcStrictness -> HsSrcBang

+ GHC.Core.DataCon: dataConUserTyVarBinders :: DataCon -> [TyVarBinder]

+ GHC.Core.DataCon: mkDataCon :: Name -> Bool -> TyConRepName -> [HsSrcBang] -> [HsImplBang] -> [StrictnessMark] -> [FieldLabel] -> [TyVar] -> [TyCoVar] -> ConcreteTyVars -> [TyVarBinder] -> [EqSpec] -> KnotTied ThetaType -> [KnotTied (Scaled Type)] -> KnotTied Type -> PromDataConInfo -> KnotTied TyCon -> ConTag -> ThetaType -> Id -> DataConRep -> DataCon

+ GHC.Core.InstEnv: instanceBindFun :: BindTvFun

+ GHC.Core.LateCC.Types: LateCCConfig :: LateCCBindSpec -> Bool -> LateCCEnv -> LateCCConfig

+ GHC.Core.LateCC.Types: LateCCEnv :: Module -> Maybe FastString -> Bool -> Bool -> LateCCEnv

+ GHC.Core.LateCC.Types: LateCCState :: Set CostCentre -> CostCentreState -> s -> LateCCState s

+ GHC.Core.LateCC.Types: [lateCCConfig_env] :: LateCCConfig -> LateCCEnv

+ GHC.Core.LateCC.Types: [lateCCConfig_overloadedCalls] :: LateCCConfig -> Bool

+ GHC.Core.LateCC.Types: [lateCCConfig_whichBinds] :: LateCCConfig -> LateCCBindSpec

+ GHC.Core.LateCC.Types: [lateCCEnv_collectCCs] :: LateCCEnv -> Bool

+ GHC.Core.LateCC.Types: [lateCCEnv_countEntries] :: LateCCEnv -> Bool

+ GHC.Core.LateCC.Types: [lateCCEnv_module] :: LateCCEnv -> Module

+ GHC.Core.LateCC.Types: [lateCCState_ccState] :: LateCCState s -> CostCentreState

+ GHC.Core.LateCC.Types: [lateCCState_ccs] :: LateCCState s -> Set CostCentre

+ GHC.Core.LateCC.Types: [lateCCState_extra] :: LateCCState s -> s

+ GHC.Core.Lint: EndPassConfig :: Bool -> Maybe LintPassResultConfig -> NamePprCtx -> Maybe DumpFlag -> SDoc -> SDoc -> EndPassConfig

+ GHC.Core.Lint: LintConfig :: DiagOpts -> Platform -> LintFlags -> [Var] -> LintConfig

+ GHC.Core.Lint: LintPassResultConfig :: DiagOpts -> Platform -> LintFlags -> Bool -> SDoc -> [Var] -> LintPassResultConfig

+ GHC.Core.Lint: [ep_dumpCoreSizes] :: EndPassConfig -> Bool

+ GHC.Core.Lint: [ep_dumpFlag] :: EndPassConfig -> Maybe DumpFlag

+ GHC.Core.Lint: [ep_lintPassResult] :: EndPassConfig -> Maybe LintPassResultConfig

+ GHC.Core.Lint: [ep_namePprCtx] :: EndPassConfig -> NamePprCtx

+ GHC.Core.Lint: [ep_passDetails] :: EndPassConfig -> SDoc

+ GHC.Core.Lint: [ep_prettyPass] :: EndPassConfig -> SDoc

+ GHC.Core.Lint: [l_diagOpts] :: LintConfig -> DiagOpts

+ GHC.Core.Lint: [l_flags] :: LintConfig -> LintFlags

+ GHC.Core.Lint: [l_platform] :: LintConfig -> Platform

+ GHC.Core.Lint: [l_vars] :: LintConfig -> [Var]

+ GHC.Core.Lint: [lpr_diagOpts] :: LintPassResultConfig -> DiagOpts

+ GHC.Core.Lint: [lpr_localsInScope] :: LintPassResultConfig -> [Var]

+ GHC.Core.Lint: [lpr_makeLintFlags] :: LintPassResultConfig -> LintFlags

+ GHC.Core.Lint: [lpr_passPpr] :: LintPassResultConfig -> SDoc

+ GHC.Core.Lint: [lpr_platform] :: LintPassResultConfig -> Platform

+ GHC.Core.Lint: [lpr_showLintWarnings] :: LintPassResultConfig -> Bool

+ GHC.Core.Make: MkStringIds :: Id -> Id -> MkStringIds

+ GHC.Core.Make: [unpackCStringId] :: MkStringIds -> Id

+ GHC.Core.Make: [unpackCStringUtf8Id] :: MkStringIds -> Id

+ GHC.Core.Multiplicity: Scaled :: Mult -> a -> Scaled a

+ GHC.Core.Opt.Arity: ArityOpts :: Bool -> Bool -> ArityOpts

+ GHC.Core.Opt.Arity: [ao_dicts_cheap] :: ArityOpts -> Bool

+ GHC.Core.Opt.Arity: [ao_ped_bot] :: ArityOpts -> Bool

+ GHC.Core.Opt.Arity: pushCoDataCon :: DataCon -> [CoreExpr] -> MCoercionR -> Maybe (DataCon, [Type], [CoreExpr])

+ GHC.Core.Opt.DmdAnal: DmdAnalOpts :: Bool -> Bool -> Int -> Int -> DmdAnalOpts

+ GHC.Core.Opt.DmdAnal: [dmd_do_boxity] :: DmdAnalOpts -> Bool

+ GHC.Core.Opt.DmdAnal: [dmd_max_worker_args] :: DmdAnalOpts -> Int

+ GHC.Core.Opt.DmdAnal: [dmd_strict_dicts] :: DmdAnalOpts -> Bool

+ GHC.Core.Opt.DmdAnal: [dmd_unbox_width] :: DmdAnalOpts -> Int

+ GHC.Core.Opt.LiberateCase: LibCaseOpts :: Maybe Int -> UnfoldingOpts -> LibCaseOpts

+ GHC.Core.Opt.LiberateCase: [lco_threshold] :: LibCaseOpts -> Maybe Int

+ GHC.Core.Opt.LiberateCase: [lco_unfolding_opts] :: LibCaseOpts -> UnfoldingOpts

+ GHC.Core.Opt.Pipeline.Types: CoreDoSimplify :: SimplifyOpts -> CoreToDo

+ GHC.Core.Opt.Simplify: SimplifyExprOpts :: [FamInst] -> SimplMode -> TopEnvConfig -> SimplifyExprOpts

+ GHC.Core.Opt.Simplify: SimplifyOpts :: Bool -> Int -> SimplMode -> Maybe LintPassResultConfig -> RuleBase -> TopEnvConfig -> SimplifyOpts

+ GHC.Core.Opt.Simplify: [se_fam_inst] :: SimplifyExprOpts -> [FamInst]

+ GHC.Core.Opt.Simplify: [se_mode] :: SimplifyExprOpts -> SimplMode

+ GHC.Core.Opt.Simplify: [se_top_env_cfg] :: SimplifyExprOpts -> TopEnvConfig

+ GHC.Core.Opt.Simplify: [so_dump_core_sizes] :: SimplifyOpts -> Bool

+ GHC.Core.Opt.Simplify: [so_hpt_rules] :: SimplifyOpts -> RuleBase

+ GHC.Core.Opt.Simplify: [so_iterations] :: SimplifyOpts -> Int

+ GHC.Core.Opt.Simplify: [so_mode] :: SimplifyOpts -> SimplMode

+ GHC.Core.Opt.Simplify: [so_pass_result_cfg] :: SimplifyOpts -> Maybe LintPassResultConfig

+ GHC.Core.Opt.Simplify: [so_top_env_cfg] :: SimplifyOpts -> TopEnvConfig

+ GHC.Core.Opt.Simplify.Env: SimplEnv :: SimplMode -> (FamInstEnv, FamInstEnv) -> TvSubstEnv -> CvSubstEnv -> SimplIdSubst -> UnVarSet -> InScopeSet -> Int -> Int -> SimplEnv

+ GHC.Core.Opt.Simplify.Env: SimplMode :: CompilerPhase -> [String] -> Bool -> Bool -> Bool -> Bool -> UnfoldingOpts -> Bool -> Bool -> FloatEnable -> Bool -> ArityOpts -> RuleOpts -> Bool -> Bool -> OptCoercionOpts -> SimplMode

+ GHC.Core.Opt.Simplify.Env: [seCaseDepth] :: SimplEnv -> Int

+ GHC.Core.Opt.Simplify.Env: [seFamEnvs] :: SimplEnv -> (FamInstEnv, FamInstEnv)

+ GHC.Core.Opt.Simplify.Env: [seInScope] :: SimplEnv -> InScopeSet

+ GHC.Core.Opt.Simplify.Env: [seInlineDepth] :: SimplEnv -> Int

+ GHC.Core.Opt.Simplify.Env: [seMode] :: SimplEnv -> SimplMode

+ GHC.Core.Opt.Simplify.Env: [seRecIds] :: SimplEnv -> UnVarSet

+ GHC.Core.Opt.Simplify.Env: [sm_arity_opts] :: SimplMode -> ArityOpts

+ GHC.Core.Opt.Simplify.Env: [sm_case_case] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_case_folding] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_case_merge] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_cast_swizzle] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_co_opt_opts] :: SimplMode -> OptCoercionOpts

+ GHC.Core.Opt.Simplify.Env: [sm_do_eta_reduction] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_eta_expand] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_float_enable] :: SimplMode -> FloatEnable

+ GHC.Core.Opt.Simplify.Env: [sm_inline] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_names] :: SimplMode -> [String]

+ GHC.Core.Opt.Simplify.Env: [sm_phase] :: SimplMode -> CompilerPhase

+ GHC.Core.Opt.Simplify.Env: [sm_pre_inline] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_rule_opts] :: SimplMode -> RuleOpts

+ GHC.Core.Opt.Simplify.Env: [sm_rules] :: SimplMode -> Bool

+ GHC.Core.Opt.Simplify.Env: [sm_uf_opts] :: SimplMode -> UnfoldingOpts

+ GHC.Core.Opt.Simplify.Monad: TopEnvConfig :: Int -> Int -> TopEnvConfig

+ GHC.Core.Opt.Simplify.Monad: [te_history_size] :: TopEnvConfig -> Int

+ GHC.Core.Opt.Simplify.Monad: [te_tick_factor] :: TopEnvConfig -> Int

+ GHC.Core.Opt.Simplify.Utils: ArgInfo :: OutId -> [ArgSpec] -> [CoreRule] -> Bool -> [Demand] -> [Int] -> ArgInfo

+ GHC.Core.Opt.Simplify.Utils: mkArgInfo :: SimplEnv -> Id -> [CoreRule] -> SimplCont -> ArgInfo

+ GHC.Core.Opt.WorkWrap: MkWwOpts :: FamInstEnvs -> SimpleOpts -> Bool -> Module -> Bool -> WwOpts

+ GHC.Core.Opt.WorkWrap: [wo_cpr_anal] :: WwOpts -> Bool

+ GHC.Core.Opt.WorkWrap: [wo_fam_envs] :: WwOpts -> FamInstEnvs

+ GHC.Core.Opt.WorkWrap: [wo_module] :: WwOpts -> Module

+ GHC.Core.Opt.WorkWrap: [wo_simple_opts] :: WwOpts -> SimpleOpts

+ GHC.Core.Opt.WorkWrap: [wo_unlift_strict] :: WwOpts -> Bool

+ GHC.Core.Opt.WorkWrap.Utils: DataConPatContext :: DataCon -> [Type] -> Coercion -> [s] -> DataConPatContext s

+ GHC.Core.Opt.WorkWrap.Utils: DoUnbox :: unboxing_info -> UnboxingDecision unboxing_info

+ GHC.Core.Opt.WorkWrap.Utils: MkWwOpts :: FamInstEnvs -> SimpleOpts -> Bool -> Module -> Bool -> WwOpts

+ GHC.Core.Opt.WorkWrap.Utils: [dcpc_args] :: DataConPatContext s -> [s]

+ GHC.Core.Opt.WorkWrap.Utils: [dcpc_co] :: DataConPatContext s -> Coercion

+ GHC.Core.Opt.WorkWrap.Utils: [dcpc_dc] :: DataConPatContext s -> DataCon

+ GHC.Core.Opt.WorkWrap.Utils: [dcpc_tc_args] :: DataConPatContext s -> [Type]

+ GHC.Core.Opt.WorkWrap.Utils: [wo_cpr_anal] :: WwOpts -> Bool

+ GHC.Core.Opt.WorkWrap.Utils: [wo_fam_envs] :: WwOpts -> FamInstEnvs

+ GHC.Core.Opt.WorkWrap.Utils: [wo_module] :: WwOpts -> Module

+ GHC.Core.Opt.WorkWrap.Utils: [wo_simple_opts] :: WwOpts -> SimpleOpts

+ GHC.Core.Opt.WorkWrap.Utils: [wo_unlift_strict] :: WwOpts -> Bool

+ GHC.Core.Predicate: classifyPredType :: HasDebugCallStack => PredType -> Pred

+ GHC.Core.Predicate: isPredTy :: Type -> Bool

+ GHC.Core.Predicate: typeDeterminesValue :: PredType -> Bool

+ GHC.Core.Reduction: ArgsReductions :: Reductions -> MCoercionN -> ArgsReductions

+ GHC.Core.Reduction: Reduction :: Coercion -> Type -> Reduction

+ GHC.Core.Reduction: [reductionReducedType] :: Reduction -> Type

+ GHC.Core.Rules: RuleEnv :: RuleBase -> RuleBase -> RuleBase -> ModuleSet -> RuleEnv

+ GHC.Core.Rules: [re_eps_rules] :: RuleEnv -> RuleBase

+ GHC.Core.Rules: [re_home_rules] :: RuleEnv -> RuleBase

+ GHC.Core.Rules: [re_local_rules] :: RuleEnv -> RuleBase

+ GHC.Core.Rules: [re_visible_orphs] :: RuleEnv -> ModuleSet

+ GHC.Core.Rules: lookupRule :: HasDebugCallStack => RuleOpts -> InScopeEnv -> (Activation -> Bool) -> Id -> [CoreExpr] -> [CoreRule] -> Maybe (CoreRule, CoreExpr)

+ GHC.Core.Rules: matchExprs :: HasDebugCallStack => InScopeEnv -> [Var] -> [CoreExpr] -> [CoreExpr] -> Maybe (BindWrapper, [CoreExpr])

+ GHC.Core.Rules.Config: RuleOpts :: Platform -> Bool -> Bool -> Bool -> RuleOpts

+ GHC.Core.Rules.Config: [roBignumRules] :: RuleOpts -> Bool

+ GHC.Core.Rules.Config: [roExcessRationalPrecision] :: RuleOpts -> Bool

+ GHC.Core.Rules.Config: [roNumConstantFolding] :: RuleOpts -> Bool

+ GHC.Core.Rules.Config: [roPlatform] :: RuleOpts -> Platform

+ GHC.Core.SimpleOpt: SimpleOpts :: UnfoldingOpts -> OptCoercionOpts -> Bool -> Bool -> SimpleOpts

+ GHC.Core.SimpleOpt: [so_co_opts] :: SimpleOpts -> OptCoercionOpts

+ GHC.Core.SimpleOpt: [so_eta_red] :: SimpleOpts -> Bool

+ GHC.Core.SimpleOpt: [so_uf_opts] :: SimpleOpts -> UnfoldingOpts

+ GHC.Core.Stats: CS :: Int -> Int -> Int -> Int -> Int -> CoreStats

+ GHC.Core.Stats: [cs_co] :: CoreStats -> Int

+ GHC.Core.Stats: [cs_jb] :: CoreStats -> Int

+ GHC.Core.Stats: [cs_tm] :: CoreStats -> Int

+ GHC.Core.Stats: [cs_ty] :: CoreStats -> Int

+ GHC.Core.Stats: [cs_vb] :: CoreStats -> Int

+ GHC.Core.Subst: cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])

+ GHC.Core.Subst: cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

+ GHC.Core.Subst: extendSubst :: HasDebugCallStack => Subst -> Var -> CoreArg -> Subst

+ GHC.Core.TyCo.Rep: CoercionHole :: CoVar -> IORef (Maybe Coercion) -> CoercionHole

+ GHC.Core.TyCo.Rep: ForAllCo :: TyCoVar -> ForAllTyFlag -> ForAllTyFlag -> KindCoercion -> Coercion -> Coercion

+ GHC.Core.TyCo.Rep: ForAllTy :: ForAllTyBinder -> Type -> Type

+ GHC.Core.TyCo.Rep: Invisible :: Specificity -> ForAllTyFlag

+ GHC.Core.TyCo.Rep: Scaled :: Mult -> a -> Scaled a

+ GHC.Core.TyCo.Rep: [fco_visL] :: Coercion -> ForAllTyFlag

+ GHC.Core.TyCo.Rep: [fco_visR] :: Coercion -> ForAllTyFlag

+ GHC.Core.TyCo.Subst: substForAllCoBndrUsing :: (Coercion -> Coercion) -> Subst -> TyCoVar -> KindCoercion -> (Subst, TyCoVar, KindCoercion)

+ GHC.Core.TyCon: BoxedRep :: Maybe Levity -> PrimRep

+ GHC.Core.TyCon: tyConBinderForAllTyFlag :: VarBndr a TyConBndrVis -> ForAllTyFlag

+ GHC.Core.Type: Invisible :: Specificity -> ForAllTyFlag

+ GHC.Core.Unfold: SizeIs :: Int -> Bag (Id, Int) -> Int -> ExprSize

+ GHC.Core.Unfold: UnfoldingOpts :: Int -> Int -> Int -> Int -> Bool -> Int -> Int -> Maybe String -> UnfoldingOpts

+ GHC.Core.Unfold: [_es_args] :: ExprSize -> Bag (Id, Int)

+ GHC.Core.Unfold: [_es_discount] :: ExprSize -> Int

+ GHC.Core.Unfold: [_es_size_is] :: ExprSize -> Int

+ GHC.Core.Unfold: [unfoldingCaseScaling] :: UnfoldingOpts -> Int

+ GHC.Core.Unfold: [unfoldingCaseThreshold] :: UnfoldingOpts -> Int

+ GHC.Core.Unfold: [unfoldingCreationThreshold] :: UnfoldingOpts -> Int

+ GHC.Core.Unfold: [unfoldingDictDiscount] :: UnfoldingOpts -> Int

+ GHC.Core.Unfold: [unfoldingFunAppDiscount] :: UnfoldingOpts -> Int

+ GHC.Core.Unfold: [unfoldingReportPrefix] :: UnfoldingOpts -> Maybe String

+ GHC.Core.Unfold: [unfoldingUseThreshold] :: UnfoldingOpts -> Int

+ GHC.Core.Unfold: [unfoldingVeryAggressive] :: UnfoldingOpts -> Bool

+ GHC.Core.Unify: tcMatchTy :: HasDebugCallStack => Type -> Type -> Maybe Subst

+ GHC.Core.Unify: tcMatchTyKi :: HasDebugCallStack => Type -> Type -> Maybe Subst

+ GHC.Core.Unify: tcMatchTyKis :: HasDebugCallStack => [Type] -> [Type] -> Maybe Subst

+ GHC.Core.Unify: tcMatchTyKisX :: HasDebugCallStack => Subst -> [Type] -> [Type] -> Maybe Subst

+ GHC.Core.Unify: tcMatchTyX :: HasDebugCallStack => Subst -> Type -> Type -> Maybe Subst

+ GHC.Core.Unify: tcMatchTyX_BM :: HasDebugCallStack => BindTvFun -> Subst -> Type -> Type -> Maybe Subst

+ GHC.Core.Unify: tcMatchTys :: HasDebugCallStack => [Type] -> [Type] -> Maybe Subst

+ GHC.Core.Unify: tcMatchTysX :: HasDebugCallStack => Subst -> [Type] -> [Type] -> Maybe Subst

+ GHC.Core.Unify: tcUnifyTys :: BindTvFun -> [Type] -> [Type] -> Maybe Subst

+ GHC.Core.Unify: tcUnifyTysFG :: BindFamFun -> BindTvFun -> [Type] -> [Type] -> UnifyResult

+ GHC.Core.UsageEnv: supUEs :: Foldable f => f UsageEnv -> UsageEnv

+ GHC.Core.Utils: applyTypeToArgs :: HasDebugCallStack => Type -> [CoreExpr] -> Type

+ GHC.Core.Utils: exprIsCheapX :: CheapAppFun -> Bool -> CoreExpr -> Bool

+ GHC.CoreToStg.Prep: CorePrepConfig :: Bool -> Platform -> Maybe ArityOpts -> Bool -> Bool -> CorePrepConfig

+ GHC.CoreToStg.Prep: CorePrepPgmConfig :: EndPassConfig -> Bool -> CorePrepPgmConfig

+ GHC.CoreToStg.Prep: [cpPgm_endPassConfig] :: CorePrepPgmConfig -> EndPassConfig

+ GHC.CoreToStg.Prep: [cpPgm_generateDebugInfo] :: CorePrepPgmConfig -> Bool

+ GHC.CoreToStg.Prep: [cp_arityOpts] :: CorePrepConfig -> Maybe ArityOpts

+ GHC.CoreToStg.Prep: [cp_catchNonexhaustiveCases] :: CorePrepConfig -> Bool

+ GHC.CoreToStg.Prep: [cp_specEvalDFun] :: CorePrepConfig -> Bool

+ GHC.CoreToStg.Prep: [cp_specEval] :: CorePrepConfig -> Bool

+ GHC.CoreToStg.Prep: corePrepPgm :: Logger -> CorePrepConfig -> CorePrepPgmConfig -> Module -> CoreProgram -> IO CoreProgram

+ GHC.Data.BooleanFormula: eval :: forall (p :: Pass). (LIdP (GhcPass p) -> Bool) -> BooleanFormula (GhcPass p) -> Bool

+ GHC.Data.BooleanFormula: implies :: forall (p :: Pass). Uniquable (IdP (GhcPass p)) => BooleanFormula (GhcPass p) -> BooleanFormula (GhcPass p) -> Bool

+ GHC.Data.BooleanFormula: impliesAtom :: forall (p :: Pass). Eq (IdP (GhcPass p)) => BooleanFormula (GhcPass p) -> LIdP (GhcPass p) -> Bool

+ GHC.Data.BooleanFormula: isFalse :: forall (p :: Pass). BooleanFormula (GhcPass p) -> Bool

+ GHC.Data.BooleanFormula: isTrue :: forall (p :: Pass). BooleanFormula (GhcPass p) -> Bool

+ GHC.Data.BooleanFormula: isUnsatisfied :: forall (p :: Pass). Eq (LIdP (GhcPass p)) => (LIdP (GhcPass p) -> Bool) -> BooleanFormula (GhcPass p) -> Maybe (BooleanFormula (GhcPass p))

+ GHC.Data.BooleanFormula: pprBooleanFormula :: forall (p :: Pass). (Rational -> LIdP (GhcPass p) -> SDoc) -> Rational -> BooleanFormula (GhcPass p) -> SDoc

+ GHC.Data.BooleanFormula: pprBooleanFormulaNice :: forall (p :: Pass). Outputable (LIdP (GhcPass p)) => BooleanFormula (GhcPass p) -> SDoc

+ GHC.Data.BooleanFormula: simplify :: forall (p :: Pass). Eq (LIdP (GhcPass p)) => (LIdP (GhcPass p) -> Maybe Bool) -> BooleanFormula (GhcPass p) -> BooleanFormula (GhcPass p)

+ GHC.Data.FastString: FastString :: Int -> Int -> ShortByteString -> FastZString -> FastString

+ GHC.Data.FastString: PtrString :: Ptr Word8 -> Int -> PtrString

+ GHC.Data.FastString: [fs_sbs] :: FastString -> ShortByteString

+ GHC.Data.FastString: [n_chars] :: FastString -> Int

+ GHC.Data.FastString: [uniq] :: FastString -> Int

+ GHC.Data.FlatBag: TupleFlatBag :: a -> a -> FlatBag a

+ GHC.Data.FlatBag: UnitFlatBag :: a -> FlatBag a

+ GHC.Data.Graph.Directed: NECyclicSCC :: NonEmpty vertex -> SCC vertex

+ GHC.Data.Maybe: expectJust :: HasCallStack => Maybe a -> a

+ GHC.Data.Strict: And :: a -> b -> Pair a b

+ GHC.Data.Strict: Just :: a -> Maybe a

+ GHC.Data.StringBuffer: StringBuffer :: ForeignPtr Word8 -> Int -> Int -> StringBuffer

+ GHC.Data.StringBuffer: [buf] :: StringBuffer -> ForeignPtr Word8

+ GHC.Data.StringBuffer: [cur] :: StringBuffer -> Int

+ GHC.Data.StringBuffer: [len] :: StringBuffer -> Int

+ GHC.Data.UnionFind: Info :: STRef s Int -> STRef s a -> Link s a

+ GHC.Data.UnionFind: Link :: Point s a -> Link s a

+ GHC.Data.Word64Map.Internal: Bin :: Prefix -> Mask -> Word64Map a -> Word64Map a -> Word64Map a

+ GHC.Data.Word64Map.Internal: Tip :: Key -> a -> Word64Map a

+ GHC.Data.Word64Set.Internal: Bin :: Prefix -> Mask -> Word64Set -> Word64Set -> Word64Set

+ GHC.Data.Word64Set.Internal: Tip :: Prefix -> BitMap -> Word64Set

+ GHC.Driver.Config: initEvalOpts :: DynFlags -> EvalStep -> EvalOpts

+ GHC.Driver.DynFlags: DynFlags :: GhcMode -> GhcLink -> Backend -> GhcNameVersion -> FileSettings -> UnitSettings -> Platform -> ToolSettings -> PlatformMisc -> [(String, String)] -> TempDir -> Int -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe ParMakeCount -> Bool -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Int -> Int -> Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Word -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Bool -> Maybe Int -> Int -> [FilePath] -> ModuleName -> Maybe String -> IntWithInf -> IntWithInf -> Int -> Int -> Int -> UnitId -> Maybe UnitId -> [(ModuleName, Module)] -> Maybe FilePath -> Maybe String -> Set ModuleName -> [ReexportedModule] -> Ways -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> String -> String -> String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Bool -> FilePath -> Maybe FilePath -> [Option] -> IncludeSpecs -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> [ExternalPluginSpec] -> FilePath -> Bool -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> EnumSet DumpFlag -> EnumSet GeneralFlag -> EnumSet WarningFlag -> EnumSet WarningFlag -> WarningCategorySet -> WarningCategorySet -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff Extension] -> EnumSet Extension -> UnfoldingOpts -> Int -> Int -> Int -> String -> Int -> Maybe String -> Maybe String -> Maybe String -> FlushOut -> Maybe FilePath -> Maybe String -> [String] -> Int -> Int -> Bool -> OverridingBool -> Bool -> OverridingBool -> Bool -> Scheme -> ProfAuto -> [CallerCcFilter] -> Maybe String -> Maybe SseVersion -> Maybe BmiVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Int -> Int -> Int -> Bool -> Maybe Int -> Word64 -> Int -> Weights -> DynFlags

+ GHC.Driver.DynFlags: WarningWithCategory :: WarningCategory -> DiagnosticReason

+ GHC.Driver.DynFlags: WarningWithFlags :: NonEmpty WarningFlag -> DiagnosticReason

+ GHC.Driver.DynFlags: [backend] :: DynFlags -> Backend

+ GHC.Driver.DynFlags: [dmdUnboxWidth] :: DynFlags -> Int

+ GHC.Driver.DynFlags: [dynamicNow] :: DynFlags -> Bool

+ GHC.Driver.DynFlags: [fileSettings] :: DynFlags -> FileSettings

+ GHC.Driver.DynFlags: [ghcNameVersion] :: DynFlags -> GhcNameVersion

+ GHC.Driver.DynFlags: [platformMisc] :: DynFlags -> PlatformMisc

+ GHC.Driver.DynFlags: [toolSettings] :: DynFlags -> ToolSettings

+ GHC.Driver.DynFlags: [unfoldingOpts] :: DynFlags -> UnfoldingOpts

+ GHC.Driver.Env: HscEnv :: DynFlags -> [Target] -> InteractiveContext -> NameCache -> FinderCache -> KnotVars (IORef TypeEnv) -> Maybe Interp -> Plugins -> UnitEnv -> Logger -> Hooks -> TmpFs -> LlvmConfigCache -> HscEnv

+ GHC.Driver.Env: [hsc_FC] :: HscEnv -> FinderCache

+ GHC.Driver.Env: [hsc_NC] :: HscEnv -> NameCache

+ GHC.Driver.Env: [hsc_hooks] :: HscEnv -> Hooks

+ GHC.Driver.Env: [hsc_llvm_config] :: HscEnv -> LlvmConfigCache

+ GHC.Driver.Env: [hsc_logger] :: HscEnv -> Logger

+ GHC.Driver.Env: [hsc_plugins] :: HscEnv -> Plugins

+ GHC.Driver.Env: [hsc_tmpfs] :: HscEnv -> TmpFs

+ GHC.Driver.Env: lookupIfaceByModule :: HomeUnitGraph -> PackageIfaceTable -> Module -> IO (Maybe ModIface)

+ GHC.Driver.Env.Types: HscEnv :: DynFlags -> [Target] -> InteractiveContext -> NameCache -> FinderCache -> KnotVars (IORef TypeEnv) -> Maybe Interp -> Plugins -> UnitEnv -> Logger -> Hooks -> TmpFs -> LlvmConfigCache -> HscEnv

+ GHC.Driver.Env.Types: [hsc_FC] :: HscEnv -> FinderCache

+ GHC.Driver.Env.Types: [hsc_NC] :: HscEnv -> NameCache

+ GHC.Driver.Env.Types: [hsc_hooks] :: HscEnv -> Hooks

+ GHC.Driver.Env.Types: [hsc_llvm_config] :: HscEnv -> LlvmConfigCache

+ GHC.Driver.Env.Types: [hsc_logger] :: HscEnv -> Logger

+ GHC.Driver.Env.Types: [hsc_plugins] :: HscEnv -> Plugins

+ GHC.Driver.Env.Types: [hsc_tmpfs] :: HscEnv -> TmpFs

+ GHC.Driver.Errors.Types: PsHeaderMessage :: PsHeaderMessage -> PsMessage

+ GHC.Driver.Errors.Types: [DriverBackpackModuleNotFound] :: ModuleName -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverCannotImportFromUntrustedPackage] :: UnitState -> Module -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverCannotImportUnsafeModule] :: Module -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverCannotLoadInterfaceFile] :: Module -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverDuplicatedModuleDeclaration] :: Module -> [FilePath] -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverFileModuleNameMismatch] :: ModuleName -> ModuleName -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverFileNotFound] :: FilePath -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverHomePackagesNotClosed] :: [UnitId] -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverInferredSafeImport] :: Module -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverInferredSafeModule] :: Module -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverInterfaceError] :: IfaceMessage -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverMarkedTrustworthyButInferredSafe] :: Module -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverMissingHomeModules] :: UnitId -> [ModuleName] -> BuildingCabalPackage -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverMissingSafeHaskellMode] :: Module -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverMixedSafetyImport] :: ModuleName -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverModuleNotFound] :: UnitId -> ModuleName -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverPackageNotTrusted] :: UnitState -> UnitId -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverPsHeaderMessage] :: PsMessage -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverRedirectedNoMain] :: ModuleName -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverSafeHaskellIgnoredExtension] :: Extension -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverUnexpectedSignature] :: ModuleName -> BuildingCabalPackage -> GenInstantiations UnitId -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverUnknownMessage] :: UnknownDiagnosticFor DriverMessage -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverUnnecessarySourceImports] :: ModuleName -> DriverMessage

+ GHC.Driver.Errors.Types: [DriverUserDefinedRuleIgnored] :: RuleDecl GhcTc -> DriverMessage

+ GHC.Driver.Errors.Types: [GhcUnknownMessage] :: UnknownDiagnosticFor GhcMessage -> GhcMessage

+ GHC.Driver.Errors.Types: ghcUnknownMessage :: (DiagnosticOpts a ~ NoDiagnosticOpts, DiagnosticHint a ~ DiagnosticHint GhcMessage, Diagnostic a, Typeable a) => a -> GhcMessage

+ GHC.Driver.Flags: impliedXFlags :: [(Extension, OnOff Extension)]

+ GHC.Driver.Main: HscRecomp :: CgGuts -> ModLocation -> PartialModIface -> Maybe Fingerprint -> HscBackendAction

+ GHC.Driver.Main: [hscs_mod_location] :: HscBackendAction -> ModLocation

+ GHC.Driver.Main: [hscs_old_iface_hash] :: HscBackendAction -> Maybe Fingerprint

+ GHC.Driver.Main: [hscs_partial_iface] :: HscBackendAction -> PartialModIface

+ GHC.Driver.Make: FoundHome :: ModuleNodeInfo -> SummariseResult

+ GHC.Driver.Make: LoadUpTo :: [HomeUnitModule] -> LoadHowMuch

+ GHC.Driver.Make: ModNodeKeyWithUid :: ModuleNameWithIsBoot -> UnitId -> ModNodeKeyWithUid

+ GHC.Driver.Make: [mnkModuleName] :: ModNodeKeyWithUid -> ModuleNameWithIsBoot

+ GHC.Driver.Make: [mnkUnitId] :: ModNodeKeyWithUid -> UnitId

+ GHC.Driver.Make: depanalE :: GhcMonad m => (GhcMessage -> AnyGhcDiagnostic) -> Maybe Messager -> [ModuleName] -> Bool -> m (DriverMessages, ModuleGraph)

+ GHC.Driver.Make: depanalPartial :: GhcMonad m => (GhcMessage -> AnyGhcDiagnostic) -> Maybe Messager -> [ModuleName] -> Bool -> m (DriverMessages, ModuleGraph)

+ GHC.Driver.Make: downsweep :: HscEnv -> (GhcMessage -> AnyGhcDiagnostic) -> Maybe Messager -> [ModSummary] -> [ModuleName] -> Bool -> IO ([DriverMessages], ModuleGraph)

+ GHC.Driver.Make: implicitRequirementsShallow :: HscEnv -> [(ImportLevel, PkgQual, Located ModuleName)] -> IO ([ModuleName], [InstantiatedUnit])

+ GHC.Driver.Make: instantiationNodes :: UnitId -> UnitState -> [(UnitId, InstantiatedUnit)]

+ GHC.Driver.Make: ms_home_imps :: ModSummary -> [(ImportLevel, PkgQual, Located ModuleName)]

+ GHC.Driver.Make: topSortModuleGraph :: Bool -> ModuleGraph -> Maybe [HomeUnitModule] -> [SCC ModuleGraphNode]

+ GHC.Driver.Make: type AnyGhcDiagnostic = UnknownDiagnosticFor GhcMessage

+ GHC.Driver.Monad: Session :: IORef HscEnv -> Session

+ GHC.Driver.Pipeline.Execute: llvmOptions :: LlvmConfig -> DynFlags -> [(String, String)]

+ GHC.Driver.Pipeline.LogQueue: LogQueue :: Int -> IORef [Maybe (MessageClass, SrcSpan, SDoc, LogFlags)] -> MVar () -> LogQueue

+ GHC.Driver.Pipeline.LogQueue: [logQueueId] :: LogQueue -> Int

+ GHC.Driver.Pipeline.LogQueue: [logQueueMessages] :: LogQueue -> IORef [Maybe (MessageClass, SrcSpan, SDoc, LogFlags)]

+ GHC.Driver.Pipeline.LogQueue: [logQueueSemaphore] :: LogQueue -> MVar ()

+ GHC.Driver.Plugins: Plugins :: [StaticPlugin] -> [ExternalPlugin] -> [LoadedPlugin] -> ([Linkable], PkgsLoaded) -> Plugins

+ GHC.Driver.Plugins: [externalPlugins] :: Plugins -> [ExternalPlugin]

+ GHC.Driver.Plugins: [loadedPluginDeps] :: Plugins -> ([Linkable], PkgsLoaded)

+ GHC.Driver.Plugins: [loadedPlugins] :: Plugins -> [LoadedPlugin]

+ GHC.Driver.Plugins: [staticPlugins] :: Plugins -> [StaticPlugin]

+ GHC.Driver.Plugins.External: ExternalPluginSpec :: FilePath -> String -> String -> [String] -> ExternalPluginSpec

+ GHC.Driver.Plugins.External: [esp_args] :: ExternalPluginSpec -> [String]

+ GHC.Driver.Plugins.External: [esp_lib] :: ExternalPluginSpec -> FilePath

+ GHC.Driver.Plugins.External: [esp_module] :: ExternalPluginSpec -> String

+ GHC.Driver.Plugins.External: [esp_unit_id] :: ExternalPluginSpec -> String

+ GHC.Driver.Session: DynFlags :: GhcMode -> GhcLink -> Backend -> GhcNameVersion -> FileSettings -> UnitSettings -> Platform -> ToolSettings -> PlatformMisc -> [(String, String)] -> TempDir -> Int -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe ParMakeCount -> Bool -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Int -> Int -> Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Word -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Bool -> Maybe Int -> Int -> [FilePath] -> ModuleName -> Maybe String -> IntWithInf -> IntWithInf -> Int -> Int -> Int -> UnitId -> Maybe UnitId -> [(ModuleName, Module)] -> Maybe FilePath -> Maybe String -> Set ModuleName -> [ReexportedModule] -> Ways -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> String -> String -> String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Bool -> FilePath -> Maybe FilePath -> [Option] -> IncludeSpecs -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> [ExternalPluginSpec] -> FilePath -> Bool -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> EnumSet DumpFlag -> EnumSet GeneralFlag -> EnumSet WarningFlag -> EnumSet WarningFlag -> WarningCategorySet -> WarningCategorySet -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff Extension] -> EnumSet Extension -> UnfoldingOpts -> Int -> Int -> Int -> String -> Int -> Maybe String -> Maybe String -> Maybe String -> FlushOut -> Maybe FilePath -> Maybe String -> [String] -> Int -> Int -> Bool -> OverridingBool -> Bool -> OverridingBool -> Bool -> Scheme -> ProfAuto -> [CallerCcFilter] -> Maybe String -> Maybe SseVersion -> Maybe BmiVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Int -> Int -> Int -> Bool -> Maybe Int -> Word64 -> Int -> Weights -> DynFlags

+ GHC.Driver.Session: Settings :: GhcNameVersion -> FileSettings -> Platform -> ToolSettings -> PlatformMisc -> UnitSettings -> [(String, String)] -> Settings

+ GHC.Driver.Session: WarningWithCategory :: WarningCategory -> DiagnosticReason

+ GHC.Driver.Session: WarningWithFlags :: NonEmpty WarningFlag -> DiagnosticReason

+ GHC.Driver.Session: [backend] :: DynFlags -> Backend

+ GHC.Driver.Session: [dmdUnboxWidth] :: DynFlags -> Int

+ GHC.Driver.Session: [dynamicNow] :: DynFlags -> Bool

+ GHC.Driver.Session: [fileSettings] :: DynFlags -> FileSettings

+ GHC.Driver.Session: [ghcNameVersion] :: DynFlags -> GhcNameVersion

+ GHC.Driver.Session: [platformMisc] :: DynFlags -> PlatformMisc

+ GHC.Driver.Session: [sFileSettings] :: Settings -> FileSettings

+ GHC.Driver.Session: [sGhcNameVersion] :: Settings -> GhcNameVersion

+ GHC.Driver.Session: [sPlatformMisc] :: Settings -> PlatformMisc

+ GHC.Driver.Session: [sToolSettings] :: Settings -> ToolSettings

+ GHC.Driver.Session: [toolSettings] :: DynFlags -> ToolSettings

+ GHC.Driver.Session: [unfoldingOpts] :: DynFlags -> UnfoldingOpts

+ GHC.Driver.Session: impliedXFlags :: [(Extension, OnOff Extension)]

+ GHC.Driver.Session: makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Warn], [Located SDoc])

+ GHC.Driver.Session: parseDynamicFilePragma :: MonadIO m => Logger -> DynFlags -> [Located String] -> m (DynFlags, [Located String], Messages DriverMessage)

+ GHC.Driver.Session: parseDynamicFlagsCmdLine :: MonadIO m => Logger -> DynFlags -> [Located String] -> m (DynFlags, [Located String], Messages DriverMessage)

+ GHC.Driver.Session: parseDynamicFlagsFull :: MonadIO m => [Flag (CmdLineP DynFlags)] -> Bool -> Logger -> DynFlags -> [Located String] -> m (DynFlags, [Located String], Messages DriverMessage)

+ GHC.Hs: XModule :: XXModule p -> HsModule p

+ GHC.Hs.Binds: AnnSpecSig :: EpaLocation -> EpToken "#-}" -> Maybe TokDcolon -> ActivationAnn -> AnnSpecSig

+ GHC.Hs.Binds: [ass_dcolon] :: AnnSpecSig -> Maybe TokDcolon

+ GHC.Hs.Binds: pprMinimalSig :: forall (p :: Pass). OutputableBndrId p => LBooleanFormula (GhcPass p) -> SDoc

+ GHC.Hs.Decls: ConDeclGADT :: XConDeclGADT pass -> NonEmpty (LIdP pass) -> XRec pass (HsOuterSigTyVarBndrs pass) -> [HsForAllTelescope pass] -> Maybe (LHsContext pass) -> HsConDeclGADTDetails pass -> LHsType pass -> Maybe (LHsDoc pass) -> ConDecl pass

+ GHC.Hs.Decls: HsRule :: XHsRule pass -> XRec pass RuleName -> Activation -> RuleBndrs pass -> XRec pass (HsExpr pass) -> XRec pass (HsExpr pass) -> RuleDecl pass

+ GHC.Hs.Decls: PrefixConGADT :: XPrefixConGADT pass -> [HsConDeclField pass] -> HsConDeclGADTDetails pass

+ GHC.Hs.Decls: RecConGADT :: XRecConGADT pass -> XRec pass [LHsConDeclRecField pass] -> HsConDeclGADTDetails pass

+ GHC.Hs.Decls: XAnnDecl :: XXAnnDecl pass -> AnnDecl pass

+ GHC.Hs.Decls: XClsInstDecl :: XXClsInstDecl pass -> ClsInstDecl pass

+ GHC.Hs.Decls: XConDecl :: XXConDecl pass -> ConDecl pass

+ GHC.Hs.Decls: XConDeclGADTDetails :: XXConDeclGADTDetails pass -> HsConDeclGADTDetails pass

+ GHC.Hs.Decls: XDefaultDecl :: XXDefaultDecl pass -> DefaultDecl pass

+ GHC.Hs.Decls: XDerivClauseTys :: XXDerivClauseTys pass -> DerivClauseTys pass

+ GHC.Hs.Decls: XDerivDecl :: XXDerivDecl pass -> DerivDecl pass

+ GHC.Hs.Decls: XFamEqn :: XXFamEqn pass rhs -> FamEqn pass rhs

+ GHC.Hs.Decls: XFamilyDecl :: XXFamilyDecl pass -> FamilyDecl pass

+ GHC.Hs.Decls: XFamilyResultSig :: XXFamilyResultSig pass -> FamilyResultSig pass

+ GHC.Hs.Decls: XForeignDecl :: XXForeignDecl pass -> ForeignDecl pass

+ GHC.Hs.Decls: XForeignExport :: XXForeignExport pass -> ForeignExport pass

+ GHC.Hs.Decls: XForeignImport :: XXForeignImport pass -> ForeignImport pass

+ GHC.Hs.Decls: XFunDep :: XXFunDep pass -> FunDep pass

+ GHC.Hs.Decls: XHsDataDefn :: XXHsDataDefn pass -> HsDataDefn pass

+ GHC.Hs.Decls: XHsDecl :: XXHsDecl p -> HsDecl p

+ GHC.Hs.Decls: XHsDerivingClause :: XXHsDerivingClause pass -> HsDerivingClause pass

+ GHC.Hs.Decls: XHsGroup :: XXHsGroup p -> HsGroup p

+ GHC.Hs.Decls: XInjectivityAnn :: XXInjectivityAnn pass -> InjectivityAnn pass

+ GHC.Hs.Decls: XInstDecl :: XXInstDecl pass -> InstDecl pass

+ GHC.Hs.Decls: XRoleAnnotDecl :: XXRoleAnnotDecl pass -> RoleAnnotDecl pass

+ GHC.Hs.Decls: XRuleBndr :: XXRuleBndr pass -> RuleBndr pass

+ GHC.Hs.Decls: XRuleDecl :: XXRuleDecl pass -> RuleDecl pass

+ GHC.Hs.Decls: XRuleDecls :: XXRuleDecls pass -> RuleDecls pass

+ GHC.Hs.Decls: XSpliceDecl :: XXSpliceDecl p -> SpliceDecl p

+ GHC.Hs.Decls: XStandaloneKindSig :: XXStandaloneKindSig pass -> StandaloneKindSig pass

+ GHC.Hs.Decls: XTyClDecl :: XXTyClDecl pass -> TyClDecl pass

+ GHC.Hs.Decls: XTyClGroup :: XXTyClGroup pass -> TyClGroup pass

+ GHC.Hs.Decls: XTyFamInstDecl :: XXTyFamInstDecl pass -> TyFamInstDecl pass

+ GHC.Hs.Decls: XWarnDecl :: XXWarnDecl pass -> WarnDecl pass

+ GHC.Hs.Decls: XWarnDecls :: XXWarnDecls pass -> WarnDecls pass

+ GHC.Hs.Decls: familyDeclLName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> XRecGhc (IdGhcP p)

+ GHC.Hs.Decls: getRecConArgs_maybe :: ConDecl GhcRn -> Maybe (LocatedL [LHsConDeclRecField GhcRn])

+ GHC.Hs.Decls: hsGroupInstDecls :: forall (p :: Pass). HsGroup (GhcPass p) -> [LInstDecl (GhcPass p)]

+ GHC.Hs.Decls: pp_vanilla_decl_head :: forall (p :: Pass). OutputableBndrId p => XRecGhc (IdGhcP p) -> LHsQTyVars (GhcPass p) -> LexicalFixity -> Maybe (LHsContext (GhcPass p)) -> SDoc

+ GHC.Hs.Decls: tyClDeclTyVars :: forall (p :: Pass). TyClDecl (GhcPass p) -> LHsQTyVars (GhcPass p)

+ GHC.Hs.Decls: tyClGroupInstDecls :: forall (p :: Pass). [TyClGroup (GhcPass p)] -> [LInstDecl (GhcPass p)]

+ GHC.Hs.Decls: tyClGroupKindSigs :: forall (p :: Pass). [TyClGroup (GhcPass p)] -> [LStandaloneKindSig (GhcPass p)]

+ GHC.Hs.Decls: tyClGroupRoleDecls :: forall (p :: Pass). [TyClGroup (GhcPass p)] -> [LRoleAnnotDecl (GhcPass p)]

+ GHC.Hs.Decls: tyClGroupTyClDecls :: forall (p :: Pass). [TyClGroup (GhcPass p)] -> [LTyClDecl (GhcPass p)]

+ GHC.Hs.Decls: type HsConDeclH98Details pass = HsConDetails HsConDeclField pass XRec pass [LHsConDeclRecField pass]

+ GHC.Hs.Doc: DsiDocChunk :: HsDoc GhcRn -> DocStructureItem

+ GHC.Hs.Doc: DsiExports :: DetOrdAvails -> DocStructureItem

+ GHC.Hs.Doc: DsiModExport :: NonEmpty ModuleName -> DetOrdAvails -> DocStructureItem

+ GHC.Hs.Doc: DsiNamedChunkRef :: String -> DocStructureItem

+ GHC.Hs.Doc: DsiSectionHeading :: Int -> HsDoc GhcRn -> DocStructureItem

+ GHC.Hs.Doc: WithHsDocIdentifiers :: a -> [Located (IdP pass)] -> WithHsDocIdentifiers a pass

+ GHC.Hs.Doc: [hsDocIdentifiers] :: WithHsDocIdentifiers a pass -> [Located (IdP pass)]

+ GHC.Hs.Doc: [hsDocString] :: WithHsDocIdentifiers a pass -> a

+ GHC.Hs.DocString: HsDocStringGroup :: Int -> HsDocStringDecorator

+ GHC.Hs.DocString: HsDocStringNamed :: String -> HsDocStringDecorator

+ GHC.Hs.DocString: MultiLineDocString :: HsDocStringDecorator -> NonEmpty LHsDocStringChunk -> HsDocString

+ GHC.Hs.DocString: NestedDocString :: HsDocStringDecorator -> LHsDocStringChunk -> HsDocString

+ GHC.Hs.Expr: PendingRnSplice :: SplicePointName -> HsUntypedSplice GhcRn -> PendingRnSplice

+ GHC.Hs.Expr: PopErrCtxt :: LHsExpr GhcRn -> XXExprGhcRn

+ GHC.Hs.Expr: XApplicativeArg :: XXApplicativeArg idL -> ApplicativeArg idL

+ GHC.Hs.Expr: pprMatchContext :: Outputable p => HsMatchContext p -> SDoc

+ GHC.Hs.Expr: pprTypedSplice :: forall (p :: Pass). OutputableBndrId p => Maybe SplicePointName -> HsTypedSplice (GhcPass p) -> SDoc

+ GHC.Hs.Extension: type IsSrcSpanAnn (p :: Pass) a = (Anno IdGhcP p ~ EpAnn a, Anno IdOccGhcP p ~ EpAnn a, NoAnn a, IsPass p)

+ GHC.Hs.Extension: type OutputableBndrId (pass :: Pass) = (OutputableBndr IdGhcP pass, OutputableBndr IdOccGhcP pass, OutputableBndr IdGhcP NoGhcTcPass pass, OutputableBndr IdOccGhcP NoGhcTcPass pass, Outputable LIdGhcP pass, Outputable LIdOccGhcP pass, Outputable LIdGhcP NoGhcTcPass pass, Outputable LIdOccGhcP NoGhcTcPass pass, IsPass pass)

+ GHC.Hs.ImpExp: EpAnnImportDecl :: EpToken "import" -> Maybe (EpaLocation, EpToken "#-}") -> Maybe (EpToken "safe") -> Maybe EpAnnLevel -> Maybe (EpToken "qualified") -> Maybe EpaLocation -> Maybe (EpToken "as") -> EpAnnImportDecl

+ GHC.Hs.Lit: convertLit :: forall (p :: Pass) (p' :: Pass). XXLit (GhcPass p) ~ DataConCantHappen => HsLit (GhcPass p) -> HsLit (GhcPass p')

+ GHC.Hs.Lit: hsLitNeedsParens :: forall (x :: Pass). IsPass x => PprPrec -> HsLit (GhcPass x) -> Bool

+ GHC.Hs.Lit: pmPprHsLit :: forall (p :: Pass). IsPass p => HsLit (GhcPass p) -> SDoc

+ GHC.Hs.Pat: HsRecFields :: XHsRecFields p -> [LHsRecField p arg] -> Maybe (XRec p RecFieldsDotDot) -> HsRecFields p arg

+ GHC.Hs.Pat: XPat :: XXPat p -> Pat p

+ GHC.Hs.Pat: [rec_ext] :: HsRecFields p arg -> XHsRecFields p

+ GHC.Hs.Pat: hsRecFieldSel :: forall (p :: Pass) arg. HsRecField (GhcPass p) arg -> IdGhcP p

+ GHC.Hs.Pat: hsRecFields :: forall (p :: Pass) arg. HsRecFields (GhcPass p) arg -> [IdGhcP p]

+ GHC.Hs.Pat: hsRecFieldsArgs :: forall (p :: Pass) arg. HsRecFields (GhcPass p) arg -> [arg]

+ GHC.Hs.Pat: type HsConPatDetails p = HsConDetails LPat p HsRecFields p LPat p

+ GHC.Hs.Syn.Type: hsLitType :: forall (p :: Pass). IsPass p => HsLit (GhcPass p) -> Type

+ GHC.Hs.Type: EpLolly :: EpToken "\8888" -> EpLinear

+ GHC.Hs.Type: EpPct1 :: EpToken "%1" -> EpArrowOrColon -> EpLinear

+ GHC.Hs.Type: HsArgPar :: XArgPar p -> HsArg p tm ty

+ GHC.Hs.Type: HsBangTy :: (EpaLocation, EpToken "#-}", EpaLocation) -> HsSrcBang -> LHsType GhcPs -> HsTypeGhcPsExt

+ GHC.Hs.Type: HsBndrInvisible :: XBndrInvisible pass -> HsBndrVis pass

+ GHC.Hs.Type: HsBndrKind :: XBndrKind pass -> LHsKind pass -> HsBndrKind pass

+ GHC.Hs.Type: HsBndrNoKind :: XBndrNoKind pass -> HsBndrKind pass

+ GHC.Hs.Type: HsBndrRequired :: XBndrRequired pass -> HsBndrVis pass

+ GHC.Hs.Type: HsBndrVar :: XBndrVar pass -> LIdP pass -> HsBndrVar pass

+ GHC.Hs.Type: HsBndrWildCard :: XBndrWildCard pass -> HsBndrVar pass

+ GHC.Hs.Type: HsExplicitMult :: XExplicitMult mult pass -> mult -> HsMultAnnOf mult pass

+ GHC.Hs.Type: HsFunTy :: XFunTy pass -> HsMultAnn pass -> LHsType pass -> LHsType pass -> HsType pass

+ GHC.Hs.Type: HsOpTy :: XOpTy pass -> PromotionFlag -> LHsType pass -> LIdOccP pass -> LHsType pass -> HsType pass

+ GHC.Hs.Type: HsRecTy :: AnnList () -> [LHsConDeclRecField GhcPs] -> HsTypeGhcPsExt

+ GHC.Hs.Type: HsSrcBang :: SourceText -> SrcUnpackedness -> SrcStrictness -> HsSrcBang

+ GHC.Hs.Type: HsTyVar :: XTyVar pass -> PromotionFlag -> LIdOccP pass -> HsType pass

+ GHC.Hs.Type: HsTypeArg :: XTypeArg p -> ty -> HsArg p tm ty

+ GHC.Hs.Type: HsValArg :: XValArg p -> tm -> HsArg p tm ty

+ GHC.Hs.Type: InfixCon :: arg -> arg -> HsConDetails arg rec

+ GHC.Hs.Type: NormalOp :: WithUserRdr Name -> OpName

+ GHC.Hs.Type: PrefixCon :: [arg] -> HsConDetails arg rec

+ GHC.Hs.Type: RecCon :: rec -> HsConDetails arg rec

+ GHC.Hs.Type: XArg :: XXArg p -> HsArg p tm ty

+ GHC.Hs.Type: XBndrKind :: XXBndrKind pass -> HsBndrKind pass

+ GHC.Hs.Type: XBndrVar :: XXBndrVar pass -> HsBndrVar pass

+ GHC.Hs.Type: XBndrVis :: XXBndrVis pass -> HsBndrVis pass

+ GHC.Hs.Type: XFieldOcc :: XXFieldOcc pass -> FieldOcc pass

+ GHC.Hs.Type: XHsForAllTelescope :: XXHsForAllTelescope pass -> HsForAllTelescope pass

+ GHC.Hs.Type: XHsOuterTyVarBndrs :: XXHsOuterTyVarBndrs pass -> HsOuterTyVarBndrs flag pass

+ GHC.Hs.Type: XHsPatSigType :: XXHsPatSigType pass -> HsPatSigType pass

+ GHC.Hs.Type: XHsSigType :: XXHsSigType pass -> HsSigType pass

+ GHC.Hs.Type: XHsTyPat :: XXHsTyPat pass -> HsTyPat pass

+ GHC.Hs.Type: XHsType :: XXType pass -> HsType pass

+ GHC.Hs.Type: XHsWildCardBndrs :: XXHsWildCardBndrs pass thing -> HsWildCardBndrs pass thing

+ GHC.Hs.Type: XLHsQTyVars :: XXLHsQTyVars pass -> LHsQTyVars pass

+ GHC.Hs.Type: XTyLit :: XXTyLit pass -> HsTyLit pass

+ GHC.Hs.Type: XTyVarBndr :: XXTyVarBndr pass -> HsTyVarBndr flag pass

+ GHC.Hs.Type: data HsConDetails arg rec

+ GHC.Hs.Type: dropWildCards :: forall (p :: Pass). LHsSigWcType (GhcPass p) -> LHsSigType (GhcPass p)

+ GHC.Hs.Type: getLHsInstDeclClass_maybe :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => LHsSigType (GhcPass p) -> Maybe (LocatedN (IdOccP (GhcPass p)))

+ GHC.Hs.Type: hsPatSigType :: forall (p :: Pass). HsPatSigType (GhcPass p) -> LHsType (GhcPass p)

+ GHC.Hs.Type: hsSigWcType :: forall (p :: Pass). LHsSigWcType (GhcPass p) -> LHsType (GhcPass p)

+ GHC.Hs.Type: hsTyGetAppHead_maybe :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => LHsType (GhcPass p) -> Maybe (LocatedN (IdOccP (GhcPass p)))

+ GHC.Hs.Type: hsTypeNeedsParens :: forall (p :: Pass). IsPass p => PprPrec -> HsType (GhcPass p) -> Bool

+ GHC.Hs.Type: mkHsOpTy :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => PromotionFlag -> LHsType (GhcPass p) -> LocatedN (IdOccP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p)

+ GHC.Hs.Type: parenthesizeHsContext :: forall (p :: Pass). IsPass p => PprPrec -> LHsContext (GhcPass p) -> LHsContext (GhcPass p)

+ GHC.Hs.Type: parenthesizeHsType :: forall (p :: Pass). IsPass p => PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p)

+ GHC.Hs.Type: pprHsArrow :: forall mult (pass :: Pass). (Outputable mult, OutputableBndrId pass) => HsMultAnnOf mult (GhcPass pass) -> SDoc

+ GHC.Hs.Type: splitHsFunType :: LHsType GhcPs -> (([EpToken "("], [EpToken ")"]), EpAnnComments, [HsConDeclField GhcPs], LHsType GhcPs)

+ GHC.Hs.Type: splitLHsGadtTy :: LHsSigType GhcPs -> (HsOuterSigTyVarBndrs GhcPs, [HsForAllTelescope GhcPs], Maybe (LHsContext GhcPs), LHsType GhcPs)

+ GHC.Hs.Utils: TyDeclBinders :: (LocatedA (IdP (GhcPass p)), TyConFlavour ()) -> [(LocatedA (IdP (GhcPass p)), TyConFlavour ())] -> [LocatedA (IdP (GhcPass p))] -> LConsWithFields p -> TyDeclBinders (p :: Pass)

+ GHC.Hs.Utils: [tyDeclATs] :: TyDeclBinders (p :: Pass) -> [(LocatedA (IdP (GhcPass p)), TyConFlavour ())]

+ GHC.Hs.Utils: [tyDeclConsWithFields] :: TyDeclBinders (p :: Pass) -> LConsWithFields p

+ GHC.Hs.Utils: [tyDeclMainBinder] :: TyDeclBinders (p :: Pass) -> (LocatedA (IdP (GhcPass p)), TyConFlavour ())

+ GHC.Hs.Utils: [tyDeclOpSigs] :: TyDeclBinders (p :: Pass) -> [LocatedA (IdP (GhcPass p))]

+ GHC.Hs.Utils: isInfixFunBind :: forall (p1 :: Pass) (p2 :: Pass). HsBindLR (GhcPass p1) (GhcPass p2) -> Bool

+ GHC.Hs.Utils: nlHsTyConApp :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> LexicalFixity -> IdOccP (GhcPass p) -> [LHsTypeArg (GhcPass p)] -> LHsType (GhcPass p)

+ GHC.Hs.Utils: unguardedRHS :: forall (p :: Pass) body. Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ EpAnn NoEpAnns => EpAnn GrhsAnn -> SrcSpan -> LocatedA (body (GhcPass p)) -> NonEmpty (LGRHS (GhcPass p) (LocatedA (body (GhcPass p))))

+ GHC.HsToCore.Breakpoints: mkModBreaks :: Bool -> Module -> SizedSeq Tick -> ModBreaks

+ GHC.HsToCore.Docs: con_arg_docs :: Int -> [Maybe (LHsDoc GhcRn)] -> IntMap (HsDoc GhcRn)

+ GHC.HsToCore.Docs: mkDecls :: (decl -> hsDecl) -> [GenLocated l decl] -> [GenLocated l hsDecl]

+ GHC.HsToCore.Errors.Types: DsAnotherRuleMightFireFirst :: RuleName -> RuleName -> Var -> DsMessage

+ GHC.HsToCore.Errors.Types: DsCannotMixPolyAndUnliftedBindings :: HsBindLR GhcTc GhcTc -> DsMessage

+ GHC.HsToCore.Errors.Types: DsIdentitiesFound :: Id -> Type -> DsMessage

+ GHC.HsToCore.Errors.Types: DsInaccessibleRhs :: HsMatchContextRn -> SDoc -> DsMessage

+ GHC.HsToCore.Errors.Types: DsIncompleteRecordSelector :: Name -> [ConLike] -> Int -> DsMessage

+ GHC.HsToCore.Errors.Types: DsMaxPmCheckModelsReached :: MaxPmCheckModels -> DsMessage

+ GHC.HsToCore.Errors.Types: DsNonExhaustivePatterns :: HsMatchContextRn -> ExhaustivityCheckType -> MaxUncoveredPatterns -> [Id] -> [Nabla] -> DsMessage

+ GHC.HsToCore.Errors.Types: DsNotYetHandledByTH :: ThRejectionReason -> DsMessage

+ GHC.HsToCore.Errors.Types: DsOrphanRule :: CoreRule -> DsMessage

+ GHC.HsToCore.Errors.Types: DsOverflowedLiterals :: Integer -> Name -> Maybe (MinBound, MaxBound) -> NegLiteralExtEnabled -> DsMessage

+ GHC.HsToCore.Errors.Types: DsOverlappingPatterns :: HsMatchContextRn -> SDoc -> DsMessage

+ GHC.HsToCore.Errors.Types: DsRecBindsNotAllowedForUnliftedTys :: [LHsBindLR GhcTc GhcTc] -> DsMessage

+ GHC.HsToCore.Errors.Types: DsRedundantBangPatterns :: HsMatchContextRn -> SDoc -> DsMessage

+ GHC.HsToCore.Errors.Types: DsRuleBindersNotBound :: [Var] -> [Var] -> CoreExpr -> CoreExpr -> DsMessage

+ GHC.HsToCore.Errors.Types: DsRuleIgnoredDueToConstructor :: DataCon -> DsMessage

+ GHC.HsToCore.Errors.Types: DsRuleLhsTooComplicated :: CoreExpr -> CoreExpr -> DsMessage

+ GHC.HsToCore.Errors.Types: DsRuleMightInlineFirst :: RuleName -> Var -> Activation -> DsMessage

+ GHC.HsToCore.Errors.Types: DsTopLevelBindsNotAllowed :: BindsType -> HsBindLR GhcTc GhcTc -> DsMessage

+ GHC.HsToCore.Errors.Types: DsUnbangedStrictPatterns :: HsBindLR GhcTc GhcTc -> DsMessage

+ GHC.HsToCore.Errors.Types: DsUnknownMessage :: UnknownDiagnosticFor DsMessage -> DsMessage

+ GHC.HsToCore.Errors.Types: DsUnusedDoBind :: LHsExpr GhcTc -> Type -> DsMessage

+ GHC.HsToCore.Errors.Types: DsWrongDoBind :: LHsExpr GhcTc -> Type -> DsMessage

+ GHC.HsToCore.Errors.Types: ThAbstractClosedTypeFamily :: LFamilyDecl GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThAmbiguousRecordSelectors :: HsExpr GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThAmbiguousRecordUpdates :: HsRecUpdField GhcRn GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThCostCentres :: HsExpr GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThExoticFormOfType :: HsType GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThExoticLiteral :: HsLit GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThExoticPattern :: Pat GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThExpressionForm :: HsExpr GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThForeignExport :: LForeignDecl GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThForeignLabel :: CLabelString -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThGuardedLambdas :: Match GhcRn (LHsExpr GhcRn) -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThMonadComprehensionSyntax :: HsExpr GhcRn -> ThRejectionReason

+ GHC.HsToCore.Errors.Types: ThNegativeOverloadedPatterns :: Pat GhcRn -> ThRejectionReason

+ GHC.HsToCore.Expr: dsLit :: forall (p :: Pass). IsPass p => HsLit (GhcPass p) -> DsM CoreExpr

+ GHC.HsToCore.Match.Literal: dsLit :: forall (p :: Pass). IsPass p => HsLit (GhcPass p) -> DsM CoreExpr

+ GHC.HsToCore.Monad: addUnspecables :: [EvVar] -> DsM a -> DsM a

+ GHC.HsToCore.Monad: getUnspecables :: DsM (Maybe VarSet)

+ GHC.HsToCore.Pmc.Solver: PhiBotCt :: Id -> PhiCt

+ GHC.HsToCore.Pmc.Solver: PhiConCt :: Id -> PmAltCon -> [TyVar] -> [PredType] -> [Id] -> PhiCt

+ GHC.HsToCore.Pmc.Solver: PhiCoreCt :: Id -> CoreExpr -> PhiCt

+ GHC.HsToCore.Pmc.Solver: PhiNotBotCt :: Id -> PhiCt

+ GHC.HsToCore.Pmc.Solver: PhiNotConCt :: Id -> PmAltCon -> PhiCt

+ GHC.HsToCore.Pmc.Solver: PhiTyCt :: PredType -> PhiCt

+ GHC.HsToCore.Pmc.Solver.Types: MkNabla :: TyState -> TmState -> Nabla

+ GHC.HsToCore.Pmc.Solver.Types: PACA :: PmAltCon -> [TyVar] -> [Id] -> PmAltConApp

+ GHC.HsToCore.Pmc.Solver.Types: RCM :: Maybe DsCompleteMatch -> Maybe DsCompleteMatches -> ResidualCompleteMatches

+ GHC.HsToCore.Pmc.Solver.Types: TmSt :: UniqSDFM Id VarInfo -> CoreMap Id -> DIdSet -> TmState

+ GHC.HsToCore.Pmc.Solver.Types: TySt :: Int -> InertSet -> TyState

+ GHC.HsToCore.Pmc.Solver.Types: VI :: Id -> [PmAltConApp] -> PmAltConSet -> BotInfo -> ResidualCompleteMatches -> VarInfo

+ GHC.HsToCore.Pmc.Solver.Types: [nabla_tm_st] :: Nabla -> TmState

+ GHC.HsToCore.Pmc.Solver.Types: [nabla_ty_st] :: Nabla -> TyState

+ GHC.HsToCore.Pmc.Solver.Types: [paca_con] :: PmAltConApp -> PmAltCon

+ GHC.HsToCore.Pmc.Solver.Types: [paca_ids] :: PmAltConApp -> [Id]

+ GHC.HsToCore.Pmc.Solver.Types: [paca_tvs] :: PmAltConApp -> [TyVar]

+ GHC.HsToCore.Pmc.Solver.Types: [rcm_pragmas] :: ResidualCompleteMatches -> Maybe DsCompleteMatches

+ GHC.HsToCore.Pmc.Solver.Types: [rcm_vanilla] :: ResidualCompleteMatches -> Maybe DsCompleteMatch

+ GHC.HsToCore.Pmc.Solver.Types: [ts_dirty] :: TmState -> DIdSet

+ GHC.HsToCore.Pmc.Solver.Types: [ts_facts] :: TmState -> UniqSDFM Id VarInfo

+ GHC.HsToCore.Pmc.Solver.Types: [ts_reps] :: TmState -> CoreMap Id

+ GHC.HsToCore.Pmc.Solver.Types: [ty_st_inert] :: TyState -> InertSet

+ GHC.HsToCore.Pmc.Solver.Types: [ty_st_n] :: TyState -> Int

+ GHC.HsToCore.Pmc.Solver.Types: [vi_id] :: VarInfo -> Id

+ GHC.HsToCore.Pmc.Solver.Types: [vi_neg] :: VarInfo -> PmAltConSet

+ GHC.HsToCore.Pmc.Solver.Types: [vi_pos] :: VarInfo -> [PmAltConApp]

+ GHC.HsToCore.Pmc.Solver.Types: [vi_rcm] :: VarInfo -> ResidualCompleteMatches

+ GHC.HsToCore.Pmc.Types: CheckResult :: a -> Nablas -> Precision -> CheckResult a

+ GHC.HsToCore.Pmc.Types: GdAlt :: GrdDag -> GrdDag -> GrdDag

+ GHC.HsToCore.Pmc.Types: GdOne :: PmGrd -> GrdDag

+ GHC.HsToCore.Pmc.Types: GdSeq :: GrdDag -> GrdDag -> GrdDag

+ GHC.HsToCore.Pmc.Types: PmBang :: Id -> Maybe SrcInfo -> PmGrd

+ GHC.HsToCore.Pmc.Types: PmCon :: Id -> PmAltCon -> [TyVar] -> [EvVar] -> [Id] -> PmGrd

+ GHC.HsToCore.Pmc.Types: PmGRHS :: p -> SrcInfo -> PmGRHS p

+ GHC.HsToCore.Pmc.Types: PmGRHSs :: p -> NonEmpty (PmGRHS p) -> PmGRHSs p

+ GHC.HsToCore.Pmc.Types: PmLet :: Id -> CoreExpr -> PmGrd

+ GHC.HsToCore.Pmc.Types: PmMatch :: p -> PmGRHSs p -> PmMatch p

+ GHC.HsToCore.Pmc.Types: RedSets :: Nablas -> Nablas -> OrdList (Nablas, SrcInfo) -> RedSets

+ GHC.HsToCore.Pmc.Types: [_pm_let_expr] :: PmGrd -> CoreExpr

+ GHC.HsToCore.Pmc.Types: [_pm_loc] :: PmGrd -> Maybe SrcInfo

+ GHC.HsToCore.Pmc.Types: [cr_approx] :: CheckResult a -> Precision

+ GHC.HsToCore.Pmc.Types: [cr_ret] :: CheckResult a -> a

+ GHC.HsToCore.Pmc.Types: [cr_uncov] :: CheckResult a -> Nablas

+ GHC.HsToCore.Pmc.Types: [pg_grds] :: PmGRHS p -> p

+ GHC.HsToCore.Pmc.Types: [pg_rhs] :: PmGRHS p -> SrcInfo

+ GHC.HsToCore.Pmc.Types: [pgs_grhss] :: PmGRHSs p -> NonEmpty (PmGRHS p)

+ GHC.HsToCore.Pmc.Types: [pgs_lcls] :: PmGRHSs p -> p

+ GHC.HsToCore.Pmc.Types: [pm_con_args] :: PmGrd -> [Id]

+ GHC.HsToCore.Pmc.Types: [pm_con_con] :: PmGrd -> PmAltCon

+ GHC.HsToCore.Pmc.Types: [pm_con_dicts] :: PmGrd -> [EvVar]

+ GHC.HsToCore.Pmc.Types: [pm_con_tvs] :: PmGrd -> [TyVar]

+ GHC.HsToCore.Pmc.Types: [pm_grhss] :: PmMatch p -> PmGRHSs p

+ GHC.HsToCore.Pmc.Types: [pm_id] :: PmGrd -> Id

+ GHC.HsToCore.Pmc.Types: [pm_pats] :: PmMatch p -> p

+ GHC.HsToCore.Pmc.Types: [rs_bangs] :: RedSets -> OrdList (Nablas, SrcInfo)

+ GHC.HsToCore.Pmc.Types: [rs_cov] :: RedSets -> Nablas

+ GHC.HsToCore.Pmc.Types: [rs_div] :: RedSets -> Nablas

+ GHC.HsToCore.Ticks: TicksConfig :: [TickishType] -> ProfAuto -> Bool -> TicksConfig

+ GHC.HsToCore.Ticks: [ticks_countEntries] :: TicksConfig -> Bool

+ GHC.HsToCore.Ticks: [ticks_passes] :: TicksConfig -> [TickishType]

+ GHC.HsToCore.Ticks: [ticks_profAuto] :: TicksConfig -> ProfAuto

+ GHC.HsToCore.Types: DsLclEnv :: DsMetaEnv -> RealSrcSpan -> Nablas -> Maybe VarSet -> DsLclEnv

+ GHC.HsToCore.Types: [dsl_unspecables] :: DsLclEnv -> Maybe VarSet

+ GHC.HsToCore.Usage: UsageConfig :: Bool -> UsageConfig

+ GHC.HsToCore.Usage: [uc_safe_implicit_imps_req] :: UsageConfig -> Bool

+ GHC.HsToCore.Usage: mkUsageInfo :: UsageConfig -> Plugins -> FinderCache -> UnitEnv -> Module -> ImportedMods -> [ImportUserSpec] -> NameSet -> [FilePath] -> [(Module, Fingerprint)] -> [Linkable] -> PkgsLoaded -> IfG [Usage]

+ GHC.Iface.Binary: BinSymbolTable :: FastMutInt -> IORef (UniqFM Name (Int, Name)) -> BinSymbolTable

+ GHC.Iface.Binary: [bin_symtab_map] :: BinSymbolTable -> IORef (UniqFM Name (Int, Name))

+ GHC.Iface.Binary: [bin_symtab_next] :: BinSymbolTable -> FastMutInt

+ GHC.Iface.Binary: readBinIfaceHeader :: Profile -> NameCache -> CheckHiWay -> TraceBinIFace -> FilePath -> IO ReadBinHandle

+ GHC.Iface.Errors.Ppr: IfaceMessageOpts :: Bool -> BuildingCabalPackage -> IfaceMessageOpts

+ GHC.Iface.Errors.Ppr: [ifaceBuildingCabalPackage] :: IfaceMessageOpts -> BuildingCabalPackage