X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcMonoType.lhs;h=fb575aba627867d7eed7620df3851b5c495cb160;hb=cbb5beb0ecef58ae6e47fa62e144a0855644f50a;hp=35f8353323c520437aaeb34702073d08bbd08ff4;hpb=26741ec416bae2c502ef00a2ba0e79050a32cb67;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcMonoType.lhs b/ghc/compiler/typecheck/TcMonoType.lhs index 35f8353..fb575ab 100644 --- a/ghc/compiler/typecheck/TcMonoType.lhs +++ b/ghc/compiler/typecheck/TcMonoType.lhs @@ -1,195 +1,721 @@ % -% (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 ( tcHsSigType, tcHsType, tcIfaceType, tcHsTheta, tcHsPred, + UserTypeCtxt(..), -module TcMonoType ( tcPolyType, tcMonoType, tcMonoTypeKind, tcContext ) where + -- Kind checking + kcHsTyVar, kcHsTyVars, mkTyClTyVars, + kcHsType, kcHsSigType, kcHsSigTypes, + kcHsLiftedSigType, kcHsContext, + tcAddScopedTyVars, tcHsTyVars, mkImmutTyVars, -IMP_Ubiq(){-uitous-} + TcSigInfo(..), tcTySig, mkTcSig, maybeSig, tcSigPolyId, tcSigMonoId + ) where -import HsSyn ( PolyType(..), MonoType(..), Fake ) -import RnHsSyn ( RenamedPolyType(..), RenamedMonoType(..), - RenamedContext(..), RnName(..) - ) +#include "HsVersions.h" +import HsSyn ( HsType(..), HsTyVarBndr(..), HsTyOp(..), + Sig(..), HsPred(..), pprParendHsType, HsTupCon(..), hsTyVarNames ) +import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig, extractHsTyVars ) +import TcHsSyn ( TcId ) -import TcMonad hiding ( rnMtoTcM ) -import TcEnv ( tcLookupTyVar, tcLookupClass, tcLookupTyCon, - tcTyVarScope, tcTyVarScopeGivenKinds +import TcRnMonad +import TcEnv ( tcExtendTyVarEnv, tcLookup, tcLookupGlobal, + TyThing(..), TcTyThing(..), tcExtendKindEnv, + getInLocalScope ) -import TcKind ( TcKind, mkTcTypeKind, mkBoxedTypeKind, - mkTcArrowKind, unifyKind, newKindVar, - kindToTcKind +import TcMType ( newMutTyVar, newKindVar, zonkKindEnv, tcInstType, + checkValidType, UserTypeCtxt(..), pprUserTypeCtxt ) -import Type ( GenType, SYN_IE(Type), SYN_IE(ThetaType), - mkTyVarTy, mkTyConTy, mkFunTy, mkAppTy, mkSynTy, - mkSigmaTy +import TcUnify ( unifyKind, unifyOpenTypeKind ) +import TcType ( Type, Kind, SourceType(..), ThetaType, TyVarDetails(..), + TcTyVar, TcKind, TcThetaType, TcTauType, + mkTyVarTy, mkTyVarTys, mkFunTy, + zipFunTys, mkForAllTys, mkFunTys, tcEqType, isPredTy, + mkSigmaTy, mkPredTy, mkGenTyConApp, mkTyConApp, mkAppTys, + liftedTypeKind, unliftedTypeKind, mkArrowKind, + mkArrowKinds, tcSplitFunTy_maybe, tcSplitForAllTys ) -import TyVar ( GenTyVar, SYN_IE(TyVar) ) -import Type ( mkDictTy ) -import Class ( cCallishClassKeys ) -import TyCon ( TyCon ) -import TysWiredIn ( mkListTy, mkTupleTy ) -import Unique ( Unique ) -import PprStyle -import Pretty -import RnHsSyn ( isRnLocal, isRnClass, isRnTyCon, - RnName{-instance NamedThing-} - ) -import Util ( zipWithEqual, panic, pprPanic{-ToDo:rm-} ) +import Inst ( Inst, InstOrigin(..), newMethodWith, instToId ) + +import Id ( mkLocalId, idName, idType ) +import Var ( TyVar, mkTyVar, tyVarKind ) +import ErrUtils ( Message ) +import TyCon ( TyCon, tyConKind ) +import Class ( classTyCon ) +import Name ( Name ) +import NameSet +import Subst ( deShadowTy ) +import TysWiredIn ( mkListTy, mkPArrTy, mkTupleTy, genUnitTyCon ) +import BasicTypes ( Boxity(..) ) +import SrcLoc ( SrcLoc ) +import Util ( lengthIs ) +import Outputable +import List ( nubBy ) \end{code} -tcMonoType and tcMonoTypeKind -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\subsection{Checking types} +%* * +%************************************************************************ -tcMonoType checks that the type really is of kind Type! +Generally speaking we now type-check types in three phases -\begin{code} -tcMonoType :: RenamedMonoType -> TcM s Type + 1. Kind check the HsType [kcHsType] + 2. Convert from HsType to Type, and hoist the foralls [tcHsType] + 3. Check the validity of the resulting type [checkValidType] -tcMonoType ty - = tcMonoTypeKind ty `thenTc` \ (kind,ty) -> - unifyKind kind mkTcTypeKind `thenTc_` - returnTc ty +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 = addErrCtxt (checkTypeCtxt ctxt ty) ( + kcTypeType ty `thenM_` + tcHsType ty + ) `thenM` \ ty' -> + checkValidType ctxt ty' `thenM_` + returnM ty' + +checkTypeCtxt ctxt ty + = vcat [ptext SLIT("In the type:") <+> ppr ty, + ptext SLIT("While checking") <+> pprUserTypeCtxt ctxt ] + +tcHsType :: RenamedHsType -> TcM Type + -- Don't do kind checking, nor validity checking, + -- but do hoist for-alls to the top + -- This is used in type and class decls, where kinding is + -- done in advance, and validity checking is done later + -- [Validity checking done later because of knot-tying issues.] +tcHsType ty = tc_type ty `thenM` \ ty' -> + returnM (hoistForAllTys ty') + +tcHsTheta :: RenamedContext -> TcM ThetaType +-- Used when we are expecting a ClassContext (i.e. no implicit params) +-- Does not do validity checking, like tcHsType +tcHsTheta hs_theta = mappM tc_pred hs_theta + +-- In interface files the type is already kinded, +-- and we definitely don't want to hoist for-alls. +-- Otherwise we'll change +-- dmfail :: forall m:(*->*) Monad m => forall a:* => String -> m a +-- into +-- dmfail :: forall m:(*->*) a:* Monad m => String -> m a +-- which definitely isn't right! +tcIfaceType ty = tc_type ty \end{code} -tcMonoTypeKind does the real work. It returns a kind and a type. + +%************************************************************************ +%* * +\subsection{Kind checking} +%* * +%************************************************************************ + +Kind checking +~~~~~~~~~~~~~ +When we come across the binding site for some type variables, we +proceed in two stages + +1. Figure out what kind each tyvar has + +2. Create suitably-kinded tyvars, + extend the envt, + and typecheck the body + +To do step 1, we proceed thus: + +1a. Bind each type variable to a kind variable +1b. Apply the kind checker +1c. Zonk the resulting kinds + +The kind checker is passed to tcHsTyVars as an argument. + +For example, when we find + (forall a m. m a -> m a) +we bind a,m to kind varibles and kind-check (m a -> m a). This +makes a get kind *, and m get kind *->*. Now we typecheck (m a -> m a) +in an environment that binds a and m suitably. + +The kind checker passed to tcHsTyVars needs to look at enough to +establish the kind of the tyvar: + * For a group of type and class decls, it's just the group, not + the rest of the program + * For a tyvar bound in a pattern type signature, its the types + mentioned in the other type signatures in that bunch of patterns + * For a tyvar bound in a RULE, it's the type signatures on other + universally quantified variables in the rule + +Note that this may occasionally give surprising results. For example: + + data T a b = MkT (a b) + +Here we deduce a::*->*, b::*. +But equally valid would be + a::(*->*)-> *, b::*->* + +\begin{code} +-- tcHsTyVars is used for type variables in type signatures +-- e.g. forall a. a->a +-- They are immutable, because they scope only over the signature +-- They may or may not be explicitly-kinded +tcHsTyVars :: [HsTyVarBndr Name] + -> TcM a -- The kind checker + -> ([TyVar] -> TcM b) + -> TcM b + +tcHsTyVars [] kind_check thing_inside = thing_inside [] + -- A useful short cut for a common case! + +tcHsTyVars tv_names kind_check thing_inside + = kcHsTyVars tv_names `thenM` \ tv_names_w_kinds -> + tcExtendKindEnv tv_names_w_kinds kind_check `thenM_` + zonkKindEnv tv_names_w_kinds `thenM` \ tvs_w_kinds -> + let + tyvars = mkImmutTyVars tvs_w_kinds + in + tcExtendTyVarEnv tyvars (thing_inside tyvars) + + + +tcAddScopedTyVars :: [RenamedHsType] -> TcM a -> TcM a +-- tcAddScopedTyVars is used for scoped type variables +-- added by pattern type signatures +-- e.g. \ (x::a) (y::a) -> x+y +-- They never have explicit kinds (because this is source-code only) +-- They are mutable (because they can get bound to a more specific type) + +-- Find the not-already-in-scope signature type variables, +-- kind-check them, and bring them into scope +-- +-- We no longer specify that these type variables must be univerally +-- quantified (lots of email on the subject). If you want to put that +-- back in, you need to +-- a) Do a checkSigTyVars after thing_inside +-- b) More insidiously, don't pass in expected_ty, else +-- we unify with it too early and checkSigTyVars barfs +-- Instead you have to pass in a fresh ty var, and unify +-- it with expected_ty afterwards +tcAddScopedTyVars [] thing_inside + = thing_inside -- Quick get-out for the empty case + +tcAddScopedTyVars sig_tys thing_inside + = getInLocalScope `thenM` \ in_scope -> + let + all_sig_tvs = foldr (unionNameSets . extractHsTyVars) emptyNameSet sig_tys + sig_tvs = filter (not . in_scope) (nameSetToList all_sig_tvs) + in + mappM newNamedKindVar sig_tvs `thenM` \ kind_env -> + tcExtendKindEnv kind_env (kcHsSigTypes sig_tys) `thenM_` + zonkKindEnv kind_env `thenM` \ tvs_w_kinds -> + sequenceM [ newMutTyVar name kind PatSigTv + | (name, kind) <- tvs_w_kinds] `thenM` \ tyvars -> + tcExtendTyVarEnv tyvars thing_inside +\end{code} + \begin{code} -tcMonoTypeKind :: RenamedMonoType -> TcM s (TcKind s, Type) +kcHsTyVar :: HsTyVarBndr name -> TcM (name, TcKind) +kcHsTyVars :: [HsTyVarBndr name] -> TcM [(name, TcKind)] + +kcHsTyVar (UserTyVar name) = newNamedKindVar name +kcHsTyVar (IfaceTyVar name kind) = returnM (name, kind) + +kcHsTyVars tvs = mappM kcHsTyVar tvs + +newNamedKindVar name = newKindVar `thenM` \ kind -> + returnM (name, kind) -tcMonoTypeKind (MonoTyVar name) - = tcLookupTyVar name `thenNF_Tc` \ (kind,tyvar) -> - returnTc (kind, mkTyVarTy tyvar) +--------------------------- +kcLiftedType :: RenamedHsType -> TcM () + -- The type ty must be a *lifted* *type* +kcLiftedType ty + = kcHsType ty `thenM` \ kind -> + addErrCtxt (typeKindCtxt ty) $ + unifyKind liftedTypeKind kind + +--------------------------- +kcTypeType :: RenamedHsType -> TcM () + -- The type ty must be a *type*, but it can be lifted or unlifted. +kcTypeType ty + = kcHsType ty `thenM` \ kind -> + addErrCtxt (typeKindCtxt ty) $ + unifyOpenTypeKind kind + +--------------------------- +kcHsSigType, kcHsLiftedSigType :: RenamedHsType -> TcM () + -- Used for type signatures +kcHsSigType = kcTypeType +kcHsSigTypes tys = mappM_ kcHsSigType tys +kcHsLiftedSigType = kcLiftedType + +--------------------------- +kcHsType :: RenamedHsType -> TcM TcKind +kcHsType (HsTyVar name) = kcTyVar name + +kcHsType (HsKindSig ty k) + = kcHsType ty `thenM` \ k' -> + unifyKind k k' `thenM_` + returnM k + +kcHsType (HsListTy ty) + = kcLiftedType ty `thenM` \ tau_ty -> + returnM liftedTypeKind + +kcHsType (HsPArrTy ty) + = kcLiftedType ty `thenM` \ tau_ty -> + returnM liftedTypeKind + +kcHsType (HsTupleTy (HsTupCon boxity _) tys) + = mappM kcTypeType tys `thenM_` + returnM (case boxity of + Boxed -> liftedTypeKind + Unboxed -> unliftedTypeKind) + +kcHsType (HsFunTy ty1 ty2) + = kcTypeType ty1 `thenM_` + kcTypeType ty2 `thenM_` + returnM liftedTypeKind + +kcHsType (HsOpTy ty1 HsArrow ty2) + = kcTypeType ty1 `thenM_` + kcTypeType ty2 `thenM_` + returnM liftedTypeKind + +kcHsType ty@(HsOpTy ty1 (HsTyOp op) ty2) + = kcTyVar op `thenM` \ op_kind -> + kcHsType ty1 `thenM` \ ty1_kind -> + kcHsType ty2 `thenM` \ ty2_kind -> + addErrCtxt (appKindCtxt (ppr ty)) $ + kcAppKind op_kind ty1_kind `thenM` \ op_kind' -> + kcAppKind op_kind' ty2_kind + +kcHsType (HsParTy ty) -- Skip parentheses markers + = kcHsType ty + +kcHsType (HsNumTy _) -- The unit type for generics + = returnM liftedTypeKind + +kcHsType (HsPredTy pred) + = kcHsPred pred `thenM_` + returnM liftedTypeKind + +kcHsType ty@(HsAppTy ty1 ty2) + = kcHsType ty1 `thenM` \ tc_kind -> + kcHsType ty2 `thenM` \ arg_kind -> + addErrCtxt (appKindCtxt (ppr ty)) $ + kcAppKind tc_kind arg_kind + +kcHsType (HsForAllTy (Just tv_names) context ty) + = kcHsTyVars tv_names `thenM` \ kind_env -> + tcExtendKindEnv kind_env $ + kcHsContext context `thenM_` + kcLiftedType ty `thenM_` + -- The body of a forall must be of kind * + -- In principle, I suppose, we could allow unlifted types, + -- but it seems simpler to stick to lifted types for now. + returnM liftedTypeKind + +--------------------------- +kcAppKind fun_kind arg_kind + = case tcSplitFunTy_maybe fun_kind of + Just (arg_kind', res_kind) + -> unifyKind arg_kind arg_kind' `thenM_` + returnM res_kind + + Nothing -> newKindVar `thenM` \ res_kind -> + unifyKind fun_kind (mkArrowKind arg_kind res_kind) `thenM_` + returnM res_kind + + +--------------------------- +kc_pred :: RenamedHsPred -> TcM TcKind -- Does *not* check for a saturated + -- application (reason: used from TcDeriv) +kc_pred pred@(HsIParam name ty) + = kcHsType ty + +kc_pred pred@(HsClassP cls tys) + = kcClass cls `thenM` \ kind -> + mappM kcHsType tys `thenM` \ arg_kinds -> + newKindVar `thenM` \ kv -> + unifyKind kind (mkArrowKinds arg_kinds kv) `thenM_` + returnM kv + +--------------------------- +kcHsContext ctxt = mappM_ kcHsPred ctxt + +kcHsPred pred -- Checks that the result is of kind liftedType + = addErrCtxt (appKindCtxt (ppr pred)) $ + kc_pred pred `thenM` \ kind -> + unifyKind liftedTypeKind kind `thenM_` + returnM () -tcMonoTypeKind (MonoListTy ty) - = tcMonoType ty `thenTc` \ tau_ty -> - returnTc (mkTcTypeKind, mkListTy tau_ty) + --------------------------- +kcTyVar name -- Could be a tyvar or a tycon + = tcLookup name `thenM` \ thing -> + case thing of + AThing kind -> returnM kind + ATyVar tv -> returnM (tyVarKind tv) + AGlobal (ATyCon tc) -> returnM (tyConKind tc) + other -> failWithTc (wrongThingErr "type" thing name) + +kcClass cls -- Must be a class + = tcLookup cls `thenM` \ thing -> + case thing of + AThing kind -> returnM kind + AGlobal (AClass cls) -> returnM (tyConKind (classTyCon cls)) + other -> failWithTc (wrongThingErr "class" thing cls) +\end{code} -tcMonoTypeKind (MonoTupleTy tys) - = mapTc tcMonoType tys `thenTc` \ tau_tys -> - returnTc (mkTcTypeKind, mkTupleTy (length tys) tau_tys) +%************************************************************************ +%* * +\subsection{tc_type} +%* * +%************************************************************************ -tcMonoTypeKind (MonoFunTy ty1 ty2) - = tcMonoType ty1 `thenTc` \ tau_ty1 -> - tcMonoType ty2 `thenTc` \ tau_ty2 -> - returnTc (mkTcTypeKind, mkFunTy tau_ty1 tau_ty2) +tc_type, the main work horse +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -tcMonoTypeKind (MonoTyApp name tys) - | isRnLocal name -- Must be a type variable - = tcLookupTyVar name `thenNF_Tc` \ (kind,tyvar) -> - tcMonoTyApp kind (mkTyVarTy tyvar) tys + ------------------- + *** BIG WARNING *** + ------------------- - | otherwise {-isRnTyCon name-} -- Must be a type constructor - = tcLookupTyCon name `thenNF_Tc` \ (kind,maybe_arity,tycon) -> - case maybe_arity of - Just arity -> tcSynApp name kind arity tycon tys -- synonum - Nothing -> tcMonoTyApp kind (mkTyConTy tycon) tys -- newtype or data +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. --- | otherwise --- = pprPanic "tcMonoTypeKind:" (ppr PprDebug name) - --- for unfoldings only: -tcMonoTypeKind (MonoForAllTy tyvars_w_kinds ty) - = tcTyVarScopeGivenKinds names tc_kinds (\ tyvars -> - tcMonoTypeKind ty `thenTc` \ (kind, ty') -> - unifyKind kind mkTcTypeKind `thenTc_` - returnTc (mkTcTypeKind, ty') - ) - where - (rn_names, kinds) = unzip tyvars_w_kinds - names = map de_rn rn_names - tc_kinds = map kindToTcKind kinds - de_rn (RnName n) = n - --- 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) + data T a = MkT a [T a] + +While typechecking the [T a] on the RHS, T itself is not yet fully +defined. That in turn places restrictions on what you can check in +tcHsType; if you poke on too much you get a black hole. I keep +forgetting this, hence this warning! + +So tc_type does no validity-checking. Instead that's all done +by TcMType.checkValidType + + -------------------------- + *** END OF BIG WARNING *** + -------------------------- + + +\begin{code} +tc_type :: RenamedHsType -> TcM Type + +tc_type ty@(HsTyVar name) + = tc_app ty [] + +tc_type (HsKindSig ty k) + = tc_type ty -- Kind checking done already + +tc_type (HsListTy ty) + = tc_type ty `thenM` \ tau_ty -> + returnM (mkListTy tau_ty) + +tc_type (HsPArrTy ty) + = tc_type ty `thenM` \ tau_ty -> + returnM (mkPArrTy tau_ty) + +tc_type (HsTupleTy (HsTupCon boxity arity) tys) + = ASSERT( tys `lengthIs` arity ) + tc_types tys `thenM` \ tau_tys -> + returnM (mkTupleTy boxity arity tau_tys) + +tc_type (HsFunTy ty1 ty2) + = tc_type ty1 `thenM` \ tau_ty1 -> + tc_type ty2 `thenM` \ tau_ty2 -> + returnM (mkFunTy tau_ty1 tau_ty2) + +tc_type (HsOpTy ty1 HsArrow ty2) + = tc_type ty1 `thenM` \ tau_ty1 -> + tc_type ty2 `thenM` \ tau_ty2 -> + returnM (mkFunTy tau_ty1 tau_ty2) + +tc_type (HsOpTy ty1 (HsTyOp op) ty2) + = tc_type ty1 `thenM` \ tau_ty1 -> + tc_type ty2 `thenM` \ tau_ty2 -> + tc_fun_type op [tau_ty1,tau_ty2] + +tc_type (HsParTy ty) -- Remove the parentheses markers + = tc_type ty + +tc_type (HsNumTy n) + = ASSERT(n== 1) + returnM (mkTyConApp genUnitTyCon []) + +tc_type (HsAppTy ty1 ty2) = tc_app ty1 [ty2] + +tc_type (HsPredTy pred) + = tc_pred pred `thenM` \ pred' -> + returnM (mkPredTy pred') + +tc_type full_ty@(HsForAllTy (Just tv_names) ctxt ty) + = let + kind_check = kcHsContext ctxt `thenM_` kcHsType ty + in + tcHsTyVars tv_names kind_check $ \ tyvars -> + mappM tc_pred ctxt `thenM` \ theta -> + tc_type ty `thenM` \ tau -> + returnM (mkSigmaTy tyvars theta tau) + +tc_types arg_tys = mappM tc_type arg_tys \end{code} Help functions for type applications ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + \begin{code} -tcMonoTyApp fun_kind fun_ty tys - = mapAndUnzipTc tcMonoTypeKind tys `thenTc` \ (arg_kinds, arg_tys) -> - newKindVar `thenNF_Tc` \ result_kind -> - unifyKind fun_kind (foldr mkTcArrowKind result_kind arg_kinds) `thenTc_` - returnTc (result_kind, foldl mkAppTy fun_ty arg_tys) - -tcSynApp name syn_kind arity tycon tys - = mapAndUnzipTc tcMonoTypeKind tys `thenTc` \ (arg_kinds, arg_tys) -> - newKindVar `thenNF_Tc` \ result_kind -> - unifyKind syn_kind (foldr mkTcArrowKind result_kind arg_kinds) `thenTc_` - - -- Check that it's applied to the right number of arguments - checkTc (arity == n_args) (err arity) `thenTc_` - returnTc (result_kind, mkSynTy tycon arg_tys) +tc_app :: RenamedHsType -> [RenamedHsType] -> TcM Type +tc_app (HsAppTy ty1 ty2) tys + = tc_app ty1 (ty2:tys) + +tc_app ty tys + = addErrCtxt (appKindCtxt pp_app) $ + tc_types tys `thenM` \ arg_tys -> + case ty of + HsTyVar fun -> tc_fun_type fun arg_tys + other -> tc_type ty `thenM` \ fun_ty -> + returnM (mkAppTys fun_ty arg_tys) where - err arity = arityErr "Type synonym constructor" name arity n_args - n_args = length tys + 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 `thenM` \ thing -> + case thing of + ATyVar tv -> returnM (mkAppTys (mkTyVarTy tv) arg_tys) + + AGlobal (ATyCon tc) -> returnM (mkGenTyConApp tc arg_tys) + + other -> failWithTc (wrongThingErr "type constructor" thing name) \end{code} Contexts ~~~~~~~~ \begin{code} +tcHsPred pred = kc_pred pred `thenM_` tc_pred pred + -- Is happy with a partial application, e.g. (ST s) + -- Used from TcDeriv + +tc_pred assn@(HsClassP class_name tys) + = addErrCtxt (appKindCtxt (ppr assn)) $ + tc_types tys `thenM` \ arg_tys -> + tcLookupGlobal class_name `thenM` \ thing -> + case thing of + AClass clas -> returnM (ClassP clas arg_tys) + other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name) + +tc_pred assn@(HsIParam name ty) + = addErrCtxt (appKindCtxt (ppr assn)) $ + tc_type ty `thenM` \ arg_ty -> + returnM (IParam name arg_ty) +\end{code} -tcContext :: RenamedContext -> TcM s ThetaType -tcContext context = mapTc tcClassAssertion context - -tcClassAssertion (class_name, tyvar_name) - = checkTc (canBeUsedInContext class_name) - (naughtyCCallContextErr class_name) `thenTc_` - tcLookupClass class_name `thenNF_Tc` \ (class_kind, clas) -> - tcLookupTyVar tyvar_name `thenNF_Tc` \ (tyvar_kind, tyvar) -> - 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 :: RnName -> Bool -canBeUsedInContext n - = isRnClass n && not (uniqueOf n `elem` cCallishClassKeys) +data TcSigInfo + = TySigInfo + 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 id tyvars theta tau _ inst loc) = + ppr id <+> ptext SLIT("::") <+> ppr tyvars <+> ppr theta <+> ptext SLIT("=>") <+> ppr tau + +tcSigPolyId :: TcSigInfo -> TcId +tcSigPolyId (TySigInfo id _ _ _ _ _ _) = id + +tcSigMonoId :: TcSigInfo -> TcId +tcSigMonoId (TySigInfo _ _ _ _ id _ _) = id + +maybeSig :: [TcSigInfo] -> Name -> Maybe (TcSigInfo) + -- Search for a particular signature +maybeSig [] name = Nothing +maybeSig (sig@(TySigInfo sig_id _ _ _ _ _ _) : sigs) name + | name == idName sig_id = Just sig + | otherwise = maybeSig sigs name \end{code} -Polytypes -~~~~~~~~~ + \begin{code} -tcPolyType :: RenamedPolyType -> TcM s Type -tcPolyType (HsForAllTy tyvar_names context ty) - = tcTyVarScope 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) + = addSrcLoc src_loc $ + tcHsSigType (FunSigCtxt v) ty `thenM` \ sigma_tc_ty -> + mkTcSig (mkLocalId v sigma_tc_ty) src_loc `thenM` \ sig -> + returnM sig + +mkTcSig :: TcId -> SrcLoc -> 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 + tcInstType SigTv (idType poly_id) `thenM` \ (tyvars', theta', tau') -> + + getInstLoc SignatureOrigin `thenM` \ inst_loc -> + newMethodWith inst_loc poly_id + (mkTyVarTys tyvars') + theta' tau' `thenM` \ inst -> + -- We make a Method even if it's not overloaded; no harm + -- But do not extend the LIE! We're just making an Id. + + returnM (TySigInfo poly_id tyvars' theta' tau' + (instToId inst) [inst] src_loc) +\end{code} + + +%************************************************************************ +%* * +\subsection{Errors and contexts} +%* * +%************************************************************************ + + +\begin{code} +hoistForAllTys :: Type -> Type +-- Used for user-written type signatures only +-- Move all the foralls and constraints to the top +-- e.g. T -> forall a. a ==> forall a. T -> a +-- T -> (?x::Int) -> Int ==> (?x::Int) -> T -> Int +-- +-- Also: eliminate duplicate constraints. These can show up +-- when hoisting constraints, notably implicit parameters. +-- +-- We want to 'look through' type synonyms when doing this +-- so it's better done on the Type than the HsType + +hoistForAllTys ty + = let + no_shadow_ty = deShadowTy ty + -- Running over ty with an empty substitution gives it the + -- no-shadowing property. This is important. For example: + -- type Foo r = forall a. a -> r + -- foo :: Foo (Foo ()) + -- Here the hoisting should give + -- foo :: forall a a1. a -> a1 -> () + -- + -- What about type vars that are lexically in scope in the envt? + -- We simply rely on them having a different unique to any + -- binder in 'ty'. Otherwise we'd have to slurp the in-scope-tyvars + -- out of the envt, which is boring and (I think) not necessary. + in + case hoist no_shadow_ty of + (tvs, theta, body) -> mkForAllTys tvs (mkFunTys (nubBy tcEqType theta) body) + -- The 'nubBy' eliminates duplicate constraints, + -- notably implicit parameters where - names = map de_rn tyvar_names - de_rn (RnName n) = n + hoist ty + | (tvs1, body_ty) <- tcSplitForAllTys ty, + not (null tvs1) + = case hoist body_ty of + (tvs2,theta,tau) -> (tvs1 ++ tvs2, theta, tau) + + | Just (arg, res) <- tcSplitFunTy_maybe ty + = let + arg' = hoistForAllTys arg -- Don't forget to apply hoist recursively + in -- to the argument type + if (isPredTy arg') then + case hoist res of + (tvs,theta,tau) -> (tvs, arg':theta, tau) + else + case hoist res of + (tvs,theta,tau) -> (tvs, theta, mkFunTy arg' tau) + + | otherwise = ([], [], ty) \end{code} -Errors and contexts -~~~~~~~~~~~~~~~~~~~ + +%************************************************************************ +%* * +\subsection{Errors and contexts} +%* * +%************************************************************************ + \begin{code} -naughtyCCallContextErr clas_name sty - = ppSep [ppStr "Can't use class", ppr sty clas_name, ppStr "in a context"] +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") \end{code}