X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcMonoType.lhs;h=e8b2335082dfd17f7127e03acc037ff60290b19b;hb=f12359af6ae59e05a19c9e2d847a356c8dcf40be;hp=4ed8e502c0365b09e52f173cd074061e044c2d68;hpb=6c381e873e222417d9a67aeec77b9555eca7b7a8;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcMonoType.lhs b/ghc/compiler/typecheck/TcMonoType.lhs index 4ed8e50..e8b2335 100644 --- a/ghc/compiler/typecheck/TcMonoType.lhs +++ b/ghc/compiler/typecheck/TcMonoType.lhs @@ -1,195 +1,987 @@ % -% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996 +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % \section[TcMonoType]{Typechecking user-specified @MonoTypes@} \begin{code} -#include "HsVersions.h" +module TcMonoType ( tcHsType, tcHsRecType, + tcHsSigType, tcHsBoxedSigType, + tcRecClassContext, checkAmbiguity, -module TcMonoType ( tcPolyType, tcMonoType, tcMonoTypeKind, tcContext ) where + -- Kind checking + kcHsTyVar, kcHsTyVars, mkTyClTyVars, + kcHsType, kcHsSigType, kcHsBoxedSigType, kcHsContext, + tcTyVars, tcHsTyVars, mkImmutTyVars, -import Ubiq{-uitous-} + TcSigInfo(..), tcTySig, mkTcSig, maybeSig, + checkSigTyVars, sigCtxt, sigPatCtxt + ) where -import HsSyn ( PolyType(..), MonoType(..), Fake ) -import RnHsSyn ( RenamedPolyType(..), RenamedMonoType(..), - RenamedContext(..) - ) +#include "HsVersions.h" +import HsSyn ( HsType(..), HsTyVarBndr(..), + Sig(..), HsPred(..), pprParendHsType, HsTupCon(..), hsTyVarNames ) +import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig ) +import TcHsSyn ( TcId ) import TcMonad -import TcEnv ( tcLookupTyVar, tcLookupClass, tcLookupTyCon, - tcExtendTyVarEnv, tcTyVarScope +import TcEnv ( tcExtendTyVarEnv, tcLookup, tcLookupGlobal, + tcGetGlobalTyVars, tcEnvTcIds, tcEnvTyVars, + TyThing(..), TcTyThing(..), tcExtendKindEnv ) -import TcKind ( TcKind, mkTcTypeKind, mkBoxedTypeKind, - mkTcArrowKind, unifyKind, newKindVar, - kindToTcKind +import TcType ( TcKind, TcTyVar, TcThetaType, TcTauType, + newKindVar, tcInstSigVar, + zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar ) -import ErrUtils ( arityErr ) -import Type ( GenType, Type(..), ThetaType(..), - mkTyVarTy, mkTyConTy, mkFunTy, mkAppTy, - mkSigmaTy +import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToIdBndr, + instFunDeps, instFunDepsOfTheta ) +import FunDeps ( oclose ) +import TcUnify ( unifyKind, unifyOpenTypeKind ) +import Type ( Type, Kind, PredType(..), ThetaType, SigmaType, TauType, + mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, + 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, isForAllTy ) -import TyVar ( GenTyVar, TyVar(..), mkTyVar ) -import PrelInfo ( mkListTy, mkTupleTy ) -import Type ( mkDictTy ) -import Class ( cCallishClassKeys ) -import Unique ( Unique ) -import Name ( Name(..), getNameShortName, isTyConName, getSynNameArity ) -import PprStyle -import Pretty -import Util ( zipWithEqual, panic ) +import PprType ( pprType, pprPred ) +import Subst ( mkTopTyVarSubst, substTy ) +import CoreFVs ( idFreeTyVars ) +import Id ( mkVanillaId, 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 ) +import TysWiredIn ( mkListTy, mkTupleTy, genUnitTyCon ) +import UniqFM ( elemUFM ) +import BasicTypes ( Boxity(..), RecFlag(..), isRec ) +import SrcLoc ( SrcLoc ) +import Util ( mapAccumL, isSingleton ) +import Outputable + \end{code} -tcMonoType and tcMonoTypeKind -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\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 -tcMonoType checks that the type really is of kind Type! +Note that this may occasionally give surprising results. For example: + + data T a b = MkT (a b) + +Here we deduce a::*->*, b::*. +But equally valid would be + a::(*->*)-> *, b::*->* + +\begin{code} +tcHsTyVars :: [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) + +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} -tcMonoType :: RenamedMonoType -> TcM s Type +kcHsTyVar :: HsTyVarBndr name -> NF_TcM (name, TcKind) +kcHsTyVars :: [HsTyVarBndr name] -> NF_TcM [(name, TcKind)] -tcMonoType ty - = tcMonoTypeKind ty `thenTc` \ (kind,ty) -> - unifyKind kind mkTcTypeKind `thenTc_` - returnTc ty +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 () + -- The type ty must be a *boxed* *type* +kcBoxedType ty + = kcHsType ty `thenTc` \ kind -> + tcAddErrCtxt (typeKindCtxt ty) $ + unifyKind boxedTypeKind kind + +--------------------------- +kcTypeType :: RenamedHsType -> TcM () + -- The type ty must be a *type*, but it can be boxed or unboxed. +kcTypeType ty + = kcHsType ty `thenTc` \ kind -> + tcAddErrCtxt (typeKindCtxt ty) $ + unifyOpenTypeKind kind + +--------------------------- +kcHsSigType, kcHsBoxedSigType :: RenamedHsType -> TcM () + -- Used for type signatures +kcHsSigType = kcTypeType +kcHsBoxedSigType = kcBoxedType + +--------------------------- +kcHsType :: RenamedHsType -> TcM TcKind +kcHsType (HsTyVar name) = kcTyVar name + +kcHsType (HsListTy ty) + = kcBoxedType ty `thenTc` \ tau_ty -> + returnTc boxedTypeKind + +kcHsType (HsTupleTy (HsTupCon _ boxity _) tys) + = mapTc kcTypeType tys `thenTc_` + returnTc (case boxity of + Boxed -> boxedTypeKind + Unboxed -> unboxedTypeKind) + +kcHsType (HsFunTy ty1 ty2) + = kcTypeType ty1 `thenTc_` + kcTypeType ty2 `thenTc_` + returnTc boxedTypeKind + +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 + +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 boxedTypeKind + +--------------------------- +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 fun_kind (mkArrowKind arg_kind res_kind) `thenTc_` + returnTc res_kind + + +--------------------------- +kcHsContext ctxt = mapTc_ kcHsPred ctxt + +kcHsPred :: RenamedHsPred -> TcM () +kcHsPred pred@(HsPIParam name ty) + = tcAddErrCtxt (appKindCtxt (ppr pred)) $ + kcBoxedType ty + +kcHsPred pred@(HsPClass cls tys) + = tcAddErrCtxt (appKindCtxt (ppr pred)) $ + kcClass cls `thenTc` \ kind -> + mapTc kcHsType tys `thenTc` \ arg_kinds -> + unifyKind kind (mkArrowKinds arg_kinds boxedTypeKind) + + --------------------------- +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} -tcMonoTypeKind does the real work. It returns a kind and a type. +%************************************************************************ +%* * +\subsection{Checking types} +%* * +%************************************************************************ + +tcHsSigType and tcHsBoxedSigType +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +tcHsSigType and tcHsBoxedSigType 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} -tcMonoTypeKind :: RenamedMonoType -> TcM s (TcKind s, Type) +tcHsSigType, tcHsBoxedSigType :: RenamedHsType -> TcM Type + -- Do kind checking, and hoist for-alls to the top +tcHsSigType ty = kcTypeType ty `thenTc_` tcHsType ty +tcHsBoxedSigType ty = kcBoxedType 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 +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') +\end{code} -tcMonoTypeKind (MonoTyVar name) - = tcLookupTyVar name `thenNF_Tc` \ (kind,tyvar) -> - returnTc (kind, mkTyVarTy tyvar) - -tcMonoTypeKind (MonoListTy ty) - = tcMonoType ty `thenTc` \ tau_ty -> - returnTc (mkTcTypeKind, mkListTy tau_ty) +%************************************************************************ +%* * +\subsection{tc_type} +%* * +%************************************************************************ + +tc_type, the main work horse +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -tcMonoTypeKind (MonoTupleTy tys) - = mapTc tcMonoType tys `thenTc` \ tau_tys -> - returnTc (mkTcTypeKind, mkTupleTy (length tys) tau_tys) + ------------------- + *** BIG WARNING *** + ------------------- -tcMonoTypeKind (MonoFunTy ty1 ty2) - = tcMonoType ty1 `thenTc` \ tau_ty1 -> - tcMonoType ty2 `thenTc` \ tau_ty2 -> - returnTc (mkTcTypeKind, mkFunTy tau_ty1 tau_ty2) +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. -tcMonoTypeKind (MonoTyApp name tys) - = mapAndUnzipTc tcMonoTypeKind tys `thenTc` \ (arg_kinds, arg_tys) -> + data T a = MkT a [T a] - tc_mono_name name `thenNF_Tc` \ (fun_kind, fun_ty) -> +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! - newKindVar `thenNF_Tc` \ result_kind -> - unifyKind fun_kind (foldr mkTcArrowKind result_kind arg_kinds) `thenTc_` +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. - -- Check for saturated application in the special case of - -- type synoyms. Here the renamer has kindly attached the - -- arity to the Name. - synArityCheck name (length tys) `thenTc_` + -------------------------- + *** END OF BIG WARNING *** + -------------------------- - returnTc (result_kind, foldl mkAppTy fun_ty arg_tys) --- for unfoldings only: -tcMonoTypeKind (MonoForAllTy tyvars_w_kinds ty) - = tcExtendTyVarEnv tyvar_names (tc_kinds `zip` tyvars) ( - tcMonoTypeKind ty `thenTc` \ (kind, ty') -> - unifyKind kind mkTcTypeKind `thenTc_` - returnTc (mkTcTypeKind, ty') - ) +\begin{code} +tc_type :: RecFlag -> RenamedHsType -> TcM Type + +tc_type wimp_out ty@(HsTyVar name) + = tc_app wimp_out ty [] + +tc_type wimp_out (HsListTy ty) + = tc_arg_type wimp_out ty `thenTc` \ tau_ty -> + returnTc (mkListTy tau_ty) + +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 - (tyvar_names, kinds) = unzip tyvars_w_kinds - tyvars = zipWithEqual mk_tyvar tyvar_names kinds - tc_kinds = map kindToTcKind kinds - mk_tyvar name kind = mkTyVar (getNameShortName name) (getItsUnique name) kind - --- for unfoldings only: -tcMonoTypeKind (MonoDictTy class_name ty) - = tcMonoTypeKind ty `thenTc` \ (arg_kind, arg_ty) -> - tcLookupClass class_name `thenNF_Tc` \ (class_kind, clas) -> - unifyKind class_kind arg_kind `thenTc_` - returnTc (mkTcTypeKind, mkDictTy clas arg_ty) - - -tc_mono_name :: Name -> NF_TcM s (TcKind s, Type) -tc_mono_name name@(Short _ _) -- Must be a type variable - = tcLookupTyVar name `thenNF_Tc` \ (kind,tyvar) -> - returnNF_Tc (kind, mkTyVarTy tyvar) - -tc_mono_name name | isTyConName name -- Must be a type constructor - = tcLookupTyCon name `thenNF_Tc` \ (kind,tycon) -> - returnNF_Tc (kind, mkTyConTy tycon) - -tc_mono_name name -- Renamer should have got it right - = panic ("tc_mono_name:" ++ ppShow 1000 (ppr PprDebug name)) + 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) + +tc_type wimp_out (HsNumTy n) + = ASSERT(n== 1) + returnTc (mkTyConApp genUnitTyCon []) + +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] + +tc_type wimp_out (HsAppTy ty1 ty2) + = tc_app wimp_out ty1 [ty2] + +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 + kind_check = kcHsContext ctxt `thenTc_` kcHsType ty + in + tcHsTyVars tv_names kind_check $ \ tyvars -> + tc_context 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 -> + + 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 :: RecFlag -> RenamedHsType -> [RenamedHsType] -> TcM Type +tc_app wimp_out (HsAppTy ty1 ty2) tys + = tc_app wimp_out ty1 (ty2:tys) + +tc_app wimp_out ty tys + = tcAddErrCtxt (appKindCtxt pp_app) $ + 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) + +-- (tc_fun_type ty arg_tys) returns (mkAppTys ty arg_tys) +-- But not quite; for synonyms it checks the correct arity, and builds a SynTy +-- hence the rather strange functionality. + +tc_fun_type name arg_tys + = tcLookup name `thenTc` \ thing -> + case thing of + 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)) + + | 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} Contexts ~~~~~~~~ \begin{code} +tcRecClassContext :: RecFlag -> RenamedContext -> TcM ClassContext + -- Used when we are expecting a ClassContext (i.e. no implicit params) +tcRecClassContext wimp_out context + = tc_context wimp_out context `thenTc` \ theta -> + returnTc (classesOfPreds theta) + +tc_context :: RecFlag -> RenamedContext -> TcM ThetaType +tc_context wimp_out context = mapTc (tc_pred wimp_out) context + +tc_pred wimp_out assn@(HsPClass class_name tys) + = tcAddErrCtxt (appKindCtxt (ppr assn)) $ + 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) + where + arity = classArity clas + n_tys = length tys + err = arityErr "Class" class_name arity n_tys + + other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name) + +tc_pred wimp_out assn@(HsPIParam name ty) + = tcAddErrCtxt (appKindCtxt (ppr assn)) $ + tc_arg_type wimp_out ty `thenTc` \ arg_ty -> + returnTc (IParam name arg_ty) +\end{code} -tcContext :: RenamedContext -> TcM s ThetaType -tcContext context = mapTc tcClassAssertion context -tcClassAssertion (class_name, tyvar_name) - = checkTc (canBeUsedInContext class_name) - (naughtyCCallContextErr class_name) `thenTc_` +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). - tcLookupClass class_name `thenNF_Tc` \ (class_kind, clas) -> - tcLookupTyVar tyvar_name `thenNF_Tc` \ (tyvar_kind, tyvar) -> +\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 + fds = instFunDepsOfTheta theta + extended_tau_vars = oclose fds 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 sigma_ty) `thenTc_` + checkTc (is_ip pred || not all_free) (freeErr pred sigma_ty) + where + ct_vars = varSetElems (tyVarsOfPred pred) + all_free = all is_free ct_vars + any_ambig = is_source_polytype && any is_ambig ct_vars + is_ip (IParam _ _) = True + is_ip _ = False +\end{code} - unifyKind class_kind tyvar_kind `thenTc_` +%************************************************************************ +%* * +\subsection{Type variables, with knot tying!} +%* * +%************************************************************************ - returnTc (clas, mkTyVarTy tyvar) +\begin{code} +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} -HACK warning: Someone discovered that @_CCallable@ and @_CReturnable@ -could be used in contexts such as: -\begin{verbatim} -foo :: _CCallable a => a -> PrimIO Int -\end{verbatim} -Doing this utterly wrecks the whole point of introducing these -classes so we specifically check that this isn't being done. +%************************************************************************ +%* * +\subsection{Signatures} +%* * +%************************************************************************ + +@tcSigs@ checks the signatures for validity, and returns a list of +{\em freshly-instantiated} signatures. That is, the types are already +split up, and have fresh type variables installed. All non-type-signature +"RenamedSigs" are ignored. + +The @TcSigInfo@ contains @TcTypes@ because they are unified with +the variable's type, and after that checked to see whether they've +been instantiated. \begin{code} -canBeUsedInContext :: Name -> Bool -canBeUsedInContext (ClassName uniq _ _) = not (uniq `elem` cCallishClassKeys) -canBeUsedInContext other = True +data TcSigInfo + = TySigInfo + Name -- N, the Name in corresponding binding + + TcId -- *Polymorphic* binder for this value... + -- Has name = N + + [TcTyVar] -- tyvars + TcThetaType -- theta + TcTauType -- tau + + TcId -- *Monomorphic* binder for this value + -- Does *not* have name = N + -- Has type tau + + [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] -> 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 \end{code} -Polytypes -~~~~~~~~~ \begin{code} -tcPolyType :: RenamedPolyType -> TcM s Type -tcPolyType (HsForAllTy tyvar_names context ty) - = tcTyVarScope tyvar_names (\ tyvars -> - tcContext context `thenTc` \ theta -> - tcMonoType ty `thenTc` \ tau -> - returnTc (mkSigmaTy tyvars theta tau) - ) +tcTySig :: RenamedSig -> TcM TcSigInfo + +tcTySig (Sig v ty src_loc) + = tcAddSrcLoc src_loc $ + tcAddErrCtxt (tcsigCtxt v) $ + tcHsSigType ty `thenTc` \ sigma_tc_ty -> + mkTcSig (mkVanillaId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig -> + returnTc sig + +mkTcSig :: TcId -> SrcLoc -> NF_TcM TcSigInfo +mkTcSig poly_id src_loc + = -- Instantiate this type + -- It's important to do this even though in the error-free case + -- we could just split the sigma_tc_ty (since the tyvars don't + -- unified with anything). But in the case of an error, when + -- the tyvars *do* get unified with something, we want to carry on + -- typechecking the rest of the program with the function bound + -- to a pristine type, namely sigma_tc_ty + let + (tyvars, rho) = splitForAllTys (idType poly_id) + in + mapNF_Tc tcInstSigVar tyvars `thenNF_Tc` \ tyvars' -> + -- Make *signature* type variables + + let + tyvar_tys' = mkTyVarTys tyvars' + rho' = substTy (mkTopTyVarSubst tyvars tyvar_tys') rho + -- mkTopTyVarSubst because the tyvars' are fresh + (theta', tau') = splitRhoTy rho' + -- This splitRhoTy tries hard to make sure that tau' is a type synonym + -- wherever possible, which can improve interface files. + in + newMethodWithGivenTy SignatureOrigin + poly_id + tyvar_tys' + theta' tau' `thenNF_Tc` \ inst -> + -- 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) + where + name = idName poly_id \end{code} -Auxilliary functions -~~~~~~~~~~~~~~~~~~~~ + + +%************************************************************************ +%* * +\subsection{Checking signature type variables} +%* * +%************************************************************************ + +@checkSigTyVars@ is used after the type in a type signature has been unified with +the actual type found. It then checks that the type variables of the type signature +are + (a) Still all type variables + eg matching signature [a] against inferred type [(p,q)] + [then a will be unified to a non-type variable] + + (b) Still all distinct + eg matching signature [(a,b)] against inferred type [(p,p)] + [then a and b will be unified together] + + (c) Not mentioned in the environment + eg the signature for f in this: + + g x = ... where + f :: a->[a] + f y = [x,y] + + Here, f is forced to be monorphic by the free occurence of x. + + (d) Not (unified with another type variable that is) in scope. + eg f x :: (r->r) = (\y->y) :: forall a. a->r + when checking the expression type signature, we find that + even though there is nothing in scope whose type mentions r, + nevertheless the type signature for the expression isn't right. + + Another example is in a class or instance declaration: + class C a where + op :: forall b. a -> b + op x = x + Here, b gets unified with a + +Before doing this, the substitution is applied to the signature type variable. + +We used to have the notion of a "DontBind" type variable, which would +only be bound to itself or nothing. Then points (a) and (b) were +self-checking. But it gave rise to bogus consequential error messages. +For example: + + f = (*) -- Monomorphic + + g :: Num a => a -> a + g x = f x x + +Here, we get a complaint when checking the type signature for g, +that g isn't polymorphic enough; but then we get another one when +dealing with the (Num x) context arising from f's definition; +we try to unify x with Int (to default it), but find that x has already +been unified with the DontBind variable "a" from g's signature. +This is really a problem with side-effecting unification; we'd like to +undo g's effects when its type signature fails, but unification is done +by side effect, so we can't (easily). + +So we revert to ordinary type variables for signatures, and try to +give a helpful message in checkSigTyVars. + \begin{code} -synArityCheck :: Name -> Int -> TcM s () -synArityCheck name n_args - = case getSynNameArity name of - Just arity | arity /= n_args -> failTc (err arity) - other -> returnTc () +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 + +checkSigTyVars [] free = returnTc [] + +checkSigTyVars sig_tyvars free_tyvars + = zonkTcTyVars sig_tyvars `thenNF_Tc` \ sig_tys -> + tcGetGlobalTyVars `thenNF_Tc` \ globals -> + + checkTcM (all_ok sig_tys globals) + (complain sig_tys globals) `thenTc_` + + returnTc (map (getTyVar "checkSigTyVars") sig_tys) + + where + all_ok [] acc = True + all_ok (ty:tys) acc = case getTyVar_maybe ty of + Nothing -> False -- Point (a) + Just tv | tv `elemVarSet` acc -> False -- Point (b) or (c) + | otherwise -> all_ok tys (acc `extendVarSet` tv) + + + complain sig_tys globals + = -- For the in-scope ones, zonk them and construct a map + -- from the zonked tyvar to the in-scope one + -- If any of the in-scope tyvars zonk to a type, then ignore them; + -- that'll be caught later when we back up to their type sig + 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 + foldlNF_Tc check + (env2, in_scope_env, []) + (tidy_tvs `zip` tidy_tys) `thenNF_Tc` \ (env3, _, msgs) -> + + failWithTcM (env3, main_msg $$ nest 4 (vcat msgs)) + where + (env1, tidy_tvs) = mapAccumL tidyTyVar emptyTidyEnv sig_tyvars + (env2, tidy_tys) = tidyOpenTypes env1 sig_tys + + main_msg = ptext SLIT("Inferred type is less polymorphic than expected") + + check (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 (tidy_env, acc, unify_msg sig_tyvar (ppr ty) : msgs) ; + + Just tv -> + + case lookupVarEnv acc tv of { + Just sig_tyvar' -> -- Error (b) or (d)! + returnNF_Tc (tidy_env, acc, unify_msg sig_tyvar (ppr sig_tyvar') : msgs) ; + + Nothing -> + + if tv `elemVarSet` globals -- Error (c)! Type variable escapes + -- The least comprehensible, so put it last + -- 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 (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) + | isEmptyVarSet (idFreeTyVars id) + = find_globals tv tidy_env acc ids + + | otherwise + = zonkTcType (idType id) `thenNF_Tc` \ id_ty -> + if tv `elemVarSet` tyVarsOfType id_ty then + let + (tidy_env', id_ty') = tidyOpenType tidy_env id_ty + acc' = (idName id, id_ty') : acc + in + find_globals tv tidy_env' acc' ids + else + find_globals tv tidy_env acc ids + +find_frees tv tidy_env acc [] + = returnNF_Tc (tidy_env, acc) +find_frees tv tidy_env acc (ftv:ftvs) + = zonkTcTyVar ftv `thenNF_Tc` \ ty -> + if tv `elemVarSet` tyVarsOfType ty then + let + (tidy_env', ftv') = tidyTyVar tidy_env ftv + in + find_frees tv tidy_env' (ftv':acc) ftvs + else + find_frees tv tidy_env acc ftvs + + +escape_msg sig_tv tv globs frees + = mk_msg sig_tv <+> ptext SLIT("escapes") $$ + if not (null globs) then + vcat [pp_it <+> ptext SLIT("is mentioned in the environment"), + ptext SLIT("The following variables in the environment mention") <+> quotes (ppr tv), + nest 2 (vcat_first 10 [ppr name <+> dcolon <+> ppr ty | (name,ty) <- globs]) + ] + else if not (null frees) then + vcat [ptext SLIT("It is reachable from the type variable(s)") <+> pprQuotedList frees, + nest 2 (ptext SLIT("which") <+> is_are <+> ptext SLIT("free in the signature")) + ] + else + empty -- Sigh. It's really hard to give a good error message + -- all the time. One bad case is an existential pattern match where - err arity = arityErr "Type synonym constructor" name arity n_args + is_are | isSingleton frees = ptext SLIT("is") + | otherwise = ptext SLIT("are") + pp_it | sig_tv /= tv = ptext SLIT("It unifies with") <+> quotes (ppr tv) <> comma <+> ptext SLIT("which") + | otherwise = ptext SLIT("It") + + vcat_first :: Int -> [SDoc] -> SDoc + vcat_first n [] = empty + vcat_first 0 (x:xs) = text "...others omitted..." + vcat_first n (x:xs) = x $$ vcat_first (n-1) xs + +unify_msg tv thing = mk_msg tv <+> ptext SLIT("is unified with") <+> quotes thing +mk_msg tv = ptext SLIT("Quantified type variable") <+> quotes (ppr tv) \end{code} -Errors and contexts -~~~~~~~~~~~~~~~~~~~ +These two context are used with checkSigTyVars + +\begin{code} +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_sig_tyvars) = tidyTyVars tidy_env sig_tyvars + (env2, tidy_sig_rho) = tidyOpenType env1 (mkRhoTy sig_theta sig_tau) + (env3, tidy_actual_tau) = tidyOpenType env2 actual_tau + msg = vcat [ptext SLIT("Signature type: ") <+> pprType (mkForAllTys tidy_sig_tyvars tidy_sig_rho), + ptext SLIT("Type to generalise:") <+> pprType tidy_actual_tau, + when + ] + in + returnNF_Tc (env3, msg) + +sigPatCtxt bound_tvs bound_ids tidy_env + = returnNF_Tc (env1, + sep [ptext SLIT("When checking a pattern that binds"), + nest 4 (vcat (zipWith ppr_id show_ids tidy_tys))]) + where + show_ids = filter is_interesting bound_ids + is_interesting id = any (`elemVarSet` idFreeTyVars id) bound_tvs + + (env1, tidy_tys) = tidyOpenTypes tidy_env (map idType show_ids) + ppr_id id ty = ppr id <+> dcolon <+> ppr ty + -- Don't zonk the types so we get the separate, un-unified versions +\end{code} + + +%************************************************************************ +%* * +\subsection{Errors and contexts} +%* * +%************************************************************************ + \begin{code} -naughtyCCallContextErr clas_name sty - = ppSep [ppStr "Can't use class", ppr sty clas_name, ppStr "in a context"] +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)), + ptext SLIT("is a type")] + +appKindCtxt :: SDoc -> Message +appKindCtxt pp = ptext SLIT("When checking kinds in") <+> quotes pp + +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") + +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)) + ] + +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}