import {-# SOURCE #-} TcMatches ( tcGRHSsPat, tcMatchesFun )
import {-# SOURCE #-} TcExpr ( tcMonoExpr )
-import DynFlags ( DynFlag(Opt_MonomorphismRestriction, Opt_GlasgowExts) )
+import DynFlags ( dopt, DynFlags,
+ DynFlag(Opt_MonomorphismRestriction, Opt_MonoPatBinds, Opt_GlasgowExts) )
import HsSyn ( HsExpr(..), HsBind(..), LHsBinds, LHsBind, Sig(..),
HsLocalBinds(..), HsValBinds(..), HsIPBinds(..),
LSig, Match(..), IPBind(..), Prag(..),
import TcHsSyn ( zonkId )
import TcRnMonad
-import Inst ( newDictsAtLoc, newIPDict, instToId )
+import Inst ( newDictBndrs, newIPDict, instToId )
import TcEnv ( tcExtendIdEnv, tcExtendIdEnv2, tcExtendTyVarEnv2,
- pprBinders, tcLookupLocalId_maybe, tcLookupId,
+ pprBinders, tcLookupId,
tcGetGlobalTyVars )
import TcUnify ( tcInfer, tcSubExp, unifyTheta,
bleatEscapedTvs, sigCtxt )
import TcSimplify ( tcSimplifyInfer, tcSimplifyInferCheck,
tcSimplifyRestricted, tcSimplifyIPs )
import TcHsType ( tcHsSigType, UserTypeCtxt(..) )
-import TcPat ( tcPat, PatCtxt(..) )
+import TcPat ( tcLetPat )
import TcSimplify ( bindInstsOfLocalFuns )
import TcMType ( newFlexiTyVarTy, zonkQuantifiedTyVar, zonkSigTyVar,
tcInstSigTyVars, tcInstSkolTyVars, tcInstType,
- zonkTcType, zonkTcTypes, zonkTcTyVars )
+ zonkTcType, zonkTcTypes, zonkTcTyVar )
import TcType ( TcType, TcTyVar, TcThetaType,
SkolemInfo(SigSkol), UserTypeCtxt(FunSigCtxt),
TcTauType, TcSigmaType, isUnboxedTupleType,
mkTyVarTy, mkForAllTys, mkFunTys, exactTyVarsOfType,
mkForAllTy, isUnLiftedType, tcGetTyVar,
mkTyVarTys, tidyOpenTyVar )
-import Kind ( argTypeKind )
+import {- Kind parts of -} Type ( argTypeKind )
import VarEnv ( TyVarEnv, emptyVarEnv, lookupVarEnv, extendVarEnv )
-import TysWiredIn ( unitTy )
import TysPrim ( alphaTyVar )
import Id ( Id, mkLocalId, mkVanillaGlobal )
import IdInfo ( vanillaIdInfo )
-- Extend the envt right away with all
-- the Ids declared with type signatures
+ ; gla_exts <- doptM Opt_GlasgowExts
; (binds', thing) <- tcExtendIdEnv poly_ids $
- tc_val_binds top_lvl sig_fn prag_fn
+ tc_val_binds gla_exts top_lvl sig_fn prag_fn
binds thing_inside
; return (ValBindsOut binds' sigs, thing) }
------------------------
-tc_val_binds :: TopLevelFlag -> TcSigFun -> TcPragFun
+tc_val_binds :: Bool -> TopLevelFlag -> TcSigFun -> TcPragFun
-> [(RecFlag, LHsBinds Name)] -> TcM thing
-> TcM ([(RecFlag, LHsBinds TcId)], thing)
-- Typecheck a whole lot of value bindings,
-- one strongly-connected component at a time
-tc_val_binds top_lvl sig_fn prag_fn [] thing_inside
+tc_val_binds gla_exts top_lvl sig_fn prag_fn [] thing_inside
= do { thing <- thing_inside
; return ([], thing) }
-tc_val_binds top_lvl sig_fn prag_fn (group : groups) thing_inside
+tc_val_binds gla_exts top_lvl sig_fn prag_fn (group : groups) thing_inside
= do { (group', (groups', thing))
- <- tc_group top_lvl sig_fn prag_fn group $
- tc_val_binds top_lvl sig_fn prag_fn groups thing_inside
+ <- tc_group gla_exts top_lvl sig_fn prag_fn group $
+ tc_val_binds gla_exts top_lvl sig_fn prag_fn groups thing_inside
; return (group' ++ groups', thing) }
------------------------
-tc_group :: TopLevelFlag -> TcSigFun -> TcPragFun
+tc_group :: Bool -> TopLevelFlag -> TcSigFun -> TcPragFun
-> (RecFlag, LHsBinds Name) -> TcM thing
-> TcM ([(RecFlag, LHsBinds TcId)], thing)
-- We get a list of groups back, because there may
-- be specialisations etc as well
-tc_group top_lvl sig_fn prag_fn (NonRecursive, binds) thing_inside
- = -- A single non-recursive binding
+tc_group gla_exts top_lvl sig_fn prag_fn (NonRecursive, binds) thing_inside
+ -- A single non-recursive binding
-- We want to keep non-recursive things non-recursive
-- so that we desugar unlifted bindings correctly
- do { (binds, thing) <- tcPolyBinds top_lvl NonRecursive NonRecursive
- sig_fn prag_fn binds thing_inside
+ = do { (binds, thing) <- tc_haskell98 top_lvl sig_fn prag_fn NonRecursive binds thing_inside
; return ([(NonRecursive, b) | b <- binds], thing) }
-tc_group top_lvl sig_fn prag_fn (Recursive, binds) thing_inside
- = -- A recursive strongly-connected component
- -- To maximise polymorphism (with -fglasgow-exts), we do a new
+tc_group gla_exts top_lvl sig_fn prag_fn (Recursive, binds) thing_inside
+ | not gla_exts -- Recursive group, normal Haskell 98 route
+ = do { (binds1, thing) <- tc_haskell98 top_lvl sig_fn prag_fn Recursive binds thing_inside
+ ; return ([(Recursive, unionManyBags binds1)], thing) }
+
+ | otherwise -- Recursive group, with gla-exts
+ = -- To maximise polymorphism (with -fglasgow-exts), we do a new
-- strongly-connected-component analysis, this time omitting
-- any references to variables with type signatures.
--
- -- Then we bring into scope all the variables with type signatures
+ -- Notice that the bindInsts thing covers *all* the bindings in the original
+ -- group at once; an earlier one may use a later one!
do { traceTc (text "tc_group rec" <+> pprLHsBinds binds)
- ; gla_exts <- doptM Opt_GlasgowExts
- ; (binds,thing) <- if gla_exts
- then go new_sccs
- else tc_binds Recursive binds thing_inside
- ; return ([(Recursive, unionManyBags binds)], thing) }
+ ; (binds1,thing) <- bindLocalInsts top_lvl $
+ go (stronglyConnComp (mkEdges sig_fn binds))
+ ; return ([(Recursive, unionManyBags binds1)], thing) }
-- Rec them all together
where
- new_sccs :: [SCC (LHsBind Name)]
- new_sccs = stronglyConnComp (mkEdges sig_fn binds)
+-- go :: SCC (LHsBind Name) -> TcM ([LHsBind TcId], [TcId], thing)
+ go (scc:sccs) = do { (binds1, ids1) <- tc_scc scc
+ ; (binds2, ids2, thing) <- tcExtendIdEnv ids1 $ go sccs
+ ; return (binds1 ++ binds2, ids1 ++ ids2, thing) }
+ go [] = do { thing <- thing_inside; return ([], [], thing) }
--- go :: SCC (LHsBind Name) -> TcM ([LHsBind TcId], thing)
- go (scc:sccs) = do { (binds1, (binds2, thing)) <- go1 scc (go sccs)
- ; return (binds1 ++ binds2, thing) }
- go [] = do { thing <- thing_inside; return ([], thing) }
+ tc_scc (AcyclicSCC bind) = tc_sub_group NonRecursive (unitBag bind)
+ tc_scc (CyclicSCC binds) = tc_sub_group Recursive (listToBag binds)
- go1 (AcyclicSCC bind) = tc_binds NonRecursive (unitBag bind)
- go1 (CyclicSCC binds) = tc_binds Recursive (listToBag binds)
+ tc_sub_group = tcPolyBinds top_lvl sig_fn prag_fn Recursive
- tc_binds rec_tc binds = tcPolyBinds top_lvl Recursive rec_tc sig_fn prag_fn binds
+tc_haskell98 top_lvl sig_fn prag_fn rec_flag binds thing_inside
+ = bindLocalInsts top_lvl $ do
+ { (binds1, ids) <- tcPolyBinds top_lvl sig_fn prag_fn rec_flag rec_flag binds
+ ; thing <- tcExtendIdEnv ids thing_inside
+ ; return (binds1, ids, thing) }
+
+------------------------
+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.
+ -- 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
+
+ | otherwise -- Nested case
+ = do { ((binds, ids, thing), lie) <- getLIE thing_inside
+ ; lie_binds <- bindInstsOfLocalFuns lie ids
+ ; return (binds ++ [lie_binds], thing) }
------------------------
mkEdges :: TcSigFun -> LHsBinds Name
bindersOfHsBind (FunBind { fun_id = L _ f }) = [f]
------------------------
-tcPolyBinds :: TopLevelFlag
+tcPolyBinds :: TopLevelFlag -> TcSigFun -> TcPragFun
-> RecFlag -- Whether the group is really recursive
- -> RecFlag -- Whether it's recursive for typechecking purposes
- -> TcSigFun -> TcPragFun
+ -> RecFlag -- Whether it's recursive after breaking
+ -- dependencies based on type signatures
-> LHsBinds Name
- -> TcM thing
- -> TcM ([LHsBinds TcId], thing)
+ -> TcM ([LHsBinds TcId], [TcId])
-- Typechecks a single bunch of bindings all together,
-- and generalises them. The bunch may be only part of a recursive
-- group, because we use type signatures to maximise polymorphism
--
--- Deals with the bindInstsOfLocalFuns thing too
---
-- Returns a list because the input may be a single non-recursive binding,
-- in which case the dependency order of the resulting bindings is
-- important.
-
-tcPolyBinds top_lvl rec_group rec_tc sig_fn prag_fn scc thing_inside
- = -- NB: polymorphic recursion means that a function
- -- may use an instance of itself, we must look at the LIE arising
- -- from the function's own right hand side. Hence the getLIE
- -- encloses the tc_poly_binds.
- do { traceTc (text "tcPolyBinds" <+> ppr scc)
- ; ((binds1, poly_ids, thing), lie) <- getLIE $
- do { (binds1, poly_ids) <- tc_poly_binds top_lvl rec_group rec_tc
- sig_fn prag_fn scc
- ; thing <- tcExtendIdEnv poly_ids thing_inside
- ; return (binds1, poly_ids, thing) }
-
- ; if isTopLevel top_lvl
- then -- For the top level don't bother will 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
- do { extendLIEs lie; return (binds1, thing) }
-
- else do -- Nested case
- { lie_binds <- bindInstsOfLocalFuns lie poly_ids
- ; return (binds1 ++ [lie_binds], thing) }}
-
-------------------------
-tc_poly_binds :: TopLevelFlag -- See comments on tcPolyBinds
- -> RecFlag -> RecFlag
- -> TcSigFun -> TcPragFun
- -> LHsBinds Name
- -> TcM ([LHsBinds TcId], [TcId])
--- Typechecks the bindings themselves
+--
-- Knows nothing about the scope of the bindings
-tc_poly_binds top_lvl rec_group rec_tc sig_fn prag_fn binds
+tcPolyBinds top_lvl sig_fn prag_fn rec_group rec_tc binds
= let
- binder_names = collectHsBindBinders binds
bind_list = bagToList binds
-
- loc = getLoc (head bind_list)
+ binder_names = collectHsBindBinders binds
+ loc = getLoc (head bind_list)
-- TODO: location a bit awkward, but the mbinds have been
-- dependency analysed and may no longer be adjacent
in
-- SET UP THE MAIN RECOVERY; take advantage of any type sigs
setSrcSpan loc $
- recoverM (recoveryCode binder_names) $ do
+ recoverM (recoveryCode binder_names sig_fn) $ do
{ traceTc (ptext SLIT("------------------------------------------------"))
; traceTc (ptext SLIT("Bindings for") <+> ppr binder_names)
[poly_id | (_, poly_id, _, _) <- exports]) } -- Guaranteed zonked
else do -- The normal lifted case: GENERALISE
- { is_unres <- isUnRestrictedGroup bind_list sig_fn
+ { dflags <- getDOpts
; (tyvars_to_gen, dict_binds, dict_ids)
<- addErrCtxt (genCtxt (bndrNames mono_bind_infos)) $
- generalise top_lvl is_unres mono_bind_infos lie_req
+ generalise dflags top_lvl bind_list sig_fn mono_bind_infos lie_req
-- FINALISE THE QUANTIFIED TYPE VARIABLES
-- The quantified type variables often include meta type variables
; exports <- mapM (mkExport prag_fn tyvars_to_gen' (map idType dict_ids))
mono_bind_infos
- -- ZONK THE poly_ids, because they are used to extend the type
- -- environment; see the invariant on TcEnv.tcExtendIdEnv
; let poly_ids = [poly_id | (_, poly_id, _, _) <- exports]
- ; zonked_poly_ids <- mappM zonkId poly_ids
-
- ; traceTc (text "binding:" <+> ppr (zonked_poly_ids `zip` map idType zonked_poly_ids))
+ ; traceTc (text "binding:" <+> ppr (poly_ids `zip` map idType poly_ids))
; let abs_bind = L loc $ AbsBinds tyvars_to_gen'
dict_ids exports
(dict_binds `unionBags` binds')
- ; return ([unitBag abs_bind], zonked_poly_ids)
+ ; return ([unitBag abs_bind], poly_ids) -- poly_ids are guaranteed zonked by mkExport
} }
--------------
mkExport :: TcPragFun -> [TyVar] -> [TcType] -> MonoBindInfo
-> TcM ([TyVar], Id, Id, [Prag])
+-- mkExport generates exports with
+-- zonked type variables,
+-- zonked poly_ids
+-- The former is just because no further unifications will change
+-- the quantified type variables, so we can fix their final form
+-- right now.
+-- The latter is needed because the poly_ids are used to extend the
+-- type environment; see the invariant on TcEnv.tcExtendIdEnv
+
+-- Pre-condition: the inferred_tvs are already zonked
+
mkExport prag_fn inferred_tvs dict_tys (poly_name, mb_sig, mono_id)
- = case mb_sig of
- Nothing -> do { prags <- tcPrags poly_id (prag_fn poly_name)
- ; return (inferred_tvs, poly_id, mono_id, prags) }
- where
- poly_id = mkLocalId poly_name poly_ty
- poly_ty = mkForAllTys inferred_tvs
- $ mkFunTys dict_tys
- $ idType mono_id
-
- Just sig -> do { let poly_id = sig_id sig
- ; prags <- tcPrags poly_id (prag_fn poly_name)
- ; sig_tys <- zonkTcTyVars (sig_tvs sig)
- ; let sig_tvs' = map (tcGetTyVar "mkExport") sig_tys
- ; return (sig_tvs', poly_id, mono_id, prags) }
- -- We zonk the sig_tvs here so that the export triple
- -- always has zonked type variables;
- -- a convenient invariant
+ = do { (tvs, poly_id) <- mk_poly_id mb_sig
+
+ ; poly_id' <- zonkId poly_id
+ ; prags <- tcPrags poly_id' (prag_fn poly_name)
+ -- tcPrags requires a zonked poly_id
+
+ ; return (tvs, poly_id', mono_id, prags) }
+ where
+ poly_ty = mkForAllTys inferred_tvs (mkFunTys dict_tys (idType mono_id))
+
+ mk_poly_id Nothing = return (inferred_tvs, mkLocalId poly_name poly_ty)
+ mk_poly_id (Just sig) = do { tvs <- mapM zonk_tv (sig_tvs sig)
+ ; return (tvs, sig_id sig) }
+ zonk_tv tv = do { ty <- zonkTcTyVar tv; return (tcGetTyVar "mkExport" ty) }
------------------------
type TcPragFun = Name -> [LSig Name]
pragSigCtxt prag = hang (ptext SLIT("In the pragma")) 2 (ppr prag)
tcPrag :: TcId -> Sig Name -> TcM Prag
+-- Pre-condition: the poly_id is zonked
+-- Reason: required by tcSubExp
tcPrag poly_id (SpecSig orig_name hs_ty inl) = tcSpecPrag poly_id hs_ty inl
tcPrag poly_id (SpecInstSig hs_ty) = tcSpecPrag poly_id hs_ty defaultInlineSpec
tcPrag poly_id (InlineSig v inl) = return (InlinePrag inl)
-- If typechecking the binds fails, then return with each
-- signature-less binder given type (forall a.a), to minimise
-- subsequent error messages
-recoveryCode binder_names
+recoveryCode binder_names sig_fn
= do { traceTc (text "tcBindsWithSigs: error recovery" <+> ppr binder_names)
; poly_ids <- mapM mk_dummy binder_names
; return ([], poly_ids) }
where
- mk_dummy name = do { mb_id <- tcLookupLocalId_maybe name
- ; case mb_id of
- Just id -> return id -- Had signature, was in envt
- Nothing -> return (mkLocalId name forall_a_a) } -- No signature
+ mk_dummy name
+ | isJust (sig_fn name) = tcLookupId name -- Had signature; look it up
+ | otherwise = return (mkLocalId name forall_a_a) -- No signature
forall_a_a :: TcType
forall_a_a = mkForAllTy alphaTyVar (mkTyVarTy alphaTyVar)
check_sig other = return ()
strictBindErr flavour unlifted mbind
- = hang (text flavour <+> msg <+> ptext SLIT("aren't allowed:")) 4 (ppr mbind)
+ = hang (text flavour <+> msg <+> ptext SLIT("aren't allowed:"))
+ 4 (pprLHsBinds mbind)
where
msg | unlifted = ptext SLIT("bindings for unlifted types")
| otherwise = ptext SLIT("bang-pattern bindings")
tcLhs sig_fn bind@(PatBind { pat_lhs = pat, pat_rhs = grhss })
= do { mb_sigs <- mapM (tcInstSig_maybe sig_fn) names
+ ; mono_pat_binds <- doptM Opt_MonoPatBinds
+ -- With -fmono-pat-binds, we do no generalisation of pattern bindings
+ -- But the signature can still be polymoprhic!
+ -- data T = MkT (forall a. a->a)
+ -- x :: forall a. a->a
+ -- MkT x = <rhs>
+ -- The function get_sig_ty decides whether the pattern-bound variables
+ -- should have exactly the type in the type signature (-fmono-pat-binds),
+ -- or the instantiated version (-fmono-pat-binds)
; let nm_sig_prs = names `zip` mb_sigs
- tau_sig_env = mkNameEnv [ (name, sig_tau sig) | (name, Just sig) <- nm_sig_prs]
+ get_sig_ty | mono_pat_binds = idType . sig_id
+ | otherwise = sig_tau
+ tau_sig_env = mkNameEnv [ (name, get_sig_ty sig)
+ | (name, Just sig) <- nm_sig_prs]
sig_tau_fn = lookupNameEnv tau_sig_env
- tc_pat exp_ty = tcPat (LetPat sig_tau_fn) pat exp_ty unitTy $ \ _ ->
+ tc_pat exp_ty = tcLetPat sig_tau_fn pat exp_ty $
mapM lookup_info nm_sig_prs
- -- The unitTy is a bit bogus; it's the "result type" for lookup_info.
-- After typechecking the pattern, look up the binder
-- names, which the pattern has brought into scope.
%************************************************************************
\begin{code}
-generalise :: TopLevelFlag -> Bool
+generalise :: DynFlags -> TopLevelFlag
+ -> [LHsBind Name] -> TcSigFun
-> [MonoBindInfo] -> [Inst]
-> TcM ([TcTyVar], TcDictBinds, [TcId])
-generalise top_lvl is_unrestricted mono_infos lie_req
- | not is_unrestricted -- RESTRICTED CASE
+generalise dflags top_lvl bind_list sig_fn mono_infos lie_req
+ | isMonoGroup dflags bind_list
+ = do { extendLIEs lie_req; return ([], emptyBag, []) }
+
+ | isRestrictedGroup dflags bind_list sig_fn -- RESTRICTED CASE
= -- Check signature contexts are empty
do { checkTc (all is_mono_sig sigs)
(restrictedBindCtxtErr bndrs)
unifyCtxts :: [TcSigInfo] -> TcM [Inst]
unifyCtxts (sig1 : sigs) -- Argument is always non-empty
= do { mapM unify_ctxt sigs
- ; newDictsAtLoc (sig_loc sig1) (sig_theta sig1) }
+ ; newDictBndrs (sig_loc sig1) (sig_theta sig1) }
where
theta1 = sig_theta sig1
unify_ctxt :: TcSigInfo -> TcM ()
tcInstSig :: Bool -> Name -> [Name] -> TcM TcSigInfo
-- Instantiate the signature, with either skolems or meta-type variables
--- depending on the use_skols boolean
+-- depending on the use_skols boolean. This variable is set True
+-- when we are typechecking a single function binding; and False for
+-- pattern bindigs and a group of several function bindings.
+-- Reason: in the latter cases, the "skolems" can be unified together,
+-- so they aren't properly rigid in the type-refinement sense.
+-- NB: unless we are doing H98, each function with a sig will be done
+-- separately, even if it's mutually recursive, so use_skols will be True
--
--- We always instantiate with freshs uniques,
+-- We always instantiate with fresh uniques,
-- although we keep the same print-name
--
-- type T = forall a. [a] -> [a]
| otherwise = []
-------------------
-isUnRestrictedGroup :: [LHsBind Name] -> TcSigFun -> TcM Bool
-isUnRestrictedGroup binds sig_fn
- = do { mono_restriction <- doptM Opt_MonomorphismRestriction
- ; return (not mono_restriction || all_unrestricted) }
+isMonoGroup :: DynFlags -> [LHsBind Name] -> Bool
+-- No generalisation at all
+isMonoGroup dflags binds
+ = dopt Opt_MonoPatBinds dflags && any is_pat_bind binds
+ where
+ is_pat_bind (L _ (PatBind {})) = True
+ is_pat_bind other = False
+
+-------------------
+isRestrictedGroup :: DynFlags -> [LHsBind Name] -> TcSigFun -> Bool
+isRestrictedGroup dflags binds sig_fn
+ = mono_restriction && not all_unrestricted
where
+ mono_restriction = dopt Opt_MonomorphismRestriction dflags
all_unrestricted = all (unrestricted . unLoc) binds
has_sig n = isJust (sig_fn n)