X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcMonoType.lhs;h=c257251ee014a36a85df3df3cdef9410c7928c28;hb=16e4ce4c0c02650082f2e11982017c903c549ad5;hp=4fe0e3e33a38a54c06552a66d7781078410c36a4;hpb=266fadd93461d4317967df08cd641e965cd8769a;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcMonoType.lhs b/ghc/compiler/typecheck/TcMonoType.lhs index 4fe0e3e..c257251 100644 --- a/ghc/compiler/typecheck/TcMonoType.lhs +++ b/ghc/compiler/typecheck/TcMonoType.lhs @@ -4,58 +4,59 @@ \section[TcMonoType]{Typechecking user-specified @MonoTypes@} \begin{code} -module TcMonoType ( tcHsType, tcHsTypeKind, tcHsTopType, tcHsTopBoxedType, tcHsTopTypeKind, - tcContext, tcHsTyVar, kcHsTyVar, - tcExtendTyVarScope, tcExtendTopTyVarScope, - TcSigInfo(..), tcTySig, mkTcSig, maybeSig, - checkSigTyVars, sigCtxt, sigPatCtxt +module TcMonoType ( tcHsSigType, tcHsType, tcIfaceType, tcHsTheta, tcHsPred, + UserTypeCtxt(..), + + -- Kind checking + kcHsTyVar, kcHsTyVars, mkTyClTyVars, + kcHsType, kcHsSigType, kcHsSigTypes, + kcHsLiftedSigType, kcHsContext, + tcAddScopedTyVars, tcHsTyVars, mkImmutTyVars, + + TcSigInfo(..), tcTySig, mkTcSig, maybeSig, tcSigPolyId, tcSigMonoId ) where #include "HsVersions.h" -import HsSyn ( HsType(..), HsTyVar(..), MonoUsageAnn(..), - Sig(..), HsPred(..), pprHsPred, pprParendHsType ) -import RnHsSyn ( RenamedHsType, 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, TcTyThing(..) +import TcRnMonad +import TcEnv ( tcExtendTyVarEnv, tcLookup, tcLookupGlobal, + TyThing(..), TcTyThing(..), tcExtendKindEnv, + getInLocalScope ) -import TcType ( TcType, TcKind, TcTyVar, TcThetaType, TcTauType, - typeToTcType, kindToTcKind, - newKindVar, tcInstSigVar, - zonkTcKindToKind, zonkTcTypeToType, zonkTcTyVars, zonkTcType +import TcMType ( newMutTyVar, newKindVar, zonkKindEnv, tcInstType, zonkTcType, + checkValidType, UserTypeCtxt(..), pprUserTypeCtxt, newOpenTypeKind ) -import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToIdBndr ) -import TcUnify ( unifyKind, unifyKinds, unifyTypeKind ) -import Type ( Type, PredType(..), ThetaType, UsageAnn(..), - mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, mkUsgTy, - mkUsForAllTy, zipFunTys, - mkSigmaTy, mkDictTy, mkTyConApp, mkAppTys, splitForAllTys, splitRhoTy, - boxedTypeKind, unboxedTypeKind, tyVarsOfType, - mkArrowKinds, getTyVar_maybe, getTyVar, - tidyOpenType, tidyOpenTypes, tidyTyVar, - tyVarsOfType, tyVarsOfTypes +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 ) -import Subst ( mkTopTyVarSubst, substTy ) -import Id ( mkVanillaId, idName, idType, idFreeTyVars ) -import Var ( TyVar, mkTyVar, mkNamedUVar, varName ) -import VarEnv -import VarSet -import Bag ( bagToList ) +import qualified Type ( splitFunTys ) +import Inst ( Inst, InstOrigin(..), newMethod, instToId ) + +import Id ( mkLocalId, idName, idType ) +import Var ( TyVar, mkTyVar, tyVarKind ) import ErrUtils ( Message ) -import PrelInfo ( cCallishClassKeys ) -import TyCon ( TyCon ) -import Name ( Name, OccName, isLocallyDefined ) -import TysWiredIn ( mkListTy, mkTupleTy, mkUnboxedTupleTy ) -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 Unique ( Unique, Uniquable(..) ) -import Util ( zipWithEqual, zipLazy, mapAccumL ) +import Util ( lengthIs ) import Outputable +import List ( nubBy ) \end{code} @@ -65,255 +66,517 @@ import Outputable %* * %************************************************************************ -tcHsType and tcHsTypeKind -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +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] -tcHsType checks that the type really is of kind Type! +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} -tcHsType :: RenamedHsType -> TcM s TcType -tcHsType ty - = -- tcAddErrCtxt (typeCtxt ty) $ - tc_type ty - -tcHsTypeKind :: RenamedHsType -> TcM s (TcKind, TcType) -tcHsTypeKind ty - = -- tcAddErrCtxt (typeCtxt ty) $ - tc_type_kind ty - --- Type-check a type, *and* then lazily zonk it. The important --- point is that this zonks all the uncommitted *kind* variables --- in kinds of any any nested for-all tyvars. --- There won't be any mutable *type* variables at all. --- --- NOTE the forkNF_Tc. This makes the zonking lazy, which is --- absolutely necessary. During the type-checking of a recursive --- group of tycons/classes (TcTyClsDecls.tcGroup) we use an --- environment in which we aren't allowed to look at the actual --- tycons/classes returned from a lookup. Because tc_app does --- look at the tycon to build the type, we can't look at the type --- either, until we get out of the loop. The fork delays the --- zonking till we've completed the loop. Sigh. - -tcHsTopType :: RenamedHsType -> TcM s Type -tcHsTopType ty - = -- tcAddErrCtxt (typeCtxt ty) $ - tc_type ty `thenTc` \ ty' -> - forkNF_Tc (zonkTcTypeToType ty') - -tcHsTopTypeKind :: RenamedHsType -> TcM s (TcKind, Type) -tcHsTopTypeKind ty - = -- tcAddErrCtxt (typeCtxt ty) $ - tc_type_kind ty `thenTc` \ (kind, ty') -> - forkNF_Tc (zonkTcTypeToType ty') `thenTc` \ zonked_ty -> - returnNF_Tc (kind, zonked_ty) - -tcHsTopBoxedType :: RenamedHsType -> TcM s Type -tcHsTopBoxedType ty - = -- tcAddErrCtxt (typeCtxt ty) $ - tc_boxed_type ty `thenTc` \ ty' -> - forkNF_Tc (zonkTcTypeToType ty') +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} -The main work horse -~~~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\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} -tc_boxed_type :: RenamedHsType -> TcM s Type -tc_boxed_type ty - = tc_type_kind ty `thenTc` \ (actual_kind, tc_ty) -> - tcAddErrCtxt (typeKindCtxt ty) - (unifyKind boxedTypeKind actual_kind) `thenTc_` - returnTc tc_ty - -tc_type :: RenamedHsType -> TcM s Type -tc_type ty - -- The type ty must be a *type*, but it can be boxed - -- or unboxed. So we check that is is of form (Type bv) - -- using unifyTypeKind - = tc_type_kind ty `thenTc` \ (actual_kind, tc_ty) -> - tcAddErrCtxt (typeKindCtxt ty) - (unifyTypeKind actual_kind) `thenTc_` - returnTc tc_ty - -tc_type_kind :: RenamedHsType -> TcM s (TcKind, Type) -tc_type_kind ty@(MonoTyVar name) - = tc_app ty [] +-- 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} -tc_type_kind (MonoListTy ty) - = tc_boxed_type ty `thenTc` \ tau_ty -> - returnTc (boxedTypeKind, mkListTy tau_ty) - -tc_type_kind (MonoTupleTy tys True {-boxed-}) - = mapTc tc_boxed_type tys `thenTc` \ tau_tys -> - returnTc (boxedTypeKind, mkTupleTy (length tys) tau_tys) - -tc_type_kind (MonoTupleTy tys False {-unboxed-}) - = mapTc tc_type tys `thenTc` \ tau_tys -> - returnTc (unboxedTypeKind, mkUnboxedTupleTy (length tys) tau_tys) - -tc_type_kind (MonoFunTy ty1 ty2) - = tc_type ty1 `thenTc` \ tau_ty1 -> - tc_type ty2 `thenTc` \ tau_ty2 -> - returnTc (boxedTypeKind, mkFunTy tau_ty1 tau_ty2) - -tc_type_kind (MonoTyApp ty1 ty2) - = tc_app ty1 [ty2] - -tc_type_kind (MonoDictTy class_name tys) - = tcClassAssertion (HsPClass class_name tys) `thenTc` \ (Class clas arg_tys) -> - returnTc (boxedTypeKind, mkDictTy clas arg_tys) - -tc_type_kind (MonoUsgTy usg ty) - = newUsg usg `thenTc` \ usg' -> - tc_type_kind ty `thenTc` \ (kind, tc_ty) -> - returnTc (kind, mkUsgTy usg' tc_ty) + +\begin{code} +kcHsTyVar :: HsTyVarBndr name -> TcM (name, TcKind) +kcHsTyVars :: [HsTyVarBndr name] -> TcM [(name, TcKind)] + +kcHsTyVar (UserTyVar name) = newNamedKindVar name +kcHsTyVar (IfaceTyVar name kind) = returnM (name, kind) + +kcHsTyVars tvs = mappM kcHsTyVar tvs + +newNamedKindVar name = newKindVar `thenM` \ kind -> + returnM (name, 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 () + -- The type ty must be a *type*, but it can be lifted or unlifted. +kcTypeType ty + = kcHsType ty `thenM` \ kind -> + if isTypeKind kind then + return () + else + newOpenTypeKind `thenM` \ exp_kind -> + checkExpectedKind (ppr ty) kind exp_kind `thenM_` + returnM () + +--------------------------- +kcHsSigType, kcHsLiftedSigType :: RenamedHsType -> TcM () + -- Used for type signatures +kcHsSigType ty = kcTypeType ty +kcHsSigTypes tys = mappM_ kcHsSigType tys +kcHsLiftedSigType ty = kcLiftedType ty `thenM_` returnM () + +--------------------------- +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 (HsFunTy ty1 ty2) + = kcTypeType ty1 `thenM_` + kcTypeType ty2 `thenM_` + returnM liftedTypeKind + +kcHsType (HsOpTy ty1 HsArrow ty2) + = kcTypeType ty1 `thenM_` + kcTypeType ty2 `thenM_` + returnM liftedTypeKind + +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 `thenM_` + returnM liftedTypeKind + +kcHsType ty@(HsAppTy ty1 ty2) + = addErrCtxt (appKindCtxt (ppr ty)) $ + kc_app ty [] where - newUsg usg = case usg of - MonoUsOnce -> returnTc UsOnce - MonoUsMany -> returnTc UsMany - MonoUsVar uv_name -> tcLookupUVar uv_name `thenTc` \ uv -> - returnTc (UsVar uv) + kc_app (HsAppTy f a) as = kc_app f (a:as) + kc_app f as = kcHsType f `thenM` \ fk -> + kcApps (ppr f) fk as + +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. + +--------------------------- +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") + +--------------------------- +-- 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) + } + +--------------------------- +kc_pred :: RenamedHsPred -> TcM TcKind -- Does *not* check for a saturated + -- application (reason: used from TcDeriv) +kc_pred pred@(HsIParam name ty) + = kcHsType ty + +kc_pred pred@(HsClassP cls tys) + = kcClass cls `thenM` \ kind -> + kcApps (ppr cls) kind tys + +--------------------------- +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{tc_type} +%* * +%************************************************************************ + +tc_type, the main work horse +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + ------------------- + *** BIG WARNING *** + ------------------- + +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. + + data T a = MkT a [T a] + +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 *** + -------------------------- + + +\begin{code} +tc_type :: RenamedHsType -> TcM Type + +tc_type ty@(HsTyVar name) + = tc_app ty [] + +tc_type (HsKindSig ty k) + = tc_type ty -- Kind checking done already + +tc_type (HsListTy ty) + = tc_type ty `thenM` \ tau_ty -> + returnM (mkListTy tau_ty) + +tc_type (HsPArrTy ty) + = tc_type ty `thenM` \ tau_ty -> + returnM (mkPArrTy tau_ty) + +tc_type (HsTupleTy (HsTupCon boxity arity) tys) + = ASSERT( tys `lengthIs` arity ) + tc_types tys `thenM` \ tau_tys -> + returnM (mkTupleTy boxity arity tau_tys) + +tc_type (HsFunTy ty1 ty2) + = tc_type ty1 `thenM` \ tau_ty1 -> + tc_type ty2 `thenM` \ tau_ty2 -> + returnM (mkFunTy tau_ty1 tau_ty2) -tc_type_kind (MonoUsgForAllTy uv_name ty) +tc_type (HsOpTy ty1 HsArrow ty2) + = tc_type ty1 `thenM` \ tau_ty1 -> + tc_type ty2 `thenM` \ tau_ty2 -> + returnM (mkFunTy tau_ty1 tau_ty2) + +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] + +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 - uv = mkNamedUVar uv_name - in - tcExtendUVarEnv uv_name uv $ - tc_type_kind ty `thenTc` \ (kind, tc_ty) -> - returnTc (kind, mkUsForAllTy uv tc_ty) - -tc_type_kind (HsForAllTy (Just tv_names) context ty) - = tcExtendTyVarScope tv_names $ \ tyvars -> - tcContext context `thenTc` \ theta -> - tc_type_kind ty `thenTc` \ (kind, tau) -> - tcGetInScopeTyVars `thenTc` \ in_scope_vars -> - let - body_kind | null theta = kind - | otherwise = boxedTypeKind - -- 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 - check ct@(Class c tys) | ambiguous = failWithTc (ambigErr (c,tys) tau) - | otherwise = returnTc () - where ct_vars = tyVarsOfTypes tys - forall_tyvars = map varName in_scope_vars - tau_vars = tyVarsOfType tau - ambig ct_var = (varName ct_var `elem` forall_tyvars) && - not (ct_var `elemUFM` tau_vars) - ambiguous = foldUFM ((||) . ambig) False ct_vars + kind_check = kcHsContext ctxt `thenM_` kcHsType ty in - mapTc check theta `thenTc_` - returnTc (body_kind, mkSigmaTy 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 (MonoTyApp ty1 ty2) tys +tc_app :: RenamedHsType -> [RenamedHsType] -> TcM Type +tc_app (HsAppTy ty1 ty2) tys = tc_app ty1 (ty2:tys) tc_app ty tys - | null tys - = tc_fun_type ty [] + = 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) - | otherwise - = tcAddErrCtxt (appKindCtxt pp_app) $ - mapAndUnzipTc tc_type_kind tys `thenTc` \ (arg_kinds, arg_tys) -> - tc_fun_type ty arg_tys `thenTc` \ (fun_kind, result_ty) -> - - -- Check argument compatibility - newKindVar `thenNF_Tc` \ result_kind -> - unifyKind fun_kind (mkArrowKinds arg_kinds result_kind) - `thenTc_` - returnTc (result_kind, result_ty) - where - pp_app = ppr ty <+> sep (map pprParendHsType tys) - --- (tc_fun_type ty arg_tys) returns (kind-of ty, mkAppTys 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 (MonoTyVar name) arg_tys - = tcLookupTy name `thenTc` \ (tycon_kind, maybe_arity, thing) -> +tc_fun_type name arg_tys + = tcLookup name `thenM` \ thing -> case thing of - ATyVar tv -> returnTc (tycon_kind, mkAppTys (mkTyVarTy tv) arg_tys) - AClass clas -> failWithTc (classAsTyConErr name) - ATyCon tc -> case maybe_arity of - Nothing -> -- Data or newtype - returnTc (tycon_kind, mkTyConApp tc arg_tys) - - Just arity -> -- Type synonym - checkTc (arity <= n_args) err_msg `thenTc_` - returnTc (tycon_kind, result_ty) - where - -- It's OK to have an *over-applied* type synonym - -- data Tree a b = ... - -- type Foo a = Tree [a] - -- f :: Foo a b -> ... - result_ty = mkAppTys (mkSynTy tc (take arity arg_tys)) - (drop arity arg_tys) - err_msg = arityErr "type synonym" name arity n_args - n_args = length arg_tys - -tc_fun_type ty arg_tys - = tc_type_kind ty `thenTc` \ (fun_kind, fun_ty) -> - returnTc (fun_kind, mkAppTys fun_ty arg_tys) + ATyVar tv -> returnM (mkAppTys (mkTyVarTy tv) arg_tys) + + AGlobal (ATyCon tc) -> returnM (mkGenTyConApp tc arg_tys) + + other -> failWithTc (wrongThingErr "type constructor" thing name) \end{code} Contexts ~~~~~~~~ \begin{code} - -tcContext :: RenamedContext -> TcM s ThetaType -tcContext context - = --Someone discovered that @CCallable@ and @CReturnable@ - -- could be used in contexts such as: - -- foo :: CCallable a => a -> PrimIO Int - -- Doing this utterly wrecks the whole point of introducing these - -- classes so we specifically check that this isn't being done. - -- - -- We *don't* do this check in tcClassAssertion, because that's - -- called when checking a HsDictTy, and we don't want to reject - -- instance CCallable Int - -- etc. Ugh! - mapTc check_naughty context `thenTc_` - - mapTc tcClassAssertion context - - where - check_naughty (HsPClass class_name _) - = checkTc (not (getUnique class_name `elem` cCallishClassKeys)) - (naughtyCCallContextErr class_name) - check_naughty (HsPIParam _ _) = returnTc () - -tcClassAssertion assn@(HsPClass class_name tys) - = tcAddErrCtxt (appKindCtxt (pprHsPred assn)) $ - mapAndUnzipTc tc_type_kind tys `thenTc` \ (arg_kinds, arg_tys) -> - tcLookupTy class_name `thenTc` \ (kind, ~(Just arity), 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 - ATyVar _ -> failWithTc (tyVarAsClassErr class_name) - ATyCon _ -> failWithTc (tyConAsClassErr class_name) - AClass clas -> - -- Check with kind mis-match - checkTc (arity == n_tys) err `thenTc_` - unifyKind kind (mkArrowKinds arg_kinds boxedTypeKind) `thenTc_` - returnTc (Class clas arg_tys) - where - n_tys = length tys - err = arityErr "Class" class_name arity n_tys -tcClassAssertion assn@(HsPIParam name ty) - = tcAddErrCtxt (appKindCtxt (pprHsPred assn)) $ - tc_type_kind ty `thenTc` \ (arg_kind, 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!} @@ -321,38 +584,16 @@ tcClassAssertion assn@(HsPIParam name ty) %************************************************************************ \begin{code} -tcExtendTopTyVarScope :: TcKind -> [HsTyVar Name] - -> ([TcTyVar] -> TcKind -> TcM s a) - -> TcM s a -tcExtendTopTyVarScope kind tyvar_names thing_inside - = let - (tyvars_w_kinds, result_kind) = zipFunTys tyvar_names kind - tyvars = map mk_tv tyvars_w_kinds - in - tcExtendTyVarEnv tyvars (thing_inside tyvars result_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 + = mkImmutTyVars tyvars_w_kinds where - mk_tv (UserTyVar name, kind) = mkTyVar name kind - mk_tv (IfaceTyVar name _, kind) = mkTyVar name kind - -- NB: immutable tyvars, but perhaps with mutable kinds - -tcExtendTyVarScope :: [HsTyVar Name] - -> ([TcTyVar] -> TcM s a) -> TcM s a -tcExtendTyVarScope tv_names thing_inside - = mapNF_Tc tcHsTyVar tv_names `thenNF_Tc` \ tyvars -> - tcExtendTyVarEnv tyvars $ - thing_inside tyvars - -tcHsTyVar :: HsTyVar 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 (kindToTcKind kind)) - -kcHsTyVar :: HsTyVar name -> NF_TcM s TcKind -kcHsTyVar (UserTyVar name) = newKindVar -kcHsTyVar (IfaceTyVar name kind) = returnNF_Tc (kindToTcKind kind) + (tyvars_w_kinds, _) = zipFunTys (hsTyVarNames tyvar_names) kind \end{code} @@ -374,8 +615,6 @@ been instantiated. \begin{code} data TcSigInfo = TySigInfo - Name -- N, the Name in corresponding binding - TcId -- *Polymorphic* binder for this value... -- Has name = N @@ -387,32 +626,41 @@ data TcSigInfo -- Does *not* have name = N -- Has type tau - Inst -- Empty if theta is null, or + [Inst] -- Empty if theta is null, or -- (method mono_id) otherwise SrcLoc -- Of the signature +instance Outputable TcSigInfo where + 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 $ - tcHsType ty `thenTc` \ sigma_tc_ty -> - mkTcSig (mkVanillaId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig -> - returnTc sig + = addSrcLoc src_loc $ + tcHsSigType (FunSigCtxt v) ty `thenM` \ sigma_tc_ty -> + mkTcSig (mkLocalId v sigma_tc_ty) `thenM` \ sig -> + returnM sig -mkTcSig :: TcId -> SrcLoc -> NF_TcM s TcSigInfo -mkTcSig poly_id src_loc +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 @@ -420,239 +668,79 @@ mkTcSig poly_id src_loc -- 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 + -- But do not extend the LIE! We're just making an Id. - returnNF_Tc (TySigInfo name poly_id tyvars' theta' tau' (instToIdBndr inst) inst 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] -- The original signature type variables - -> TcM s [TcTyVar] -- Zonked signature type variables - -checkSigTyVars [] = returnTc [] - -checkSigTyVars sig_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) -> - returnNF_Tc (env1, acc, escape_msg sig_tyvar tv globs : 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 ids - | null ids - = returnNF_Tc (tidy_env, []) - -find_globals tv tidy_env (id:ids) - | not (isLocallyDefined id) || - isEmptyVarSet (idFreeTyVars id) - = find_globals tv tidy_env 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 - in - find_globals tv tidy_env' ids `thenNF_Tc` \ (tidy_env'', globs) -> - returnNF_Tc (tidy_env'', (idName id, id_ty') : globs) - else - find_globals tv tidy_env ids - -escape_msg sig_tv tv globs - = vcat [mk_msg sig_tv <+> ptext SLIT("escapes"), - pp_escape, - ptext SLIT("The following variables in the environment mention") <+> quotes (ppr tv), - nest 4 (vcat_first 10 [ppr name <+> dcolon <+> ppr ty | (name,ty) <- globs]) - ] - where - pp_escape | sig_tv /= tv = ptext SLIT("It unifies with") <+> - quotes (ppr tv) <> comma <+> - ptext SLIT("which is mentioned in the environment") - | otherwise = ptext SLIT("It is mentioned in the environment") - - 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} +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 -These two context are used with checkSigTyVars - -\begin{code} -sigCtxt :: (Type -> Message) -> Type - -> TidyEnv -> NF_TcM s (TidyEnv, Message) -sigCtxt mk_msg sig_ty tidy_env +hoistForAllTys ty = let - (env1, tidy_sig_ty) = tidyOpenType tidy_env sig_ty + 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 (env1, mk_msg tidy_sig_ty) - -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} @@ -663,12 +751,6 @@ sigPatCtxt bound_tvs bound_ids tidy_env %************************************************************************ \begin{code} -naughtyCCallContextErr clas_name - = sep [ptext SLIT("Can't use class") <+> quotes (ppr clas_name), - ptext SLIT("in a context")] - -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)), @@ -677,17 +759,14 @@ typeKindCtxt ty = sep [ptext SLIT("When checking that"), appKindCtxt :: SDoc -> Message appKindCtxt pp = ptext SLIT("When checking kinds in") <+> quotes pp -classAsTyConErr name - = ptext SLIT("Class used as a type constructor:") <+> ppr name - -tyConAsClassErr name - = ptext SLIT("Type constructor used as a class:") <+> ppr name - -tyVarAsClassErr name - = ptext SLIT("Type variable used as a class:") <+> ppr name - -ambigErr (c, ts) ty - = sep [ptext SLIT("Ambiguous constraint") <+> quotes (pprConstraint c ts), - 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 =>."))] +wrongThingErr expected thing name + = pp_thing thing <+> quotes (ppr name) <+> ptext SLIT("used as a") <+> text expected + where + 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}