\section[TcMonoType]{Typechecking user-specified @MonoTypes@}
\begin{code}
-module TcMonoType ( tcHsType, tcHsSigType, tcHsBoxedSigType,
- tcContext, tcClassContext, tcHsTyVar,
+module TcMonoType ( tcHsSigType, tcHsType, tcIfaceType, tcHsTheta, tcHsPred,
+ UserTypeCtxt(..),
-- Kind checking
kcHsTyVar, kcHsTyVars, mkTyClTyVars,
- kcHsType, kcHsSigType, kcHsBoxedSigType, kcHsContext,
- kcTyVarScope,
+ kcHsType, kcHsSigType, kcHsSigTypes,
+ kcHsLiftedSigType, kcHsContext,
+ tcAddScopedTyVars, tcHsTyVars, mkImmutTyVars,
- TcSigInfo(..), tcTySig, mkTcSig, maybeSig,
- checkSigTyVars, sigCtxt, sigPatCtxt
+ TcSigInfo(..), tcTySig, mkTcSig, maybeSig, tcSigPolyId, tcSigMonoId
) where
#include "HsVersions.h"
-import HsSyn ( HsType(..), HsTyVarBndr(..), HsUsageAnn(..),
- Sig(..), HsPred(..), pprParendHsType, HsTupCon(..), hsTyVarNames )
-import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig )
+import HsSyn ( HsType(..), HsTyVarBndr(..), HsTyOp(..),
+ Sig(..), HsPred(..), HsTupCon(..), hsTyVarNames )
+import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig, extractHsTyVars )
import TcHsSyn ( TcId )
-import TcMonad
-import TcEnv ( tcExtendTyVarEnv, tcLookupTy, tcGetValueEnv, tcGetInScopeTyVars,
- tcExtendUVarEnv, tcLookupUVar,
- tcGetGlobalTyVars, valueEnvIds,
- TyThing(..), tyThingKind, tcExtendKindEnv
+import TcRnMonad
+import TcEnv ( tcExtendTyVarEnv, tcLookup, tcLookupGlobal,
+ TyThing(..), TcTyThing(..), tcExtendKindEnv,
+ getInLocalScope
)
-import TcType ( TcType, TcKind, TcTyVar, TcThetaType, TcTauType,
- newKindVar, tcInstSigVar,
- zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar
+import TcMType ( newMutTyVar, newKindVar, zonkKindEnv, tcInstType, zonkTcType,
+ checkValidType, UserTypeCtxt(..), pprUserTypeCtxt, newOpenTypeKind
)
-import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToIdBndr,
- instFunDeps, instFunDepsOfTheta )
-import FunDeps ( tyVarFunDep, oclose )
-import TcUnify ( unifyKind, unifyKinds, unifyOpenTypeKind )
-import Type ( Type, Kind, PredType(..), ThetaType, UsageAnn(..),
- mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, mkUsgTy,
- mkUsForAllTy, zipFunTys, hoistForAllTys,
- mkSigmaTy, mkDictTy, mkPredTy, mkTyConApp,
- mkAppTys, splitForAllTys, splitRhoTy, mkRhoTy,
- boxedTypeKind, unboxedTypeKind, mkArrowKind,
- mkArrowKinds, getTyVar_maybe, getTyVar, splitFunTy_maybe,
- tidyOpenType, tidyOpenTypes, tidyTyVar, tidyTyVars,
- tyVarsOfType, tyVarsOfTypes, tyVarsOfPred, mkForAllTys,
- classesOfPreds
+import TcUnify ( unifyKind, unifyFunKind )
+import TcType ( Type, Kind, SourceType(..), ThetaType, TyVarDetails(..),
+ TcTyVar, TcKind, TcThetaType, TcTauType,
+ mkTyVarTy, mkTyVarTys, mkFunTy, isTypeKind,
+ zipFunTys, mkForAllTys, mkFunTys, tcEqType, isPredTy,
+ mkSigmaTy, mkPredTy, mkGenTyConApp, mkTyConApp, mkAppTys,
+ liftedTypeKind, unliftedTypeKind, eqKind,
+ tcSplitFunTy_maybe, tcSplitForAllTys
)
-import PprType ( pprConstraint, pprType, pprPred )
-import Subst ( mkTopTyVarSubst, substTy )
-import Id ( mkVanillaId, idName, idType, idFreeTyVars )
-import Var ( TyVar, mkTyVar, tyVarKind, mkNamedUVar, varName )
-import VarEnv
-import VarSet
+import qualified Type ( splitFunTys )
+import Inst ( Inst, InstOrigin(..), newMethod, instToId )
+
+import Id ( mkLocalId, idName, idType )
+import Var ( TyVar, mkTyVar, tyVarKind )
import ErrUtils ( Message )
-import TyCon ( TyCon, isSynTyCon, tyConArity, tyConKind )
-import Class ( ClassContext, classArity, classTyCon )
-import Name ( Name, OccName, isLocallyDefined )
-import TysWiredIn ( mkListTy, mkTupleTy )
-import UniqFM ( elemUFM, foldUFM )
+import TyCon ( TyCon, tyConKind )
+import Class ( classTyCon )
+import Name ( Name )
+import NameSet
+import Subst ( deShadowTy )
+import TysWiredIn ( mkListTy, mkPArrTy, mkTupleTy, genUnitTyCon )
import BasicTypes ( Boxity(..) )
import SrcLoc ( SrcLoc )
-import Util ( mapAccumL, isSingleton, removeDups )
+import Util ( lengthIs )
import Outputable
+import List ( nubBy )
\end{code}
%* *
%************************************************************************
+Generally speaking we now type-check types in three phases
+
+ 1. Kind check the HsType [kcHsType]
+ 2. Convert from HsType to Type, and hoist the foralls [tcHsType]
+ 3. Check the validity of the resulting type [checkValidType]
+
+Often these steps are done one after the othe (tcHsSigType).
+But in mutually recursive groups of type and class decls we do
+ 1 kind-check the whole group
+ 2 build TyCons/Classes in a knot-tied wa
+ 3 check the validity of types in the now-unknotted TyCons/Classes
+
+\begin{code}
+tcHsSigType :: UserTypeCtxt -> RenamedHsType -> TcM Type
+ -- Do kind checking, and hoist for-alls to the top
+tcHsSigType ctxt ty = addErrCtxt (checkTypeCtxt ctxt ty) (
+ kcTypeType ty `thenM_`
+ tcHsType ty
+ ) `thenM` \ ty' ->
+ checkValidType ctxt ty' `thenM_`
+ returnM ty'
+
+checkTypeCtxt ctxt ty
+ = vcat [ptext SLIT("In the type:") <+> ppr ty,
+ ptext SLIT("While checking") <+> pprUserTypeCtxt ctxt ]
+
+tcHsType :: RenamedHsType -> TcM Type
+ -- Don't do kind checking, nor validity checking,
+ -- but do hoist for-alls to the top
+ -- This is used in type and class decls, where kinding is
+ -- done in advance, and validity checking is done later
+ -- [Validity checking done later because of knot-tying issues.]
+tcHsType ty = tc_type ty `thenM` \ ty' ->
+ returnM (hoistForAllTys ty')
+
+tcHsTheta :: RenamedContext -> TcM ThetaType
+-- Used when we are expecting a ClassContext (i.e. no implicit params)
+-- Does not do validity checking, like tcHsType
+tcHsTheta hs_theta = mappM tc_pred hs_theta
+
+-- In interface files the type is already kinded,
+-- and we definitely don't want to hoist for-alls.
+-- Otherwise we'll change
+-- dmfail :: forall m:(*->*) Monad m => forall a:* => String -> m a
+-- into
+-- dmfail :: forall m:(*->*) a:* Monad m => String -> m a
+-- which definitely isn't right!
+tcIfaceType ty = tc_type ty
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{Kind checking}
+%* *
+%************************************************************************
+
+Kind checking
+~~~~~~~~~~~~~
+When we come across the binding site for some type variables, we
+proceed in two stages
+
+1. Figure out what kind each tyvar has
+
+2. Create suitably-kinded tyvars,
+ extend the envt,
+ and typecheck the body
+
+To do step 1, we proceed thus:
+
+1a. Bind each type variable to a kind variable
+1b. Apply the kind checker
+1c. Zonk the resulting kinds
+
+The kind checker is passed to tcHsTyVars as an argument.
+
+For example, when we find
+ (forall a m. m a -> m a)
+we bind a,m to kind varibles and kind-check (m a -> m a). This
+makes a get kind *, and m get kind *->*. Now we typecheck (m a -> m a)
+in an environment that binds a and m suitably.
+
+The kind checker passed to tcHsTyVars needs to look at enough to
+establish the kind of the tyvar:
+ * For a group of type and class decls, it's just the group, not
+ the rest of the program
+ * For a tyvar bound in a pattern type signature, its the types
+ mentioned in the other type signatures in that bunch of patterns
+ * For a tyvar bound in a RULE, it's the type signatures on other
+ universally quantified variables in the rule
+
+Note that this may occasionally give surprising results. For example:
+
+ data T a b = MkT (a b)
+
+Here we deduce a::*->*, b::*.
+But equally valid would be
+ a::(*->*)-> *, b::*->*
+
+\begin{code}
+-- tcHsTyVars is used for type variables in type signatures
+-- e.g. forall a. a->a
+-- They are immutable, because they scope only over the signature
+-- They may or may not be explicitly-kinded
+tcHsTyVars :: [HsTyVarBndr Name]
+ -> TcM a -- The kind checker
+ -> ([TyVar] -> TcM b)
+ -> TcM b
+
+tcHsTyVars [] kind_check thing_inside = thing_inside []
+ -- A useful short cut for a common case!
+
+tcHsTyVars tv_names kind_check thing_inside
+ = kcHsTyVars tv_names `thenM` \ tv_names_w_kinds ->
+ tcExtendKindEnv tv_names_w_kinds kind_check `thenM_`
+ zonkKindEnv tv_names_w_kinds `thenM` \ tvs_w_kinds ->
+ let
+ tyvars = mkImmutTyVars tvs_w_kinds
+ in
+ tcExtendTyVarEnv tyvars (thing_inside tyvars)
+
+
+
+tcAddScopedTyVars :: [RenamedHsType] -> TcM a -> TcM a
+-- tcAddScopedTyVars is used for scoped type variables
+-- added by pattern type signatures
+-- e.g. \ (x::a) (y::a) -> x+y
+-- They never have explicit kinds (because this is source-code only)
+-- They are mutable (because they can get bound to a more specific type)
+
+-- Find the not-already-in-scope signature type variables,
+-- kind-check them, and bring them into scope
+--
+-- We no longer specify that these type variables must be univerally
+-- quantified (lots of email on the subject). If you want to put that
+-- back in, you need to
+-- a) Do a checkSigTyVars after thing_inside
+-- b) More insidiously, don't pass in expected_ty, else
+-- we unify with it too early and checkSigTyVars barfs
+-- Instead you have to pass in a fresh ty var, and unify
+-- it with expected_ty afterwards
+tcAddScopedTyVars [] thing_inside
+ = thing_inside -- Quick get-out for the empty case
+
+tcAddScopedTyVars sig_tys thing_inside
+ = getInLocalScope `thenM` \ in_scope ->
+ let
+ all_sig_tvs = foldr (unionNameSets . extractHsTyVars) emptyNameSet sig_tys
+ sig_tvs = filter (not . in_scope) (nameSetToList all_sig_tvs)
+ in
+ mappM newNamedKindVar sig_tvs `thenM` \ kind_env ->
+ tcExtendKindEnv kind_env (kcHsSigTypes sig_tys) `thenM_`
+ zonkKindEnv kind_env `thenM` \ tvs_w_kinds ->
+ sequenceM [ newMutTyVar name kind PatSigTv
+ | (name, kind) <- tvs_w_kinds] `thenM` \ tyvars ->
+ tcExtendTyVarEnv tyvars thing_inside
+\end{code}
+
+
\begin{code}
+kcHsTyVar :: HsTyVarBndr name -> TcM (name, TcKind)
+kcHsTyVars :: [HsTyVarBndr name] -> TcM [(name, TcKind)]
-kcHsTyVar :: HsTyVarBndr name -> NF_TcM s (name, TcKind)
-kcHsTyVars :: [HsTyVarBndr name] -> NF_TcM s [(name, TcKind)]
+kcHsTyVar (UserTyVar name) = newNamedKindVar name
+kcHsTyVar (IfaceTyVar name kind) = returnM (name, kind)
-kcHsTyVar (UserTyVar name) = newKindVar `thenNF_Tc` \ kind ->
- returnNF_Tc (name, kind)
-kcHsTyVar (IfaceTyVar name kind) = returnNF_Tc (name, kind)
+kcHsTyVars tvs = mappM kcHsTyVar tvs
-kcHsTyVars tvs = mapNF_Tc kcHsTyVar tvs
+newNamedKindVar name = newKindVar `thenM` \ kind ->
+ returnM (name, kind)
---------------------------
-kcBoxedType :: RenamedHsType -> TcM s ()
- -- The type ty must be a *boxed* *type*
-kcBoxedType ty
- = kcHsType ty `thenTc` \ kind ->
- tcAddErrCtxt (typeKindCtxt ty) $
- unifyKind boxedTypeKind kind
+kcLiftedType :: RenamedHsType -> TcM Kind
+ -- The type ty must be a *lifted* *type*
+kcLiftedType ty = kcHsType ty `thenM` \ act_kind ->
+ checkExpectedKind (ppr ty) act_kind liftedTypeKind
---------------------------
-kcTypeType :: RenamedHsType -> TcM s ()
- -- The type ty must be a *type*, but it can be boxed or unboxed.
+kcTypeType :: RenamedHsType -> TcM ()
+ -- The type ty must be a *type*, but it can be lifted or unlifted.
kcTypeType ty
- = kcHsType ty `thenTc` \ kind ->
- tcAddErrCtxt (typeKindCtxt ty) $
- unifyOpenTypeKind kind
+ = kcHsType ty `thenM` \ kind ->
+ if isTypeKind kind then
+ return ()
+ else
+ newOpenTypeKind `thenM` \ exp_kind ->
+ checkExpectedKind (ppr ty) kind exp_kind `thenM_`
+ returnM ()
---------------------------
-kcHsSigType, kcHsBoxedSigType :: RenamedHsType -> TcM s ()
+kcHsSigType, kcHsLiftedSigType :: RenamedHsType -> TcM ()
-- Used for type signatures
-kcHsSigType = kcTypeType
-kcHsBoxedSigType = kcBoxedType
+kcHsSigType ty = kcTypeType ty
+kcHsSigTypes tys = mappM_ kcHsSigType tys
+kcHsLiftedSigType ty = kcLiftedType ty `thenM_` returnM ()
---------------------------
-kcHsType :: RenamedHsType -> TcM s TcKind
-kcHsType (HsTyVar name)
- = tcLookupTy name `thenTc` \ thing ->
- case thing of
- ATyVar tv -> returnTc (tyVarKind tv)
- ATyCon tc -> returnTc (tyConKind tc)
- AThing k -> returnTc k
- other -> failWithTc (wrongThingErr "type" thing name)
-
-kcHsType (HsUsgTy _ ty) = kcHsType ty
-kcHsType (HsUsgForAllTy _ ty) = kcHsType ty
-
-kcHsType (HsListTy ty)
- = kcBoxedType ty `thenTc` \ tau_ty ->
- returnTc boxedTypeKind
+kcHsType :: RenamedHsType -> TcM TcKind
+-- kcHsType *returns* the kind of the type, rather than taking an expected
+-- kind as argument as tcExpr does. Reason: the kind of (->) is
+-- forall bx1 bx2. Type bx1 -> Type bx2 -> Type Boxed
+-- so we'd need to generate huge numbers of bx variables.
+
+kcHsType (HsTyVar name) = kcTyVar name
+kcHsType (HsListTy ty) = kcLiftedType ty
+kcHsType (HsPArrTy ty) = kcLiftedType ty
+kcHsType (HsParTy ty) = kcHsType ty -- Skip parentheses markers
+kcHsType (HsNumTy _) = returnM liftedTypeKind -- The unit type for generics
+kcHsType (HsKindSig ty k) = kcHsType ty `thenM` \ act_kind ->
+ checkExpectedKind (ppr ty) act_kind k
+
+kcHsType (HsTupleTy (HsTupCon boxity _) tys)
+ = mappM kcTypeType tys `thenM_`
+ returnM (case boxity of
+ Boxed -> liftedTypeKind
+ Unboxed -> unliftedTypeKind)
-kcHsType (HsTupleTy (HsTupCon _ Boxed) tys)
- = mapTc kcBoxedType tys `thenTc_`
- returnTc boxedTypeKind
+kcHsType (HsFunTy ty1 ty2)
+ = kcTypeType ty1 `thenM_`
+ kcTypeType ty2 `thenM_`
+ returnM liftedTypeKind
-kcHsType (HsTupleTy (HsTupCon _ Unboxed) tys)
- = mapTc kcTypeType tys `thenTc_`
- returnTc unboxedTypeKind
+kcHsType (HsOpTy ty1 HsArrow ty2)
+ = kcTypeType ty1 `thenM_`
+ kcTypeType ty2 `thenM_`
+ returnM liftedTypeKind
-kcHsType (HsFunTy ty1 ty2)
- = kcTypeType ty1 `thenTc_`
- kcTypeType ty2 `thenTc_`
- returnTc boxedTypeKind
+kcHsType ty@(HsOpTy ty1 op_ty@(HsTyOp op) ty2)
+ = addErrCtxt (appKindCtxt (ppr ty)) $
+ kcTyVar op `thenM` \ op_kind ->
+ kcApps (ppr op_ty) op_kind [ty1,ty2]
kcHsType (HsPredTy pred)
- = kcHsPred pred `thenTc_`
- returnTc boxedTypeKind
+ = kcHsPred pred `thenM_`
+ returnM liftedTypeKind
kcHsType ty@(HsAppTy ty1 ty2)
- = kcHsType ty1 `thenTc` \ tc_kind ->
- kcHsType ty2 `thenTc` \ arg_kind ->
+ = addErrCtxt (appKindCtxt (ppr ty)) $
+ kc_app ty []
+ where
+ kc_app (HsAppTy f a) as = kc_app f (a:as)
+ kc_app f as = kcHsType f `thenM` \ fk ->
+ kcApps (ppr f) fk as
- tcAddErrCtxt (appKindCtxt (ppr ty)) $
- case splitFunTy_maybe tc_kind of
- Just (arg_kind', res_kind)
- -> unifyKind arg_kind arg_kind' `thenTc_`
- returnTc res_kind
+kcHsType (HsForAllTy (Just tv_names) context ty)
+ = kcHsTyVars tv_names `thenM` \ kind_env ->
+ tcExtendKindEnv kind_env $
+ kcHsContext context `thenM_`
+ kcLiftedType ty
+ -- The body of a forall must be of kind *
+ -- In principle, I suppose, we could allow unlifted types,
+ -- but it seems simpler to stick to lifted types for now.
- Nothing -> newKindVar `thenNF_Tc` \ res_kind ->
- unifyKind tc_kind (mkArrowKind arg_kind res_kind) `thenTc_`
- returnTc res_kind
+---------------------------
+kcApps :: SDoc -- The function
+ -> TcKind -- Function kind
+ -> [RenamedHsType] -- Arg types
+ -> TcM TcKind -- Result kind
+kcApps pp_fun fun_kind args
+ = go fun_kind args
+ where
+ go fk [] = returnM fk
+ go fk (ty:tys) = unifyFunKind fk `thenM` \ mb_fk ->
+ case mb_fk of {
+ Nothing -> failWithTc too_few_args ;
+ Just (ak',fk') ->
+ kcHsType ty `thenM` \ ak ->
+ checkExpectedKind (ppr ty) ak ak' `thenM_`
+ go fk' tys }
+
+ too_few_args = ptext SLIT("Kind error:") <+> quotes pp_fun <+>
+ ptext SLIT("is applied to too many type arguments")
-kcHsType (HsForAllTy (Just tv_names) context ty)
- = kcHsTyVars tv_names `thenNF_Tc` \ kind_env ->
- tcExtendKindEnv kind_env $
- kcHsContext context `thenTc_`
- kcHsType ty `thenTc` \ kind ->
-
- -- Context behaves like a function type
- -- This matters. Return-unboxed-tuple analysis can
- -- give overloaded functions like
- -- f :: forall a. Num a => (# a->a, a->a #)
- -- And we want these to get through the type checker
- returnTc (if null context then
- kind
- else
- boxedTypeKind)
+---------------------------
+-- We would like to get a decent error message from
+-- (a) Under-applied type constructors
+-- f :: (Maybe, Maybe)
+-- (b) Over-applied type constructors
+-- f :: Int x -> Int x
+--
+
+checkExpectedKind :: SDoc -> TcKind -> TcKind -> TcM TcKind
+-- A fancy wrapper for 'unifyKind', which tries to give
+-- decent error messages.
+-- Returns the same kind that it is passed, exp_kind
+checkExpectedKind pp_ty act_kind exp_kind
+ | act_kind `eqKind` exp_kind -- Short cut for a very common case
+ = returnM exp_kind
+ | otherwise
+ = tryTc (unifyKind exp_kind act_kind) `thenM` \ (errs, mb_r) ->
+ case mb_r of {
+ Just _ -> returnM exp_kind ; -- Unification succeeded
+ Nothing ->
+
+ -- So there's definitely an error
+ -- Now to find out what sort
+ zonkTcType exp_kind `thenM` \ exp_kind ->
+ zonkTcType act_kind `thenM` \ act_kind ->
+
+ let (exp_as, _) = Type.splitFunTys exp_kind
+ (act_as, _) = Type.splitFunTys act_kind
+ -- Use the Type versions for kinds
+ n_exp_as = length exp_as
+ n_act_as = length act_as
+
+ err | n_exp_as < n_act_as -- E.g. [Maybe]
+ = quotes pp_ty <+> ptext SLIT("is not applied to enough type arguments")
+
+ -- Now n_exp_as >= n_act_as. In the next two cases,
+ -- n_exp_as == 0, and hence so is n_act_as
+ | exp_kind `eqKind` liftedTypeKind && act_kind `eqKind` unliftedTypeKind
+ = ptext SLIT("Expecting a lifted type, but") <+> quotes pp_ty
+ <+> ptext SLIT("is unlifted")
+
+ | exp_kind `eqKind` unliftedTypeKind && act_kind `eqKind` liftedTypeKind
+ = ptext SLIT("Expecting an unlifted type, but") <+> quotes pp_ty
+ <+> ptext SLIT("is lifted")
+
+ | otherwise -- E.g. Monad [Int]
+ = sep [ ptext SLIT("Expecting kind") <+> quotes (ppr exp_kind) <> comma,
+ ptext SLIT("but") <+> quotes pp_ty <+>
+ ptext SLIT("has kind") <+> quotes (ppr act_kind)]
+ in
+ failWithTc (ptext SLIT("Kind error:") <+> err)
+ }
---------------------------
-kcHsContext ctxt = mapTc_ kcHsPred ctxt
-
-kcHsPred :: RenamedHsPred -> TcM s ()
-kcHsPred pred@(HsPIParam name ty)
- = tcAddErrCtxt (appKindCtxt (ppr pred)) $
- kcBoxedType ty
-
-kcHsPred pred@(HsPClass cls tys)
- = tcAddErrCtxt (appKindCtxt (ppr pred)) $
- tcLookupTy cls `thenNF_Tc` \ thing ->
- (case thing of
- AClass cls -> returnTc (tyConKind (classTyCon cls))
- AThing kind -> returnTc kind
- other -> failWithTc (wrongThingErr "class" thing cls)) `thenTc` \ kind ->
- mapTc kcHsType tys `thenTc` \ arg_kinds ->
- unifyKind kind (mkArrowKinds arg_kinds boxedTypeKind)
-\end{code}
+kc_pred :: RenamedHsPred -> TcM TcKind -- Does *not* check for a saturated
+ -- application (reason: used from TcDeriv)
+kc_pred pred@(HsIParam name ty)
+ = kcHsType ty
-\begin{code}
-kcTyVarScope :: [HsTyVarBndr Name]
- -> TcM s a -- The kind checker
- -> TcM s [TyVar]
- -- Do a kind check to find out the kinds of the type variables
- -- Then return the type variables
+kc_pred pred@(HsClassP cls tys)
+ = kcClass cls `thenM` \ kind ->
+ kcApps (ppr cls) kind tys
-kcTyVarScope [] kind_check = returnTc []
- -- A useful short cut for a common case!
-
-kcTyVarScope tv_names kind_check
- = kcHsTyVars tv_names `thenNF_Tc` \ tv_names_w_kinds ->
- tcExtendKindEnv tv_names_w_kinds kind_check `thenTc_`
- zonkKindEnv tv_names_w_kinds `thenNF_Tc` \ zonked_pairs ->
- returnTc (map mk_tyvar zonked_pairs)
-\end{code}
+---------------------------
+kcHsContext ctxt = mappM_ kcHsPred ctxt
+
+kcHsPred pred -- Checks that the result is of kind liftedType
+ = addErrCtxt (appKindCtxt (ppr pred)) $
+ kc_pred pred `thenM` \ kind ->
+ checkExpectedKind (ppr pred) kind liftedTypeKind
+ ---------------------------
+kcTyVar name -- Could be a tyvar or a tycon
+ = tcLookup name `thenM` \ thing ->
+ case thing of
+ AThing kind -> returnM kind
+ ATyVar tv -> returnM (tyVarKind tv)
+ AGlobal (ATyCon tc) -> returnM (tyConKind tc)
+ other -> failWithTc (wrongThingErr "type" thing name)
+
+kcClass cls -- Must be a class
+ = tcLookup cls `thenM` \ thing ->
+ case thing of
+ AThing kind -> returnM kind
+ AGlobal (AClass cls) -> returnM (tyConKind (classTyCon cls))
+ other -> failWithTc (wrongThingErr "class" thing cls)
+\end{code}
+
%************************************************************************
%* *
-\subsection{Checking types}
+\subsection{tc_type}
%* *
%************************************************************************
-tcHsType and tcHsTypeKind
+tc_type, the main work horse
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-tcHsSigType and tcHsBoxedSigType are used for type signatures written by the programmer
+ -------------------
+ *** BIG WARNING ***
+ -------------------
- * We hoist any inner for-alls to the top
+tc_type is used to typecheck the types in the RHS of data
+constructors. In the case of recursive data types, that means that
+the type constructors themselves are (partly) black holes. e.g.
- * Notice that we kind-check first, because the type-check assumes
- that the kinds are already checked.
- * They are only called when there are no kind vars in the environment
- so the kind returned is indeed a Kind not a TcKind
+ data T a = MkT a [T a]
-\begin{code}
-tcHsSigType :: RenamedHsType -> TcM s TcType
-tcHsSigType ty
- = kcTypeType ty `thenTc_`
- tcHsType ty `thenTc` \ ty' ->
- returnTc (hoistForAllTys ty')
-
-tcHsBoxedSigType :: RenamedHsType -> TcM s Type
-tcHsBoxedSigType ty
- = kcBoxedType ty `thenTc_`
- tcHsType ty `thenTc` \ ty' ->
- returnTc (hoistForAllTys ty')
-\end{code}
+While typechecking the [T a] on the RHS, T itself is not yet fully
+defined. That in turn places restrictions on what you can check in
+tcHsType; if you poke on too much you get a black hole. I keep
+forgetting this, hence this warning!
+
+So tc_type does no validity-checking. Instead that's all done
+by TcMType.checkValidType
+ --------------------------
+ *** END OF BIG WARNING ***
+ --------------------------
-The main work horse
-~~~~~~~~~~~~~~~~~~~
\begin{code}
-tcHsType :: RenamedHsType -> TcM s Type
-tcHsType ty@(HsTyVar name)
+tc_type :: RenamedHsType -> TcM Type
+
+tc_type ty@(HsTyVar name)
= tc_app ty []
-tcHsType (HsListTy ty)
- = tcHsType ty `thenTc` \ tau_ty ->
- returnTc (mkListTy tau_ty)
+tc_type (HsKindSig ty k)
+ = tc_type ty -- Kind checking done already
-tcHsType (HsTupleTy (HsTupCon _ boxity) tys)
- = mapTc tcHsType tys `thenTc` \ tau_tys ->
- returnTc (mkTupleTy boxity (length tys) tau_tys)
+tc_type (HsListTy ty)
+ = tc_type ty `thenM` \ tau_ty ->
+ returnM (mkListTy tau_ty)
-tcHsType (HsFunTy ty1 ty2)
- = tcHsType ty1 `thenTc` \ tau_ty1 ->
- tcHsType ty2 `thenTc` \ tau_ty2 ->
- returnTc (mkFunTy tau_ty1 tau_ty2)
+tc_type (HsPArrTy ty)
+ = tc_type ty `thenM` \ tau_ty ->
+ returnM (mkPArrTy tau_ty)
-tcHsType (HsAppTy ty1 ty2)
- = tc_app ty1 [ty2]
+tc_type (HsTupleTy (HsTupCon boxity arity) tys)
+ = ASSERT( tys `lengthIs` arity )
+ tc_types tys `thenM` \ tau_tys ->
+ returnM (mkTupleTy boxity arity tau_tys)
-tcHsType (HsPredTy pred)
- = tcClassAssertion True pred `thenTc` \ pred' ->
- returnTc (mkPredTy pred')
+tc_type (HsFunTy ty1 ty2)
+ = tc_type ty1 `thenM` \ tau_ty1 ->
+ tc_type ty2 `thenM` \ tau_ty2 ->
+ returnM (mkFunTy tau_ty1 tau_ty2)
-tcHsType (HsUsgTy usg ty)
- = newUsg usg `thenTc` \ usg' ->
- tcHsType ty `thenTc` \ tc_ty ->
- returnTc (mkUsgTy usg' tc_ty)
- where
- newUsg usg = case usg of
- HsUsOnce -> returnTc UsOnce
- HsUsMany -> returnTc UsMany
- HsUsVar uv_name -> tcLookupUVar uv_name `thenTc` \ uv ->
- returnTc (UsVar uv)
+tc_type (HsOpTy ty1 HsArrow ty2)
+ = tc_type ty1 `thenM` \ tau_ty1 ->
+ tc_type ty2 `thenM` \ tau_ty2 ->
+ returnM (mkFunTy tau_ty1 tau_ty2)
-tcHsType (HsUsgForAllTy uv_name ty)
- = let
- uv = mkNamedUVar uv_name
- in
- tcExtendUVarEnv uv_name uv $
- tcHsType ty `thenTc` \ tc_ty ->
- returnTc (mkUsForAllTy uv tc_ty)
+tc_type (HsOpTy ty1 (HsTyOp op) ty2)
+ = tc_type ty1 `thenM` \ tau_ty1 ->
+ tc_type ty2 `thenM` \ tau_ty2 ->
+ tc_fun_type op [tau_ty1,tau_ty2]
-tcHsType full_ty@(HsForAllTy (Just tv_names) context ty)
+tc_type (HsParTy ty) -- Remove the parentheses markers
+ = tc_type ty
+
+tc_type (HsNumTy n)
+ = ASSERT(n== 1)
+ returnM (mkTyConApp genUnitTyCon [])
+
+tc_type ty@(HsAppTy ty1 ty2)
+ = addErrCtxt (appKindCtxt (ppr ty)) $
+ tc_app ty1 [ty2]
+
+tc_type (HsPredTy pred)
+ = tc_pred pred `thenM` \ pred' ->
+ returnM (mkPredTy pred')
+
+tc_type full_ty@(HsForAllTy (Just tv_names) ctxt ty)
= let
- kind_check = kcHsContext context `thenTc_` kcHsType ty
- in
- kcTyVarScope tv_names kind_check `thenTc` \ forall_tyvars ->
- tcExtendTyVarEnv forall_tyvars $
- tcContext context `thenTc` \ theta ->
- tcHsType ty `thenTc` \ tau ->
- let
- -- Check for ambiguity
- -- forall V. P => tau
- -- is ambiguous if P contains generic variables
- -- (i.e. one of the Vs) that are not mentioned in tau
- --
- -- However, we need to take account of functional dependencies
- -- when we speak of 'mentioned in tau'. Example:
- -- class C a b | a -> b where ...
- -- Then the type
- -- forall x y. (C x y) => x
- -- is not ambiguous because x is mentioned and x determines y
- --
- -- NOTE: In addition, GHC insists that at least one type variable
- -- in each constraint is in V. So we disallow a type like
- -- forall a. Eq b => b -> b
- -- even in a scope where b is in scope.
- -- This is the is_free test below.
-
- tau_vars = tyVarsOfType tau
- fds = instFunDepsOfTheta theta
- tvFundep = tyVarFunDep fds
- extended_tau_vars = oclose tvFundep tau_vars
- is_ambig ct_var = (ct_var `elem` forall_tyvars) &&
- not (ct_var `elemUFM` extended_tau_vars)
- is_free ct_var = not (ct_var `elem` forall_tyvars)
-
- check_pred pred = checkTc (not any_ambig) (ambigErr pred full_ty) `thenTc_`
- checkTc (not all_free) (freeErr pred full_ty)
- where
- ct_vars = varSetElems (tyVarsOfPred pred)
- any_ambig = is_source_polytype && any is_ambig ct_vars
- all_free = all is_free ct_vars
-
- -- Check ambiguity only for source-program types, not
- -- for types coming from inteface files. The latter can
- -- legitimately have ambiguous types. Example
- -- class S a where s :: a -> (Int,Int)
- -- instance S Char where s _ = (1,1)
- -- f:: S a => [a] -> Int -> (Int,Int)
- -- f (_::[a]) x = (a*x,b)
- -- where (a,b) = s (undefined::a)
- -- Here the worker for f gets the type
- -- fw :: forall a. S a => Int -> (# Int, Int #)
- --
- -- If the list of tv_names is empty, we have a monotype,
- -- and then we don't need to check for ambiguity either,
- -- because the test can't fail (see is_ambig).
- is_source_polytype = case tv_names of
- (UserTyVar _ : _) -> True
- other -> False
+ kind_check = kcHsContext ctxt `thenM_` kcHsType ty
in
- mapTc check_pred theta `thenTc_`
- returnTc (mkSigmaTy forall_tyvars theta tau)
+ tcHsTyVars tv_names kind_check $ \ tyvars ->
+ mappM tc_pred ctxt `thenM` \ theta ->
+ tc_type ty `thenM` \ tau ->
+ returnM (mkSigmaTy tyvars theta tau)
+
+tc_types arg_tys = mappM tc_type arg_tys
\end{code}
Help functions for type applications
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
\begin{code}
+tc_app :: RenamedHsType -> [RenamedHsType] -> TcM Type
tc_app (HsAppTy ty1 ty2) tys
= tc_app ty1 (ty2:tys)
tc_app ty tys
- = tcAddErrCtxt (appKindCtxt pp_app) $
- mapTc tcHsType tys `thenTc` \ arg_tys ->
- tc_fun_type ty arg_tys
- where
- pp_app = ppr ty <+> sep (map pprParendHsType tys)
+ = tc_types tys `thenM` \ arg_tys ->
+ case ty of
+ HsTyVar fun -> tc_fun_type fun arg_tys
+ other -> tc_type ty `thenM` \ fun_ty ->
+ returnM (mkAppTys fun_ty arg_tys)
-- (tc_fun_type ty arg_tys) returns (mkAppTys ty arg_tys)
-- But not quite; for synonyms it checks the correct arity, and builds a SynTy
-- hence the rather strange functionality.
-tc_fun_type (HsTyVar name) arg_tys
- = tcLookupTy name `thenTc` \ thing ->
+tc_fun_type name arg_tys
+ = tcLookup name `thenM` \ thing ->
case thing of
- ATyVar tv -> returnTc (mkAppTys (mkTyVarTy tv) arg_tys)
-
- ATyCon tc | isSynTyCon tc -> checkTc arity_ok err_msg `thenTc_`
- returnTc (mkAppTys (mkSynTy tc (take arity arg_tys))
- (drop arity arg_tys))
-
- | otherwise -> returnTc (mkTyConApp tc arg_tys)
- where
+ ATyVar tv -> returnM (mkAppTys (mkTyVarTy tv) arg_tys)
- arity_ok = arity <= n_args
- arity = tyConArity tc
- -- It's OK to have an *over-applied* type synonym
- -- data Tree a b = ...
- -- type Foo a = Tree [a]
- -- f :: Foo a b -> ...
- err_msg = arityErr "type synonym" name arity n_args
- n_args = length arg_tys
+ AGlobal (ATyCon tc) -> returnM (mkGenTyConApp tc arg_tys)
other -> failWithTc (wrongThingErr "type constructor" thing name)
-
-tc_fun_type ty arg_tys
- = tcHsType ty `thenTc` \ fun_ty ->
- returnNF_Tc (mkAppTys fun_ty arg_tys)
\end{code}
Contexts
~~~~~~~~
\begin{code}
-tcClassContext :: RenamedContext -> TcM s ClassContext
- -- Used when we are expecting a ClassContext (i.e. no implicit params)
-tcClassContext context
- = tcContext context `thenTc` \ theta ->
- returnTc (classesOfPreds theta)
-
-tcContext :: RenamedContext -> TcM s ThetaType
-tcContext context = mapTc (tcClassAssertion False) context
-
-tcClassAssertion ccall_ok assn@(HsPClass class_name tys)
- = tcAddErrCtxt (appKindCtxt (ppr assn)) $
- mapTc tcHsType tys `thenTc` \ arg_tys ->
- tcLookupTy class_name `thenTc` \ thing ->
+tcHsPred pred = kc_pred pred `thenM_` tc_pred pred
+ -- Is happy with a partial application, e.g. (ST s)
+ -- Used from TcDeriv
+
+tc_pred assn@(HsClassP class_name tys)
+ = addErrCtxt (appKindCtxt (ppr assn)) $
+ tc_types tys `thenM` \ arg_tys ->
+ tcLookupGlobal class_name `thenM` \ thing ->
case thing of
- AClass clas -> checkTc (arity == n_tys) err `thenTc_`
- returnTc (Class clas arg_tys)
- where
- arity = classArity clas
- n_tys = length tys
- err = arityErr "Class" class_name arity n_tys
-
- other -> failWithTc (wrongThingErr "class" thing class_name)
-
-tcClassAssertion ccall_ok assn@(HsPIParam name ty)
- = tcAddErrCtxt (appKindCtxt (ppr assn)) $
- tcHsType ty `thenTc` \ arg_ty ->
- returnTc (IParam name arg_ty)
+ AClass clas -> returnM (ClassP clas arg_tys)
+ other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name)
+
+tc_pred assn@(HsIParam name ty)
+ = addErrCtxt (appKindCtxt (ppr assn)) $
+ tc_type ty `thenM` \ arg_ty ->
+ returnM (IParam name arg_ty)
\end{code}
+
%************************************************************************
%* *
\subsection{Type variables, with knot tying!}
%************************************************************************
\begin{code}
-mk_tyvar (tv_bndr, kind) = mkTyVar tv_bndr kind
+mkImmutTyVars :: [(Name,Kind)] -> [TyVar]
+mkImmutTyVars pairs = [mkTyVar name kind | (name, kind) <- pairs]
mkTyClTyVars :: Kind -- Kind of the tycon or class
-> [HsTyVarBndr Name]
-> [TyVar]
mkTyClTyVars kind tyvar_names
- = map mk_tyvar tyvars_w_kinds
+ = mkImmutTyVars tyvars_w_kinds
where
(tyvars_w_kinds, _) = zipFunTys (hsTyVarNames tyvar_names) kind
-
-tcHsTyVar :: HsTyVarBndr Name -> NF_TcM s TcTyVar
-tcHsTyVar (UserTyVar name) = newKindVar `thenNF_Tc` \ kind ->
- tcNewMutTyVar name kind
- -- NB: mutable kind => mutable tyvar, so that zonking can bind
- -- the tyvar to its immutable form
-
-tcHsTyVar (IfaceTyVar name kind) = returnNF_Tc (mkTyVar name kind)
-
\end{code}
\begin{code}
data TcSigInfo
= TySigInfo
- Name -- N, the Name in corresponding binding
-
TcId -- *Polymorphic* binder for this value...
-- Has name = N
SrcLoc -- Of the signature
instance Outputable TcSigInfo where
- ppr (TySigInfo nm id tyvars theta tau _ inst loc) =
- ppr nm <+> ptext SLIT("::") <+> ppr tyvars <+> ppr theta <+> ptext SLIT("=>") <+> ppr tau
+ ppr (TySigInfo id tyvars theta tau _ inst loc) =
+ ppr id <+> ptext SLIT("::") <+> ppr tyvars <+> ppr theta <+> ptext SLIT("=>") <+> ppr tau
+
+tcSigPolyId :: TcSigInfo -> TcId
+tcSigPolyId (TySigInfo id _ _ _ _ _ _) = id
+
+tcSigMonoId :: TcSigInfo -> TcId
+tcSigMonoId (TySigInfo _ _ _ _ id _ _) = id
maybeSig :: [TcSigInfo] -> Name -> Maybe (TcSigInfo)
-- Search for a particular signature
maybeSig [] name = Nothing
-maybeSig (sig@(TySigInfo sig_name _ _ _ _ _ _ _) : sigs) name
- | name == sig_name = Just sig
- | otherwise = maybeSig sigs name
+maybeSig (sig@(TySigInfo sig_id _ _ _ _ _ _) : sigs) name
+ | name == idName sig_id = Just sig
+ | otherwise = maybeSig sigs name
\end{code}
\begin{code}
-tcTySig :: RenamedSig -> TcM s TcSigInfo
+tcTySig :: RenamedSig -> TcM TcSigInfo
tcTySig (Sig v ty src_loc)
- = tcAddSrcLoc src_loc $
- tcAddErrCtxt (tcsigCtxt v) $
- tcHsSigType ty `thenTc` \ sigma_tc_ty ->
- mkTcSig (mkVanillaId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig ->
- returnTc sig
-
-mkTcSig :: TcId -> SrcLoc -> NF_TcM s TcSigInfo
-mkTcSig poly_id src_loc
+ = addSrcLoc src_loc $
+ tcHsSigType (FunSigCtxt v) ty `thenM` \ sigma_tc_ty ->
+ mkTcSig (mkLocalId v sigma_tc_ty) `thenM` \ sig ->
+ returnM sig
+
+mkTcSig :: TcId -> TcM TcSigInfo
+mkTcSig poly_id
= -- Instantiate this type
-- It's important to do this even though in the error-free case
-- we could just split the sigma_tc_ty (since the tyvars don't
-- the tyvars *do* get unified with something, we want to carry on
-- typechecking the rest of the program with the function bound
-- to a pristine type, namely sigma_tc_ty
- let
- (tyvars, rho) = splitForAllTys (idType poly_id)
- in
- mapNF_Tc tcInstSigVar tyvars `thenNF_Tc` \ tyvars' ->
- -- Make *signature* type variables
-
- let
- tyvar_tys' = mkTyVarTys tyvars'
- rho' = substTy (mkTopTyVarSubst tyvars tyvar_tys') rho
- -- mkTopTyVarSubst because the tyvars' are fresh
- (theta', tau') = splitRhoTy rho'
- -- This splitRhoTy tries hard to make sure that tau' is a type synonym
- -- wherever possible, which can improve interface files.
- in
- newMethodWithGivenTy SignatureOrigin
- poly_id
- tyvar_tys'
- theta' tau' `thenNF_Tc` \ inst ->
+ tcInstType SigTv (idType poly_id) `thenM` \ (tyvars', theta', tau') ->
+
+ getInstLoc SignatureOrigin `thenM` \ inst_loc ->
+ newMethod inst_loc poly_id
+ (mkTyVarTys tyvars')
+ theta' tau' `thenM` \ inst ->
-- We make a Method even if it's not overloaded; no harm
- instFunDeps SignatureOrigin theta' `thenNF_Tc` \ fds ->
+ -- But do not extend the LIE! We're just making an Id.
- returnNF_Tc (TySigInfo name poly_id tyvars' theta' tau' (instToIdBndr inst) (inst : fds) src_loc)
- where
- name = idName poly_id
+ getSrcLocM `thenM` \ src_loc ->
+ returnM (TySigInfo poly_id tyvars' theta' tau'
+ (instToId inst) [inst] src_loc)
\end{code}
-
%************************************************************************
%* *
-\subsection{Checking signature type variables}
+\subsection{Errors and contexts}
%* *
%************************************************************************
-@checkSigTyVars@ is used after the type in a type signature has been unified with
-the actual type found. It then checks that the type variables of the type signature
-are
- (a) Still all type variables
- eg matching signature [a] against inferred type [(p,q)]
- [then a will be unified to a non-type variable]
-
- (b) Still all distinct
- eg matching signature [(a,b)] against inferred type [(p,p)]
- [then a and b will be unified together]
-
- (c) Not mentioned in the environment
- eg the signature for f in this:
-
- g x = ... where
- f :: a->[a]
- f y = [x,y]
-
- Here, f is forced to be monorphic by the free occurence of x.
- (d) Not (unified with another type variable that is) in scope.
- eg f x :: (r->r) = (\y->y) :: forall a. a->r
- when checking the expression type signature, we find that
- even though there is nothing in scope whose type mentions r,
- nevertheless the type signature for the expression isn't right.
-
- Another example is in a class or instance declaration:
- class C a where
- op :: forall b. a -> b
- op x = x
- Here, b gets unified with a
-
-Before doing this, the substitution is applied to the signature type variable.
-
-We used to have the notion of a "DontBind" type variable, which would
-only be bound to itself or nothing. Then points (a) and (b) were
-self-checking. But it gave rise to bogus consequential error messages.
-For example:
-
- f = (*) -- Monomorphic
-
- g :: Num a => a -> a
- g x = f x x
-
-Here, we get a complaint when checking the type signature for g,
-that g isn't polymorphic enough; but then we get another one when
-dealing with the (Num x) context arising from f's definition;
-we try to unify x with Int (to default it), but find that x has already
-been unified with the DontBind variable "a" from g's signature.
-This is really a problem with side-effecting unification; we'd like to
-undo g's effects when its type signature fails, but unification is done
-by side effect, so we can't (easily).
-
-So we revert to ordinary type variables for signatures, and try to
-give a helpful message in checkSigTyVars.
-
-\begin{code}
-checkSigTyVars :: [TcTyVar] -- Universally-quantified type variables in the signature
- -> TcTyVarSet -- Tyvars that are free in the type signature
- -- These should *already* be in the global-var set, and are
- -- used here only to improve the error message
- -> TcM s [TcTyVar] -- Zonked signature type variables
-
-checkSigTyVars [] free = returnTc []
-
-checkSigTyVars sig_tyvars free_tyvars
- = zonkTcTyVars sig_tyvars `thenNF_Tc` \ sig_tys ->
- tcGetGlobalTyVars `thenNF_Tc` \ globals ->
-
- checkTcM (all_ok sig_tys globals)
- (complain sig_tys globals) `thenTc_`
-
- returnTc (map (getTyVar "checkSigTyVars") sig_tys)
-
- where
- all_ok [] acc = True
- all_ok (ty:tys) acc = case getTyVar_maybe ty of
- Nothing -> False -- Point (a)
- Just tv | tv `elemVarSet` acc -> False -- Point (b) or (c)
- | otherwise -> all_ok tys (acc `extendVarSet` tv)
-
-
- complain sig_tys globals
- = -- For the in-scope ones, zonk them and construct a map
- -- from the zonked tyvar to the in-scope one
- -- If any of the in-scope tyvars zonk to a type, then ignore them;
- -- that'll be caught later when we back up to their type sig
- tcGetInScopeTyVars `thenNF_Tc` \ in_scope_tvs ->
- zonkTcTyVars in_scope_tvs `thenNF_Tc` \ in_scope_tys ->
- let
- in_scope_assoc = [ (zonked_tv, in_scope_tv)
- | (z_ty, in_scope_tv) <- in_scope_tys `zip` in_scope_tvs,
- Just zonked_tv <- [getTyVar_maybe z_ty]
- ]
- in_scope_env = mkVarEnv in_scope_assoc
- in
-
- -- "check" checks each sig tyvar in turn
- foldlNF_Tc check
- (env2, in_scope_env, [])
- (tidy_tvs `zip` tidy_tys) `thenNF_Tc` \ (env3, _, msgs) ->
-
- failWithTcM (env3, main_msg $$ nest 4 (vcat msgs))
- where
- (env1, tidy_tvs) = mapAccumL tidyTyVar emptyTidyEnv sig_tyvars
- (env2, tidy_tys) = tidyOpenTypes env1 sig_tys
-
- main_msg = ptext SLIT("Inferred type is less polymorphic than expected")
-
- check (env, acc, msgs) (sig_tyvar,ty)
- -- sig_tyvar is from the signature;
- -- ty is what you get if you zonk sig_tyvar and then tidy it
- --
- -- acc maps a zonked type variable back to a signature type variable
- = case getTyVar_maybe ty of {
- Nothing -> -- Error (a)!
- returnNF_Tc (env, acc, unify_msg sig_tyvar (ppr ty) : msgs) ;
-
- Just tv ->
-
- case lookupVarEnv acc tv of {
- Just sig_tyvar' -> -- Error (b) or (d)!
- returnNF_Tc (env, acc, unify_msg sig_tyvar (ppr sig_tyvar') : msgs) ;
-
- Nothing ->
-
- if tv `elemVarSet` globals -- Error (c)! Type variable escapes
- -- The least comprehensible, so put it last
- then tcGetValueEnv `thenNF_Tc` \ ve ->
- find_globals tv env [] (valueEnvIds ve) `thenNF_Tc` \ (env1, globs) ->
- find_frees tv env1 [] (varSetElems free_tyvars) `thenNF_Tc` \ (env2, frees) ->
- returnNF_Tc (env2, acc, escape_msg sig_tyvar tv globs frees : msgs)
-
- else -- All OK
- returnNF_Tc (env, extendVarEnv acc tv sig_tyvar, msgs)
- }}
-
--- find_globals looks at the value environment and finds values
--- whose types mention the offending type variable. It has to be
--- careful to zonk the Id's type first, so it has to be in the monad.
--- We must be careful to pass it a zonked type variable, too.
-find_globals tv tidy_env acc []
- = returnNF_Tc (tidy_env, acc)
-
-find_globals tv tidy_env acc (id:ids)
- | not (isLocallyDefined id) ||
- isEmptyVarSet (idFreeTyVars id)
- = find_globals tv tidy_env acc ids
-
- | otherwise
- = zonkTcType (idType id) `thenNF_Tc` \ id_ty ->
- if tv `elemVarSet` tyVarsOfType id_ty then
- let
- (tidy_env', id_ty') = tidyOpenType tidy_env id_ty
- acc' = (idName id, id_ty') : acc
- in
- find_globals tv tidy_env' acc' ids
- else
- find_globals tv tidy_env acc ids
-
-find_frees tv tidy_env acc []
- = returnNF_Tc (tidy_env, acc)
-find_frees tv tidy_env acc (ftv:ftvs)
- = zonkTcTyVar ftv `thenNF_Tc` \ ty ->
- if tv `elemVarSet` tyVarsOfType ty then
- let
- (tidy_env', ftv') = tidyTyVar tidy_env ftv
- in
- find_frees tv tidy_env' (ftv':acc) ftvs
- else
- find_frees tv tidy_env acc ftvs
-
-
-escape_msg sig_tv tv globs frees
- = mk_msg sig_tv <+> ptext SLIT("escapes") $$
- if not (null globs) then
- vcat [pp_it <+> ptext SLIT("is mentioned in the environment"),
- ptext SLIT("The following variables in the environment mention") <+> quotes (ppr tv),
- nest 2 (vcat_first 10 [ppr name <+> dcolon <+> ppr ty | (name,ty) <- globs])
- ]
- else if not (null frees) then
- vcat [ptext SLIT("It is reachable from the type variable(s)") <+> pprQuotedList frees,
- nest 2 (ptext SLIT("which") <+> is_are <+> ptext SLIT("free in the signature"))
- ]
- else
- empty -- Sigh. It's really hard to give a good error message
- -- all the time. One bad case is an existential pattern match
- where
- is_are | isSingleton frees = ptext SLIT("is")
- | otherwise = ptext SLIT("are")
- pp_it | sig_tv /= tv = ptext SLIT("It unifies with") <+> quotes (ppr tv) <> comma <+> ptext SLIT("which")
- | otherwise = ptext SLIT("It")
-
- vcat_first :: Int -> [SDoc] -> SDoc
- vcat_first n [] = empty
- vcat_first 0 (x:xs) = text "...others omitted..."
- vcat_first n (x:xs) = x $$ vcat_first (n-1) xs
-
-unify_msg tv thing = mk_msg tv <+> ptext SLIT("is unified with") <+> quotes thing
-mk_msg tv = ptext SLIT("Quantified type variable") <+> quotes (ppr tv)
-\end{code}
-
-These two context are used with checkSigTyVars
-
\begin{code}
-sigCtxt :: Message -> [TcTyVar] -> TcThetaType -> TcTauType
- -> TidyEnv -> NF_TcM s (TidyEnv, Message)
-sigCtxt when sig_tyvars sig_theta sig_tau tidy_env
- = zonkTcType sig_tau `thenNF_Tc` \ actual_tau ->
- let
- (env1, tidy_sig_tyvars) = tidyTyVars tidy_env sig_tyvars
- (env2, tidy_sig_rho) = tidyOpenType env1 (mkRhoTy sig_theta sig_tau)
- (env3, tidy_actual_tau) = tidyOpenType env2 actual_tau
- msg = vcat [ptext SLIT("Signature type: ") <+> pprType (mkForAllTys tidy_sig_tyvars tidy_sig_rho),
- ptext SLIT("Type to generalise:") <+> pprType tidy_actual_tau,
- when
- ]
+hoistForAllTys :: Type -> Type
+-- Used for user-written type signatures only
+-- Move all the foralls and constraints to the top
+-- e.g. T -> forall a. a ==> forall a. T -> a
+-- T -> (?x::Int) -> Int ==> (?x::Int) -> T -> Int
+--
+-- Also: eliminate duplicate constraints. These can show up
+-- when hoisting constraints, notably implicit parameters.
+--
+-- We want to 'look through' type synonyms when doing this
+-- so it's better done on the Type than the HsType
+
+hoistForAllTys ty
+ = let
+ no_shadow_ty = deShadowTy ty
+ -- Running over ty with an empty substitution gives it the
+ -- no-shadowing property. This is important. For example:
+ -- type Foo r = forall a. a -> r
+ -- foo :: Foo (Foo ())
+ -- Here the hoisting should give
+ -- foo :: forall a a1. a -> a1 -> ()
+ --
+ -- What about type vars that are lexically in scope in the envt?
+ -- We simply rely on them having a different unique to any
+ -- binder in 'ty'. Otherwise we'd have to slurp the in-scope-tyvars
+ -- out of the envt, which is boring and (I think) not necessary.
in
- returnNF_Tc (env3, msg)
-
-sigPatCtxt bound_tvs bound_ids tidy_env
- = returnNF_Tc (env1,
- sep [ptext SLIT("When checking a pattern that binds"),
- nest 4 (vcat (zipWith ppr_id show_ids tidy_tys))])
+ case hoist no_shadow_ty of
+ (tvs, theta, body) -> mkForAllTys tvs (mkFunTys (nubBy tcEqType theta) body)
+ -- The 'nubBy' eliminates duplicate constraints,
+ -- notably implicit parameters
where
- show_ids = filter is_interesting bound_ids
- is_interesting id = any (`elemVarSet` idFreeTyVars id) bound_tvs
-
- (env1, tidy_tys) = tidyOpenTypes tidy_env (map idType show_ids)
- ppr_id id ty = ppr id <+> dcolon <+> ppr ty
- -- Don't zonk the types so we get the separate, un-unified versions
+ hoist ty
+ | (tvs1, body_ty) <- tcSplitForAllTys ty,
+ not (null tvs1)
+ = case hoist body_ty of
+ (tvs2,theta,tau) -> (tvs1 ++ tvs2, theta, tau)
+
+ | Just (arg, res) <- tcSplitFunTy_maybe ty
+ = let
+ arg' = hoistForAllTys arg -- Don't forget to apply hoist recursively
+ in -- to the argument type
+ if (isPredTy arg') then
+ case hoist res of
+ (tvs,theta,tau) -> (tvs, arg':theta, tau)
+ else
+ case hoist res of
+ (tvs,theta,tau) -> (tvs, theta, mkFunTy arg' tau)
+
+ | otherwise = ([], [], ty)
\end{code}
%************************************************************************
\begin{code}
-tcsigCtxt v = ptext SLIT("In a type signature for") <+> quotes (ppr v)
-
-typeCtxt ty = ptext SLIT("In the type") <+> quotes (ppr ty)
-
typeKindCtxt :: RenamedHsType -> Message
typeKindCtxt ty = sep [ptext SLIT("When checking that"),
nest 2 (quotes (ppr ty)),
appKindCtxt :: SDoc -> Message
appKindCtxt pp = ptext SLIT("When checking kinds in") <+> quotes pp
-wrongThingErr expected actual name
- = pp_actual actual <+> quotes (ppr name) <+> ptext SLIT("used as a") <+> text expected
+wrongThingErr expected thing name
+ = pp_thing thing <+> quotes (ppr name) <+> ptext SLIT("used as a") <+> text expected
where
- pp_actual (ATyCon _) = ptext SLIT("Type constructor")
- pp_actual (AClass _) = ptext SLIT("Class")
- pp_actual (ATyVar _) = ptext SLIT("Type variable")
- pp_actual (AThing _) = ptext SLIT("Utterly bogus")
-
-ambigErr pred ty
- = sep [ptext SLIT("Ambiguous constraint") <+> quotes (pprPred pred),
- nest 4 (ptext SLIT("for the type:") <+> ppr ty),
- nest 4 (ptext SLIT("Each forall'd type variable mentioned by the constraint must appear after the =>"))]
-
-freeErr pred ty
- = sep [ptext SLIT("The constraint") <+> quotes (pprPred pred) <+>
- ptext SLIT("does not mention any of the universally quantified type variables"),
- nest 4 (ptext SLIT("in the type") <+> quotes (ppr ty))
- ]
+ pp_thing (AGlobal (ATyCon _)) = ptext SLIT("Type constructor")
+ pp_thing (AGlobal (AClass _)) = ptext SLIT("Class")
+ pp_thing (AGlobal (AnId _)) = ptext SLIT("Identifier")
+ pp_thing (AGlobal (ADataCon _)) = ptext SLIT("Data constructor")
+ pp_thing (ATyVar _) = ptext SLIT("Type variable")
+ pp_thing (ATcId _ _ _) = ptext SLIT("Local identifier")
+ pp_thing (AThing _) = ptext SLIT("Utterly bogus")
\end{code}