ghc-9.2.5: The GHC API
Safe HaskellSafe-Inferred



Typechecking user-specified MonoTypes



addSigCtxt :: Outputable hs_ty => UserTypeCtxt -> LocatedA hs_ty -> TcM a -> TcM a Source #

tcDerivStrategy Source #


:: Maybe (LDerivStrategy GhcRn)

The deriving strategy

-> TcM (Maybe (LDerivStrategy GhcTc), [TyVar])

The typechecked deriving strategy and the tyvars that it binds (if using ViaStrategy).

Typecheck a deriving strategy. For most deriving strategies, this is a no-op, but for the via strategy, this requires typechecking the via type.

tcHsTypeApp :: LHsWcType GhcRn -> Kind -> TcM Type Source #

Type-check a visible type application

bindExplicitTKBndrs_Tv :: OutputableBndrFlag flag 'Renamed => [LHsTyVarBndr flag GhcRn] -> TcM a -> TcM ([VarBndr TyVar flag], a) Source #

Skolemise the HsTyVarBndrs in an HsForAllTelescope with the supplied TcTyMode.

bindExplicitTKBndrs_Skol :: OutputableBndrFlag flag 'Renamed => [LHsTyVarBndr flag GhcRn] -> TcM a -> TcM ([VarBndr TyVar flag], a) Source #

Skolemise the HsTyVarBndrs in an HsForAllTelescope with the supplied TcTyMode.

bindTyClTyVars :: Name -> (TcTyCon -> [TyConBinder] -> Kind -> TcM a) -> TcM a Source #

Used for the type variables of a type or class decl in the "kind checking" and "type checking" pass, but not in the initial-kind run.

data SAKS_or_CUSK Source #


SAKS Kind 


Instances details
Outputable SAKS_or_CUSK Source # 
Instance details

Defined in GHC.Tc.Gen.HsType

data ContextKind Source #

Describes the kind expected in a certain context.


TheKind Kind

a specific kind


any kind will do


something of the form TYPE _

kcDeclHeader Source #


:: InitialKindStrategy 
-> Name

of the thing being checked

-> TyConFlavour

What sort of TyCon is being checked

-> LHsQTyVars GhcRn

Binders in the header

-> TcM ContextKind

The result kind

-> TcM TcTyCon

A suitably-kinded TcTyCon

kindGeneralizeAll :: TcType -> TcM [KindVar] Source #

  • Specialised version of kindGeneralizeSome, but with empty WantedConstraints, so no filtering is needed i.e. kindGeneraliseAll = kindGeneralizeSome emptyWC

kindGeneralizeSome Source #


:: WantedConstraints 
-> TcType

needn't be zonked

-> TcM [KindVar] 

Generalize some of the free variables in the given type. All such variables should be *kind* variables; any type variables should be explicitly quantified (with a forall) before now.

The WantedConstraints are un-solved kind constraints. Generally they'll be reported as errors later, but meanwhile we refrain from quantifying over any variable free in these unsolved constraints. See Note [Failure in local type signatures].

But in all cases, generalize only those variables whose TcLevel is strictly greater than the ambient level. This "strictly greater than" means that you likely need to push the level before creating whatever type gets passed here.

Any variable whose level is greater than the ambient level but is not selected to be generalized will be promoted. (See [Promoting unification variables] in GHC.Tc.Solver and Note [Recipe for checking a signature].)

The resulting KindVar are the variables to quantify over, in the correct, well-scoped order. They should generally be Inferred, not Specified, but that's really up to the caller of this function.

kindGeneralizeNone :: TcType -> TcM () Source #

Specialized version of kindGeneralizeSome, but where no variables can be generalized, but perhaps some may need to be promoted. Use this variant when it is unknowable whether metavariables might later be constrained.

To see why this promotion is needed, see Note [Recipe for checking a signature], and especially Note [Promotion in signatures].

checkDataKindSig :: DataSort -> Kind -> TcM () Source #

Checks that the return kind in a data declaration's kind signature is permissible. There are three cases:

If dealing with a data, newtype, data instance, or newtype instance declaration, check that the return kind is Type.

If the declaration is a newtype or newtype instance and the UnliftedNewtypes extension is enabled, this check is slightly relaxed so that a return kind of the form TYPE r (for some r) is permitted. See Note [Implementation of UnliftedNewtypes] in GHC.Tc.TyCl.

If dealing with a data family declaration, check that the return kind is either of the form:

  1. TYPE r (for some r), or
  2. k (where k is a bare kind variable; see #12369)

See also Note [Datatype return kinds] in GHC.Tc.TyCl

data DataSort Source #

A description of whether something is a

At present, this data type is only consumed by checkDataKindSig.

checkClassKindSig :: Kind -> TcM () Source #

Checks that the result kind of a class is exactly Constraint, rejecting type synonyms and type families that reduce to Constraint. See #16826.

data HoleMode Source #


Instances details
Outputable HoleMode Source # 
Instance details

Defined in GHC.Tc.Gen.HsType


ppr :: HoleMode -> SDoc Source #

funAppCtxt :: (Outputable fun, Outputable arg) => fun -> arg -> Int -> SDoc Source #

Make an appropriate message for an error in a function argument. Used for both expressions and types.

addTyConFlavCtxt :: Name -> TyConFlavour -> TcM a -> TcM a Source #

Add a "In the data declaration for T" or some such.