Upgrade UniqSet to a newtype
[ghc.git] / compiler / typecheck / TcBinds.hs
1 {-
2 (c) The University of Glasgow 2006
3 (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4
5 \section[TcBinds]{TcBinds}
6 -}
7
8 {-# LANGUAGE CPP, RankNTypes, ScopedTypeVariables #-}
9 {-# LANGUAGE FlexibleContexts #-}
10
11 module TcBinds ( tcLocalBinds, tcTopBinds, tcRecSelBinds,
12 tcHsBootSigs, tcPolyCheck,
13 tcVectDecls, addTypecheckedBinds,
14 chooseInferredQuantifiers,
15 badBootDeclErr ) where
16
17 import {-# SOURCE #-} TcMatches ( tcGRHSsPat, tcMatchesFun )
18 import {-# SOURCE #-} TcExpr ( tcMonoExpr )
19 import {-# SOURCE #-} TcPatSyn ( tcInferPatSynDecl, tcCheckPatSynDecl
20 , tcPatSynBuilderBind )
21 import CoreSyn (Tickish (..))
22 import CostCentre (mkUserCC)
23 import DynFlags
24 import FastString
25 import HsSyn
26 import HscTypes( isHsBootOrSig )
27 import TcSigs
28 import TcRnMonad
29 import TcEnv
30 import TcUnify
31 import TcSimplify
32 import TcEvidence
33 import TcHsType
34 import TcPat
35 import TcMType
36 import FamInstEnv( normaliseType )
37 import FamInst( tcGetFamInstEnvs )
38 import TyCon
39 import TcType
40 import Type( mkStrLitTy, tidyOpenType, mkTyVarBinder, splitTyConApp_maybe)
41 import TysPrim
42 import TysWiredIn( cTupleTyConName )
43 import Id
44 import Var
45 import VarSet
46 import VarEnv( TidyEnv )
47 import Module
48 import Name
49 import NameSet
50 import NameEnv
51 import SrcLoc
52 import Bag
53 import ListSetOps
54 import ErrUtils
55 import Digraph
56 import Maybes
57 import Util
58 import BasicTypes
59 import Outputable
60 import PrelNames( ipClassName )
61 import TcValidity (checkValidType)
62 import Unique (getUnique)
63 import UniqFM
64 import UniqSet
65 import qualified GHC.LanguageExtensions as LangExt
66 import ConLike
67
68 import Control.Monad
69
70 #include "HsVersions.h"
71
72 {- *********************************************************************
73 * *
74 A useful helper function
75 * *
76 ********************************************************************* -}
77
78 addTypecheckedBinds :: TcGblEnv -> [LHsBinds Id] -> TcGblEnv
79 addTypecheckedBinds tcg_env binds
80 | isHsBootOrSig (tcg_src tcg_env) = tcg_env
81 -- Do not add the code for record-selector bindings
82 -- when compiling hs-boot files
83 | otherwise = tcg_env { tcg_binds = foldr unionBags
84 (tcg_binds tcg_env)
85 binds }
86
87 {-
88 ************************************************************************
89 * *
90 \subsection{Type-checking bindings}
91 * *
92 ************************************************************************
93
94 @tcBindsAndThen@ typechecks a @HsBinds@. The "and then" part is because
95 it needs to know something about the {\em usage} of the things bound,
96 so that it can create specialisations of them. So @tcBindsAndThen@
97 takes a function which, given an extended environment, E, typechecks
98 the scope of the bindings returning a typechecked thing and (most
99 important) an LIE. It is this LIE which is then used as the basis for
100 specialising the things bound.
101
102 @tcBindsAndThen@ also takes a "combiner" which glues together the
103 bindings and the "thing" to make a new "thing".
104
105 The real work is done by @tcBindWithSigsAndThen@.
106
107 Recursive and non-recursive binds are handled in essentially the same
108 way: because of uniques there are no scoping issues left. The only
109 difference is that non-recursive bindings can bind primitive values.
110
111 Even for non-recursive binding groups we add typings for each binder
112 to the LVE for the following reason. When each individual binding is
113 checked the type of its LHS is unified with that of its RHS; and
114 type-checking the LHS of course requires that the binder is in scope.
115
116 At the top-level the LIE is sure to contain nothing but constant
117 dictionaries, which we resolve at the module level.
118
119 Note [Polymorphic recursion]
120 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
121 The game plan for polymorphic recursion in the code above is
122
123 * Bind any variable for which we have a type signature
124 to an Id with a polymorphic type. Then when type-checking
125 the RHSs we'll make a full polymorphic call.
126
127 This fine, but if you aren't a bit careful you end up with a horrendous
128 amount of partial application and (worse) a huge space leak. For example:
129
130 f :: Eq a => [a] -> [a]
131 f xs = ...f...
132
133 If we don't take care, after typechecking we get
134
135 f = /\a -> \d::Eq a -> let f' = f a d
136 in
137 \ys:[a] -> ...f'...
138
139 Notice the the stupid construction of (f a d), which is of course
140 identical to the function we're executing. In this case, the
141 polymorphic recursion isn't being used (but that's a very common case).
142 This can lead to a massive space leak, from the following top-level defn
143 (post-typechecking)
144
145 ff :: [Int] -> [Int]
146 ff = f Int dEqInt
147
148 Now (f dEqInt) evaluates to a lambda that has f' as a free variable; but
149 f' is another thunk which evaluates to the same thing... and you end
150 up with a chain of identical values all hung onto by the CAF ff.
151
152 ff = f Int dEqInt
153
154 = let f' = f Int dEqInt in \ys. ...f'...
155
156 = let f' = let f' = f Int dEqInt in \ys. ...f'...
157 in \ys. ...f'...
158
159 Etc.
160
161 NOTE: a bit of arity anaysis would push the (f a d) inside the (\ys...),
162 which would make the space leak go away in this case
163
164 Solution: when typechecking the RHSs we always have in hand the
165 *monomorphic* Ids for each binding. So we just need to make sure that
166 if (Method f a d) shows up in the constraints emerging from (...f...)
167 we just use the monomorphic Id. We achieve this by adding monomorphic Ids
168 to the "givens" when simplifying constraints. That's what the "lies_avail"
169 is doing.
170
171 Then we get
172
173 f = /\a -> \d::Eq a -> letrec
174 fm = \ys:[a] -> ...fm...
175 in
176 fm
177 -}
178
179 tcTopBinds :: [(RecFlag, LHsBinds Name)] -> [LSig Name] -> TcM (TcGblEnv, TcLclEnv)
180 -- The TcGblEnv contains the new tcg_binds and tcg_spects
181 -- The TcLclEnv has an extended type envt for the new bindings
182 tcTopBinds binds sigs
183 = do { -- Pattern synonym bindings populate the global environment
184 (binds', (tcg_env, tcl_env)) <- tcValBinds TopLevel binds sigs $
185 do { gbl <- getGblEnv
186 ; lcl <- getLclEnv
187 ; return (gbl, lcl) }
188 ; specs <- tcImpPrags sigs -- SPECIALISE prags for imported Ids
189
190 ; complete_matches <- setEnvs (tcg_env, tcl_env) $ tcCompleteSigs sigs
191 ; traceTc "complete_matches" (ppr binds $$ ppr sigs)
192 ; traceTc "complete_matches" (ppr complete_matches)
193
194 ; let { tcg_env' = tcg_env { tcg_imp_specs
195 = specs ++ tcg_imp_specs tcg_env
196 , tcg_complete_matches
197 = complete_matches
198 ++ tcg_complete_matches tcg_env }
199 `addTypecheckedBinds` map snd binds' }
200
201 ; return (tcg_env', tcl_env) }
202 -- The top level bindings are flattened into a giant
203 -- implicitly-mutually-recursive LHsBinds
204
205
206 -- Note [Typechecking Complete Matches]
207 -- Much like when a user bundled a pattern synonym, the result types of
208 -- all the constructors in the match pragma must be consistent.
209 --
210 -- If we allowed pragmas with inconsistent types then it would be
211 -- impossible to ever match every constructor in the list and so
212 -- the pragma would be useless.
213
214
215
216
217
218 -- This is only used in `tcCompleteSig`. We fold over all the conlikes,
219 -- this accumulator keeps track of the first `ConLike` with a concrete
220 -- return type. After fixing the return type, all other constructors with
221 -- a fixed return type must agree with this.
222 --
223 -- The fields of `Fixed` cache the first conlike and its return type so
224 -- that that we can compare all the other conlikes to it. The conlike is
225 -- stored for error messages.
226 --
227 -- `Nothing` in the case that the type is fixed by a type signature
228 data CompleteSigType = AcceptAny | Fixed (Maybe ConLike) TyCon
229
230 tcCompleteSigs :: [LSig Name] -> TcM [CompleteMatch]
231 tcCompleteSigs sigs =
232 let
233 doOne :: Sig Name -> TcM (Maybe CompleteMatch)
234 doOne c@(CompleteMatchSig _ lns mtc)
235 = fmap Just $ do
236 addErrCtxt (text "In" <+> ppr c) $
237 case mtc of
238 Nothing -> infer_complete_match
239 Just tc -> check_complete_match tc
240 where
241
242 checkCLTypes acc = foldM checkCLType (acc, []) (unLoc lns)
243
244 infer_complete_match = do
245 (res, cls) <- checkCLTypes AcceptAny
246 case res of
247 AcceptAny -> failWithTc ambiguousError
248 Fixed _ tc -> return $ CompleteMatch cls tc
249
250 check_complete_match tc_name = do
251 ty_con <- tcLookupLocatedTyCon tc_name
252 (_, cls) <- checkCLTypes (Fixed Nothing ty_con)
253 return $ CompleteMatch cls ty_con
254 doOne _ = return Nothing
255
256 ambiguousError :: SDoc
257 ambiguousError =
258 text "A type signature must be provided for a set of polymorphic"
259 <+> text "pattern synonyms."
260
261
262 -- See note [Typechecking Complete Matches]
263 checkCLType :: (CompleteSigType, [ConLike]) -> Located Name
264 -> TcM (CompleteSigType, [ConLike])
265 checkCLType (cst, cs) n = do
266 cl <- addLocM tcLookupConLike n
267 let (_,_,_,_,_,_, res_ty) = conLikeFullSig cl
268 res_ty_con = fst <$> splitTyConApp_maybe res_ty
269 case (cst, res_ty_con) of
270 (AcceptAny, Nothing) -> return (AcceptAny, cl:cs)
271 (AcceptAny, Just tc) -> return (Fixed (Just cl) tc, cl:cs)
272 (Fixed mfcl tc, Nothing) -> return (Fixed mfcl tc, cl:cs)
273 (Fixed mfcl tc, Just tc') ->
274 if tc == tc'
275 then return (Fixed mfcl tc, cl:cs)
276 else case mfcl of
277 Nothing ->
278 addErrCtxt (text "In" <+> ppr cl) $
279 failWithTc typeSigErrMsg
280 Just cl -> failWithTc (errMsg cl)
281 where
282 typeSigErrMsg :: SDoc
283 typeSigErrMsg =
284 text "Couldn't match expected type"
285 <+> quotes (ppr tc)
286 <+> text "with"
287 <+> quotes (ppr tc')
288
289 errMsg :: ConLike -> SDoc
290 errMsg fcl =
291 text "Cannot form a group of complete patterns from patterns"
292 <+> quotes (ppr fcl) <+> text "and" <+> quotes (ppr cl)
293 <+> text "as they match different type constructors"
294 <+> parens (quotes (ppr tc)
295 <+> text "resp."
296 <+> quotes (ppr tc'))
297 in mapMaybeM (addLocM doOne) sigs
298
299 tcRecSelBinds :: HsValBinds Name -> TcM TcGblEnv
300 tcRecSelBinds (ValBindsOut binds sigs)
301 = tcExtendGlobalValEnv [sel_id | L _ (IdSig sel_id) <- sigs] $
302 do { (rec_sel_binds, tcg_env) <- discardWarnings $
303 tcValBinds TopLevel binds sigs getGblEnv
304 ; let tcg_env' = tcg_env `addTypecheckedBinds` map snd rec_sel_binds
305 ; return tcg_env' }
306 tcRecSelBinds (ValBindsIn {}) = panic "tcRecSelBinds"
307
308 tcHsBootSigs :: [(RecFlag, LHsBinds Name)] -> [LSig Name] -> TcM [Id]
309 -- A hs-boot file has only one BindGroup, and it only has type
310 -- signatures in it. The renamer checked all this
311 tcHsBootSigs binds sigs
312 = do { checkTc (null binds) badBootDeclErr
313 ; concat <$> mapM (addLocM tc_boot_sig) (filter isTypeLSig sigs) }
314 where
315 tc_boot_sig (TypeSig lnames hs_ty) = mapM f lnames
316 where
317 f (L _ name)
318 = do { sigma_ty <- solveEqualities $
319 tcHsSigWcType (FunSigCtxt name False) hs_ty
320 ; return (mkVanillaGlobal name sigma_ty) }
321 -- Notice that we make GlobalIds, not LocalIds
322 tc_boot_sig s = pprPanic "tcHsBootSigs/tc_boot_sig" (ppr s)
323
324 badBootDeclErr :: MsgDoc
325 badBootDeclErr = text "Illegal declarations in an hs-boot file"
326
327 ------------------------
328 tcLocalBinds :: HsLocalBinds Name -> TcM thing
329 -> TcM (HsLocalBinds TcId, thing)
330
331 tcLocalBinds EmptyLocalBinds thing_inside
332 = do { thing <- thing_inside
333 ; return (EmptyLocalBinds, thing) }
334
335 tcLocalBinds (HsValBinds (ValBindsOut binds sigs)) thing_inside
336 = do { (binds', thing) <- tcValBinds NotTopLevel binds sigs thing_inside
337 ; return (HsValBinds (ValBindsOut binds' sigs), thing) }
338 tcLocalBinds (HsValBinds (ValBindsIn {})) _ = panic "tcLocalBinds"
339
340 tcLocalBinds (HsIPBinds (IPBinds ip_binds _)) thing_inside
341 = do { ipClass <- tcLookupClass ipClassName
342 ; (given_ips, ip_binds') <-
343 mapAndUnzipM (wrapLocSndM (tc_ip_bind ipClass)) ip_binds
344
345 -- If the binding binds ?x = E, we must now
346 -- discharge any ?x constraints in expr_lie
347 -- See Note [Implicit parameter untouchables]
348 ; (ev_binds, result) <- checkConstraints (IPSkol ips)
349 [] given_ips thing_inside
350
351 ; return (HsIPBinds (IPBinds ip_binds' ev_binds), result) }
352 where
353 ips = [ip | L _ (IPBind (Left (L _ ip)) _) <- ip_binds]
354
355 -- I wonder if we should do these one at at time
356 -- Consider ?x = 4
357 -- ?y = ?x + 1
358 tc_ip_bind ipClass (IPBind (Left (L _ ip)) expr)
359 = do { ty <- newOpenFlexiTyVarTy
360 ; let p = mkStrLitTy $ hsIPNameFS ip
361 ; ip_id <- newDict ipClass [ p, ty ]
362 ; expr' <- tcMonoExpr expr (mkCheckExpType ty)
363 ; let d = toDict ipClass p ty `fmap` expr'
364 ; return (ip_id, (IPBind (Right ip_id) d)) }
365 tc_ip_bind _ (IPBind (Right {}) _) = panic "tc_ip_bind"
366
367 -- Coerces a `t` into a dictionry for `IP "x" t`.
368 -- co : t -> IP "x" t
369 toDict ipClass x ty = HsWrap $ mkWpCastR $
370 wrapIP $ mkClassPred ipClass [x,ty]
371
372 {- Note [Implicit parameter untouchables]
373 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
374 We add the type variables in the types of the implicit parameters
375 as untouchables, not so much because we really must not unify them,
376 but rather because we otherwise end up with constraints like this
377 Num alpha, Implic { wanted = alpha ~ Int }
378 The constraint solver solves alpha~Int by unification, but then
379 doesn't float that solved constraint out (it's not an unsolved
380 wanted). Result disaster: the (Num alpha) is again solved, this
381 time by defaulting. No no no.
382
383 However [Oct 10] this is all handled automatically by the
384 untouchable-range idea.
385 -}
386
387 tcValBinds :: TopLevelFlag
388 -> [(RecFlag, LHsBinds Name)] -> [LSig Name]
389 -> TcM thing
390 -> TcM ([(RecFlag, LHsBinds TcId)], thing)
391
392 tcValBinds top_lvl binds sigs thing_inside
393 = do { let patsyns = getPatSynBinds binds
394
395 -- Typecheck the signature
396 ; (poly_ids, sig_fn) <- tcAddPatSynPlaceholders patsyns $
397 tcTySigs sigs
398
399 ; let prag_fn = mkPragEnv sigs (foldr (unionBags . snd) emptyBag binds)
400
401 -- Extend the envt right away with all the Ids
402 -- declared with complete type signatures
403 -- Do not extend the TcIdBinderStack; instead
404 -- we extend it on a per-rhs basis in tcExtendForRhs
405 ; tcExtendLetEnvIds top_lvl [(idName id, id) | id <- poly_ids] $ do
406 { (binds', (extra_binds', thing)) <- tcBindGroups top_lvl sig_fn prag_fn binds $ do
407 { thing <- thing_inside
408 -- See Note [Pattern synonym builders don't yield dependencies]
409 -- in RnBinds
410 ; patsyn_builders <- mapM tcPatSynBuilderBind patsyns
411 ; let extra_binds = [ (NonRecursive, builder) | builder <- patsyn_builders ]
412 ; return (extra_binds, thing) }
413 ; return (binds' ++ extra_binds', thing) }}
414
415 ------------------------
416 tcBindGroups :: TopLevelFlag -> TcSigFun -> TcPragEnv
417 -> [(RecFlag, LHsBinds Name)] -> TcM thing
418 -> TcM ([(RecFlag, LHsBinds TcId)], thing)
419 -- Typecheck a whole lot of value bindings,
420 -- one strongly-connected component at a time
421 -- Here a "strongly connected component" has the strightforward
422 -- meaning of a group of bindings that mention each other,
423 -- ignoring type signatures (that part comes later)
424
425 tcBindGroups _ _ _ [] thing_inside
426 = do { thing <- thing_inside
427 ; return ([], thing) }
428
429 tcBindGroups top_lvl sig_fn prag_fn (group : groups) thing_inside
430 = do { -- See Note [Closed binder groups]
431 closed <- isClosedBndrGroup $ snd group
432 ; (group', (groups', thing))
433 <- tc_group top_lvl sig_fn prag_fn group closed $
434 tcBindGroups top_lvl sig_fn prag_fn groups thing_inside
435 ; return (group' ++ groups', thing) }
436
437 -- Note [Closed binder groups]
438 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~
439 --
440 -- A mutually recursive group is "closed" if all of the free variables of
441 -- the bindings are closed. For example
442 --
443 -- > h = \x -> let f = ...g...
444 -- > g = ....f...x...
445 -- > in ...
446 --
447 -- Here @g@ is not closed because it mentions @x@; and hence neither is @f@
448 -- closed.
449 --
450 -- So we need to compute closed-ness on each strongly connected components,
451 -- before we sub-divide it based on what type signatures it has.
452 --
453
454 ------------------------
455 tc_group :: forall thing.
456 TopLevelFlag -> TcSigFun -> TcPragEnv
457 -> (RecFlag, LHsBinds Name) -> IsGroupClosed -> TcM thing
458 -> TcM ([(RecFlag, LHsBinds TcId)], thing)
459
460 -- Typecheck one strongly-connected component of the original program.
461 -- We get a list of groups back, because there may
462 -- be specialisations etc as well
463
464 tc_group top_lvl sig_fn prag_fn (NonRecursive, binds) closed thing_inside
465 -- A single non-recursive binding
466 -- We want to keep non-recursive things non-recursive
467 -- so that we desugar unlifted bindings correctly
468 = do { let bind = case bagToList binds of
469 [bind] -> bind
470 [] -> panic "tc_group: empty list of binds"
471 _ -> panic "tc_group: NonRecursive binds is not a singleton bag"
472 ; (bind', thing) <- tc_single top_lvl sig_fn prag_fn bind closed
473 thing_inside
474 ; return ( [(NonRecursive, bind')], thing) }
475
476 tc_group top_lvl sig_fn prag_fn (Recursive, binds) closed thing_inside
477 = -- To maximise polymorphism, we do a new
478 -- strongly-connected-component analysis, this time omitting
479 -- any references to variables with type signatures.
480 -- (This used to be optional, but isn't now.)
481 -- See Note [Polymorphic recursion] in HsBinds.
482 do { traceTc "tc_group rec" (pprLHsBinds binds)
483 ; when hasPatSyn $ recursivePatSynErr binds
484 ; (binds1, thing) <- go sccs
485 ; return ([(Recursive, binds1)], thing) }
486 -- Rec them all together
487 where
488 hasPatSyn = anyBag (isPatSyn . unLoc) binds
489 isPatSyn PatSynBind{} = True
490 isPatSyn _ = False
491
492 sccs :: [SCC (LHsBind Name)]
493 sccs = stronglyConnCompFromEdgedVerticesUniq (mkEdges sig_fn binds)
494
495 go :: [SCC (LHsBind Name)] -> TcM (LHsBinds TcId, thing)
496 go (scc:sccs) = do { (binds1, ids1) <- tc_scc scc
497 ; (binds2, thing) <- tcExtendLetEnv top_lvl closed ids1
498 (go sccs)
499 ; return (binds1 `unionBags` binds2, thing) }
500 go [] = do { thing <- thing_inside; return (emptyBag, thing) }
501
502 tc_scc (AcyclicSCC bind) = tc_sub_group NonRecursive [bind]
503 tc_scc (CyclicSCC binds) = tc_sub_group Recursive binds
504
505 tc_sub_group rec_tc binds =
506 tcPolyBinds sig_fn prag_fn Recursive rec_tc closed binds
507
508 recursivePatSynErr :: OutputableBndr name => LHsBinds name -> TcM a
509 recursivePatSynErr binds
510 = failWithTc $
511 hang (text "Recursive pattern synonym definition with following bindings:")
512 2 (vcat $ map pprLBind . bagToList $ binds)
513 where
514 pprLoc loc = parens (text "defined at" <+> ppr loc)
515 pprLBind (L loc bind) = pprWithCommas ppr (collectHsBindBinders bind) <+>
516 pprLoc loc
517
518 tc_single :: forall thing.
519 TopLevelFlag -> TcSigFun -> TcPragEnv
520 -> LHsBind Name -> IsGroupClosed -> TcM thing
521 -> TcM (LHsBinds TcId, thing)
522 tc_single _top_lvl sig_fn _prag_fn
523 (L _ (PatSynBind psb@PSB{ psb_id = L _ name }))
524 _ thing_inside
525 = do { (aux_binds, tcg_env) <- tc_pat_syn_decl
526 ; thing <- setGblEnv tcg_env thing_inside
527 ; return (aux_binds, thing)
528 }
529 where
530 tc_pat_syn_decl :: TcM (LHsBinds TcId, TcGblEnv)
531 tc_pat_syn_decl = case sig_fn name of
532 Nothing -> tcInferPatSynDecl psb
533 Just (TcPatSynSig tpsi) -> tcCheckPatSynDecl psb tpsi
534 Just _ -> panic "tc_single"
535
536 tc_single top_lvl sig_fn prag_fn lbind closed thing_inside
537 = do { (binds1, ids) <- tcPolyBinds sig_fn prag_fn
538 NonRecursive NonRecursive
539 closed
540 [lbind]
541 ; thing <- tcExtendLetEnv top_lvl closed ids thing_inside
542 ; return (binds1, thing) }
543
544 ------------------------
545 type BKey = Int -- Just number off the bindings
546
547 mkEdges :: TcSigFun -> LHsBinds Name -> [Node BKey (LHsBind Name)]
548 -- See Note [Polymorphic recursion] in HsBinds.
549 mkEdges sig_fn binds
550 = [ (bind, key, [key | n <- nonDetEltsUniqSet (bind_fvs (unLoc bind)),
551 Just key <- [lookupNameEnv key_map n], no_sig n ])
552 | (bind, key) <- keyd_binds
553 ]
554 -- It's OK to use nonDetEltsUFM here as stronglyConnCompFromEdgedVertices
555 -- is still deterministic even if the edges are in nondeterministic order
556 -- as explained in Note [Deterministic SCC] in Digraph.
557 where
558 no_sig :: Name -> Bool
559 no_sig n = noCompleteSig (sig_fn n)
560
561 keyd_binds = bagToList binds `zip` [0::BKey ..]
562
563 key_map :: NameEnv BKey -- Which binding it comes from
564 key_map = mkNameEnv [(bndr, key) | (L _ bind, key) <- keyd_binds
565 , bndr <- collectHsBindBinders bind ]
566
567 ------------------------
568 tcPolyBinds :: TcSigFun -> TcPragEnv
569 -> RecFlag -- Whether the group is really recursive
570 -> RecFlag -- Whether it's recursive after breaking
571 -- dependencies based on type signatures
572 -> IsGroupClosed -- Whether the group is closed
573 -> [LHsBind Name] -- None are PatSynBind
574 -> TcM (LHsBinds TcId, [TcId])
575
576 -- Typechecks a single bunch of values bindings all together,
577 -- and generalises them. The bunch may be only part of a recursive
578 -- group, because we use type signatures to maximise polymorphism
579 --
580 -- Returns a list because the input may be a single non-recursive binding,
581 -- in which case the dependency order of the resulting bindings is
582 -- important.
583 --
584 -- Knows nothing about the scope of the bindings
585 -- None of the bindings are pattern synonyms
586
587 tcPolyBinds sig_fn prag_fn rec_group rec_tc closed bind_list
588 = setSrcSpan loc $
589 recoverM (recoveryCode binder_names sig_fn) $ do
590 -- Set up main recover; take advantage of any type sigs
591
592 { traceTc "------------------------------------------------" Outputable.empty
593 ; traceTc "Bindings for {" (ppr binder_names)
594 ; dflags <- getDynFlags
595 ; let plan = decideGeneralisationPlan dflags bind_list closed sig_fn
596 ; traceTc "Generalisation plan" (ppr plan)
597 ; result@(_, poly_ids) <- case plan of
598 NoGen -> tcPolyNoGen rec_tc prag_fn sig_fn bind_list
599 InferGen mn -> tcPolyInfer rec_tc prag_fn sig_fn mn bind_list
600 CheckGen lbind sig -> tcPolyCheck prag_fn sig lbind
601
602 ; traceTc "} End of bindings for" (vcat [ ppr binder_names, ppr rec_group
603 , vcat [ppr id <+> ppr (idType id) | id <- poly_ids]
604 ])
605
606 ; return result }
607 where
608 binder_names = collectHsBindListBinders bind_list
609 loc = foldr1 combineSrcSpans (map getLoc bind_list)
610 -- The mbinds have been dependency analysed and
611 -- may no longer be adjacent; so find the narrowest
612 -- span that includes them all
613
614 --------------
615 -- If typechecking the binds fails, then return with each
616 -- signature-less binder given type (forall a.a), to minimise
617 -- subsequent error messages
618 recoveryCode :: [Name] -> TcSigFun -> TcM (LHsBinds TcId, [Id])
619 recoveryCode binder_names sig_fn
620 = do { traceTc "tcBindsWithSigs: error recovery" (ppr binder_names)
621 ; let poly_ids = map mk_dummy binder_names
622 ; return (emptyBag, poly_ids) }
623 where
624 mk_dummy name
625 | Just sig <- sig_fn name
626 , Just poly_id <- completeSigPolyId_maybe sig
627 = poly_id
628 | otherwise
629 = mkLocalId name forall_a_a
630
631 forall_a_a :: TcType
632 forall_a_a = mkSpecForAllTys [runtimeRep1TyVar, openAlphaTyVar] openAlphaTy
633
634 {- *********************************************************************
635 * *
636 tcPolyNoGen
637 * *
638 ********************************************************************* -}
639
640 tcPolyNoGen -- No generalisation whatsoever
641 :: RecFlag -- Whether it's recursive after breaking
642 -- dependencies based on type signatures
643 -> TcPragEnv -> TcSigFun
644 -> [LHsBind Name]
645 -> TcM (LHsBinds TcId, [TcId])
646
647 tcPolyNoGen rec_tc prag_fn tc_sig_fn bind_list
648 = do { (binds', mono_infos) <- tcMonoBinds rec_tc tc_sig_fn
649 (LetGblBndr prag_fn)
650 bind_list
651 ; mono_ids' <- mapM tc_mono_info mono_infos
652 ; return (binds', mono_ids') }
653 where
654 tc_mono_info (MBI { mbi_poly_name = name, mbi_mono_id = mono_id })
655 = do { _specs <- tcSpecPrags mono_id (lookupPragEnv prag_fn name)
656 ; return mono_id }
657 -- NB: tcPrags generates error messages for
658 -- specialisation pragmas for non-overloaded sigs
659 -- Indeed that is why we call it here!
660 -- So we can safely ignore _specs
661
662
663 {- *********************************************************************
664 * *
665 tcPolyCheck
666 * *
667 ********************************************************************* -}
668
669 tcPolyCheck :: TcPragEnv
670 -> TcIdSigInfo -- Must be a complete signature
671 -> LHsBind Name -- Must be a FunBind
672 -> TcM (LHsBinds TcId, [TcId])
673 -- There is just one binding,
674 -- it is a Funbind
675 -- it has a complete type signature,
676 tcPolyCheck prag_fn
677 (CompleteSig { sig_bndr = poly_id
678 , sig_ctxt = ctxt
679 , sig_loc = sig_loc })
680 (L loc (FunBind { fun_id = L nm_loc name
681 , fun_matches = matches }))
682 = setSrcSpan sig_loc $
683 do { traceTc "tcPolyCheck" (ppr poly_id $$ ppr sig_loc)
684 ; (tv_prs, theta, tau) <- tcInstType (tcInstSigTyVars sig_loc) poly_id
685 -- See Note [Instantiate sig with fresh variables]
686
687 ; mono_name <- newNameAt (nameOccName name) nm_loc
688 ; ev_vars <- newEvVars theta
689 ; let mono_id = mkLocalId mono_name tau
690 skol_info = SigSkol ctxt (mkPhiTy theta tau)
691 skol_tvs = map snd tv_prs
692
693 ; (ev_binds, (co_fn, matches'))
694 <- checkConstraints skol_info skol_tvs ev_vars $
695 tcExtendIdBndrs [TcIdBndr mono_id NotTopLevel] $
696 tcExtendTyVarEnv2 tv_prs $
697 setSrcSpan loc $
698 tcMatchesFun (L nm_loc mono_name) matches (mkCheckExpType tau)
699
700 ; let prag_sigs = lookupPragEnv prag_fn name
701 ; spec_prags <- tcSpecPrags poly_id prag_sigs
702 ; poly_id <- addInlinePrags poly_id prag_sigs
703
704 ; mod <- getModule
705 ; let bind' = FunBind { fun_id = L nm_loc mono_id
706 , fun_matches = matches'
707 , fun_co_fn = co_fn
708 , bind_fvs = placeHolderNamesTc
709 , fun_tick = funBindTicks nm_loc mono_id mod prag_sigs }
710
711 abs_bind = L loc $ AbsBindsSig
712 { abs_sig_export = poly_id
713 , abs_tvs = skol_tvs
714 , abs_ev_vars = ev_vars
715 , abs_sig_prags = SpecPrags spec_prags
716 , abs_sig_ev_bind = ev_binds
717 , abs_sig_bind = L loc bind' }
718
719 ; return (unitBag abs_bind, [poly_id]) }
720
721 tcPolyCheck _prag_fn sig bind
722 = pprPanic "tcPolyCheck" (ppr sig $$ ppr bind)
723
724 funBindTicks :: SrcSpan -> TcId -> Module -> [LSig Name] -> [Tickish TcId]
725 funBindTicks loc fun_id mod sigs
726 | (mb_cc_str : _) <- [ cc_name | L _ (SCCFunSig _ _ cc_name) <- sigs ]
727 -- this can only be a singleton list, as duplicate pragmas are rejected
728 -- by the renamer
729 , let cc_str
730 | Just cc_str <- mb_cc_str
731 = sl_fs $ unLoc cc_str
732 | otherwise
733 = getOccFS (Var.varName fun_id)
734 cc_name = moduleNameFS (moduleName mod) `appendFS` consFS '.' cc_str
735 cc = mkUserCC cc_name mod loc (getUnique fun_id)
736 = [ProfNote cc True True]
737 | otherwise
738 = []
739
740 {- Note [Instantiate sig with fresh variables]
741 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
742 It's vital to instantiate a type signature with fresh variables.
743 For example:
744 type T = forall a. [a] -> [a]
745 f :: T;
746 f = g where { g :: T; g = <rhs> }
747
748 We must not use the same 'a' from the defn of T at both places!!
749 (Instantiation is only necessary because of type synonyms. Otherwise,
750 it's all cool; each signature has distinct type variables from the renamer.)
751 -}
752
753
754 {- *********************************************************************
755 * *
756 tcPolyInfer
757 * *
758 ********************************************************************* -}
759
760 tcPolyInfer
761 :: RecFlag -- Whether it's recursive after breaking
762 -- dependencies based on type signatures
763 -> TcPragEnv -> TcSigFun
764 -> Bool -- True <=> apply the monomorphism restriction
765 -> [LHsBind Name]
766 -> TcM (LHsBinds TcId, [TcId])
767 tcPolyInfer rec_tc prag_fn tc_sig_fn mono bind_list
768 = do { (tclvl, wanted, (binds', mono_infos))
769 <- pushLevelAndCaptureConstraints $
770 tcMonoBinds rec_tc tc_sig_fn LetLclBndr bind_list
771
772 ; let name_taus = [ (mbi_poly_name info, idType (mbi_mono_id info))
773 | info <- mono_infos ]
774 sigs = [ sig | MBI { mbi_sig = Just sig } <- mono_infos ]
775 infer_mode = if mono then ApplyMR else NoRestrictions
776
777 ; mapM_ (checkOverloadedSig mono) sigs
778
779 ; traceTc "simplifyInfer call" (ppr tclvl $$ ppr name_taus $$ ppr wanted)
780 ; (qtvs, givens, ev_binds)
781 <- simplifyInfer tclvl infer_mode sigs name_taus wanted
782
783 ; let inferred_theta = map evVarPred givens
784 ; exports <- checkNoErrs $
785 mapM (mkExport prag_fn qtvs inferred_theta) mono_infos
786
787 ; loc <- getSrcSpanM
788 ; let poly_ids = map abe_poly exports
789 abs_bind = L loc $
790 AbsBinds { abs_tvs = qtvs
791 , abs_ev_vars = givens, abs_ev_binds = [ev_binds]
792 , abs_exports = exports, abs_binds = binds' }
793
794 ; traceTc "Binding:" (ppr (poly_ids `zip` map idType poly_ids))
795 ; return (unitBag abs_bind, poly_ids) }
796 -- poly_ids are guaranteed zonked by mkExport
797
798 --------------
799 mkExport :: TcPragEnv
800 -> [TyVar] -> TcThetaType -- Both already zonked
801 -> MonoBindInfo
802 -> TcM (ABExport Id)
803 -- Only called for generalisation plan InferGen, not by CheckGen or NoGen
804 --
805 -- mkExport generates exports with
806 -- zonked type variables,
807 -- zonked poly_ids
808 -- The former is just because no further unifications will change
809 -- the quantified type variables, so we can fix their final form
810 -- right now.
811 -- The latter is needed because the poly_ids are used to extend the
812 -- type environment; see the invariant on TcEnv.tcExtendIdEnv
813
814 -- Pre-condition: the qtvs and theta are already zonked
815
816 mkExport prag_fn qtvs theta
817 mono_info@(MBI { mbi_poly_name = poly_name
818 , mbi_sig = mb_sig
819 , mbi_mono_id = mono_id })
820 = do { mono_ty <- zonkTcType (idType mono_id)
821 ; poly_id <- mkInferredPolyId qtvs theta poly_name mb_sig mono_ty
822
823 -- NB: poly_id has a zonked type
824 ; poly_id <- addInlinePrags poly_id prag_sigs
825 ; spec_prags <- tcSpecPrags poly_id prag_sigs
826 -- tcPrags requires a zonked poly_id
827
828 -- See Note [Impedence matching]
829 -- NB: we have already done checkValidType, including an ambiguity check,
830 -- on the type; either when we checked the sig or in mkInferredPolyId
831 ; let poly_ty = idType poly_id
832 sel_poly_ty = mkInfSigmaTy qtvs theta mono_ty
833 -- This type is just going into tcSubType,
834 -- so Inferred vs. Specified doesn't matter
835
836 ; wrap <- if sel_poly_ty `eqType` poly_ty -- NB: eqType ignores visibility
837 then return idHsWrapper -- Fast path; also avoids complaint when we infer
838 -- an ambiguouse type and have AllowAmbiguousType
839 -- e..g infer x :: forall a. F a -> Int
840 else addErrCtxtM (mk_impedence_match_msg mono_info sel_poly_ty poly_ty) $
841 tcSubType_NC sig_ctxt sel_poly_ty poly_ty
842
843 ; warn_missing_sigs <- woptM Opt_WarnMissingLocalSignatures
844 ; when warn_missing_sigs $
845 localSigWarn Opt_WarnMissingLocalSignatures poly_id mb_sig
846
847 ; return (ABE { abe_wrap = wrap
848 -- abe_wrap :: idType poly_id ~ (forall qtvs. theta => mono_ty)
849 , abe_poly = poly_id
850 , abe_mono = mono_id
851 , abe_prags = SpecPrags spec_prags}) }
852 where
853 prag_sigs = lookupPragEnv prag_fn poly_name
854 sig_ctxt = InfSigCtxt poly_name
855
856 mkInferredPolyId :: [TyVar] -> TcThetaType
857 -> Name -> Maybe TcIdSigInst -> TcType
858 -> TcM TcId
859 mkInferredPolyId qtvs inferred_theta poly_name mb_sig_inst mono_ty
860 | Just (TISI { sig_inst_sig = sig }) <- mb_sig_inst
861 , CompleteSig { sig_bndr = poly_id } <- sig
862 = return poly_id
863
864 | otherwise -- Either no type sig or partial type sig
865 = checkNoErrs $ -- The checkNoErrs ensures that if the type is ambiguous
866 -- we don't carry on to the impedence matching, and generate
867 -- a duplicate ambiguity error. There is a similar
868 -- checkNoErrs for complete type signatures too.
869 do { fam_envs <- tcGetFamInstEnvs
870 ; let (_co, mono_ty') = normaliseType fam_envs Nominal mono_ty
871 -- Unification may not have normalised the type,
872 -- (see Note [Lazy flattening] in TcFlatten) so do it
873 -- here to make it as uncomplicated as possible.
874 -- Example: f :: [F Int] -> Bool
875 -- should be rewritten to f :: [Char] -> Bool, if possible
876 --
877 -- We can discard the coercion _co, because we'll reconstruct
878 -- it in the call to tcSubType below
879
880 ; (binders, theta') <- chooseInferredQuantifiers inferred_theta
881 (tyCoVarsOfType mono_ty') qtvs mb_sig_inst
882
883 ; let inferred_poly_ty = mkForAllTys binders (mkPhiTy theta' mono_ty')
884
885 ; traceTc "mkInferredPolyId" (vcat [ppr poly_name, ppr qtvs, ppr theta'
886 , ppr inferred_poly_ty])
887 ; addErrCtxtM (mk_inf_msg poly_name inferred_poly_ty) $
888 checkValidType (InfSigCtxt poly_name) inferred_poly_ty
889 -- See Note [Validity of inferred types]
890
891 ; return (mkLocalIdOrCoVar poly_name inferred_poly_ty) }
892
893
894 chooseInferredQuantifiers :: TcThetaType -- inferred
895 -> TcTyVarSet -- tvs free in tau type
896 -> [TcTyVar] -- inferred quantified tvs
897 -> Maybe TcIdSigInst
898 -> TcM ([TyVarBinder], TcThetaType)
899 chooseInferredQuantifiers inferred_theta tau_tvs qtvs Nothing
900 = -- No type signature (partial or complete) for this binder,
901 do { let free_tvs = closeOverKinds (growThetaTyVars inferred_theta tau_tvs)
902 -- Include kind variables! Trac #7916
903 my_theta = pickCapturedPreds free_tvs inferred_theta
904 binders = [ mkTyVarBinder Inferred tv
905 | tv <- qtvs
906 , tv `elemVarSet` free_tvs ]
907 ; return (binders, my_theta) }
908
909 chooseInferredQuantifiers inferred_theta tau_tvs qtvs
910 (Just (TISI { sig_inst_sig = sig -- Always PartialSig
911 , sig_inst_wcx = wcx
912 , sig_inst_theta = annotated_theta
913 , sig_inst_skols = annotated_tvs }))
914 | Nothing <- wcx
915 = do { annotated_theta <- zonkTcTypes annotated_theta
916 ; let free_tvs = closeOverKinds (tyCoVarsOfTypes annotated_theta
917 `unionVarSet` tau_tvs)
918 ; traceTc "ciq" (vcat [ ppr sig, ppr annotated_theta, ppr free_tvs])
919 ; return (mk_binders free_tvs, annotated_theta) }
920
921 | Just wc_var <- wcx
922 = do { annotated_theta <- zonkTcTypes annotated_theta
923 ; let free_tvs = closeOverKinds (growThetaTyVars inferred_theta seed_tvs)
924 -- growThetaVars just like the no-type-sig case
925 -- Omitting this caused #12844
926 seed_tvs = tyCoVarsOfTypes annotated_theta -- These are put there
927 `unionVarSet` tau_tvs -- by the user
928 my_theta = pickCapturedPreds free_tvs inferred_theta
929
930 -- Report the inferred constraints for an extra-constraints wildcard/hole as
931 -- an error message, unless the PartialTypeSignatures flag is enabled. In this
932 -- case, the extra inferred constraints are accepted without complaining.
933 -- NB: inferred_theta already includes all the annotated constraints
934 inferred_diff = [ pred
935 | pred <- my_theta
936 , all (not . (`eqType` pred)) annotated_theta ]
937 ; ctuple <- mk_ctuple inferred_diff
938 ; writeMetaTyVar wc_var ctuple
939 ; traceTc "completeTheta" $
940 vcat [ ppr sig
941 , ppr annotated_theta, ppr inferred_theta
942 , ppr inferred_diff ]
943
944 ; return (mk_binders free_tvs, my_theta) }
945
946 | otherwise -- A complete type signature is dealt with in mkInferredPolyId
947 = pprPanic "chooseInferredQuantifiers" (ppr sig)
948
949 where
950 spec_tv_set = mkVarSet $ map snd annotated_tvs
951 mk_binders free_tvs
952 = [ mkTyVarBinder vis tv
953 | tv <- qtvs
954 , tv `elemVarSet` free_tvs
955 , let vis | tv `elemVarSet` spec_tv_set = Specified
956 | otherwise = Inferred ]
957 -- Pulling from qtvs maintains original order
958
959 mk_ctuple [pred] = return pred
960 mk_ctuple preds = do { tc <- tcLookupTyCon (cTupleTyConName (length preds))
961 ; return (mkTyConApp tc preds) }
962
963 mk_impedence_match_msg :: MonoBindInfo
964 -> TcType -> TcType
965 -> TidyEnv -> TcM (TidyEnv, SDoc)
966 -- This is a rare but rather awkward error messages
967 mk_impedence_match_msg (MBI { mbi_poly_name = name, mbi_sig = mb_sig })
968 inf_ty sig_ty tidy_env
969 = do { (tidy_env1, inf_ty) <- zonkTidyTcType tidy_env inf_ty
970 ; (tidy_env2, sig_ty) <- zonkTidyTcType tidy_env1 sig_ty
971 ; let msg = vcat [ text "When checking that the inferred type"
972 , nest 2 $ ppr name <+> dcolon <+> ppr inf_ty
973 , text "is as general as its" <+> what <+> text "signature"
974 , nest 2 $ ppr name <+> dcolon <+> ppr sig_ty ]
975 ; return (tidy_env2, msg) }
976 where
977 what = case mb_sig of
978 Nothing -> text "inferred"
979 Just sig | isPartialSig sig -> text "(partial)"
980 | otherwise -> empty
981
982
983 mk_inf_msg :: Name -> TcType -> TidyEnv -> TcM (TidyEnv, SDoc)
984 mk_inf_msg poly_name poly_ty tidy_env
985 = do { (tidy_env1, poly_ty) <- zonkTidyTcType tidy_env poly_ty
986 ; let msg = vcat [ text "When checking the inferred type"
987 , nest 2 $ ppr poly_name <+> dcolon <+> ppr poly_ty ]
988 ; return (tidy_env1, msg) }
989
990
991 -- | Warn the user about polymorphic local binders that lack type signatures.
992 localSigWarn :: WarningFlag -> Id -> Maybe TcIdSigInst -> TcM ()
993 localSigWarn flag id mb_sig
994 | Just _ <- mb_sig = return ()
995 | not (isSigmaTy (idType id)) = return ()
996 | otherwise = warnMissingSignatures flag msg id
997 where
998 msg = text "Polymorphic local binding with no type signature:"
999
1000 warnMissingSignatures :: WarningFlag -> SDoc -> Id -> TcM ()
1001 warnMissingSignatures flag msg id
1002 = do { env0 <- tcInitTidyEnv
1003 ; let (env1, tidy_ty) = tidyOpenType env0 (idType id)
1004 ; addWarnTcM (Reason flag) (env1, mk_msg tidy_ty) }
1005 where
1006 mk_msg ty = sep [ msg, nest 2 $ pprPrefixName (idName id) <+> dcolon <+> ppr ty ]
1007
1008 checkOverloadedSig :: Bool -> TcIdSigInst -> TcM ()
1009 -- Example:
1010 -- f :: Eq a => a -> a
1011 -- K f = e
1012 -- The MR applies, but the signature is overloaded, and it's
1013 -- best to complain about this directly
1014 -- c.f Trac #11339
1015 checkOverloadedSig monomorphism_restriction_applies sig
1016 | not (null (sig_inst_theta sig))
1017 , monomorphism_restriction_applies
1018 , let orig_sig = sig_inst_sig sig
1019 = setSrcSpan (sig_loc orig_sig) $
1020 failWith $
1021 hang (text "Overloaded signature conflicts with monomorphism restriction")
1022 2 (ppr orig_sig)
1023 | otherwise
1024 = return ()
1025
1026 {- Note [Partial type signatures and generalisation]
1027 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1028 If /any/ of the signatures in the gropu is a partial type signature
1029 f :: _ -> Int
1030 then we *always* use the InferGen plan, and hence tcPolyInfer.
1031 We do this even for a local binding with -XMonoLocalBinds, when
1032 we normally use NoGen.
1033
1034 Reasons:
1035 * The TcSigInfo for 'f' has a unification variable for the '_',
1036 whose TcLevel is one level deeper than the current level.
1037 (See pushTcLevelM in tcTySig.) But NoGen doesn't increase
1038 the TcLevel like InferGen, so we lose the level invariant.
1039
1040 * The signature might be f :: forall a. _ -> a
1041 so it really is polymorphic. It's not clear what it would
1042 mean to use NoGen on this, and indeed the ASSERT in tcLhs,
1043 in the (Just sig) case, checks that if there is a signature
1044 then we are using LetLclBndr, and hence a nested AbsBinds with
1045 increased TcLevel
1046
1047 It might be possible to fix these difficulties somehow, but there
1048 doesn't seem much point. Indeed, adding a partial type signature is a
1049 way to get per-binding inferred generalisation.
1050
1051 We apply the MR if /all/ of the partial signatures lack a context.
1052 In particular (Trac #11016):
1053 f2 :: (?loc :: Int) => _
1054 f2 = ?loc
1055 It's stupid to apply the MR here. This test includes an extra-constraints
1056 wildcard; that is, we don't apply the MR if you write
1057 f3 :: _ => blah
1058
1059 Note [Validity of inferred types]
1060 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1061 We need to check inferred type for validity, in case it uses language
1062 extensions that are not turned on. The principle is that if the user
1063 simply adds the inferred type to the program source, it'll compile fine.
1064 See #8883.
1065
1066 Examples that might fail:
1067 - the type might be ambiguous
1068
1069 - an inferred theta that requires type equalities e.g. (F a ~ G b)
1070 or multi-parameter type classes
1071 - an inferred type that includes unboxed tuples
1072
1073
1074 Note [Impedence matching]
1075 ~~~~~~~~~~~~~~~~~~~~~~~~~
1076 Consider
1077 f 0 x = x
1078 f n x = g [] (not x)
1079
1080 g [] y = f 10 y
1081 g _ y = f 9 y
1082
1083 After typechecking we'll get
1084 f_mono_ty :: a -> Bool -> Bool
1085 g_mono_ty :: [b] -> Bool -> Bool
1086 with constraints
1087 (Eq a, Num a)
1088
1089 Note that f is polymorphic in 'a' and g in 'b'; and these are not linked.
1090 The types we really want for f and g are
1091 f :: forall a. (Eq a, Num a) => a -> Bool -> Bool
1092 g :: forall b. [b] -> Bool -> Bool
1093
1094 We can get these by "impedance matching":
1095 tuple :: forall a b. (Eq a, Num a) => (a -> Bool -> Bool, [b] -> Bool -> Bool)
1096 tuple a b d1 d1 = let ...bind f_mono, g_mono in (f_mono, g_mono)
1097
1098 f a d1 d2 = case tuple a Any d1 d2 of (f, g) -> f
1099 g b = case tuple Integer b dEqInteger dNumInteger of (f,g) -> g
1100
1101 Suppose the shared quantified tyvars are qtvs and constraints theta.
1102 Then we want to check that
1103 forall qtvs. theta => f_mono_ty is more polymorphic than f's polytype
1104 and the proof is the impedance matcher.
1105
1106 Notice that the impedance matcher may do defaulting. See Trac #7173.
1107
1108 It also cleverly does an ambiguity check; for example, rejecting
1109 f :: F a -> F a
1110 where F is a non-injective type function.
1111 -}
1112
1113 {- *********************************************************************
1114 * *
1115 Vectorisation
1116 * *
1117 ********************************************************************* -}
1118
1119 tcVectDecls :: [LVectDecl Name] -> TcM ([LVectDecl TcId])
1120 tcVectDecls decls
1121 = do { decls' <- mapM (wrapLocM tcVect) decls
1122 ; let ids = [lvectDeclName decl | decl <- decls', not $ lvectInstDecl decl]
1123 dups = findDupsEq (==) ids
1124 ; mapM_ reportVectDups dups
1125 ; traceTcConstraints "End of tcVectDecls"
1126 ; return decls'
1127 }
1128 where
1129 reportVectDups (first:_second:_more)
1130 = addErrAt (getSrcSpan first) $
1131 text "Duplicate vectorisation declarations for" <+> ppr first
1132 reportVectDups _ = return ()
1133
1134 --------------
1135 tcVect :: VectDecl Name -> TcM (VectDecl TcId)
1136 -- FIXME: We can't typecheck the expression of a vectorisation declaration against the vectorised
1137 -- type of the original definition as this requires internals of the vectoriser not available
1138 -- during type checking. Instead, constrain the rhs of a vectorisation declaration to be a single
1139 -- identifier (this is checked in 'rnHsVectDecl'). Fix this by enabling the use of 'vectType'
1140 -- from the vectoriser here.
1141 tcVect (HsVect s name rhs)
1142 = addErrCtxt (vectCtxt name) $
1143 do { var <- wrapLocM tcLookupId name
1144 ; let L rhs_loc (HsVar (L lv rhs_var_name)) = rhs
1145 ; rhs_id <- tcLookupId rhs_var_name
1146 ; return $ HsVect s var (L rhs_loc (HsVar (L lv rhs_id)))
1147 }
1148
1149 tcVect (HsNoVect s name)
1150 = addErrCtxt (vectCtxt name) $
1151 do { var <- wrapLocM tcLookupId name
1152 ; return $ HsNoVect s var
1153 }
1154 tcVect (HsVectTypeIn _ isScalar lname rhs_name)
1155 = addErrCtxt (vectCtxt lname) $
1156 do { tycon <- tcLookupLocatedTyCon lname
1157 ; checkTc ( not isScalar -- either we have a non-SCALAR declaration
1158 || isJust rhs_name -- or we explicitly provide a vectorised type
1159 || tyConArity tycon == 0 -- otherwise the type constructor must be nullary
1160 )
1161 scalarTyConMustBeNullary
1162
1163 ; rhs_tycon <- fmapMaybeM (tcLookupTyCon . unLoc) rhs_name
1164 ; return $ HsVectTypeOut isScalar tycon rhs_tycon
1165 }
1166 tcVect (HsVectTypeOut _ _ _)
1167 = panic "TcBinds.tcVect: Unexpected 'HsVectTypeOut'"
1168 tcVect (HsVectClassIn _ lname)
1169 = addErrCtxt (vectCtxt lname) $
1170 do { cls <- tcLookupLocatedClass lname
1171 ; return $ HsVectClassOut cls
1172 }
1173 tcVect (HsVectClassOut _)
1174 = panic "TcBinds.tcVect: Unexpected 'HsVectClassOut'"
1175 tcVect (HsVectInstIn linstTy)
1176 = addErrCtxt (vectCtxt linstTy) $
1177 do { (cls, tys) <- tcHsVectInst linstTy
1178 ; inst <- tcLookupInstance cls tys
1179 ; return $ HsVectInstOut inst
1180 }
1181 tcVect (HsVectInstOut _)
1182 = panic "TcBinds.tcVect: Unexpected 'HsVectInstOut'"
1183
1184 vectCtxt :: Outputable thing => thing -> SDoc
1185 vectCtxt thing = text "When checking the vectorisation declaration for" <+> ppr thing
1186
1187 scalarTyConMustBeNullary :: MsgDoc
1188 scalarTyConMustBeNullary = text "VECTORISE SCALAR type constructor must be nullary"
1189
1190 {-
1191 Note [SPECIALISE pragmas]
1192 ~~~~~~~~~~~~~~~~~~~~~~~~~
1193 There is no point in a SPECIALISE pragma for a non-overloaded function:
1194 reverse :: [a] -> [a]
1195 {-# SPECIALISE reverse :: [Int] -> [Int] #-}
1196
1197 But SPECIALISE INLINE *can* make sense for GADTS:
1198 data Arr e where
1199 ArrInt :: !Int -> ByteArray# -> Arr Int
1200 ArrPair :: !Int -> Arr e1 -> Arr e2 -> Arr (e1, e2)
1201
1202 (!:) :: Arr e -> Int -> e
1203 {-# SPECIALISE INLINE (!:) :: Arr Int -> Int -> Int #-}
1204 {-# SPECIALISE INLINE (!:) :: Arr (a, b) -> Int -> (a, b) #-}
1205 (ArrInt _ ba) !: (I# i) = I# (indexIntArray# ba i)
1206 (ArrPair _ a1 a2) !: i = (a1 !: i, a2 !: i)
1207
1208 When (!:) is specialised it becomes non-recursive, and can usefully
1209 be inlined. Scary! So we only warn for SPECIALISE *without* INLINE
1210 for a non-overloaded function.
1211
1212 ************************************************************************
1213 * *
1214 tcMonoBinds
1215 * *
1216 ************************************************************************
1217
1218 @tcMonoBinds@ deals with a perhaps-recursive group of HsBinds.
1219 The signatures have been dealt with already.
1220 -}
1221
1222 data MonoBindInfo = MBI { mbi_poly_name :: Name
1223 , mbi_sig :: Maybe TcIdSigInst
1224 , mbi_mono_id :: TcId }
1225
1226 tcMonoBinds :: RecFlag -- Whether the binding is recursive for typechecking purposes
1227 -- i.e. the binders are mentioned in their RHSs, and
1228 -- we are not rescued by a type signature
1229 -> TcSigFun -> LetBndrSpec
1230 -> [LHsBind Name]
1231 -> TcM (LHsBinds TcId, [MonoBindInfo])
1232 tcMonoBinds is_rec sig_fn no_gen
1233 [ L b_loc (FunBind { fun_id = L nm_loc name,
1234 fun_matches = matches, bind_fvs = fvs })]
1235 -- Single function binding,
1236 | NonRecursive <- is_rec -- ...binder isn't mentioned in RHS
1237 , Nothing <- sig_fn name -- ...with no type signature
1238 = -- Note [Single function non-recursive binding special-case]
1239 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1240 -- In this very special case we infer the type of the
1241 -- right hand side first (it may have a higher-rank type)
1242 -- and *then* make the monomorphic Id for the LHS
1243 -- e.g. f = \(x::forall a. a->a) -> <body>
1244 -- We want to infer a higher-rank type for f
1245 setSrcSpan b_loc $
1246 do { ((co_fn, matches'), rhs_ty)
1247 <- tcInferInst $ \ exp_ty ->
1248 -- tcInferInst: see TcUnify,
1249 -- Note [Deep instantiation of InferResult]
1250 tcExtendIdBndrs [TcIdBndr_ExpType name exp_ty NotTopLevel] $
1251 -- We extend the error context even for a non-recursive
1252 -- function so that in type error messages we show the
1253 -- type of the thing whose rhs we are type checking
1254 tcMatchesFun (L nm_loc name) matches exp_ty
1255
1256 ; mono_id <- newLetBndr no_gen name rhs_ty
1257 ; return (unitBag $ L b_loc $
1258 FunBind { fun_id = L nm_loc mono_id,
1259 fun_matches = matches', bind_fvs = fvs,
1260 fun_co_fn = co_fn, fun_tick = [] },
1261 [MBI { mbi_poly_name = name
1262 , mbi_sig = Nothing
1263 , mbi_mono_id = mono_id }]) }
1264
1265 tcMonoBinds _ sig_fn no_gen binds
1266 = do { tc_binds <- mapM (wrapLocM (tcLhs sig_fn no_gen)) binds
1267
1268 -- Bring the monomorphic Ids, into scope for the RHSs
1269 ; let mono_infos = getMonoBindInfo tc_binds
1270 rhs_id_env = [ (name, mono_id)
1271 | MBI { mbi_poly_name = name
1272 , mbi_sig = mb_sig
1273 , mbi_mono_id = mono_id } <- mono_infos
1274 , case mb_sig of
1275 Just sig -> isPartialSig sig
1276 Nothing -> True ]
1277 -- A monomorphic binding for each term variable that lacks
1278 -- a complete type sig. (Ones with a sig are already in scope.)
1279
1280 ; traceTc "tcMonoBinds" $ vcat [ ppr n <+> ppr id <+> ppr (idType id)
1281 | (n,id) <- rhs_id_env]
1282 ; binds' <- tcExtendLetEnvIds NotTopLevel rhs_id_env $
1283 mapM (wrapLocM tcRhs) tc_binds
1284
1285 ; return (listToBag binds', mono_infos) }
1286
1287
1288 ------------------------
1289 -- tcLhs typechecks the LHS of the bindings, to construct the environment in which
1290 -- we typecheck the RHSs. Basically what we are doing is this: for each binder:
1291 -- if there's a signature for it, use the instantiated signature type
1292 -- otherwise invent a type variable
1293 -- You see that quite directly in the FunBind case.
1294 --
1295 -- But there's a complication for pattern bindings:
1296 -- data T = MkT (forall a. a->a)
1297 -- MkT f = e
1298 -- Here we can guess a type variable for the entire LHS (which will be refined to T)
1299 -- but we want to get (f::forall a. a->a) as the RHS environment.
1300 -- The simplest way to do this is to typecheck the pattern, and then look up the
1301 -- bound mono-ids. Then we want to retain the typechecked pattern to avoid re-doing
1302 -- it; hence the TcMonoBind data type in which the LHS is done but the RHS isn't
1303
1304 data TcMonoBind -- Half completed; LHS done, RHS not done
1305 = TcFunBind MonoBindInfo SrcSpan (MatchGroup Name (LHsExpr Name))
1306 | TcPatBind [MonoBindInfo] (LPat TcId) (GRHSs Name (LHsExpr Name)) TcSigmaType
1307
1308 tcLhs :: TcSigFun -> LetBndrSpec -> HsBind Name -> TcM TcMonoBind
1309 -- Only called with plan InferGen (LetBndrSpec = LetLclBndr)
1310 -- or NoGen (LetBndrSpec = LetGblBndr)
1311 -- CheckGen is used only for functions with a complete type signature,
1312 -- and tcPolyCheck doesn't use tcMonoBinds at all
1313
1314 tcLhs sig_fn no_gen (FunBind { fun_id = L nm_loc name, fun_matches = matches })
1315 | Just (TcIdSig sig) <- sig_fn name
1316 = -- There is a type signature.
1317 -- It must be partial; if complete we'd be in tcPolyCheck!
1318 -- e.g. f :: _ -> _
1319 -- f x = ...g...
1320 -- Just g = ...f...
1321 -- Hence always typechecked with InferGen
1322 do { mono_info <- tcLhsSigId no_gen (name, sig)
1323 ; return (TcFunBind mono_info nm_loc matches) }
1324
1325 | otherwise -- No type signature
1326 = do { mono_ty <- newOpenFlexiTyVarTy
1327 ; mono_id <- newLetBndr no_gen name mono_ty
1328 ; let mono_info = MBI { mbi_poly_name = name
1329 , mbi_sig = Nothing
1330 , mbi_mono_id = mono_id }
1331 ; return (TcFunBind mono_info nm_loc matches) }
1332
1333 tcLhs sig_fn no_gen (PatBind { pat_lhs = pat, pat_rhs = grhss })
1334 = -- See Note [Typechecking pattern bindings]
1335 do { sig_mbis <- mapM (tcLhsSigId no_gen) sig_names
1336
1337 ; let inst_sig_fun = lookupNameEnv $ mkNameEnv $
1338 [ (mbi_poly_name mbi, mbi_mono_id mbi)
1339 | mbi <- sig_mbis ]
1340
1341 -- See Note [Existentials in pattern bindings]
1342 ; ((pat', nosig_mbis), pat_ty)
1343 <- addErrCtxt (patMonoBindsCtxt pat grhss) $
1344 tcInferNoInst $ \ exp_ty ->
1345 tcLetPat inst_sig_fun no_gen pat exp_ty $
1346 mapM lookup_info nosig_names
1347
1348 ; let mbis = sig_mbis ++ nosig_mbis
1349
1350 ; traceTc "tcLhs" (vcat [ ppr id <+> dcolon <+> ppr (idType id)
1351 | mbi <- mbis, let id = mbi_mono_id mbi ]
1352 $$ ppr no_gen)
1353
1354 ; return (TcPatBind mbis pat' grhss pat_ty) }
1355 where
1356 bndr_names = collectPatBinders pat
1357 (nosig_names, sig_names) = partitionWith find_sig bndr_names
1358
1359 find_sig :: Name -> Either Name (Name, TcIdSigInfo)
1360 find_sig name = case sig_fn name of
1361 Just (TcIdSig sig) -> Right (name, sig)
1362 _ -> Left name
1363
1364 -- After typechecking the pattern, look up the binder
1365 -- names that lack a signature, which the pattern has brought
1366 -- into scope.
1367 lookup_info :: Name -> TcM MonoBindInfo
1368 lookup_info name
1369 = do { mono_id <- tcLookupId name
1370 ; return (MBI { mbi_poly_name = name
1371 , mbi_sig = Nothing
1372 , mbi_mono_id = mono_id }) }
1373
1374 tcLhs _ _ other_bind = pprPanic "tcLhs" (ppr other_bind)
1375 -- AbsBind, VarBind impossible
1376
1377 -------------------
1378 tcLhsSigId :: LetBndrSpec -> (Name, TcIdSigInfo) -> TcM MonoBindInfo
1379 tcLhsSigId no_gen (name, sig)
1380 = do { inst_sig <- tcInstSig sig
1381 ; mono_id <- newSigLetBndr no_gen name inst_sig
1382 ; return (MBI { mbi_poly_name = name
1383 , mbi_sig = Just inst_sig
1384 , mbi_mono_id = mono_id }) }
1385
1386 ------------
1387 newSigLetBndr :: LetBndrSpec -> Name -> TcIdSigInst -> TcM TcId
1388 newSigLetBndr (LetGblBndr prags) name (TISI { sig_inst_sig = id_sig })
1389 | CompleteSig { sig_bndr = poly_id } <- id_sig
1390 = addInlinePrags poly_id (lookupPragEnv prags name)
1391 newSigLetBndr no_gen name (TISI { sig_inst_tau = tau })
1392 = newLetBndr no_gen name tau
1393
1394 -------------------
1395 tcRhs :: TcMonoBind -> TcM (HsBind TcId)
1396 tcRhs (TcFunBind info@(MBI { mbi_sig = mb_sig, mbi_mono_id = mono_id })
1397 loc matches)
1398 = tcExtendIdBinderStackForRhs [info] $
1399 tcExtendTyVarEnvForRhs mb_sig $
1400 do { traceTc "tcRhs: fun bind" (ppr mono_id $$ ppr (idType mono_id))
1401 ; (co_fn, matches') <- tcMatchesFun (L loc (idName mono_id))
1402 matches (mkCheckExpType $ idType mono_id)
1403 ; return ( FunBind { fun_id = L loc mono_id
1404 , fun_matches = matches'
1405 , fun_co_fn = co_fn
1406 , bind_fvs = placeHolderNamesTc
1407 , fun_tick = [] } ) }
1408
1409 tcRhs (TcPatBind infos pat' grhss pat_ty)
1410 = -- When we are doing pattern bindings we *don't* bring any scoped
1411 -- type variables into scope unlike function bindings
1412 -- Wny not? They are not completely rigid.
1413 -- That's why we have the special case for a single FunBind in tcMonoBinds
1414 tcExtendIdBinderStackForRhs infos $
1415 do { traceTc "tcRhs: pat bind" (ppr pat' $$ ppr pat_ty)
1416 ; grhss' <- addErrCtxt (patMonoBindsCtxt pat' grhss) $
1417 tcGRHSsPat grhss pat_ty
1418 ; return ( PatBind { pat_lhs = pat', pat_rhs = grhss'
1419 , pat_rhs_ty = pat_ty
1420 , bind_fvs = placeHolderNamesTc
1421 , pat_ticks = ([],[]) } )}
1422
1423 tcExtendTyVarEnvForRhs :: Maybe TcIdSigInst -> TcM a -> TcM a
1424 tcExtendTyVarEnvForRhs Nothing thing_inside
1425 = thing_inside
1426 tcExtendTyVarEnvForRhs (Just sig) thing_inside
1427 = tcExtendTyVarEnvFromSig sig thing_inside
1428
1429 tcExtendTyVarEnvFromSig :: TcIdSigInst -> TcM a -> TcM a
1430 tcExtendTyVarEnvFromSig sig_inst thing_inside
1431 | TISI { sig_inst_skols = skol_prs, sig_inst_wcs = wcs } <- sig_inst
1432 = tcExtendTyVarEnv2 wcs $
1433 tcExtendTyVarEnv2 skol_prs $
1434 thing_inside
1435
1436 tcExtendIdBinderStackForRhs :: [MonoBindInfo] -> TcM a -> TcM a
1437 -- Extend the TcIdBinderStack for the RHS of the binding, with
1438 -- the monomorphic Id. That way, if we have, say
1439 -- f = \x -> blah
1440 -- and something goes wrong in 'blah', we get a "relevant binding"
1441 -- looking like f :: alpha -> beta
1442 -- This applies if 'f' has a type signature too:
1443 -- f :: forall a. [a] -> [a]
1444 -- f x = True
1445 -- We can't unify True with [a], and a relevant binding is f :: [a] -> [a]
1446 -- If we had the *polymorphic* version of f in the TcIdBinderStack, it
1447 -- would not be reported as relevant, because its type is closed
1448 tcExtendIdBinderStackForRhs infos thing_inside
1449 = tcExtendIdBndrs [ TcIdBndr mono_id NotTopLevel
1450 | MBI { mbi_mono_id = mono_id } <- infos ]
1451 thing_inside
1452 -- NotTopLevel: it's a monomorphic binding
1453
1454 ---------------------
1455 getMonoBindInfo :: [Located TcMonoBind] -> [MonoBindInfo]
1456 getMonoBindInfo tc_binds
1457 = foldr (get_info . unLoc) [] tc_binds
1458 where
1459 get_info (TcFunBind info _ _) rest = info : rest
1460 get_info (TcPatBind infos _ _ _) rest = infos ++ rest
1461
1462
1463 {- Note [Typechecking pattern bindings]
1464 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1465 Look at:
1466 - typecheck/should_compile/ExPat
1467 - Trac #12427, typecheck/should_compile/T12427{a,b}
1468
1469 data T where
1470 MkT :: Integral a => a -> Int -> T
1471
1472 and suppose t :: T. Which of these pattern bindings are ok?
1473
1474 E1. let { MkT p _ = t } in <body>
1475
1476 E2. let { MkT _ q = t } in <body>
1477
1478 E3. let { MkT (toInteger -> r) _ = t } in <body>
1479
1480 * (E1) is clearly wrong because the existential 'a' escapes.
1481 What type could 'p' possibly have?
1482
1483 * (E2) is fine, despite the existential pattern, because
1484 q::Int, and nothing escapes.
1485
1486 * Even (E3) is fine. The existential pattern binds a dictionary
1487 for (Integral a) which the view pattern can use to convert the
1488 a-valued field to an Integer, so r :: Integer.
1489
1490 An easy way to see all three is to imagine the desugaring.
1491 For (E2) it would look like
1492 let q = case t of MkT _ q' -> q'
1493 in <body>
1494
1495
1496 We typecheck pattern bindings as follows. First tcLhs does this:
1497
1498 1. Take each type signature q :: ty, partial or complete, and
1499 instantiate it (with tcLhsSigId) to get a MonoBindInfo. This
1500 gives us a fresh "mono_id" qm :: instantiate(ty), where qm has
1501 a fresh name.
1502
1503 Any fresh unification variables in instantiate(ty) born here, not
1504 deep under implications as would happen if we allocated them when
1505 we encountered q during tcPat.
1506
1507 2. Build a little environment mapping "q" -> "qm" for those Ids
1508 with signatures (inst_sig_fun)
1509
1510 3. Invoke tcLetPat to typecheck the pattern.
1511
1512 - We pass in the current TcLevel. This is captured by
1513 TcPat.tcLetPat, and put into the pc_lvl field of PatCtxt, in
1514 PatEnv.
1515
1516 - When tcPat finds an existential constructor, it binds fresh
1517 type variables and dictionaries as usual, increments the TcLevel,
1518 and emits an implication constraint.
1519
1520 - When we come to a binder (TcPat.tcPatBndr), it looks it up
1521 in the little environment (the pc_sig_fn field of PatCtxt).
1522
1523 Success => There was a type signature, so just use it,
1524 checking compatibility with the expected type.
1525
1526 Failure => No type sigature.
1527 Infer case: (happens only outside any constructor pattern)
1528 use a unification variable
1529 at the outer level pc_lvl
1530
1531 Check case: use promoteTcType to promote the type
1532 to the outer level pc_lvl. This is the
1533 place where we emit a constraint that'll blow
1534 up if existential capture takes place
1535
1536 Result: the type of the binder is always at pc_lvl. This is
1537 crucial.
1538
1539 4. Throughout, when we are making up an Id for the pattern-bound variables
1540 (newLetBndr), we have two cases:
1541
1542 - If we are generalising (generalisation plan is InferGen or
1543 CheckGen), then the let_bndr_spec will be LetLclBndr. In that case
1544 we want to bind a cloned, local version of the variable, with the
1545 type given by the pattern context, *not* by the signature (even if
1546 there is one; see Trac #7268). The mkExport part of the
1547 generalisation step will do the checking and impedance matching
1548 against the signature.
1549
1550 - If for some some reason we are not generalising (plan = NoGen), the
1551 LetBndrSpec will be LetGblBndr. In that case we must bind the
1552 global version of the Id, and do so with precisely the type given
1553 in the signature. (Then we unify with the type from the pattern
1554 context type.)
1555
1556
1557 And that's it! The implication constraints check for the skolem
1558 escape. It's quite simple and neat, and more expressive than before
1559 e.g. GHC 8.0 rejects (E2) and (E3).
1560
1561 Example for (E1), starting at level 1. We generate
1562 p :: beta:1, with constraints (forall:3 a. Integral a => a ~ beta)
1563 The (a~beta) can't float (because of the 'a'), nor be solved (because
1564 beta is untouchable.)
1565
1566 Example for (E2), we generate
1567 q :: beta:1, with constraint (forall:3 a. Integral a => Int ~ beta)
1568 The beta is untoucable, but floats out of the constraint and can
1569 be solved absolutely fine.
1570
1571 ************************************************************************
1572 * *
1573 Generalisation
1574 * *
1575 ********************************************************************* -}
1576
1577 data GeneralisationPlan
1578 = NoGen -- No generalisation, no AbsBinds
1579
1580 | InferGen -- Implicit generalisation; there is an AbsBinds
1581 Bool -- True <=> apply the MR; generalise only unconstrained type vars
1582
1583 | CheckGen (LHsBind Name) TcIdSigInfo
1584 -- One FunBind with a signature
1585 -- Explicit generalisation; there is an AbsBindsSig
1586
1587 -- A consequence of the no-AbsBinds choice (NoGen) is that there is
1588 -- no "polymorphic Id" and "monmomorphic Id"; there is just the one
1589
1590 instance Outputable GeneralisationPlan where
1591 ppr NoGen = text "NoGen"
1592 ppr (InferGen b) = text "InferGen" <+> ppr b
1593 ppr (CheckGen _ s) = text "CheckGen" <+> ppr s
1594
1595 decideGeneralisationPlan
1596 :: DynFlags -> [LHsBind Name] -> IsGroupClosed -> TcSigFun
1597 -> GeneralisationPlan
1598 decideGeneralisationPlan dflags lbinds closed sig_fn
1599 | has_partial_sigs = InferGen (and partial_sig_mrs)
1600 | Just (bind, sig) <- one_funbind_with_sig = CheckGen bind sig
1601 | mono_local_binds closed = NoGen
1602 | otherwise = InferGen mono_restriction
1603 where
1604 binds = map unLoc lbinds
1605
1606 partial_sig_mrs :: [Bool]
1607 -- One for each parital signature (so empty => no partial sigs)
1608 -- The Bool is True if the signature has no constraint context
1609 -- so we should apply the MR
1610 -- See Note [Partial type signatures and generalisation]
1611 partial_sig_mrs
1612 = [ null theta
1613 | TcIdSig (PartialSig { psig_hs_ty = hs_ty })
1614 <- mapMaybe sig_fn (collectHsBindListBinders lbinds)
1615 , let (_, L _ theta, _) = splitLHsSigmaTy (hsSigWcType hs_ty) ]
1616
1617 has_partial_sigs = not (null partial_sig_mrs)
1618
1619 mono_restriction = xopt LangExt.MonomorphismRestriction dflags
1620 && any restricted binds
1621
1622 mono_local_binds ClosedGroup = False
1623 mono_local_binds _ = xopt LangExt.MonoLocalBinds dflags
1624
1625 -- With OutsideIn, all nested bindings are monomorphic
1626 -- except a single function binding with a signature
1627 one_funbind_with_sig
1628 | [lbind@(L _ (FunBind { fun_id = v }))] <- lbinds
1629 , Just (TcIdSig sig) <- sig_fn (unLoc v)
1630 = Just (lbind, sig)
1631 | otherwise
1632 = Nothing
1633
1634 -- The Haskell 98 monomorphism restriction
1635 restricted (PatBind {}) = True
1636 restricted (VarBind { var_id = v }) = no_sig v
1637 restricted (FunBind { fun_id = v, fun_matches = m }) = restricted_match m
1638 && no_sig (unLoc v)
1639 restricted (PatSynBind {}) = panic "isRestrictedGroup/unrestricted PatSynBind"
1640 restricted (AbsBinds {}) = panic "isRestrictedGroup/unrestricted AbsBinds"
1641 restricted (AbsBindsSig {}) = panic "isRestrictedGroup/unrestricted AbsBindsSig"
1642
1643 restricted_match (MG { mg_alts = L _ (L _ (Match _ [] _ _) : _ )}) = True
1644 restricted_match _ = False
1645 -- No args => like a pattern binding
1646 -- Some args => a function binding
1647
1648 no_sig n = noCompleteSig (sig_fn n)
1649
1650 isClosedBndrGroup :: Bag (LHsBind Name) -> TcM IsGroupClosed
1651 isClosedBndrGroup binds = do
1652 type_env <- getLclTypeEnv
1653 if foldUFM (is_closed_ns type_env) True fv_env
1654 then return ClosedGroup
1655 else return $ NonClosedGroup fv_env
1656 where
1657 fv_env :: NameEnv NameSet
1658 fv_env = mkNameEnv $ concatMap (bindFvs . unLoc) binds
1659
1660 bindFvs :: HsBindLR Name idR -> [(Name, NameSet)]
1661 bindFvs (FunBind { fun_id = f, bind_fvs = fvs })
1662 = [(unLoc f, fvs)]
1663 bindFvs (PatBind { pat_lhs = pat, bind_fvs = fvs })
1664 = [(b, fvs) | b <- collectPatBinders pat]
1665 bindFvs _
1666 = []
1667
1668 is_closed_ns :: TcTypeEnv -> NameSet -> Bool -> Bool
1669 is_closed_ns type_env ns b = b && nameSetAll (is_closed_id type_env) ns
1670 -- ns are the Names referred to from the RHS of this bind
1671
1672 is_closed_id :: TcTypeEnv -> Name -> Bool
1673 -- See Note [Bindings with closed types] in TcRnTypes
1674 is_closed_id type_env name
1675 | Just thing <- lookupNameEnv type_env name
1676 = case thing of
1677 ATcId { tct_info = ClosedLet } -> True -- This is the key line
1678 ATcId {} -> False
1679 ATyVar {} -> False -- In-scope type variables
1680 AGlobal {} -> True -- are not closed!
1681 _ -> pprPanic "is_closed_id" (ppr name)
1682 | otherwise
1683 = True
1684 -- The free-var set for a top level binding mentions
1685 -- imported things too, so that we can report unused imports
1686 -- These won't be in the local type env.
1687 -- Ditto class method etc from the current module
1688
1689 {- *********************************************************************
1690 * *
1691 Error contexts and messages
1692 * *
1693 ********************************************************************* -}
1694
1695 -- This one is called on LHS, when pat and grhss are both Name
1696 -- and on RHS, when pat is TcId and grhss is still Name
1697 patMonoBindsCtxt :: (OutputableBndrId id, Outputable body)
1698 => LPat id -> GRHSs Name body -> SDoc
1699 patMonoBindsCtxt pat grhss
1700 = hang (text "In a pattern binding:") 2 (pprPatBind pat grhss)