\section[TcMonoType]{Typechecking user-specified @MonoTypes@}
\begin{code}
-module TcMonoType ( tcHsType, tcHsRecType,
- tcHsSigType, tcHsBoxedSigType,
- tcRecClassContext, checkAmbiguity,
+module TcMonoType ( tcHsType, tcHsRecType, tcIfaceType,
+ tcHsSigType, tcHsLiftedSigType,
+ tcRecTheta, checkAmbiguity,
-- Kind checking
kcHsTyVar, kcHsTyVars, mkTyClTyVars,
- kcHsType, kcHsSigType, kcHsBoxedSigType, kcHsContext,
+ kcHsType, kcHsSigType, kcHsLiftedSigType, kcHsContext,
tcTyVars, tcHsTyVars, mkImmutTyVars,
TcSigInfo(..), tcTySig, mkTcSig, maybeSig,
newKindVar, tcInstSigVar,
zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar
)
-import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToIdBndr,
- instFunDeps, instFunDepsOfTheta )
-import FunDeps ( tyVarFunDep, oclose )
+import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToId )
+import FunDeps ( grow )
import TcUnify ( unifyKind, unifyOpenTypeKind )
-import Type ( Type, Kind, PredType(..), ThetaType,
+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, tyVarsOfPred, mkForAllTys,
- classesOfPreds, isUnboxedTupleType, isForAllTy
+ isUnboxedTupleType, isForAllTy, isIPPred
)
-import PprType ( pprType, pprPred )
+import PprType ( pprType, pprTheta, pprPred )
import Subst ( mkTopTyVarSubst, substTy )
-import Id ( mkVanillaId, idName, idType, idFreeTyVars )
+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, isLocallyDefined )
+import Class ( 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 )
returnNF_Tc (name, kind)
---------------------------
-kcBoxedType :: RenamedHsType -> TcM ()
- -- 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 ()
- -- The type ty must be a *type*, but it can be boxed or unboxed.
+ -- 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 ()
+kcHsSigType, kcHsLiftedSigType :: RenamedHsType -> TcM ()
-- Used for type signatures
kcHsSigType = kcTypeType
-kcHsBoxedSigType = kcBoxedType
+kcHsLiftedSigType = kcLiftedType
---------------------------
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 _ boxity) tys)
+kcHsType (HsTupleTy (HsTupCon _ boxity _) tys)
= mapTc kcTypeType tys `thenTc_`
returnTc (case boxity of
- Boxed -> boxedTypeKind
- Unboxed -> unboxedTypeKind)
+ 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 (HsPredTy pred)
= kcHsPred pred `thenTc_`
- returnTc boxedTypeKind
+ returnTc liftedTypeKind
kcHsType ty@(HsAppTy ty1 ty2)
= kcHsType ty1 `thenTc` \ tc_kind ->
tcExtendKindEnv kind_env $
kcHsContext context `thenTc_`
kcHsType ty `thenTc_`
- returnTc boxedTypeKind
+ returnTc liftedTypeKind
---------------------------
kcAppKind fun_kind arg_kind
kcHsContext ctxt = mapTc_ kcHsPred ctxt
kcHsPred :: RenamedHsPred -> TcM ()
-kcHsPred pred@(HsPIParam name ty)
+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)) $
kcClass cls `thenTc` \ kind ->
mapTc kcHsType tys `thenTc` \ arg_kinds ->
- unifyKind kind (mkArrowKinds arg_kinds boxedTypeKind)
+ unifyKind kind (mkArrowKinds arg_kinds liftedTypeKind)
---------------------------
kcTyVar name -- Could be a tyvar or a tycon
%* *
%************************************************************************
-tcHsSigType and tcHsBoxedSigType
+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
so the kind returned is indeed a Kind not a TcKind
\begin{code}
-tcHsSigType, tcHsBoxedSigType :: RenamedHsType -> TcM Type
+tcHsSigType, tcHsLiftedSigType :: 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
+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}
= tc_arg_type wimp_out ty `thenTc` \ tau_ty ->
returnTc (mkListTy tau_ty)
-tc_type wimp_out (HsTupleTy (HsTupCon _ boxity) tys)
- = mapTc tc_tup_arg tys `thenTc` \ tau_tys ->
- returnTc (mkTupleTy boxity (length tys) tau_tys)
+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
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)
-
-tc_context :: RecFlag -> RenamedContext -> TcM ThetaType
-tc_context wimp_out context = mapTc (tc_pred wimp_out) context
+tcRecTheta 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)
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_`
where
sigma_ty = mkSigmaTy forall_tyvars theta tau
tau_vars = tyVarsOfType tau
- fds = instFunDepsOfTheta theta
- tvFundep = tyVarFunDep fds
- extended_tau_vars = oclose tvFundep tau_vars
+ 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 `elemUFM` extended_tau_vars)
+ 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
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}
\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 [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
= 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
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("Each forall'd type variable mentioned by the constraint must appear after the =>"))]
+ 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
+freeErr pred ppr_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("in the type") <+> quotes ppr_ty)
]
polyArgTyErr ty = ptext SLIT("Illegal polymorphic type as argument:") <+> ppr ty