Also show types that subsume a hole as valid substitutions for that hole.
[ghc.git] / compiler / typecheck / TcSimplify.hs
1 {-# LANGUAGE CPP #-}
2
3 module TcSimplify(
4 simplifyInfer, InferMode(..),
5 growThetaTyVars,
6 simplifyAmbiguityCheck,
7 simplifyDefault,
8 simplifyTop, simplifyTopImplic, captureTopConstraints,
9 simplifyInteractive, solveEqualities,
10 simplifyWantedsTcM,
11 tcCheckSatisfiability,
12 tcSubsumes,
13
14 -- For Rules we need these
15 solveWanteds, solveWantedsAndDrop,
16 approximateWC, runTcSDeriveds
17 ) where
18
19 #include "HsVersions.h"
20
21 import GhcPrelude
22
23 import Bag
24 import Class ( Class, classKey, classTyCon )
25 import DynFlags ( WarningFlag ( Opt_WarnMonomorphism )
26 , WarnReason ( Reason )
27 , DynFlags( solverIterations ) )
28 import Id ( idType )
29 import Inst
30 import ListSetOps
31 import Maybes
32 import Name
33 import Outputable
34 import PrelInfo
35 import PrelNames
36 import TcErrors
37 import TcEvidence
38 import TcInteract
39 import TcCanonical ( makeSuperClasses )
40 import TcMType as TcM
41 import TcRnMonad as TcM
42 import TcSMonad as TcS
43 import TcType
44 import TrieMap () -- DV: for now
45 import Type
46 import TysWiredIn ( liftedRepTy )
47 import Unify ( tcMatchTyKi )
48 import TcUnify ( tcSubType_NC )
49 import Util
50 import Var
51 import VarSet
52 import UniqSet
53 import BasicTypes ( IntWithInf, intGtLimit )
54 import ErrUtils ( emptyMessages )
55 import qualified GHC.LanguageExtensions as LangExt
56
57 import Control.Monad
58 import Data.Foldable ( toList )
59 import Data.List ( partition )
60 import Data.List.NonEmpty ( NonEmpty(..) )
61
62 {-
63 *********************************************************************************
64 * *
65 * External interface *
66 * *
67 *********************************************************************************
68 -}
69
70 captureTopConstraints :: TcM a -> TcM (a, WantedConstraints)
71 -- (captureTopConstraints m) runs m, and returns the type constraints it
72 -- generates plus the constraints produced by static forms inside.
73 -- If it fails with an exception, it reports any insolubles
74 -- (out of scope variables) before doing so
75 captureTopConstraints thing_inside
76 = do { static_wc_var <- TcM.newTcRef emptyWC ;
77 ; (mb_res, lie) <- TcM.updGblEnv (\env -> env { tcg_static_wc = static_wc_var } ) $
78 TcM.tryCaptureConstraints thing_inside
79 ; stWC <- TcM.readTcRef static_wc_var
80
81 -- See TcRnMonad Note [Constraints and errors]
82 -- If the thing_inside threw an exception, but generated some insoluble
83 -- constraints, report the latter before propagating the exception
84 -- Otherwise they will be lost altogether
85 ; case mb_res of
86 Right res -> return (res, lie `andWC` stWC)
87 Left {} -> do { _ <- reportUnsolved lie; failM } }
88 -- This call to reportUnsolved is the reason
89 -- this function is here instead of TcRnMonad
90
91 simplifyTopImplic :: Bag Implication -> TcM ()
92 simplifyTopImplic implics
93 = do { empty_binds <- simplifyTop (mkImplicWC implics)
94
95 -- Since all the inputs are implications the returned bindings will be empty
96 ; MASSERT2( isEmptyBag empty_binds, ppr empty_binds )
97
98 ; return () }
99
100 simplifyTop :: WantedConstraints -> TcM (Bag EvBind)
101 -- Simplify top-level constraints
102 -- Usually these will be implications,
103 -- but when there is nothing to quantify we don't wrap
104 -- in a degenerate implication, so we do that here instead
105 simplifyTop wanteds
106 = do { traceTc "simplifyTop {" $ text "wanted = " <+> ppr wanteds
107 ; ((final_wc, unsafe_ol), binds1) <- runTcS $
108 do { final_wc <- simpl_top wanteds
109 ; unsafe_ol <- getSafeOverlapFailures
110 ; return (final_wc, unsafe_ol) }
111 ; traceTc "End simplifyTop }" empty
112
113 ; traceTc "reportUnsolved {" empty
114 ; binds2 <- reportUnsolved final_wc
115 ; traceTc "reportUnsolved }" empty
116
117 ; traceTc "reportUnsolved (unsafe overlapping) {" empty
118 ; unless (isEmptyCts unsafe_ol) $ do {
119 -- grab current error messages and clear, warnAllUnsolved will
120 -- update error messages which we'll grab and then restore saved
121 -- messages.
122 ; errs_var <- getErrsVar
123 ; saved_msg <- TcM.readTcRef errs_var
124 ; TcM.writeTcRef errs_var emptyMessages
125
126 ; warnAllUnsolved $ WC { wc_simple = unsafe_ol
127 , wc_insol = emptyCts
128 , wc_impl = emptyBag }
129
130 ; whyUnsafe <- fst <$> TcM.readTcRef errs_var
131 ; TcM.writeTcRef errs_var saved_msg
132 ; recordUnsafeInfer whyUnsafe
133 }
134 ; traceTc "reportUnsolved (unsafe overlapping) }" empty
135
136 ; return (evBindMapBinds binds1 `unionBags` binds2) }
137
138 -- | Type-check a thing that emits only equality constraints, then
139 -- solve those constraints. Fails outright if there is trouble.
140 solveEqualities :: TcM a -> TcM a
141 solveEqualities thing_inside
142 = checkNoErrs $ -- See Note [Fail fast on kind errors]
143 do { (result, wanted) <- captureConstraints thing_inside
144 ; traceTc "solveEqualities {" $ text "wanted = " <+> ppr wanted
145 ; final_wc <- runTcSEqualities $ simpl_top wanted
146 ; traceTc "End solveEqualities }" empty
147
148 ; traceTc "reportAllUnsolved {" empty
149 ; reportAllUnsolved final_wc
150 ; traceTc "reportAllUnsolved }" empty
151 ; return result }
152
153 simpl_top :: WantedConstraints -> TcS WantedConstraints
154 -- See Note [Top-level Defaulting Plan]
155 simpl_top wanteds
156 = do { wc_first_go <- nestTcS (solveWantedsAndDrop wanteds)
157 -- This is where the main work happens
158 ; try_tyvar_defaulting wc_first_go }
159 where
160 try_tyvar_defaulting :: WantedConstraints -> TcS WantedConstraints
161 try_tyvar_defaulting wc
162 | isEmptyWC wc
163 = return wc
164 | otherwise
165 = do { free_tvs <- TcS.zonkTyCoVarsAndFVList (tyCoVarsOfWCList wc)
166 ; let meta_tvs = filter (isTyVar <&&> isMetaTyVar) free_tvs
167 -- zonkTyCoVarsAndFV: the wc_first_go is not yet zonked
168 -- filter isMetaTyVar: we might have runtime-skolems in GHCi,
169 -- and we definitely don't want to try to assign to those!
170 -- The isTyVar is needed to weed out coercion variables
171
172 ; defaulted <- mapM defaultTyVarTcS meta_tvs -- Has unification side effects
173 ; if or defaulted
174 then do { wc_residual <- nestTcS (solveWanteds wc)
175 -- See Note [Must simplify after defaulting]
176 ; try_class_defaulting wc_residual }
177 else try_class_defaulting wc } -- No defaulting took place
178
179 try_class_defaulting :: WantedConstraints -> TcS WantedConstraints
180 try_class_defaulting wc
181 | isEmptyWC wc
182 = return wc
183 | otherwise -- See Note [When to do type-class defaulting]
184 = do { something_happened <- applyDefaultingRules wc
185 -- See Note [Top-level Defaulting Plan]
186 ; if something_happened
187 then do { wc_residual <- nestTcS (solveWantedsAndDrop wc)
188 ; try_class_defaulting wc_residual }
189 -- See Note [Overview of implicit CallStacks] in TcEvidence
190 else try_callstack_defaulting wc }
191
192 try_callstack_defaulting :: WantedConstraints -> TcS WantedConstraints
193 try_callstack_defaulting wc
194 | isEmptyWC wc
195 = return wc
196 | otherwise
197 = defaultCallStacks wc
198
199 -- | Default any remaining @CallStack@ constraints to empty @CallStack@s.
200 defaultCallStacks :: WantedConstraints -> TcS WantedConstraints
201 -- See Note [Overview of implicit CallStacks] in TcEvidence
202 defaultCallStacks wanteds
203 = do simples <- handle_simples (wc_simple wanteds)
204 mb_implics <- mapBagM handle_implic (wc_impl wanteds)
205 return (wanteds { wc_simple = simples
206 , wc_impl = catBagMaybes mb_implics })
207
208 where
209
210 handle_simples simples
211 = catBagMaybes <$> mapBagM defaultCallStack simples
212
213 handle_implic :: Implication -> TcS (Maybe Implication)
214 -- The Maybe is because solving the CallStack constraint
215 -- may well allow us to discard the implication entirely
216 handle_implic implic
217 | isSolvedStatus (ic_status implic)
218 = return (Just implic)
219 | otherwise
220 = do { wanteds <- setEvBindsTcS (ic_binds implic) $
221 -- defaultCallStack sets a binding, so
222 -- we must set the correct binding group
223 defaultCallStacks (ic_wanted implic)
224 ; setImplicationStatus (implic { ic_wanted = wanteds }) }
225
226 defaultCallStack ct
227 | Just _ <- isCallStackPred (ctPred ct)
228 = do { solveCallStack (cc_ev ct) EvCsEmpty
229 ; return Nothing }
230
231 defaultCallStack ct
232 = return (Just ct)
233
234
235 {- Note [Fail fast on kind errors]
236 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
237 solveEqualities is used to solve kind equalities when kind-checking
238 user-written types. If solving fails we should fail outright, rather
239 than just accumulate an error message, for two reasons:
240
241 * A kind-bogus type signature may cause a cascade of knock-on
242 errors if we let it pass
243
244 * More seriously, we don't have a convenient term-level place to add
245 deferred bindings for unsolved kind-equality constraints, so we
246 don't build evidence bindings (by usine reportAllUnsolved). That
247 means that we'll be left with with a type that has coercion holes
248 in it, something like
249 <type> |> co-hole
250 where co-hole is not filled in. Eeek! That un-filled-in
251 hole actually causes GHC to crash with "fvProv falls into a hole"
252 See Trac #11563, #11520, #11516, #11399
253
254 So it's important to use 'checkNoErrs' here!
255
256 Note [When to do type-class defaulting]
257 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
258 In GHC 7.6 and 7.8.2, we did type-class defaulting only if insolubleWC
259 was false, on the grounds that defaulting can't help solve insoluble
260 constraints. But if we *don't* do defaulting we may report a whole
261 lot of errors that would be solved by defaulting; these errors are
262 quite spurious because fixing the single insoluble error means that
263 defaulting happens again, which makes all the other errors go away.
264 This is jolly confusing: Trac #9033.
265
266 So it seems better to always do type-class defaulting.
267
268 However, always doing defaulting does mean that we'll do it in
269 situations like this (Trac #5934):
270 run :: (forall s. GenST s) -> Int
271 run = fromInteger 0
272 We don't unify the return type of fromInteger with the given function
273 type, because the latter involves foralls. So we're left with
274 (Num alpha, alpha ~ (forall s. GenST s) -> Int)
275 Now we do defaulting, get alpha := Integer, and report that we can't
276 match Integer with (forall s. GenST s) -> Int. That's not totally
277 stupid, but perhaps a little strange.
278
279 Another potential alternative would be to suppress *all* non-insoluble
280 errors if there are *any* insoluble errors, anywhere, but that seems
281 too drastic.
282
283 Note [Must simplify after defaulting]
284 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
285 We may have a deeply buried constraint
286 (t:*) ~ (a:Open)
287 which we couldn't solve because of the kind incompatibility, and 'a' is free.
288 Then when we default 'a' we can solve the constraint. And we want to do
289 that before starting in on type classes. We MUST do it before reporting
290 errors, because it isn't an error! Trac #7967 was due to this.
291
292 Note [Top-level Defaulting Plan]
293 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
294 We have considered two design choices for where/when to apply defaulting.
295 (i) Do it in SimplCheck mode only /whenever/ you try to solve some
296 simple constraints, maybe deep inside the context of implications.
297 This used to be the case in GHC 7.4.1.
298 (ii) Do it in a tight loop at simplifyTop, once all other constraints have
299 finished. This is the current story.
300
301 Option (i) had many disadvantages:
302 a) Firstly, it was deep inside the actual solver.
303 b) Secondly, it was dependent on the context (Infer a type signature,
304 or Check a type signature, or Interactive) since we did not want
305 to always start defaulting when inferring (though there is an exception to
306 this, see Note [Default while Inferring]).
307 c) It plainly did not work. Consider typecheck/should_compile/DfltProb2.hs:
308 f :: Int -> Bool
309 f x = const True (\y -> let w :: a -> a
310 w a = const a (y+1)
311 in w y)
312 We will get an implication constraint (for beta the type of y):
313 [untch=beta] forall a. 0 => Num beta
314 which we really cannot default /while solving/ the implication, since beta is
315 untouchable.
316
317 Instead our new defaulting story is to pull defaulting out of the solver loop and
318 go with option (ii), implemented at SimplifyTop. Namely:
319 - First, have a go at solving the residual constraint of the whole
320 program
321 - Try to approximate it with a simple constraint
322 - Figure out derived defaulting equations for that simple constraint
323 - Go round the loop again if you did manage to get some equations
324
325 Now, that has to do with class defaulting. However there exists type variable /kind/
326 defaulting. Again this is done at the top-level and the plan is:
327 - At the top-level, once you had a go at solving the constraint, do
328 figure out /all/ the touchable unification variables of the wanted constraints.
329 - Apply defaulting to their kinds
330
331 More details in Note [DefaultTyVar].
332
333 Note [Safe Haskell Overlapping Instances]
334 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
335 In Safe Haskell, we apply an extra restriction to overlapping instances. The
336 motive is to prevent untrusted code provided by a third-party, changing the
337 behavior of trusted code through type-classes. This is due to the global and
338 implicit nature of type-classes that can hide the source of the dictionary.
339
340 Another way to state this is: if a module M compiles without importing another
341 module N, changing M to import N shouldn't change the behavior of M.
342
343 Overlapping instances with type-classes can violate this principle. However,
344 overlapping instances aren't always unsafe. They are just unsafe when the most
345 selected dictionary comes from untrusted code (code compiled with -XSafe) and
346 overlaps instances provided by other modules.
347
348 In particular, in Safe Haskell at a call site with overlapping instances, we
349 apply the following rule to determine if it is a 'unsafe' overlap:
350
351 1) Most specific instance, I1, defined in an `-XSafe` compiled module.
352 2) I1 is an orphan instance or a MPTC.
353 3) At least one overlapped instance, Ix, is both:
354 A) from a different module than I1
355 B) Ix is not marked `OVERLAPPABLE`
356
357 This is a slightly involved heuristic, but captures the situation of an
358 imported module N changing the behavior of existing code. For example, if
359 condition (2) isn't violated, then the module author M must depend either on a
360 type-class or type defined in N.
361
362 Secondly, when should these heuristics be enforced? We enforced them when the
363 type-class method call site is in a module marked `-XSafe` or `-XTrustworthy`.
364 This allows `-XUnsafe` modules to operate without restriction, and for Safe
365 Haskell inferrence to infer modules with unsafe overlaps as unsafe.
366
367 One alternative design would be to also consider if an instance was imported as
368 a `safe` import or not and only apply the restriction to instances imported
369 safely. However, since instances are global and can be imported through more
370 than one path, this alternative doesn't work.
371
372 Note [Safe Haskell Overlapping Instances Implementation]
373 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
374
375 How is this implemented? It's complicated! So we'll step through it all:
376
377 1) `InstEnv.lookupInstEnv` -- Performs instance resolution, so this is where
378 we check if a particular type-class method call is safe or unsafe. We do this
379 through the return type, `ClsInstLookupResult`, where the last parameter is a
380 list of instances that are unsafe to overlap. When the method call is safe,
381 the list is null.
382
383 2) `TcInteract.matchClassInst` -- This module drives the instance resolution
384 / dictionary generation. The return type is `LookupInstResult`, which either
385 says no instance matched, or one found, and if it was a safe or unsafe
386 overlap.
387
388 3) `TcInteract.doTopReactDict` -- Takes a dictionary / class constraint and
389 tries to resolve it by calling (in part) `matchClassInst`. The resolving
390 mechanism has a work list (of constraints) that it process one at a time. If
391 the constraint can't be resolved, it's added to an inert set. When compiling
392 an `-XSafe` or `-XTrustworthy` module, we follow this approach as we know
393 compilation should fail. These are handled as normal constraint resolution
394 failures from here-on (see step 6).
395
396 Otherwise, we may be inferring safety (or using `-Wunsafe`), and
397 compilation should succeed, but print warnings and/or mark the compiled module
398 as `-XUnsafe`. In this case, we call `insertSafeOverlapFailureTcS` which adds
399 the unsafe (but resolved!) constraint to the `inert_safehask` field of
400 `InertCans`.
401
402 4) `TcSimplify.simplifyTop`:
403 * Call simpl_top, the top-level function for driving the simplifier for
404 constraint resolution.
405
406 * Once finished, call `getSafeOverlapFailures` to retrieve the
407 list of overlapping instances that were successfully resolved,
408 but unsafe. Remember, this is only applicable for generating warnings
409 (`-Wunsafe`) or inferring a module unsafe. `-XSafe` and `-XTrustworthy`
410 cause compilation failure by not resolving the unsafe constraint at all.
411
412 * For unresolved constraints (all types), call `TcErrors.reportUnsolved`,
413 while for resolved but unsafe overlapping dictionary constraints, call
414 `TcErrors.warnAllUnsolved`. Both functions convert constraints into a
415 warning message for the user.
416
417 * In the case of `warnAllUnsolved` for resolved, but unsafe
418 dictionary constraints, we collect the generated warning
419 message (pop it) and call `TcRnMonad.recordUnsafeInfer` to
420 mark the module we are compiling as unsafe, passing the
421 warning message along as the reason.
422
423 5) `TcErrors.*Unsolved` -- Generates error messages for constraints by
424 actually calling `InstEnv.lookupInstEnv` again! Yes, confusing, but all we
425 know is the constraint that is unresolved or unsafe. For dictionary, all we
426 know is that we need a dictionary of type C, but not what instances are
427 available and how they overlap. So we once again call `lookupInstEnv` to
428 figure that out so we can generate a helpful error message.
429
430 6) `TcRnMonad.recordUnsafeInfer` -- Save the unsafe result and reason in an
431 IORef called `tcg_safeInfer`.
432
433 7) `HscMain.tcRnModule'` -- Reads `tcg_safeInfer` after type-checking, calling
434 `HscMain.markUnsafeInfer` (passing the reason along) when safe-inferrence
435 failed.
436
437 Note [No defaulting in the ambiguity check]
438 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
439 When simplifying constraints for the ambiguity check, we use
440 solveWantedsAndDrop, not simpl_top, so that we do no defaulting.
441 Trac #11947 was an example:
442 f :: Num a => Int -> Int
443 This is ambiguous of course, but we don't want to default the
444 (Num alpha) constraint to (Num Int)! Doing so gives a defaulting
445 warning, but no error.
446 -}
447
448 ------------------
449 simplifyAmbiguityCheck :: Type -> WantedConstraints -> TcM ()
450 simplifyAmbiguityCheck ty wanteds
451 = do { traceTc "simplifyAmbiguityCheck {" (text "type = " <+> ppr ty $$ text "wanted = " <+> ppr wanteds)
452 ; (final_wc, _) <- runTcS $ solveWantedsAndDrop wanteds
453 -- NB: no defaulting! See Note [No defaulting in the ambiguity check]
454
455 ; traceTc "End simplifyAmbiguityCheck }" empty
456
457 -- Normally report all errors; but with -XAllowAmbiguousTypes
458 -- report only insoluble ones, since they represent genuinely
459 -- inaccessible code
460 ; allow_ambiguous <- xoptM LangExt.AllowAmbiguousTypes
461 ; traceTc "reportUnsolved(ambig) {" empty
462 ; unless (allow_ambiguous && not (insolubleWC final_wc))
463 (discardResult (reportUnsolved final_wc))
464 ; traceTc "reportUnsolved(ambig) }" empty
465
466 ; return () }
467
468 ------------------
469 simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
470 simplifyInteractive wanteds
471 = traceTc "simplifyInteractive" empty >>
472 simplifyTop wanteds
473
474 ------------------
475 simplifyDefault :: ThetaType -- Wanted; has no type variables in it
476 -> TcM () -- Succeeds if the constraint is soluble
477 simplifyDefault theta
478 = do { traceTc "simplifyDefault" empty
479 ; wanteds <- newWanteds DefaultOrigin theta
480 ; unsolved <- runTcSDeriveds (solveWantedsAndDrop (mkSimpleWC wanteds))
481 ; traceTc "reportUnsolved {" empty
482 ; reportAllUnsolved unsolved
483 ; traceTc "reportUnsolved }" empty
484 ; return () }
485
486 -- | Reports whether first type (ty_a) subsumes the second type (ty_b),
487 -- discarding any errors. Subsumption here means that the ty_b can fit into the
488 -- ty_a, i.e. `tcSubsumes a b == True` if b is a subtype of a.
489 -- N.B.: Make sure that the types contain all the constraints
490 -- contained in any associated implications.
491 tcSubsumes :: TcSigmaType -> TcSigmaType -> TcM Bool
492 tcSubsumes ty_a ty_b | ty_a `eqType` ty_b = return True
493 tcSubsumes ty_a ty_b = discardErrs $
494 do { (_, wanted, _) <- pushLevelAndCaptureConstraints $
495 tcSubType_NC ExprSigCtxt ty_b ty_a
496 ; (rem, _) <- runTcS (simpl_top wanted)
497 -- We don't want any insoluble or simple constraints left,
498 -- but solved implications are ok (and neccessary for e.g. undefined)
499 ; return (isEmptyBag (wc_simple rem)
500 && isEmptyBag (wc_insol rem)
501 && allBag (isSolvedStatus . ic_status) (wc_impl rem))
502 }
503
504 ------------------
505 tcCheckSatisfiability :: Bag EvVar -> TcM Bool
506 -- Return True if satisfiable, False if definitely contradictory
507 tcCheckSatisfiability given_ids
508 = do { lcl_env <- TcM.getLclEnv
509 ; let given_loc = mkGivenLoc topTcLevel UnkSkol lcl_env
510 ; (res, _ev_binds) <- runTcS $
511 do { traceTcS "checkSatisfiability {" (ppr given_ids)
512 ; let given_cts = mkGivens given_loc (bagToList given_ids)
513 -- See Note [Superclasses and satisfiability]
514 ; solveSimpleGivens given_cts
515 ; insols <- getInertInsols
516 ; insols <- try_harder insols
517 ; traceTcS "checkSatisfiability }" (ppr insols)
518 ; return (isEmptyBag insols) }
519 ; return res }
520 where
521 try_harder :: Cts -> TcS Cts
522 -- Maybe we have to search up the superclass chain to find
523 -- an unsatisfiable constraint. Example: pmcheck/T3927b.
524 -- At the moment we try just once
525 try_harder insols
526 | not (isEmptyBag insols) -- We've found that it's definitely unsatisfiable
527 = return insols -- Hurrah -- stop now.
528 | otherwise
529 = do { pending_given <- getPendingScDicts
530 ; new_given <- makeSuperClasses pending_given
531 ; solveSimpleGivens new_given
532 ; getInertInsols }
533
534 {- Note [Superclasses and satisfiability]
535 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
536 Expand superclasses before starting, because (Int ~ Bool), has
537 (Int ~~ Bool) as a superclass, which in turn has (Int ~N# Bool)
538 as a superclass, and it's the latter that is insoluble. See
539 Note [The equality types story] in TysPrim.
540
541 If we fail to prove unsatisfiability we (arbitrarily) try just once to
542 find superclasses, using try_harder. Reason: we might have a type
543 signature
544 f :: F op (Implements push) => ..
545 where F is a type function. This happened in Trac #3972.
546
547 We could do more than once but we'd have to have /some/ limit: in the
548 the recursive case, we would go on forever in the common case where
549 the constraints /are/ satisfiable (Trac #10592 comment:12!).
550
551 For stratightforard situations without type functions the try_harder
552 step does nothing.
553
554
555 ***********************************************************************************
556 * *
557 * Inference
558 * *
559 ***********************************************************************************
560
561 Note [Inferring the type of a let-bound variable]
562 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
563 Consider
564 f x = rhs
565
566 To infer f's type we do the following:
567 * Gather the constraints for the RHS with ambient level *one more than*
568 the current one. This is done by the call
569 pushLevelAndCaptureConstraints (tcMonoBinds...)
570 in TcBinds.tcPolyInfer
571
572 * Call simplifyInfer to simplify the constraints and decide what to
573 quantify over. We pass in the level used for the RHS constraints,
574 here called rhs_tclvl.
575
576 This ensures that the implication constraint we generate, if any,
577 has a strictly-increased level compared to the ambient level outside
578 the let binding.
579
580 -}
581
582 -- | How should we choose which constraints to quantify over?
583 data InferMode = ApplyMR -- ^ Apply the monomorphism restriction,
584 -- never quantifying over any constraints
585 | EagerDefaulting -- ^ See Note [TcRnExprMode] in TcRnDriver,
586 -- the :type +d case; this mode refuses
587 -- to quantify over any defaultable constraint
588 | NoRestrictions -- ^ Quantify over any constraint that
589 -- satisfies TcType.pickQuantifiablePreds
590
591 instance Outputable InferMode where
592 ppr ApplyMR = text "ApplyMR"
593 ppr EagerDefaulting = text "EagerDefaulting"
594 ppr NoRestrictions = text "NoRestrictions"
595
596 simplifyInfer :: TcLevel -- Used when generating the constraints
597 -> InferMode
598 -> [TcIdSigInst] -- Any signatures (possibly partial)
599 -> [(Name, TcTauType)] -- Variables to be generalised,
600 -- and their tau-types
601 -> WantedConstraints
602 -> TcM ([TcTyVar], -- Quantify over these type variables
603 [EvVar], -- ... and these constraints (fully zonked)
604 TcEvBinds, -- ... binding these evidence variables
605 Bool) -- True <=> there was an insoluble type error
606 -- in these bindings
607 simplifyInfer rhs_tclvl infer_mode sigs name_taus wanteds
608 | isEmptyWC wanteds
609 = do { gbl_tvs <- tcGetGlobalTyCoVars
610 ; dep_vars <- zonkTcTypesAndSplitDepVars (map snd name_taus)
611 ; qtkvs <- quantifyTyVars gbl_tvs dep_vars
612 ; traceTc "simplifyInfer: empty WC" (ppr name_taus $$ ppr qtkvs)
613 ; return (qtkvs, [], emptyTcEvBinds, False) }
614
615 | otherwise
616 = do { traceTc "simplifyInfer {" $ vcat
617 [ text "sigs =" <+> ppr sigs
618 , text "binds =" <+> ppr name_taus
619 , text "rhs_tclvl =" <+> ppr rhs_tclvl
620 , text "infer_mode =" <+> ppr infer_mode
621 , text "(unzonked) wanted =" <+> ppr wanteds
622 ]
623
624 ; let partial_sigs = filter isPartialSig sigs
625 psig_theta = concatMap sig_inst_theta partial_sigs
626
627 -- First do full-blown solving
628 -- NB: we must gather up all the bindings from doing
629 -- this solving; hence (runTcSWithEvBinds ev_binds_var).
630 -- And note that since there are nested implications,
631 -- calling solveWanteds will side-effect their evidence
632 -- bindings, so we can't just revert to the input
633 -- constraint.
634
635 ; tc_lcl_env <- TcM.getLclEnv
636 ; ev_binds_var <- TcM.newTcEvBinds
637 ; psig_theta_vars <- mapM TcM.newEvVar psig_theta
638 ; wanted_transformed_incl_derivs
639 <- setTcLevel rhs_tclvl $
640 runTcSWithEvBinds ev_binds_var $
641 do { let loc = mkGivenLoc rhs_tclvl UnkSkol tc_lcl_env
642 psig_givens = mkGivens loc psig_theta_vars
643 ; _ <- solveSimpleGivens psig_givens
644 -- See Note [Add signature contexts as givens]
645 ; wanteds' <- solveWanteds wanteds
646 ; TcS.zonkWC wanteds' }
647
648
649 -- Find quant_pred_candidates, the predicates that
650 -- we'll consider quantifying over
651 -- NB1: wanted_transformed does not include anything provable from
652 -- the psig_theta; it's just the extra bit
653 -- NB2: We do not do any defaulting when inferring a type, this can lead
654 -- to less polymorphic types, see Note [Default while Inferring]
655 ; let definite_error = insolubleWC wanted_transformed_incl_derivs
656 -- See Note [Quantification with errors]
657 -- NB: must include derived errors in this test,
658 -- hence "incl_derivs"
659 wanted_transformed = dropDerivedWC wanted_transformed_incl_derivs
660 quant_pred_candidates
661 | definite_error = []
662 | otherwise = ctsPreds (approximateWC False wanted_transformed)
663
664 -- Decide what type variables and constraints to quantify
665 -- NB: quant_pred_candidates is already fully zonked
666 -- NB: bound_theta are constraints we want to quantify over,
667 -- /apart from/ the psig_theta, which we always quantify over
668 ; (qtvs, bound_theta) <- decideQuantification infer_mode rhs_tclvl
669 name_taus partial_sigs
670 quant_pred_candidates
671
672 -- Emit an implication constraint for the
673 -- remaining constraints from the RHS.
674 -- We must retain the psig_theta_vars, because we've used them in
675 -- evidence bindings constructed by solveWanteds earlier
676 ; psig_theta_vars <- mapM zonkId psig_theta_vars
677 ; bound_theta_vars <- mapM TcM.newEvVar bound_theta
678 ; let full_theta_vars = psig_theta_vars ++ bound_theta_vars
679
680 ; emitResidualImplication rhs_tclvl tc_lcl_env ev_binds_var
681 name_taus qtvs full_theta_vars
682 wanted_transformed
683
684 -- All done!
685 ; traceTc "} simplifyInfer/produced residual implication for quantification" $
686 vcat [ text "quant_pred_candidates =" <+> ppr quant_pred_candidates
687 , text "psig_theta =" <+> ppr psig_theta
688 , text "bound_theta =" <+> ppr bound_theta
689 , text "full_theta =" <+> ppr (map idType full_theta_vars)
690 , text "qtvs =" <+> ppr qtvs
691 , text "definite_error =" <+> ppr definite_error ]
692
693 ; return ( qtvs, full_theta_vars, TcEvBinds ev_binds_var, definite_error ) }
694 -- NB: full_theta_vars must be fully zonked
695
696
697 --------------------
698 emitResidualImplication :: TcLevel -> TcLclEnv -> EvBindsVar
699 -> [(Name, TcTauType)] -> [TcTyVar] -> [EvVar]
700 -> WantedConstraints -> TcM ()
701 emitResidualImplication rhs_tclvl tc_lcl_env ev_binds_var
702 name_taus qtvs full_theta_vars wanteds
703 | isEmptyWC wanteds
704 = return ()
705 | otherwise
706 = do { traceTc "emitResidualImplication" (ppr implic)
707 ; emitImplication implic }
708 where
709 implic = Implic { ic_tclvl = rhs_tclvl
710 , ic_skols = qtvs
711 , ic_no_eqs = False
712 , ic_given = full_theta_vars
713 , ic_wanted = wanteds
714 , ic_status = IC_Unsolved
715 , ic_binds = ev_binds_var
716 , ic_info = skol_info
717 , ic_needed = emptyVarSet
718 , ic_env = tc_lcl_env }
719
720 full_theta = map idType full_theta_vars
721 skol_info = InferSkol [ (name, mkSigmaTy [] full_theta ty)
722 | (name, ty) <- name_taus ]
723 -- Don't add the quantified variables here, because
724 -- they are also bound in ic_skols and we want them
725 -- to be tidied uniformly
726
727 --------------------
728 ctsPreds :: Cts -> [PredType]
729 ctsPreds cts = [ ctEvPred ev | ct <- bagToList cts
730 , let ev = ctEvidence ct ]
731
732 {- Note [Add signature contexts as givens]
733 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
734 Consider this (Trac #11016):
735 f2 :: (?x :: Int) => _
736 f2 = ?x
737 or this
738 f3 :: a ~ Bool => (a, _)
739 f3 = (True, False)
740 or theis
741 f4 :: (Ord a, _) => a -> Bool
742 f4 x = x==x
743
744 We'll use plan InferGen because there are holes in the type. But:
745 * For f2 we want to have the (?x :: Int) constraint floating around
746 so that the functional dependencies kick in. Otherwise the
747 occurrence of ?x on the RHS produces constraint (?x :: alpha), and
748 we won't unify alpha:=Int.
749 * For f3 we want the (a ~ Bool) available to solve the wanted (a ~ Bool)
750 in the RHS
751 * For f4 we want to use the (Ord a) in the signature to solve the Eq a
752 constraint.
753
754 Solution: in simplifyInfer, just before simplifying the constraints
755 gathered from the RHS, add Given constraints for the context of any
756 type signatures.
757
758 ************************************************************************
759 * *
760 Quantification
761 * *
762 ************************************************************************
763
764 Note [Deciding quantification]
765 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
766 If the monomorphism restriction does not apply, then we quantify as follows:
767
768 * Step 1. Take the global tyvars, and "grow" them using the equality
769 constraints
770 E.g. if x:alpha is in the environment, and alpha ~ [beta] (which can
771 happen because alpha is untouchable here) then do not quantify over
772 beta, because alpha fixes beta, and beta is effectively free in
773 the environment too
774
775 We also account for the monomorphism restriction; if it applies,
776 add the free vars of all the constraints.
777
778 Result is mono_tvs; we will not quantify over these.
779
780 * Step 2. Default any non-mono tyvars (i.e ones that are definitely
781 not going to become further constrained), and re-simplify the
782 candidate constraints.
783
784 Motivation for re-simplification (Trac #7857): imagine we have a
785 constraint (C (a->b)), where 'a :: TYPE l1' and 'b :: TYPE l2' are
786 not free in the envt, and instance forall (a::*) (b::*). (C a) => C
787 (a -> b) The instance doesn't match while l1,l2 are polymorphic, but
788 it will match when we default them to LiftedRep.
789
790 This is all very tiresome.
791
792 * Step 3: decide which variables to quantify over, as follows:
793
794 - Take the free vars of the tau-type (zonked_tau_tvs) and "grow"
795 them using all the constraints. These are tau_tvs_plus
796
797 - Use quantifyTyVars to quantify over (tau_tvs_plus - mono_tvs), being
798 careful to close over kinds, and to skolemise the quantified tyvars.
799 (This actually unifies each quantifies meta-tyvar with a fresh skolem.)
800
801 Result is qtvs.
802
803 * Step 4: Filter the constraints using pickQuantifiablePreds and the
804 qtvs. We have to zonk the constraints first, so they "see" the
805 freshly created skolems.
806
807 -}
808
809 decideQuantification
810 :: InferMode
811 -> TcLevel
812 -> [(Name, TcTauType)] -- Variables to be generalised
813 -> [TcIdSigInst] -- Partial type signatures (if any)
814 -> [PredType] -- Candidate theta; already zonked
815 -> TcM ( [TcTyVar] -- Quantify over these (skolems)
816 , [PredType] ) -- and this context (fully zonked)
817 -- See Note [Deciding quantification]
818 decideQuantification infer_mode rhs_tclvl name_taus psigs candidates
819 = do { -- Step 1: find the mono_tvs
820 ; (mono_tvs, candidates) <- decideMonoTyVars infer_mode
821 name_taus psigs candidates
822
823 -- Step 2: default any non-mono tyvars, and re-simplify
824 -- This step may do some unification, but result candidates is zonked
825 ; candidates <- defaultTyVarsAndSimplify rhs_tclvl mono_tvs candidates
826
827 -- Step 3: decide which kind/type variables to quantify over
828 ; qtvs <- decideQuantifiedTyVars mono_tvs name_taus psigs candidates
829
830 -- Step 4: choose which of the remaining candidate
831 -- predicates to actually quantify over
832 -- NB: decideQuantifiedTyVars turned some meta tyvars
833 -- into quantified skolems, so we have to zonk again
834 ; candidates <- TcM.zonkTcTypes candidates
835 ; let theta = pickQuantifiablePreds (mkVarSet qtvs) $
836 mkMinimalBySCs $ -- See Note [Minimize by Superclasses]
837 candidates
838
839 ; traceTc "decideQuantification"
840 (vcat [ text "infer_mode:" <+> ppr infer_mode
841 , text "candidates:" <+> ppr candidates
842 , text "mono_tvs:" <+> ppr mono_tvs
843 , text "qtvs:" <+> ppr qtvs
844 , text "theta:" <+> ppr theta ])
845 ; return (qtvs, theta) }
846
847 ------------------
848 decideMonoTyVars :: InferMode
849 -> [(Name,TcType)]
850 -> [TcIdSigInst]
851 -> [PredType]
852 -> TcM (TcTyCoVarSet, [PredType])
853 -- Decide which tyvars cannot be generalised:
854 -- (a) Free in the environment
855 -- (b) Mentioned in a constraint we can't generalise
856 -- (c) Connected by an equality to (a) or (b)
857 -- Also return the reduced set of constraint we can generalise
858 decideMonoTyVars infer_mode name_taus psigs candidates
859 = do { (no_quant, yes_quant) <- pick infer_mode candidates
860
861 ; gbl_tvs <- tcGetGlobalTyCoVars
862 ; let eq_constraints = filter isEqPred candidates
863 mono_tvs1 = growThetaTyVars eq_constraints gbl_tvs
864 constrained_tvs = growThetaTyVars eq_constraints
865 (tyCoVarsOfTypes no_quant)
866 `minusVarSet` mono_tvs1
867 mono_tvs2 = mono_tvs1 `unionVarSet` constrained_tvs
868 -- A type variable is only "constrained" (so that the MR bites)
869 -- if it is not free in the environment (Trac #13785)
870
871 -- Always quantify over partial-sig qtvs, so they are not mono
872 -- Need to zonk them because they are meta-tyvar SigTvs
873 -- Note [Quantification and partial signatures], wrinkle 3
874 ; psig_qtvs <- mapM zonkTcTyVarToTyVar $
875 concatMap (map snd . sig_inst_skols) psigs
876 ; let mono_tvs = mono_tvs2 `delVarSetList` psig_qtvs
877
878 -- Warn about the monomorphism restriction
879 ; warn_mono <- woptM Opt_WarnMonomorphism
880 ; when (case infer_mode of { ApplyMR -> warn_mono; _ -> False}) $
881 do { taus <- mapM (TcM.zonkTcType . snd) name_taus
882 ; warnTc (Reason Opt_WarnMonomorphism)
883 (constrained_tvs `intersectsVarSet` tyCoVarsOfTypes taus)
884 mr_msg }
885
886 ; traceTc "decideMonoTyVars" $ vcat
887 [ text "gbl_tvs =" <+> ppr gbl_tvs
888 , text "no_quant =" <+> ppr no_quant
889 , text "yes_quant =" <+> ppr yes_quant
890 , text "eq_constraints =" <+> ppr eq_constraints
891 , text "mono_tvs =" <+> ppr mono_tvs ]
892
893 ; return (mono_tvs, yes_quant) }
894 where
895 pick :: InferMode -> [PredType] -> TcM ([PredType], [PredType])
896 -- Split the candidates into ones we definitely
897 -- won't quantify, and ones that we might
898 pick NoRestrictions cand = return ([], cand)
899 pick ApplyMR cand = return (cand, [])
900 pick EagerDefaulting cand = do { os <- xoptM LangExt.OverloadedStrings
901 ; return (partition (is_int_ct os) cand) }
902
903 -- For EagerDefaulting, do not quantify over
904 -- over any interactive class constraint
905 is_int_ct ovl_strings pred
906 | Just (cls, _) <- getClassPredTys_maybe pred
907 = isInteractiveClass ovl_strings cls
908 | otherwise
909 = False
910
911 pp_bndrs = pprWithCommas (quotes . ppr . fst) name_taus
912 mr_msg =
913 hang (sep [ text "The Monomorphism Restriction applies to the binding"
914 <> plural name_taus
915 , text "for" <+> pp_bndrs ])
916 2 (hsep [ text "Consider giving"
917 , text (if isSingleton name_taus then "it" else "them")
918 , text "a type signature"])
919
920 -------------------
921 defaultTyVarsAndSimplify :: TcLevel
922 -> TyCoVarSet
923 -> [PredType] -- Assumed zonked
924 -> TcM [PredType] -- Guaranteed zonked
925 -- Default any tyvar free in the constraints,
926 -- and re-simplify in case the defaulting allows further simplification
927 defaultTyVarsAndSimplify rhs_tclvl mono_tvs candidates
928 = do { -- Promote any tyvars that we cannot generalise
929 -- See Note [Promote momomorphic tyvars]
930 ; outer_tclvl <- TcM.getTcLevel
931 ; let prom_tvs = nonDetEltsUniqSet mono_tvs
932 -- It's OK to use nonDetEltsUniqSet here
933 -- because promoteTyVar is commutative
934 ; traceTc "decideMonoTyVars: promotion:" (ppr prom_tvs)
935 ; proms <- mapM (promoteTyVar outer_tclvl) prom_tvs
936
937 -- Default any kind/levity vars
938 ; let DV {dv_kvs = cand_kvs, dv_tvs = cand_tvs}
939 = candidateQTyVarsOfTypes candidates
940 ; poly_kinds <- xoptM LangExt.PolyKinds
941 ; default_kvs <- mapM (default_one poly_kinds True)
942 (dVarSetElems cand_kvs)
943 ; default_tvs <- mapM (default_one poly_kinds False)
944 (dVarSetElems (cand_tvs `minusDVarSet` cand_kvs))
945 ; let some_default = or default_kvs || or default_tvs
946
947 ; case () of
948 _ | some_default -> simplify_cand candidates
949 | or proms -> mapM TcM.zonkTcType candidates
950 | otherwise -> return candidates
951 }
952 where
953 default_one poly_kinds is_kind_var tv
954 | not (isMetaTyVar tv)
955 = return False
956 | tv `elemVarSet` mono_tvs
957 = return False
958 | otherwise
959 = defaultTyVar (not poly_kinds && is_kind_var) tv
960
961 simplify_cand candidates
962 = do { clone_wanteds <- newWanteds DefaultOrigin candidates
963 ; WC { wc_simple = simples } <- setTcLevel rhs_tclvl $
964 simplifyWantedsTcM clone_wanteds
965 -- Discard evidence; simples is fully zonked
966
967 ; let new_candidates = ctsPreds simples
968 ; traceTc "Simplified after defaulting" $
969 vcat [ text "Before:" <+> ppr candidates
970 , text "After:" <+> ppr new_candidates ]
971 ; return new_candidates }
972
973 ------------------
974 decideQuantifiedTyVars
975 :: TyCoVarSet -- Monomorphic tyvars
976 -> [(Name,TcType)] -- Annotated theta and (name,tau) pairs
977 -> [TcIdSigInst] -- Partial signatures
978 -> [PredType] -- Candidates, zonked
979 -> TcM [TyVar]
980 -- Fix what tyvars we are going to quantify over, and quantify them
981 decideQuantifiedTyVars mono_tvs name_taus psigs candidates
982 = do { -- Why psig_tys? We try to quantify over everything free in here
983 -- See Note [Quantification and partial signatures]
984 -- wrinkles 2 and 3
985 ; psig_tv_tys <- mapM TcM.zonkTcTyVar [ tv | sig <- psigs
986 , (_,tv) <- sig_inst_skols sig ]
987 ; psig_theta <- mapM TcM.zonkTcType [ pred | sig <- psigs
988 , pred <- sig_inst_theta sig ]
989 ; tau_tys <- mapM (TcM.zonkTcType . snd) name_taus
990
991 ; let -- Try to quantify over variables free in these types
992 psig_tys = psig_tv_tys ++ psig_theta
993 seed_tys = psig_tys ++ tau_tys
994
995 -- Now "grow" those seeds to find ones reachable via 'candidates'
996 grown_tvs = growThetaTyVars candidates (tyCoVarsOfTypes seed_tys)
997
998 -- Now we have to classify them into kind variables and type variables
999 -- (sigh) just for the benefit of -XNoPolyKinds; see quantifyTyVars
1000 --
1001 -- Keep the psig_tys first, so that candidateQTyVarsOfTypes produces
1002 -- them in that order, so that the final qtvs quantifies in the same
1003 -- order as the partial signatures do (Trac #13524)
1004 ; let DV {dv_kvs = cand_kvs, dv_tvs = cand_tvs}
1005 = candidateQTyVarsOfTypes $
1006 psig_tys ++ candidates ++ tau_tys
1007 pick = (`dVarSetIntersectVarSet` grown_tvs)
1008 dvs_plus = DV { dv_kvs = pick cand_kvs, dv_tvs = pick cand_tvs }
1009
1010 ; mono_tvs <- TcM.zonkTyCoVarsAndFV mono_tvs
1011 ; quantifyTyVars mono_tvs dvs_plus }
1012
1013 ------------------
1014 growThetaTyVars :: ThetaType -> TyCoVarSet -> TyVarSet
1015 -- See Note [Growing the tau-tvs using constraints]
1016 -- NB: only returns tyvars, never covars
1017 growThetaTyVars theta tvs
1018 | null theta = tvs_only
1019 | otherwise = filterVarSet isTyVar $
1020 transCloVarSet mk_next seed_tvs
1021 where
1022 tvs_only = filterVarSet isTyVar tvs
1023 seed_tvs = tvs `unionVarSet` tyCoVarsOfTypes ips
1024 (ips, non_ips) = partition isIPPred theta
1025 -- See Note [Inheriting implicit parameters] in TcType
1026
1027 mk_next :: VarSet -> VarSet -- Maps current set to newly-grown ones
1028 mk_next so_far = foldr (grow_one so_far) emptyVarSet non_ips
1029 grow_one so_far pred tvs
1030 | pred_tvs `intersectsVarSet` so_far = tvs `unionVarSet` pred_tvs
1031 | otherwise = tvs
1032 where
1033 pred_tvs = tyCoVarsOfType pred
1034
1035 {- Note [Promote momomorphic tyvars]
1036 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1037 Promote any type variables that are free in the environment. Eg
1038 f :: forall qtvs. bound_theta => zonked_tau
1039 The free vars of f's type become free in the envt, and hence will show
1040 up whenever 'f' is called. They may currently at rhs_tclvl, but they
1041 had better be unifiable at the outer_tclvl! Example: envt mentions
1042 alpha[1]
1043 tau_ty = beta[2] -> beta[2]
1044 constraints = alpha ~ [beta]
1045 we don't quantify over beta (since it is fixed by envt)
1046 so we must promote it! The inferred type is just
1047 f :: beta -> beta
1048
1049 NB: promoteTyVar ignores coercion variables
1050
1051 Note [Quantification and partial signatures]
1052 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1053 When choosing type variables to quantify, the basic plan is to
1054 quantify over all type variables that are
1055 * free in the tau_tvs, and
1056 * not forced to be monomorphic (mono_tvs),
1057 for example by being free in the environment.
1058
1059 However, in the case of a partial type signature, be doing inference
1060 *in the presence of a type signature*. For example:
1061 f :: _ -> a
1062 f x = ...
1063 or
1064 g :: (Eq _a) => _b -> _b
1065 In both cases we use plan InferGen, and hence call simplifyInfer. But
1066 those 'a' variables are skolems (actually SigTvs), and we should be
1067 sure to quantify over them. This leads to several wrinkles:
1068
1069 * Wrinkle 1. In the case of a type error
1070 f :: _ -> Maybe a
1071 f x = True && x
1072 The inferred type of 'f' is f :: Bool -> Bool, but there's a
1073 left-over error of form (HoleCan (Maybe a ~ Bool)). The error-reporting
1074 machine expects to find a binding site for the skolem 'a', so we
1075 add it to the quantified tyvars.
1076
1077 * Wrinkle 2. Consider the partial type signature
1078 f :: (Eq _) => Int -> Int
1079 f x = x
1080 In normal cases that makes sense; e.g.
1081 g :: Eq _a => _a -> _a
1082 g x = x
1083 where the signature makes the type less general than it could
1084 be. But for 'f' we must therefore quantify over the user-annotated
1085 constraints, to get
1086 f :: forall a. Eq a => Int -> Int
1087 (thereby correctly triggering an ambiguity error later). If we don't
1088 we'll end up with a strange open type
1089 f :: Eq alpha => Int -> Int
1090 which isn't ambiguous but is still very wrong.
1091
1092 Bottom line: Try to quantify over any variable free in psig_theta,
1093 just like the tau-part of the type.
1094
1095 * Wrinkle 3 (Trac #13482). Also consider
1096 f :: forall a. _ => Int -> Int
1097 f x = if undefined :: a == undefined then x else 0
1098 Here we get an (Eq a) constraint, but it's not mentioned in the
1099 psig_theta nor the type of 'f'. Moreover, if we have
1100 f :: forall a. a -> _
1101 f x = not x
1102 and a constraint (a ~ g), where 'g' is free in the environment,
1103 we would not usually quanitfy over 'a'. But here we should anyway
1104 (leading to a justified subsequent error) since 'a' is explicitly
1105 quantified by the programmer.
1106
1107 Bottom line: always quantify over the psig_tvs, regardless.
1108
1109 Note [Quantifying over equality constraints]
1110 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1111 Should we quantify over an equality constraint (s ~ t)? In general, we don't.
1112 Doing so may simply postpone a type error from the function definition site to
1113 its call site. (At worst, imagine (Int ~ Bool)).
1114
1115 However, consider this
1116 forall a. (F [a] ~ Int) => blah
1117 Should we quantify over the (F [a] ~ Int)? Perhaps yes, because at the call
1118 site we will know 'a', and perhaps we have instance F [Bool] = Int.
1119 So we *do* quantify over a type-family equality where the arguments mention
1120 the quantified variables.
1121
1122 Note [Growing the tau-tvs using constraints]
1123 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1124 (growThetaTyVars insts tvs) is the result of extending the set
1125 of tyvars, tvs, using all conceivable links from pred
1126
1127 E.g. tvs = {a}, preds = {H [a] b, K (b,Int) c, Eq e}
1128 Then growThetaTyVars preds tvs = {a,b,c}
1129
1130 Notice that
1131 growThetaTyVars is conservative if v might be fixed by vs
1132 => v `elem` grow(vs,C)
1133
1134 Note [Quantification with errors]
1135 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1136 If we find that the RHS of the definition has some absolutely-insoluble
1137 constraints (including especially "variable not in scope"), we
1138
1139 * Abandon all attempts to find a context to quantify over,
1140 and instead make the function fully-polymorphic in whatever
1141 type we have found
1142
1143 * Return a flag from simplifyInfer, indicating that we found an
1144 insoluble constraint. This flag is used to suppress the ambiguity
1145 check for the inferred type, which may well be bogus, and which
1146 tends to obscure the real error. This fix feels a bit clunky,
1147 but I failed to come up with anything better.
1148
1149 Reasons:
1150 - Avoid downstream errors
1151 - Do not perform an ambiguity test on a bogus type, which might well
1152 fail spuriously, thereby obfuscating the original insoluble error.
1153 Trac #14000 is an example
1154
1155 I tried an alterantive approach: simply failM, after emitting the
1156 residual implication constraint; the exception will be caught in
1157 TcBinds.tcPolyBinds, which gives all the binders in the group the type
1158 (forall a. a). But that didn't work with -fdefer-type-errors, because
1159 the recovery from failM emits no code at all, so there is no function
1160 to run! But -fdefer-type-errors aspires to produce a runnable program.
1161
1162 NB that we must include *derived* errors in the check for insolubles.
1163 Example:
1164 (a::*) ~ Int#
1165 We get an insoluble derived error *~#, and we don't want to discard
1166 it before doing the isInsolubleWC test! (Trac #8262)
1167
1168 Note [Default while Inferring]
1169 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1170 Our current plan is that defaulting only happens at simplifyTop and
1171 not simplifyInfer. This may lead to some insoluble deferred constraints.
1172 Example:
1173
1174 instance D g => C g Int b
1175
1176 constraint inferred = (forall b. 0 => C gamma alpha b) /\ Num alpha
1177 type inferred = gamma -> gamma
1178
1179 Now, if we try to default (alpha := Int) we will be able to refine the implication to
1180 (forall b. 0 => C gamma Int b)
1181 which can then be simplified further to
1182 (forall b. 0 => D gamma)
1183 Finally, we /can/ approximate this implication with (D gamma) and infer the quantified
1184 type: forall g. D g => g -> g
1185
1186 Instead what will currently happen is that we will get a quantified type
1187 (forall g. g -> g) and an implication:
1188 forall g. 0 => (forall b. 0 => C g alpha b) /\ Num alpha
1189
1190 Which, even if the simplifyTop defaults (alpha := Int) we will still be left with an
1191 unsolvable implication:
1192 forall g. 0 => (forall b. 0 => D g)
1193
1194 The concrete example would be:
1195 h :: C g a s => g -> a -> ST s a
1196 f (x::gamma) = (\_ -> x) (runST (h x (undefined::alpha)) + 1)
1197
1198 But it is quite tedious to do defaulting and resolve the implication constraints, and
1199 we have not observed code breaking because of the lack of defaulting in inference, so
1200 we don't do it for now.
1201
1202
1203
1204 Note [Minimize by Superclasses]
1205 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1206 When we quantify over a constraint, in simplifyInfer we need to
1207 quantify over a constraint that is minimal in some sense: For
1208 instance, if the final wanted constraint is (Eq alpha, Ord alpha),
1209 we'd like to quantify over Ord alpha, because we can just get Eq alpha
1210 from superclass selection from Ord alpha. This minimization is what
1211 mkMinimalBySCs does. Then, simplifyInfer uses the minimal constraint
1212 to check the original wanted.
1213
1214
1215 Note [Avoid unnecessary constraint simplification]
1216 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1217 -------- NB NB NB (Jun 12) -------------
1218 This note not longer applies; see the notes with Trac #4361.
1219 But I'm leaving it in here so we remember the issue.)
1220 ----------------------------------------
1221 When inferring the type of a let-binding, with simplifyInfer,
1222 try to avoid unnecessarily simplifying class constraints.
1223 Doing so aids sharing, but it also helps with delicate
1224 situations like
1225
1226 instance C t => C [t] where ..
1227
1228 f :: C [t] => ....
1229 f x = let g y = ...(constraint C [t])...
1230 in ...
1231 When inferring a type for 'g', we don't want to apply the
1232 instance decl, because then we can't satisfy (C t). So we
1233 just notice that g isn't quantified over 't' and partition
1234 the constraints before simplifying.
1235
1236 This only half-works, but then let-generalisation only half-works.
1237
1238 *********************************************************************************
1239 * *
1240 * Main Simplifier *
1241 * *
1242 ***********************************************************************************
1243
1244 -}
1245
1246 simplifyWantedsTcM :: [CtEvidence] -> TcM WantedConstraints
1247 -- Solve the specified Wanted constraints
1248 -- Discard the evidence binds
1249 -- Discards all Derived stuff in result
1250 -- Postcondition: fully zonked and unflattened constraints
1251 simplifyWantedsTcM wanted
1252 = do { traceTc "simplifyWantedsTcM {" (ppr wanted)
1253 ; (result, _) <- runTcS (solveWantedsAndDrop (mkSimpleWC wanted))
1254 ; result <- TcM.zonkWC result
1255 ; traceTc "simplifyWantedsTcM }" (ppr result)
1256 ; return result }
1257
1258 solveWantedsAndDrop :: WantedConstraints -> TcS WantedConstraints
1259 -- Since solveWanteds returns the residual WantedConstraints,
1260 -- it should always be called within a runTcS or something similar,
1261 -- Result is not zonked
1262 solveWantedsAndDrop wanted
1263 = do { wc <- solveWanteds wanted
1264 ; return (dropDerivedWC wc) }
1265
1266 solveWanteds :: WantedConstraints -> TcS WantedConstraints
1267 -- so that the inert set doesn't mindlessly propagate.
1268 -- NB: wc_simples may be wanted /or/ derived now
1269 solveWanteds wc@(WC { wc_simple = simples, wc_insol = insols, wc_impl = implics })
1270 = do { traceTcS "solveWanteds {" (ppr wc)
1271
1272 ; wc1 <- solveSimpleWanteds (simples `unionBags` insols)
1273 -- Why solve 'insols'? See Note [Rewrite insolubles] in TcSMonad
1274
1275 ; let WC { wc_simple = simples1, wc_insol = insols1, wc_impl = implics1 } = wc1
1276
1277 ; (floated_eqs, implics2) <- solveNestedImplications (implics `unionBags` implics1)
1278 ; (no_new_scs, simples2) <- expandSuperClasses simples1
1279
1280 ; traceTcS "solveWanteds middle" $ vcat [ text "simples1 =" <+> ppr simples1
1281 , text "simples2 =" <+> ppr simples2 ]
1282
1283 ; dflags <- getDynFlags
1284 ; final_wc <- simpl_loop 0 (solverIterations dflags) floated_eqs
1285 no_new_scs
1286 (WC { wc_simple = simples2
1287 , wc_insol = insols1
1288 , wc_impl = implics2 })
1289
1290 ; bb <- TcS.getTcEvBindsMap
1291 ; traceTcS "solveWanteds }" $
1292 vcat [ text "final wc =" <+> ppr final_wc
1293 , text "current evbinds =" <+> ppr (evBindMapBinds bb) ]
1294
1295 ; return final_wc }
1296
1297 simpl_loop :: Int -> IntWithInf -> Cts -> Bool
1298 -> WantedConstraints
1299 -> TcS WantedConstraints
1300 simpl_loop n limit floated_eqs no_new_deriveds
1301 wc@(WC { wc_simple = simples, wc_insol = insols, wc_impl = implics })
1302 | isEmptyBag floated_eqs && no_new_deriveds
1303 = return wc -- Done!
1304
1305 | n `intGtLimit` limit
1306 = do { -- Add an error (not a warning) if we blow the limit,
1307 -- Typically if we blow the limit we are going to report some other error
1308 -- (an unsolved constraint), and we don't want that error to suppress
1309 -- the iteration limit warning!
1310 addErrTcS (hang (text "solveWanteds: too many iterations"
1311 <+> parens (text "limit =" <+> ppr limit))
1312 2 (vcat [ text "Unsolved:" <+> ppr wc
1313 , ppUnless (isEmptyBag floated_eqs) $
1314 text "Floated equalities:" <+> ppr floated_eqs
1315 , ppUnless no_new_deriveds $
1316 text "New deriveds found"
1317 , text "Set limit with -fconstraint-solver-iterations=n; n=0 for no limit"
1318 ]))
1319 ; return wc }
1320
1321 | otherwise
1322 = do { let n_floated = lengthBag floated_eqs
1323 ; csTraceTcS $
1324 text "simpl_loop iteration=" <> int n
1325 <+> (parens $ hsep [ text "no new deriveds =" <+> ppr no_new_deriveds <> comma
1326 , int n_floated <+> text "floated eqs" <> comma
1327 , int (lengthBag simples) <+> text "simples to solve" ])
1328
1329 -- solveSimples may make progress if either float_eqs hold
1330 ; (unifs1, wc1) <- reportUnifications $
1331 solveSimpleWanteds $
1332 floated_eqs `unionBags` simples `unionBags` insols
1333 -- Notes:
1334 -- - Why solve 'insols'? See Note [Rewrite insolubles] in TcSMonad
1335 -- - Put floated_eqs first so they get solved first
1336 -- NB: the floated_eqs may include /derived/ equalities
1337 -- arising from fundeps inside an implication
1338
1339 ; let WC { wc_simple = simples1, wc_insol = insols1, wc_impl = implics1 } = wc1
1340 ; (no_new_scs, simples2) <- expandSuperClasses simples1
1341
1342 -- We have already tried to solve the nested implications once
1343 -- Try again only if we have unified some meta-variables
1344 -- (which is a bit like adding more givens)
1345 -- See Note [Cutting off simpl_loop]
1346 ; (floated_eqs2, implics2) <- if unifs1 == 0 && isEmptyBag implics1
1347 then return (emptyBag, implics)
1348 else solveNestedImplications (implics `unionBags` implics1)
1349
1350 ; simpl_loop (n+1) limit floated_eqs2 no_new_scs
1351 (WC { wc_simple = simples2
1352 , wc_insol = insols1
1353 , wc_impl = implics2 }) }
1354
1355
1356 expandSuperClasses :: Cts -> TcS (Bool, Cts)
1357 -- If there are any unsolved wanteds, expand one step of
1358 -- superclasses for deriveds
1359 -- Returned Bool is True <=> no new superclass constraints added
1360 -- See Note [The superclass story] in TcCanonical
1361 expandSuperClasses unsolved
1362 | not (anyBag superClassesMightHelp unsolved)
1363 = return (True, unsolved)
1364 | otherwise
1365 = do { traceTcS "expandSuperClasses {" empty
1366 ; let (pending_wanted, unsolved') = mapAccumBagL get [] unsolved
1367 get acc ct | Just ct' <- isPendingScDict ct
1368 = (ct':acc, ct')
1369 | otherwise
1370 = (acc, ct)
1371 ; pending_given <- getPendingScDicts
1372 ; if null pending_given && null pending_wanted
1373 then do { traceTcS "End expandSuperClasses no-op }" empty
1374 ; return (True, unsolved) }
1375 else
1376 do { new_given <- makeSuperClasses pending_given
1377 ; solveSimpleGivens new_given
1378 ; new_wanted <- makeSuperClasses pending_wanted
1379 ; traceTcS "End expandSuperClasses }"
1380 (vcat [ text "Given:" <+> ppr pending_given
1381 , text "Wanted:" <+> ppr new_wanted ])
1382 ; return (False, unsolved' `unionBags` listToBag new_wanted) } }
1383
1384 solveNestedImplications :: Bag Implication
1385 -> TcS (Cts, Bag Implication)
1386 -- Precondition: the TcS inerts may contain unsolved simples which have
1387 -- to be converted to givens before we go inside a nested implication.
1388 solveNestedImplications implics
1389 | isEmptyBag implics
1390 = return (emptyBag, emptyBag)
1391 | otherwise
1392 = do { traceTcS "solveNestedImplications starting {" empty
1393 ; (floated_eqs_s, unsolved_implics) <- mapAndUnzipBagM solveImplication implics
1394 ; let floated_eqs = concatBag floated_eqs_s
1395
1396 -- ... and we are back in the original TcS inerts
1397 -- Notice that the original includes the _insoluble_simples so it was safe to ignore
1398 -- them in the beginning of this function.
1399 ; traceTcS "solveNestedImplications end }" $
1400 vcat [ text "all floated_eqs =" <+> ppr floated_eqs
1401 , text "unsolved_implics =" <+> ppr unsolved_implics ]
1402
1403 ; return (floated_eqs, catBagMaybes unsolved_implics) }
1404
1405 solveImplication :: Implication -- Wanted
1406 -> TcS (Cts, -- All wanted or derived floated equalities: var = type
1407 Maybe Implication) -- Simplified implication (empty or singleton)
1408 -- Precondition: The TcS monad contains an empty worklist and given-only inerts
1409 -- which after trying to solve this implication we must restore to their original value
1410 solveImplication imp@(Implic { ic_tclvl = tclvl
1411 , ic_binds = ev_binds_var
1412 , ic_skols = skols
1413 , ic_given = given_ids
1414 , ic_wanted = wanteds
1415 , ic_info = info
1416 , ic_status = status
1417 , ic_env = env })
1418 | isSolvedStatus status
1419 = return (emptyCts, Just imp) -- Do nothing
1420
1421 | otherwise -- Even for IC_Insoluble it is worth doing more work
1422 -- The insoluble stuff might be in one sub-implication
1423 -- and other unsolved goals in another; and we want to
1424 -- solve the latter as much as possible
1425 = do { inerts <- getTcSInerts
1426 ; traceTcS "solveImplication {" (ppr imp $$ text "Inerts" <+> ppr inerts)
1427
1428 -- Solve the nested constraints
1429 ; (no_given_eqs, given_insols, residual_wanted)
1430 <- nestImplicTcS ev_binds_var tclvl $
1431 do { let loc = mkGivenLoc tclvl info env
1432 givens = mkGivens loc given_ids
1433 ; solveSimpleGivens givens
1434
1435 ; residual_wanted <- solveWanteds wanteds
1436 -- solveWanteds, *not* solveWantedsAndDrop, because
1437 -- we want to retain derived equalities so we can float
1438 -- them out in floatEqualities
1439
1440 ; (no_eqs, given_insols) <- getNoGivenEqs tclvl skols
1441 -- Call getNoGivenEqs /after/ solveWanteds, because
1442 -- solveWanteds can augment the givens, via expandSuperClasses,
1443 -- to reveal given superclass equalities
1444
1445 ; return (no_eqs, given_insols, residual_wanted) }
1446
1447 ; (floated_eqs, residual_wanted)
1448 <- floatEqualities skols no_given_eqs residual_wanted
1449
1450 ; traceTcS "solveImplication 2"
1451 (ppr given_insols $$ ppr residual_wanted)
1452 ; let final_wanted = residual_wanted `addInsols` given_insols
1453
1454 ; res_implic <- setImplicationStatus (imp { ic_no_eqs = no_given_eqs
1455 , ic_wanted = final_wanted })
1456
1457 ; (evbinds, tcvs) <- TcS.getTcEvBindsAndTCVs ev_binds_var
1458 ; traceTcS "solveImplication end }" $ vcat
1459 [ text "no_given_eqs =" <+> ppr no_given_eqs
1460 , text "floated_eqs =" <+> ppr floated_eqs
1461 , text "res_implic =" <+> ppr res_implic
1462 , text "implication evbinds =" <+> ppr (evBindMapBinds evbinds)
1463 , text "implication tvcs =" <+> ppr tcvs ]
1464
1465 ; return (floated_eqs, res_implic) }
1466
1467 ----------------------
1468 setImplicationStatus :: Implication -> TcS (Maybe Implication)
1469 -- Finalise the implication returned from solveImplication:
1470 -- * Set the ic_status field
1471 -- * Trim the ic_wanted field to remove Derived constraints
1472 -- Precondition: the ic_status field is not already IC_Solved
1473 -- Return Nothing if we can discard the implication altogether
1474 setImplicationStatus implic@(Implic { ic_binds = ev_binds_var
1475 , ic_status = status
1476 , ic_info = info
1477 , ic_wanted = wc
1478 , ic_needed = old_discarded_needs
1479 , ic_given = givens })
1480 | ASSERT2( not (isSolvedStatus status ), ppr info )
1481 -- Precondition: we only set the status if it is not already solved
1482 some_insoluble
1483 = return $ Just $
1484 implic { ic_status = IC_Insoluble
1485 , ic_needed = new_discarded_needs
1486 , ic_wanted = pruned_wc }
1487
1488 | some_unsolved
1489 = do { traceTcS "setImplicationStatus" $
1490 vcat [ppr givens $$ ppr simples $$ ppr insols $$ ppr mb_implic_needs]
1491 ; return $ Just $
1492 implic { ic_status = IC_Unsolved
1493 , ic_needed = new_discarded_needs
1494 , ic_wanted = pruned_wc }
1495 }
1496
1497 | otherwise -- Everything is solved; look at the implications
1498 -- See Note [Tracking redundant constraints]
1499 = do { ev_binds <- TcS.getTcEvBindsAndTCVs ev_binds_var
1500 ; let all_needs = neededEvVars ev_binds $
1501 solved_implic_needs `unionVarSet` new_discarded_needs
1502
1503 dead_givens | warnRedundantGivens info
1504 = filterOut (`elemVarSet` all_needs) givens
1505 | otherwise = [] -- None to report
1506
1507 final_needs = all_needs `delVarSetList` givens
1508
1509 discard_entire_implication -- Can we discard the entire implication?
1510 = null dead_givens -- No warning from this implication
1511 && isEmptyBag pruned_implics -- No live children
1512 && isEmptyVarSet final_needs -- No needed vars to pass up to parent
1513
1514 final_status = IC_Solved { ics_need = final_needs
1515 , ics_dead = dead_givens }
1516 final_implic = implic { ic_status = final_status
1517 , ic_needed = emptyVarSet -- Irrelevant for IC_Solved
1518 , ic_wanted = pruned_wc }
1519
1520 -- Check that there are no term-level evidence bindings
1521 -- in the cases where we have no place to put them
1522 ; MASSERT2( termEvidenceAllowed info || isEmptyEvBindMap (fst ev_binds)
1523 , ppr info $$ ppr ev_binds )
1524
1525 ; traceTcS "setImplicationStatus 2" $
1526 vcat [ppr givens $$ ppr ev_binds $$ ppr all_needs]
1527 ; return $ if discard_entire_implication
1528 then Nothing
1529 else Just final_implic }
1530 where
1531 WC { wc_simple = simples, wc_impl = implics, wc_insol = insols } = wc
1532
1533 some_insoluble = insolubleWC wc
1534 some_unsolved = not (isEmptyBag simples && isEmptyBag insols)
1535 || isNothing mb_implic_needs
1536
1537 pruned_simples = dropDerivedSimples simples
1538 pruned_insols = dropDerivedInsols insols
1539 (pruned_implics, discarded_needs) = partitionBagWith discard_me implics
1540 pruned_wc = wc { wc_simple = pruned_simples
1541 , wc_insol = pruned_insols
1542 , wc_impl = pruned_implics }
1543 new_discarded_needs = foldrBag unionVarSet old_discarded_needs discarded_needs
1544
1545 mb_implic_needs :: Maybe VarSet
1546 -- Just vs => all implics are IC_Solved, with 'vs' needed
1547 -- Nothing => at least one implic is not IC_Solved
1548 mb_implic_needs = foldrBag add_implic (Just emptyVarSet) pruned_implics
1549 Just solved_implic_needs = mb_implic_needs
1550
1551 add_implic implic acc
1552 | Just vs_acc <- acc
1553 , IC_Solved { ics_need = vs } <- ic_status implic
1554 = Just (vs `unionVarSet` vs_acc)
1555 | otherwise = Nothing
1556
1557 discard_me :: Implication -> Either Implication VarSet
1558 discard_me ic
1559 | IC_Solved { ics_dead = dead_givens, ics_need = needed } <- ic_status ic
1560 -- Fully solved
1561 , null dead_givens -- No redundant givens to report
1562 , isEmptyBag (wc_impl (ic_wanted ic))
1563 -- And no children that might have things to report
1564 = Right needed
1565 | otherwise
1566 = Left ic
1567
1568 warnRedundantGivens :: SkolemInfo -> Bool
1569 warnRedundantGivens (SigSkol ctxt _ _)
1570 = case ctxt of
1571 FunSigCtxt _ warn_redundant -> warn_redundant
1572 ExprSigCtxt -> True
1573 _ -> False
1574
1575 -- To think about: do we want to report redundant givens for
1576 -- pattern synonyms, PatSynSigSkol? c.f Trac #9953, comment:21.
1577 warnRedundantGivens (InstSkol {}) = True
1578 warnRedundantGivens _ = False
1579
1580 neededEvVars :: (EvBindMap, TcTyVarSet) -> VarSet -> VarSet
1581 -- Find all the evidence variables that are "needed",
1582 -- and then delete all those bound by the evidence bindings
1583 -- See Note [Tracking redundant constraints]
1584 --
1585 -- - Start from initial_seeds (from nested implications)
1586 -- - Add free vars of RHS of all Wanted evidence bindings
1587 -- and coercion variables accumulated in tcvs (all Wanted)
1588 -- - Do transitive closure through Given bindings
1589 -- e.g. Neede {a,b}
1590 -- Given a = sc_sel a2
1591 -- Then a2 is needed too
1592 -- - Finally delete all the binders of the evidence bindings
1593 --
1594 neededEvVars (ev_binds, tcvs) initial_seeds
1595 = needed `minusVarSet` bndrs
1596 where
1597 needed = transCloVarSet also_needs seeds
1598 seeds = foldEvBindMap add_wanted initial_seeds ev_binds
1599 `unionVarSet` tcvs
1600 bndrs = foldEvBindMap add_bndr emptyVarSet ev_binds
1601
1602 add_wanted :: EvBind -> VarSet -> VarSet
1603 add_wanted (EvBind { eb_is_given = is_given, eb_rhs = rhs }) needs
1604 | is_given = needs -- Add the rhs vars of the Wanted bindings only
1605 | otherwise = evVarsOfTerm rhs `unionVarSet` needs
1606
1607 also_needs :: VarSet -> VarSet
1608 also_needs needs
1609 = nonDetFoldUniqSet add emptyVarSet needs
1610 -- It's OK to use nonDetFoldUFM here because we immediately forget
1611 -- about the ordering by creating a set
1612 where
1613 add v needs
1614 | Just ev_bind <- lookupEvBind ev_binds v
1615 , EvBind { eb_is_given = is_given, eb_rhs = rhs } <- ev_bind
1616 , is_given
1617 = evVarsOfTerm rhs `unionVarSet` needs
1618 | otherwise
1619 = needs
1620
1621 add_bndr :: EvBind -> VarSet -> VarSet
1622 add_bndr (EvBind { eb_lhs = v }) vs = extendVarSet vs v
1623
1624
1625 {-
1626 Note [Tracking redundant constraints]
1627 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1628 With Opt_WarnRedundantConstraints, GHC can report which
1629 constraints of a type signature (or instance declaration) are
1630 redundant, and can be omitted. Here is an overview of how it
1631 works:
1632
1633 ----- What is a redundant constraint?
1634
1635 * The things that can be redundant are precisely the Given
1636 constraints of an implication.
1637
1638 * A constraint can be redundant in two different ways:
1639 a) It is implied by other givens. E.g.
1640 f :: (Eq a, Ord a) => blah -- Eq a unnecessary
1641 g :: (Eq a, a~b, Eq b) => blah -- Either Eq a or Eq b unnecessary
1642 b) It is not needed by the Wanted constraints covered by the
1643 implication E.g.
1644 f :: Eq a => a -> Bool
1645 f x = True -- Equality not used
1646
1647 * To find (a), when we have two Given constraints,
1648 we must be careful to drop the one that is a naked variable (if poss).
1649 So if we have
1650 f :: (Eq a, Ord a) => blah
1651 then we may find [G] sc_sel (d1::Ord a) :: Eq a
1652 [G] d2 :: Eq a
1653 We want to discard d2 in favour of the superclass selection from
1654 the Ord dictionary. This is done by TcInteract.solveOneFromTheOther
1655 See Note [Replacement vs keeping].
1656
1657 * To find (b) we need to know which evidence bindings are 'wanted';
1658 hence the eb_is_given field on an EvBind.
1659
1660 ----- How tracking works
1661
1662 * When the constraint solver finishes solving all the wanteds in
1663 an implication, it sets its status to IC_Solved
1664
1665 - The ics_dead field, of IC_Solved, records the subset of this
1666 implication's ic_given that are redundant (not needed).
1667
1668 - The ics_need field of IC_Solved then records all the
1669 in-scope (given) evidence variables bound by the context, that
1670 were needed to solve this implication, including all its nested
1671 implications. (We remove the ic_given of this implication from
1672 the set, of course.)
1673
1674 * We compute which evidence variables are needed by an implication
1675 in setImplicationStatus. A variable is needed if
1676 a) it is free in the RHS of a Wanted EvBind,
1677 b) it is free in the RHS of an EvBind whose LHS is needed,
1678 c) it is in the ics_need of a nested implication.
1679
1680 * We need to be careful not to discard an implication
1681 prematurely, even one that is fully solved, because we might
1682 thereby forget which variables it needs, and hence wrongly
1683 report a constraint as redundant. But we can discard it once
1684 its free vars have been incorporated into its parent; or if it
1685 simply has no free vars. This careful discarding is also
1686 handled in setImplicationStatus.
1687
1688 ----- Reporting redundant constraints
1689
1690 * TcErrors does the actual warning, in warnRedundantConstraints.
1691
1692 * We don't report redundant givens for *every* implication; only
1693 for those which reply True to TcSimplify.warnRedundantGivens:
1694
1695 - For example, in a class declaration, the default method *can*
1696 use the class constraint, but it certainly doesn't *have* to,
1697 and we don't want to report an error there.
1698
1699 - More subtly, in a function definition
1700 f :: (Ord a, Ord a, Ix a) => a -> a
1701 f x = rhs
1702 we do an ambiguity check on the type (which would find that one
1703 of the Ord a constraints was redundant), and then we check that
1704 the definition has that type (which might find that both are
1705 redundant). We don't want to report the same error twice, so we
1706 disable it for the ambiguity check. Hence using two different
1707 FunSigCtxts, one with the warn-redundant field set True, and the
1708 other set False in
1709 - TcBinds.tcSpecPrag
1710 - TcBinds.tcTySig
1711
1712 This decision is taken in setImplicationStatus, rather than TcErrors
1713 so that we can discard implication constraints that we don't need.
1714 So ics_dead consists only of the *reportable* redundant givens.
1715
1716 ----- Shortcomings
1717
1718 Consider (see Trac #9939)
1719 f2 :: (Eq a, Ord a) => a -> a -> Bool
1720 -- Ord a redundant, but Eq a is reported
1721 f2 x y = (x == y)
1722
1723 We report (Eq a) as redundant, whereas actually (Ord a) is. But it's
1724 really not easy to detect that!
1725
1726
1727 Note [Cutting off simpl_loop]
1728 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1729 It is very important not to iterate in simpl_loop unless there is a chance
1730 of progress. Trac #8474 is a classic example:
1731
1732 * There's a deeply-nested chain of implication constraints.
1733 ?x:alpha => ?y1:beta1 => ... ?yn:betan => [W] ?x:Int
1734
1735 * From the innermost one we get a [D] alpha ~ Int,
1736 but alpha is untouchable until we get out to the outermost one
1737
1738 * We float [D] alpha~Int out (it is in floated_eqs), but since alpha
1739 is untouchable, the solveInteract in simpl_loop makes no progress
1740
1741 * So there is no point in attempting to re-solve
1742 ?yn:betan => [W] ?x:Int
1743 via solveNestedImplications, because we'll just get the
1744 same [D] again
1745
1746 * If we *do* re-solve, we'll get an ininite loop. It is cut off by
1747 the fixed bound of 10, but solving the next takes 10*10*...*10 (ie
1748 exponentially many) iterations!
1749
1750 Conclusion: we should call solveNestedImplications only if we did
1751 some unification in solveSimpleWanteds; because that's the only way
1752 we'll get more Givens (a unification is like adding a Given) to
1753 allow the implication to make progress.
1754 -}
1755
1756 promoteTyVar :: TcLevel -> TcTyVar -> TcM Bool
1757 -- When we float a constraint out of an implication we must restore
1758 -- invariant (MetaTvInv) in Note [TcLevel and untouchable type variables] in TcType
1759 -- Return True <=> we did some promotion
1760 -- See Note [Promoting unification variables]
1761 promoteTyVar tclvl tv
1762 | isFloatedTouchableMetaTyVar tclvl tv
1763 = do { cloned_tv <- TcM.cloneMetaTyVar tv
1764 ; let rhs_tv = setMetaTyVarTcLevel cloned_tv tclvl
1765 ; TcM.writeMetaTyVar tv (mkTyVarTy rhs_tv)
1766 ; return True }
1767 | otherwise
1768 = return False
1769
1770 promoteTyVarTcS :: TcLevel -> TcTyVar -> TcS ()
1771 -- When we float a constraint out of an implication we must restore
1772 -- invariant (MetaTvInv) in Note [TcLevel and untouchable type variables] in TcType
1773 -- See Note [Promoting unification variables]
1774 -- We don't just call promoteTyVar because we want to use unifyTyVar,
1775 -- not writeMetaTyVar
1776 promoteTyVarTcS tclvl tv
1777 | isFloatedTouchableMetaTyVar tclvl tv
1778 = do { cloned_tv <- TcS.cloneMetaTyVar tv
1779 ; let rhs_tv = setMetaTyVarTcLevel cloned_tv tclvl
1780 ; unifyTyVar tv (mkTyVarTy rhs_tv) }
1781 | otherwise
1782 = return ()
1783
1784 -- | Like 'defaultTyVar', but in the TcS monad.
1785 defaultTyVarTcS :: TcTyVar -> TcS Bool
1786 defaultTyVarTcS the_tv
1787 | isRuntimeRepVar the_tv
1788 = do { traceTcS "defaultTyVarTcS RuntimeRep" (ppr the_tv)
1789 ; unifyTyVar the_tv liftedRepTy
1790 ; return True }
1791 | otherwise
1792 = return False -- the common case
1793
1794 approximateWC :: Bool -> WantedConstraints -> Cts
1795 -- Postcondition: Wanted or Derived Cts
1796 -- See Note [ApproximateWC]
1797 approximateWC float_past_equalities wc
1798 = float_wc emptyVarSet wc
1799 where
1800 float_wc :: TcTyCoVarSet -> WantedConstraints -> Cts
1801 float_wc trapping_tvs (WC { wc_simple = simples, wc_impl = implics })
1802 = filterBag is_floatable simples `unionBags`
1803 do_bag (float_implic trapping_tvs) implics
1804 where
1805 is_floatable ct = tyCoVarsOfCt ct `disjointVarSet` trapping_tvs
1806
1807 float_implic :: TcTyCoVarSet -> Implication -> Cts
1808 float_implic trapping_tvs imp
1809 | float_past_equalities || ic_no_eqs imp
1810 = float_wc new_trapping_tvs (ic_wanted imp)
1811 | otherwise -- Take care with equalities
1812 = emptyCts -- See (1) under Note [ApproximateWC]
1813 where
1814 new_trapping_tvs = trapping_tvs `extendVarSetList` ic_skols imp
1815 do_bag :: (a -> Bag c) -> Bag a -> Bag c
1816 do_bag f = foldrBag (unionBags.f) emptyBag
1817
1818 {- Note [ApproximateWC]
1819 ~~~~~~~~~~~~~~~~~~~~~~~
1820 approximateWC takes a constraint, typically arising from the RHS of a
1821 let-binding whose type we are *inferring*, and extracts from it some
1822 *simple* constraints that we might plausibly abstract over. Of course
1823 the top-level simple constraints are plausible, but we also float constraints
1824 out from inside, if they are not captured by skolems.
1825
1826 The same function is used when doing type-class defaulting (see the call
1827 to applyDefaultingRules) to extract constraints that that might be defaulted.
1828
1829 There is one caveat:
1830
1831 1. When infering most-general types (in simplifyInfer), we do *not*
1832 float anything out if the implication binds equality constraints,
1833 because that defeats the OutsideIn story. Consider
1834 data T a where
1835 TInt :: T Int
1836 MkT :: T a
1837
1838 f TInt = 3::Int
1839
1840 We get the implication (a ~ Int => res ~ Int), where so far we've decided
1841 f :: T a -> res
1842 We don't want to float (res~Int) out because then we'll infer
1843 f :: T a -> Int
1844 which is only on of the possible types. (GHC 7.6 accidentally *did*
1845 float out of such implications, which meant it would happily infer
1846 non-principal types.)
1847
1848 HOWEVER (Trac #12797) in findDefaultableGroups we are not worried about
1849 the most-general type; and we /do/ want to float out of equalities.
1850 Hence the boolean flag to approximateWC.
1851
1852 ------ Historical note -----------
1853 There used to be a second caveat, driven by Trac #8155
1854
1855 2. We do not float out an inner constraint that shares a type variable
1856 (transitively) with one that is trapped by a skolem. Eg
1857 forall a. F a ~ beta, Integral beta
1858 We don't want to float out (Integral beta). Doing so would be bad
1859 when defaulting, because then we'll default beta:=Integer, and that
1860 makes the error message much worse; we'd get
1861 Can't solve F a ~ Integer
1862 rather than
1863 Can't solve Integral (F a)
1864
1865 Moreover, floating out these "contaminated" constraints doesn't help
1866 when generalising either. If we generalise over (Integral b), we still
1867 can't solve the retained implication (forall a. F a ~ b). Indeed,
1868 arguably that too would be a harder error to understand.
1869
1870 But this transitive closure stuff gives rise to a complex rule for
1871 when defaulting actually happens, and one that was never documented.
1872 Moreover (Trac #12923), the more complex rule is sometimes NOT what
1873 you want. So I simply removed the extra code to implement the
1874 contamination stuff. There was zero effect on the testsuite (not even
1875 #8155).
1876 ------ End of historical note -----------
1877
1878
1879 Note [DefaultTyVar]
1880 ~~~~~~~~~~~~~~~~~~~
1881 defaultTyVar is used on any un-instantiated meta type variables to
1882 default any RuntimeRep variables to LiftedRep. This is important
1883 to ensure that instance declarations match. For example consider
1884
1885 instance Show (a->b)
1886 foo x = show (\_ -> True)
1887
1888 Then we'll get a constraint (Show (p ->q)) where p has kind (TYPE r),
1889 and that won't match the typeKind (*) in the instance decl. See tests
1890 tc217 and tc175.
1891
1892 We look only at touchable type variables. No further constraints
1893 are going to affect these type variables, so it's time to do it by
1894 hand. However we aren't ready to default them fully to () or
1895 whatever, because the type-class defaulting rules have yet to run.
1896
1897 An alternate implementation would be to emit a derived constraint setting
1898 the RuntimeRep variable to LiftedRep, but this seems unnecessarily indirect.
1899
1900 Note [Promote _and_ default when inferring]
1901 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1902 When we are inferring a type, we simplify the constraint, and then use
1903 approximateWC to produce a list of candidate constraints. Then we MUST
1904
1905 a) Promote any meta-tyvars that have been floated out by
1906 approximateWC, to restore invariant (MetaTvInv) described in
1907 Note [TcLevel and untouchable type variables] in TcType.
1908
1909 b) Default the kind of any meta-tyvars that are not mentioned in
1910 in the environment.
1911
1912 To see (b), suppose the constraint is (C ((a :: OpenKind) -> Int)), and we
1913 have an instance (C ((x:*) -> Int)). The instance doesn't match -- but it
1914 should! If we don't solve the constraint, we'll stupidly quantify over
1915 (C (a->Int)) and, worse, in doing so zonkQuantifiedTyVar will quantify over
1916 (b:*) instead of (a:OpenKind), which can lead to disaster; see Trac #7332.
1917 Trac #7641 is a simpler example.
1918
1919 Note [Promoting unification variables]
1920 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1921 When we float an equality out of an implication we must "promote" free
1922 unification variables of the equality, in order to maintain Invariant
1923 (MetaTvInv) from Note [TcLevel and untouchable type variables] in TcType. for the
1924 leftover implication.
1925
1926 This is absolutely necessary. Consider the following example. We start
1927 with two implications and a class with a functional dependency.
1928
1929 class C x y | x -> y
1930 instance C [a] [a]
1931
1932 (I1) [untch=beta]forall b. 0 => F Int ~ [beta]
1933 (I2) [untch=beta]forall c. 0 => F Int ~ [[alpha]] /\ C beta [c]
1934
1935 We float (F Int ~ [beta]) out of I1, and we float (F Int ~ [[alpha]]) out of I2.
1936 They may react to yield that (beta := [alpha]) which can then be pushed inwards
1937 the leftover of I2 to get (C [alpha] [a]) which, using the FunDep, will mean that
1938 (alpha := a). In the end we will have the skolem 'b' escaping in the untouchable
1939 beta! Concrete example is in indexed_types/should_fail/ExtraTcsUntch.hs:
1940
1941 class C x y | x -> y where
1942 op :: x -> y -> ()
1943
1944 instance C [a] [a]
1945
1946 type family F a :: *
1947
1948 h :: F Int -> ()
1949 h = undefined
1950
1951 data TEx where
1952 TEx :: a -> TEx
1953
1954 f (x::beta) =
1955 let g1 :: forall b. b -> ()
1956 g1 _ = h [x]
1957 g2 z = case z of TEx y -> (h [[undefined]], op x [y])
1958 in (g1 '3', g2 undefined)
1959
1960
1961
1962 *********************************************************************************
1963 * *
1964 * Floating equalities *
1965 * *
1966 *********************************************************************************
1967
1968 Note [Float Equalities out of Implications]
1969 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1970 For ordinary pattern matches (including existentials) we float
1971 equalities out of implications, for instance:
1972 data T where
1973 MkT :: Eq a => a -> T
1974 f x y = case x of MkT _ -> (y::Int)
1975 We get the implication constraint (x::T) (y::alpha):
1976 forall a. [untouchable=alpha] Eq a => alpha ~ Int
1977 We want to float out the equality into a scope where alpha is no
1978 longer untouchable, to solve the implication!
1979
1980 But we cannot float equalities out of implications whose givens may
1981 yield or contain equalities:
1982
1983 data T a where
1984 T1 :: T Int
1985 T2 :: T Bool
1986 T3 :: T a
1987
1988 h :: T a -> a -> Int
1989
1990 f x y = case x of
1991 T1 -> y::Int
1992 T2 -> y::Bool
1993 T3 -> h x y
1994
1995 We generate constraint, for (x::T alpha) and (y :: beta):
1996 [untouchables = beta] (alpha ~ Int => beta ~ Int) -- From 1st branch
1997 [untouchables = beta] (alpha ~ Bool => beta ~ Bool) -- From 2nd branch
1998 (alpha ~ beta) -- From 3rd branch
1999
2000 If we float the equality (beta ~ Int) outside of the first implication and
2001 the equality (beta ~ Bool) out of the second we get an insoluble constraint.
2002 But if we just leave them inside the implications, we unify alpha := beta and
2003 solve everything.
2004
2005 Principle:
2006 We do not want to float equalities out which may
2007 need the given *evidence* to become soluble.
2008
2009 Consequence: classes with functional dependencies don't matter (since there is
2010 no evidence for a fundep equality), but equality superclasses do matter (since
2011 they carry evidence).
2012 -}
2013
2014 floatEqualities :: [TcTyVar] -> Bool
2015 -> WantedConstraints
2016 -> TcS (Cts, WantedConstraints)
2017 -- Main idea: see Note [Float Equalities out of Implications]
2018 --
2019 -- Precondition: the wc_simple of the incoming WantedConstraints are
2020 -- fully zonked, so that we can see their free variables
2021 --
2022 -- Postcondition: The returned floated constraints (Cts) are only
2023 -- Wanted or Derived
2024 --
2025 -- Also performs some unifications (via promoteTyVar), adding to
2026 -- monadically-carried ty_binds. These will be used when processing
2027 -- floated_eqs later
2028 --
2029 -- Subtleties: Note [Float equalities from under a skolem binding]
2030 -- Note [Skolem escape]
2031 floatEqualities skols no_given_eqs
2032 wanteds@(WC { wc_simple = simples })
2033 | not no_given_eqs -- There are some given equalities, so don't float
2034 = return (emptyBag, wanteds) -- Note [Float Equalities out of Implications]
2035
2036 | otherwise
2037 = do { -- First zonk: the inert set (from whence they came) is fully
2038 -- zonked, but unflattening may have filled in unification
2039 -- variables, and we /must/ see them. Otherwise we may float
2040 -- constraints that mention the skolems!
2041 simples <- TcS.zonkSimples simples
2042
2043 -- Now we can pick the ones to float
2044 ; let (float_eqs, remaining_simples) = partitionBag (usefulToFloat skol_set) simples
2045 skol_set = mkVarSet skols
2046
2047 -- Promote any unification variables mentioned in the floated equalities
2048 -- See Note [Promoting unification variables]
2049 ; outer_tclvl <- TcS.getTcLevel
2050 ; mapM_ (promoteTyVarTcS outer_tclvl)
2051 (tyCoVarsOfCtsList float_eqs)
2052
2053 ; traceTcS "floatEqualities" (vcat [ text "Skols =" <+> ppr skols
2054 , text "Simples =" <+> ppr simples
2055 , text "Floated eqs =" <+> ppr float_eqs])
2056 ; return ( float_eqs
2057 , wanteds { wc_simple = remaining_simples } ) }
2058
2059 usefulToFloat :: VarSet -- ^ the skolems in the implication
2060 -> Ct -> Bool
2061 usefulToFloat skol_set ct -- The constraint is un-flattened and de-canonicalised
2062 = is_meta_var_eq pred &&
2063 (tyCoVarsOfType pred `disjointVarSet` skol_set)
2064 where
2065 pred = ctPred ct
2066
2067 -- Float out alpha ~ ty, or ty ~ alpha
2068 -- which might be unified outside
2069 -- See Note [Which equalities to float]
2070 is_meta_var_eq pred
2071 | EqPred NomEq ty1 ty2 <- classifyPredType pred
2072 , is_homogeneous ty1 ty2
2073 = case (tcGetTyVar_maybe ty1, tcGetTyVar_maybe ty2) of
2074 (Just tv1, _) -> float_tv_eq tv1 ty2
2075 (_, Just tv2) -> float_tv_eq tv2 ty1
2076 _ -> False
2077 | otherwise
2078 = False
2079
2080 float_tv_eq tv1 ty2 -- See Note [Which equalities to float]
2081 = isMetaTyVar tv1
2082 && (not (isSigTyVar tv1) || isTyVarTy ty2)
2083
2084 is_homogeneous ty1 ty2
2085 = not has_heterogeneous_form || -- checking the shape is quicker
2086 -- than looking at kinds
2087 typeKind ty1 `tcEqType` typeKind ty2
2088
2089 has_heterogeneous_form = case ct of
2090 CIrredEvCan {} -> True
2091 CNonCanonical {} -> True
2092 _ -> False
2093
2094
2095 {- Note [Float equalities from under a skolem binding]
2096 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2097 Which of the simple equalities can we float out? Obviously, only
2098 ones that don't mention the skolem-bound variables. But that is
2099 over-eager. Consider
2100 [2] forall a. F a beta[1] ~ gamma[2], G beta[1] gamma[2] ~ Int
2101 The second constraint doesn't mention 'a'. But if we float it,
2102 we'll promote gamma[2] to gamma'[1]. Now suppose that we learn that
2103 beta := Bool, and F a Bool = a, and G Bool _ = Int. Then we'll
2104 we left with the constraint
2105 [2] forall a. a ~ gamma'[1]
2106 which is insoluble because gamma became untouchable.
2107
2108 Solution: float only constraints that stand a jolly good chance of
2109 being soluble simply by being floated, namely ones of form
2110 a ~ ty
2111 where 'a' is a currently-untouchable unification variable, but may
2112 become touchable by being floated (perhaps by more than one level).
2113
2114 We had a very complicated rule previously, but this is nice and
2115 simple. (To see the notes, look at this Note in a version of
2116 TcSimplify prior to Oct 2014).
2117
2118 Note [Which equalities to float]
2119 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2120 Which equalities should we float? We want to float ones where there
2121 is a decent chance that floating outwards will allow unification to
2122 happen. In particular:
2123
2124 Float out homogeneous equalities of form (alpha ~ ty) or (ty ~ alpha), where
2125
2126 * alpha is a meta-tyvar.
2127
2128 * And 'alpha' is not a SigTv with 'ty' being a non-tyvar. In that
2129 case, floating out won't help either, and it may affect grouping
2130 of error messages.
2131
2132 Why homogeneous (i.e., the kinds of the types are the same)? Because heterogeneous
2133 equalities have derived kind equalities. See Note [Equalities with incompatible kinds]
2134 in TcCanonical. If we float out a hetero equality, then it will spit out the
2135 same derived kind equality again, which might create duplicate error messages.
2136 Instead, we do float out the kind equality (if it's worth floating out, as
2137 above). If/when we solve it, we'll be able to rewrite the original hetero equality
2138 to be homogeneous, and then perhaps make progress / float it out. The duplicate
2139 error message was spotted in typecheck/should_fail/T7368.
2140
2141 Note [Skolem escape]
2142 ~~~~~~~~~~~~~~~~~~~~
2143 You might worry about skolem escape with all this floating.
2144 For example, consider
2145 [2] forall a. (a ~ F beta[2] delta,
2146 Maybe beta[2] ~ gamma[1])
2147
2148 The (Maybe beta ~ gamma) doesn't mention 'a', so we float it, and
2149 solve with gamma := beta. But what if later delta:=Int, and
2150 F b Int = b.
2151 Then we'd get a ~ beta[2], and solve to get beta:=a, and now the
2152 skolem has escaped!
2153
2154 But it's ok: when we float (Maybe beta[2] ~ gamma[1]), we promote beta[2]
2155 to beta[1], and that means the (a ~ beta[1]) will be stuck, as it should be.
2156
2157
2158 *********************************************************************************
2159 * *
2160 * Defaulting and disambiguation *
2161 * *
2162 *********************************************************************************
2163 -}
2164
2165 applyDefaultingRules :: WantedConstraints -> TcS Bool
2166 -- True <=> I did some defaulting, by unifying a meta-tyvar
2167 -- Input WantedConstraints are not necessarily zonked
2168
2169 applyDefaultingRules wanteds
2170 | isEmptyWC wanteds
2171 = return False
2172 | otherwise
2173 = do { info@(default_tys, _) <- getDefaultInfo
2174 ; wanteds <- TcS.zonkWC wanteds
2175
2176 ; let groups = findDefaultableGroups info wanteds
2177
2178 ; traceTcS "applyDefaultingRules {" $
2179 vcat [ text "wanteds =" <+> ppr wanteds
2180 , text "groups =" <+> ppr groups
2181 , text "info =" <+> ppr info ]
2182
2183 ; something_happeneds <- mapM (disambigGroup default_tys) groups
2184
2185 ; traceTcS "applyDefaultingRules }" (ppr something_happeneds)
2186
2187 ; return (or something_happeneds) }
2188
2189 findDefaultableGroups
2190 :: ( [Type]
2191 , (Bool,Bool) ) -- (Overloaded strings, extended default rules)
2192 -> WantedConstraints -- Unsolved (wanted or derived)
2193 -> [(TyVar, [Ct])]
2194 findDefaultableGroups (default_tys, (ovl_strings, extended_defaults)) wanteds
2195 | null default_tys
2196 = []
2197 | otherwise
2198 = [ (tv, map fstOf3 group)
2199 | group'@((_,_,tv) :| _) <- unary_groups
2200 , let group = toList group'
2201 , defaultable_tyvar tv
2202 , defaultable_classes (map sndOf3 group) ]
2203 where
2204 simples = approximateWC True wanteds
2205 (unaries, non_unaries) = partitionWith find_unary (bagToList simples)
2206 unary_groups = equivClasses cmp_tv unaries
2207
2208 unary_groups :: [NonEmpty (Ct, Class, TcTyVar)] -- (C tv) constraints
2209 unaries :: [(Ct, Class, TcTyVar)] -- (C tv) constraints
2210 non_unaries :: [Ct] -- and *other* constraints
2211
2212 -- Finds unary type-class constraints
2213 -- But take account of polykinded classes like Typeable,
2214 -- which may look like (Typeable * (a:*)) (Trac #8931)
2215 find_unary :: Ct -> Either (Ct, Class, TyVar) Ct
2216 find_unary cc
2217 | Just (cls,tys) <- getClassPredTys_maybe (ctPred cc)
2218 , [ty] <- filterOutInvisibleTypes (classTyCon cls) tys
2219 -- Ignore invisible arguments for this purpose
2220 , Just tv <- tcGetTyVar_maybe ty
2221 , isMetaTyVar tv -- We might have runtime-skolems in GHCi, and
2222 -- we definitely don't want to try to assign to those!
2223 = Left (cc, cls, tv)
2224 find_unary cc = Right cc -- Non unary or non dictionary
2225
2226 bad_tvs :: TcTyCoVarSet -- TyVars mentioned by non-unaries
2227 bad_tvs = mapUnionVarSet tyCoVarsOfCt non_unaries
2228
2229 cmp_tv (_,_,tv1) (_,_,tv2) = tv1 `compare` tv2
2230
2231 defaultable_tyvar :: TcTyVar -> Bool
2232 defaultable_tyvar tv
2233 = let b1 = isTyConableTyVar tv -- Note [Avoiding spurious errors]
2234 b2 = not (tv `elemVarSet` bad_tvs)
2235 in b1 && (b2 || extended_defaults) -- Note [Multi-parameter defaults]
2236
2237 defaultable_classes :: [Class] -> Bool
2238 defaultable_classes clss
2239 | extended_defaults = any (isInteractiveClass ovl_strings) clss
2240 | otherwise = all is_std_class clss && (any (isNumClass ovl_strings) clss)
2241
2242 -- is_std_class adds IsString to the standard numeric classes,
2243 -- when -foverloaded-strings is enabled
2244 is_std_class cls = isStandardClass cls ||
2245 (ovl_strings && (cls `hasKey` isStringClassKey))
2246
2247 ------------------------------
2248 disambigGroup :: [Type] -- The default types
2249 -> (TcTyVar, [Ct]) -- All classes of the form (C a)
2250 -- sharing same type variable
2251 -> TcS Bool -- True <=> something happened, reflected in ty_binds
2252
2253 disambigGroup [] _
2254 = return False
2255 disambigGroup (default_ty:default_tys) group@(the_tv, wanteds)
2256 = do { traceTcS "disambigGroup {" (vcat [ ppr default_ty, ppr the_tv, ppr wanteds ])
2257 ; fake_ev_binds_var <- TcS.newTcEvBinds
2258 ; tclvl <- TcS.getTcLevel
2259 ; success <- nestImplicTcS fake_ev_binds_var (pushTcLevel tclvl) try_group
2260
2261 ; if success then
2262 -- Success: record the type variable binding, and return
2263 do { unifyTyVar the_tv default_ty
2264 ; wrapWarnTcS $ warnDefaulting wanteds default_ty
2265 ; traceTcS "disambigGroup succeeded }" (ppr default_ty)
2266 ; return True }
2267 else
2268 -- Failure: try with the next type
2269 do { traceTcS "disambigGroup failed, will try other default types }"
2270 (ppr default_ty)
2271 ; disambigGroup default_tys group } }
2272 where
2273 try_group
2274 | Just subst <- mb_subst
2275 = do { lcl_env <- TcS.getLclEnv
2276 ; tc_lvl <- TcS.getTcLevel
2277 ; let loc = mkGivenLoc tc_lvl UnkSkol lcl_env
2278 ; wanted_evs <- mapM (newWantedEvVarNC loc . substTy subst . ctPred)
2279 wanteds
2280 ; fmap isEmptyWC $
2281 solveSimpleWanteds $ listToBag $
2282 map mkNonCanonical wanted_evs }
2283
2284 | otherwise
2285 = return False
2286
2287 the_ty = mkTyVarTy the_tv
2288 mb_subst = tcMatchTyKi the_ty default_ty
2289 -- Make sure the kinds match too; hence this call to tcMatchTyKi
2290 -- E.g. suppose the only constraint was (Typeable k (a::k))
2291 -- With the addition of polykinded defaulting we also want to reject
2292 -- ill-kinded defaulting attempts like (Eq []) or (Foldable Int) here.
2293
2294 -- In interactive mode, or with -XExtendedDefaultRules,
2295 -- we default Show a to Show () to avoid graututious errors on "show []"
2296 isInteractiveClass :: Bool -- -XOverloadedStrings?
2297 -> Class -> Bool
2298 isInteractiveClass ovl_strings cls
2299 = isNumClass ovl_strings cls || (classKey cls `elem` interactiveClassKeys)
2300
2301 -- isNumClass adds IsString to the standard numeric classes,
2302 -- when -foverloaded-strings is enabled
2303 isNumClass :: Bool -- -XOverloadedStrings?
2304 -> Class -> Bool
2305 isNumClass ovl_strings cls
2306 = isNumericClass cls || (ovl_strings && (cls `hasKey` isStringClassKey))
2307
2308
2309 {-
2310 Note [Avoiding spurious errors]
2311 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2312 When doing the unification for defaulting, we check for skolem
2313 type variables, and simply don't default them. For example:
2314 f = (*) -- Monomorphic
2315 g :: Num a => a -> a
2316 g x = f x x
2317 Here, we get a complaint when checking the type signature for g,
2318 that g isn't polymorphic enough; but then we get another one when
2319 dealing with the (Num a) context arising from f's definition;
2320 we try to unify a with Int (to default it), but find that it's
2321 already been unified with the rigid variable from g's type sig.
2322
2323 Note [Multi-parameter defaults]
2324 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2325 With -XExtendedDefaultRules, we default only based on single-variable
2326 constraints, but do not exclude from defaulting any type variables which also
2327 appear in multi-variable constraints. This means that the following will
2328 default properly:
2329
2330 default (Integer, Double)
2331
2332 class A b (c :: Symbol) where
2333 a :: b -> Proxy c
2334
2335 instance A Integer c where a _ = Proxy
2336
2337 main = print (a 5 :: Proxy "5")
2338
2339 Note that if we change the above instance ("instance A Integer") to
2340 "instance A Double", we get an error:
2341
2342 No instance for (A Integer "5")
2343
2344 This is because the first defaulted type (Integer) has successfully satisfied
2345 its single-parameter constraints (in this case Num).
2346 -}