X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcMonoType.lhs;h=93083908da7b118bcbc36b155112ca205a0fc874;hb=0f7c4b885e64428f50e9fa943ecd42d3c5f39c35;hp=17189bd9f4ee60357ff9ae6edd9ed6f3be0facd1;hpb=71352675a2133713c0a3e7c8b826060bf3085130;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcMonoType.lhs b/ghc/compiler/typecheck/TcMonoType.lhs index 17189bd..9308390 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 ( tcHsType, tcHsRecType, tcIfaceType, + tcHsSigType, tcHsLiftedSigType, + tcRecTheta, checkAmbiguity, -- Kind checking kcHsTyVar, kcHsTyVars, mkTyClTyVars, - kcHsType, kcHsSigType, kcHsBoxedSigType, kcHsContext, - kcTyVarScope, newSigTyVars, mkImmutTyVars, + kcHsType, kcHsSigType, kcHsLiftedSigType, kcHsContext, + tcTyVars, tcHsTyVars, mkImmutTyVars, TcSigInfo(..), tcTySig, mkTcSig, maybeSig, checkSigTyVars, sigCtxt, sigPatCtxt @@ -18,52 +19,52 @@ 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 TcHsSyn ( TcId ) import TcMonad -import TcEnv ( tcExtendTyVarEnv, tcLookupTy, tcGetValueEnv, tcGetInScopeTyVars, - tcExtendUVarEnv, tcLookupUVar, - tcGetGlobalTyVars, valueEnvIds, - TyThing(..), tyThingKind, tcExtendKindEnv +import TcEnv ( tcExtendTyVarEnv, tcLookup, tcLookupGlobal, + tcGetGlobalTyVars, tcEnvTcIds, tcEnvTyVars, + TyThing(..), TcTyThing(..), tcExtendKindEnv ) -import TcType ( TcType, TcKind, TcTyVar, TcThetaType, TcTauType, +import TcType ( TcKind, TcTyVar, TcThetaType, TcTauType, newKindVar, tcInstSigVar, zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar ) -import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToIdBndr, - instFunDeps, instFunDepsOfTheta ) -import FunDeps ( tyVarFunDep, oclose ) -import TcUnify ( unifyKind, unifyKinds, unifyOpenTypeKind ) -import Type ( Type, Kind, PredType(..), ThetaType, UsageAnn(..), - mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, mkUsgTy, - mkUsForAllTy, zipFunTys, hoistForAllTys, - mkSigmaTy, mkDictTy, mkPredTy, mkTyConApp, +import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToId ) +import FunDeps ( grow ) +import TcUnify ( unifyKind, unifyOpenTypeKind ) +import Unify ( allDistinctTyVars ) +import Type ( Type, Kind, PredType(..), ThetaType, SigmaType, TauType, + mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, + zipFunTys, hoistForAllTys, + mkSigmaTy, mkPredTy, mkTyConApp, mkAppTys, splitForAllTys, splitRhoTy, mkRhoTy, - boxedTypeKind, unboxedTypeKind, mkArrowKind, + liftedTypeKind, unliftedTypeKind, mkArrowKind, mkArrowKinds, getTyVar_maybe, getTyVar, splitFunTy_maybe, tidyOpenType, tidyOpenTypes, tidyTyVar, tidyTyVars, - tyVarsOfType, tyVarsOfTypes, tyVarsOfPred, mkForAllTys, - classesOfPreds + tyVarsOfType, tyVarsOfPred, mkForAllTys, + isUnboxedTupleType, isForAllTy, isIPPred ) -import PprType ( pprConstraint, pprType, pprPred ) +import PprType ( pprType, pprTheta, pprPred ) import Subst ( mkTopTyVarSubst, substTy ) -import Id ( mkVanillaId, idName, idType, idFreeTyVars ) -import Var ( TyVar, mkTyVar, tyVarKind, mkNamedUVar, varName ) +import CoreFVs ( idFreeTyVars ) +import Id ( mkLocalId, idName, idType ) +import Var ( Id, Var, TyVar, mkTyVar, tyVarKind ) import VarEnv import VarSet import ErrUtils ( Message ) import TyCon ( TyCon, isSynTyCon, tyConArity, tyConKind ) -import Class ( ClassContext, classArity, classTyCon ) -import Name ( Name, OccName, isLocallyDefined ) -import TysWiredIn ( mkListTy, mkTupleTy ) -import UniqFM ( elemUFM, foldUFM ) -import BasicTypes ( Boxity(..) ) +import Class ( classArity, classTyCon ) +import Name ( Name ) +import TysWiredIn ( mkListTy, mkTupleTy, genUnitTyCon ) +import BasicTypes ( Boxity(..), RecFlag(..), isRec ) import SrcLoc ( SrcLoc ) -import Util ( mapAccumL, isSingleton, removeDups ) +import Util ( mapAccumL, isSingleton ) import Outputable + \end{code} @@ -90,7 +91,7 @@ To do step 1, we proceed thus: 1b. Apply the kind checker 1c. Zonk the resulting kinds -The kind checker is passed to kcTyVarScope as an argument. +The kind checker is passed to tcHsTyVars as an argument. For example, when we find (forall a m. m a -> m a) @@ -98,7 +99,7 @@ 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 kcTyVarScope needs to look at enough to +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 @@ -116,138 +117,155 @@ But equally valid would be a::(*->*)-> *, b::*->* \begin{code} -kcTyVarScope :: [HsTyVarBndr Name] - -> TcM s a -- The kind checker - -> TcM s [(Name,Kind)] - -- Do a kind check to find out the kinds of the type variables - -- Then return a bunch of name-kind pairs, from which to - -- construct the type variables. We don't return the tyvars - -- themselves because sometimes we want mutable ones and - -- sometimes we want immutable ones. - -kcTyVarScope [] kind_check = returnTc [] +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! -kcTyVarScope tv_names kind_check +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 + zonkKindEnv tv_names_w_kinds `thenNF_Tc` \ tvs_w_kinds -> + let + tyvars = mkImmutTyVars tvs_w_kinds + 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] \end{code} \begin{code} -kcHsTyVar :: HsTyVarBndr name -> NF_TcM s (name, TcKind) -kcHsTyVars :: [HsTyVarBndr name] -> NF_TcM s [(name, TcKind)] +kcHsTyVar :: HsTyVarBndr name -> NF_TcM (name, TcKind) +kcHsTyVars :: [HsTyVarBndr name] -> NF_TcM [(name, TcKind)] -kcHsTyVar (UserTyVar name) = newKindVar `thenNF_Tc` \ kind -> - returnNF_Tc (name, kind) +kcHsTyVar (UserTyVar name) = newNamedKindVar name kcHsTyVar (IfaceTyVar name kind) = returnNF_Tc (name, kind) kcHsTyVars tvs = mapNF_Tc kcHsTyVar tvs +newNamedKindVar name = newKindVar `thenNF_Tc` \ kind -> + returnNF_Tc (name, kind) + --------------------------- -kcBoxedType :: RenamedHsType -> TcM s () - -- 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 s () - -- The type ty must be a *type*, but it can be boxed or unboxed. +kcTypeType :: RenamedHsType -> TcM () + -- The type ty must be a *type*, but it can be lifted or unlifted. kcTypeType ty = kcHsType ty `thenTc` \ kind -> tcAddErrCtxt (typeKindCtxt ty) $ unifyOpenTypeKind kind --------------------------- -kcHsSigType, kcHsBoxedSigType :: RenamedHsType -> TcM s () +kcHsSigType, kcHsLiftedSigType :: RenamedHsType -> TcM () -- Used for type signatures kcHsSigType = kcTypeType -kcHsBoxedSigType = kcBoxedType +kcHsLiftedSigType = kcLiftedType --------------------------- -kcHsType :: RenamedHsType -> TcM s TcKind -kcHsType (HsTyVar name) - = tcLookupTy name `thenTc` \ thing -> - case thing of - ATyVar tv -> returnTc (tyVarKind tv) - ATyCon tc -> returnTc (tyConKind tc) - AThing k -> returnTc k - other -> failWithTc (wrongThingErr "type" thing name) - -kcHsType (HsUsgTy _ ty) = kcHsType ty -kcHsType (HsUsgForAllTy _ ty) = kcHsType ty +kcHsType :: RenamedHsType -> TcM TcKind +kcHsType (HsTyVar name) = kcTyVar name kcHsType (HsListTy ty) - = kcBoxedType ty `thenTc` \ tau_ty -> - returnTc boxedTypeKind + = kcLiftedType ty `thenTc` \ tau_ty -> + returnTc liftedTypeKind -kcHsType (HsTupleTy (HsTupCon _ Boxed) tys) - = mapTc kcBoxedType tys `thenTc_` - returnTc boxedTypeKind - -kcHsType (HsTupleTy (HsTupCon _ Unboxed) tys) - = mapTc kcTypeType tys `thenTc_` - returnTc unboxedTypeKind +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 boxedTypeKind + 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 boxedTypeKind + returnTc liftedTypeKind kcHsType ty@(HsAppTy ty1 ty2) - = kcHsType ty1 `thenTc` \ tc_kind -> - kcHsType ty2 `thenTc` \ arg_kind -> - + = kcHsType ty1 `thenTc` \ tc_kind -> + kcHsType ty2 `thenTc` \ arg_kind -> tcAddErrCtxt (appKindCtxt (ppr ty)) $ - case splitFunTy_maybe tc_kind of + 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 splitFunTy_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 tc_kind (mkArrowKind arg_kind res_kind) `thenTc_` + unifyKind fun_kind (mkArrowKind arg_kind res_kind) `thenTc_` returnTc res_kind -kcHsType (HsForAllTy (Just tv_names) context ty) - = kcHsTyVars tv_names `thenNF_Tc` \ kind_env -> - tcExtendKindEnv kind_env $ - kcHsContext context `thenTc_` - kcHsType ty `thenTc` \ kind -> - - -- Context behaves like a function type - -- This matters. Return-unboxed-tuple analysis can - -- give overloaded functions like - -- f :: forall a. Num a => (# a->a, a->a #) - -- And we want these to get through the type checker - returnTc (if null context then - kind - else - boxedTypeKind) --------------------------- kcHsContext ctxt = mapTc_ kcHsPred ctxt -kcHsPred :: RenamedHsPred -> TcM s () -kcHsPred pred@(HsPIParam name ty) +kcHsPred :: RenamedHsPred -> TcM () +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)) $ - tcLookupTy cls `thenNF_Tc` \ thing -> - (case thing of - AClass cls -> returnTc (tyConKind (classTyCon cls)) - AThing kind -> returnTc kind - other -> failWithTc (wrongThingErr "class" thing cls)) `thenTc` \ kind -> - mapTc kcHsType tys `thenTc` \ arg_kinds -> - unifyKind kind (mkArrowKinds arg_kinds boxedTypeKind) + 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} %************************************************************************ @@ -256,156 +274,188 @@ kcHsPred pred@(HsPClass cls tys) %* * %************************************************************************ -tcHsType and tcHsTypeKind -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +tcHsSigType and tcHsLiftedSigType +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -tcHsSigType and tcHsBoxedSigType are used for type signatures written by the programmer +tcHsSigType and tcHsLiftedSigType are used for type signatures written by the programmer * We hoist any inner for-alls to the top * Notice that we kind-check first, because the type-check assumes that the kinds are already checked. + * They are only called when there are no kind vars in the environment so the kind returned is indeed a Kind not a TcKind \begin{code} -tcHsSigType :: RenamedHsType -> TcM s TcType -tcHsSigType ty - = kcTypeType ty `thenTc_` - tcHsType ty `thenTc` \ ty' -> - returnTc (hoistForAllTys ty') - -tcHsBoxedSigType :: RenamedHsType -> TcM s Type -tcHsBoxedSigType ty - = kcBoxedType ty `thenTc_` - tcHsType ty `thenTc` \ ty' -> - returnTc (hoistForAllTys ty') +tcHsSigType, tcHsLiftedSigType :: RenamedHsType -> TcM Type + -- Do kind checking, and hoist for-alls to the top +tcHsSigType ty = kcTypeType ty `thenTc_` tcHsType ty +tcHsLiftedSigType ty = kcLiftedType ty `thenTc_` tcHsType ty + +tcHsType :: RenamedHsType -> TcM Type +tcHsRecType :: RecFlag -> RenamedHsType -> TcM Type + -- Don't do kind checking, but do hoist for-alls to the top + -- These are used in type and class decls, where kinding is + -- done in advance +tcHsType ty = tc_type NonRecursive ty `thenTc` \ ty' -> returnTc (hoistForAllTys ty') +tcHsRecType wimp_out ty = tc_type wimp_out ty `thenTc` \ ty' -> returnTc (hoistForAllTys ty') + +-- 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 NonRecursive ty \end{code} -The main work horse -~~~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\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! + +The wimp_out argument tells when we are in a mutually-recursive +group of type declarations, so omit various checks else we +get a black hole. They'll be done again later, in TcTyClDecls.tcGroup. + + -------------------------- + *** END OF BIG WARNING *** + -------------------------- + \begin{code} -tcHsType :: RenamedHsType -> TcM s Type -tcHsType ty@(HsTyVar name) - = tc_app ty [] +tc_type :: RecFlag -> RenamedHsType -> TcM Type -tcHsType (HsListTy ty) - = tcHsType ty `thenTc` \ tau_ty -> - returnTc (mkListTy tau_ty) +tc_type wimp_out ty@(HsTyVar name) + = tc_app wimp_out ty [] -tcHsType (HsTupleTy (HsTupCon _ boxity) tys) - = mapTc tcHsType tys `thenTc` \ tau_tys -> - returnTc (mkTupleTy boxity (length tys) tau_tys) +tc_type wimp_out (HsListTy ty) + = tc_arg_type wimp_out ty `thenTc` \ tau_ty -> + returnTc (mkListTy tau_ty) -tcHsType (HsFunTy ty1 ty2) - = tcHsType ty1 `thenTc` \ tau_ty1 -> - tcHsType ty2 `thenTc` \ tau_ty2 -> +tc_type wimp_out (HsTupleTy (HsTupCon _ boxity arity) tys) + = ASSERT( arity == length tys ) + mapTc tc_tup_arg tys `thenTc` \ tau_tys -> + returnTc (mkTupleTy boxity arity tau_tys) + where + tc_tup_arg = case boxity of + Boxed -> tc_arg_type wimp_out + Unboxed -> tc_type wimp_out + -- Unboxed tuples can have polymorphic or unboxed args. + -- This happens in the workers for functions returning + -- product types with polymorphic components + +tc_type wimp_out (HsFunTy ty1 ty2) + = tc_type wimp_out ty1 `thenTc` \ tau_ty1 -> + -- Function argument can be polymorphic, but + -- must not be an unboxed tuple + checkTc (not (isUnboxedTupleType tau_ty1)) + (ubxArgTyErr ty1) `thenTc_` + tc_type wimp_out ty2 `thenTc` \ tau_ty2 -> returnTc (mkFunTy tau_ty1 tau_ty2) -tcHsType (HsAppTy ty1 ty2) - = tc_app ty1 [ty2] +tc_type wimp_out (HsNumTy n) + = ASSERT(n== 1) + returnTc (mkTyConApp genUnitTyCon []) -tcHsType (HsPredTy pred) - = tcClassAssertion True pred `thenTc` \ pred' -> - returnTc (mkPredTy pred') +tc_type wimp_out (HsOpTy ty1 op ty2) = + tc_arg_type wimp_out ty1 `thenTc` \ tau_ty1 -> + tc_arg_type wimp_out ty2 `thenTc` \ tau_ty2 -> + tc_fun_type op [tau_ty1,tau_ty2] -tcHsType (HsUsgTy usg ty) - = newUsg usg `thenTc` \ usg' -> - tcHsType ty `thenTc` \ tc_ty -> - returnTc (mkUsgTy usg' tc_ty) - where - newUsg usg = case usg of - HsUsOnce -> returnTc UsOnce - HsUsMany -> returnTc UsMany - HsUsVar uv_name -> tcLookupUVar uv_name `thenTc` \ uv -> - returnTc (UsVar uv) +tc_type wimp_out (HsAppTy ty1 ty2) + = tc_app wimp_out ty1 [ty2] -tcHsType (HsUsgForAllTy uv_name ty) +tc_type wimp_out (HsPredTy pred) + = tc_pred wimp_out pred `thenTc` \ pred' -> + returnTc (mkPredTy pred') + +tc_type wimp_out full_ty@(HsForAllTy (Just tv_names) ctxt ty) = let - uv = mkNamedUVar uv_name + kind_check = kcHsContext ctxt `thenTc_` kcHsType ty in - tcExtendUVarEnv uv_name uv $ - tcHsType ty `thenTc` \ tc_ty -> - returnTc (mkUsForAllTy uv tc_ty) + tcHsTyVars tv_names kind_check $ \ tyvars -> + tcRecTheta wimp_out ctxt `thenTc` \ theta -> + + -- 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 theta then + tc_arg_type wimp_out ty + else + tc_type wimp_out ty + ) `thenTc` \ tau -> -tcHsType full_ty@(HsForAllTy (Just tv_names) ctxt ty) - = kcTyVarScope tv_names - (kcHsContext ctxt `thenTc_` kcHsType ty) `thenTc` \ tv_kinds -> - let - forall_tyvars = mkImmutTyVars tv_kinds - in - tcExtendTyVarEnv forall_tyvars $ - tcContext ctxt `thenTc` \ theta -> - tcHsType ty `thenTc` \ tau -> - let - -- Check for ambiguity - -- forall V. P => tau - -- is ambiguous if P contains generic variables - -- (i.e. one of the Vs) that are not mentioned in tau - -- - -- However, we need to take account of functional dependencies - -- when we speak of 'mentioned in tau'. Example: - -- class C a b | a -> b where ... - -- Then the type - -- forall x y. (C x y) => x - -- is not ambiguous because x is mentioned and x determines y - -- - -- NOTE: In addition, GHC insists that at least one type variable - -- in each constraint is in V. So we disallow a type like - -- forall a. Eq b => b -> b - -- even in a scope where b is in scope. - -- This is the is_free test below. - - tau_vars = tyVarsOfType tau - fds = instFunDepsOfTheta theta - tvFundep = tyVarFunDep fds - extended_tau_vars = oclose tvFundep tau_vars - is_ambig ct_var = (ct_var `elem` forall_tyvars) && - not (ct_var `elemUFM` extended_tau_vars) - is_free ct_var = not (ct_var `elem` forall_tyvars) - - check_pred pred = checkTc (not any_ambig) (ambigErr pred full_ty) `thenTc_` - checkTc (not all_free) (freeErr pred full_ty) - where - ct_vars = varSetElems (tyVarsOfPred pred) - any_ambig = is_source_polytype && any is_ambig ct_vars - all_free = all is_free ct_vars - - -- Check ambiguity only for source-program types, not - -- for types coming from inteface files. The latter can - -- legitimately have ambiguous types. Example - -- class S a where s :: a -> (Int,Int) - -- instance S Char where s _ = (1,1) - -- f:: S a => [a] -> Int -> (Int,Int) - -- f (_::[a]) x = (a*x,b) - -- where (a,b) = s (undefined::a) - -- Here the worker for f gets the type - -- fw :: forall a. S a => Int -> (# Int, Int #) - -- - -- If the list of tv_names is empty, we have a monotype, - -- and then we don't need to check for ambiguity either, - -- because the test can't fail (see is_ambig). - is_source_polytype = case tv_names of - (UserTyVar _ : _) -> True - other -> False - in - mapTc check_pred theta `thenTc_` - returnTc (mkSigmaTy forall_tyvars theta tau) + checkAmbiguity wimp_out is_source tyvars theta tau + where + is_source = case tv_names of + (UserTyVar _ : _) -> True + other -> False + + + -- tc_arg_type checks that the argument of a + -- type appplication isn't a for-all type or an unboxed tuple type + -- For example, we want to reject things like: + -- + -- instance Ord a => Ord (forall s. T s a) + -- and + -- g :: T s (forall b.b) + -- + -- Other unboxed types are very occasionally allowed as type + -- arguments depending on the kind of the type constructor + +tc_arg_type wimp_out arg_ty + | isRec wimp_out + = tc_type wimp_out arg_ty + + | otherwise + = tc_type wimp_out arg_ty `thenTc` \ arg_ty' -> + checkTc (not (isForAllTy arg_ty')) (polyArgTyErr arg_ty) `thenTc_` + checkTc (not (isUnboxedTupleType arg_ty')) (ubxArgTyErr arg_ty) `thenTc_` + returnTc arg_ty' + +tc_arg_types wimp_out arg_tys = mapTc (tc_arg_type wimp_out) arg_tys \end{code} Help functions for type applications ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -tc_app (HsAppTy ty1 ty2) tys - = tc_app ty1 (ty2:tys) +tc_app :: RecFlag -> RenamedHsType -> [RenamedHsType] -> TcM Type +tc_app wimp_out (HsAppTy ty1 ty2) tys + = tc_app wimp_out ty1 (ty2:tys) -tc_app ty tys +tc_app wimp_out ty tys = tcAddErrCtxt (appKindCtxt pp_app) $ - mapTc tcHsType tys `thenTc` \ arg_tys -> - tc_fun_type ty arg_tys + tc_arg_types wimp_out tys `thenTc` \ arg_tys -> + case ty of + HsTyVar fun -> tc_fun_type fun arg_tys + other -> tc_type wimp_out ty `thenTc` \ fun_ty -> + returnNF_Tc (mkAppTys fun_ty arg_tys) where pp_app = ppr ty <+> sep (map pprParendHsType tys) @@ -413,17 +463,18 @@ tc_app ty tys -- But not quite; for synonyms it checks the correct arity, and builds a SynTy -- hence the rather strange functionality. -tc_fun_type (HsTyVar name) arg_tys - = tcLookupTy name `thenTc` \ thing -> +tc_fun_type name arg_tys + = tcLookup name `thenTc` \ thing -> case thing of ATyVar tv -> returnTc (mkAppTys (mkTyVarTy tv) arg_tys) - ATyCon tc | isSynTyCon tc -> checkTc arity_ok err_msg `thenTc_` - returnTc (mkAppTys (mkSynTy tc (take arity arg_tys)) - (drop arity arg_tys)) + AGlobal (ATyCon tc) + | isSynTyCon tc -> checkTc arity_ok err_msg `thenTc_` + returnTc (mkAppTys (mkSynTy tc (take arity arg_tys)) + (drop arity arg_tys)) - | otherwise -> returnTc (mkTyConApp tc arg_tys) - where + | otherwise -> returnTc (mkTyConApp tc arg_tys) + where arity_ok = arity <= n_args arity = tyConArity tc @@ -435,46 +486,108 @@ tc_fun_type (HsTyVar name) arg_tys n_args = length arg_tys other -> failWithTc (wrongThingErr "type constructor" thing name) - -tc_fun_type ty arg_tys - = tcHsType ty `thenTc` \ fun_ty -> - returnNF_Tc (mkAppTys fun_ty arg_tys) \end{code} Contexts ~~~~~~~~ \begin{code} -tcClassContext :: RenamedContext -> TcM s ClassContext +tcRecTheta :: RecFlag -> RenamedContext -> TcM ThetaType -- Used when we are expecting a ClassContext (i.e. no implicit params) -tcClassContext context - = tcContext context `thenTc` \ theta -> - returnTc (classesOfPreds theta) - -tcContext :: RenamedContext -> TcM s ThetaType -tcContext context = mapTc (tcClassAssertion False) context +tcRecTheta wimp_out context = mapTc (tc_pred wimp_out) context -tcClassAssertion ccall_ok assn@(HsPClass class_name tys) +tc_pred wimp_out assn@(HsClassP class_name tys) = tcAddErrCtxt (appKindCtxt (ppr assn)) $ - mapTc tcHsType tys `thenTc` \ arg_tys -> - tcLookupTy class_name `thenTc` \ thing -> + tc_arg_types wimp_out 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) + AClass clas -> checkTc (arity == n_tys) err `thenTc_` + returnTc (ClassP clas arg_tys) where arity = classArity clas n_tys = length tys err = arityErr "Class" class_name arity n_tys - other -> failWithTc (wrongThingErr "class" thing class_name) + other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name) -tcClassAssertion ccall_ok assn@(HsPIParam name ty) +tc_pred wimp_out assn@(HsIParam name ty) = tcAddErrCtxt (appKindCtxt (ppr assn)) $ - tcHsType ty `thenTc` \ arg_ty -> + tc_arg_type wimp_out ty `thenTc` \ arg_ty -> returnTc (IParam name arg_ty) \end{code} +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. + +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). + +\begin{code} +checkAmbiguity :: RecFlag -> Bool + -> [TyVar] -> ThetaType -> TauType + -> TcM SigmaType +checkAmbiguity wimp_out is_source_polytype forall_tyvars theta tau + | isRec wimp_out = returnTc sigma_ty + | otherwise = mapTc_ check_pred theta `thenTc_` + returnTc sigma_ty + where + sigma_ty = mkSigmaTy forall_tyvars theta tau + tau_vars = tyVarsOfType tau + extended_tau_vars = grow theta tau_vars + + -- Hack alert. If there are no tyvars, (ppr sigma_ty) will print + -- something strange like {Eq k} -> k -> k, because there is no + -- ForAll at the top of the type. Since this is going to the user + -- we want it to look like a proper Haskell type even then; hence the hack + -- + -- This shows up in the complaint about + -- case C a where + -- op :: Eq a => a -> a + ppr_sigma | null forall_tyvars = pprTheta theta <+> ptext SLIT("=>") <+> ppr tau + | otherwise = ppr sigma_ty + + is_ambig ct_var = (ct_var `elem` forall_tyvars) && + not (ct_var `elemVarSet` extended_tau_vars) + is_free ct_var = not (ct_var `elem` forall_tyvars) + + check_pred pred = checkTc (not any_ambig) (ambigErr pred ppr_sigma) `thenTc_` + checkTc (isIPPred pred || not all_free) (freeErr pred ppr_sigma) + where + ct_vars = varSetElems (tyVarsOfPred pred) + all_free = all is_free ct_vars + any_ambig = is_source_polytype && any is_ambig ct_vars +\end{code} + %************************************************************************ %* * \subsection{Type variables, with knot tying!} @@ -483,10 +596,7 @@ tcClassAssertion ccall_ok assn@(HsPIParam name ty) \begin{code} mkImmutTyVars :: [(Name,Kind)] -> [TyVar] -newSigTyVars :: [(Name,Kind)] -> NF_TcM s [TcTyVar] - mkImmutTyVars pairs = [mkTyVar name kind | (name, kind) <- pairs] -newSigTyVars pairs = listNF_Tc [tcNewSigTyVar name kind | (name,kind) <- pairs] mkTyClTyVars :: Kind -- Kind of the tycon or class -> [HsTyVarBndr Name] @@ -548,16 +658,16 @@ maybeSig (sig@(TySigInfo sig_name _ _ _ _ _ _ _) : sigs) name \begin{code} -tcTySig :: RenamedSig -> TcM s TcSigInfo +tcTySig :: RenamedSig -> TcM TcSigInfo tcTySig (Sig v ty src_loc) = tcAddSrcLoc src_loc $ tcAddErrCtxt (tcsigCtxt v) $ tcHsSigType ty `thenTc` \ sigma_tc_ty -> - mkTcSig (mkVanillaId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig -> + mkTcSig (mkLocalId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig -> returnTc sig -mkTcSig :: TcId -> SrcLoc -> NF_TcM s TcSigInfo +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 @@ -585,9 +695,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} @@ -659,35 +768,31 @@ give a helpful message in checkSigTyVars. \begin{code} checkSigTyVars :: [TcTyVar] -- Universally-quantified type variables in the signature -> TcTyVarSet -- Tyvars that are free in the type signature - -- These should *already* be in the global-var set, and are - -- used here only to improve the error message - -> TcM s [TcTyVar] -- Zonked signature type variables + -- 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) 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 -> + 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) @@ -709,44 +814,56 @@ checkSigTyVars sig_tyvars free_tyvars 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 { 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) ; + 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 -- The least comprehensible, so put it last - then tcGetValueEnv `thenNF_Tc` \ ve -> - find_globals tv env [] (valueEnvIds ve) `thenNF_Tc` \ (env1, globs) -> - find_frees tv env1 [] (varSetElems free_tyvars) `thenNF_Tc` \ (env2, frees) -> - returnNF_Tc (env2, acc, escape_msg sig_tyvar tv globs frees : msgs) + -- Game plan: + -- a) get the local TcIds 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 [] (tcEnvTcIds 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 :: Var + -> TidyEnv + -> [(Name,Type)] + -> [Id] + -> NF_TcM (TidyEnv,[(Name,Type)]) + 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) + | isEmptyVarSet (idFreeTyVars id) = find_globals tv tidy_env acc ids | otherwise @@ -798,7 +915,7 @@ 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} @@ -806,7 +923,7 @@ These two context are used with checkSigTyVars \begin{code} sigCtxt :: Message -> [TcTyVar] -> TcThetaType -> TcTauType - -> TidyEnv -> NF_TcM s (TidyEnv, Message) + -> TidyEnv -> NF_TcM (TidyEnv, Message) sigCtxt when sig_tyvars sig_theta sig_tau tidy_env = zonkTcType sig_tau `thenNF_Tc` \ actual_tau -> let @@ -843,8 +960,6 @@ sigPatCtxt bound_tvs bound_ids tidy_env \begin{code} tcsigCtxt v = ptext SLIT("In a type signature for") <+> quotes (ppr v) -typeCtxt ty = ptext SLIT("In the type") <+> quotes (ppr ty) - typeKindCtxt :: RenamedHsType -> Message typeKindCtxt ty = sep [ptext SLIT("When checking that"), nest 2 (quotes (ppr ty)), @@ -853,22 +968,29 @@ typeKindCtxt ty = sep [ptext SLIT("When checking that"), appKindCtxt :: SDoc -> Message appKindCtxt pp = ptext SLIT("When checking kinds in") <+> quotes pp -wrongThingErr expected actual name - = pp_actual actual <+> quotes (ppr name) <+> ptext SLIT("used as a") <+> text expected +wrongThingErr expected thing name + = pp_thing thing <+> quotes (ppr name) <+> ptext SLIT("used as a") <+> text expected where - pp_actual (ATyCon _) = ptext SLIT("Type constructor") - pp_actual (AClass _) = ptext SLIT("Class") - pp_actual (ATyVar _) = ptext SLIT("Type variable") - pp_actual (AThing _) = ptext SLIT("Utterly bogus") - -ambigErr pred ty + 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") + +ambigErr pred ppr_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)) + nest 4 (ptext SLIT("for the type:") <+> ppr_ty), + nest 4 (ptext SLIT("At least one of the forall'd type variables mentioned by the constraint") $$ + ptext SLIT("must be reachable from the type after the =>"))] + +freeErr pred ppr_ty + = sep [ptext SLIT("All of the type variables in the constraint") <+> quotes (pprPred pred) <+> + ptext SLIT("are already in scope"), + nest 4 (ptext SLIT("At least one must be universally quantified here")), + ptext SLIT("In the type") <+> quotes ppr_ty ] + +polyArgTyErr ty = ptext SLIT("Illegal polymorphic type as argument:") <+> ppr ty +ubxArgTyErr ty = ptext SLIT("Illegal unboxed tuple type as argument:") <+> ppr ty \end{code}