\section[TcBinds]{TcBinds}
\begin{code}
+{-# OPTIONS -w #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
module TcBinds ( tcLocalBinds, tcTopBinds,
tcHsBootSigs, tcMonoBinds,
TcPragFun, tcSpecPrag, tcPrags, mkPragFun,
import TcMType
import TcType
import {- Kind parts of -} Type
+import Coercion
import VarEnv
import TysPrim
import Id
import IdInfo
-import Var ( TyVar )
+import Var ( TyVar, varType )
import Name
import NameSet
import NameEnv
import Util
import BasicTypes
import Outputable
+
+import Control.Monad
\end{code}
-- I wonder if we should do these one at at time
-- Consider ?x = 4
-- ?y = ?x + 1
- tc_ip_bind (IPBind ip expr)
- = newFlexiTyVarTy argTypeKind `thenM` \ ty ->
- newIPDict (IPBindOrigin ip) ip ty `thenM` \ (ip', ip_inst) ->
- tcMonoExpr expr ty `thenM` \ expr' ->
- returnM (ip_inst, (IPBind ip' expr'))
+ tc_ip_bind (IPBind ip expr) = do
+ ty <- newFlexiTyVarTy argTypeKind
+ (ip', ip_inst) <- newIPDict (IPBindOrigin ip) ip ty
+ expr' <- tcMonoExpr expr ty
+ return (ip_inst, (IPBind ip' expr'))
------------------------
tcValBinds :: TopLevelFlag
bindLocalInsts :: TopLevelFlag -> TcM ([LHsBinds TcId], [TcId], a) -> TcM ([LHsBinds TcId], a)
bindLocalInsts top_lvl thing_inside
| isTopLevel top_lvl = do { (binds, ids, thing) <- thing_inside; return (binds, thing) }
- -- For the top level don't bother will all this bindInstsOfLocalFuns stuff.
+ -- For the top level don't bother with all this bindInstsOfLocalFuns stuff.
-- All the top level things are rec'd together anyway, so it's fine to
-- leave them to the tcSimplifyTop, and quite a bit faster too
generalise dflags top_lvl bind_list sig_fn mono_bind_infos lie_req
-- BUILD THE POLYMORPHIC RESULT IDs
- ; let dict_ids = map instToId dicts
- ; exports <- mapM (mkExport top_lvl prag_fn tyvars_to_gen (map idType dict_ids))
+ ; let dict_vars = map instToVar dicts -- May include equality constraints
+ ; exports <- mapM (mkExport top_lvl prag_fn tyvars_to_gen (map varType dict_vars))
mono_bind_infos
; let poly_ids = [poly_id | (_, poly_id, _, _) <- exports]
; traceTc (text "binding:" <+> ppr (poly_ids `zip` map idType poly_ids))
; let abs_bind = L loc $ AbsBinds tyvars_to_gen
- dict_ids exports
+ dict_vars exports
(dict_binds `unionBags` binds')
; return ([unitBag abs_bind], poly_ids) -- poly_ids are guaranteed zonked by mkExport
= do { warn_missing_sigs <- doptM Opt_WarnMissingSigs
; let warn = isTopLevel top_lvl && warn_missing_sigs
; (tvs, poly_id) <- mk_poly_id warn mb_sig
+ -- poly_id has a zonked type
- ; poly_id' <- zonkId poly_id
- ; prags <- tcPrags poly_id' (prag_fn poly_name)
+ ; prags <- tcPrags poly_id (prag_fn poly_name)
-- tcPrags requires a zonked poly_id
- ; return (tvs, poly_id', mono_id, prags) }
+ ; return (tvs, poly_id, mono_id, prags) }
where
poly_ty = mkForAllTys inferred_tvs (mkFunTys dict_tys (idType mono_id))
- mk_poly_id warn Nothing = do { missingSigWarn warn poly_name poly_ty
- ; return (inferred_tvs, mkLocalId poly_name poly_ty) }
+ mk_poly_id warn Nothing = do { poly_ty' <- zonkTcType poly_ty
+ ; missingSigWarn warn poly_name poly_ty'
+ ; return (inferred_tvs, mkLocalId poly_name poly_ty') }
mk_poly_id warn (Just sig) = do { tvs <- mapM zonk_tv (sig_tvs sig)
; return (tvs, sig_id sig) }
tcSpecPrag :: TcId -> LHsType Name -> InlineSpec -> TcM Prag
tcSpecPrag poly_id hs_ty inl
- = do { spec_ty <- tcHsSigType (FunSigCtxt (idName poly_id)) hs_ty
- ; (co_fn, lie) <- getLIE (tcSubExp (idType poly_id) spec_ty)
- ; extendLIEs lie
- ; let const_dicts = map instToId lie
- ; return (SpecPrag (mkHsWrap co_fn (HsVar poly_id)) spec_ty const_dicts inl) }
+ = do { let name = idName poly_id
+ ; spec_ty <- tcHsSigType (FunSigCtxt name) hs_ty
+ ; co_fn <- tcSubExp (SpecPragOrigin name) (idType poly_id) spec_ty
+ ; return (SpecPrag (mkHsWrap co_fn (HsVar poly_id)) spec_ty inl) }
-- Most of the work of specialisation is done by
-- the desugarer, guided by the SpecPrag
-- e.g. f = \(x::forall a. a->a) -> <body>
-- We want to infer a higher-rank type for f
setSrcSpan b_loc $
- do { ((co_fn, matches'), rhs_ty) <- tcInfer (tcMatchesFun name matches)
+ do { ((co_fn, matches'), rhs_ty) <- tcInfer (tcMatchesFun name inf matches)
-- Check for an unboxed tuple type
-- f = (# True, False #)
-- we can (a) use genuine, rigid skolem constants for the type variables
-- (b) bring (rigid) scoped type variables into scope
setSrcSpan b_loc $
- do { tc_sig <- tcInstSig True name scoped_tvs
+ do { tc_sig <- tcInstSig True name
; mono_name <- newLocalName name
; let mono_ty = sig_tau tc_sig
mono_id = mkLocalId mono_name mono_ty
rhs_tvs = [ (name, mkTyVarTy tv)
- | (name, tv) <- sig_scoped tc_sig `zip` sig_tvs tc_sig ]
+ | (name, tv) <- scoped_tvs `zip` sig_tvs tc_sig ]
+ -- See Note [More instantiated than scoped]
+ -- Note that the scoped_tvs and the (sig_tvs sig)
+ -- may have different Names. That's quite ok.
- ; (co_fn, matches') <- tcExtendTyVarEnv2 rhs_tvs $
- tcMatchesFun mono_name matches mono_ty
+ ; (co_fn, matches') <- tcExtendTyVarEnv2 rhs_tvs $
+ tcMatchesFun mono_name inf matches mono_ty
; let fun_bind' = FunBind { fun_id = L nm_loc mono_id,
fun_infix = inf, fun_matches = matches',
-- A monomorphic binding for each term variable that lacks
-- a type sig. (Ones with a sig are already in scope.)
- ; binds' <- tcExtendIdEnv2 rhs_id_env $
+ ; binds' <- tcExtendIdEnv2 rhs_id_env $ do
traceTc (text "tcMonoBinds" <+> vcat [ ppr n <+> ppr id <+> ppr (idType id)
- | (n,id) <- rhs_id_env]) `thenM_`
+ | (n,id) <- rhs_id_env])
mapM (wrapLocM tcRhs) tc_binds
; return (listToBag binds', mono_info) }
-------------------
tcRhs :: TcMonoBind -> TcM (HsBind TcId)
-tcRhs (TcFunBind info fun'@(L _ mono_id) inf matches)
- = do { (co_fn, matches') <- tcMatchesFun (idName mono_id) matches
- (idType mono_id)
+-- When we are doing pattern bindings, or multiple function bindings at a time
+-- we *don't* bring any scoped type variables into scope
+-- Wny not? They are not completely rigid.
+-- That's why we have the special case for a single FunBind in tcMonoBinds
+tcRhs (TcFunBind (_,_,mono_id) fun' inf matches)
+ = do { (co_fn, matches') <- tcMatchesFun (idName mono_id) inf
+ matches (idType mono_id)
; return (FunBind { fun_id = fun', fun_infix = inf, fun_matches = matches',
bind_fvs = placeHolderNames, fun_co_fn = co_fn,
fun_tick = Nothing }) }
-- Check that signature type variables are OK
; final_qtvs <- checkSigsTyVars qtvs sigs
- ; returnM (final_qtvs, sig_lie, binds) }
+ ; return (final_qtvs, sig_lie, binds) }
where
bndrs = bndrNames mono_infos
sigs = [sig | (_, Just sig, _) <- mono_infos]
- tau_tvs = foldr (unionVarSet . exactTyVarsOfType . getMonoType) emptyVarSet mono_infos
- -- NB: exactTyVarsOfType; see Note [Silly type synonym]
- -- near defn of TcType.exactTyVarsOfType
+ get_tvs | isTopLevel top_lvl = tyVarsOfType -- See Note [Silly type synonym] in TcType
+ | otherwise = exactTyVarsOfType
+ tau_tvs = foldr (unionVarSet . get_tvs . getMonoType) emptyVarSet mono_infos
is_mono_sig sig = null (sig_theta sig)
doc = ptext SLIT("type signature(s) for") <+> pprBinders bndrs
unify_ctxt sig@(TcSigInfo { sig_theta = theta })
= setSrcSpan (instLocSpan (sig_loc sig)) $
addErrCtxt (sigContextsCtxt sig1 sig) $
- unifyTheta theta1 theta
+ do { cois <- unifyTheta theta1 theta
+ ; -- Check whether all coercions are identity coercions
+ -- That can happen if we have, say
+ -- f :: C [a] => ...
+ -- g :: C (F a) => ...
+ -- where F is a type function and (F a ~ [a])
+ -- Then unification might succeed with a coercion. But it's much
+ -- much simpler to require that such signatures have identical contexts
+ checkTc (all isIdentityCoercion cois)
+ (ptext SLIT("Mutually dependent functions have syntactically distinct contexts"))
+ }
checkSigsTyVars :: [TcTyVar] -> [TcSigInfo] -> TcM [TcTyVar]
checkSigsTyVars qtvs sigs
= do { gbl_tvs <- tcGetGlobalTyVars
- ; sig_tvs_s <- mappM (check_sig gbl_tvs) sigs
+ ; sig_tvs_s <- mapM (check_sig gbl_tvs) sigs
; let -- Sigh. Make sure that all the tyvars in the type sigs
-- appear in the returned ty var list, which is what we are
-- Here, 'a' won't appear in qtvs, so we have to add it
sig_tvs = foldl extendVarSetList emptyVarSet sig_tvs_s
all_tvs = varSetElems (extendVarSetList sig_tvs qtvs)
- ; returnM all_tvs }
+ ; return all_tvs }
where
check_sig gbl_tvs (TcSigInfo {sig_id = id, sig_tvs = tvs,
sig_theta = theta, sig_tau = tau})
= addErrCtxt (ptext SLIT("In the type signature for") <+> quotes (ppr id)) $
addErrCtxtM (sigCtxt id tvs theta tau) $
do { tvs' <- checkDistinctTyVars tvs
- ; ifM (any (`elemVarSet` gbl_tvs) tvs')
- (bleatEscapedTvs gbl_tvs tvs tvs')
+ ; when (any (`elemVarSet` gbl_tvs) tvs')
+ (bleatEscapedTvs gbl_tvs tvs tvs')
; return tvs' }
checkDistinctTyVars :: [TcTyVar] -> TcM [TcTyVar]
the variable's type, and after that checked to see whether they've
been instantiated.
+Note [Scoped tyvars]
+~~~~~~~~~~~~~~~~~~~~
+The -XScopedTypeVariables flag brings lexically-scoped type variables
+into scope for any explicitly forall-quantified type variables:
+ f :: forall a. a -> a
+ f x = e
+Then 'a' is in scope inside 'e'.
+
+However, we do *not* support this
+ - For pattern bindings e.g
+ f :: forall a. a->a
+ (f,g) = e
+
+ - For multiple function bindings, unless Opt_RelaxedPolyRec is on
+ f :: forall a. a -> a
+ f = g
+ g :: forall b. b -> b
+ g = ...f...
+ Reason: we use mutable variables for 'a' and 'b', since they may
+ unify to each other, and that means the scoped type variable would
+ not stand for a completely rigid variable.
+
+ Currently, we simply make Opt_ScopedTypeVariables imply Opt_RelaxedPolyRec
+
+
+Note [More instantiated than scoped]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+There may be more instantiated type variables than lexically-scoped
+ones. For example:
+ type T a = forall b. b -> (a,b)
+ f :: forall c. T c
+Here, the signature for f will have one scoped type variable, c,
+but two instantiated type variables, c' and b'.
+
+We assume that the scoped ones are at the *front* of sig_tvs,
+and remember the names from the original HsForAllTy in the TcSigFun.
+
+
\begin{code}
type TcSigFun = Name -> Maybe [Name] -- Maps a let-binder to the list of
-- type variables brought into scope
| L span (TypeSig (L _ name) lhs_ty) <- sigs]
-- The scoped names are the ones explicitly mentioned
-- in the HsForAll. (There may be more in sigma_ty, because
- -- of nested type synonyms. See Note [Scoped] with TcSigInfo.)
+ -- of nested type synonyms. See Note [More instantiated than scoped].)
-- See Note [Only scoped tyvars are in the TyVarEnv]
---------------
= TcSigInfo {
sig_id :: TcId, -- *Polymorphic* binder for this value...
- sig_scoped :: [Name], -- Names for any scoped type variables
- -- Invariant: correspond 1-1 with an initial
- -- segment of sig_tvs (see Note [Scoped])
-
sig_tvs :: [TcTyVar], -- Instantiated type variables
-- See Note [Instantiate sig]
-- only the lexically scoped ones into the environment.
--- Note [Scoped]
--- There may be more instantiated type variables than scoped
--- ones. For example:
--- type T a = forall b. b -> (a,b)
--- f :: forall c. T c
--- Here, the signature for f will have one scoped type variable, c,
--- but two instantiated type variables, c' and b'.
---
--- We assume that the scoped ones are at the *front* of sig_tvs,
--- and remember the names from the original HsForAllTy in sig_scoped
-
-- Note [Instantiate sig]
-- It's vital to instantiate a type signature with fresh variables.
-- For example:
tcInstSig_maybe sig_fn name
= case sig_fn name of
Nothing -> return Nothing
- Just tvs -> do { tc_sig <- tcInstSig False name tvs
- ; return (Just tc_sig) }
+ Just scoped_tvs -> do { tc_sig <- tcInstSig False name
+ ; return (Just tc_sig) }
+ -- NB: the scoped_tvs may be non-empty, but we can
+ -- just ignore them. See Note [Scoped tyvars].
-tcInstSig :: Bool -> Name -> [Name] -> TcM TcSigInfo
+tcInstSig :: Bool -> Name -> TcM TcSigInfo
-- Instantiate the signature, with either skolems or meta-type variables
-- depending on the use_skols boolean. This variable is set True
-- when we are typechecking a single function binding; and False for
--
-- We must not use the same 'a' from the defn of T at both places!!
-tcInstSig use_skols name scoped_names
+tcInstSig use_skols name
= do { poly_id <- tcLookupId name -- Cannot fail; the poly ids are put into
-- scope when starting the binding group
; let skol_info = SigSkol (FunSigCtxt name)
; loc <- getInstLoc (SigOrigin skol_info)
; return (TcSigInfo { sig_id = poly_id,
sig_tvs = tvs, sig_theta = theta, sig_tau = tau,
- sig_scoped = final_scoped_names, sig_loc = loc }) }
- -- Note that the scoped_names and the sig_tvs will have
- -- different Names. That's quite ok; when we bring the
- -- scoped_names into scope, we just bind them to the sig_tvs
- where
- -- We also only have scoped type variables when we are instantiating
- -- with true skolems
- final_scoped_names | use_skols = scoped_names
- | otherwise = []
+ sig_loc = loc }) }
-------------------
isMonoGroup :: DynFlags -> [LHsBind Name] -> Bool