import {-# SOURCE #-} TcExpr( tcExpr )
import HsSyn ( HsBinds(..), Match(..), GRHSs(..), GRHS(..),
- MonoBinds(..), Stmt(..), HsMatchContext(..),
+ MonoBinds(..), Stmt(..), HsMatchContext(..), HsDoContext(..),
pprMatch, getMatchLoc, pprMatchContext, isDoExpr,
mkMonoBind, nullMonoBinds, collectSigTysFromPats
)
import RnHsSyn ( RenamedMatch, RenamedGRHSs, RenamedStmt, RenamedPat, RenamedHsType,
- extractHsTyVars )
+ RenamedMatchContext, extractHsTyVars )
import TcHsSyn ( TcMatch, TcGRHSs, TcStmt, TcDictBinds, TypecheckedPat )
import TcMonad
-import TcMonoType ( kcHsSigTypes, tcScopedTyVars, checkSigTyVars, tcHsSigType, sigPatCtxt )
+import TcMonoType ( kcHsSigTypes, tcAddScopedTyVars, checkSigTyVars, tcHsSigType, UserTypeCtxt(..), sigPatCtxt )
import Inst ( LIE, isEmptyLIE, plusLIE, emptyLIE, plusLIEs, lieToList )
import TcEnv ( TcId, tcLookupLocalIds, tcExtendLocalValEnv, tcExtendGlobalTyVars,
tcInLocalScope )
import TcPat ( tcPat, tcMonoPatBndr, polyPatSig )
-import TcType ( TcType, newTyVarTy )
+import TcMType ( newTyVarTy, unifyFunTy, unifyTauTy )
+import TcType ( TcType, TcTyVar, tyVarsOfType, isTauTy,
+ mkFunTy, isOverloadedTy, liftedTypeKind, openTypeKind )
import TcBinds ( tcBindsAndThen )
import TcSimplify ( tcSimplifyCheck, bindInstsOfLocalFuns )
-import TcUnify ( unifyFunTy, unifyTauTy )
import Name ( Name )
import TysWiredIn ( boolTy )
import Id ( idType )
import BasicTypes ( RecFlag(..) )
-import Type ( tyVarsOfType, isTauTy, mkFunTy,
- liftedTypeKind, openTypeKind, splitSigmaTy )
import NameSet
import VarSet
import Var ( Id )
import Bag
+import Util ( isSingleton )
import Outputable
+
import List ( nub )
\end{code}
-- may show up as something wrong with the (non-existent) type signature
-- No need to zonk expected_ty, because unifyFunTy does that on the fly
- tcMatches xve matches expected_ty (FunRhs fun_name)
+ tcMatches xve (FunRhs fun_name) matches expected_ty
\end{code}
@tcMatchesCase@ doesn't do the argument-count check because the
tcMatchesCase matches expr_ty
= newTyVarTy openTypeKind `thenNF_Tc` \ scrut_ty ->
- tcMatches [] matches (mkFunTy scrut_ty expr_ty) CaseAlt `thenTc` \ (matches', lie) ->
+ tcMatches [] CaseAlt matches (mkFunTy scrut_ty expr_ty) `thenTc` \ (matches', lie) ->
returnTc (scrut_ty, matches', lie)
tcMatchLambda :: RenamedMatch -> TcType -> TcM (TcMatch, LIE)
-tcMatchLambda match res_ty = tcMatch [] match res_ty LambdaExpr
+tcMatchLambda match res_ty = tcMatch [] LambdaExpr match res_ty
\end{code}
\begin{code}
tcMatches :: [(Name,Id)]
+ -> RenamedMatchContext
-> [RenamedMatch]
-> TcType
- -> HsMatchContext
-> TcM ([TcMatch], LIE)
-tcMatches xve matches expected_ty fun_or_case
+tcMatches xve fun_or_case matches expected_ty
= mapAndUnzipTc tc_match matches `thenTc` \ (matches, lies) ->
returnTc (matches, plusLIEs lies)
where
- tc_match match = tcMatch xve match expected_ty fun_or_case
+ tc_match match = tcMatch xve fun_or_case match expected_ty
\end{code}
\begin{code}
tcMatch :: [(Name,Id)]
+ -> RenamedMatchContext
-> RenamedMatch
- -> TcType -- Expected result-type of the Match.
- -- Early unification with this guy gives better error messages
- -> HsMatchContext
+ -> TcType -- Expected result-type of the Match.
+ -- Early unification with this guy gives better error messages
+ -- We regard the Match as having type
+ -- (ty1 -> ... -> tyn -> result_ty)
+ -- where there are n patterns.
-> TcM (TcMatch, LIE)
-tcMatch xve1 match@(Match sig_tvs pats maybe_rhs_sig grhss) expected_ty ctxt
- = tcMatchPats pats expected_ty tc_grhss `thenTc` \ ((pats', grhss'), lie, ex_binds) ->
- returnTc (Match [] pats' Nothing (glue_on Recursive ex_binds grhss'), lie)
+tcMatch xve1 ctxt match@(Match pats maybe_rhs_sig grhss) expected_ty
+ = tcAddSrcLoc (getMatchLoc match) $ -- At one stage I removed this;
+ tcAddErrCtxt (matchCtxt ctxt match) $ -- I'm not sure why, so I put it back
+
+ tcMatchPats pats expected_ty tc_grhss `thenTc` \ ((pats', grhss'), lie, ex_binds) ->
+ returnTc (Match pats' Nothing (glue_on Recursive ex_binds grhss'), lie)
where
tc_grhss pats' rhs_ty
= -- Check that the remaining "expected type" is not a rank-2 type
-- If it is it'll mess up the unifier when checking the RHS
- checkTc (isTauTy rhs_ty) lurkingRank2SigErr `thenTc_`
+ checkTc (isTauTy rhs_ty) lurkingRank2SigErr `thenTc` \_ ->
-- Deal with the result signature
- tc_result_sig maybe_rhs_sig (
+ -- It "wraps" the rest of the body typecheck because it may
+ -- bring into scope the type variables in the signature
+ tc_result_sig maybe_rhs_sig rhs_ty $
-- Typecheck the body
- tcExtendLocalValEnv xve1 $
- tcGRHSs grhss rhs_ty ctxt `thenTc` \ (grhss', lie) ->
- returnTc ((pats', grhss'), lie)
- )
+ tcExtendLocalValEnv xve1 $
+ tcGRHSs ctxt grhss rhs_ty `thenTc` \ (grhss', lie) ->
+ returnTc ((pats', grhss'), lie)
- tc_result_sig Nothing thing_inside
+ tc_result_sig Nothing rhs_ty thing_inside
= thing_inside
- tc_result_sig (Just sig) thing_inside
+ tc_result_sig (Just sig) rhs_ty thing_inside
= tcAddScopedTyVars [sig] $
- tcHsSigType sig `thenTc` \ sig_ty ->
+ tcHsSigType ResSigCtxt sig `thenTc` \ sig_ty ->
-- Check that the signature isn't a polymorphic one, which
-- we don't permit (at present, anyway)
checkTc (isTauTy sig_ty) (polyPatSig sig_ty) `thenTc_`
- unifyTauTy expected_ty sig_ty `thenTc_`
+ unifyTauTy sig_ty rhs_ty `thenTc_`
thing_inside
glue_on is_rec mbinds (GRHSs grhss binds ty)
= GRHSs grhss (mkMonoBind mbinds [] is_rec `ThenBinds` binds) ty
-tcGRHSs :: RenamedGRHSs
- -> TcType -> HsMatchContext
+tcGRHSs :: RenamedMatchContext -> RenamedGRHSs
+ -> TcType
-> TcM (TcGRHSs, LIE)
-tcGRHSs (GRHSs grhss binds _) expected_ty ctxt
+tcGRHSs ctxt (GRHSs grhss binds _) expected_ty
= tcBindsAndThen glue_on binds (tc_grhss grhss)
where
tc_grhss grhss
= mapAndUnzipTc tc_grhs grhss `thenTc` \ (grhss', lies) ->
- returnTc (GRHSs grhss' EmptyBinds (Just expected_ty), plusLIEs lies)
+ returnTc (GRHSs grhss' EmptyBinds expected_ty, plusLIEs lies)
tc_grhs (GRHS guarded locn)
= tcAddSrcLoc locn $
tcMatchPats pats expected_ty thing_inside
= -- STEP 1: Bring pattern-signature type variables into scope
- tcAddScopedTyVars (collectSigTysFromPats pats) $
+ tcAddScopedTyVars (collectSigTysFromPats pats) (
-- STEP 2: Typecheck the patterns themselves, gathering all the stuff
- tc_match_pats pats expected_ty `thenTc` \ (rhs_ty, pats', lie_req1, ex_tvs, pat_bndrs, lie_avail) ->
+ tc_match_pats pats expected_ty `thenTc` \ (rhs_ty, pats', lie_req1, ex_tvs, pat_bndrs, lie_avail) ->
-- STEP 3: Extend the environment, and do the thing inside
- let
+ let
xve = bagToList pat_bndrs
pat_ids = map snd xve
- in
- tcExtendLocalValEnv xve (thing_inside pats' rhs_ty) `thenTc` \ (result, lie_req2) ->
+ in
+ tcExtendLocalValEnv xve (thing_inside pats' rhs_ty) `thenTc` \ (result, lie_req2) ->
+
+ returnTc (rhs_ty, lie_req1, ex_tvs, pat_ids, lie_avail, result, lie_req2)
+ ) `thenTc` \ (rhs_ty, lie_req1, ex_tvs, pat_ids, lie_avail, result, lie_req2) ->
-- STEP 4: Check for existentially bound type variables
+ -- Do this *outside* the scope of the tcAddScopedTyVars, else checkSigTyVars
+ -- complains that 'a' is captured by the inscope 'a'! (Test (d) in checkSigTyVars.)
+ --
-- I'm a bit concerned that lie_req1 from an 'inner' pattern in the list
-- might need (via lie_req2) something made available from an 'outer'
-- pattern. But it's inconvenient to deal with, and I can't find an example
- tcCheckExistentialPat pat_ids ex_tvs lie_avail lie_req1 rhs_ty `thenTc` \ (lie_req1', ex_binds) ->
-
- returnTc (result, lie_req1' `plusLIE` lie_req2, ex_binds)
-
-tcAddScopedTyVars :: [RenamedHsType] -> TcM a -> TcM a
--- 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 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
- tcScopedTyVars sig_tvs (kcHsSigTypes sig_tys) thing_inside
+ tcCheckExistentialPat pat_ids ex_tvs lie_avail lie_req2 expected_ty `thenTc` \ (lie_req2', ex_binds) ->
+ -- NB: we *must* pass "expected_ty" not "result_ty" to tcCheckExistentialPat
+ -- For example, we must reject this program:
+ -- data C = forall a. C (a -> Int)
+ -- f (C g) x = g x
+ -- Here, result_ty will be simply Int, but expected_ty is (a -> Int).
+
+ returnTc (result, lie_req1 `plusLIE` lie_req2', ex_binds)
tcCheckExistentialPat :: [TcId] -- Ids bound by this pattern
-> Bag TcTyVar -- Existentially quantified tyvars bound by pattern
-> LIE -- and context
-> LIE -- Required context
- -> TcType -- and result type; vars in here must not escape
+ -> TcType -- and type of the Match; vars in here must not escape
-> TcM (LIE, TcDictBinds) -- LIE to float out and dict bindings
-tcCheckExistentialPat ids ex_tvs lie_avail lie_req result_ty
+tcCheckExistentialPat ids ex_tvs lie_avail lie_req match_ty
| isEmptyBag ex_tvs && all not_overloaded ids
-- Short cut for case when there are no existentials
-- and no polymorphic overloaded variables
returnTc (lie_req, EmptyMonoBinds)
| otherwise
- = tcExtendGlobalTyVars (tyVarsOfType result_ty) $
+ = tcExtendGlobalTyVars (tyVarsOfType match_ty) $
tcAddErrCtxtM (sigPatCtxt tv_list ids) $
-- In case there are any polymorpic, overloaded binders in the pattern
bindInstsOfLocalFuns lie_req ids `thenTc` \ (lie1, inst_binds) ->
-- Deal with overloaded functions bound by the pattern
- tcSimplifyCheck doc tv_list
- (lieToList lie_avail) lie1 `thenTc` \ (lie2, dict_binds) ->
+ tcSimplifyCheck doc tv_list (lieToList lie_avail) lie1 `thenTc` \ (lie2, dict_binds) ->
checkSigTyVars tv_list emptyVarSet `thenTc_`
returnTc (lie2, dict_binds `AndMonoBinds` inst_binds)
where
doc = text ("the existential context of a data constructor")
tv_list = bagToList ex_tvs
- not_overloaded id = case splitSigmaTy (idType id) of
- (_, theta, _) -> null theta
+ not_overloaded id = not (isOverloadedTy (idType id))
tc_match_pats [] expected_ty
= returnTc (expected_ty, [], emptyLIE, emptyBag, emptyBag, emptyLIE)
tcStmtsAndThen
:: (TcStmt -> thing -> thing) -- Combiner
- -> HsMatchContext
+ -> RenamedMatchContext
-> (TcType -> TcType, TcType) -- m, the relationship type of pat and rhs in pat <- rhs
-- elt_ty, where type of the comprehension is (m elt_ty)
-> [RenamedStmt]
loop ((bndrs,stmts) : pairs)
= tcStmtsAndThen
- combine_par ListComp m_ty stmts
+ combine_par (DoCtxt ListComp) m_ty stmts
-- Notice we pass on m_ty; the result type is used only
-- to get escaping type variables for checkExistentialPat
(tcLookupLocalIds bndrs `thenNF_Tc` \ bndrs' ->
combine_par stmt (stmts, thing) = (stmt:stmts, thing)
-- ExprStmt
-tcStmtAndThen combine do_or_lc m_ty@(m, res_elt_ty) stmt@(ExprStmt exp locn) thing_inside
+tcStmtAndThen combine do_or_lc m_ty@(m, res_elt_ty) stmt@(ExprStmt exp _ locn) thing_inside
= tcSetErrCtxt (stmtCtxt do_or_lc stmt) (
if isDoExpr do_or_lc then
newTyVarTy openTypeKind `thenNF_Tc` \ any_ty ->
- tcExpr exp (m any_ty)
+ tcExpr exp (m any_ty) `thenNF_Tc` \ (exp', lie) ->
+ returnTc (ExprStmt exp' any_ty locn, lie)
else
- tcExpr exp boolTy
- ) `thenTc` \ (exp', stmt_lie) ->
+ tcExpr exp boolTy `thenNF_Tc` \ (exp', lie) ->
+ returnTc (ExprStmt exp' boolTy locn, lie)
+ ) `thenTc` \ (stmt', stmt_lie) ->
thing_inside `thenTc` \ (thing, stmts_lie) ->
- returnTc (combine (ExprStmt exp' locn) thing,
- stmt_lie `plusLIE` stmts_lie)
+ returnTc (combine stmt' thing, stmt_lie `plusLIE` stmts_lie)
-- Result statements
\begin{code}
sameNoOfArgs :: [RenamedMatch] -> Bool
-sameNoOfArgs matches = length (nub (map args_in_match matches)) == 1
+sameNoOfArgs matches = isSingleton (nub (map args_in_match matches))
where
args_in_match :: RenamedMatch -> Int
- args_in_match (Match _ pats _ _) = length pats
+ args_in_match (Match pats _ _) = length pats
\end{code}
\begin{code}
-matchCtxt CaseAlt match
- = hang (ptext SLIT("In a case alternative:"))
- 4 (pprMatch (True,empty) {-is_case-} match)
-
-matchCtxt (FunRhs fun) match
- = hang (hcat [ptext SLIT("In an equation for function "), quotes (ppr_fun), char ':'])
- 4 (pprMatch (False, ppr_fun) {-not case-} match)
- where
- ppr_fun = ppr fun
-
-matchCtxt LambdaExpr match
- = hang (ptext SLIT("In the lambda expression"))
- 4 (pprMatch (True, empty) match)
+matchCtxt ctxt match = hang (pprMatchContext ctxt <> colon) 4 (pprMatch ctxt match)
+stmtCtxt do_or_lc stmt = hang (pprMatchContext do_or_lc <> colon) 4 (ppr stmt)
varyingArgsErr name matches
= sep [ptext SLIT("Varying number of arguments for function"), quotes (ppr name)]
lurkingRank2SigErr
= ptext SLIT("Too few explicit arguments when defining a function with a rank-2 type")
-
-stmtCtxt do_or_lc stmt = hang (pprMatchContext do_or_lc <> colon) 4 (ppr stmt)
\end{code}
projects / ghc-hetmet.git / blobdiff