\begin{code}
module TcMonoType ( tcHsType, tcHsRecType, tcIfaceType,
tcHsSigType, tcHsLiftedSigType,
- tcRecClassContext, checkAmbiguity,
+ tcRecTheta, checkAmbiguity,
-- Kind checking
kcHsTyVar, kcHsTyVars, mkTyClTyVars,
mkArrowKinds, getTyVar_maybe, getTyVar, splitFunTy_maybe,
tidyOpenType, tidyOpenTypes, tidyTyVar, tidyTyVars,
tyVarsOfType, tyVarsOfPred, mkForAllTys,
- classesOfPreds, isUnboxedTupleType, isForAllTy
+ isUnboxedTupleType, isForAllTy, isIPPred
)
-import PprType ( pprType, pprPred )
+import PprType ( pprType, pprTheta, pprPred )
import Subst ( mkTopTyVarSubst, substTy )
import CoreFVs ( idFreeTyVars )
-import Id ( mkVanillaId, idName, idType )
+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 Class ( classArity, classTyCon )
import Name ( Name )
import TysWiredIn ( mkListTy, mkTupleTy, genUnitTyCon )
import BasicTypes ( Boxity(..), RecFlag(..), isRec )
kcHsContext ctxt = mapTc_ kcHsPred ctxt
kcHsPred :: RenamedHsPred -> TcM ()
-kcHsPred pred@(HsPIParam name ty)
+kcHsPred pred@(HsIParam name ty)
= tcAddErrCtxt (appKindCtxt (ppr pred)) $
kcLiftedType ty
-kcHsPred pred@(HsPClass cls tys)
+kcHsPred pred@(HsClassP cls tys)
= tcAddErrCtxt (appKindCtxt (ppr pred)) $
kcClass cls `thenTc` \ kind ->
mapTc kcHsType tys `thenTc` \ arg_kinds ->
kind_check = kcHsContext ctxt `thenTc_` kcHsType ty
in
tcHsTyVars tv_names kind_check $ \ tyvars ->
- tc_context wimp_out ctxt `thenTc` \ theta ->
+ tcRecTheta wimp_out ctxt `thenTc` \ theta ->
-- Context behaves like a function type
-- This matters. Return-unboxed-tuple analysis can
Contexts
~~~~~~~~
\begin{code}
-tcRecClassContext :: RecFlag -> RenamedContext -> TcM ClassContext
+tcRecTheta :: RecFlag -> RenamedContext -> TcM ThetaType
-- 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)
+tcRecTheta wimp_out context = mapTc (tc_pred wimp_out) context
-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)
+tc_pred wimp_out assn@(HsClassP 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)
+ returnTc (ClassP clas arg_tys)
where
arity = classArity clas
n_tys = length tys
other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name)
-tc_pred wimp_out assn@(HsPIParam name ty)
+tc_pred wimp_out assn@(HsIParam name ty)
= tcAddErrCtxt (appKindCtxt (ppr assn)) $
tc_arg_type wimp_out ty `thenTc` \ arg_ty ->
returnTc (IParam name arg_ty)
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 sigma_ty) `thenTc_`
- checkTc (is_ip pred || not all_free) (freeErr pred sigma_ty)
+ 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
- is_ip (IParam _ _) = True
- is_ip _ = False
\end{code}
%************************************************************************
= 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 TcSigInfo
-- 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) ;
+ 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 (tidy_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
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}
pp_thing (ATcId _) = ptext SLIT("Local identifier")
pp_thing (AThing _) = ptext SLIT("Utterly bogus")
-ambigErr pred ty
+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("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 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))
+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
projects / ghc-hetmet.git / blobdiff