ghc-8.2.2: The GHC API

Safe Haskell | None
Language | Haskell2010

TcRnTypes

Synopsis

- type TcRnIf a b = IOEnv (Env a b)
- type TcRn = TcRnIf TcGblEnv TcLclEnv
- type TcM = TcRn
- type RnM = TcRn
- type IfM lcl = TcRnIf IfGblEnv lcl
- type IfL = IfM IfLclEnv
- type IfG = IfM ()
- type TcRef a = IORef a
- data Env gbl lcl = Env {
  - env_top :: HscEnv
  - env_us :: !(IORef UniqSupply)
  - env_gbl :: gbl
  - env_lcl :: lcl
  }
- data TcGblEnv = TcGblEnv {
  - tcg_mod :: Module
  - tcg_semantic_mod :: Module
  - tcg_src :: HscSource
  - tcg_rdr_env :: GlobalRdrEnv
  - tcg_default :: Maybe [Type]
  - tcg_fix_env :: FixityEnv
  - tcg_field_env :: RecFieldEnv
  - tcg_type_env :: TypeEnv
  - tcg_type_env_var :: TcRef TypeEnv
  - tcg_inst_env :: InstEnv
  - tcg_fam_inst_env :: FamInstEnv
  - tcg_ann_env :: AnnEnv
  - tcg_pending_fam_checks :: NameEnv [([FamInst], FamInstEnv)]
  - tcg_exports :: [AvailInfo]
  - tcg_imports :: ImportAvails
  - tcg_dus :: DefUses
  - tcg_used_gres :: TcRef [GlobalRdrElt]
  - tcg_keep :: TcRef NameSet
  - tcg_th_used :: TcRef Bool
  - tcg_th_splice_used :: TcRef Bool
  - tcg_th_top_level_locs :: TcRef (Set RealSrcSpan)
  - tcg_dfun_n :: TcRef OccSet
  - tcg_merged :: [(Module, Fingerprint)]
  - tcg_rn_exports :: Maybe [Located (IE Name)]
  - tcg_rn_imports :: [LImportDecl Name]
  - tcg_rn_decls :: Maybe (HsGroup Name)
  - tcg_dependent_files :: TcRef [FilePath]
  - tcg_th_topdecls :: TcRef [LHsDecl RdrName]
  - tcg_th_foreign_files :: TcRef [(ForeignSrcLang, String)]
  - tcg_th_topnames :: TcRef NameSet
  - tcg_th_modfinalizers :: TcRef [TcM ()]
  - tcg_th_state :: TcRef (Map TypeRep Dynamic)
  - tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState)))
  - tcg_ev_binds :: Bag EvBind
  - tcg_tr_module :: Maybe Id
  - tcg_binds :: LHsBinds Id
  - tcg_sigs :: NameSet
  - tcg_imp_specs :: [LTcSpecPrag]
  - tcg_warns :: Warnings
  - tcg_anns :: [Annotation]
  - tcg_tcs :: [TyCon]
  - tcg_insts :: [ClsInst]
  - tcg_fam_insts :: [FamInst]
  - tcg_rules :: [LRuleDecl Id]
  - tcg_fords :: [LForeignDecl Id]
  - tcg_vects :: [LVectDecl Id]
  - tcg_patsyns :: [PatSyn]
  - tcg_doc_hdr :: Maybe LHsDocString
  - tcg_hpc :: AnyHpcUsage
  - tcg_self_boot :: SelfBootInfo
  - tcg_main :: Maybe Name
  - tcg_safeInfer :: TcRef (Bool, WarningMessages)
  - tcg_tc_plugins :: [TcPluginSolver]
  - tcg_top_loc :: RealSrcSpan
  - tcg_static_wc :: TcRef WantedConstraints
  - tcg_complete_matches :: [CompleteMatch]
  }
- data TcLclEnv = TcLclEnv {
  - tcl_loc :: RealSrcSpan
  - tcl_ctxt :: [ErrCtxt]
  - tcl_tclvl :: TcLevel
  - tcl_th_ctxt :: ThStage
  - tcl_th_bndrs :: ThBindEnv
  - tcl_arrow_ctxt :: ArrowCtxt
  - tcl_rdr :: LocalRdrEnv
  - tcl_env :: TcTypeEnv
  - tcl_bndrs :: TcIdBinderStack
  - tcl_tidy :: TidyEnv
  - tcl_tyvars :: TcRef TcTyVarSet
  - tcl_lie :: TcRef WantedConstraints
  - tcl_errs :: TcRef Messages
  }
- data IfGblEnv = IfGblEnv {
  - if_doc :: SDoc
  - if_rec_types :: Maybe (Module, IfG TypeEnv)
  }
- data IfLclEnv = IfLclEnv {
  - if_mod :: Module
  - if_boot :: Bool
  - if_loc :: SDoc
  - if_nsubst :: Maybe NameShape
  - if_implicits_env :: Maybe TypeEnv
  - if_tv_env :: FastStringEnv TyVar
  - if_id_env :: FastStringEnv Id
  }
- tcVisibleOrphanMods :: TcGblEnv -> ModuleSet
- data FrontendResult = FrontendTypecheck TcGblEnv
- type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, MsgDoc))
- type RecFieldEnv = NameEnv [FieldLabel]
- data ImportAvails = ImportAvails {
  - imp_mods :: ImportedMods
  - imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface)
  - imp_dep_pkgs :: Set InstalledUnitId
  - imp_trust_pkgs :: Set InstalledUnitId
  - imp_trust_own_pkg :: Bool
  - imp_orphs :: [Module]
  - imp_finsts :: [Module]
  }
- emptyImportAvails :: ImportAvails
- plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails
- data WhereFrom
  - = ImportByUser IsBootInterface
  - | ImportBySystem
  - | ImportByPlugin
- mkModDeps :: [(ModuleName, IsBootInterface)] -> ModuleNameEnv (ModuleName, IsBootInterface)
- modDepsElts :: ModuleNameEnv (ModuleName, IsBootInterface) -> [(ModuleName, IsBootInterface)]
- type TcTypeEnv = NameEnv TcTyThing
- type TcIdBinderStack = [TcIdBinder]
- data TcIdBinder
  - = TcIdBndr TcId TopLevelFlag
  - | TcIdBndr_ExpType Name ExpType TopLevelFlag
- data TcTyThing
  - = AGlobal TyThing
  - | ATcId {
    - tct_id :: TcId
    - tct_info :: IdBindingInfo
    }
  - | ATyVar Name TcTyVar
  - | ATcTyCon TyCon
  - | APromotionErr PromotionErr
- data PromotionErr
  - = TyConPE
  - | ClassPE
  - | FamDataConPE
  - | PatSynPE
  - | RecDataConPE
  - | NoDataKindsTC
  - | NoDataKindsDC
  - | NoTypeInTypeTC
  - | NoTypeInTypeDC
- data IdBindingInfo
  - = NotLetBound
  - | ClosedLet
  - | NonClosedLet RhsNames ClosedTypeId
- type ClosedTypeId = Bool
- type RhsNames = NameSet
- data IsGroupClosed = IsGroupClosed (NameEnv RhsNames) ClosedTypeId
- data SelfBootInfo
  - = NoSelfBoot
  - | SelfBoot {
    - sb_mds :: ModDetails
    - sb_tcs :: NameSet
    }
- pprTcTyThingCategory :: TcTyThing -> SDoc
- pprPECategory :: PromotionErr -> SDoc
- data CompleteMatch = CompleteMatch {
  - completeMatchConLikes :: [Name]
  - completeMatchTyCon :: Name
  }
- type DsM = TcRnIf DsGblEnv DsLclEnv
- data DsLclEnv = DsLclEnv {
  - dsl_meta :: DsMetaEnv
  - dsl_loc :: RealSrcSpan
  - dsl_dicts :: Bag EvVar
  - dsl_tm_cs :: Bag SimpleEq
  - dsl_pm_iter :: IORef Int
  }
- data DsGblEnv = DsGblEnv {
  - ds_mod :: Module
  - ds_fam_inst_env :: FamInstEnv
  - ds_unqual :: PrintUnqualified
  - ds_msgs :: IORef Messages
  - ds_if_env :: (IfGblEnv, IfLclEnv)
  - ds_dph_env :: GlobalRdrEnv
  - ds_parr_bi :: PArrBuiltin
  - ds_complete_matches :: CompleteMatchMap
  }
- data PArrBuiltin = PArrBuiltin {
  - lengthPVar :: Var
  - replicatePVar :: Var
  - singletonPVar :: Var
  - mapPVar :: Var
  - filterPVar :: Var
  - zipPVar :: Var
  - crossMapPVar :: Var
  - indexPVar :: Var
  - emptyPVar :: Var
  - appPVar :: Var
  - enumFromToPVar :: Var
  - enumFromThenToPVar :: Var
  }
- type DsMetaEnv = NameEnv DsMetaVal
- data DsMetaVal
  - = DsBound Id
  - | DsSplice (HsExpr Id)
- type CompleteMatchMap = UniqFM [CompleteMatch]
- mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap
- extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch] -> CompleteMatchMap
- data ThStage
  - = Splice SpliceType
  - | RunSplice (TcRef [ForeignRef (Q ())])
  - | Comp
  - | Brack ThStage PendingStuff
- data SpliceType
  - = Typed
  - | Untyped
- data PendingStuff
  - = RnPendingUntyped (TcRef [PendingRnSplice])
  - | RnPendingTyped
  - | TcPending (TcRef [PendingTcSplice]) (TcRef WantedConstraints)
- topStage :: ThStage
- topAnnStage :: ThStage
- topSpliceStage :: ThStage
- type ThLevel = Int
- impLevel :: ThLevel
- outerLevel :: ThLevel
- thLevel :: ThStage -> ThLevel
- data ForeignSrcLang :: *
  - = LangC
  - | LangCxx
  - | LangObjc
  - | LangObjcxx
- data ArrowCtxt
  - = NoArrowCtxt
  - | ArrowCtxt LocalRdrEnv (TcRef WantedConstraints)
- type TcSigFun = Name -> Maybe TcSigInfo
- data TcSigInfo
  - = TcIdSig TcIdSigInfo
  - | TcPatSynSig TcPatSynInfo
- data TcIdSigInfo
  - = CompleteSig {
    - sig_bndr :: TcId
    - sig_ctxt :: UserTypeCtxt
    - sig_loc :: SrcSpan
    }
  - | PartialSig {
    - psig_name :: Name
    - psig_hs_ty :: LHsSigWcType Name
    - sig_ctxt :: UserTypeCtxt
    - sig_loc :: SrcSpan
    }
- data TcIdSigInst = TISI {
  - sig_inst_sig :: TcIdSigInfo
  - sig_inst_skols :: [(Name, TcTyVar)]
  - sig_inst_theta :: TcThetaType
  - sig_inst_tau :: TcSigmaType
  - sig_inst_wcs :: [(Name, TcTyVar)]
  - sig_inst_wcx :: Maybe TcTyVar
  }
- data TcPatSynInfo = TPSI {
  - patsig_name :: Name
  - patsig_implicit_bndrs :: [TyVarBinder]
  - patsig_univ_bndrs :: [TyVar]
  - patsig_req :: TcThetaType
  - patsig_ex_bndrs :: [TyVar]
  - patsig_prov :: TcThetaType
  - patsig_body_ty :: TcSigmaType
  }
- isPartialSig :: TcIdSigInst -> Bool
- hasCompleteSig :: TcSigFun -> Name -> Bool
- type Xi = Type
- data Ct
  - = CDictCan {
    - cc_ev :: CtEvidence
    - cc_class :: Class
    - cc_tyargs :: [Xi]
    - cc_pend_sc :: Bool
    }
  - | CIrredEvCan {
    - cc_ev :: CtEvidence
    }
  - | CTyEqCan {
    - cc_ev :: CtEvidence
    - cc_tyvar :: TcTyVar
    - cc_rhs :: TcType
    - cc_eq_rel :: EqRel
    }
  - | CFunEqCan {
    - cc_ev :: CtEvidence
    - cc_fun :: TyCon
    - cc_tyargs :: [Xi]
    - cc_fsk :: TcTyVar
    }
  - | CNonCanonical {
    - cc_ev :: CtEvidence
    }
  - | CHoleCan {
    - cc_ev :: CtEvidence
    - cc_hole :: Hole
    }
- type Cts = Bag Ct
- emptyCts :: Cts
- andCts :: Cts -> Cts -> Cts
- andManyCts :: [Cts] -> Cts
- pprCts :: Cts -> SDoc
- singleCt :: Ct -> Cts
- listToCts :: [Ct] -> Cts
- ctsElts :: Cts -> [Ct]
- consCts :: Ct -> Cts -> Cts
- snocCts :: Cts -> Ct -> Cts
- extendCtsList :: Cts -> [Ct] -> Cts
- isEmptyCts :: Cts -> Bool
- isCTyEqCan :: Ct -> Bool
- isCFunEqCan :: Ct -> Bool
- isPendingScDict :: Ct -> Maybe Ct
- superClassesMightHelp :: Ct -> Bool
- isCDictCan_Maybe :: Ct -> Maybe Class
- isCFunEqCan_maybe :: Ct -> Maybe (TyCon, [Type])
- isCIrredEvCan :: Ct -> Bool
- isCNonCanonical :: Ct -> Bool
- isWantedCt :: Ct -> Bool
- isDerivedCt :: Ct -> Bool
- isGivenCt :: Ct -> Bool
- isHoleCt :: Ct -> Bool
- isOutOfScopeCt :: Ct -> Bool
- isExprHoleCt :: Ct -> Bool
- isTypeHoleCt :: Ct -> Bool
- isUserTypeErrorCt :: Ct -> Bool
- getUserTypeErrorMsg :: Ct -> Maybe Type
- ctEvidence :: Ct -> CtEvidence
- ctLoc :: Ct -> CtLoc
- setCtLoc :: Ct -> CtLoc -> Ct
- ctPred :: Ct -> PredType
- ctFlavour :: Ct -> CtFlavour
- ctEqRel :: Ct -> EqRel
- ctOrigin :: Ct -> CtOrigin
- mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType
- mkNonCanonical :: CtEvidence -> Ct
- mkNonCanonicalCt :: Ct -> Ct
- mkGivens :: CtLoc -> [EvId] -> [Ct]
- ctEvPred :: CtEvidence -> TcPredType
- ctEvLoc :: CtEvidence -> CtLoc
- ctEvOrigin :: CtEvidence -> CtOrigin
- ctEvEqRel :: CtEvidence -> EqRel
- ctEvTerm :: CtEvidence -> EvTerm
- ctEvCoercion :: CtEvidence -> Coercion
- ctEvId :: CtEvidence -> TcId
- tyCoVarsOfCt :: Ct -> TcTyCoVarSet
- tyCoVarsOfCts :: Cts -> TcTyCoVarSet
- tyCoVarsOfCtList :: Ct -> [TcTyCoVar]
- tyCoVarsOfCtsList :: Cts -> [TcTyCoVar]
- data WantedConstraints = WC {
  - wc_simple :: Cts
  - wc_impl :: Bag Implication
  - wc_insol :: Cts
  }
- insolubleWC :: WantedConstraints -> Bool
- emptyWC :: WantedConstraints
- isEmptyWC :: WantedConstraints -> Bool
- andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints
- unionsWC :: [WantedConstraints] -> WantedConstraints
- mkSimpleWC :: [CtEvidence] -> WantedConstraints
- mkImplicWC :: Bag Implication -> WantedConstraints
- addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints
- getInsolubles :: WantedConstraints -> Cts
- insolublesOnly :: WantedConstraints -> WantedConstraints
- addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints
- addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints
- tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet
- dropDerivedWC :: WantedConstraints -> WantedConstraints
- dropDerivedSimples :: Cts -> Cts
- dropDerivedInsols :: Cts -> Cts
- tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar]
- trulyInsoluble :: Ct -> Bool
- isDroppableDerivedLoc :: CtLoc -> Bool
- insolubleImplic :: Implication -> Bool
- arisesFromGivens :: Ct -> Bool
- data Implication = Implic {
  - ic_tclvl :: TcLevel
  - ic_skols :: [TcTyVar]
  - ic_info :: SkolemInfo
  - ic_given :: [EvVar]
  - ic_no_eqs :: Bool
  - ic_env :: TcLclEnv
  - ic_wanted :: WantedConstraints
  - ic_binds :: EvBindsVar
  - ic_needed :: VarSet
  - ic_status :: ImplicStatus
  }
- data ImplicStatus
  - = IC_Solved {
    - ics_need :: VarSet
    - ics_dead :: [EvVar]
    }
  - | IC_Insoluble
  - | IC_Unsolved
- isInsolubleStatus :: ImplicStatus -> Bool
- isSolvedStatus :: ImplicStatus -> Bool
- data SubGoalDepth
- initialSubGoalDepth :: SubGoalDepth
- maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
- bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth
- subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool
- data CtLoc = CtLoc {
  - ctl_origin :: CtOrigin
  - ctl_env :: TcLclEnv
  - ctl_t_or_k :: Maybe TypeOrKind
  - ctl_depth :: !SubGoalDepth
  }
- ctLocSpan :: CtLoc -> RealSrcSpan
- ctLocEnv :: CtLoc -> TcLclEnv
- ctLocLevel :: CtLoc -> TcLevel
- ctLocOrigin :: CtLoc -> CtOrigin
- ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind
- ctLocDepth :: CtLoc -> SubGoalDepth
- bumpCtLocDepth :: CtLoc -> CtLoc
- setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc
- setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc
- setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc
- data CtOrigin
  - = GivenOrigin SkolemInfo
  - | OccurrenceOf Name
  - | OccurrenceOfRecSel RdrName
  - | AppOrigin
  - | SpecPragOrigin UserTypeCtxt
  - | TypeEqOrigin {
    - uo_actual :: TcType
    - uo_expected :: TcType
    - uo_thing :: Maybe ErrorThing
    }
  - | KindEqOrigin TcType (Maybe TcType) CtOrigin (Maybe TypeOrKind)
  - | IPOccOrigin HsIPName
  - | OverLabelOrigin FastString
  - | LiteralOrigin (HsOverLit Name)
  - | NegateOrigin
  - | ArithSeqOrigin (ArithSeqInfo Name)
  - | PArrSeqOrigin (ArithSeqInfo Name)
  - | SectionOrigin
  - | TupleOrigin
  - | ExprSigOrigin
  - | PatSigOrigin
  - | PatOrigin
  - | ProvCtxtOrigin (PatSynBind Name Name)
  - | RecordUpdOrigin
  - | ViewPatOrigin
  - | ScOrigin TypeSize
  - | DerivOrigin
  - | DerivOriginDC DataCon Int
  - | DerivOriginCoerce Id Type Type
  - | StandAloneDerivOrigin
  - | DefaultOrigin
  - | DoOrigin
  - | DoPatOrigin (LPat Name)
  - | MCompOrigin
  - | MCompPatOrigin (LPat Name)
  - | IfOrigin
  - | ProcOrigin
  - | AnnOrigin
  - | FunDepOrigin1 PredType CtLoc PredType CtLoc
  - | FunDepOrigin2 PredType CtOrigin PredType SrcSpan
  - | HoleOrigin
  - | UnboundOccurrenceOf OccName
  - | ListOrigin
  - | StaticOrigin
  - | FailablePattern (LPat TcId)
  - | Shouldn'tHappenOrigin String
  - | InstProvidedOrigin Module ClsInst
- exprCtOrigin :: HsExpr Name -> CtOrigin
- lexprCtOrigin :: LHsExpr Name -> CtOrigin
- matchesCtOrigin :: MatchGroup Name (LHsExpr Name) -> CtOrigin
- grhssCtOrigin :: GRHSs Name (LHsExpr Name) -> CtOrigin
- data ErrorThing = Outputable a => ErrorThing a (Maybe Arity) (TidyEnv -> a -> TcM (TidyEnv, a))
- mkErrorThing :: Outputable a => a -> ErrorThing
- errorThingNumArgs_maybe :: ErrorThing -> Maybe Arity
- data TypeOrKind
  - = TypeLevel
  - | KindLevel
- isTypeLevel :: TypeOrKind -> Bool
- isKindLevel :: TypeOrKind -> Bool
- pprCtOrigin :: CtOrigin -> SDoc
- pprCtLoc :: CtLoc -> SDoc
- pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc
- pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc
- data SkolemInfo
  - = SigSkol UserTypeCtxt TcType [(Name, TcTyVar)]
  - | ClsSkol Class
  - | DerivSkol Type
  - | InstSkol
  - | InstSC TypeSize
  - | DataSkol
  - | FamInstSkol
  - | PatSkol ConLike (HsMatchContext Name)
  - | ArrowSkol
  - | IPSkol [HsIPName]
  - | RuleSkol RuleName
  - | InferSkol [(Name, TcType)]
  - | BracketSkol
  - | UnifyForAllSkol TcType
  - | UnkSkol
- pprSigSkolInfo :: UserTypeCtxt -> TcType -> SDoc
- pprSkolInfo :: SkolemInfo -> SDoc
- termEvidenceAllowed :: SkolemInfo -> Bool
- data CtEvidence
  - = CtGiven {
    - ctev_pred :: TcPredType
    - ctev_evar :: EvVar
    - ctev_loc :: CtLoc
    }
  - | CtWanted {
    - ctev_pred :: TcPredType
    - ctev_dest :: TcEvDest
    - ctev_nosh :: ShadowInfo
    - ctev_loc :: CtLoc
    }
  - | CtDerived {
    - ctev_pred :: TcPredType
    - ctev_loc :: CtLoc
    }
- data TcEvDest
  - = EvVarDest EvVar
  - | HoleDest CoercionHole
- mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
- mkKindLoc :: TcType -> TcType -> CtLoc -> CtLoc
- toKindLoc :: CtLoc -> CtLoc
- isWanted :: CtEvidence -> Bool
- isGiven :: CtEvidence -> Bool
- isDerived :: CtEvidence -> Bool
- isGivenOrWDeriv :: CtFlavour -> Bool
- ctEvRole :: CtEvidence -> Role
- data TcPlugin = TcPlugin {
  - tcPluginInit :: TcPluginM s
  - tcPluginSolve :: s -> TcPluginSolver
  - tcPluginStop :: s -> TcPluginM ()
  }
- data TcPluginResult
  - = TcPluginContradiction [Ct]
  - | TcPluginOk [(EvTerm, Ct)] [Ct]
- type TcPluginSolver = [Ct] -> [Ct] -> [Ct] -> TcPluginM TcPluginResult
- data TcPluginM a
- runTcPluginM :: TcPluginM a -> EvBindsVar -> TcM a
- unsafeTcPluginTcM :: TcM a -> TcPluginM a
- getEvBindsTcPluginM :: TcPluginM EvBindsVar
- data CtFlavour
  - = Given
  - | Wanted ShadowInfo
  - | Derived
- data ShadowInfo
  - = WDeriv
  - | WOnly
- ctEvFlavour :: CtEvidence -> CtFlavour
- type CtFlavourRole = (CtFlavour, EqRel)
- ctEvFlavourRole :: CtEvidence -> CtFlavourRole
- ctFlavourRole :: Ct -> CtFlavourRole
- eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
- eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
- eqCanDischarge :: CtEvidence -> CtEvidence -> Bool
- funEqCanDischarge :: CtEvidence -> CtEvidence -> (SwapFlag, Bool)
- funEqCanDischargeF :: CtFlavour -> CtFlavour -> (SwapFlag, Bool)
- pprEvVarTheta :: [EvVar] -> SDoc
- pprEvVars :: [EvVar] -> SDoc
- pprEvVarWithType :: EvVar -> SDoc
- type TcId = Id
- type TcIdSet = IdSet
- data Hole
  - = ExprHole UnboundVar
  - | TypeHole OccName
- holeOcc :: Hole -> OccName
- data NameShape = NameShape {
  - ns_mod_name :: ModuleName
  - ns_exports :: [AvailInfo]
  - ns_map :: OccEnv Name
  }

# Documentation

type TcRnIf a b = IOEnv (Env a b) #

type TcRn = TcRnIf TcGblEnv TcLclEnv #

type TcM = TcRn #

Historical "type-checking monad" (now it's just `TcRn`).

type RnM = TcRn #

Historical "renaming monad" (now it's just `TcRn`).

type IfM lcl = TcRnIf IfGblEnv lcl #

type IfL = IfM IfLclEnv #

type IfG = IfM () #

type TcRef a = IORef a #

Type alias for `IORef`; the convention is we'll use this for mutable bits of data in `TcGblEnv` which are updated during typechecking and returned at the end.

data Env gbl lcl #

Constructors

Env |

Fields

- env_top :: HscEnv
- env_us :: !(IORef UniqSupply)
- env_gbl :: gbl
- env_lcl :: lcl

Instances

ContainsModule gbl => ContainsModule (Env gbl lcl) # |
Methods extractModule :: Env gbl lcl -> Module #
ContainsDynFlags (Env gbl lcl) # |
Methods extractDynFlags :: Env gbl lcl -> DynFlags #

data TcGblEnv #

`TcGblEnv` describes the top-level of the module at the point at which the typechecker is finished work. It is this structure that is handed on to the desugarer For state that needs to be updated during the typechecking phase and returned at end, use a `TcRef` (= `IORef`).

Constructors

TcGblEnv |

Fields

- tcg_mod :: Module

  Module being compiled

- tcg_semantic_mod :: Module

  If a signature, the backing module See also Note [Identity versus semantic module]

- tcg_src :: HscSource

  What kind of module (regular Haskell, hs-boot, hsig)

- tcg_rdr_env :: GlobalRdrEnv

  Top level envt; used during renaming

- tcg_default :: Maybe [Type]

  Types used for defaulting. `Nothing` => no `default` decl

- tcg_fix_env :: FixityEnv

  Just for things in this module

- tcg_field_env :: RecFieldEnv

  Just for things in this module See Note [The interactive package] in HscTypes

- tcg_type_env :: TypeEnv

  Global type env for the module we are compiling now. All TyCons and Classes (for this module) end up in here right away, along with their derived constructors, selectors.

  (Ids defined in this module start in the local envt, though they move to the global envt during zonking)

  NB: for what "things in this module" means, see Note [The interactive package] in HscTypes

- tcg_type_env_var :: TcRef TypeEnv
- tcg_inst_env :: InstEnv

  Instance envt for all home-package modules; Includes the dfuns in tcg_insts

- tcg_fam_inst_env :: FamInstEnv

  Ditto for family instances

- tcg_ann_env :: AnnEnv

  And for annotations

- tcg_pending_fam_checks :: NameEnv [([FamInst], FamInstEnv)]

  Family instances we have to check for consistency. Invariant: each FamInst in the list's fi_fam matches the key of the entry in the `NameEnv`. This gets consumed by `checkRecFamInstConsistency`. See Note [Don't check hs-boot type family instances too early]

- tcg_exports :: [AvailInfo]

  What is exported

- tcg_imports :: ImportAvails

  Information about what was imported from where, including things bound in this module. Also store Safe Haskell info here about transative trusted packaage requirements.

- tcg_dus :: DefUses

  What is defined in this module and what is used.

- tcg_used_gres :: TcRef [GlobalRdrElt]

  Records occurrences of imported entities See Note [Tracking unused binding and imports]

- tcg_keep :: TcRef NameSet

  Locally-defined top-level names to keep alive.

  "Keep alive" means give them an Exported flag, so that the simplifier does not discard them as dead code, and so that they are exposed in the interface file (but not to export to the user).

  Some things, like dict-fun Ids and default-method Ids are "born" with the Exported flag on, for exactly the above reason, but some we only discover as we go. Specifically:

  - The to/from functions for generic data types
  - Top-level variables appearing free in the RHS of an orphan rule
  - Top-level variables appearing free in a TH bracket
- tcg_th_used :: TcRef Bool

  `True` = Template Haskell syntax used.

  We need this so that we can generate a dependency on the Template Haskell package, because the desugarer is going to emit loads of references to TH symbols. The reference is implicit rather than explicit, so we have to zap a mutable variable.

- tcg_th_splice_used :: TcRef Bool

  `True` = A Template Haskell splice was used.

  Splices disable recompilation avoidance (see #481)

- tcg_th_top_level_locs :: TcRef (Set RealSrcSpan)

  Locations of the top-level splices; used for providing details on scope in error messages for out-of-scope variables

- tcg_dfun_n :: TcRef OccSet

  Allows us to choose unique DFun names.

- tcg_merged :: [(Module, Fingerprint)]

  The requirements we merged with; we always have to recompile if any of these changed.

- tcg_rn_exports :: Maybe [Located (IE Name)]
- tcg_rn_imports :: [LImportDecl Name]
- tcg_rn_decls :: Maybe (HsGroup Name)

  Renamed decls, maybe. `Nothing` = Don't retain renamed decls.

- tcg_dependent_files :: TcRef [FilePath]

  dependencies from addDependentFile

- tcg_th_topdecls :: TcRef [LHsDecl RdrName]

  Top-level declarations from addTopDecls

- tcg_th_foreign_files :: TcRef [(ForeignSrcLang, String)]

  Foreign files emitted from TH.

- tcg_th_topnames :: TcRef NameSet

  Exact names bound in top-level declarations in tcg_th_topdecls

- tcg_th_modfinalizers :: TcRef [TcM ()]

  Template Haskell module finalizers.

  They are computations in the `TcM` monad rather than `Q` because we set them to use particular local environments.

- tcg_th_state :: TcRef (Map TypeRep Dynamic)
- tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState)))

  Template Haskell state

- tcg_ev_binds :: Bag EvBind
- tcg_tr_module :: Maybe Id
- tcg_binds :: LHsBinds Id
- tcg_sigs :: NameSet
- tcg_imp_specs :: [LTcSpecPrag]
- tcg_warns :: Warnings
- tcg_anns :: [Annotation]
- tcg_tcs :: [TyCon]
- tcg_insts :: [ClsInst]
- tcg_fam_insts :: [FamInst]
- tcg_rules :: [LRuleDecl Id]
- tcg_fords :: [LForeignDecl Id]
- tcg_vects :: [LVectDecl Id]
- tcg_patsyns :: [PatSyn]
- tcg_doc_hdr :: Maybe LHsDocString

  Maybe Haddock header docs

- tcg_hpc :: AnyHpcUsage

  `True` if any part of the prog uses hpc instrumentation.

- tcg_self_boot :: SelfBootInfo

  Whether this module has a corresponding hi-boot file

- tcg_main :: Maybe Name

  The Name of the main function, if this module is the main module.

- tcg_safeInfer :: TcRef (Bool, WarningMessages)

  Has the typechecker inferred this module as -XSafe (Safe Haskell) See Note [Safe Haskell Overlapping Instances Implementation], although this is used for more than just that failure case.

- tcg_tc_plugins :: [TcPluginSolver]

  A list of user-defined plugins for the constraint solver.

- tcg_top_loc :: RealSrcSpan

  The RealSrcSpan this module came from

- tcg_static_wc :: TcRef WantedConstraints

  Wanted constraints of static forms. See Note [Constraints in static forms].

- tcg_complete_matches :: [CompleteMatch]

Instances

ContainsModule TcGblEnv # |
Methods extractModule :: TcGblEnv -> Module #

data TcLclEnv #

Constructors

TcLclEnv |

Fields

- tcl_loc :: RealSrcSpan
- tcl_ctxt :: [ErrCtxt]
- tcl_tclvl :: TcLevel
- tcl_th_ctxt :: ThStage
- tcl_th_bndrs :: ThBindEnv
- tcl_arrow_ctxt :: ArrowCtxt
- tcl_rdr :: LocalRdrEnv
- tcl_env :: TcTypeEnv
- tcl_bndrs :: TcIdBinderStack
- tcl_tidy :: TidyEnv
- tcl_tyvars :: TcRef TcTyVarSet
- tcl_lie :: TcRef WantedConstraints
- tcl_errs :: TcRef Messages

data IfGblEnv #

Constructors

IfGblEnv |

Fields

- if_doc :: SDoc
- if_rec_types :: Maybe (Module, IfG TypeEnv)

data IfLclEnv #

Constructors

IfLclEnv |

Fields

- if_mod :: Module
- if_boot :: Bool
- if_loc :: SDoc
- if_nsubst :: Maybe NameShape
- if_implicits_env :: Maybe TypeEnv
- if_tv_env :: FastStringEnv TyVar
- if_id_env :: FastStringEnv Id

tcVisibleOrphanMods :: TcGblEnv -> ModuleSet #

data FrontendResult #

`FrontendResult` describes the result of running the frontend of a Haskell module. Usually, you'll get a `FrontendTypecheck`, since running the frontend involves typechecking a program, but for an hs-boot merge you'll just get a ModIface, since no actual typechecking occurred.

This data type really should be in HscTypes, but it needs to have a TcGblEnv which is only defined here.

Constructors

FrontendTypecheck TcGblEnv |

type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, MsgDoc)) #

type RecFieldEnv = NameEnv [FieldLabel] #

data ImportAvails #

`ImportAvails` summarises what was imported from where, irrespective of whether the imported things are actually used or not. It is used:

- when processing the export list,
- when constructing usage info for the interface file,
- to identify the list of directly imported modules for initialisation purposes and for optimised overlap checking of family instances,
- when figuring out what things are really unused

Constructors

ImportAvails |

Fields

- imp_mods :: ImportedMods

  Domain is all directly-imported modules

  See the documentation on ImportedModsVal in HscTypes for the meaning of the fields.

  We need a full ModuleEnv rather than a ModuleNameEnv here, because we might be importing modules of the same name from different packages. (currently not the case, but might be in the future).

- imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface)

  Home-package modules needed by the module being compiled

  It doesn't matter whether any of these dependencies are actually used when compiling the module; they are listed if they are below it at all. For example, suppose M imports A which imports X. Then compiling M might not need to consult X.hi, but X is still listed in M's dependencies.

- imp_dep_pkgs :: Set InstalledUnitId

  Packages needed by the module being compiled, whether directly, or via other modules in this package, or via modules imported from other packages.

- imp_trust_pkgs :: Set InstalledUnitId

  This is strictly a subset of imp_dep_pkgs and records the packages the current module needs to trust for Safe Haskell compilation to succeed. A package is required to be trusted if we are dependent on a trustworthy module in that package. While perhaps making imp_dep_pkgs a tuple of (UnitId, Bool) where True for the bool indicates the package is required to be trusted is the more logical design, doing so complicates a lot of code not concerned with Safe Haskell. See Note [RnNames . Tracking Trust Transitively]

- imp_trust_own_pkg :: Bool

  Do we require that our own package is trusted? This is to handle efficiently the case where a Safe module imports a Trustworthy module that resides in the same package as it. See Note [RnNames . Trust Own Package]

- imp_orphs :: [Module]

  Orphan modules below us in the import tree (and maybe including us for imported modules)

- imp_finsts :: [Module]

  Family instance modules below us in the import tree (and maybe including us for imported modules)

emptyImportAvails :: ImportAvails #

plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails #

Union two ImportAvails

This function is a key part of Import handling, basically for each import we create a separate ImportAvails structure and then union them all together with this function.

data WhereFrom #

Constructors

ImportByUser IsBootInterface |
ImportBySystem |
ImportByPlugin |

Instances

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

mkModDeps :: [(ModuleName, IsBootInterface)] -> ModuleNameEnv (ModuleName, IsBootInterface) #

modDepsElts :: ModuleNameEnv (ModuleName, IsBootInterface) -> [(ModuleName, IsBootInterface)] #

type TcTypeEnv = NameEnv TcTyThing #

type TcIdBinderStack = [TcIdBinder] #

data TcIdBinder #

Constructors

TcIdBndr TcId TopLevelFlag |
TcIdBndr_ExpType Name ExpType TopLevelFlag |

Instances

Outputable TcIdBinder # |
Methods ppr :: TcIdBinder -> SDoc # pprPrec :: Rational -> TcIdBinder -> SDoc #
HasOccName TcIdBinder # |
Methods occName :: TcIdBinder -> OccName #

data TcTyThing #

A typecheckable thing available in a local context. Could be `AGlobal` `TyThing`, but also lexically scoped variables, etc. See `TcEnv` for how to retrieve a `TyThing` given a `Name`.

Constructors

AGlobal TyThing |
ATcId |

Fields

- tct_id :: TcId
- tct_info :: IdBindingInfo

ATyVar Name TcTyVar |
ATcTyCon TyCon |
APromotionErr PromotionErr |

Instances

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

data PromotionErr #

Constructors

TyConPE |
ClassPE |
FamDataConPE |
PatSynPE |
RecDataConPE |
NoDataKindsTC |
NoDataKindsDC |
NoTypeInTypeTC |
NoTypeInTypeDC |

Instances

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

data IdBindingInfo #

IdBindingInfo describes how an Id is bound.

It is used for the following purposes: a) for static forms in TcExpr.checkClosedInStaticForm and b) to figure out when a nested binding can be generalised, in TcBinds.decideGeneralisationPlan.

Constructors

NotLetBound |
ClosedLet |
NonClosedLet RhsNames ClosedTypeId |

Instances

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

type ClosedTypeId = Bool #

type RhsNames = NameSet #

data IsGroupClosed #

IsGroupClosed describes a group of mutually-recursive bindings

Constructors

IsGroupClosed (NameEnv RhsNames) ClosedTypeId |

data SelfBootInfo #

Constructors

NoSelfBoot |
SelfBoot |

Fields

- sb_mds :: ModDetails
- sb_tcs :: NameSet

pprTcTyThingCategory :: TcTyThing -> SDoc #

pprPECategory :: PromotionErr -> SDoc #

data CompleteMatch #

A list of conlikes which represents a complete pattern match. These arise from `COMPLETE` signatures.

Constructors

CompleteMatch |

Fields

- completeMatchConLikes :: [Name]

  The ConLikes that form a covering family (e.g. Nothing, Just)

- completeMatchTyCon :: Name

  The TyCon that they cover (e.g. Maybe)

Instances

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

type DsM = TcRnIf DsGblEnv DsLclEnv #

data DsLclEnv #

Constructors

DsLclEnv |

Fields

- dsl_meta :: DsMetaEnv
- dsl_loc :: RealSrcSpan
- dsl_dicts :: Bag EvVar
- dsl_tm_cs :: Bag SimpleEq
- dsl_pm_iter :: IORef Int

data DsGblEnv #

Constructors

DsGblEnv |

Fields

- ds_mod :: Module
- ds_fam_inst_env :: FamInstEnv
- ds_unqual :: PrintUnqualified
- ds_msgs :: IORef Messages
- ds_if_env :: (IfGblEnv, IfLclEnv)
- ds_dph_env :: GlobalRdrEnv
- ds_parr_bi :: PArrBuiltin
- ds_complete_matches :: CompleteMatchMap

Instances

ContainsModule DsGblEnv # |
Methods extractModule :: DsGblEnv -> Module #

data PArrBuiltin #

Constructors

PArrBuiltin |

Fields

- lengthPVar :: Var

  lengthP

- replicatePVar :: Var

  replicateP

- singletonPVar :: Var

  singletonP

- mapPVar :: Var

  mapP

- filterPVar :: Var

  filterP

- zipPVar :: Var

  zipP

- crossMapPVar :: Var

  crossMapP

- indexPVar :: Var

  (!:)

- emptyPVar :: Var

  emptyP

- appPVar :: Var

  (+:+)

- enumFromToPVar :: Var

  enumFromToP

- enumFromThenToPVar :: Var

  enumFromThenToP

type DsMetaEnv = NameEnv DsMetaVal #

data DsMetaVal #

Constructors

DsBound Id |
DsSplice (HsExpr Id) |

type CompleteMatchMap = UniqFM [CompleteMatch] #

A map keyed by the `completeMatchTyCon`.

mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap #

extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch] -> CompleteMatchMap #

data ThStage #

Constructors

Splice SpliceType |
RunSplice (TcRef [ForeignRef (Q ())]) |
Comp |
Brack ThStage PendingStuff |

Instances

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

data SpliceType #

Constructors

Typed |
Untyped |

data PendingStuff #

Constructors

RnPendingUntyped (TcRef [PendingRnSplice]) |
RnPendingTyped |
TcPending (TcRef [PendingTcSplice]) (TcRef WantedConstraints) |

topStage :: ThStage #

topAnnStage :: ThStage #

topSpliceStage :: ThStage #

type ThLevel = Int #

impLevel :: ThLevel #

outerLevel :: ThLevel #

thLevel :: ThStage -> ThLevel #

data ForeignSrcLang :: * Source #

Constructors

LangC |
LangCxx |
LangObjc |
LangObjcxx |

Instances

Eq ForeignSrcLang |
Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool #
Show ForeignSrcLang |
Methods showsPrec :: Int -> ForeignSrcLang -> ShowS Source # show :: ForeignSrcLang -> String Source # showList :: [ForeignSrcLang] -> ShowS Source #
Generic ForeignSrcLang |
Associated Types type Rep ForeignSrcLang :: * -> * Source # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x Source # to :: Rep ForeignSrcLang x -> ForeignSrcLang Source #
type Rep ForeignSrcLang |
type Rep ForeignSrcLang = D1 * (MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-8.2.2" False) ((:+:) * ((:+:) * (C1 * (MetaCons "LangC" PrefixI False) (U1 *)) (C1 * (MetaCons "LangCxx" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "LangObjc" PrefixI False) (U1 *)) (C1 * (MetaCons "LangObjcxx" PrefixI False) (U1 *))))

data ArrowCtxt #

Constructors

NoArrowCtxt |
ArrowCtxt LocalRdrEnv (TcRef WantedConstraints) |

type TcSigFun = Name -> Maybe TcSigInfo #

data TcSigInfo #

Constructors

TcIdSig TcIdSigInfo |
TcPatSynSig TcPatSynInfo |

Instances

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

data TcIdSigInfo #

Constructors

CompleteSig |

Fields

- sig_bndr :: TcId
- sig_ctxt :: UserTypeCtxt
- sig_loc :: SrcSpan

PartialSig |

Fields

- psig_name :: Name
- psig_hs_ty :: LHsSigWcType Name
- sig_ctxt :: UserTypeCtxt
- sig_loc :: SrcSpan

Instances

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

data TcIdSigInst #

Constructors

TISI |

Fields

- sig_inst_sig :: TcIdSigInfo
- sig_inst_skols :: [(Name, TcTyVar)]
- sig_inst_theta :: TcThetaType
- sig_inst_tau :: TcSigmaType
- sig_inst_wcs :: [(Name, TcTyVar)]
- sig_inst_wcx :: Maybe TcTyVar

Instances

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

data TcPatSynInfo #

Constructors

TPSI |

Fields

- patsig_name :: Name
- patsig_implicit_bndrs :: [TyVarBinder]
- patsig_univ_bndrs :: [TyVar]
- patsig_req :: TcThetaType
- patsig_ex_bndrs :: [TyVar]
- patsig_prov :: TcThetaType
- patsig_body_ty :: TcSigmaType

Instances

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

isPartialSig :: TcIdSigInst -> Bool #

hasCompleteSig :: TcSigFun -> Name -> Bool #

No signature or a partial signature

type Xi = Type #

data Ct #

Constructors

CDictCan |

Fields

- cc_ev :: CtEvidence
- cc_class :: Class
- cc_tyargs :: [Xi]
- cc_pend_sc :: Bool

CIrredEvCan |

Fields

- cc_ev :: CtEvidence

CTyEqCan |

Fields

- cc_ev :: CtEvidence
- cc_tyvar :: TcTyVar
- cc_rhs :: TcType
- cc_eq_rel :: EqRel

CFunEqCan |

Fields

- cc_ev :: CtEvidence
- cc_fun :: TyCon
- cc_tyargs :: [Xi]
- cc_fsk :: TcTyVar

CNonCanonical |

Fields

- cc_ev :: CtEvidence

CHoleCan |

Fields

- cc_ev :: CtEvidence
- cc_hole :: Hole

Instances

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

type Cts = Bag Ct #

emptyCts :: Cts #

andCts :: Cts -> Cts -> Cts #

andManyCts :: [Cts] -> Cts #

pprCts :: Cts -> SDoc #

singleCt :: Ct -> Cts #

listToCts :: [Ct] -> Cts #

ctsElts :: Cts -> [Ct] #

consCts :: Ct -> Cts -> Cts #

snocCts :: Cts -> Ct -> Cts #

extendCtsList :: Cts -> [Ct] -> Cts #

isEmptyCts :: Cts -> Bool #

isCTyEqCan :: Ct -> Bool #

isCFunEqCan :: Ct -> Bool #

isPendingScDict :: Ct -> Maybe Ct #

superClassesMightHelp :: Ct -> Bool #

True if taking superclasses of givens, or of wanteds (to perhaps expose more equalities or functional dependencies) might help to solve this constraint. See Note [When superclasses help]

isCDictCan_Maybe :: Ct -> Maybe Class #

isCFunEqCan_maybe :: Ct -> Maybe (TyCon, [Type]) #

isCIrredEvCan :: Ct -> Bool #

isCNonCanonical :: Ct -> Bool #

isWantedCt :: Ct -> Bool #

isDerivedCt :: Ct -> Bool #

isGivenCt :: Ct -> Bool #

isHoleCt :: Ct -> Bool #

isOutOfScopeCt :: Ct -> Bool #

isExprHoleCt :: Ct -> Bool #

isTypeHoleCt :: Ct -> Bool #

isUserTypeErrorCt :: Ct -> Bool #

getUserTypeErrorMsg :: Ct -> Maybe Type #

A constraint is considered to be a custom type error, if it contains custom type errors anywhere in it. See Note [Custom type errors in constraints]

ctEvidence :: Ct -> CtEvidence #

ctLoc :: Ct -> CtLoc #

setCtLoc :: Ct -> CtLoc -> Ct #

ctPred :: Ct -> PredType #

ctFlavour :: Ct -> CtFlavour #

Get the flavour of the given `Ct`

ctEqRel :: Ct -> EqRel #

Get the equality relation for the given `Ct`

ctOrigin :: Ct -> CtOrigin #

mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType #

Makes a new equality predicate with the same role as the given evidence.

mkNonCanonical :: CtEvidence -> Ct #

mkNonCanonicalCt :: Ct -> Ct #

mkGivens :: CtLoc -> [EvId] -> [Ct] #

ctEvPred :: CtEvidence -> TcPredType #

ctEvLoc :: CtEvidence -> CtLoc #

ctEvOrigin :: CtEvidence -> CtOrigin #

ctEvEqRel :: CtEvidence -> EqRel #

Get the equality relation relevant for a `CtEvidence`

ctEvTerm :: CtEvidence -> EvTerm #

ctEvCoercion :: CtEvidence -> Coercion #

ctEvId :: CtEvidence -> TcId #

tyCoVarsOfCt :: Ct -> TcTyCoVarSet #

Returns free variables of constraints as a non-deterministic set

tyCoVarsOfCts :: Cts -> TcTyCoVarSet #

Returns free variables of a bag of constraints as a non-deterministic set. See Note [Deterministic FV] in FV.

tyCoVarsOfCtList :: Ct -> [TcTyCoVar] #

Returns free variables of constraints as a deterministically ordered. list. See Note [Deterministic FV] in FV.

tyCoVarsOfCtsList :: Cts -> [TcTyCoVar] #

Returns free variables of a bag of constraints as a deterministically odered list. See Note [Deterministic FV] in FV.

data WantedConstraints #

Constructors

WC |

Fields

- wc_simple :: Cts
- wc_impl :: Bag Implication
- wc_insol :: Cts

Instances

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

insolubleWC :: WantedConstraints -> Bool #

emptyWC :: WantedConstraints #

isEmptyWC :: WantedConstraints -> Bool #

andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints #

unionsWC :: [WantedConstraints] -> WantedConstraints #

mkSimpleWC :: [CtEvidence] -> WantedConstraints #

mkImplicWC :: Bag Implication -> WantedConstraints #

addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints #

getInsolubles :: WantedConstraints -> Cts #

insolublesOnly :: WantedConstraints -> WantedConstraints #

addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints #

addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints #

tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet #

Returns free variables of WantedConstraints as a non-deterministic set. See Note [Deterministic FV] in FV.

dropDerivedWC :: WantedConstraints -> WantedConstraints #

dropDerivedSimples :: Cts -> Cts #

dropDerivedInsols :: Cts -> Cts #

tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar] #

Returns free variables of WantedConstraints as a deterministically ordered list. See Note [Deterministic FV] in FV.

trulyInsoluble :: Ct -> Bool #

isDroppableDerivedLoc :: CtLoc -> Bool #

insolubleImplic :: Implication -> Bool #

arisesFromGivens :: Ct -> Bool #

data Implication #

Constructors

Implic |

Fields

- ic_tclvl :: TcLevel
- ic_skols :: [TcTyVar]
- ic_info :: SkolemInfo
- ic_given :: [EvVar]
- ic_no_eqs :: Bool
- ic_env :: TcLclEnv
- ic_wanted :: WantedConstraints
- ic_binds :: EvBindsVar
- ic_needed :: VarSet
- ic_status :: ImplicStatus

Instances

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

data ImplicStatus #

Constructors

IC_Solved |

Fields

- ics_need :: VarSet
- ics_dead :: [EvVar]

IC_Insoluble |
IC_Unsolved |

Instances

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

isInsolubleStatus :: ImplicStatus -> Bool #

isSolvedStatus :: ImplicStatus -> Bool #

data SubGoalDepth #

See Note [SubGoalDepth]

Instances

Eq SubGoalDepth # |
Methods (==) :: SubGoalDepth -> SubGoalDepth -> Bool # (/=) :: SubGoalDepth -> SubGoalDepth -> Bool #
Ord SubGoalDepth # |
Methods compare :: SubGoalDepth -> SubGoalDepth -> Ordering # (<) :: SubGoalDepth -> SubGoalDepth -> Bool # (<=) :: SubGoalDepth -> SubGoalDepth -> Bool # (>) :: SubGoalDepth -> SubGoalDepth -> Bool # (>=) :: SubGoalDepth -> SubGoalDepth -> Bool # max :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth # min :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth #
Outputable SubGoalDepth # |
Methods ppr :: SubGoalDepth -> SDoc # pprPrec :: Rational -> SubGoalDepth -> SDoc #

initialSubGoalDepth :: SubGoalDepth #

maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth #

bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth #

subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool #

data CtLoc #

Constructors

CtLoc |

Fields

- ctl_origin :: CtOrigin
- ctl_env :: TcLclEnv
- ctl_t_or_k :: Maybe TypeOrKind
- ctl_depth :: !SubGoalDepth

ctLocSpan :: CtLoc -> RealSrcSpan #

ctLocEnv :: CtLoc -> TcLclEnv #

ctLocLevel :: CtLoc -> TcLevel #

ctLocOrigin :: CtLoc -> CtOrigin #

ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind #

ctLocDepth :: CtLoc -> SubGoalDepth #

bumpCtLocDepth :: CtLoc -> CtLoc #

setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc #

setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc #

setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc #

data CtOrigin #

Constructors

GivenOrigin SkolemInfo |
OccurrenceOf Name |
OccurrenceOfRecSel RdrName |
AppOrigin |
SpecPragOrigin UserTypeCtxt |
TypeEqOrigin |

Fields

- uo_actual :: TcType
- uo_expected :: TcType
- uo_thing :: Maybe ErrorThing

  The thing that has type "actual"

KindEqOrigin TcType (Maybe TcType) CtOrigin (Maybe TypeOrKind) |
IPOccOrigin HsIPName |
OverLabelOrigin FastString |
LiteralOrigin (HsOverLit Name) |
NegateOrigin |
ArithSeqOrigin (ArithSeqInfo Name) |
PArrSeqOrigin (ArithSeqInfo Name) |
SectionOrigin |
TupleOrigin |
ExprSigOrigin |
PatSigOrigin |
PatOrigin |
ProvCtxtOrigin (PatSynBind Name Name) |
RecordUpdOrigin |
ViewPatOrigin |
ScOrigin TypeSize |
DerivOrigin |
DerivOriginDC DataCon Int |
DerivOriginCoerce Id Type Type |
StandAloneDerivOrigin |
DefaultOrigin |
DoOrigin |
DoPatOrigin (LPat Name) |
MCompOrigin |
MCompPatOrigin (LPat Name) |
IfOrigin |
ProcOrigin |
AnnOrigin |
FunDepOrigin1 PredType CtLoc PredType CtLoc |
FunDepOrigin2 PredType CtOrigin PredType SrcSpan |
HoleOrigin |
UnboundOccurrenceOf OccName |
ListOrigin |
StaticOrigin |
FailablePattern (LPat TcId) |
Shouldn'tHappenOrigin String |
InstProvidedOrigin Module ClsInst |

Instances

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

exprCtOrigin :: HsExpr Name -> CtOrigin #

lexprCtOrigin :: LHsExpr Name -> CtOrigin #

Extract a suitable CtOrigin from a HsExpr

matchesCtOrigin :: MatchGroup Name (LHsExpr Name) -> CtOrigin #

Extract a suitable CtOrigin from a MatchGroup

grhssCtOrigin :: GRHSs Name (LHsExpr Name) -> CtOrigin #

Extract a suitable CtOrigin from guarded RHSs

data ErrorThing #

A thing that can be stored for error message generation only. It is stored with a function to zonk and tidy the thing.

Constructors

Outputable a => ErrorThing a (Maybe Arity) (TidyEnv -> a -> TcM (TidyEnv, a)) |

Instances

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

mkErrorThing :: Outputable a => a -> ErrorThing #

Make an `ErrorThing` that doesn't need tidying or zonking

errorThingNumArgs_maybe :: ErrorThing -> Maybe Arity #

Retrieve the # of arguments in the error thing, if known

data TypeOrKind #

Flag to see whether we're type-checking terms or kind-checking types

Constructors

TypeLevel |
KindLevel |

Instances

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

isTypeLevel :: TypeOrKind -> Bool #

isKindLevel :: TypeOrKind -> Bool #

pprCtOrigin :: CtOrigin -> SDoc #

pprCtLoc :: CtLoc -> SDoc #

pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc #

pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc #

data SkolemInfo #

Constructors

SigSkol UserTypeCtxt TcType [(Name, TcTyVar)] |
ClsSkol Class |
DerivSkol Type |
InstSkol |
InstSC TypeSize |
DataSkol |
FamInstSkol |
PatSkol ConLike (HsMatchContext Name) |
ArrowSkol |
IPSkol [HsIPName] |
RuleSkol RuleName |
InferSkol [(Name, TcType)] |
BracketSkol |
UnifyForAllSkol TcType |
UnkSkol |

Instances

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

pprSigSkolInfo :: UserTypeCtxt -> TcType -> SDoc #

pprSkolInfo :: SkolemInfo -> SDoc #

termEvidenceAllowed :: SkolemInfo -> Bool #

data CtEvidence #

Constructors

CtGiven |

Fields

- ctev_pred :: TcPredType
- ctev_evar :: EvVar
- ctev_loc :: CtLoc

CtWanted |

Fields

- ctev_pred :: TcPredType
- ctev_dest :: TcEvDest
- ctev_nosh :: ShadowInfo
- ctev_loc :: CtLoc

CtDerived |

Fields

- ctev_pred :: TcPredType
- ctev_loc :: CtLoc

Instances

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

data TcEvDest #

A place for type-checking evidence to go after it is generated. Wanted equalities are always HoleDest; other wanteds are always EvVarDest.

Constructors

EvVarDest EvVar | bind this var to the evidence EvVarDest is always used for non-type-equalities e.g. class constraints
HoleDest CoercionHole | fill in this hole with the evidence HoleDest is always used for type-equalities See Note [Coercion holes] in TyCoRep

Instances

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

mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc #

mkKindLoc :: TcType -> TcType -> CtLoc -> CtLoc #

toKindLoc :: CtLoc -> CtLoc #

Take a CtLoc and moves it to the kind level

isWanted :: CtEvidence -> Bool #

isGiven :: CtEvidence -> Bool #

isDerived :: CtEvidence -> Bool #

isGivenOrWDeriv :: CtFlavour -> Bool #

ctEvRole :: CtEvidence -> Role #

Get the role relevant for a `CtEvidence`

data TcPlugin #

Constructors

TcPlugin |

Fields

- tcPluginInit :: TcPluginM s

  Initialize plugin, when entering type-checker.

- tcPluginSolve :: s -> TcPluginSolver

  Solve some constraints. TODO: WRITE MORE DETAILS ON HOW THIS WORKS.

- tcPluginStop :: s -> TcPluginM ()

  Clean up after the plugin, when exiting the type-checker.

data TcPluginResult #

Constructors

TcPluginContradiction [Ct] | The plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble.
TcPluginOk [(EvTerm, Ct)] [Ct] | The first field is for constraints that were solved. These are removed from the inert set, and the evidence for them is recorded. The second field contains new work, that should be processed by the constraint solver.

type TcPluginSolver = [Ct] -> [Ct] -> [Ct] -> TcPluginM TcPluginResult #

data TcPluginM a #

Instances

Monad TcPluginM # |
Methods (>>=) :: TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b Source # (>>) :: TcPluginM a -> TcPluginM b -> TcPluginM b Source # return :: a -> TcPluginM a Source # fail :: String -> TcPluginM a Source #
Functor TcPluginM # |
Methods fmap :: (a -> b) -> TcPluginM a -> TcPluginM b Source # (<$) :: a -> TcPluginM b -> TcPluginM a Source #
MonadFail TcPluginM # |
Methods fail :: String -> TcPluginM a Source #
Applicative TcPluginM # |
Methods pure :: a -> TcPluginM a Source # (<*>) :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b Source # liftA2 :: (a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c Source # (*>) :: TcPluginM a -> TcPluginM b -> TcPluginM b Source # (<*) :: TcPluginM a -> TcPluginM b -> TcPluginM a Source #

runTcPluginM :: TcPluginM a -> EvBindsVar -> TcM a #

unsafeTcPluginTcM :: TcM a -> TcPluginM a #

This function provides an escape for direct access to the `TcM` monad. It should not be used lightly, and the provided `TcPluginM` API should be favoured instead.

getEvBindsTcPluginM :: TcPluginM EvBindsVar #

Access the `EvBindsVar` carried by the `TcPluginM` during constraint solving. Returns `Nothing` if invoked during `tcPluginInit` or `tcPluginStop`.

data CtFlavour #

Constructors

Given |
Wanted ShadowInfo |
Derived |

Instances

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

data ShadowInfo #

Constructors

WDeriv |
WOnly |

Instances

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

ctEvFlavour :: CtEvidence -> CtFlavour #

type CtFlavourRole = (CtFlavour, EqRel) #

Whether or not one `Ct` can rewrite another is determined by its flavour and its equality relation. See also Note [Flavours with roles] in TcSMonad

ctEvFlavourRole :: CtEvidence -> CtFlavourRole #

Extract the flavour, role, and boxity from a `CtEvidence`

ctFlavourRole :: Ct -> CtFlavourRole #

Extract the flavour, role, and boxity from a `Ct`

eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool #

eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool #

eqCanDischarge :: CtEvidence -> CtEvidence -> Bool #

funEqCanDischarge :: CtEvidence -> CtEvidence -> (SwapFlag, Bool) #

funEqCanDischargeF :: CtFlavour -> CtFlavour -> (SwapFlag, Bool) #

pprEvVarTheta :: [EvVar] -> SDoc #

pprEvVars :: [EvVar] -> SDoc #

pprEvVarWithType :: EvVar -> SDoc #

type TcId = Id #

type TcIdSet = IdSet #

data Hole #

An expression or type hole

Constructors

ExprHole UnboundVar | Either an out-of-scope variable or a "true" hole in an expression (TypedHoles)
TypeHole OccName | A hole in a type (PartialTypeSignatures)

holeOcc :: Hole -> OccName #

data NameShape #

A `NameShape` is a substitution on `Name`s that can be used to refine the identities of a hole while we are renaming interfaces (see `RnModIface`). Specifically, a `NameShape` for `ns_module_name` `A`, defines a mapping from `{A.T}` (for some `OccName` `T`) to some arbitrary other `Name`.

The most intruiging thing about a `NameShape`, however, is how it's constructed. A `NameShape` is *implied* by the exported `AvailInfo`s of the implementor of an interface: if an implementor of signature `H` exports `M.T`, you implicitly define a substitution from `{H.T}` to `M.T`. So a `NameShape` is computed from the list of `AvailInfo`s that are exported by the implementation of a module, or successively merged together by the export lists of signatures which are joining together.

It's not the most obvious way to go about doing this, but it does seem to work!

NB: Can't boot this and put it in NameShape because then we start pulling in too many DynFlags things.

Constructors

NameShape |

Fields

- ns_mod_name :: ModuleName
- ns_exports :: [AvailInfo]
- ns_map :: OccEnv Name