import {-# SOURCE #-} TcExpr( tcCheckRho, tcInferRho )
import HsSyn
-import TcHsSyn ( mkHsLet )
+import TcHsSyn ( mkHsDictLet )
import TcMatches ( tcMatchPats, matchCtxt, tcStmts, tcMDoStmt, tcGuardStmt,
TcMatchCtxt(..), tcMatchesCase )
mkTyVarTy, mkAppTys, tcSplitTyConApp_maybe, tcEqType,
SkolemInfo(..) )
import TcMType ( newTyFlexiVarTy, newTyFlexiVarTys, tcSkolTyVars, zonkTcType )
-import TcBinds ( tcBindsAndThen )
+import TcBinds ( tcLocalBinds )
import TcSimplify ( tcSimplifyCheck )
import TcUnify ( Expected(..), checkSigTyVarsWrt, zapExpectedTo )
import TcRnMonad
tcProc pat cmd exp_ty
-- gaw 2004 FIX?
- = do { arr_ty <- newTyFlexiVarTy arrowTyConKind
+ = newArrowScope $ do
+ { arr_ty <- newTyFlexiVarTy arrowTyConKind
; [arg_ty, res_ty] <- newTyFlexiVarTys 2 liftedTypeKind
; zapExpectedTo exp_ty (mkAppTys arr_ty [arg_ty,res_ty])
; let cmd_env = CmdEnv { cmd_arr = arr_ty }
- ; ([pat'], cmd') <- incProcLevel $
- tcMatchPats [pat] [Check arg_ty] (Check res_ty) $
+ ; ([pat'], cmd') <- tcMatchPats [pat] [Check arg_ty] (Check res_ty) $
tcCmdTop cmd_env cmd ([], res_ty)
-- The False says don't do GADT type refinement
-- This is a conservative choice, but I'm not sure of the consequences
\begin{code}
type CmdStack = [TcTauType]
-data CmdEnv = CmdEnv { cmd_arr :: TcType } -- The arrow type constructor, of kind *->*->*
+data CmdEnv
+ = CmdEnv {
+ cmd_arr :: TcType -- arrow type constructor, of kind *->*->*
+ }
mkCmdArrTy :: CmdEnv -> TcTauType -> TcTauType -> TcTauType
mkCmdArrTy env t1 t2 = mkAppTys (cmd_arr env) [t1, t2]
; return (HsPar cmd') }
tc_cmd env (HsLet binds (L body_loc body)) res_ty
- = tcBindsAndThen glue binds $
- setSrcSpan body_loc $
- tc_cmd env body res_ty
- where
- glue binds expr = HsLet [binds] (L body_loc expr)
+ = do { (binds', body') <- tcLocalBinds binds $
+ setSrcSpan body_loc $
+ tc_cmd env body res_ty
+ ; return (HsLet binds' (L body_loc body')) }
tc_cmd env in_cmd@(HsCase scrut matches) (stk, res_ty)
= addErrCtxt (cmdCtxt in_cmd) $
do { arg_ty <- newTyFlexiVarTy openTypeKind
; let fun_ty = mkCmdArrTy env (foldl mkPairTy arg_ty cmd_stk) res_ty
- ; fun' <- pop_arrow_binders (tcCheckRho fun fun_ty)
+ ; fun' <- select_arrow_scope (tcCheckRho fun fun_ty)
; arg' <- tcCheckRho arg arg_ty
; return (HsArrApp fun' arg' fun_ty ho_app lr) }
where
- -- Before type-checking f, remove the "arrow binders" from the
- -- environment in the (-<) case.
+ -- Before type-checking f, use the environment of the enclosing
+ -- proc for the (-<) case.
-- Local bindings, inside the enclosing proc, are not in scope
-- inside f. In the higher-order case (-<<), they are.
- pop_arrow_binders tc = case ho_app of
+ select_arrow_scope tc = case ho_app of
HsHigherOrderApp -> tc
- HsFirstOrderApp -> popArrowBinders tc
+ HsFirstOrderApp -> escapeArrowScope tc
-------------------------------------------
-- Command application
pg_ctxt = PatGuard match_ctxt
tc_grhss (GRHSs grhss binds)
- = tcBindsAndThen glueBindsOnGRHSs binds $
- do { grhss' <- mappM (wrapLocM tc_grhs) grhss
- ; return (GRHSs grhss' []) }
+ = do { (binds', grhss') <- tcLocalBinds binds $
+ mappM (wrapLocM tc_grhs) grhss
+ ; return (GRHSs grhss' binds') }
tc_grhs (GRHS guards body)
= do { (guards', rhs') <- tcStmts pg_ctxt
e_res_ty
-- Check expr
- ; (expr', lie) <- popArrowBinders (getLIE (tcCheckRho expr e_ty))
+ ; (expr', lie) <- escapeArrowScope (getLIE (tcCheckRho expr e_ty))
; inst_binds <- tcSimplifyCheck sig_msg [w_tv] [] lie
-- Check that the polymorphic variable hasn't been unified with anything
-- the s1..sm and check each cmd
; cmds' <- mapM (tc_cmd w_tv) cmds_w_tys
- ; returnM (HsArrForm (mkHsTyLam [w_tv] (mkHsLet inst_binds expr')) fixity cmds')
+ ; returnM (HsArrForm (mkHsTyLam [w_tv] (mkHsDictLet inst_binds expr')) fixity cmds')
}
where
-- Make the types
not (w_tv `elemVarSet` tyVarsOfTypes arg_tys))
(badFormFun i tup_ty')
- ; tcCmdTop (CmdEnv { cmd_arr = b }) cmd (arg_tys, s) }
+ ; tcCmdTop (env { cmd_arr = b }) cmd (arg_tys, s) }
unscramble :: TcType -> (TcType, [TcType])
-- unscramble ((w,s1) .. sn) = (w, [s1..sn])