import TcHsSyn ( TcId )
import TcMonad
-import TcEnv ( tcExtendTyVarEnv, tcLookupTy, tcGetValueEnv, tcGetInScopeTyVars,
- tcExtendUVarEnv, tcLookupUVar,
- tcGetGlobalTyVars, valueEnvIds,
- TyThing(..), tcExtendKindEnv
+import TcEnv ( tcExtendTyVarEnv, tcExtendKindEnv,
+ tcLookup, tcLookupGlobal,
+ tcGetEnv, tcEnvTyVars, tcEnvTcIds,
+ tcGetGlobalTyVars,
+ TyThing(..)
)
import TcType ( TcType, TcKind, TcTyVar, TcThetaType, TcTauType,
newKindVar, tcInstSigVar,
mkArrowKinds, getTyVar_maybe, getTyVar, splitFunTy_maybe,
tidyOpenType, tidyOpenTypes, tidyTyVar, tidyTyVars,
tyVarsOfType, tyVarsOfPred, mkForAllTys,
- classesOfPreds, isUnboxedTupleType, isForAllTy
+ classesOfPreds, isUnboxedTupleType
)
import PprType ( pprType, pprPred )
import Subst ( mkTopTyVarSubst, substTy )
import Id ( mkVanillaId, idName, idType, idFreeTyVars )
-import Var ( TyVar, mkTyVar, tyVarKind, mkNamedUVar )
+import Var ( TyVar, mkTyVar, tyVarKind )
import VarEnv
import VarSet
import ErrUtils ( Message )
\begin{code}
tcHsTyVars :: [HsTyVarBndr Name]
- -> TcM s a -- The kind checker
- -> ([TyVar] -> TcM s b)
- -> TcM s b
+ -> 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!
tcExtendTyVarEnv tyvars (thing_inside tyvars)
tcTyVars :: [Name]
- -> TcM s a -- The kind checker
- -> TcM s [TyVar]
+ -> TcM a -- The kind checker
+ -> TcM [TyVar]
tcTyVars [] kind_check = returnTc []
tcTyVars tv_names kind_check
\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) = newNamedKindVar name
kcHsTyVar (IfaceTyVar name kind) = returnNF_Tc (name, kind)
returnNF_Tc (name, kind)
---------------------------
-kcBoxedType :: RenamedHsType -> TcM s ()
+kcBoxedType :: RenamedHsType -> TcM ()
-- The type ty must be a *boxed* *type*
kcBoxedType ty
= kcHsType ty `thenTc` \ kind ->
unifyKind boxedTypeKind kind
---------------------------
-kcTypeType :: RenamedHsType -> TcM s ()
+kcTypeType :: RenamedHsType -> TcM ()
-- The type ty must be a *type*, but it can be boxed or unboxed.
kcTypeType ty
= kcHsType ty `thenTc` \ kind ->
unifyOpenTypeKind kind
---------------------------
-kcHsSigType, kcHsBoxedSigType :: RenamedHsType -> TcM s ()
+kcHsSigType, kcHsBoxedSigType :: RenamedHsType -> TcM ()
-- Used for type signatures
kcHsSigType = kcTypeType
kcHsBoxedSigType = kcBoxedType
---------------------------
-kcHsType :: RenamedHsType -> TcM s TcKind
+kcHsType :: RenamedHsType -> TcM TcKind
kcHsType (HsTyVar name) = kcTyVar name
kcHsType (HsUsgTy _ ty) = kcHsType ty
kcHsType (HsUsgForAllTy _ ty) = kcHsType ty
returnTc boxedTypeKind
---------------------------
-kcTyVar 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)
-
----------------------------
-kcFunResType :: RenamedHsType -> TcM s TcKind
+kcFunResType :: RenamedHsType -> TcM TcKind
-- The only place an unboxed tuple type is allowed
-- is at the right hand end of an arrow
kcFunResType (HsTupleTy (HsTupCon _ Unboxed) tys)
---------------------------
kcHsContext ctxt = mapTc_ kcHsPred ctxt
-kcHsPred :: RenamedHsPred -> TcM s ()
+kcHsPred :: RenamedHsPred -> TcM ()
kcHsPred pred@(HsPIParam name ty)
= tcAddErrCtxt (appKindCtxt (ppr pred)) $
kcBoxedType ty
kcHsPred pred@(HsPClass 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 ->
+ 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}
%************************************************************************
so the kind returned is indeed a Kind not a TcKind
\begin{code}
-tcHsSigType :: RenamedHsType -> TcM s TcType
+tcHsSigType :: RenamedHsType -> TcM TcType
tcHsSigType ty
= kcTypeType ty `thenTc_`
tcHsType ty `thenTc` \ ty' ->
returnTc (hoistForAllTys ty')
-tcHsBoxedSigType :: RenamedHsType -> TcM s Type
+tcHsBoxedSigType :: RenamedHsType -> TcM Type
tcHsBoxedSigType ty
= kcBoxedType ty `thenTc_`
tcHsType ty `thenTc` \ ty' ->
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
\begin{code}
-tcHsType :: RenamedHsType -> TcM s Type
+tcHsType :: RenamedHsType -> TcM Type
tcHsType ty@(HsTyVar name)
= tc_app ty []
tcHsType (HsListTy ty)
- = tcHsArgType ty `thenTc` \ tau_ty ->
+ = tcHsType ty `thenTc` \ tau_ty ->
returnTc (mkListTy tau_ty)
tcHsType (HsTupleTy (HsTupCon _ boxity) tys)
- = mapTc tcHsArgType tys `thenTc` \ tau_tys ->
+ = mapTc tcHsType tys `thenTc` \ tau_tys ->
returnTc (mkTupleTy boxity (length tys) tau_tys)
tcHsType (HsFunTy ty1 ty2)
= ASSERT(n== 1)
returnTc (mkTyConApp genUnitTyCon [])
-tcHsType (HsOpTy ty1 op ty2)
- = tcHsArgType ty1 `thenTc` \ tau_ty1 ->
- tcHsArgType ty2 `thenTc` \ tau_ty2 ->
- tc_fun_type op [tau_ty1,tau_ty2]
+tcHsType (HsOpTy ty1 op ty2) =
+ tcHsType ty1 `thenTc` \ tau_ty1 ->
+ tcHsType ty2 `thenTc` \ tau_ty2 ->
+ tc_fun_type op [tau_ty1,tau_ty2]
tcHsType (HsAppTy ty1 ty2)
= tc_app ty1 [ty2]
= tcClassAssertion True pred `thenTc` \ pred' ->
returnTc (mkPredTy pred')
-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)
-
-tcHsType (HsUsgForAllTy uv_name ty)
- = let
- uv = mkNamedUVar uv_name
- in
- tcExtendUVarEnv uv_name uv $
- tcHsType ty `thenTc` \ tc_ty ->
- returnTc (mkUsForAllTy uv tc_ty)
-
tcHsType full_ty@(HsForAllTy (Just tv_names) ctxt ty)
= let
kind_check = kcHsContext ctxt `thenTc_` kcFunResType ty
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
\begin{code}
-tc_app :: RenamedHsType -> [RenamedHsType] -> TcM s Type
+tc_app :: RenamedHsType -> [RenamedHsType] -> TcM Type
tc_app (HsAppTy ty1 ty2) tys
= tc_app ty1 (ty2:tys)
tc_app ty tys
= tcAddErrCtxt (appKindCtxt pp_app) $
- mapTc tcHsArgType tys `thenTc` \ arg_tys ->
+ mapTc tcHsType tys `thenTc` \ arg_tys ->
case ty of
HsTyVar fun -> tc_fun_type fun arg_tys
other -> tcHsType ty `thenTc` \ fun_ty ->
where
pp_app = ppr ty <+> sep (map pprParendHsType tys)
-tcHsArgType arg_ty -- Check that the argument of a type appplication
- -- isn't a for-all type
- = tcHsType arg_ty `thenTc` \ arg_ty' ->
- checkTc (not (isForAllTy arg_ty'))
- (argTyErr arg_ty) `thenTc_`
- returnTc arg_ty'
-
-- (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
- = tcLookupTy name `thenTc` \ thing ->
+ = 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))
+ 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
Contexts
~~~~~~~~
\begin{code}
-tcClassContext :: RenamedContext -> TcM s ClassContext
+tcClassContext :: RenamedContext -> TcM ClassContext
-- Used when we are expecting a ClassContext (i.e. no implicit params)
tcClassContext context
= tcContext context `thenTc` \ theta ->
returnTc (classesOfPreds theta)
-tcContext :: RenamedContext -> TcM s ThetaType
+tcContext :: RenamedContext -> TcM ThetaType
tcContext context = mapTc (tcClassAssertion False) context
tcClassAssertion ccall_ok assn@(HsPClass class_name tys)
= tcAddErrCtxt (appKindCtxt (ppr assn)) $
- mapTc tcHsArgType tys `thenTc` \ arg_tys ->
- tcLookupTy class_name `thenTc` \ thing ->
+ mapTc tcHsType 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)
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)
= tcAddErrCtxt (appKindCtxt (ppr assn)) $
\begin{code}
-tcTySig :: RenamedSig -> TcM s TcSigInfo
+tcTySig :: RenamedSig -> TcM TcSigInfo
tcTySig (Sig v ty src_loc)
= tcAddSrcLoc src_loc $
mkTcSig (mkVanillaId 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
-> 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
+ -> TcM [TcTyVar] -- Zonked signature type variables
checkSigTyVars [] free = returnTc []
-- 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)
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) ->
+ then tcGetEnv `thenNF_Tc` \ env ->
+ find_globals tv env [] (tcEnvTcIds) `thenNF_Tc` \ (env1, globs) ->
find_frees tv env1 [] (varSetElems free_tyvars) `thenNF_Tc` \ (env2, frees) ->
returnNF_Tc (env2, acc, escape_msg sig_tyvar tv globs frees : msgs)
\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
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")
+ 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),
unboxedTupleErr ty
= sep [ptext (SLIT("Illegal unboxed tuple as a function or contructor argument:")), nest 4 (ppr ty)]
-
-argTyErr ty = ptext SLIT("Illegal polymorphic type as argument:") <+> ppr ty
\end{code}
projects / ghc-hetmet.git / blobdiff