\begin{code}
module TcMonoType ( tcHsType, tcHsSigType, tcHsBoxedSigType,
- tcContext, tcClassContext,
+ tcContext, tcClassContext, checkAmbiguity,
-- Kind checking
kcHsTyVar, kcHsTyVars, mkTyClTyVars,
#include "HsVersions.h"
-import HsSyn ( HsType(..), HsTyVarBndr(..), HsUsageAnn(..),
+import HsSyn ( HsType(..), HsTyVarBndr(..),
Sig(..), HsPred(..), pprParendHsType, HsTupCon(..), hsTyVarNames )
import RnHsSyn ( RenamedHsType, RenamedHsPred, RenamedContext, RenamedSig )
import TcHsSyn ( TcId )
import TcMonad
import TcEnv ( tcExtendTyVarEnv, tcExtendKindEnv,
- tcLookup, tcLookupGlobal,
- tcGetEnv, tcEnvTyVars, tcEnvTcIds,
+ tcLookupGlobal, tcLookup,
+ tcEnvTcIds, tcEnvTyVars,
tcGetGlobalTyVars,
- TyThing(..)
+ TyThing(..), TcTyThing(..)
)
import TcType ( TcType, TcKind, TcTyVar, TcThetaType, TcTauType,
newKindVar, tcInstSigVar,
instFunDeps, instFunDepsOfTheta )
import FunDeps ( tyVarFunDep, oclose )
import TcUnify ( unifyKind, unifyOpenTypeKind )
-import Type ( Type, Kind, PredType(..), ThetaType, UsageAnn(..),
- mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy, mkUsgTy,
- mkUsForAllTy, zipFunTys, hoistForAllTys,
+import Type ( Type, Kind, PredType(..), ThetaType,
+ mkTyVarTy, mkTyVarTys, mkFunTy, mkSynTy,
+ zipFunTys, hoistForAllTys,
mkSigmaTy, mkPredTy, mkTyConApp,
mkAppTys, splitForAllTys, splitRhoTy, mkRhoTy,
boxedTypeKind, unboxedTypeKind, mkArrowKind,
mkArrowKinds, getTyVar_maybe, getTyVar, splitFunTy_maybe,
tidyOpenType, tidyOpenTypes, tidyTyVar, tidyTyVars,
tyVarsOfType, tyVarsOfPred, mkForAllTys,
- classesOfPreds, isUnboxedTupleType
+ classesOfPreds,
)
import PprType ( pprType, pprPred )
import Subst ( mkTopTyVarSubst, substTy )
-import Id ( mkVanillaId, idName, idType, idFreeTyVars )
-import Var ( TyVar, mkTyVar, tyVarKind )
+import Id ( Id, mkVanillaId, idName, idType, idFreeTyVars )
+import Var ( Var, TyVar, mkTyVar, tyVarKind )
import VarEnv
import VarSet
import ErrUtils ( Message )
-import TyCon ( TyCon, isSynTyCon, tyConArity, tyConKind, tyConName )
+import TyCon ( TyCon, isSynTyCon, tyConArity, tyConKind )
import Class ( ClassContext, classArity, classTyCon )
-import Name ( Name, isLocallyDefined )
+import Name ( Name )
import TysWiredIn ( mkListTy, mkTupleTy, genUnitTyCon )
import UniqFM ( elemUFM )
import BasicTypes ( Boxity(..) )
import SrcLoc ( SrcLoc )
import Util ( mapAccumL, isSingleton )
import Outputable
-
+import HscTypes ( TyThing(..) )
\end{code}
tcHsTyVars tv_names kind_check $ \ tyvars ->
tcContext ctxt `thenTc` \ theta ->
tcHsType ty `thenTc` \ tau ->
- checkAmbiguity full_ty tyvars theta tau `thenTc_`
- returnTc (mkSigmaTy tyvars theta tau)
+ checkAmbiguity is_source tyvars theta tau
+ where
+ is_source = case tv_names of
+ (UserTyVar _ : _) -> True
+ other -> False
+checkAmbiguity :: Bool -> [TyVar] -> ThetaType -> Type -> TcM Type
-- Check for ambiguity
-- forall V. P => tau
-- is ambiguous if P contains generic variables
-- even in a scope where b is in scope.
-- This is the is_free test below.
-checkAmbiguity full_ty forall_tyvars theta tau
- = mapTc check_pred theta
- where
- tau_vars = tyVarsOfType tau
- fds = instFunDepsOfTheta theta
- tvFundep = tyVarFunDep fds
- extended_tau_vars = oclose tvFundep 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 full_ty) `thenTc_`
- checkTc (not all_free) (freeErr pred full_ty)
- where
- ct_vars = varSetElems (tyVarsOfPred pred)
- all_free = all is_free ct_vars
- any_ambig = is_source_polytype && any is_ambig ct_vars
-
-- 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
-- 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).
- is_source_polytype
- = case full_ty of
- HsForAllTy (Just (UserTyVar _ : _)) _ _ -> True
- other -> False
+
+checkAmbiguity is_source_polytype forall_tyvars theta tau
+ = mapTc_ check_pred theta `thenTc_`
+ returnTc sigma_ty
+ 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
+
+ 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 (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
\end{code}
Help functions for type applications
main_msg = ptext SLIT("Inferred type is less polymorphic than expected")
- check (env, acc, msgs) (sig_tyvar,ty)
+ check (tidy_env, acc, msgs) (sig_tyvar,ty)
-- sig_tyvar is from the signature;
-- 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 {
Nothing -> -- Error (a)!
- returnNF_Tc (env, acc, unify_msg sig_tyvar (ppr ty) : msgs) ;
+ returnNF_Tc (tidy_env, acc, unify_msg sig_tyvar (ppr ty) : msgs) ;
Just tv ->
case lookupVarEnv acc tv of {
Just sig_tyvar' -> -- Error (b) or (d)!
- returnNF_Tc (env, acc, unify_msg sig_tyvar (ppr sig_tyvar') : msgs) ;
+ returnNF_Tc (tidy_env, acc, unify_msg sig_tyvar (ppr sig_tyvar') : msgs) ;
Nothing ->
if tv `elemVarSet` globals -- Error (c)! Type variable escapes
-- The least comprehensible, so put it last
- 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)
+ -- Game plan:
+ -- a) get the local TcIds 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` \ tc_env ->
+ find_globals tv tidy_env [] (tcEnvTcIds tc_env) `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)
else -- All OK
- returnNF_Tc (env, extendVarEnv acc tv sig_tyvar, 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.
-- We must be careful to pass it a zonked type variable, too.
+
+find_globals :: Var
+ -> TidyEnv
+ -> [(Name,Type)]
+ -> [Id]
+ -> NF_TcM (TidyEnv,[(Name,Type)])
+
find_globals tv tidy_env acc []
= 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
projects / ghc-hetmet.git / blobdiff