#include "HsVersions.h"
-import {-# SOURCE #-} TcExpr( tcExpr )
+import {-# SOURCE #-} TcExpr( tcMonoExpr )
import HsSyn ( HsBinds(..), Match(..), GRHSs(..), GRHS(..),
MonoBinds(..), Stmt(..), HsMatchContext(..), HsDoContext(..),
pprMatch, getMatchLoc, pprMatchContext, isDoExpr,
mkMonoBind, nullMonoBinds, collectSigTysFromPats
)
-import RnHsSyn ( RenamedMatch, RenamedGRHSs, RenamedStmt, RenamedPat, RenamedHsType,
- RenamedMatchContext, extractHsTyVars )
+import RnHsSyn ( RenamedMatch, RenamedGRHSs, RenamedStmt, RenamedPat, RenamedMatchContext )
import TcHsSyn ( TcMatch, TcGRHSs, TcStmt, TcDictBinds, TypecheckedPat )
import TcMonad
-import TcMonoType ( kcHsSigTypes, tcAddScopedTyVars, checkSigTyVars, tcHsSigType, UserTypeCtxt(..), sigPatCtxt )
+import TcMonoType ( tcAddScopedTyVars, tcHsSigType, UserTypeCtxt(..) )
import Inst ( LIE, isEmptyLIE, plusLIE, emptyLIE, plusLIEs, lieToList )
-import TcEnv ( TcId, tcLookupLocalIds, tcExtendLocalValEnv, tcExtendGlobalTyVars,
- tcInLocalScope )
-import TcPat ( tcPat, tcMonoPatBndr, polyPatSig )
-import TcMType ( newTyVarTy, unifyFunTy, unifyTauTy )
-import TcType ( TcType, TcTyVar, tyVarsOfType, isTauTy,
+import TcEnv ( TcId, tcLookupLocalIds, tcExtendLocalValEnv, tcExtendGlobalTyVars )
+import TcPat ( tcPat, tcMonoPatBndr )
+import TcMType ( newTyVarTy )
+import TcType ( TcType, TcTyVar, tyVarsOfType,
mkFunTy, isOverloadedTy, liftedTypeKind, openTypeKind )
import TcBinds ( tcBindsAndThen )
+import TcUnify ( subFunTy, checkSigTyVars, tcSub, isIdCoercion, (<$>), sigPatCtxt )
import TcSimplify ( tcSimplifyCheck, bindInstsOfLocalFuns )
import Name ( Name )
import TysWiredIn ( boolTy )
import Id ( idType )
import BasicTypes ( RecFlag(..) )
-import NameSet
import VarSet
import Var ( Id )
import Bag
-- because inconsistency between branches
-- 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
+ -- No need to zonk expected_ty, because subFunTy does that on the fly
tcMatches xve (FunRhs fun_name) matches expected_ty
\end{code}
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` \_ ->
+ = tcExtendLocalValEnv xve1 $
-- Deal with the result signature
- -- 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 ctxt grhss rhs_ty `thenTc` \ (grhss', lie) ->
- returnTc ((pats', grhss'), lie)
-
- tc_result_sig Nothing rhs_ty thing_inside
- = thing_inside
- tc_result_sig (Just sig) rhs_ty thing_inside
- = tcAddScopedTyVars [sig] $
- 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 sig_ty rhs_ty `thenTc_`
- thing_inside
-
-
- -- glue_on just avoids stupid dross
+ case maybe_rhs_sig of
+ Nothing -> tcGRHSs ctxt grhss rhs_ty `thenTc` \ (grhss', lie) ->
+ returnTc ((pats', grhss'), lie)
+
+ Just sig -> tcAddScopedTyVars [sig] $
+ -- Bring into scope the type variables in the signature
+ tcHsSigType ResSigCtxt sig `thenTc` \ sig_ty ->
+ tcGRHSs ctxt grhss sig_ty `thenTc` \ (grhss', lie1) ->
+ tcSub rhs_ty sig_ty `thenTc` \ (co_fn, lie2) ->
+ returnTc ((pats', lift_grhss co_fn rhs_ty grhss'),
+ lie1 `plusLIE` lie2)
+
+-- lift_grhss pushes the coercion down to the right hand sides,
+-- because there is no convenient place to hang it otherwise.
+lift_grhss co_fn rhs_ty grhss
+ | isIdCoercion co_fn = grhss
+lift_grhss co_fn rhs_ty (GRHSs grhss binds ty)
+ = GRHSs (map lift_grhs grhss) binds rhs_ty -- Change the type, since we
+ where
+ lift_grhs (GRHS stmts loc) = GRHS (map lift_stmt stmts) loc
+
+ lift_stmt (ResultStmt e l) = ResultStmt (co_fn <$> e) l
+ lift_stmt stmt = stmt
+
+-- glue_on just avoids stupid dross
glue_on _ EmptyMonoBinds grhss = grhss -- The common case
glue_on is_rec mbinds (GRHSs grhss binds ty)
= GRHSs grhss (mkMonoBind mbinds [] is_rec `ThenBinds` binds) ty
+
tcGRHSs :: RenamedMatchContext -> RenamedGRHSs
-> TcType
-> TcM (TcGRHSs, LIE)
= returnTc (expected_ty, [], emptyLIE, emptyBag, emptyBag, emptyLIE)
tc_match_pats (pat:pats) expected_ty
- = unifyFunTy expected_ty `thenTc` \ (arg_ty, rest_ty) ->
+ = subFunTy expected_ty `thenTc` \ (arg_ty, rest_ty) ->
+ -- This is the unique place we call subFunTy
+ -- The point is that if expected_y is a "hole", we want
+ -- to make arg_ty and rest_ty as "holes" too.
tcPat tcMonoPatBndr pat arg_ty `thenTc` \ (pat', lie_req, pat_tvs, pat_ids, lie_avail) ->
tc_match_pats pats rest_ty `thenTc` \ (rhs_ty, pats', lie_reqs, pats_tvs, pats_ids, lie_avails) ->
returnTc ( rhs_ty,
= tcAddSrcLoc src_loc $
tcAddErrCtxt (stmtCtxt do_or_lc stmt) $
newTyVarTy liftedTypeKind `thenNF_Tc` \ pat_ty ->
- tcExpr exp (m pat_ty) `thenTc` \ (exp', exp_lie) ->
+ tcMonoExpr exp (m pat_ty) `thenTc` \ (exp', exp_lie) ->
tcMatchPats [pat] (mkFunTy pat_ty (m elt_ty)) (\ [pat'] _ ->
tcPopErrCtxt $
thing_inside `thenTc` \ (thing, lie) ->
= tcSetErrCtxt (stmtCtxt do_or_lc stmt) (
if isDoExpr do_or_lc then
newTyVarTy openTypeKind `thenNF_Tc` \ any_ty ->
- tcExpr exp (m any_ty) `thenNF_Tc` \ (exp', lie) ->
+ tcMonoExpr exp (m any_ty) `thenNF_Tc` \ (exp', lie) ->
returnTc (ExprStmt exp' any_ty locn, lie)
else
- tcExpr exp boolTy `thenNF_Tc` \ (exp', lie) ->
+ tcMonoExpr exp boolTy `thenNF_Tc` \ (exp', lie) ->
returnTc (ExprStmt exp' boolTy locn, lie)
) `thenTc` \ (stmt', stmt_lie) ->
tcStmtAndThen combine do_or_lc m_ty@(m, res_elt_ty) stmt@(ResultStmt exp locn) thing_inside
= tcSetErrCtxt (stmtCtxt do_or_lc stmt) (
if isDoExpr do_or_lc then
- tcExpr exp (m res_elt_ty)
+ tcMonoExpr exp (m res_elt_ty)
else
- tcExpr exp res_elt_ty
+ tcMonoExpr exp res_elt_ty
) `thenTc` \ (exp', stmt_lie) ->
thing_inside `thenTc` \ (thing, stmts_lie) ->
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")
\end{code}