2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[TcExpr]{Typecheck an expression}
7 module TcExpr ( tcCheckSigma, tcCheckRho, tcInferRho,
8 tcMonoExpr, tcExpr, tcSyntaxOp
11 #include "HsVersions.h"
13 #ifdef GHCI /* Only if bootstrapped */
14 import {-# SOURCE #-} TcSplice( tcSpliceExpr, tcBracket )
15 import HsSyn ( nlHsVar )
17 import Name ( isExternalName )
18 import TcType ( isTauTy )
19 import TcEnv ( checkWellStaged )
20 import HsSyn ( nlHsApp )
21 import qualified DsMeta
24 import HsSyn ( HsExpr(..), LHsExpr, HsLit(..), ArithSeqInfo(..), recBindFields,
25 HsMatchContext(..), HsRecordBinds, mkHsApp )
26 import TcHsSyn ( hsLitType, (<$>) )
28 import TcUnify ( Expected(..), tcInfer, zapExpectedType, zapExpectedTo,
29 tcSubExp, tcGen, tcSub,
30 unifyFunTys, zapToListTy, zapToTyConApp )
31 import BasicTypes ( isMarkedStrict )
32 import Inst ( tcOverloadedLit, newMethodFromName, newIPDict,
33 newDicts, newMethodWithGivenTy, tcInstStupidTheta, tcInstCall )
34 import TcBinds ( tcLocalBinds )
35 import TcEnv ( tcLookup, tcLookupId,
36 tcLookupDataCon, tcLookupGlobalId
38 import TcArrows ( tcProc )
39 import TcMatches ( tcMatchesCase, tcMatchLambda, tcDoStmts, tcThingWithSig, TcMatchCtxt(..) )
40 import TcHsType ( tcHsSigType, UserTypeCtxt(..) )
41 import TcPat ( badFieldCon, refineTyVars )
42 import TcMType ( tcInstTyVars, tcInstType, newTyFlexiVarTy, zonkTcType )
43 import TcType ( TcTyVar, TcType, TcSigmaType, TcRhoType,
44 tcSplitFunTys, mkTyVarTys,
45 isSigmaTy, mkFunTy, mkTyConApp, tyVarsOfTypes, isLinearPred,
46 tcSplitSigmaTy, tidyOpenType
48 import Kind ( openTypeKind, liftedTypeKind, argTypeKind )
50 import Id ( idType, recordSelectorFieldLabel, isRecordSelector, isNaughtyRecordSelector )
51 import DataCon ( DataCon, dataConFieldLabels, dataConStrictMarks,
52 dataConWrapId, isVanillaDataCon, dataConTyVars, dataConOrigArgTys )
54 import TyCon ( FieldLabel, tyConStupidTheta, tyConDataCons )
55 import Type ( substTheta, substTy )
56 import Var ( tyVarKind )
57 import VarSet ( emptyVarSet, elemVarSet )
58 import TysWiredIn ( boolTy, parrTyCon, tupleTyCon )
59 import PrelNames ( enumFromName, enumFromThenName,
60 enumFromToName, enumFromThenToName,
61 enumFromToPName, enumFromThenToPName, negateName
64 import StaticFlags ( opt_NoMethodSharing )
65 import HscTypes ( TyThing(..) )
66 import SrcLoc ( Located(..), unLoc, getLoc )
68 import ListSetOps ( assocMaybe )
69 import Maybes ( catMaybes )
74 import TyCon ( tyConArity )
78 %************************************************************************
80 \subsection{Main wrappers}
82 %************************************************************************
85 -- tcCheckSigma does type *checking*; it's passed the expected type of the result
86 tcCheckSigma :: LHsExpr Name -- Expession to type check
87 -> TcSigmaType -- Expected type (could be a polytpye)
88 -> TcM (LHsExpr TcId) -- Generalised expr with expected type
90 tcCheckSigma expr expected_ty
91 = -- traceTc (text "tcExpr" <+> (ppr expected_ty $$ ppr expr)) `thenM_`
92 tc_expr' expr expected_ty
94 tc_expr' expr sigma_ty
96 = tcGen sigma_ty emptyVarSet (
97 \ rho_ty -> tcCheckRho expr rho_ty
98 ) `thenM` \ (gen_fn, expr') ->
99 returnM (L (getLoc expr') (gen_fn <$> unLoc expr'))
101 tc_expr' expr rho_ty -- Monomorphic case
102 = tcCheckRho expr rho_ty
105 Typecheck expression which in most cases will be an Id.
106 The expression can return a higher-ranked type, such as
107 (forall a. a->a) -> Int
108 so we must create a hole to pass in as the expected tyvar.
111 tcCheckRho :: LHsExpr Name -> TcRhoType -> TcM (LHsExpr TcId)
112 tcCheckRho expr rho_ty = tcMonoExpr expr (Check rho_ty)
114 tcInferRho :: LHsExpr Name -> TcM (LHsExpr TcId, TcRhoType)
115 tcInferRho (L loc (HsVar name)) = setSrcSpan loc $ do
116 { (e,_,ty) <- tcId (OccurrenceOf name) name
117 ; return (L loc e, ty) }
118 tcInferRho expr = tcInfer (tcMonoExpr expr)
120 tcSyntaxOp :: InstOrigin -> HsExpr Name -> TcType -> TcM (HsExpr TcId)
121 -- Typecheck a syntax operator, checking that it has the specified type
122 -- The operator is always a variable at this stage (i.e. renamer output)
123 tcSyntaxOp orig (HsVar op) ty = do { (expr', _, id_ty) <- tcId orig op
124 ; co_fn <- tcSub ty id_ty
125 ; returnM (co_fn <$> expr') }
126 tcSyntaxOp orig other ty = pprPanic "tcSyntaxOp" (ppr other)
131 %************************************************************************
133 \subsection{The TAUT rules for variables}TcExpr
135 %************************************************************************
138 tcMonoExpr :: LHsExpr Name -- Expession to type check
139 -> Expected TcRhoType -- Expected type (could be a type variable)
140 -- Definitely no foralls at the top
142 -> TcM (LHsExpr TcId)
144 tcMonoExpr (L loc expr) res_ty
145 = setSrcSpan loc (do { expr' <- tcExpr expr res_ty
146 ; return (L loc expr') })
148 tcExpr :: HsExpr Name -> Expected TcRhoType -> TcM (HsExpr TcId)
149 tcExpr (HsVar name) res_ty
150 = do { (expr', _, id_ty) <- tcId (OccurrenceOf name) name
151 ; co_fn <- tcSubExp res_ty id_ty
152 ; returnM (co_fn <$> expr') }
154 tcExpr (HsIPVar ip) res_ty
155 = -- Implicit parameters must have a *tau-type* not a
156 -- type scheme. We enforce this by creating a fresh
157 -- type variable as its type. (Because res_ty may not
159 newTyFlexiVarTy argTypeKind `thenM` \ ip_ty ->
160 -- argTypeKind: it can't be an unboxed tuple
161 newIPDict (IPOccOrigin ip) ip ip_ty `thenM` \ (ip', inst) ->
162 extendLIE inst `thenM_`
163 tcSubExp res_ty ip_ty `thenM` \ co_fn ->
164 returnM (co_fn <$> HsIPVar ip')
168 %************************************************************************
170 \subsection{Expressions type signatures}
172 %************************************************************************
175 tcExpr in_expr@(ExprWithTySig expr poly_ty) res_ty
176 = addErrCtxt (exprCtxt in_expr) $
177 tcHsSigType ExprSigCtxt poly_ty `thenM` \ sig_tc_ty ->
178 tcThingWithSig sig_tc_ty (tcCheckRho expr) res_ty `thenM` \ (co_fn, expr') ->
179 returnM (co_fn <$> ExprWithTySigOut expr' poly_ty)
181 tcExpr (HsType ty) res_ty
182 = failWithTc (text "Can't handle type argument:" <+> ppr ty)
183 -- This is the syntax for type applications that I was planning
184 -- but there are difficulties (e.g. what order for type args)
185 -- so it's not enabled yet.
186 -- Can't eliminate it altogether from the parser, because the
187 -- same parser parses *patterns*.
191 %************************************************************************
193 \subsection{Other expression forms}
195 %************************************************************************
198 tcExpr (HsPar expr) res_ty = tcMonoExpr expr res_ty `thenM` \ expr' ->
199 returnM (HsPar expr')
200 tcExpr (HsSCC lbl expr) res_ty = tcMonoExpr expr res_ty `thenM` \ expr' ->
201 returnM (HsSCC lbl expr')
202 tcExpr (HsCoreAnn lbl expr) res_ty = tcMonoExpr expr res_ty `thenM` \ expr' -> -- hdaume: core annotation
203 returnM (HsCoreAnn lbl expr')
205 tcExpr (HsLit lit) res_ty = tcLit lit res_ty
207 tcExpr (HsOverLit lit) res_ty
208 = zapExpectedType res_ty liftedTypeKind `thenM` \ res_ty' ->
209 -- Overloaded literals must have liftedTypeKind, because
210 -- we're instantiating an overloaded function here,
211 -- whereas res_ty might be openTypeKind. This was a bug in 6.2.2
212 tcOverloadedLit (LiteralOrigin lit) lit res_ty' `thenM` \ lit' ->
213 returnM (HsOverLit lit')
215 tcExpr (NegApp expr neg_expr) res_ty
216 = do { res_ty' <- zapExpectedType res_ty liftedTypeKind
217 ; neg_expr' <- tcSyntaxOp (OccurrenceOf negateName) neg_expr
218 (mkFunTy res_ty' res_ty')
219 ; expr' <- tcCheckRho expr res_ty'
220 ; return (NegApp expr' neg_expr') }
222 tcExpr (HsLam match) res_ty
223 = tcMatchLambda match res_ty `thenM` \ match' ->
224 returnM (HsLam match')
226 tcExpr (HsApp e1 e2) res_ty
227 = tcApp e1 [e2] res_ty
230 Note that the operators in sections are expected to be binary, and
231 a type error will occur if they aren't.
234 -- Left sections, equivalent to
241 tcExpr in_expr@(SectionL arg1 op) res_ty
242 = tcInferRho op `thenM` \ (op', op_ty) ->
243 unifyInfixTy op in_expr op_ty `thenM` \ ([arg1_ty, arg2_ty], op_res_ty) ->
244 tcArg op (arg1, arg1_ty, 1) `thenM` \ arg1' ->
245 addErrCtxt (exprCtxt in_expr) $
246 tcSubExp res_ty (mkFunTy arg2_ty op_res_ty) `thenM` \ co_fn ->
247 returnM (co_fn <$> SectionL arg1' op')
249 -- Right sections, equivalent to \ x -> x op expr, or
252 tcExpr in_expr@(SectionR op arg2) res_ty
253 = tcInferRho op `thenM` \ (op', op_ty) ->
254 unifyInfixTy op in_expr op_ty `thenM` \ ([arg1_ty, arg2_ty], op_res_ty) ->
255 tcArg op (arg2, arg2_ty, 2) `thenM` \ arg2' ->
256 addErrCtxt (exprCtxt in_expr) $
257 tcSubExp res_ty (mkFunTy arg1_ty op_res_ty) `thenM` \ co_fn ->
258 returnM (co_fn <$> SectionR op' arg2')
260 -- equivalent to (op e1) e2:
262 tcExpr in_expr@(OpApp arg1 op fix arg2) res_ty
263 = tcInferRho op `thenM` \ (op', op_ty) ->
264 unifyInfixTy op in_expr op_ty `thenM` \ ([arg1_ty, arg2_ty], op_res_ty) ->
265 tcArg op (arg1, arg1_ty, 1) `thenM` \ arg1' ->
266 tcArg op (arg2, arg2_ty, 2) `thenM` \ arg2' ->
267 addErrCtxt (exprCtxt in_expr) $
268 tcSubExp res_ty op_res_ty `thenM` \ co_fn ->
269 returnM (co_fn <$> OpApp arg1' op' fix arg2')
273 tcExpr (HsLet binds expr) res_ty
274 = do { (binds', expr') <- tcLocalBinds binds $
275 tcMonoExpr expr res_ty
276 ; return (HsLet binds' expr') }
278 tcExpr in_expr@(HsCase scrut matches) exp_ty
279 = -- We used to typecheck the case alternatives first.
280 -- The case patterns tend to give good type info to use
281 -- when typechecking the scrutinee. For example
284 -- will report that map is applied to too few arguments
286 -- But now, in the GADT world, we need to typecheck the scrutinee
287 -- first, to get type info that may be refined in the case alternatives
288 addErrCtxt (caseScrutCtxt scrut)
289 (tcInferRho scrut) `thenM` \ (scrut', scrut_ty) ->
291 addErrCtxt (caseCtxt in_expr) $
292 tcMatchesCase match_ctxt scrut_ty matches exp_ty `thenM` \ matches' ->
293 returnM (HsCase scrut' matches')
295 match_ctxt = MC { mc_what = CaseAlt,
296 mc_body = tcMonoExpr }
298 tcExpr (HsIf pred b1 b2) res_ty
299 = addErrCtxt (predCtxt pred)
300 (tcCheckRho pred boolTy) `thenM` \ pred' ->
302 zapExpectedType res_ty openTypeKind `thenM` \ res_ty' ->
303 -- C.f. the call to zapToType in TcMatches.tcMatches
305 tcCheckRho b1 res_ty' `thenM` \ b1' ->
306 tcCheckRho b2 res_ty' `thenM` \ b2' ->
307 returnM (HsIf pred' b1' b2')
309 tcExpr (HsDo do_or_lc stmts body _) res_ty
310 = tcDoStmts do_or_lc stmts body res_ty
312 tcExpr in_expr@(ExplicitList _ exprs) res_ty -- Non-empty list
313 = zapToListTy res_ty `thenM` \ elt_ty ->
314 mappM (tc_elt elt_ty) exprs `thenM` \ exprs' ->
315 returnM (ExplicitList elt_ty exprs')
318 = addErrCtxt (listCtxt expr) $
319 tcCheckRho expr elt_ty
321 tcExpr in_expr@(ExplicitPArr _ exprs) res_ty -- maybe empty
322 = do { [elt_ty] <- zapToTyConApp parrTyCon res_ty
323 ; exprs' <- mappM (tc_elt elt_ty) exprs
324 ; return (ExplicitPArr elt_ty exprs') }
327 = addErrCtxt (parrCtxt expr) (tcCheckRho expr elt_ty)
329 tcExpr (ExplicitTuple exprs boxity) res_ty
330 = do { arg_tys <- zapToTyConApp (tupleTyCon boxity (length exprs)) res_ty
331 ; exprs' <- tcCheckRhos exprs arg_tys
332 ; return (ExplicitTuple exprs' boxity) }
334 tcExpr (HsProc pat cmd) res_ty
335 = tcProc pat cmd res_ty `thenM` \ (pat', cmd') ->
336 returnM (HsProc pat' cmd')
338 tcExpr e@(HsArrApp _ _ _ _ _) _
339 = failWithTc (vcat [ptext SLIT("The arrow command"), nest 2 (ppr e),
340 ptext SLIT("was found where an expression was expected")])
342 tcExpr e@(HsArrForm _ _ _) _
343 = failWithTc (vcat [ptext SLIT("The arrow command"), nest 2 (ppr e),
344 ptext SLIT("was found where an expression was expected")])
347 %************************************************************************
349 Record construction and update
351 %************************************************************************
354 tcExpr expr@(RecordCon (L loc con_name) _ rbinds) res_ty
355 = addErrCtxt (recordConCtxt expr) $
356 do { (con_expr, _, con_tau) <- setSrcSpan loc $
357 tcId (OccurrenceOf con_name) con_name
358 ; data_con <- tcLookupDataCon con_name
360 ; let (arg_tys, record_ty) = tcSplitFunTys con_tau
361 flds_w_tys = zipEqual "tcExpr RecordCon" (dataConFieldLabels data_con) arg_tys
363 -- Make the result type line up
364 ; zapExpectedTo res_ty record_ty
366 -- Typecheck the record bindings
367 ; rbinds' <- tcRecordBinds data_con flds_w_tys rbinds
369 -- Check for missing fields
370 ; checkMissingFields data_con rbinds
372 ; returnM (RecordCon (L loc (dataConWrapId data_con)) con_expr rbinds') }
374 -- The main complication with RecordUpd is that we need to explicitly
375 -- handle the *non-updated* fields. Consider:
377 -- data T a b = MkT1 { fa :: a, fb :: b }
378 -- | MkT2 { fa :: a, fc :: Int -> Int }
379 -- | MkT3 { fd :: a }
381 -- upd :: T a b -> c -> T a c
382 -- upd t x = t { fb = x}
384 -- The type signature on upd is correct (i.e. the result should not be (T a b))
385 -- because upd should be equivalent to:
387 -- upd t x = case t of
388 -- MkT1 p q -> MkT1 p x
389 -- MkT2 a b -> MkT2 p b
390 -- MkT3 d -> error ...
392 -- So we need to give a completely fresh type to the result record,
393 -- and then constrain it by the fields that are *not* updated ("p" above).
395 -- Note that because MkT3 doesn't contain all the fields being updated,
396 -- its RHS is simply an error, so it doesn't impose any type constraints
398 -- All this is done in STEP 4 below.
402 -- For record update we require that every constructor involved in the
403 -- update (i.e. that has all the specified fields) is "vanilla". I
404 -- don't know how to do the update otherwise.
407 tcExpr expr@(RecordUpd record_expr rbinds _ _) res_ty
408 = addErrCtxt (recordUpdCtxt expr) $
411 -- Check that the field names are really field names
412 ASSERT( notNull rbinds )
414 field_names = map fst rbinds
416 mappM (tcLookupGlobalId.unLoc) field_names `thenM` \ sel_ids ->
417 -- The renamer has already checked that they
420 bad_guys = [ setSrcSpan loc $ addErrTc (notSelector field_name)
421 | (L loc field_name, sel_id) <- field_names `zip` sel_ids,
422 not (isRecordSelector sel_id) -- Excludes class ops
425 checkM (null bad_guys) (sequenceM bad_guys `thenM_` failM) `thenM_`
428 -- Figure out the tycon and data cons from the first field name
430 -- It's OK to use the non-tc splitters here (for a selector)
431 upd_field_lbls = recBindFields rbinds
433 (tycon, _) = recordSelectorFieldLabel sel_id -- We've failed already if
434 data_cons = tyConDataCons tycon -- it's not a field label
435 relevant_cons = filter is_relevant data_cons
436 is_relevant con = all (`elem` dataConFieldLabels con) upd_field_lbls
440 -- Check that at least one constructor has all the named fields
441 -- i.e. has an empty set of bad fields returned by badFields
442 checkTc (not (null relevant_cons))
443 (badFieldsUpd rbinds) `thenM_`
445 -- Check that all relevant data cons are vanilla. Doing record updates on
446 -- GADTs and/or existentials is more than my tiny brain can cope with today
447 checkTc (all isVanillaDataCon relevant_cons)
448 (nonVanillaUpd tycon) `thenM_`
451 -- Use the un-updated fields to find a vector of booleans saying
452 -- which type arguments must be the same in updatee and result.
454 -- WARNING: this code assumes that all data_cons in a common tycon
455 -- have FieldLabels abstracted over the same tyvars.
457 -- A constructor is only relevant to this process if
458 -- it contains *all* the fields that are being updated
459 con1 = head relevant_cons -- A representative constructor
460 con1_tyvars = dataConTyVars con1
461 con1_fld_tys = dataConFieldLabels con1 `zip` dataConOrigArgTys con1
462 common_tyvars = tyVarsOfTypes [ty | (fld,ty) <- con1_fld_tys
463 , not (fld `elem` upd_field_lbls) ]
465 is_common_tv tv = tv `elemVarSet` common_tyvars
467 mk_inst_ty tv result_inst_ty
468 | is_common_tv tv = returnM result_inst_ty -- Same as result type
469 | otherwise = newTyFlexiVarTy (tyVarKind tv) -- Fresh type, of correct kind
471 tcInstTyVars con1_tyvars `thenM` \ (_, result_inst_tys, inst_env) ->
472 zipWithM mk_inst_ty con1_tyvars result_inst_tys `thenM` \ inst_tys ->
475 -- Typecheck the update bindings.
476 -- (Do this after checking for bad fields in case there's a field that
477 -- doesn't match the constructor.)
479 result_record_ty = mkTyConApp tycon result_inst_tys
480 inst_fld_tys = [(fld, substTy inst_env ty) | (fld, ty) <- con1_fld_tys]
482 zapExpectedTo res_ty result_record_ty `thenM_`
483 tcRecordBinds con1 inst_fld_tys rbinds `thenM` \ rbinds' ->
486 -- Typecheck the expression to be updated
488 record_ty = ASSERT( length inst_tys == tyConArity tycon )
489 mkTyConApp tycon inst_tys
490 -- This is one place where the isVanilla check is important
491 -- So that inst_tys matches the tycon
493 tcCheckRho record_expr record_ty `thenM` \ record_expr' ->
496 -- Figure out the LIE we need. We have to generate some
497 -- dictionaries for the data type context, since we are going to
498 -- do pattern matching over the data cons.
500 -- What dictionaries do we need?
501 -- We just take the context of the first data constructor
502 -- This isn't right, but I just can't bear to union up all the relevant ones
504 theta' = substTheta inst_env (tyConStupidTheta tycon)
506 newDicts RecordUpdOrigin theta' `thenM` \ dicts ->
507 extendLIEs dicts `thenM_`
510 returnM (RecordUpd record_expr' rbinds' record_ty result_record_ty)
514 %************************************************************************
516 Arithmetic sequences e.g. [a,b..]
517 and their parallel-array counterparts e.g. [: a,b.. :]
520 %************************************************************************
523 tcExpr (ArithSeq _ seq@(From expr)) res_ty
524 = zapToListTy res_ty `thenM` \ elt_ty ->
525 tcCheckRho expr elt_ty `thenM` \ expr' ->
527 newMethodFromName (ArithSeqOrigin seq)
528 elt_ty enumFromName `thenM` \ enum_from ->
530 returnM (ArithSeq (HsVar enum_from) (From expr'))
532 tcExpr in_expr@(ArithSeq _ seq@(FromThen expr1 expr2)) res_ty
533 = addErrCtxt (arithSeqCtxt in_expr) $
534 zapToListTy res_ty `thenM` \ elt_ty ->
535 tcCheckRho expr1 elt_ty `thenM` \ expr1' ->
536 tcCheckRho expr2 elt_ty `thenM` \ expr2' ->
537 newMethodFromName (ArithSeqOrigin seq)
538 elt_ty enumFromThenName `thenM` \ enum_from_then ->
540 returnM (ArithSeq (HsVar enum_from_then) (FromThen expr1' expr2'))
543 tcExpr in_expr@(ArithSeq _ seq@(FromTo expr1 expr2)) res_ty
544 = addErrCtxt (arithSeqCtxt in_expr) $
545 zapToListTy res_ty `thenM` \ elt_ty ->
546 tcCheckRho expr1 elt_ty `thenM` \ expr1' ->
547 tcCheckRho expr2 elt_ty `thenM` \ expr2' ->
548 newMethodFromName (ArithSeqOrigin seq)
549 elt_ty enumFromToName `thenM` \ enum_from_to ->
551 returnM (ArithSeq (HsVar enum_from_to) (FromTo expr1' expr2'))
553 tcExpr in_expr@(ArithSeq _ seq@(FromThenTo expr1 expr2 expr3)) res_ty
554 = addErrCtxt (arithSeqCtxt in_expr) $
555 zapToListTy res_ty `thenM` \ elt_ty ->
556 tcCheckRho expr1 elt_ty `thenM` \ expr1' ->
557 tcCheckRho expr2 elt_ty `thenM` \ expr2' ->
558 tcCheckRho expr3 elt_ty `thenM` \ expr3' ->
559 newMethodFromName (ArithSeqOrigin seq)
560 elt_ty enumFromThenToName `thenM` \ eft ->
562 returnM (ArithSeq (HsVar eft) (FromThenTo expr1' expr2' expr3'))
564 tcExpr in_expr@(PArrSeq _ seq@(FromTo expr1 expr2)) res_ty
565 = addErrCtxt (parrSeqCtxt in_expr) $
566 zapToTyConApp parrTyCon res_ty `thenM` \ [elt_ty] ->
567 tcCheckRho expr1 elt_ty `thenM` \ expr1' ->
568 tcCheckRho expr2 elt_ty `thenM` \ expr2' ->
569 newMethodFromName (PArrSeqOrigin seq)
570 elt_ty enumFromToPName `thenM` \ enum_from_to ->
572 returnM (PArrSeq (HsVar enum_from_to) (FromTo expr1' expr2'))
574 tcExpr in_expr@(PArrSeq _ seq@(FromThenTo expr1 expr2 expr3)) res_ty
575 = addErrCtxt (parrSeqCtxt in_expr) $
576 zapToTyConApp parrTyCon res_ty `thenM` \ [elt_ty] ->
577 tcCheckRho expr1 elt_ty `thenM` \ expr1' ->
578 tcCheckRho expr2 elt_ty `thenM` \ expr2' ->
579 tcCheckRho expr3 elt_ty `thenM` \ expr3' ->
580 newMethodFromName (PArrSeqOrigin seq)
581 elt_ty enumFromThenToPName `thenM` \ eft ->
583 returnM (PArrSeq (HsVar eft) (FromThenTo expr1' expr2' expr3'))
585 tcExpr (PArrSeq _ _) _
586 = panic "TcExpr.tcMonoExpr: Infinite parallel array!"
587 -- the parser shouldn't have generated it and the renamer shouldn't have
592 %************************************************************************
596 %************************************************************************
599 #ifdef GHCI /* Only if bootstrapped */
600 -- Rename excludes these cases otherwise
601 tcExpr (HsSpliceE splice) res_ty = tcSpliceExpr splice res_ty
602 tcExpr (HsBracket brack) res_ty = do { e <- tcBracket brack res_ty
608 %************************************************************************
612 %************************************************************************
615 tcExpr other _ = pprPanic "tcMonoExpr" (ppr other)
619 %************************************************************************
621 \subsection{@tcApp@ typchecks an application}
623 %************************************************************************
627 tcApp :: LHsExpr Name -> [LHsExpr Name] -- Function and args
628 -> Expected TcRhoType -- Expected result type of application
629 -> TcM (HsExpr TcId) -- Translated fun and args
631 tcApp (L _ (HsApp e1 e2)) args res_ty
632 = tcApp e1 (e2:args) res_ty -- Accumulate the arguments
634 tcApp fun args res_ty
635 = do { let n_args = length args
636 ; (fun', fun_tvs, fun_tau) <- tcFun fun -- Type-check the function
638 -- Extract its argument types
639 ; (expected_arg_tys, actual_res_ty)
640 <- do { traceTc (text "tcApp" <+> (ppr fun $$ ppr fun_tau))
641 ; let msg = sep [ptext SLIT("The function") <+> quotes (ppr fun),
642 ptext SLIT("is applied to")
643 <+> speakN n_args <+> ptext SLIT("arguments")]
644 ; unifyFunTys msg n_args fun_tau }
647 Check _ -> do -- Connect to result type first
648 -- See Note [Push result type in]
649 { co_fn <- tcResult fun args res_ty actual_res_ty
650 ; the_app' <- tcArgs fun fun' args expected_arg_tys
651 ; traceTc (text "tcApp: check" <+> vcat [ppr fun <+> ppr args,
652 ppr the_app', ppr actual_res_ty])
653 ; returnM (co_fn <$> the_app') }
655 Infer _ -> do -- Type check args first, then
656 -- refine result type, then do tcResult
657 { the_app' <- tcArgs fun fun' args expected_arg_tys
658 ; subst <- refineTyVars fun_tvs
659 ; let actual_res_ty' = substTy subst actual_res_ty
660 ; co_fn <- tcResult fun args res_ty actual_res_ty'
661 ; traceTc (text "tcApp: infer" <+> vcat [ppr fun <+> ppr args, ppr the_app',
662 ppr actual_res_ty, ppr actual_res_ty'])
663 ; returnM (co_fn <$> the_app') }
666 -- Note [Push result type in]
668 -- Unify with expected result before (was: after) type-checking the args
669 -- so that the info from res_ty (was: args) percolates to args (was actual_res_ty).
670 -- This is when we might detect a too-few args situation.
671 -- (One can think of cases when the opposite order would give
672 -- a better error message.)
673 -- [March 2003: I'm experimenting with putting this first. Here's an
674 -- example where it actually makes a real difference
675 -- class C t a b | t a -> b
676 -- instance C Char a Bool
678 -- data P t a = forall b. (C t a b) => MkP b
679 -- data Q t = MkQ (forall a. P t a)
682 -- f1 = MkQ (MkP True)
683 -- f2 = MkQ (MkP True :: forall a. P Char a)
685 -- With the change, f1 will type-check, because the 'Char' info from
686 -- the signature is propagated into MkQ's argument. With the check
687 -- in the other order, the extra signature in f2 is reqd.]
690 tcFun :: LHsExpr Name -> TcM (LHsExpr TcId, [TcTyVar], TcRhoType)
691 -- Instantiate the function, returning the type variables used
692 -- If the function isn't simple, infer its type, and return no
694 tcFun (L loc (HsVar f)) = setSrcSpan loc $ do
695 { (fun', tvs, fun_tau) <- tcId (OccurrenceOf f) f
696 ; return (L loc fun', tvs, fun_tau) }
697 tcFun fun = do { (fun', fun_tau) <- tcInfer (tcMonoExpr fun)
698 ; return (fun', [], fun_tau) }
701 tcArgs :: LHsExpr Name -- The function (for error messages)
702 -> LHsExpr TcId -- The function (to build into result)
703 -> [LHsExpr Name] -> [TcSigmaType] -- Actual arguments and expected arg types
704 -> TcM (HsExpr TcId) -- Resulting application
706 tcArgs fun fun' args expected_arg_tys
707 = do { args' <- mappM (tcArg fun) (zip3 args expected_arg_tys [1..])
708 ; return (unLoc (foldl mkHsApp fun' args')) }
710 tcArg :: LHsExpr Name -- The function (for error messages)
711 -> (LHsExpr Name, TcSigmaType, Int) -- Actual argument and expected arg type
712 -> TcM (LHsExpr TcId) -- Resulting argument
713 tcArg fun (arg, ty, arg_no) = addErrCtxt (funAppCtxt fun arg arg_no)
714 (tcCheckSigma arg ty)
717 tcResult fun args res_ty actual_res_ty
718 = addErrCtxtM (checkArgsCtxt fun args res_ty actual_res_ty)
719 (tcSubExp res_ty actual_res_ty)
722 -- If an error happens we try to figure out whether the
723 -- function has been given too many or too few arguments,
725 -- The ~(Check...) is because in the Infer case the tcSubExp
726 -- definitely won't fail, so we can be certain we're in the Check branch
727 checkArgsCtxt fun args (Infer _) actual_res_ty tidy_env
728 = return (tidy_env, ptext SLIT("Urk infer"))
730 checkArgsCtxt fun args (Check expected_res_ty) actual_res_ty tidy_env
731 = zonkTcType expected_res_ty `thenM` \ exp_ty' ->
732 zonkTcType actual_res_ty `thenM` \ act_ty' ->
734 (env1, exp_ty'') = tidyOpenType tidy_env exp_ty'
735 (env2, act_ty'') = tidyOpenType env1 act_ty'
736 (exp_args, _) = tcSplitFunTys exp_ty''
737 (act_args, _) = tcSplitFunTys act_ty''
739 len_act_args = length act_args
740 len_exp_args = length exp_args
742 message | len_exp_args < len_act_args = wrongArgsCtxt "too few" fun args
743 | len_exp_args > len_act_args = wrongArgsCtxt "too many" fun args
744 | otherwise = appCtxt fun args
746 returnM (env2, message)
749 unifyInfixTy :: LHsExpr Name -> HsExpr Name -> TcType
750 -> TcM ([TcType], TcType)
751 -- This wrapper just prepares the error message for unifyFunTys
752 unifyInfixTy op expr op_ty
753 = unifyFunTys msg 2 op_ty
755 msg = sep [herald <+> quotes (ppr expr),
756 ptext SLIT("requires") <+> quotes (ppr op)
757 <+> ptext SLIT("to take two arguments")]
758 herald = case expr of
759 OpApp _ _ _ _ -> ptext SLIT("The infix expression")
760 other -> ptext SLIT("The operator section")
764 %************************************************************************
766 \subsection{@tcId@ typchecks an identifier occurrence}
768 %************************************************************************
770 tcId instantiates an occurrence of an Id.
771 The instantiate_it loop runs round instantiating the Id.
772 It has to be a loop because we are now prepared to entertain
774 f:: forall a. Eq a => forall b. Baz b => tau
775 We want to instantiate this to
776 f2::tau {f2 = f1 b (Baz b), f1 = f a (Eq a)}
778 The -fno-method-sharing flag controls what happens so far as the LIE
779 is concerned. The default case is that for an overloaded function we
780 generate a "method" Id, and add the Method Inst to the LIE. So you get
783 f = /\a (d:Num a) -> let m = (+) a d in \ (x:a) -> m x x
784 If you specify -fno-method-sharing, the dictionary application
785 isn't shared, so we get
787 f = /\a (d:Num a) (x:a) -> (+) a d x x
788 This gets a bit less sharing, but
789 a) it's better for RULEs involving overloaded functions
790 b) perhaps fewer separated lambdas
793 tcId :: InstOrigin -> Name -> TcM (HsExpr TcId, [TcTyVar], TcRhoType)
794 -- Return the type variables at which the function
795 -- is instantiated, as well as the translated variable and its type
797 tcId orig id_name -- Look up the Id and instantiate its type
798 = tcLookup id_name `thenM` \ thing ->
800 AGlobal (ADataCon con) -- Similar, but instantiate the stupid theta too
801 -> do { (expr, tvs, tau) <- instantiate (dataConWrapId con)
802 ; tcInstStupidTheta con (mkTyVarTys tvs)
803 -- Remember to chuck in the constraints from the "silly context"
804 ; return (expr, tvs, tau) }
806 ; AGlobal (AnId id) | isNaughtyRecordSelector id
807 -> failWithTc (naughtyRecordSel id)
808 ; AGlobal (AnId id) -> instantiate id
809 -- A global cannot possibly be ill-staged
810 -- nor does it need the 'lifting' treatment
812 ; ATcId id th_level -> tc_local_id id th_level
814 ; other -> failWithTc (ppr other <+> ptext SLIT("used where a value identifer was expected"))
819 tc_local_id id th_bind_lvl -- Non-TH case
822 #else /* GHCI and TH is on */
823 tc_local_id id th_bind_lvl -- TH case
824 = -- Check for cross-stage lifting
825 getStage `thenM` \ use_stage ->
827 Brack use_lvl ps_var lie_var
828 | use_lvl > th_bind_lvl
829 -> if isExternalName id_name then
830 -- Top-level identifiers in this module,
831 -- (which have External Names)
832 -- are just like the imported case:
833 -- no need for the 'lifting' treatment
834 -- E.g. this is fine:
837 -- But we do need to put f into the keep-alive
838 -- set, because after desugaring the code will
839 -- only mention f's *name*, not f itself.
840 keepAliveTc id_name `thenM_`
843 else -- Nested identifiers, such as 'x' in
844 -- E.g. \x -> [| h x |]
845 -- We must behave as if the reference to x was
847 -- We use 'x' itself as the splice proxy, used by
848 -- the desugarer to stitch it all back together.
849 -- If 'x' occurs many times we may get many identical
850 -- bindings of the same splice proxy, but that doesn't
851 -- matter, although it's a mite untidy.
855 checkTc (isTauTy id_ty) (polySpliceErr id) `thenM_`
856 -- If x is polymorphic, its occurrence sites might
857 -- have different instantiations, so we can't use plain
858 -- 'x' as the splice proxy name. I don't know how to
859 -- solve this, and it's probably unimportant, so I'm
860 -- just going to flag an error for now
863 newMethodFromName orig id_ty DsMeta.liftName `thenM` \ lift ->
864 -- Put the 'lift' constraint into the right LIE
866 -- Update the pending splices
867 readMutVar ps_var `thenM` \ ps ->
868 writeMutVar ps_var ((id_name, nlHsApp (nlHsVar lift) (nlHsVar id)) : ps) `thenM_`
870 returnM (HsVar id, [], id_ty))
873 checkWellStaged (quotes (ppr id)) th_bind_lvl use_stage `thenM_`
877 instantiate :: TcId -> TcM (HsExpr TcId, [TcTyVar], TcRhoType)
879 | not (want_method_inst fun_ty)
880 = loop (HsVar fun_id) [] fun_ty
881 | otherwise -- Make a MethodInst
882 = tcInstType fun_ty `thenM` \ (tyvars, theta, tau) ->
883 newMethodWithGivenTy orig fun_id
884 (mkTyVarTys tyvars) theta tau `thenM` \ meth_id ->
885 loop (HsVar meth_id) tyvars tau
887 fun_ty = idType fun_id
889 -- See Note [Multiple instantiation]
892 = tcInstCall orig fun_ty `thenM` \ (inst_fn, new_tvs, tau) ->
893 loop (inst_fn <$> fun) (tvs ++ new_tvs) tau
896 = returnM (fun, tvs, fun_ty)
898 -- Hack Alert (want_method_inst)!
899 -- If f :: (%x :: T) => Int -> Int
900 -- Then if we have two separate calls, (f 3, f 4), we cannot
901 -- make a method constraint that then gets shared, thus:
902 -- let m = f %x in (m 3, m 4)
903 -- because that loses the linearity of the constraint.
904 -- The simplest thing to do is never to construct a method constraint
905 -- in the first place that has a linear implicit parameter in it.
906 want_method_inst fun_ty
907 | opt_NoMethodSharing = False
908 | otherwise = case tcSplitSigmaTy fun_ty of
909 (_,[],_) -> False -- Not overloaded
910 (_,theta,_) -> not (any isLinearPred theta)
913 Note [Multiple instantiation]
914 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
915 We are careful never to make a MethodInst that has, as its meth_id, another MethodInst.
916 For example, consider
917 f :: forall a. Eq a => forall b. Ord b => a -> b
918 At a call to f, at say [Int, Bool], it's tempting to translate the call to
922 f_m1 :: forall b. Ord b => Int -> b
926 f_m2 = f_m1 Bool dOrdBool
928 But notice that f_m2 has f_m1 as its meth_id. Now the danger is that if we do
929 a tcSimplCheck with a Given f_mx :: f Int dEqInt, we may make a binding
931 But it's entirely possible that f_m2 will continue to float out, because it
932 mentions no type variables. Result, f_m1 isn't in scope.
934 Here's a concrete example that does this (test tc200):
937 f :: Eq b => b -> a -> Int
938 baz :: Eq a => Int -> a -> Int
943 Current solution: only do the "method sharing" thing for the first type/dict
944 application, not for the iterated ones. A horribly subtle point.
947 %************************************************************************
949 \subsection{Record bindings}
951 %************************************************************************
953 Game plan for record bindings
954 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
955 1. Find the TyCon for the bindings, from the first field label.
957 2. Instantiate its tyvars and unify (T a1 .. an) with expected_ty.
959 For each binding field = value
961 3. Instantiate the field type (from the field label) using the type
964 4 Type check the value using tcArg, passing the field type as
965 the expected argument type.
967 This extends OK when the field types are universally quantified.
973 -> [(FieldLabel,TcType)] -- Expected type for each field
974 -> HsRecordBinds Name
975 -> TcM (HsRecordBinds TcId)
977 tcRecordBinds data_con flds_w_tys rbinds
978 = do { mb_binds <- mappM do_bind rbinds
979 ; return (catMaybes mb_binds) }
981 do_bind (L loc field_lbl, rhs)
982 | Just field_ty <- assocMaybe flds_w_tys field_lbl
983 = addErrCtxt (fieldCtxt field_lbl) $
984 do { rhs' <- tcCheckSigma rhs field_ty
985 ; sel_id <- tcLookupId field_lbl
986 ; ASSERT( isRecordSelector sel_id )
987 return (Just (L loc sel_id, rhs')) }
989 = do { addErrTc (badFieldCon data_con field_lbl)
992 checkMissingFields :: DataCon -> HsRecordBinds Name -> TcM ()
993 checkMissingFields data_con rbinds
994 | null field_labels -- Not declared as a record;
995 -- But C{} is still valid if no strict fields
996 = if any isMarkedStrict field_strs then
997 -- Illegal if any arg is strict
998 addErrTc (missingStrictFields data_con [])
1002 | otherwise -- A record
1003 = checkM (null missing_s_fields)
1004 (addErrTc (missingStrictFields data_con missing_s_fields)) `thenM_`
1006 doptM Opt_WarnMissingFields `thenM` \ warn ->
1007 checkM (not (warn && notNull missing_ns_fields))
1008 (warnTc True (missingFields data_con missing_ns_fields))
1012 = [ fl | (fl, str) <- field_info,
1014 not (fl `elem` field_names_used)
1017 = [ fl | (fl, str) <- field_info,
1018 not (isMarkedStrict str),
1019 not (fl `elem` field_names_used)
1022 field_names_used = recBindFields rbinds
1023 field_labels = dataConFieldLabels data_con
1025 field_info = zipEqual "missingFields"
1029 field_strs = dataConStrictMarks data_con
1032 %************************************************************************
1034 \subsection{@tcCheckRhos@ typechecks a {\em list} of expressions}
1036 %************************************************************************
1039 tcCheckRhos :: [LHsExpr Name] -> [TcType] -> TcM [LHsExpr TcId]
1041 tcCheckRhos [] [] = returnM []
1042 tcCheckRhos (expr:exprs) (ty:tys)
1043 = tcCheckRho expr ty `thenM` \ expr' ->
1044 tcCheckRhos exprs tys `thenM` \ exprs' ->
1045 returnM (expr':exprs')
1046 tcCheckRhos exprs tys = pprPanic "tcCheckRhos" (ppr exprs $$ ppr tys)
1050 %************************************************************************
1052 \subsection{Literals}
1054 %************************************************************************
1056 Overloaded literals.
1059 tcLit :: HsLit -> Expected TcRhoType -> TcM (HsExpr TcId)
1061 = zapExpectedTo res_ty (hsLitType lit) `thenM_`
1066 %************************************************************************
1068 \subsection{Errors and contexts}
1070 %************************************************************************
1072 Boring and alphabetical:
1075 = hang (ptext SLIT("In an arithmetic sequence:")) 4 (ppr expr)
1078 = hang (ptext SLIT("In a parallel array sequence:")) 4 (ppr expr)
1081 = hang (ptext SLIT("In the case expression:")) 4 (ppr expr)
1084 = hang (ptext SLIT("In the scrutinee of a case expression:")) 4 (ppr expr)
1087 = hang (ptext SLIT("In the expression:")) 4 (ppr expr)
1089 fieldCtxt field_name
1090 = ptext SLIT("In the") <+> quotes (ppr field_name) <+> ptext SLIT("field of a record")
1092 funAppCtxt fun arg arg_no
1093 = hang (hsep [ ptext SLIT("In the"), speakNth arg_no, ptext SLIT("argument of"),
1094 quotes (ppr fun) <> text ", namely"])
1095 4 (quotes (ppr arg))
1098 = hang (ptext SLIT("In the list element:")) 4 (ppr expr)
1101 = hang (ptext SLIT("In the parallel array element:")) 4 (ppr expr)
1104 = hang (ptext SLIT("In the predicate expression:")) 4 (ppr expr)
1107 = ptext SLIT("In the application") <+> quotes (ppr the_app)
1109 the_app = foldl mkHsApp fun args -- Used in error messages
1112 = vcat [ptext SLIT("Record update for the non-Haskell-98 data type") <+> quotes (ppr tycon)
1113 <+> ptext SLIT("is not (yet) supported"),
1114 ptext SLIT("Use pattern-matching instead")]
1116 = hang (ptext SLIT("No constructor has all these fields:"))
1117 4 (pprQuotedList (recBindFields rbinds))
1119 recordUpdCtxt expr = ptext SLIT("In the record update:") <+> ppr expr
1120 recordConCtxt expr = ptext SLIT("In the record construction:") <+> ppr expr
1122 naughtyRecordSel sel_id
1123 = ptext SLIT("Cannot use record selector") <+> quotes (ppr sel_id) <+>
1124 ptext SLIT("as a function due to escaped type variables") $$
1125 ptext SLIT("Probably fix: use pattern-matching syntax instead")
1128 = hsep [quotes (ppr field), ptext SLIT("is not a record selector")]
1130 missingStrictFields :: DataCon -> [FieldLabel] -> SDoc
1131 missingStrictFields con fields
1134 rest | null fields = empty -- Happens for non-record constructors
1135 -- with strict fields
1136 | otherwise = colon <+> pprWithCommas ppr fields
1138 header = ptext SLIT("Constructor") <+> quotes (ppr con) <+>
1139 ptext SLIT("does not have the required strict field(s)")
1141 missingFields :: DataCon -> [FieldLabel] -> SDoc
1142 missingFields con fields
1143 = ptext SLIT("Fields of") <+> quotes (ppr con) <+> ptext SLIT("not initialised:")
1144 <+> pprWithCommas ppr fields
1146 wrongArgsCtxt too_many_or_few fun args
1147 = hang (ptext SLIT("Probable cause:") <+> quotes (ppr fun)
1148 <+> ptext SLIT("is applied to") <+> text too_many_or_few
1149 <+> ptext SLIT("arguments in the call"))
1150 4 (parens (ppr the_app))
1152 the_app = foldl mkHsApp fun args -- Used in error messages
1155 polySpliceErr :: Id -> SDoc
1157 = ptext SLIT("Can't splice the polymorphic local variable") <+> quotes (ppr id)