Fold integer-gmp.git into ghc.git (re #8545)
[ghc.git] / compiler / typecheck / TcArrows.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5 Typecheck arrow notation
6
7 \begin{code}
8 {-# OPTIONS -fno-warn-tabs #-}
9 -- The above warning supression flag is a temporary kludge.
10 -- While working on this module you are encouraged to remove it and
11 -- detab the module (please do the detabbing in a separate patch). See
12 --     http://ghc.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
13 -- for details
14
15 module TcArrows ( tcProc ) where
16
17 import {-# SOURCE #-}   TcExpr( tcMonoExpr, tcInferRho, tcSyntaxOp, tcCheckId, tcPolyExpr )
18
19 import HsSyn
20 import TcMatches
21 import TcHsSyn( hsLPatType )
22 import TcType
23 import TcMType
24 import TcBinds
25 import TcPat
26 import TcUnify
27 import TcRnMonad
28 import TcEnv
29 import TcEvidence
30 import Id( mkLocalId )
31 import Inst
32 import Name
33 import Coercion ( Role(..) )
34 import TysWiredIn
35 import VarSet 
36 import TysPrim
37 import BasicTypes( Arity )
38 import SrcLoc
39 import Outputable
40 import FastString
41 import Util
42
43 import Control.Monad
44 \end{code}
45
46 Note [Arrow overivew]
47 ~~~~~~~~~~~~~~~~~~~~~
48 Here's a summary of arrows and how they typecheck.  First, here's
49 a cut-down syntax:
50
51   expr ::= ....  
52         |  proc pat cmd
53
54   cmd ::= cmd exp                    -- Arrow application
55        |  \pat -> cmd                -- Arrow abstraction
56        |  (| exp cmd1 ... cmdn |)    -- Arrow form, n>=0
57        |  ... -- If, case in the usual way
58
59   cmd_type ::= carg_type --> type
60
61   carg_type ::= ()
62              |  (type, carg_type)
63
64 Note that
65  * The 'exp' in an arrow form can mention only 
66    "arrow-local" variables
67
68  * An "arrow-local" variable is bound by an enclosing
69    cmd binding form (eg arrow abstraction)
70
71  * A cmd_type is here written with a funny arrow "-->",
72    The bit on the left is a carg_type (command argument type)
73    which itself is a nested tuple, finishing with ()
74
75  * The arrow-tail operator (e1 -< e2) means
76        (| e1 <<< arr snd |) e2
77
78
79 %************************************************************************
80 %*                                                                      *
81                 Proc    
82 %*                                                                      *
83 %************************************************************************
84
85 \begin{code}
86 tcProc :: InPat Name -> LHsCmdTop Name          -- proc pat -> expr
87        -> TcRhoType                             -- Expected type of whole proc expression
88        -> TcM (OutPat TcId, LHsCmdTop TcId, TcCoercion)
89
90 tcProc pat cmd exp_ty
91   = newArrowScope $
92     do  { (co, (exp_ty1, res_ty)) <- matchExpectedAppTy exp_ty 
93         ; (co1, (arr_ty, arg_ty)) <- matchExpectedAppTy exp_ty1
94         ; let cmd_env = CmdEnv { cmd_arr = arr_ty }
95         ; (pat', cmd') <- tcPat ProcExpr pat arg_ty $
96                           tcCmdTop cmd_env cmd (unitTy, res_ty)
97         ; let res_co = mkTcTransCo co (mkTcAppCo co1 (mkTcNomReflCo res_ty))
98         ; return (pat', cmd', res_co) }
99 \end{code}
100
101
102 %************************************************************************
103 %*                                                                      *
104                 Commands
105 %*                                                                      *
106 %************************************************************************
107
108 \begin{code}
109 -- See Note [Arrow overview]      
110 type CmdType    = (CmdArgType, TcTauType)    -- cmd_type 
111 type CmdArgType = TcTauType                  -- carg_type, a nested tuple
112
113 data CmdEnv
114   = CmdEnv {
115         cmd_arr :: TcType -- arrow type constructor, of kind *->*->*
116     }
117
118 mkCmdArrTy :: CmdEnv -> TcTauType -> TcTauType -> TcTauType
119 mkCmdArrTy env t1 t2 = mkAppTys (cmd_arr env) [t1, t2]
120
121 ---------------------------------------
122 tcCmdTop :: CmdEnv 
123          -> LHsCmdTop Name
124          -> CmdType
125          -> TcM (LHsCmdTop TcId)
126
127 tcCmdTop env (L loc (HsCmdTop cmd _ _ names)) cmd_ty@(cmd_stk, res_ty)
128   = setSrcSpan loc $
129     do  { cmd'   <- tcCmd env cmd cmd_ty
130         ; names' <- mapM (tcSyntaxName ProcOrigin (cmd_arr env)) names
131         ; return (L loc $ HsCmdTop cmd' cmd_stk res_ty names') }
132 ----------------------------------------
133 tcCmd  :: CmdEnv -> LHsCmd Name -> CmdType -> TcM (LHsCmd TcId)
134         -- The main recursive function
135 tcCmd env (L loc cmd) res_ty
136   = setSrcSpan loc $ do
137         { cmd' <- tc_cmd env cmd res_ty
138         ; return (L loc cmd') }
139
140 tc_cmd :: CmdEnv -> HsCmd Name  -> CmdType -> TcM (HsCmd TcId)
141 tc_cmd env (HsCmdPar cmd) res_ty
142   = do  { cmd' <- tcCmd env cmd res_ty
143         ; return (HsCmdPar cmd') }
144
145 tc_cmd env (HsCmdLet binds (L body_loc body)) res_ty
146   = do  { (binds', body') <- tcLocalBinds binds         $
147                              setSrcSpan body_loc        $
148                              tc_cmd env body res_ty
149         ; return (HsCmdLet binds' (L body_loc body')) }
150
151 tc_cmd env in_cmd@(HsCmdCase scrut matches) (stk, res_ty)
152   = addErrCtxt (cmdCtxt in_cmd) $ do
153       (scrut', scrut_ty) <- tcInferRho scrut 
154       matches' <- tcMatchesCase match_ctxt scrut_ty matches res_ty
155       return (HsCmdCase scrut' matches')
156   where
157     match_ctxt = MC { mc_what = CaseAlt,
158                       mc_body = mc_body }
159     mc_body body res_ty' = tcCmd env body (stk, res_ty')
160
161 tc_cmd env (HsCmdIf Nothing pred b1 b2) res_ty    -- Ordinary 'if'
162   = do  { pred' <- tcMonoExpr pred boolTy
163         ; b1'   <- tcCmd env b1 res_ty
164         ; b2'   <- tcCmd env b2 res_ty
165         ; return (HsCmdIf Nothing pred' b1' b2')
166     }
167
168 tc_cmd env (HsCmdIf (Just fun) pred b1 b2) res_ty -- Rebindable syntax for if
169   = do  { pred_ty <- newFlexiTyVarTy openTypeKind
170         -- For arrows, need ifThenElse :: forall r. T -> r -> r -> r
171         -- because we're going to apply it to the environment, not
172         -- the return value.
173         ; (_, [r_tv]) <- tcInstSkolTyVars [alphaTyVar]
174         ; let r_ty = mkTyVarTy r_tv
175         ; let if_ty = mkFunTys [pred_ty, r_ty, r_ty] r_ty
176         ; checkTc (not (r_tv `elemVarSet` tyVarsOfType pred_ty))
177                   (ptext (sLit "Predicate type of `ifThenElse' depends on result type"))
178         ; fun'  <- tcSyntaxOp IfOrigin fun if_ty
179         ; pred' <- tcMonoExpr pred pred_ty
180         ; b1'   <- tcCmd env b1 res_ty
181         ; b2'   <- tcCmd env b2 res_ty
182         ; return (HsCmdIf (Just fun') pred' b1' b2')
183     }
184
185 -------------------------------------------
186 --              Arrow application
187 --          (f -< a)   or   (f -<< a)
188 --
189 --   D   |- fun :: a t1 t2
190 --   D,G |- arg :: t1
191 --  ------------------------
192 --   D;G |-a  fun -< arg :: stk --> t2
193 --
194 --   D,G |- fun :: a t1 t2
195 --   D,G |- arg :: t1
196 --  ------------------------
197 --   D;G |-a  fun -<< arg :: stk --> t2
198 --
199 -- (plus -<< requires ArrowApply)
200
201 tc_cmd env cmd@(HsCmdArrApp fun arg _ ho_app lr) (_, res_ty)
202   = addErrCtxt (cmdCtxt cmd)    $
203     do  { arg_ty <- newFlexiTyVarTy openTypeKind
204         ; let fun_ty = mkCmdArrTy env arg_ty res_ty
205         ; fun' <- select_arrow_scope (tcMonoExpr fun fun_ty)
206              -- ToDo: There should be no need for the escapeArrowScope stuff
207              -- See Note [Escaping the arrow scope] in TcRnTypes
208
209         ; arg' <- tcMonoExpr arg arg_ty
210
211         ; return (HsCmdArrApp fun' arg' fun_ty ho_app lr) }
212   where
213        -- Before type-checking f, use the environment of the enclosing
214        -- proc for the (-<) case.  
215        -- Local bindings, inside the enclosing proc, are not in scope 
216        -- inside f.  In the higher-order case (-<<), they are.
217     select_arrow_scope tc = case ho_app of
218         HsHigherOrderApp -> tc
219         HsFirstOrderApp  -> escapeArrowScope tc
220
221 -------------------------------------------
222 --              Command application
223 --
224 -- D,G |-  exp : t
225 -- D;G |-a cmd : (t,stk) --> res
226 -- -----------------------------
227 -- D;G |-a cmd exp : stk --> res
228
229 tc_cmd env cmd@(HsCmdApp fun arg) (cmd_stk, res_ty)
230   = addErrCtxt (cmdCtxt cmd)    $
231     do  { arg_ty <- newFlexiTyVarTy openTypeKind
232         ; fun'   <- tcCmd env fun (mkPairTy arg_ty cmd_stk, res_ty)
233         ; arg'   <- tcMonoExpr arg arg_ty
234         ; return (HsCmdApp fun' arg') }
235
236 -------------------------------------------
237 --              Lambda
238 --
239 -- D;G,x:t |-a cmd : stk --> res
240 -- ------------------------------
241 -- D;G |-a (\x.cmd) : (t,stk) --> res
242
243 tc_cmd env 
244        (HsCmdLam (MG { mg_alts = [L mtch_loc (match@(Match pats _maybe_rhs_sig grhss))], mg_origin = origin }))
245        (cmd_stk, res_ty)
246   = addErrCtxt (pprMatchInCtxt match_ctxt match)        $
247     do  { (co, arg_tys, cmd_stk') <- matchExpectedCmdArgs n_pats cmd_stk
248
249                 -- Check the patterns, and the GRHSs inside
250         ; (pats', grhss') <- setSrcSpan mtch_loc                $
251                              tcPats LambdaExpr pats arg_tys     $
252                              tc_grhss grhss cmd_stk' res_ty
253
254         ; let match' = L mtch_loc (Match pats' Nothing grhss')
255               arg_tys = map hsLPatType pats'
256               cmd' = HsCmdLam (MG { mg_alts = [match'], mg_arg_tys = arg_tys
257                                   , mg_res_ty = res_ty, mg_origin = origin })
258         ; return (mkHsCmdCast co cmd') }
259   where
260     n_pats     = length pats
261     match_ctxt = (LambdaExpr :: HsMatchContext Name)    -- Maybe KappaExpr?
262     pg_ctxt    = PatGuard match_ctxt
263
264     tc_grhss (GRHSs grhss binds) stk_ty res_ty
265         = do { (binds', grhss') <- tcLocalBinds binds $
266                                    mapM (wrapLocM (tc_grhs stk_ty res_ty)) grhss
267              ; return (GRHSs grhss' binds') }
268
269     tc_grhs stk_ty res_ty (GRHS guards body)
270         = do { (guards', rhs') <- tcStmtsAndThen pg_ctxt tcGuardStmt guards res_ty $
271                                   \ res_ty -> tcCmd env body (stk_ty, res_ty)
272              ; return (GRHS guards' rhs') }
273
274 -------------------------------------------
275 --              Do notation
276
277 tc_cmd env (HsCmdDo stmts _) (cmd_stk, res_ty)
278   = do  { co <- unifyType unitTy cmd_stk  -- Expecting empty argument stack
279         ; stmts' <- tcStmts ArrowExpr (tcArrDoStmt env) stmts res_ty 
280         ; return (mkHsCmdCast co (HsCmdDo stmts' res_ty)) }
281
282
283 -----------------------------------------------------------------
284 --      Arrow ``forms''       (| e c1 .. cn |)
285 --
286 --      D; G |-a1 c1 : stk1 --> r1
287 --      ...
288 --      D; G |-an cn : stkn --> rn
289 --      D |-  e :: forall e. a1 (e, stk1) t1
290 --                                ...
291 --                        -> an (e, stkn) tn
292 --                        -> a  (e, stk) t
293 --      e \not\in (stk, stk1, ..., stkm, t, t1, ..., tn)
294 --      ----------------------------------------------
295 --      D; G |-a  (| e c1 ... cn |)  :  stk --> t
296
297 tc_cmd env cmd@(HsCmdArrForm expr fixity cmd_args) (cmd_stk, res_ty)    
298   = addErrCtxt (cmdCtxt cmd)    $
299     do  { (cmd_args', cmd_tys) <- mapAndUnzipM tc_cmd_arg cmd_args
300         ; let e_ty = mkForAllTy alphaTyVar $   -- We use alphaTyVar for 'w'
301                      mkFunTys cmd_tys $
302                      mkCmdArrTy env (mkPairTy alphaTy cmd_stk) res_ty
303         ; expr' <- tcPolyExpr expr e_ty
304         ; return (HsCmdArrForm expr' fixity cmd_args') }
305
306   where
307     tc_cmd_arg :: LHsCmdTop Name -> TcM (LHsCmdTop TcId, TcType)
308     tc_cmd_arg cmd
309        = do { arr_ty <- newFlexiTyVarTy arrowTyConKind
310             ; stk_ty <- newFlexiTyVarTy liftedTypeKind
311             ; res_ty <- newFlexiTyVarTy liftedTypeKind
312             ; let env' = env { cmd_arr = arr_ty }
313             ; cmd' <- tcCmdTop env' cmd (stk_ty, res_ty)
314             ; return (cmd',  mkCmdArrTy env' (mkPairTy alphaTy stk_ty) res_ty) }
315
316 -----------------------------------------------------------------
317 --              Base case for illegal commands
318 -- This is where expressions that aren't commands get rejected
319
320 tc_cmd _ cmd _
321   = failWithTc (vcat [ptext (sLit "The expression"), nest 2 (ppr cmd), 
322                       ptext (sLit "was found where an arrow command was expected")])
323
324
325 matchExpectedCmdArgs :: Arity -> TcType -> TcM (TcCoercion, [TcType], TcType)
326 matchExpectedCmdArgs 0 ty 
327   = return (mkTcNomReflCo ty, [], ty)
328 matchExpectedCmdArgs n ty
329   = do { (co1, [ty1, ty2]) <- matchExpectedTyConApp pairTyCon ty  
330        ; (co2, tys, res_ty) <- matchExpectedCmdArgs (n-1) ty2
331        ; return (mkTcTyConAppCo Nominal pairTyCon [co1, co2], ty1:tys, res_ty) }
332 \end{code}
333
334
335 %************************************************************************
336 %*                                                                      *
337                 Stmts
338 %*                                                                      *
339 %************************************************************************
340
341 \begin{code}
342 --------------------------------
343 --      Mdo-notation
344 -- The distinctive features here are
345 --      (a) RecStmts, and
346 --      (b) no rebindable syntax
347
348 tcArrDoStmt :: CmdEnv -> TcCmdStmtChecker
349 tcArrDoStmt env _ (LastStmt rhs _) res_ty thing_inside
350   = do  { rhs' <- tcCmd env rhs (unitTy, res_ty)
351         ; thing <- thing_inside (panic "tcArrDoStmt")
352         ; return (LastStmt rhs' noSyntaxExpr, thing) }
353
354 tcArrDoStmt env _ (BodyStmt rhs _ _ _) res_ty thing_inside
355   = do  { (rhs', elt_ty) <- tc_arr_rhs env rhs
356         ; thing          <- thing_inside res_ty
357         ; return (BodyStmt rhs' noSyntaxExpr noSyntaxExpr elt_ty, thing) }
358
359 tcArrDoStmt env ctxt (BindStmt pat rhs _ _) res_ty thing_inside
360   = do  { (rhs', pat_ty) <- tc_arr_rhs env rhs
361         ; (pat', thing)  <- tcPat (StmtCtxt ctxt) pat pat_ty $
362                             thing_inside res_ty
363         ; return (BindStmt pat' rhs' noSyntaxExpr noSyntaxExpr, thing) }
364
365 tcArrDoStmt env ctxt (RecStmt { recS_stmts = stmts, recS_later_ids = later_names
366                             , recS_rec_ids = rec_names }) res_ty thing_inside
367   = do  { let tup_names = rec_names ++ filterOut (`elem` rec_names) later_names
368         ; tup_elt_tys <- newFlexiTyVarTys (length tup_names) liftedTypeKind
369         ; let tup_ids = zipWith mkLocalId tup_names tup_elt_tys
370         ; tcExtendIdEnv tup_ids $ do
371         { (stmts', tup_rets)
372                 <- tcStmtsAndThen ctxt (tcArrDoStmt env) stmts res_ty   $ \ _res_ty' ->
373                         -- ToDo: res_ty not really right
374                    zipWithM tcCheckId tup_names tup_elt_tys
375
376         ; thing <- thing_inside res_ty
377                 -- NB:  The rec_ids for the recursive things 
378                 --      already scope over this part. This binding may shadow
379                 --      some of them with polymorphic things with the same Name
380                 --      (see note [RecStmt] in HsExpr)
381
382         ; let rec_ids = takeList rec_names tup_ids
383         ; later_ids <- tcLookupLocalIds later_names
384
385         ; let rec_rets = takeList rec_names tup_rets
386         ; let ret_table = zip tup_ids tup_rets
387         ; let later_rets = [r | i <- later_ids, (j, r) <- ret_table, i == j]
388
389         ; return (emptyRecStmt { recS_stmts = stmts', recS_later_ids = later_ids
390                                , recS_later_rets = later_rets
391                                , recS_rec_ids = rec_ids, recS_rec_rets = rec_rets
392                                , recS_ret_ty = res_ty }, thing)
393         }}
394
395 tcArrDoStmt _ _ stmt _ _
396   = pprPanic "tcArrDoStmt: unexpected Stmt" (ppr stmt)
397
398 tc_arr_rhs :: CmdEnv -> LHsCmd Name -> TcM (LHsCmd TcId, TcType)
399 tc_arr_rhs env rhs = do { ty <- newFlexiTyVarTy liftedTypeKind
400                         ; rhs' <- tcCmd env rhs (unitTy, ty)
401                         ; return (rhs', ty) }
402 \end{code}
403
404
405 %************************************************************************
406 %*                                                                      *
407                 Helpers
408 %*                                                                      *
409 %************************************************************************
410
411
412 \begin{code}
413 mkPairTy :: Type -> Type -> Type
414 mkPairTy t1 t2 = mkTyConApp pairTyCon [t1,t2]
415
416 arrowTyConKind :: Kind          --  *->*->*
417 arrowTyConKind = mkArrowKinds [liftedTypeKind, liftedTypeKind] liftedTypeKind
418 \end{code}
419
420
421 %************************************************************************
422 %*                                                                      *
423                 Errors
424 %*                                                                      *
425 %************************************************************************
426
427 \begin{code}
428 cmdCtxt :: HsCmd Name -> SDoc
429 cmdCtxt cmd = ptext (sLit "In the command:") <+> ppr cmd
430 \end{code}