X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcMonoType.lhs;h=ca4629a164df4070b597ff4b02b4c8975414f182;hb=6aa013b48b9a85b643672be56f89f0bd0108db1f;hp=1c516cfb6bcc13025e59272bbf22dc6221b3abfb;hpb=438596897ebbe25a07e1c82085cfbc5bdb00f09e;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcMonoType.lhs b/ghc/compiler/typecheck/TcMonoType.lhs index 1c516cf..ca4629a 100644 --- a/ghc/compiler/typecheck/TcMonoType.lhs +++ b/ghc/compiler/typecheck/TcMonoType.lhs @@ -4,48 +4,68 @@ \section[TcMonoType]{Typechecking user-specified @MonoTypes@} \begin{code} -module TcMonoType ( tcHsType, tcHsTcType, tcHsTypeKind, tcContext, - tcTyVarScope, - TcSigInfo(..), tcTySig, mkTcSig, noSigs, maybeSig, - checkSigTyVars, sigCtxt, existentialPatCtxt +module TcMonoType ( tcHsSigType, tcHsType, tcIfaceType, tcHsTheta, + UserTypeCtxt(..), + + -- Kind checking + kcHsTyVar, kcHsTyVars, mkTyClTyVars, + kcHsType, kcHsSigType, kcHsSigTypes, + kcHsLiftedSigType, kcHsContext, + tcAddScopedTyVars, tcHsTyVars, mkImmutTyVars, + + TcSigInfo(..), tcTySig, mkTcSig, maybeSig, + checkSigTyVars, sigCtxt, sigPatCtxt ) where #include "HsVersions.h" -import HsSyn ( HsType(..), HsTyVar(..), Sig(..), pprContext ) -import RnHsSyn ( RenamedHsType, RenamedContext, RenamedSig ) -import TcHsSyn ( TcIdBndr, TcIdOcc(..) ) +import HsSyn ( HsType(..), HsTyVarBndr(..), + Sig(..), HsPred(..), pprParendHsType, HsTupCon(..), hsTyVarNames ) +import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig, extractHsTyVars ) +import TcHsSyn ( TcId ) import TcMonad -import TcEnv ( tcLookupTyVar, tcLookupClass, tcLookupTyCon, tcExtendTyVarEnv, - tcGetGlobalTyVars, tidyTypes, tidyTyVar +import TcEnv ( tcExtendTyVarEnv, tcLookup, tcLookupGlobal, + tcGetGlobalTyVars, tcLEnvElts, tcInLocalScope, + TyThing(..), TcTyThing(..), tcExtendKindEnv ) -import TcType ( TcType, TcKind, TcTyVar, TcThetaType, TcTauType, - typeToTcType, tcInstTcType, kindToTcKind, - newKindVar, - zonkTcKindToKind, zonkTcTyVars, zonkTcType +import TcMType ( newKindVar, tcInstSigTyVars, + zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar, + unifyKind, unifyOpenTypeKind, + checkValidType, UserTypeCtxt(..), pprUserTypeCtxt ) -import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToIdBndr ) -import TcUnify ( unifyKind, unifyKinds ) -import Type ( Type, ThetaType, +import TcType ( Type, Kind, SourceType(..), ThetaType, TyVarDetails(..), + TcTyVar, TcTyVarSet, TcType, TcKind, TcThetaType, TcTauType, mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, - mkSigmaTy, mkDictTy, mkTyConApp, mkAppTys, splitRhoTy, - boxedTypeKind, unboxedTypeKind, openTypeKind, - mkArrowKind, getTyVar_maybe, getTyVar + tcSplitForAllTys, tcSplitRhoTy, + hoistForAllTys, allDistinctTyVars, zipFunTys, + mkSigmaTy, mkPredTy, mkTyConApp, mkAppTys, mkRhoTy, + liftedTypeKind, unliftedTypeKind, mkArrowKind, + mkArrowKinds, tcGetTyVar_maybe, tcGetTyVar, tcSplitFunTy_maybe, + tidyOpenType, tidyOpenTypes, tidyOpenTyVar, tidyOpenTyVars, + tyVarsOfType, mkForAllTys ) -import Id ( mkUserId, idName, idType, idFreeTyVars ) -import Var ( TyVar, mkTyVar ) +import qualified Type ( getTyVar_maybe ) + +import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToId ) +import PprType ( pprType ) +import Subst ( mkTopTyVarSubst, substTy ) +import CoreFVs ( idFreeTyVars ) +import Id ( mkLocalId, idName, idType ) +import Var ( Id, Var, TyVar, mkTyVar, tyVarKind, isMutTyVar, mutTyVarDetails ) import VarEnv import VarSet -import Bag ( bagToList ) -import PrelInfo ( cCallishClassKeys ) -import TyCon ( TyCon ) -import Name ( Name, OccName, isTvOcc, getOccName ) -import TysWiredIn ( mkListTy, mkTupleTy, mkUnboxedTupleTy ) +import ErrUtils ( Message ) +import TyCon ( TyCon, isSynTyCon, tyConArity, tyConKind ) +import Class ( classTyCon ) +import Name ( Name, getSrcLoc ) +import NameSet +import TysWiredIn ( mkListTy, mkTupleTy, genUnitTyCon ) +import BasicTypes ( Boxity(..) ) import SrcLoc ( SrcLoc ) -import Unique ( Unique, Uniquable(..) ) -import Util ( zipWithEqual, zipLazy, mapAccumL ) +import Util ( isSingleton, lengthIs ) import Outputable + \end{code} @@ -55,181 +75,424 @@ import Outputable %* * %************************************************************************ -tcHsType and tcHsTypeKind -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Generally speaking we now type-check types in three phases -tcHsType checks that the type really is of kind Type! + 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} -tcHsType :: RenamedHsType -> TcM s Type -tcHsType ty - = tcAddErrCtxt (typeCtxt ty) $ - tc_hs_type ty - --- Version for when we need a TcType returned -tcHsTcType :: RenamedHsType -> TcM s (TcType s) -tcHsTcType ty - = tcHsType ty `thenTc` \ ty' -> - returnTc (typeToTcType ty') - -tc_hs_type ty - = tc_hs_type_kind ty `thenTc` \ (kind,ty) -> - -- Check that it really is a type - unifyKind openTypeKind kind `thenTc_` - returnTc ty +tcHsSigType :: UserTypeCtxt -> RenamedHsType -> TcM Type + -- Do kind checking, and hoist for-alls to the top +tcHsSigType ctxt ty = tcAddErrCtxt (checkTypeCtxt ctxt ty) ( + kcTypeType ty `thenTc_` + tcHsType ty + ) `thenTc` \ ty' -> + checkValidType ctxt ty' `thenTc_` + returnTc 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 `thenTc` \ ty' -> + returnTc (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 = mapTc 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} -tcHsTypeKind does the real work. It returns a kind and a type. + +%************************************************************************ +%* * +\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} -tcHsTypeKind :: RenamedHsType -> TcM s (TcKind s, Type) +-- 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 `thenNF_Tc` \ tv_names_w_kinds -> + tcExtendKindEnv tv_names_w_kinds kind_check `thenTc_` + zonkKindEnv tv_names_w_kinds `thenNF_Tc` \ 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 + = tcGetEnv `thenNF_Tc` \ env -> + let + all_sig_tvs = foldr (unionNameSets . extractHsTyVars) emptyNameSet sig_tys + sig_tvs = filter not_in_scope (nameSetToList all_sig_tvs) + not_in_scope tv = not (tcInLocalScope env tv) + in + mapNF_Tc newNamedKindVar sig_tvs `thenTc` \ kind_env -> + tcExtendKindEnv kind_env (kcHsSigTypes sig_tys) `thenTc_` + zonkKindEnv kind_env `thenNF_Tc` \ tvs_w_kinds -> + listTc [ tcNewMutTyVar name kind PatSigTv + | (name, kind) <- tvs_w_kinds] `thenNF_Tc` \ tyvars -> + tcExtendTyVarEnv tyvars thing_inside +\end{code} + + +\begin{code} +kcHsTyVar :: HsTyVarBndr name -> NF_TcM (name, TcKind) +kcHsTyVars :: [HsTyVarBndr name] -> NF_TcM [(name, TcKind)] -tcHsTypeKind ty - = tcAddErrCtxt (typeCtxt ty) $ - tc_hs_type_kind ty +kcHsTyVar (UserTyVar name) = newNamedKindVar name +kcHsTyVar (IfaceTyVar name kind) = returnNF_Tc (name, kind) +kcHsTyVars tvs = mapNF_Tc kcHsTyVar tvs - -- This equation isn't needed (the next one would handle it fine) - -- but it's rather a common case, so we handle it directly -tc_hs_type_kind (MonoTyVar name) - | isTvOcc (getOccName name) - = tcLookupTyVar name `thenNF_Tc` \ (kind,tyvar) -> - returnTc (kind, mkTyVarTy tyvar) +newNamedKindVar name = newKindVar `thenNF_Tc` \ kind -> + returnNF_Tc (name, kind) -tc_hs_type_kind ty@(MonoTyVar name) - = tcFunType ty [] +--------------------------- +kcLiftedType :: RenamedHsType -> TcM () + -- The type ty must be a *lifted* *type* +kcLiftedType ty + = kcHsType ty `thenTc` \ kind -> + tcAddErrCtxt (typeKindCtxt ty) $ + unifyKind liftedTypeKind kind -tc_hs_type_kind (MonoListTy ty) - = tc_hs_type ty `thenTc` \ tau_ty -> - returnTc (boxedTypeKind, mkListTy tau_ty) - -tc_hs_type_kind (MonoTupleTy tys True{-boxed-}) - = mapTc tc_hs_type tys `thenTc` \ tau_tys -> - returnTc (boxedTypeKind, mkTupleTy (length tys) tau_tys) - -tc_hs_type_kind (MonoTupleTy tys False{-unboxed-}) - = mapTc tc_hs_type tys `thenTc` \ tau_tys -> - returnTc (unboxedTypeKind, mkUnboxedTupleTy (length tys) tau_tys) - -tc_hs_type_kind (MonoFunTy ty1 ty2) - = tc_hs_type ty1 `thenTc` \ tau_ty1 -> - tc_hs_type ty2 `thenTc` \ tau_ty2 -> - returnTc (boxedTypeKind, mkFunTy tau_ty1 tau_ty2) - -tc_hs_type_kind (MonoTyApp ty1 ty2) - = tcTyApp ty1 [ty2] - -tc_hs_type_kind (HsForAllTy tv_names context ty) - = tcTyVarScope tv_names $ \ tyvars -> - tcContext context `thenTc` \ theta -> - tc_hs_type ty `thenTc` \ tau -> - -- For-all's are of kind type! - returnTc (boxedTypeKind, mkSigmaTy tyvars theta tau) - --- for unfoldings, and instance decls, only: -tc_hs_type_kind (MonoDictTy class_name tys) - = tcClassAssertion (class_name, tys) `thenTc` \ (clas, arg_tys) -> - returnTc (boxedTypeKind, mkDictTy clas arg_tys) +--------------------------- +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 + +--------------------------- +kcHsSigType, kcHsLiftedSigType :: RenamedHsType -> TcM () + -- Used for type signatures +kcHsSigType = kcTypeType +kcHsSigTypes tys = mapTc_ kcHsSigType tys +kcHsLiftedSigType = kcLiftedType + +--------------------------- +kcHsType :: RenamedHsType -> TcM TcKind +kcHsType (HsTyVar name) = kcTyVar name + +kcHsType (HsListTy ty) + = kcLiftedType ty `thenTc` \ tau_ty -> + returnTc liftedTypeKind + +kcHsType (HsTupleTy (HsTupCon _ boxity _) tys) + = mapTc kcTypeType tys `thenTc_` + returnTc (case boxity of + Boxed -> liftedTypeKind + Unboxed -> unliftedTypeKind) + +kcHsType (HsFunTy ty1 ty2) + = kcTypeType ty1 `thenTc_` + kcTypeType ty2 `thenTc_` + returnTc liftedTypeKind + +kcHsType (HsNumTy _) -- The unit type for generics + = returnTc liftedTypeKind + +kcHsType ty@(HsOpTy ty1 op ty2) + = kcTyVar op `thenTc` \ op_kind -> + kcHsType ty1 `thenTc` \ ty1_kind -> + kcHsType ty2 `thenTc` \ ty2_kind -> + tcAddErrCtxt (appKindCtxt (ppr ty)) $ + kcAppKind op_kind ty1_kind `thenTc` \ op_kind' -> + kcAppKind op_kind' ty2_kind + +kcHsType (HsPredTy pred) + = kcHsPred pred `thenTc_` + returnTc liftedTypeKind + +kcHsType ty@(HsAppTy ty1 ty2) + = kcHsType ty1 `thenTc` \ tc_kind -> + kcHsType ty2 `thenTc` \ arg_kind -> + tcAddErrCtxt (appKindCtxt (ppr ty)) $ + kcAppKind tc_kind arg_kind + +kcHsType (HsForAllTy (Just tv_names) context ty) + = kcHsTyVars tv_names `thenNF_Tc` \ kind_env -> + tcExtendKindEnv kind_env $ + kcHsContext context `thenTc_` + kcHsType ty `thenTc_` + returnTc liftedTypeKind + +--------------------------- +kcAppKind fun_kind arg_kind + = case tcSplitFunTy_maybe fun_kind of + Just (arg_kind', res_kind) + -> unifyKind arg_kind arg_kind' `thenTc_` + returnTc res_kind + + Nothing -> newKindVar `thenNF_Tc` \ res_kind -> + unifyKind fun_kind (mkArrowKind arg_kind res_kind) `thenTc_` + returnTc res_kind + + +--------------------------- +kcHsContext ctxt = mapTc_ kcHsPred ctxt + +kcHsPred :: RenamedHsPred -> TcM () +kcHsPred pred@(HsIParam name ty) + = tcAddErrCtxt (appKindCtxt (ppr pred)) $ + kcLiftedType ty + +kcHsPred pred@(HsClassP cls tys) + = tcAddErrCtxt (appKindCtxt (ppr pred)) $ + kcClass cls `thenTc` \ kind -> + mapTc kcHsType tys `thenTc` \ arg_kinds -> + unifyKind kind (mkArrowKinds arg_kinds liftedTypeKind) + + --------------------------- +kcTyVar name -- Could be a tyvar or a tycon + = tcLookup name `thenTc` \ thing -> + case thing of + AThing kind -> returnTc kind + ATyVar tv -> returnTc (tyVarKind tv) + AGlobal (ATyCon tc) -> returnTc (tyConKind tc) + other -> failWithTc (wrongThingErr "type" thing name) + +kcClass cls -- Must be a class + = tcLookup cls `thenNF_Tc` \ thing -> + case thing of + AThing kind -> returnTc kind + AGlobal (AClass cls) -> returnTc (tyConKind (classTyCon cls)) + other -> failWithTc (wrongThingErr "class" thing cls) \end{code} -Help functions for type applications -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\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} -tcTyApp (MonoTyApp ty1 ty2) tys - = tcTyApp ty1 (ty2:tys) +tc_type :: RenamedHsType -> TcM Type + +tc_type ty@(HsTyVar name) + = tc_app ty [] + +tc_type (HsListTy ty) + = tc_type ty `thenTc` \ tau_ty -> + returnTc (mkListTy tau_ty) + +tc_type (HsTupleTy (HsTupCon _ boxity arity) tys) + = ASSERT( tys `lengthIs` arity ) + tc_types tys `thenTc` \ tau_tys -> + returnTc (mkTupleTy boxity arity tau_tys) + +tc_type (HsFunTy ty1 ty2) + = tc_type ty1 `thenTc` \ tau_ty1 -> + tc_type ty2 `thenTc` \ tau_ty2 -> + returnTc (mkFunTy tau_ty1 tau_ty2) + +tc_type (HsNumTy n) + = ASSERT(n== 1) + returnTc (mkTyConApp genUnitTyCon []) -tcTyApp ty tys - | null tys - = tcFunType ty [] +tc_type (HsOpTy ty1 op ty2) + = tc_type ty1 `thenTc` \ tau_ty1 -> + tc_type ty2 `thenTc` \ tau_ty2 -> + tc_fun_type op [tau_ty1,tau_ty2] - | otherwise - = mapAndUnzipTc tc_hs_type_kind tys `thenTc` \ (arg_kinds, arg_tys) -> - tcFunType ty arg_tys `thenTc` \ (fun_kind, result_ty) -> +tc_type (HsAppTy ty1 ty2) = tc_app ty1 [ty2] - -- Check argument compatibility - newKindVar `thenNF_Tc` \ result_kind -> - unifyKind fun_kind (foldr mkArrowKind result_kind arg_kinds) - `thenTc_` - returnTc (result_kind, result_ty) +tc_type (HsPredTy pred) + = tc_pred pred `thenTc` \ pred' -> + returnTc (mkPredTy pred') --- (tcFunType ty arg_tys) returns (kind-of ty, mkAppTys ty arg_tys) +tc_type full_ty@(HsForAllTy (Just tv_names) ctxt ty) + = let + kind_check = kcHsContext ctxt `thenTc_` kcHsType ty + in + tcHsTyVars tv_names kind_check $ \ tyvars -> + mapTc tc_pred ctxt `thenTc` \ theta -> + tc_type ty `thenTc` \ tau -> + returnTc (mkSigmaTy tyvars theta tau) + +tc_types arg_tys = mapTc 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) $ + tc_types tys `thenTc` \ arg_tys -> + case ty of + HsTyVar fun -> tc_fun_type fun arg_tys + other -> tc_type ty `thenTc` \ fun_ty -> + returnNF_Tc (mkAppTys fun_ty arg_tys) + where + pp_app = ppr ty <+> sep (map pprParendHsType 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. -tcFunType (MonoTyVar name) arg_tys - | isTvOcc (getOccName name) -- Must be a type variable - = tcLookupTyVar name `thenNF_Tc` \ (kind,tyvar) -> - returnTc (kind, mkAppTys (mkTyVarTy tyvar) arg_tys) - - | otherwise -- Must be a type constructor - = tcLookupTyCon name `thenTc` \ (tycon_kind,maybe_arity, tycon) -> - case maybe_arity of - Nothing -> -- Data type or newtype - returnTc (tycon_kind, mkTyConApp tycon 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 tycon (take arity arg_tys)) - (drop arity arg_tys) - err_msg = arityErr "Type synonym constructor" name arity n_args - n_args = length arg_tys - -tcFunType ty arg_tys - = tc_hs_type_kind ty `thenTc` \ (fun_kind, fun_ty) -> - returnTc (fun_kind, mkAppTys fun_ty arg_tys) +tc_fun_type name arg_tys + = tcLookup name `thenTc` \ thing -> + case thing of + ATyVar tv -> returnTc (mkAppTys (mkTyVarTy tv) arg_tys) + + AGlobal (ATyCon tc) + | isSynTyCon tc -> returnTc (mkSynTy tc arg_tys) + | otherwise -> returnTc (mkTyConApp tc arg_tys) + + other -> failWithTc (wrongThingErr "type constructor" thing name) \end{code} Contexts ~~~~~~~~ \begin{code} - -tcContext :: RenamedContext -> TcM s ThetaType -tcContext context - = tcAddErrCtxt (thetaCtxt 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 (class_name, _) - = checkTc (not (getUnique class_name `elem` cCallishClassKeys)) - (naughtyCCallContextErr class_name) - -tcClassAssertion (class_name, tys) - = tcLookupClass class_name `thenTc` \ (class_kinds, clas) -> - mapAndUnzipTc tc_hs_type_kind tys `thenTc` \ (ty_kinds, tc_tys) -> - - -- Check with kind mis-match - let - arity = length class_kinds - n_tys = length ty_kinds - err = arityErr "Class" class_name arity n_tys - in - checkTc (arity == n_tys) err `thenTc_` - unifyKinds class_kinds ty_kinds `thenTc_` - - returnTc (clas, tc_tys) +tc_pred assn@(HsClassP class_name tys) + = tcAddErrCtxt (appKindCtxt (ppr assn)) $ + tc_types tys `thenTc` \ arg_tys -> + tcLookupGlobal class_name `thenTc` \ thing -> + case thing of + AClass clas -> returnTc (ClassP clas arg_tys) + other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name) + +tc_pred assn@(HsIParam name ty) + = tcAddErrCtxt (appKindCtxt (ppr assn)) $ + tc_type ty `thenTc` \ arg_ty -> + returnTc (IParam name arg_ty) \end{code} + %************************************************************************ %* * \subsection{Type variables, with knot tying!} @@ -237,36 +500,16 @@ tcClassAssertion (class_name, tys) %************************************************************************ \begin{code} -tcTyVarScope - :: [HsTyVar Name] -- Names of some type variables - -> ([TyVar] -> TcM s a) -- Thing to type check in their scope - -> TcM s a -- Result - -tcTyVarScope tyvar_names thing_inside - = mapAndUnzipNF_Tc tcHsTyVar tyvar_names `thenNF_Tc` \ (names, kinds) -> - - fixTc (\ ~(rec_tyvars, _) -> - -- Ok to look at names, kinds, but not tyvars! - - tcExtendTyVarEnv names (kinds `zipLazy` rec_tyvars) - (thing_inside rec_tyvars) `thenTc` \ result -> - - -- Get the tyvar's Kinds from their TcKinds - mapNF_Tc zonkTcKindToKind kinds `thenNF_Tc` \ kinds' -> - - -- Construct the real TyVars - let - tyvars = zipWithEqual "tcTyVarScope" mkTyVar names kinds' - in - returnTc (tyvars, result) - ) `thenTc` \ (_,result) -> - returnTc result - -tcHsTyVar (UserTyVar name) - = newKindVar `thenNF_Tc` \ tc_kind -> - returnNF_Tc (name, tc_kind) -tcHsTyVar (IfaceTyVar name kind) - = returnNF_Tc (name, kindToTcKind 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 + (tyvars_w_kinds, _) = zipFunTys (hsTyVarNames tyvar_names) kind \end{code} @@ -286,51 +529,49 @@ the variable's type, and after that checked to see whether they've been instantiated. \begin{code} -data TcSigInfo s +data TcSigInfo = TySigInfo Name -- N, the Name in corresponding binding - (TcIdBndr s) -- *Polymorphic* binder for this value... + TcId -- *Polymorphic* binder for this value... -- Has name = N - [TcTyVar s] -- tyvars - (TcThetaType s) -- theta - (TcTauType s) -- tau + [TcTyVar] -- tyvars + TcThetaType -- theta + TcTauType -- tau - (TcIdBndr s) -- *Monomorphic* binder for this value + TcId -- *Monomorphic* binder for this value -- Does *not* have name = N -- Has type tau - (Inst s) -- 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 nm id tyvars theta tau _ inst loc) = + ppr nm <+> ptext SLIT("::") <+> ppr tyvars <+> ppr theta <+> ptext SLIT("=>") <+> ppr tau -maybeSig :: [TcSigInfo s] -> Name -> Maybe (TcSigInfo s) +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 - --- This little helper is useful to pass to tcPat -noSigs :: Name -> Maybe (TcIdBndr s) -noSigs name = Nothing \end{code} \begin{code} -tcTySig :: RenamedSig - -> TcM s (TcSigInfo s) +tcTySig :: RenamedSig -> TcM TcSigInfo tcTySig (Sig v ty src_loc) - = tcAddSrcLoc src_loc $ - tcHsTcType ty `thenTc` \ sigma_tc_ty -> - mkTcSig (mkUserId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig -> + = tcAddSrcLoc src_loc $ + tcHsSigType (FunSigCtxt v) ty `thenTc` \ sigma_tc_ty -> + mkTcSig (mkLocalId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig -> returnTc sig -mkTcSig :: TcIdBndr s -> SrcLoc -> NF_TcM s (TcSigInfo s) +mkTcSig :: TcId -> SrcLoc -> NF_TcM TcSigInfo mkTcSig poly_id src_loc = -- Instantiate this type -- It's important to do this even though in the error-free case @@ -339,19 +580,28 @@ 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 - tcInstTcType (idType poly_id) `thenNF_Tc` \ (tyvars, rho) -> let - (theta, tau) = splitRhoTy rho - -- This splitSigmaTy tries hard to make sure that tau' is a type synonym + (tyvars, rho) = tcSplitForAllTys (idType poly_id) + in + tcInstSigTyVars SigTv 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') = tcSplitRhoTy rho' + -- This splitRhoTy tries hard to make sure that tau' is a type synonym -- wherever possible, which can improve interface files. in newMethodWithGivenTy SignatureOrigin - (TcId poly_id) - (mkTyVarTys tyvars) - theta tau `thenNF_Tc` \ inst -> + poly_id + tyvar_tys' + theta' tau' `thenNF_Tc` \ inst -> -- We make a Method even if it's not overloaded; no harm - returnNF_Tc (TySigInfo name poly_id tyvars theta tau (instToIdBndr inst) inst src_loc) + returnNF_Tc (TySigInfo name poly_id tyvars' theta' tau' (instToId inst) [inst] src_loc) where name = idName poly_id \end{code} @@ -367,15 +617,15 @@ mkTcSig poly_id src_loc @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 + (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 + (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 + (c) Not mentioned in the environment eg the signature for f in this: g x = ... where @@ -384,6 +634,18 @@ are 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 @@ -409,87 +671,198 @@ So we revert to ordinary type variables for signatures, and try to give a helpful message in checkSigTyVars. \begin{code} -checkSigTyVars :: [TcTyVar s] -- The original signature type variables - -> TcM s [TcTyVar s] -- Zonked signature type variables - -checkSigTyVars [] = returnTc [] - -checkSigTyVars sig_tyvars +checkSigTyVars :: [TcTyVar] -- Universally-quantified type variables in the signature + -> TcTyVarSet -- Tyvars that are free in the type signature + -- Not necessarily zonked + -- These should *already* be in the free-in-env set, + -- and are used here only to improve the error message + -> TcM [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) + + checkTcM (allDistinctTyVars sig_tys globals) (complain sig_tys globals) `thenTc_` - returnTc (map (getTyVar "checkSigTyVars") sig_tys) + returnTc (map (tcGetTyVar "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 - = failWithTcM (env2, main_msg) - where - (env1, tidy_tys) = tidyTypes emptyTidyEnv sig_tys - (env2, tidy_tvs) = mapAccumL tidyTyVar env1 sig_tyvars + = -- "check" checks each sig tyvar in turn + foldlNF_Tc check + (env2, emptyVarEnv, []) + (tidy_tvs `zip` tidy_tys) `thenNF_Tc` \ (env3, _, msgs) -> - msgs = check (tidy_tvs `zip` tidy_tys) emptyVarEnv + failWithTcM (env3, main_msg $$ vcat msgs) + where + (env1, tidy_tvs) = tidyOpenTyVars emptyTidyEnv sig_tyvars + (env2, tidy_tys) = tidyOpenTypes env1 sig_tys main_msg = ptext SLIT("Inferred type is less polymorphic than expected") - $$ - nest 4 (vcat msgs) - - check [] acc = [] - check ((sig_tyvar,ty):prs) acc - = case getTyVar_maybe ty of - Nothing -- Error (a)! - -> unify_msg sig_tyvar (ppr ty) : check prs acc - Just tv - | tv `elemVarSet` globals -- Error (c)! Type variable escapes - -> escape_msg tv : check prs acc + check (tidy_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 tcGetTyVar_maybe ty of { + Nothing -> -- Error (a)! + returnNF_Tc (tidy_env, acc, unify_msg sig_tyvar (quotes (ppr ty)) : msgs) ; + + Just tv -> + + case lookupVarEnv acc tv of { + Just sig_tyvar' -> -- Error (b)! + returnNF_Tc (tidy_env, acc, unify_msg sig_tyvar thing : msgs) + where + thing = ptext SLIT("another quantified type variable") <+> quotes (ppr sig_tyvar') + + ; Nothing -> + + if tv `elemVarSet` globals -- Error (c) or (d)! Type variable escapes + -- The least comprehensible, so put it last + -- Game plan: + -- a) get the local TcIds and TyVars from the environment, + -- and pass them to find_globals (they might have tv free) + -- b) similarly, find any free_tyvars that mention tv + then tcGetEnv `thenNF_Tc` \ ve -> + find_globals tv tidy_env (tcLEnvElts ve) `thenNF_Tc` \ (tidy_env1, globs) -> + find_frees tv tidy_env1 [] (varSetElems free_tyvars) `thenNF_Tc` \ (tidy_env2, frees) -> + returnNF_Tc (tidy_env2, acc, escape_msg sig_tyvar tv globs frees : msgs) + + else -- All OK + returnNF_Tc (tidy_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 :: Var + -> TidyEnv + -> [TcTyThing] + -> NF_TcM (TidyEnv, [SDoc]) + +find_globals tv tidy_env things + = go tidy_env [] things + where + go tidy_env acc [] = returnNF_Tc (tidy_env, acc) + go tidy_env acc (thing : things) + = find_thing ignore_it tidy_env thing `thenNF_Tc` \ (tidy_env1, maybe_doc) -> + case maybe_doc of + Just d -> go tidy_env1 (d:acc) things + Nothing -> go tidy_env1 acc things + + ignore_it ty = not (tv `elemVarSet` tyVarsOfType ty) + +----------------------- +find_thing ignore_it tidy_env (ATcId id) + = zonkTcType (idType id) `thenNF_Tc` \ id_ty -> + if ignore_it id_ty then + returnNF_Tc (tidy_env, Nothing) + else let + (tidy_env', tidy_ty) = tidyOpenType tidy_env id_ty + msg = sep [ppr id <+> dcolon <+> ppr tidy_ty, + nest 2 (parens (ptext SLIT("bound at") <+> + ppr (getSrcLoc id)))] + in + returnNF_Tc (tidy_env', Just msg) + +find_thing ignore_it tidy_env (ATyVar tv) + = zonkTcTyVar tv `thenNF_Tc` \ tv_ty -> + if ignore_it tv_ty then + returnNF_Tc (tidy_env, Nothing) + else let + (tidy_env1, tv1) = tidyOpenTyVar tidy_env tv + (tidy_env2, tidy_ty) = tidyOpenType tidy_env1 tv_ty + msg = sep [ptext SLIT("Type variable") <+> quotes (ppr tv1) <+> eq_stuff, nest 2 bound_at] + + eq_stuff | Just tv' <- Type.getTyVar_maybe tv_ty, tv == tv' = empty + | otherwise = equals <+> ppr tv_ty + -- It's ok to use Type.getTyVar_maybe because ty is zonked by now + + bound_at | isMutTyVar tv = mut_info -- The expected case + | otherwise = empty + + mut_info = sep [ptext SLIT("is bound by the") <+> ppr (mutTyVarDetails tv), + ptext SLIT("at") <+> ppr (getSrcLoc tv)] + in + returnNF_Tc (tidy_env2, Just msg) + +----------------------- +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') = tidyOpenTyVar 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:"), + nest 2 (vcat 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") - | otherwise - -> case lookupVarEnv acc tv of - Nothing -- All OK - -> check prs (extendVarEnv acc tv sig_tyvar) -- All OK - Just sig_tyvar' -- Error (b)! - -> unify_msg sig_tyvar (ppr sig_tyvar') : check prs acc + 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 -escape_msg tv = mk_msg tv <+> ptext SLIT("escapes; i.e. unifies with something more global") -unify_msg tv thing = mk_msg tv <+> ptext SLIT("is unified with") <+> quotes thing +unify_msg tv thing = mk_msg tv <+> ptext SLIT("is unified with") <+> thing mk_msg tv = ptext SLIT("Quantified type variable") <+> quotes (ppr tv) \end{code} These two context are used with checkSigTyVars \begin{code} -sigCtxt thing sig_tau tidy_env - = zonkTcType sig_tau `thenNF_Tc` \ zonked_sig_tau -> +sigCtxt :: Message -> [TcTyVar] -> TcThetaType -> TcTauType + -> TidyEnv -> NF_TcM (TidyEnv, Message) +sigCtxt when sig_tyvars sig_theta sig_tau tidy_env + = zonkTcType sig_tau `thenNF_Tc` \ actual_tau -> let - (env1, [tidy_tau, tidy_zonked_tau]) = tidyTypes tidy_env [sig_tau, zonked_sig_tau] - - msg = vcat [ptext SLIT("When checking the type signature for") <+> thing, - nest 4 (ptext SLIT("Signature:") <+> ppr tidy_tau), - nest 4 (ptext SLIT("Inferred: ") <+> ppr tidy_zonked_tau)] + (env1, tidy_sig_tyvars) = tidyOpenTyVars 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 + ] in - returnNF_Tc (env1, msg) + returnNF_Tc (env3, msg) -existentialPatCtxt bound_tvs bound_ids tidy_env +sigPatCtxt bound_tvs bound_ids tidy_env = returnNF_Tc (env1, - sep [ptext SLIT("When checking an existential pattern that binds"), + sep [ptext SLIT("When checking a pattern that binds"), nest 4 (vcat (zipWith ppr_id show_ids tidy_tys))]) where - tv_list = bagToList bound_tvs - show_ids = filter is_interesting (map snd (bagToList bound_ids)) - is_interesting id = any (`elemVarSet` idFreeTyVars id) tv_list + show_ids = filter is_interesting bound_ids + is_interesting id = any (`elemVarSet` idFreeTyVars id) bound_tvs - (env1, tidy_tys) = tidyTypes tidy_env (map idType show_ids) - ppr_id id ty = ppr id <+> ptext SLIT("::") <+> ppr ty + (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 \end{code} @@ -501,10 +874,21 @@ existentialPatCtxt 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")] +typeKindCtxt :: RenamedHsType -> Message +typeKindCtxt ty = sep [ptext SLIT("When checking that"), + nest 2 (quotes (ppr ty)), + ptext SLIT("is a type")] -typeCtxt ty = ptext SLIT("In the type") <+> quotes (ppr ty) +appKindCtxt :: SDoc -> Message +appKindCtxt pp = ptext SLIT("When checking kinds in") <+> quotes pp -thetaCtxt theta = ptext SLIT("In the context") <+> quotes (pprContext theta) +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 (ATyVar _) = ptext SLIT("Type variable") + pp_thing (ATcId _) = ptext SLIT("Local identifier") + pp_thing (AThing _) = ptext SLIT("Utterly bogus") \end{code}