ghc-8.8.4: The GHC API
Safe HaskellNone
LanguageHaskell2010

TcRnTypes

Synopsis

Documentation

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

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

Instances

Instances details
Quasi TcM # 
Instance details

Defined in TcSplice

MonadUnique (IOEnv (Env gbl lcl)) # 
Instance details

Defined in TcRnMonad

Methods

getUniqueSupplyM :: IOEnv (Env gbl lcl) UniqSupply #

getUniqueM :: IOEnv (Env gbl lcl) Unique #

getUniquesM :: IOEnv (Env gbl lcl) [Unique] #

MonadThings (IOEnv (Env TcGblEnv TcLclEnv)) # 
Instance details

Defined in TcEnv

MonadThings (IOEnv (Env DsGblEnv DsLclEnv)) # 
Instance details

Defined in DsMonad

ContainsModule gbl => ContainsModule (Env gbl lcl) # 
Instance details

Defined in TcRnTypes

Methods

extractModule :: Env gbl lcl -> Module #

ContainsDynFlags (Env gbl lcl) # 
Instance details

Defined in TcRnTypes

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

Instances

Instances details
Quasi TcM # 
Instance details

Defined in TcSplice

ContainsModule TcGblEnv # 
Instance details

Defined in TcRnTypes

ContainsCostCentreState TcGblEnv # 
Instance details

Defined in TcRnMonad

MonadThings (IOEnv (Env TcGblEnv TcLclEnv)) # 
Instance details

Defined in TcEnv

data TcLclEnv #

data IfGblEnv #

Constructors

IfGblEnv 

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.

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)

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 #

Instances

Instances details
Outputable WhereFrom # 
Instance details

Defined in TcRnTypes

data TcBinder #

Instances

Instances details
Outputable TcBinder # 
Instance details

Defined in TcRnTypes

HasOccName TcBinder # 
Instance details

Defined in TcRnTypes

Methods

occName :: TcBinder -> 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.

Instances

Instances details
Outputable TcTyThing # 
Instance details

Defined in TcRnTypes

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.

Instances

Instances details
Outputable IdBindingInfo # 
Instance details

Defined in TcRnTypes

data IsGroupClosed #

IsGroupClosed describes a group of mutually-recursive bindings

data SelfBootInfo #

Constructors

NoSelfBoot 
SelfBoot 

data CompleteMatch #

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

Constructors

CompleteMatch 

Fields

Instances

Instances details
Outputable CompleteMatch # 
Instance details

Defined in HscTypes

data DsMetaVal #

Constructors

DsBound Id 
DsSplice (HsExpr GhcTc) 

data ThStage #

Instances

Instances details
Outputable ThStage # 
Instance details

Defined in TcRnTypes

Methods

ppr :: ThStage -> SDoc #

pprPrec :: Rational -> ThStage -> SDoc #

data SpliceType #

Constructors

Typed 
Untyped 

type ThLevel = Int #

data ForeignSrcLang Source #

Foreign formats supported by GHC via TH

Constructors

LangC

C

LangCxx

C++

LangObjc

Objective C

LangObjcxx

Objective C++

LangAsm

Assembly language (.s)

RawObject

Object (.o)

Instances

Instances details
Eq ForeignSrcLang 
Instance details

Defined in GHC.ForeignSrcLang.Type

Show ForeignSrcLang 
Instance details

Defined in GHC.ForeignSrcLang.Type

Generic ForeignSrcLang 
Instance details

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type Source #

type Rep ForeignSrcLang 
Instance details

Defined in GHC.ForeignSrcLang.Type

type Rep ForeignSrcLang = D1 ('MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-8.8.4" 'False) ((C1 ('MetaCons "LangC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangCxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LangObjc" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "LangObjcxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangAsm" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RawObject" 'PrefixI 'False) (U1 :: Type -> Type))))

data TcSigInfo #

Instances

Instances details
Outputable TcSigInfo # 
Instance details

Defined in TcRnTypes

data TcIdSigInfo #

Instances

Instances details
Outputable TcIdSigInfo # 
Instance details

Defined in TcRnTypes

data TcIdSigInst #

Instances

Instances details
Outputable TcIdSigInst # 
Instance details

Defined in TcRnTypes

hasCompleteSig :: TcSigFun -> Name -> Bool #

No signature or a partial signature

data QCInst #

Constructors

QCI 

Instances

Instances details
Outputable QCInst # 
Instance details

Defined in TcRnTypes

Methods

ppr :: QCInst -> SDoc #

pprPrec :: Rational -> QCInst -> SDoc #

type Xi = Type #

data Ct #

Instances

Instances details
Outputable Ct # 
Instance details

Defined in TcRnTypes

Methods

ppr :: Ct -> SDoc #

pprPrec :: Rational -> Ct -> SDoc #

type Cts = Bag Ct #

andCts :: Cts -> Cts -> Cts #

listToCts :: [Ct] -> Cts #

ctsElts :: Cts -> [Ct] #

consCts :: Ct -> Cts -> Cts #

snocCts :: Cts -> Ct -> Cts #

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

superClassesMightHelp :: WantedConstraints -> 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]

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]

ctLoc :: Ct -> CtLoc #

setCtLoc :: Ct -> CtLoc -> Ct #

ctFlavour :: Ct -> CtFlavour #

Get the flavour of the given Ct

ctEqRel :: Ct -> EqRel #

Get the equality relation for the given Ct

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

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

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

ctEvEqRel :: CtEvidence -> EqRel #

Get the equality relation relevant for a CtEvidence

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 

Instances

Instances details
Outputable WantedConstraints # 
Instance details

Defined in TcRnTypes

isSolvedWC :: WantedConstraints -> Bool #

Checks whether a the given wanted constraints are solved, i.e. that there are no simple constraints left and all the implications are solved.

tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet #

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

tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar] #

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

newImplication :: TcM Implication #

Create a new Implication with as many sensible defaults for its fields as possible. Note that the ic_tclvl, ic_binds, and ic_info fields do not have sensible defaults, so they are initialized with lazy thunks that will panic if forced, so one should take care to initialize these fields after creation.

This is monadic purely to look up the Env, which is used to initialize ic_env.

implicLclEnv :: Implication -> TcLclEnv #

Retrieve the enclosed TcLclEnv from an Implication.

implicDynFlags :: Implication -> DynFlags #

Retrieve the enclosed DynFlags from an Implication.

data ImplicStatus #

Instances

Instances details
Outputable ImplicStatus # 
Instance details

Defined in TcRnTypes

data SubGoalDepth #

See Note [SubGoalDepth]

lexprCtOrigin :: LHsExpr GhcRn -> CtOrigin #

Extract a suitable CtOrigin from a HsExpr

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

Extract a suitable CtOrigin from a MatchGroup

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

Extract a suitable CtOrigin from guarded RHSs

data TypeOrKind #

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

Constructors

TypeLevel 
KindLevel 

Instances

Instances details
Eq TypeOrKind # 
Instance details

Defined in TcRnTypes

Outputable TypeOrKind # 
Instance details

Defined in TcRnTypes

data CtEvidence #

Instances

Instances details
Outputable CtEvidence # 
Instance details

Defined in TcRnTypes

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

Instances details
Outputable TcEvDest # 
Instance details

Defined in TcRnTypes

toKindLoc :: CtLoc -> CtLoc #

Take a CtLoc and moves it to the kind level

ctEvRole :: CtEvidence -> Role #

Get the role relevant for a CtEvidence

wrapType :: Type -> [TyVar] -> [PredType] -> Type #

wrapTypeWithImplication :: Type -> Implication -> Type #

Wraps the given type with the constraints (via ic_given) in the given implication, according to the variables mentioned (via ic_skols) in the implication, but taking care to only wrap those variables that are mentioned in the type or the implication.

data TcPlugin #

Constructors

forall s. TcPlugin 

Fields

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.

data TcPluginM a #

Instances

Instances details
Monad TcPluginM # 
Instance details

Defined in TcRnTypes

Methods

(>>=) :: TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b Source #

(>>) :: TcPluginM a -> TcPluginM b -> TcPluginM b Source #

return :: a -> TcPluginM a Source #

Functor TcPluginM # 
Instance details

Defined in TcRnTypes

Methods

fmap :: (a -> b) -> TcPluginM a -> TcPluginM b Source #

(<$) :: a -> TcPluginM b -> TcPluginM a Source #

MonadFail TcPluginM # 
Instance details

Defined in TcRnTypes

Methods

fail :: String -> TcPluginM a Source #

Applicative TcPluginM # 
Instance details

Defined in TcRnTypes

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 #

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

Instances details
Eq CtFlavour # 
Instance details

Defined in TcRnTypes

Outputable CtFlavour # 
Instance details

Defined in TcRnTypes

data ShadowInfo #

Constructors

WDeriv 
WOnly 

Instances

Instances details
Eq ShadowInfo # 
Instance details

Defined in TcRnTypes

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 and role from a Ct

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)

Instances

Instances details
Outputable Hole # 
Instance details

Defined in TcRnTypes

Methods

ppr :: Hole -> SDoc #

pprPrec :: Rational -> Hole -> SDoc #

data NameShape #

A NameShape is a substitution on Names 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 AvailInfos 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 AvailInfos 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.