X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcMonoType.lhs;h=ca4629a164df4070b597ff4b02b4c8975414f182;hb=6aa013b48b9a85b643672be56f89f0bd0108db1f;hp=41838df8ce704d2d086e5a630dea36c4cfd3b212;hpb=ecd5cb36ad575939b04f40d1b3a7255741f294a2;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcMonoType.lhs b/ghc/compiler/typecheck/TcMonoType.lhs index 41838df..ca4629a 100644 --- a/ghc/compiler/typecheck/TcMonoType.lhs +++ b/ghc/compiler/typecheck/TcMonoType.lhs @@ -4,13 +4,14 @@ \section[TcMonoType]{Typechecking user-specified @MonoTypes@} \begin{code} -module TcMonoType ( tcHsType, tcHsSigType, tcHsBoxedSigType, - tcContext, tcClassContext, +module TcMonoType ( tcHsSigType, tcHsType, tcIfaceType, tcHsTheta, + UserTypeCtxt(..), -- Kind checking kcHsTyVar, kcHsTyVars, mkTyClTyVars, - kcHsType, kcHsSigType, kcHsBoxedSigType, kcHsContext, - tcTyVars, tcHsTyVars, mkImmutTyVars, + kcHsType, kcHsSigType, kcHsSigTypes, + kcHsLiftedSigType, kcHsContext, + tcAddScopedTyVars, tcHsTyVars, mkImmutTyVars, TcSigInfo(..), tcTySig, mkTcSig, maybeSig, checkSigTyVars, sigCtxt, sigPatCtxt @@ -18,54 +19,110 @@ module TcMonoType ( tcHsType, tcHsSigType, tcHsBoxedSigType, #include "HsVersions.h" -import HsSyn ( HsType(..), HsTyVarBndr(..), HsUsageAnn(..), +import HsSyn ( HsType(..), HsTyVarBndr(..), Sig(..), HsPred(..), pprParendHsType, HsTupCon(..), hsTyVarNames ) -import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig ) +import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig, extractHsTyVars ) import TcHsSyn ( TcId ) import TcMonad -import TcEnv ( tcExtendTyVarEnv, tcExtendKindEnv, - --tcLookup, tcLookupGlobal, - tcEnvTcIds, tcEnvTyVars, - tcGetGlobalTyVars, - TyThing(..), TcTyThing(..) +import TcEnv ( tcExtendTyVarEnv, tcLookup, tcLookupGlobal, + tcGetGlobalTyVars, tcLEnvElts, tcInLocalScope, + TyThing(..), TcTyThing(..), tcExtendKindEnv ) -import TcType ( TcType, TcKind, TcTyVar, TcThetaType, TcTauType, - newKindVar, tcInstSigVar, - zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar +import TcMType ( newKindVar, tcInstSigTyVars, + zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar, + unifyKind, unifyOpenTypeKind, + checkValidType, UserTypeCtxt(..), pprUserTypeCtxt ) -import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToIdBndr, - instFunDeps, instFunDepsOfTheta ) -import FunDeps ( tyVarFunDep, oclose ) -import TcUnify ( unifyKind, unifyOpenTypeKind ) -import Type ( Type, Kind, PredType(..), ThetaType, UsageAnn(..), - mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, mkUsgTy, - mkUsForAllTy, zipFunTys, hoistForAllTys, - mkSigmaTy, mkPredTy, mkTyConApp, - mkAppTys, splitForAllTys, splitRhoTy, mkRhoTy, - boxedTypeKind, unboxedTypeKind, mkArrowKind, - mkArrowKinds, getTyVar_maybe, getTyVar, splitFunTy_maybe, - tidyOpenType, tidyOpenTypes, tidyTyVar, tidyTyVars, - tyVarsOfType, tyVarsOfPred, mkForAllTys, - classesOfPreds, isUnboxedTupleType +import TcType ( Type, Kind, SourceType(..), ThetaType, TyVarDetails(..), + TcTyVar, TcTyVarSet, TcType, TcKind, TcThetaType, TcTauType, + mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, + 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 PprType ( pprType, pprPred ) +import qualified Type ( getTyVar_maybe ) + +import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToId ) +import PprType ( pprType ) import Subst ( mkTopTyVarSubst, substTy ) -import Id ( mkVanillaId, idName, idType, idFreeTyVars ) -import Var ( TyVar, mkTyVar, tyVarKind ) +import CoreFVs ( idFreeTyVars ) +import Id ( mkLocalId, idName, idType ) +import Var ( Id, Var, TyVar, mkTyVar, tyVarKind, isMutTyVar, mutTyVarDetails ) import VarEnv import VarSet import ErrUtils ( Message ) -import TyCon ( TyCon, isSynTyCon, tyConArity, tyConKind, tyConName ) -import Class ( ClassContext, classArity, classTyCon ) -import Name ( Name, isLocallyDefined ) +import TyCon ( TyCon, isSynTyCon, tyConArity, tyConKind ) +import Class ( classTyCon ) +import Name ( Name, getSrcLoc ) +import NameSet import TysWiredIn ( mkListTy, mkTupleTy, genUnitTyCon ) -import UniqFM ( elemUFM ) import BasicTypes ( Boxity(..) ) import SrcLoc ( SrcLoc ) -import Util ( mapAccumL, isSingleton ) +import Util ( isSingleton, lengthIs ) import Outputable -import HscTypes ( TyThing(..) ) + +\end{code} + + +%************************************************************************ +%* * +\subsection{Checking types} +%* * +%************************************************************************ + +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 = 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} @@ -118,6 +175,10 @@ 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) @@ -135,16 +196,42 @@ tcHsTyVars tv_names kind_check thing_inside in tcExtendTyVarEnv tyvars (thing_inside tyvars) -tcTyVars :: [Name] - -> TcM a -- The kind checker - -> TcM [TyVar] -tcTyVars [] kind_check = returnTc [] -tcTyVars tv_names kind_check - = mapNF_Tc newNamedKindVar tv_names `thenTc` \ kind_env -> - tcExtendKindEnv kind_env kind_check `thenTc_` - zonkKindEnv kind_env `thenNF_Tc` \ tvs_w_kinds -> - listNF_Tc [tcNewSigTyVar name kind | (name,kind) <- tvs_w_kinds] + +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} @@ -161,50 +248,49 @@ newNamedKindVar name = newKindVar `thenNF_Tc` \ kind -> returnNF_Tc (name, kind) --------------------------- -kcBoxedType :: RenamedHsType -> TcM () - -- The type ty must be a *boxed* *type* -kcBoxedType ty +kcLiftedType :: RenamedHsType -> TcM () + -- The type ty must be a *lifted* *type* +kcLiftedType ty = kcHsType ty `thenTc` \ kind -> tcAddErrCtxt (typeKindCtxt ty) $ - unifyKind boxedTypeKind kind + unifyKind liftedTypeKind kind --------------------------- kcTypeType :: RenamedHsType -> TcM () - -- The type ty must be a *type*, but it can be boxed or unboxed. + -- 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, kcHsBoxedSigType :: RenamedHsType -> TcM () +kcHsSigType, kcHsLiftedSigType :: RenamedHsType -> TcM () -- Used for type signatures -kcHsSigType = kcTypeType -kcHsBoxedSigType = kcBoxedType +kcHsSigType = kcTypeType +kcHsSigTypes tys = mapTc_ kcHsSigType tys +kcHsLiftedSigType = kcLiftedType --------------------------- kcHsType :: RenamedHsType -> TcM TcKind kcHsType (HsTyVar name) = kcTyVar name -kcHsType (HsUsgTy _ ty) = kcHsType ty -kcHsType (HsUsgForAllTy _ ty) = kcHsType ty kcHsType (HsListTy ty) - = kcBoxedType ty `thenTc` \ tau_ty -> - returnTc boxedTypeKind - -kcHsType (HsTupleTy (HsTupCon _ Boxed) tys) - = mapTc kcBoxedType tys `thenTc_` - returnTc boxedTypeKind + = kcLiftedType ty `thenTc` \ tau_ty -> + returnTc liftedTypeKind -kcHsType ty@(HsTupleTy (HsTupCon _ Unboxed) tys) - = failWithTc (unboxedTupleErr ty) - -- Unboxed tuples are illegal everywhere except - -- just after a function arrow (see kcFunResType) +kcHsType (HsTupleTy (HsTupCon _ boxity _) tys) + = mapTc kcTypeType tys `thenTc_` + returnTc (case boxity of + Boxed -> liftedTypeKind + Unboxed -> unliftedTypeKind) kcHsType (HsFunTy ty1 ty2) = kcTypeType ty1 `thenTc_` - kcFunResType ty2 `thenTc_` - returnTc boxedTypeKind + 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 -> @@ -216,7 +302,7 @@ kcHsType ty@(HsOpTy ty1 op ty2) kcHsType (HsPredTy pred) = kcHsPred pred `thenTc_` - returnTc boxedTypeKind + returnTc liftedTypeKind kcHsType ty@(HsAppTy ty1 ty2) = kcHsType ty1 `thenTc` \ tc_kind -> @@ -228,31 +314,12 @@ kcHsType (HsForAllTy (Just tv_names) context ty) = kcHsTyVars tv_names `thenNF_Tc` \ kind_env -> tcExtendKindEnv kind_env $ kcHsContext context `thenTc_` - - -- 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 - if null context then - kcHsType ty - else - kcFunResType ty `thenTc_` - returnTc boxedTypeKind - ---------------------------- -kcFunResType :: RenamedHsType -> TcM TcKind --- The only place an unboxed tuple type is allowed --- is at the right hand end of an arrow -kcFunResType (HsTupleTy (HsTupCon _ Unboxed) tys) - = mapTc kcTypeType tys `thenTc_` - returnTc unboxedTypeKind - -kcFunResType ty = kcHsType ty + kcHsType ty `thenTc_` + returnTc liftedTypeKind --------------------------- kcAppKind fun_kind arg_kind - = case splitFunTy_maybe fun_kind of + = case tcSplitFunTy_maybe fun_kind of Just (arg_kind', res_kind) -> unifyKind arg_kind arg_kind' `thenTc_` returnTc res_kind @@ -266,17 +333,17 @@ kcAppKind fun_kind arg_kind kcHsContext ctxt = mapTc_ kcHsPred ctxt kcHsPred :: RenamedHsPred -> TcM () -kcHsPred pred@(HsPIParam name ty) +kcHsPred pred@(HsIParam name ty) = tcAddErrCtxt (appKindCtxt (ppr pred)) $ - kcBoxedType ty + kcLiftedType ty -kcHsPred pred@(HsPClass cls tys) +kcHsPred pred@(HsClassP cls tys) = tcAddErrCtxt (appKindCtxt (ppr pred)) $ kcClass cls `thenTc` \ kind -> mapTc kcHsType tys `thenTc` \ arg_kinds -> - unifyKind kind (mkArrowKinds arg_kinds boxedTypeKind) + unifyKind kind (mkArrowKinds arg_kinds liftedTypeKind) ---------------------------- + --------------------------- kcTyVar name -- Could be a tyvar or a tycon = tcLookup name `thenTc` \ thing -> case thing of @@ -295,141 +362,81 @@ kcClass cls -- Must be a class %************************************************************************ %* * -\subsection{Checking types} +\subsection{tc_type} %* * %************************************************************************ -tcHsSigType and tcHsBoxedSigType -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +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. + data T a = MkT a [T a] - * They are only called when there are no kind vars in the environment - so the kind returned is indeed a Kind not a TcKind +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! -\begin{code} -tcHsSigType :: RenamedHsType -> TcM TcType -tcHsSigType ty - = kcTypeType ty `thenTc_` - tcHsType ty `thenTc` \ ty' -> - returnTc (hoistForAllTys ty') - -tcHsBoxedSigType :: RenamedHsType -> TcM Type -tcHsBoxedSigType ty - = kcBoxedType ty `thenTc_` - tcHsType ty `thenTc` \ ty' -> - returnTc (hoistForAllTys ty') -\end{code} +So tc_type does no validity-checking. Instead that's all done +by TcMType.checkValidType + -------------------------- + *** END OF BIG WARNING *** + -------------------------- -tcHsType, the main work horse -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -tcHsType :: RenamedHsType -> TcM 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 -> +tc_type (HsListTy ty) + = tc_type ty `thenTc` \ tau_ty -> returnTc (mkListTy tau_ty) -tcHsType (HsTupleTy (HsTupCon _ boxity) tys) - = mapTc tcHsType tys `thenTc` \ tau_tys -> - returnTc (mkTupleTy boxity (length tys) tau_tys) +tc_type (HsTupleTy (HsTupCon _ boxity arity) tys) + = ASSERT( tys `lengthIs` arity ) + tc_types tys `thenTc` \ tau_tys -> + returnTc (mkTupleTy boxity arity tau_tys) -tcHsType (HsFunTy ty1 ty2) - = tcHsType ty1 `thenTc` \ tau_ty1 -> - tcHsType ty2 `thenTc` \ tau_ty2 -> +tc_type (HsFunTy ty1 ty2) + = tc_type ty1 `thenTc` \ tau_ty1 -> + tc_type ty2 `thenTc` \ tau_ty2 -> returnTc (mkFunTy tau_ty1 tau_ty2) -tcHsType (HsNumTy n) +tc_type (HsNumTy n) = ASSERT(n== 1) returnTc (mkTyConApp genUnitTyCon []) -tcHsType (HsOpTy ty1 op ty2) = - tcHsType ty1 `thenTc` \ tau_ty1 -> - tcHsType ty2 `thenTc` \ tau_ty2 -> - tc_fun_type op [tau_ty1,tau_ty2] +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] -tcHsType (HsAppTy ty1 ty2) - = tc_app ty1 [ty2] +tc_type (HsAppTy ty1 ty2) = tc_app ty1 [ty2] -tcHsType (HsPredTy pred) - = tcClassAssertion True pred `thenTc` \ pred' -> +tc_type (HsPredTy pred) + = tc_pred pred `thenTc` \ pred' -> returnTc (mkPredTy pred') -tcHsType full_ty@(HsForAllTy (Just tv_names) ctxt ty) +tc_type full_ty@(HsForAllTy (Just tv_names) ctxt ty) = let - kind_check = kcHsContext ctxt `thenTc_` kcFunResType ty + kind_check = kcHsContext ctxt `thenTc_` kcHsType ty in - tcHsTyVars tv_names kind_check $ \ tyvars -> - tcContext ctxt `thenTc` \ theta -> - tcHsType ty `thenTc` \ tau -> - checkAmbiguity full_ty tyvars theta tau `thenTc_` + tcHsTyVars tv_names kind_check $ \ tyvars -> + mapTc tc_pred ctxt `thenTc` \ theta -> + tc_type ty `thenTc` \ tau -> returnTc (mkSigmaTy tyvars theta tau) - -- 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. - -checkAmbiguity full_ty forall_tyvars theta tau - = mapTc check_pred theta - where - 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) - all_free = all is_free ct_vars - any_ambig = is_source_polytype && any is_ambig ct_vars - - -- Notes on the 'is_source_polytype' test above - -- 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 full_ty of - HsForAllTy (Just (UserTyVar _ : _)) _ _ -> True - other -> False +tc_types arg_tys = mapTc tc_type arg_tys \end{code} Help functions for type applications @@ -442,10 +449,10 @@ tc_app (HsAppTy ty1 ty2) tys tc_app ty tys = tcAddErrCtxt (appKindCtxt pp_app) $ - mapTc tcHsType tys `thenTc` \ arg_tys -> + tc_types tys `thenTc` \ arg_tys -> case ty of HsTyVar fun -> tc_fun_type fun arg_tys - other -> tcHsType ty `thenTc` \ fun_ty -> + other -> tc_type ty `thenTc` \ fun_ty -> returnNF_Tc (mkAppTys fun_ty arg_tys) where pp_app = ppr ty <+> sep (map pprParendHsType tys) @@ -460,21 +467,8 @@ tc_fun_type name arg_tys ATyVar tv -> returnTc (mkAppTys (mkTyVarTy tv) arg_tys) AGlobal (ATyCon tc) - | isSynTyCon tc -> checkTc arity_ok err_msg `thenTc_` - returnTc (mkAppTys (mkSynTy tc (take arity arg_tys)) - (drop arity arg_tys)) - + | isSynTyCon tc -> returnTc (mkSynTy tc arg_tys) | otherwise -> returnTc (mkTyConApp tc arg_tys) - where - - 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 other -> failWithTc (wrongThingErr "type constructor" thing name) \end{code} @@ -483,36 +477,22 @@ tc_fun_type name arg_tys Contexts ~~~~~~~~ \begin{code} -tcClassContext :: RenamedContext -> TcM 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 ThetaType -tcContext context = mapTc (tcClassAssertion False) context - -tcClassAssertion ccall_ok assn@(HsPClass class_name tys) +tc_pred assn@(HsClassP class_name tys) = tcAddErrCtxt (appKindCtxt (ppr assn)) $ - mapTc tcHsType tys `thenTc` \ arg_tys -> + tc_types tys `thenTc` \ arg_tys -> tcLookupGlobal class_name `thenTc` \ 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 + AClass clas -> returnTc (ClassP clas arg_tys) + other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name) - other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name) - -tcClassAssertion ccall_ok assn@(HsPIParam name ty) +tc_pred assn@(HsIParam name ty) = tcAddErrCtxt (appKindCtxt (ppr assn)) $ - tcHsType ty `thenTc` \ arg_ty -> + tc_type ty `thenTc` \ arg_ty -> returnTc (IParam name arg_ty) \end{code} + %************************************************************************ %* * \subsection{Type variables, with knot tying!} @@ -587,9 +567,8 @@ 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 -> + tcHsSigType (FunSigCtxt v) ty `thenTc` \ sigma_tc_ty -> + mkTcSig (mkLocalId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig -> returnTc sig mkTcSig :: TcId -> SrcLoc -> NF_TcM TcSigInfo @@ -602,16 +581,17 @@ mkTcSig poly_id src_loc -- 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) + (tyvars, rho) = tcSplitForAllTys (idType poly_id) in - mapNF_Tc tcInstSigVar tyvars `thenNF_Tc` \ tyvars' -> + 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') = splitRhoTy rho' + + (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 @@ -620,9 +600,8 @@ mkTcSig poly_id src_loc tyvar_tys' theta' tau' `thenNF_Tc` \ inst -> -- We make a Method even if it's not overloaded; no harm - instFunDeps SignatureOrigin theta' `thenNF_Tc` \ fds -> - returnNF_Tc (TySigInfo name poly_id tyvars' theta' tau' (instToIdBndr inst) (inst : fds) src_loc) + returnNF_Tc (TySigInfo name poly_id tyvars' theta' tau' (instToId inst) [inst] src_loc) where name = idName poly_id \end{code} @@ -694,117 +673,134 @@ 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 [TcTyVar] -- Zonked signature type variables + -- 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 - = -- 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 - tcGetEnv `thenNF_Tc` \ env -> - let - in_scope_tvs = tcEnvTyVars env - in - 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 + = -- "check" checks each sig tyvar in turn foldlNF_Tc check - (env2, in_scope_env, []) + (env2, emptyVarEnv, []) (tidy_tvs `zip` tidy_tys) `thenNF_Tc` \ (env3, _, msgs) -> - failWithTcM (env3, main_msg $$ nest 4 (vcat msgs)) + failWithTcM (env3, main_msg $$ vcat msgs) where - (env1, tidy_tvs) = mapAccumL tidyTyVar emptyTidyEnv sig_tyvars - (env2, tidy_tys) = tidyOpenTypes env1 sig_tys + (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") - check (env, acc, msgs) (sig_tyvar,ty) + 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 getTyVar_maybe ty of { + = case tcGetTyVar_maybe ty of { Nothing -> -- Error (a)! - returnNF_Tc (env, acc, unify_msg sig_tyvar (ppr ty) : msgs) ; + 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) or (d)! - returnNF_Tc (env, acc, unify_msg sig_tyvar (ppr sig_tyvar') : msgs) ; + 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 -> + ; Nothing -> - if tv `elemVarSet` globals -- Error (c)! Type variable escapes + if tv `elemVarSet` globals -- Error (c) or (d)! Type variable escapes -- The least comprehensible, so put it last - then tcGetEnv `thenNF_Tc` \ env -> - find_globals tv env [] (tcEnvTcIds) `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) + -- 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 (env, extendVarEnv acc tv sig_tyvar, msgs) + 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 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_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') = tidyTyVar tidy_env ftv + (tidy_env', ftv') = tidyOpenTyVar tidy_env ftv in find_frees tv tidy_env' (ftv':acc) ftvs else @@ -814,10 +810,8 @@ find_frees tv tidy_env acc (ftv: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]) - ] + 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")) @@ -836,7 +830,8 @@ escape_msg sig_tv tv globs frees 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 + +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} @@ -848,7 +843,7 @@ sigCtxt :: Message -> [TcTyVar] -> TcThetaType -> TcTauType 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 + (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), @@ -879,8 +874,6 @@ sigPatCtxt bound_tvs bound_ids tidy_env %************************************************************************ \begin{code} -tcsigCtxt v = ptext SLIT("In a type signature for") <+> quotes (ppr v) - typeKindCtxt :: RenamedHsType -> Message typeKindCtxt ty = sep [ptext SLIT("When checking that"), nest 2 (quotes (ppr ty)), @@ -898,18 +891,4 @@ wrongThingErr expected thing name pp_thing (ATyVar _) = ptext SLIT("Type variable") pp_thing (ATcId _) = ptext SLIT("Local identifier") pp_thing (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)) - ] - -unboxedTupleErr ty - = sep [ptext (SLIT("Illegal unboxed tuple as a function or contructor argument:")), nest 4 (ppr ty)] \end{code}