\section[TcMonoType]{Typechecking user-specified @MonoTypes@}
\begin{code}
-module TcMonoType ( tcHsType, tcHsRecType,
- tcHsSigType, tcHsLiftedSigType,
- tcRecClassContext, checkAmbiguity,
+module TcMonoType ( tcHsSigType, tcHsType, tcIfaceType, tcHsTheta,
+ UserTypeCtxt(..),
-- Kind checking
kcHsTyVar, kcHsTyVars, mkTyClTyVars,
- kcHsType, kcHsSigType, kcHsLiftedSigType, kcHsContext,
- tcTyVars, tcHsTyVars, mkImmutTyVars,
+ kcHsType, kcHsSigType, kcHsSigTypes,
+ kcHsLiftedSigType, kcHsContext,
+ tcAddScopedTyVars, tcHsTyVars, mkImmutTyVars,
TcSigInfo(..), tcTySig, mkTcSig, maybeSig,
checkSigTyVars, sigCtxt, sigPatCtxt
import HsSyn ( HsType(..), HsTyVarBndr(..),
Sig(..), HsPred(..), pprParendHsType, HsTupCon(..), hsTyVarNames )
-import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig )
+import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig, extractHsTyVars )
import TcHsSyn ( TcId )
import TcMonad
import TcEnv ( tcExtendTyVarEnv, tcLookup, tcLookupGlobal,
- tcGetGlobalTyVars, tcEnvTcIds, tcEnvTyVars,
+ tcGetGlobalTyVars, tcLEnvElts, tcInLocalScope,
TyThing(..), TcTyThing(..), tcExtendKindEnv
)
-import TcType ( TcKind, TcTyVar, TcThetaType, TcTauType,
- newKindVar, tcInstSigVar,
- zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar
+import TcMType ( newKindVar, tcInstSigTyVars,
+ zonkKindEnv, zonkTcType, zonkTcTyVars, zonkTcTyVar,
+ unifyKind, unifyOpenTypeKind,
+ checkValidType, UserTypeCtxt(..), pprUserTypeCtxt
)
-import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToIdBndr,
- instFunDeps, instFunDepsOfTheta )
-import FunDeps ( oclose )
-import TcUnify ( unifyKind, unifyOpenTypeKind )
-import Type ( Type, Kind, PredType(..), ThetaType, SigmaType, TauType,
+import TcType ( Type, Kind, SourceType(..), ThetaType, TyVarDetails(..),
+ TcTyVar, TcTyVarSet, TcType, TcKind, TcThetaType, TcTauType,
mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy,
- zipFunTys, hoistForAllTys,
- mkSigmaTy, mkPredTy, mkTyConApp,
- mkAppTys, splitForAllTys, splitRhoTy, mkRhoTy,
+ tcSplitForAllTys, tcSplitRhoTy,
+ hoistForAllTys, allDistinctTyVars, zipFunTys,
+ mkSigmaTy, mkPredTy, mkTyConApp, mkAppTys, mkRhoTy,
liftedTypeKind, unliftedTypeKind, mkArrowKind,
- mkArrowKinds, getTyVar_maybe, getTyVar, splitFunTy_maybe,
- tidyOpenType, tidyOpenTypes, tidyTyVar, tidyTyVars,
- tyVarsOfType, tyVarsOfPred, mkForAllTys,
- classesOfPreds, isUnboxedTupleType, isForAllTy
+ mkArrowKinds, tcGetTyVar_maybe, tcGetTyVar, tcSplitFunTy_maybe,
+ tidyOpenType, tidyOpenTypes, tidyOpenTyVar, tidyOpenTyVars,
+ tyVarsOfType, mkForAllTys
)
-import PprType ( pprType, pprPred )
+import qualified Type ( getTyVar_maybe )
+
+import Inst ( Inst, InstOrigin(..), newMethodWithGivenTy, instToId )
+import PprType ( pprType )
import Subst ( mkTopTyVarSubst, substTy )
import CoreFVs ( idFreeTyVars )
-import Id ( mkVanillaId, idName, idType )
-import Var ( Id, Var, TyVar, mkTyVar, tyVarKind )
+import Id ( mkLocalId, idName, idType )
+import Var ( Id, Var, TyVar, mkTyVar, tyVarKind, isMutTyVar, mutTyVarDetails )
import VarEnv
import VarSet
import ErrUtils ( Message )
import TyCon ( TyCon, isSynTyCon, tyConArity, tyConKind )
-import Class ( ClassContext, classArity, classTyCon )
-import Name ( Name )
+import Class ( classTyCon )
+import Name ( Name, getSrcLoc )
+import NameSet
import TysWiredIn ( mkListTy, mkTupleTy, genUnitTyCon )
-import UniqFM ( elemUFM )
-import BasicTypes ( Boxity(..), RecFlag(..), isRec )
+import BasicTypes ( Boxity(..) )
import SrcLoc ( SrcLoc )
-import Util ( mapAccumL, isSingleton )
+import Util ( isSingleton, lengthIs )
import Outputable
\end{code}
%************************************************************************
%* *
+\subsection{Checking types}
+%* *
+%************************************************************************
+
+Generally speaking we now type-check types in three phases
+
+ 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]
+
+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 = tcAddErrCtxt (checkTypeCtxt ctxt ty) (
+ kcTypeType ty `thenTc_`
+ tcHsType ty
+ ) `thenTc` \ ty' ->
+ checkValidType ctxt ty' `thenTc_`
+ returnTc 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 `thenTc` \ ty' ->
+ returnTc (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 = mapTc 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}
+
+
+%************************************************************************
+%* *
\subsection{Kind checking}
%* *
%************************************************************************
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)
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]
+
+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
+ = tcGetEnv `thenNF_Tc` \ env ->
+ let
+ all_sig_tvs = foldr (unionNameSets . extractHsTyVars) emptyNameSet sig_tys
+ sig_tvs = filter not_in_scope (nameSetToList all_sig_tvs)
+ not_in_scope tv = not (tcInLocalScope env tv)
+ in
+ mapNF_Tc newNamedKindVar sig_tvs `thenTc` \ kind_env ->
+ tcExtendKindEnv kind_env (kcHsSigTypes sig_tys) `thenTc_`
+ zonkKindEnv kind_env `thenNF_Tc` \ tvs_w_kinds ->
+ listTc [ tcNewMutTyVar name kind PatSigTv
+ | (name, kind) <- tvs_w_kinds] `thenNF_Tc` \ tyvars ->
+ tcExtendTyVarEnv tyvars thing_inside
\end{code}
---------------------------
kcHsSigType, kcHsLiftedSigType :: RenamedHsType -> TcM ()
-- Used for type signatures
-kcHsSigType = kcTypeType
+kcHsSigType = kcTypeType
+kcHsSigTypes tys = mapTc_ kcHsSigType tys
kcHsLiftedSigType = kcLiftedType
---------------------------
kcTypeType ty2 `thenTc_`
returnTc liftedTypeKind
+kcHsType (HsNumTy _) -- The unit type for generics
+ = returnTc liftedTypeKind
+
kcHsType ty@(HsOpTy ty1 op ty2)
= kcTyVar op `thenTc` \ op_kind ->
kcHsType ty1 `thenTc` \ ty1_kind ->
---------------------------
kcAppKind fun_kind arg_kind
- = case splitFunTy_maybe fun_kind of
+ = case tcSplitFunTy_maybe fun_kind of
Just (arg_kind', res_kind)
-> unifyKind arg_kind arg_kind' `thenTc_`
returnTc res_kind
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 ->
%************************************************************************
%* *
-\subsection{Checking types}
-%* *
-%************************************************************************
-
-tcHsSigType and tcHsLiftedSigType
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-tcHsSigType and tcHsLiftedSigType 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}
-tcHsSigType, tcHsLiftedSigType :: RenamedHsType -> TcM Type
- -- Do kind checking, and hoist for-alls to the top
-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
-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}
-
-
-%************************************************************************
-%* *
\subsection{tc_type}
%* *
%************************************************************************
tcHsType; if you poke on too much you get a black hole. I keep
forgetting this, hence this warning!
-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.
+So tc_type does no validity-checking. Instead that's all done
+by TcMType.checkValidType
--------------------------
*** END OF BIG WARNING ***
\begin{code}
-tc_type :: RecFlag -> RenamedHsType -> TcM Type
+tc_type :: RenamedHsType -> TcM Type
-tc_type wimp_out ty@(HsTyVar name)
- = tc_app wimp_out ty []
+tc_type ty@(HsTyVar name)
+ = tc_app ty []
-tc_type wimp_out (HsListTy ty)
- = tc_arg_type wimp_out ty `thenTc` \ tau_ty ->
+tc_type (HsListTy ty)
+ = tc_type 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 ->
+tc_type (HsTupleTy (HsTupCon _ boxity arity) tys)
+ = ASSERT( tys `lengthIs` arity )
+ tc_types tys `thenTc` \ tau_tys ->
returnTc (mkTupleTy boxity arity tau_tys)
- where
- 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 ->
+
+tc_type (HsFunTy ty1 ty2)
+ = tc_type ty1 `thenTc` \ tau_ty1 ->
+ tc_type ty2 `thenTc` \ tau_ty2 ->
returnTc (mkFunTy tau_ty1 tau_ty2)
-tc_type wimp_out (HsNumTy n)
+tc_type (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 (HsOpTy ty1 op ty2)
+ = tc_type ty1 `thenTc` \ tau_ty1 ->
+ tc_type 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 (HsAppTy ty1 ty2) = tc_app ty1 [ty2]
-tc_type wimp_out (HsPredTy pred)
- = tc_pred wimp_out pred `thenTc` \ pred' ->
+tc_type (HsPredTy pred)
+ = tc_pred pred `thenTc` \ pred' ->
returnTc (mkPredTy pred')
-tc_type wimp_out full_ty@(HsForAllTy (Just tv_names) ctxt ty)
+tc_type 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 ->
+ tcHsTyVars tv_names kind_check $ \ tyvars ->
+ mapTc tc_pred ctxt `thenTc` \ theta ->
+ tc_type ty `thenTc` \ tau ->
+ returnTc (mkSigmaTy tyvars theta 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
+tc_types arg_tys = mapTc tc_type 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 :: RenamedHsType -> [RenamedHsType] -> TcM Type
+tc_app (HsAppTy ty1 ty2) tys
+ = tc_app ty1 (ty2:tys)
-tc_app wimp_out ty tys
+tc_app ty tys
= tcAddErrCtxt (appKindCtxt pp_app) $
- tc_arg_types wimp_out tys `thenTc` \ arg_tys ->
+ tc_types tys `thenTc` \ arg_tys ->
case ty of
HsTyVar fun -> tc_fun_type fun arg_tys
- other -> tc_type wimp_out ty `thenTc` \ fun_ty ->
+ other -> tc_type ty `thenTc` \ fun_ty ->
returnNF_Tc (mkAppTys fun_ty arg_tys)
where
pp_app = ppr ty <+> sep (map pprParendHsType tys)
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
+ | isSynTyCon tc -> returnTc (mkSynTy tc arg_tys)
+ | otherwise -> returnTc (mkTyConApp tc 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)
+tc_pred assn@(HsClassP class_name tys)
= tcAddErrCtxt (appKindCtxt (ppr assn)) $
- tc_arg_types wimp_out tys `thenTc` \ arg_tys ->
+ tc_types 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)
+ AClass clas -> returnTc (ClassP clas arg_tys)
+ other -> failWithTc (wrongThingErr "class" (AGlobal thing) class_name)
-tc_pred wimp_out assn@(HsPIParam name ty)
+tc_pred assn@(HsIParam name ty)
= tcAddErrCtxt (appKindCtxt (ppr assn)) $
- tc_arg_type wimp_out ty `thenTc` \ arg_ty ->
+ tc_type ty `thenTc` \ arg_ty ->
returnTc (IParam name arg_ty)
\end{code}
-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).
-
-\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}
%************************************************************************
%* *
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 ->
+ tcHsSigType (FunSigCtxt v) ty `thenTc` \ sigma_tc_ty ->
+ mkTcSig (mkLocalId v sigma_tc_ty) src_loc `thenNF_Tc` \ sig ->
returnTc sig
mkTcSig :: TcId -> SrcLoc -> NF_TcM TcSigInfo
-- 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)
+ (tyvars, rho) = tcSplitForAllTys (idType poly_id)
in
- mapNF_Tc tcInstSigVar tyvars `thenNF_Tc` \ tyvars' ->
+ tcInstSigTyVars SigTv 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'
+
+ (theta', tau') = tcSplitRhoTy rho'
-- This splitRhoTy tries hard to make sure that tau' is a type synonym
-- wherever possible, which can improve interface files.
in
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)
+ returnTc (map (tcGetTyVar "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
+ = -- "check" checks each sig tyvar in turn
foldlNF_Tc check
- (env2, in_scope_env, [])
+ (env2, emptyVarEnv, [])
(tidy_tvs `zip` tidy_tys) `thenNF_Tc` \ (env3, _, msgs) ->
- failWithTcM (env3, main_msg $$ nest 4 (vcat msgs))
+ failWithTcM (env3, main_msg $$ vcat msgs)
where
- (env1, tidy_tvs) = mapAccumL tidyTyVar emptyTidyEnv sig_tyvars
- (env2, tidy_tys) = tidyOpenTypes env1 sig_tys
+ (env1, tidy_tvs) = tidyOpenTyVars emptyTidyEnv sig_tyvars
+ (env2, tidy_tys) = tidyOpenTypes env1 sig_tys
main_msg = ptext SLIT("Inferred type is less polymorphic than expected")
-- 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 {
+ = case tcGetTyVar_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) ;
+ Just sig_tyvar' -> -- Error (b)!
+ 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
+ if tv `elemVarSet` globals -- Error (c) or (d)! Type variable escapes
-- The least comprehensible, so put it last
-- Game plan:
- -- a) get the local TcIds from the environment,
+ -- a) get the local TcIds and TyVars 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_globals tv tidy_env (tcLEnvElts 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)
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.
find_globals :: Var
-> TidyEnv
- -> [(Name,Type)]
- -> [Id]
- -> NF_TcM (TidyEnv,[(Name,Type)])
-
-find_globals tv tidy_env acc []
- = returnNF_Tc (tidy_env, acc)
+ -> [TcTyThing]
+ -> NF_TcM (TidyEnv, [SDoc])
-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_globals tv tidy_env things
+ = go tidy_env [] things
+ where
+ go tidy_env acc [] = returnNF_Tc (tidy_env, acc)
+ go tidy_env acc (thing : things)
+ = find_thing ignore_it tidy_env thing `thenNF_Tc` \ (tidy_env1, maybe_doc) ->
+ case maybe_doc of
+ Just d -> go tidy_env1 (d:acc) things
+ Nothing -> go tidy_env1 acc things
+
+ ignore_it ty = not (tv `elemVarSet` tyVarsOfType ty)
+
+-----------------------
+find_thing ignore_it tidy_env (ATcId id)
+ = zonkTcType (idType id) `thenNF_Tc` \ id_ty ->
+ if ignore_it id_ty then
+ returnNF_Tc (tidy_env, Nothing)
+ else let
+ (tidy_env', tidy_ty) = tidyOpenType tidy_env id_ty
+ msg = sep [ppr id <+> dcolon <+> ppr tidy_ty,
+ nest 2 (parens (ptext SLIT("bound at") <+>
+ ppr (getSrcLoc id)))]
+ in
+ returnNF_Tc (tidy_env', Just msg)
+
+find_thing ignore_it tidy_env (ATyVar tv)
+ = zonkTcTyVar tv `thenNF_Tc` \ tv_ty ->
+ if ignore_it tv_ty then
+ returnNF_Tc (tidy_env, Nothing)
+ else let
+ (tidy_env1, tv1) = tidyOpenTyVar tidy_env tv
+ (tidy_env2, tidy_ty) = tidyOpenType tidy_env1 tv_ty
+ msg = sep [ptext SLIT("Type variable") <+> quotes (ppr tv1) <+> eq_stuff, nest 2 bound_at]
+
+ eq_stuff | Just tv' <- Type.getTyVar_maybe tv_ty, tv == tv' = empty
+ | otherwise = equals <+> ppr tv_ty
+ -- It's ok to use Type.getTyVar_maybe because ty is zonked by now
+
+ bound_at | isMutTyVar tv = mut_info -- The expected case
+ | otherwise = empty
+
+ mut_info = sep [ptext SLIT("is bound by the") <+> ppr (mutTyVarDetails tv),
+ ptext SLIT("at") <+> ppr (getSrcLoc tv)]
+ in
+ returnNF_Tc (tidy_env2, Just msg)
+-----------------------
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
+ (tidy_env', ftv') = tidyOpenTyVar tidy_env ftv
in
find_frees tv tidy_env' (ftv':acc) ftvs
else
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])
- ]
+ vcat [pp_it <+> ptext SLIT("is mentioned in the environment:"),
+ nest 2 (vcat 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"))
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}
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
+ (env1, tidy_sig_tyvars) = tidyOpenTyVars 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),
%************************************************************************
\begin{code}
-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)),
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}
projects / ghc-hetmet.git / blobdiff