TcSimplify.hs 90.6 KB
Newer Older
1
2
{-# LANGUAGE CPP #-}

3
module TcSimplify(
4
       simplifyInfer, InferMode(..),
5
       growThetaTyVars,
Simon Peyton Jones's avatar
Simon Peyton Jones committed
6
       simplifyAmbiguityCheck,
7
       simplifyDefault,
8
9
       simplifyTop, simplifyInteractive, solveEqualities,
       simplifyWantedsTcM,
10
       tcCheckSatisfiability,
11

12
13
       -- For Rules we need these
       solveWanteds, runTcSDeriveds
14
  ) where
15

16
#include "HsVersions.h"
17

18
import Bag
19
import Class         ( Class, classKey, classTyCon )
20
import DynFlags      ( WarningFlag ( Opt_WarnMonomorphism )
21
                     , WarnReason ( Reason )
22
                     , DynFlags( solverIterations ) )
23
import Inst
24
import ListSetOps
25
import Maybes
26
27
import Name
import Outputable
28
29
import PrelInfo
import PrelNames
30
31
32
import TcErrors
import TcEvidence
import TcInteract
33
import TcCanonical   ( makeSuperClasses )
34
import TcMType   as TcM
35
import TcRnMonad as TcM
36
37
38
import TcSMonad  as TcS
import TcType
import TrieMap       () -- DV: for now
39
import Type
40
import TysWiredIn    ( ptrRepLiftedTy )
Richard Eisenberg's avatar
Richard Eisenberg committed
41
import Unify         ( tcMatchTyKi )
42
43
44
import Util
import Var
import VarSet
niteria's avatar
niteria committed
45
import UniqFM
46
47
import BasicTypes    ( IntWithInf, intGtLimit )
import ErrUtils      ( emptyMessages )
48
import qualified GHC.LanguageExtensions as LangExt
49

50
import Control.Monad ( when, unless )
51
import Data.List     ( partition )
52

Austin Seipp's avatar
Austin Seipp committed
53
{-
54
*********************************************************************************
55
*                                                                               *
56
57
58
*                           External interface                                  *
*                                                                               *
*********************************************************************************
Austin Seipp's avatar
Austin Seipp committed
59
-}
60

61
62
simplifyTop :: WantedConstraints -> TcM (Bag EvBind)
-- Simplify top-level constraints
63
64
65
-- Usually these will be implications,
-- but when there is nothing to quantify we don't wrap
-- in a degenerate implication, so we do that here instead
66
simplifyTop wanteds
67
  = do { traceTc "simplifyTop {" $ text "wanted = " <+> ppr wanteds
Simon Peyton Jones's avatar
Simon Peyton Jones committed
68
69
70
71
       ; ((final_wc, unsafe_ol), binds1) <- runTcS $
            do { final_wc <- simpl_top wanteds
               ; unsafe_ol <- getSafeOverlapFailures
               ; return (final_wc, unsafe_ol) }
72
73
74
       ; traceTc "End simplifyTop }" empty

       ; traceTc "reportUnsolved {" empty
75
       ; binds2 <- reportUnsolved final_wc
76
       ; traceTc "reportUnsolved }" empty
77

78
79
80
81
       ; traceTc "reportUnsolved (unsafe overlapping) {" empty
       ; unless (isEmptyCts unsafe_ol) $ do {
           -- grab current error messages and clear, warnAllUnsolved will
           -- update error messages which we'll grab and then restore saved
82
           -- messages.
83
           ; errs_var  <- getErrsVar
84
85
           ; saved_msg <- TcM.readTcRef errs_var
           ; TcM.writeTcRef errs_var emptyMessages
86
87
88
89
90

           ; warnAllUnsolved $ WC { wc_simple = unsafe_ol
                                  , wc_insol = emptyCts
                                  , wc_impl = emptyBag }

91
92
           ; whyUnsafe <- fst <$> TcM.readTcRef errs_var
           ; TcM.writeTcRef errs_var saved_msg
93
94
95
96
           ; recordUnsafeInfer whyUnsafe
           }
       ; traceTc "reportUnsolved (unsafe overlapping) }" empty

97
98
99
       ; return (evBindMapBinds binds1 `unionBags` binds2) }

-- | Type-check a thing that emits only equality constraints, then
100
-- solve those constraints. Fails outright if there is trouble.
101
102
solveEqualities :: TcM a -> TcM a
solveEqualities thing_inside
103
104
  = checkNoErrs $  -- See Note [Fail fast on kind errors]
    do { (result, wanted) <- captureConstraints thing_inside
105
       ; traceTc "solveEqualities {" $ text "wanted = " <+> ppr wanted
Simon Peyton Jones's avatar
Simon Peyton Jones committed
106
       ; final_wc <- runTcSEqualities $ simpl_top wanted
107
108
109
110
111
112
       ; traceTc "End solveEqualities }" empty

       ; traceTc "reportAllUnsolved {" empty
       ; reportAllUnsolved final_wc
       ; traceTc "reportAllUnsolved }" empty
       ; return result }
113

Simon Peyton Jones's avatar
Simon Peyton Jones committed
114
simpl_top :: WantedConstraints -> TcS WantedConstraints
115
    -- See Note [Top-level Defaulting Plan]
116
simpl_top wanteds
117
  = do { wc_first_go <- nestTcS (solveWantedsAndDrop wanteds)
118
                            -- This is where the main work happens
Simon Peyton Jones's avatar
Simon Peyton Jones committed
119
       ; try_tyvar_defaulting wc_first_go }
120
  where
121
122
    try_tyvar_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_tyvar_defaulting wc
123
      | isEmptyWC wc
124
125
      = return wc
      | otherwise
126
127
      = do { free_tvs <- TcS.zonkTyCoVarsAndFVList (tyCoVarsOfWCList wc)
           ; let meta_tvs = filter (isTyVar <&&> isMetaTyVar) free_tvs
128
                   -- zonkTyCoVarsAndFV: the wc_first_go is not yet zonked
129
                   -- filter isMetaTyVar: we might have runtime-skolems in GHCi,
130
                   -- and we definitely don't want to try to assign to those!
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
131
                   -- the isTyVar needs to weed out coercion variables
132

133
134
135
           ; defaulted <- mapM defaultTyVarTcS meta_tvs   -- Has unification side effects
           ; if or defaulted
             then do { wc_residual <- nestTcS (solveWanteds wc)
136
                            -- See Note [Must simplify after defaulting]
137
138
                     ; try_class_defaulting wc_residual }
             else try_class_defaulting wc }     -- No defaulting took place
139

140
141
    try_class_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_class_defaulting wc
Austin Seipp's avatar
Austin Seipp committed
142
      | isEmptyWC wc
143
144
      = return wc
      | otherwise  -- See Note [When to do type-class defaulting]
145
      = do { something_happened <- applyDefaultingRules wc
146
                                   -- See Note [Top-level Defaulting Plan]
147
           ; if something_happened
148
             then do { wc_residual <- nestTcS (solveWantedsAndDrop wc)
149
                     ; try_class_defaulting wc_residual }
Simon Peyton Jones's avatar
Simon Peyton Jones committed
150
                  -- See Note [Overview of implicit CallStacks] in TcEvidence
151
152
153
154
155
156
157
158
159
160
161
             else try_callstack_defaulting wc }

    try_callstack_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_callstack_defaulting wc
      | isEmptyWC wc
      = return wc
      | otherwise
      = defaultCallStacks wc

-- | Default any remaining @CallStack@ constraints to empty @CallStack@s.
defaultCallStacks :: WantedConstraints -> TcS WantedConstraints
Simon Peyton Jones's avatar
Simon Peyton Jones committed
162
-- See Note [Overview of implicit CallStacks] in TcEvidence
163
164
165
166
167
168
169
170
171
172
defaultCallStacks wanteds
  = do simples <- handle_simples (wc_simple wanteds)
       implics <- mapBagM handle_implic (wc_impl wanteds)
       return (wanteds { wc_simple = simples, wc_impl = implics })

  where

  handle_simples simples
    = catBagMaybes <$> mapBagM defaultCallStack simples

173
174
175
176
177
178
  handle_implic implic
    = do { wanteds <- setEvBindsTcS (ic_binds implic) $
                      -- defaultCallStack sets a binding, so
                      -- we must set the correct binding group
                      defaultCallStacks (ic_wanted implic)
         ; return (implic { ic_wanted = wanteds }) }
179

180
  defaultCallStack ct
Eric Seidel's avatar
Eric Seidel committed
181
    | Just _ <- isCallStackPred (ctPred ct)
182
    = do { solveCallStack (cc_ev ct) EvCsEmpty
183
184
185
186
187
         ; return Nothing }

  defaultCallStack ct
    = return (Just ct)

188

189
190
191
192
193
{- Note [Fail fast on kind errors]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
solveEqualities is used to solve kind equalities when kind-checking
user-written types. If solving fails we should fail outright, rather
than just accumulate an error message, for two reasons:
Simon Peyton Jones's avatar
Simon Peyton Jones committed
194

195
196
197
  * A kind-bogus type signature may cause a cascade of knock-on
    errors if we let it pass

Simon Peyton Jones's avatar
Simon Peyton Jones committed
198
199
200
201
202
  * More seriously, we don't have a convenient term-level place to add
    deferred bindings for unsolved kind-equality constraints, so we
    don't build evidence bindings (by usine reportAllUnsolved). That
    means that we'll be left with with a type that has coercion holes
    in it, something like
203
204
205
206
207
208
209
           <type> |> co-hole
    where co-hole is not filled in.  Eeek!  That un-filled-in
    hole actually causes GHC to crash with "fvProv falls into a hole"
    See Trac #11563, #11520, #11516, #11399

So it's important to use 'checkNoErrs' here!

210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
Note [When to do type-class defaulting]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In GHC 7.6 and 7.8.2, we did type-class defaulting only if insolubleWC
was false, on the grounds that defaulting can't help solve insoluble
constraints.  But if we *don't* do defaulting we may report a whole
lot of errors that would be solved by defaulting; these errors are
quite spurious because fixing the single insoluble error means that
defaulting happens again, which makes all the other errors go away.
This is jolly confusing: Trac #9033.

So it seems better to always do type-class defaulting.

However, always doing defaulting does mean that we'll do it in
situations like this (Trac #5934):
   run :: (forall s. GenST s) -> Int
Austin Seipp's avatar
Austin Seipp committed
225
   run = fromInteger 0
226
227
228
We don't unify the return type of fromInteger with the given function
type, because the latter involves foralls.  So we're left with
    (Num alpha, alpha ~ (forall s. GenST s) -> Int)
Austin Seipp's avatar
Austin Seipp committed
229
230
Now we do defaulting, get alpha := Integer, and report that we can't
match Integer with (forall s. GenST s) -> Int.  That's not totally
231
232
233
234
235
236
stupid, but perhaps a little strange.

Another potential alternative would be to suppress *all* non-insoluble
errors if there are *any* insoluble errors, anywhere, but that seems
too drastic.

237
238
239
240
241
242
243
244
245
Note [Must simplify after defaulting]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We may have a deeply buried constraint
    (t:*) ~ (a:Open)
which we couldn't solve because of the kind incompatibility, and 'a' is free.
Then when we default 'a' we can solve the constraint.  And we want to do
that before starting in on type classes.  We MUST do it before reporting
errors, because it isn't an error!  Trac #7967 was due to this.

246
247
Note [Top-level Defaulting Plan]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
248
249
We have considered two design choices for where/when to apply defaulting.
   (i) Do it in SimplCheck mode only /whenever/ you try to solve some
250
       simple constraints, maybe deep inside the context of implications.
251
       This used to be the case in GHC 7.4.1.
252
   (ii) Do it in a tight loop at simplifyTop, once all other constraints have
253
254
        finished. This is the current story.

255
Option (i) had many disadvantages:
256
257
   a) Firstly, it was deep inside the actual solver.
   b) Secondly, it was dependent on the context (Infer a type signature,
258
259
      or Check a type signature, or Interactive) since we did not want
      to always start defaulting when inferring (though there is an exception to
260
      this, see Note [Default while Inferring]).
261
262
263
264
265
266
267
268
269
270
271
   c) It plainly did not work. Consider typecheck/should_compile/DfltProb2.hs:
          f :: Int -> Bool
          f x = const True (\y -> let w :: a -> a
                                      w a = const a (y+1)
                                  in w y)
      We will get an implication constraint (for beta the type of y):
               [untch=beta] forall a. 0 => Num beta
      which we really cannot default /while solving/ the implication, since beta is
      untouchable.

Instead our new defaulting story is to pull defaulting out of the solver loop and
272
go with option (ii), implemented at SimplifyTop. Namely:
273
274
     - First, have a go at solving the residual constraint of the whole
       program
275
276
     - Try to approximate it with a simple constraint
     - Figure out derived defaulting equations for that simple constraint
277
278
279
280
     - Go round the loop again if you did manage to get some equations

Now, that has to do with class defaulting. However there exists type variable /kind/
defaulting. Again this is done at the top-level and the plan is:
281
     - At the top-level, once you had a go at solving the constraint, do
Gabor Greif's avatar
Gabor Greif committed
282
       figure out /all/ the touchable unification variables of the wanted constraints.
283
284
285
     - Apply defaulting to their kinds

More details in Note [DefaultTyVar].
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328

Note [Safe Haskell Overlapping Instances]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In Safe Haskell, we apply an extra restriction to overlapping instances. The
motive is to prevent untrusted code provided by a third-party, changing the
behavior of trusted code through type-classes. This is due to the global and
implicit nature of type-classes that can hide the source of the dictionary.

Another way to state this is: if a module M compiles without importing another
module N, changing M to import N shouldn't change the behavior of M.

Overlapping instances with type-classes can violate this principle. However,
overlapping instances aren't always unsafe. They are just unsafe when the most
selected dictionary comes from untrusted code (code compiled with -XSafe) and
overlaps instances provided by other modules.

In particular, in Safe Haskell at a call site with overlapping instances, we
apply the following rule to determine if it is a 'unsafe' overlap:

 1) Most specific instance, I1, defined in an `-XSafe` compiled module.
 2) I1 is an orphan instance or a MPTC.
 3) At least one overlapped instance, Ix, is both:
    A) from a different module than I1
    B) Ix is not marked `OVERLAPPABLE`

This is a slightly involved heuristic, but captures the situation of an
imported module N changing the behavior of existing code. For example, if
condition (2) isn't violated, then the module author M must depend either on a
type-class or type defined in N.

Secondly, when should these heuristics be enforced? We enforced them when the
type-class method call site is in a module marked `-XSafe` or `-XTrustworthy`.
This allows `-XUnsafe` modules to operate without restriction, and for Safe
Haskell inferrence to infer modules with unsafe overlaps as unsafe.

One alternative design would be to also consider if an instance was imported as
a `safe` import or not and only apply the restriction to instances imported
safely. However, since instances are global and can be imported through more
than one path, this alternative doesn't work.

Note [Safe Haskell Overlapping Instances Implementation]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

329
How is this implemented? It's complicated! So we'll step through it all:
330
331

 1) `InstEnv.lookupInstEnv` -- Performs instance resolution, so this is where
Simon Peyton Jones's avatar
Simon Peyton Jones committed
332
333
334
335
    we check if a particular type-class method call is safe or unsafe. We do this
    through the return type, `ClsInstLookupResult`, where the last parameter is a
    list of instances that are unsafe to overlap. When the method call is safe,
    the list is null.
336

337
 2) `TcInteract.matchClassInst` -- This module drives the instance resolution
Simon Peyton Jones's avatar
Simon Peyton Jones committed
338
339
340
    / dictionary generation. The return type is `LookupInstResult`, which either
    says no instance matched, or one found, and if it was a safe or unsafe
    overlap.
341
342

 3) `TcInteract.doTopReactDict` -- Takes a dictionary / class constraint and
Simon Peyton Jones's avatar
Simon Peyton Jones committed
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
     tries to resolve it by calling (in part) `matchClassInst`. The resolving
     mechanism has a work list (of constraints) that it process one at a time. If
     the constraint can't be resolved, it's added to an inert set. When compiling
     an `-XSafe` or `-XTrustworthy` module, we follow this approach as we know
     compilation should fail. These are handled as normal constraint resolution
     failures from here-on (see step 6).

     Otherwise, we may be inferring safety (or using `-Wunsafe`), and
     compilation should succeed, but print warnings and/or mark the compiled module
     as `-XUnsafe`. In this case, we call `insertSafeOverlapFailureTcS` which adds
     the unsafe (but resolved!) constraint to the `inert_safehask` field of
     `InertCans`.

 4) `TcSimplify.simplifyTop`:
       * Call simpl_top, the top-level function for driving the simplifier for
         constraint resolution.

       * Once finished, call `getSafeOverlapFailures` to retrieve the
         list of overlapping instances that were successfully resolved,
         but unsafe. Remember, this is only applicable for generating warnings
         (`-Wunsafe`) or inferring a module unsafe. `-XSafe` and `-XTrustworthy`
         cause compilation failure by not resolving the unsafe constraint at all.

       * For unresolved constraints (all types), call `TcErrors.reportUnsolved`,
         while for resolved but unsafe overlapping dictionary constraints, call
         `TcErrors.warnAllUnsolved`. Both functions convert constraints into a
         warning message for the user.

       * In the case of `warnAllUnsolved` for resolved, but unsafe
         dictionary constraints, we collect the generated warning
         message (pop it) and call `TcRnMonad.recordUnsafeInfer` to
         mark the module we are compiling as unsafe, passing the
         warning message along as the reason.

 5) `TcErrors.*Unsolved` -- Generates error messages for constraints by
    actually calling `InstEnv.lookupInstEnv` again! Yes, confusing, but all we
    know is the constraint that is unresolved or unsafe. For dictionary, all we
    know is that we need a dictionary of type C, but not what instances are
    available and how they overlap. So we once again call `lookupInstEnv` to
    figure that out so we can generate a helpful error message.

 6) `TcRnMonad.recordUnsafeInfer` -- Save the unsafe result and reason in an
      IORef called `tcg_safeInfer`.

 7) `HscMain.tcRnModule'` -- Reads `tcg_safeInfer` after type-checking, calling
    `HscMain.markUnsafeInfer` (passing the reason along) when safe-inferrence
    failed.
390
391
392
393
394
395
396
397
398
399

Note [No defaulting in the ambiguity check]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When simplifying constraints for the ambiguity check, we use
solveWantedsAndDrop, not simpl_top, so that we do no defaulting.
Trac #11947 was an example:
   f :: Num a => Int -> Int
This is ambiguous of course, but we don't want to default the
(Num alpha) constraint to (Num Int)!  Doing so gives a defaulting
warning, but no error.
Austin Seipp's avatar
Austin Seipp committed
400
-}
401

402
------------------
403
404
405
simplifyAmbiguityCheck :: Type -> WantedConstraints -> TcM ()
simplifyAmbiguityCheck ty wanteds
  = do { traceTc "simplifyAmbiguityCheck {" (text "type = " <+> ppr ty $$ text "wanted = " <+> ppr wanteds)
406
407
408
       ; (final_wc, _) <- runTcS $ solveWantedsAndDrop wanteds
             -- NB: no defaulting!  See Note [No defaulting in the ambiguity check]

409
410
411
412
413
       ; traceTc "End simplifyAmbiguityCheck }" empty

       -- Normally report all errors; but with -XAllowAmbiguousTypes
       -- report only insoluble ones, since they represent genuinely
       -- inaccessible code
414
       ; allow_ambiguous <- xoptM LangExt.AllowAmbiguousTypes
415
       ; traceTc "reportUnsolved(ambig) {" empty
416
       ; tc_lvl <- TcM.getTcLevel
417
       ; unless (allow_ambiguous && not (insolubleWC tc_lvl final_wc))
418
                (discardResult (reportUnsolved final_wc))
419
420
421
422
       ; traceTc "reportUnsolved(ambig) }" empty

       ; return () }

423
424
------------------
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
425
simplifyInteractive wanteds
426
  = traceTc "simplifyInteractive" empty >>
427
    simplifyTop wanteds
428
429

------------------
430
simplifyDefault :: ThetaType    -- Wanted; has no type variables in it
431
                -> TcM ()       -- Succeeds if the constraint is soluble
432
simplifyDefault theta
433
  = do { traceTc "simplifyDefault" empty
434
435
436
437
438
       ; loc <- getCtLocM DefaultOrigin Nothing
       ; let wanted = [ CtDerived { ctev_pred = pred
                                  , ctev_loc  = loc }
                      | pred <- theta ]
       ; unsolved <- runTcSDeriveds (solveWanteds (mkSimpleWC wanted))
439
       ; traceTc "reportUnsolved {" empty
440
       ; reportAllUnsolved unsolved
441
       ; traceTc "reportUnsolved }" empty
442
       ; return () }
443

444
445
446
------------------
tcCheckSatisfiability :: Bag EvVar -> TcM Bool
-- Return True if satisfiable, False if definitely contradictory
447
tcCheckSatisfiability given_ids
448
  = do { lcl_env <- TcM.getLclEnv
449
450
       ; let given_loc = mkGivenLoc topTcLevel UnkSkol lcl_env
       ; (res, _ev_binds) <- runTcS $
451
             do { traceTcS "checkSatisfiability {" (ppr given_ids)
452
                ; let given_cts = mkGivens given_loc (bagToList given_ids)
453
                     -- See Note [Superclasses and satisfiability]
454
455
456
457
458
                ; insols <- solveSimpleGivens given_cts
                ; insols <- try_harder insols
                ; traceTcS "checkSatisfiability }" (ppr insols)
                ; return (isEmptyBag insols) }
       ; return res }
459
 where
460
461
462
    try_harder :: Cts -> TcS Cts
    -- Maybe we have to search up the superclass chain to find
    -- an unsatisfiable constraint.  Example: pmcheck/T3927b.
463
    -- At the moment we try just once
464
465
466
467
468
469
    try_harder insols
      | not (isEmptyBag insols)   -- We've found that it's definitely unsatisfiable
      = return insols             -- Hurrah -- stop now.
      | otherwise
      = do { pending_given <- getPendingScDicts
           ; new_given <- makeSuperClasses pending_given
470
471
           ; solveSimpleGivens new_given }

472
{- Note [Superclasses and satisfiability]
473
474
475
476
477
478
479
480
481
482
483
484
485
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Expand superclasses before starting, because (Int ~ Bool), has
(Int ~~ Bool) as a superclass, which in turn has (Int ~N# Bool)
as a superclass, and it's the latter that is insoluble.  See
Note [The equality types story] in TysPrim.

If we fail to prove unsatisfiability we (arbitrarily) try just once to
find superclasses, using try_harder.  Reason: we might have a type
signature
   f :: F op (Implements push) => ..
where F is a type function.  This happened in Trac #3972.

We could do more than once but we'd have to have /some/ limit: in the
486
the recursive case, we would go on forever in the common case where
487
488
489
490
491
the constraints /are/ satisfiable (Trac #10592 comment:12!).

For stratightforard situations without type functions the try_harder
step does nothing.

492

493
***********************************************************************************
494
*                                                                                 *
495
496
497
*                            Inference
*                                                                                 *
***********************************************************************************
498

499
500
501
502
503
504
505
506
Note [Inferring the type of a let-bound variable]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
   f x = rhs

To infer f's type we do the following:
 * Gather the constraints for the RHS with ambient level *one more than*
   the current one.  This is done by the call
507
        pushLevelAndCaptureConstraints (tcMonoBinds...)
508
509
510
511
   in TcBinds.tcPolyInfer

 * Call simplifyInfer to simplify the constraints and decide what to
   quantify over. We pass in the level used for the RHS constraints,
512
   here called rhs_tclvl.
513
514
515
516

This ensures that the implication constraint we generate, if any,
has a strictly-increased level compared to the ambient level outside
the let binding.
517

Austin Seipp's avatar
Austin Seipp committed
518
-}
519

520
521
522
523
524
525
526
527
528
529
530
531
532
533
-- | How should we choose which constraints to quantify over?
data InferMode = ApplyMR          -- ^ Apply the monomorphism restriction,
                                  -- never quantifying over any constraints
               | EagerDefaulting  -- ^ See Note [TcRnExprMode] in TcRnDriver,
                                  -- the :type +d case; this mode refuses
                                  -- to quantify over any defaultable constraint
               | NoRestrictions   -- ^ Quantify over any constraint that
                                  -- satisfies TcType.pickQuantifiablePreds

instance Outputable InferMode where
  ppr ApplyMR         = text "ApplyMR"
  ppr EagerDefaulting = text "EagerDefaulting"
  ppr NoRestrictions  = text "NoRestrictions"

534
simplifyInfer :: TcLevel               -- Used when generating the constraints
535
              -> InferMode
536
              -> [TcIdSigInst]         -- Any signatures (possibly partial)
537
538
              -> [(Name, TcTauType)]   -- Variables to be generalised,
                                       -- and their tau-types
539
              -> WantedConstraints
540
              -> TcM ([TcTyVar],    -- Quantify over these type variables
541
                      [EvVar],      -- ... and these constraints (fully zonked)
542
                      TcEvBinds)    -- ... binding these evidence variables
543
simplifyInfer rhs_tclvl infer_mode sigs name_taus wanteds
544
  | isEmptyWC wanteds
545
  = do { gbl_tvs <- tcGetGlobalTyCoVars
546
       ; dep_vars <- zonkTcTypesAndSplitDepVars (map snd name_taus)
547
       ; qtkvs <- quantifyZonkedTyVars gbl_tvs dep_vars
548
       ; traceTc "simplifyInfer: empty WC" (ppr name_taus $$ ppr qtkvs)
549
       ; return (qtkvs, [], emptyTcEvBinds) }
550

551
  | otherwise
552
  = do { traceTc "simplifyInfer {"  $ vcat
553
554
555
             [ text "sigs =" <+> ppr sigs
             , text "binds =" <+> ppr name_taus
             , text "rhs_tclvl =" <+> ppr rhs_tclvl
556
             , text "infer_mode =" <+> ppr infer_mode
557
             , text "(unzonked) wanted =" <+> ppr wanteds
558
559
             ]

560
561
       ; let partial_sigs = filter isPartialSig sigs
             psig_theta   = concatMap sig_inst_theta partial_sigs
562

563
564
565
566
567
568
569
       -- First do full-blown solving
       -- NB: we must gather up all the bindings from doing
       -- this solving; hence (runTcSWithEvBinds ev_binds_var).
       -- And note that since there are nested implications,
       -- calling solveWanteds will side-effect their evidence
       -- bindings, so we can't just revert to the input
       -- constraint.
570

571
572
573
574
575
576
577
       ; tc_lcl_env      <- TcM.getLclEnv
       ; ev_binds_var    <- TcM.newTcEvBinds
       ; psig_theta_vars <- mapM TcM.newEvVar psig_theta
       ; wanted_transformed_incl_derivs
            <- setTcLevel rhs_tclvl $
               runTcSWithEvBinds False (Just ev_binds_var) $
               do { let loc = mkGivenLoc rhs_tclvl UnkSkol tc_lcl_env
578
                        psig_givens = mkGivens loc psig_theta_vars
579
580
581
                  ; _ <- solveSimpleGivens psig_givens
                         -- See Note [Add signature contexts as givens]
                  ; solveWanteds wanteds }
582
       ; wanted_transformed_incl_derivs <- TcM.zonkWC wanted_transformed_incl_derivs
583

584
585
       -- Find quant_pred_candidates, the predicates that
       -- we'll consider quantifying over
586
587
588
589
       -- NB1: wanted_transformed does not include anything provable from
       --      the psig_theta; it's just the extra bit
       -- NB2: We do not do any defaulting when inferring a type, this can lead
       --      to less polymorphic types, see Note [Default while Inferring]
590

591
       ; let wanted_transformed = dropDerivedWC wanted_transformed_incl_derivs
592
       ; quant_pred_candidates   -- Fully zonked
593
           <- if insolubleWC rhs_tclvl wanted_transformed_incl_derivs
594
              then return []   -- See Note [Quantification with errors]
595
                               -- NB: must include derived errors in this test,
596
597
598
                               --     hence "incl_derivs"

              else do { let quant_cand = approximateWC wanted_transformed
niteria's avatar
niteria committed
599
600
                            meta_tvs   = filter isMetaTyVar $
                                         tyCoVarsOfCtsList quant_cand
601
602

                      ; gbl_tvs <- tcGetGlobalTyCoVars
603
604
                            -- Miminise quant_cand.  We are not interested in any evidence
                            -- produced, because we are going to simplify wanted_transformed
605
                            -- again later. All we want here are the predicates over which to
606
                            -- quantify.
607
                            --
608
609
                            -- If any meta-tyvar unifications take place (unlikely),
                            -- we'll pick that up later.
610

611
612
613
614
615
616
617
                      -- See Note [Promote _and_ default when inferring]
                      ; let def_tyvar tv
                              = when (not $ tv `elemVarSet` gbl_tvs) $
                                defaultTyVar tv
                      ; mapM_ def_tyvar meta_tvs
                      ; mapM_ (promoteTyVar rhs_tclvl) meta_tvs

618
                      ; WC { wc_simple = simples }
619
620
                           <- setTcLevel rhs_tclvl $
                              runTcSDeriveds       $
621
622
623
624
                              solveSimpleWanteds   $
                              mapBag toDerivedCt quant_cand
                                -- NB: we don't want evidence,
                                -- so use Derived constraints
625
626

                      ; simples <- TcM.zonkSimples simples
627

628
                      ; return [ ctEvPred ev | ct <- bagToList simples
629
                                             , let ev = ctEvidence ct ] }
630

631
       -- NB: quant_pred_candidates is already fully zonked
632

633
       -- Decide what type variables and constraints to quantify
634
635
       -- NB: bound_theta are constraints we want to quantify over,
       --     /apart from/ the psig_theta, which we always quantify over
636
       ; (qtvs, bound_theta) <- decideQuantification infer_mode name_taus psig_theta
637
                                                     quant_pred_candidates
638
639
640
641
642
643
644
645
646
647
648
649
650

         -- Promote any type variables that are free in the inferred type
         -- of the function:
         --    f :: forall qtvs. bound_theta => zonked_tau
         -- These variables now become free in the envt, and hence will show
         -- up whenever 'f' is called.  They may currently at rhs_tclvl, but
         -- they had better be unifiable at the outer_tclvl!
         -- Example:   envt mentions alpha[1]
         --            tau_ty = beta[2] -> beta[2]
         --            consraints = alpha ~ [beta]
         -- we don't quantify over beta (since it is fixed by envt)
         -- so we must promote it!  The inferred type is just
         --   f :: beta -> beta
651
       ; zonked_taus <- mapM (TcM.zonkTcType . snd) name_taus
652
653
654
              -- decideQuantification turned some meta tyvars into
              -- quantified skolems, so we have to zonk again

655
       ; let phi_tkvs = tyCoVarsOfTypes bound_theta  -- Already zonked
656
                        `unionVarSet` tyCoVarsOfTypes zonked_taus
657
             promote_tkvs = closeOverKinds phi_tkvs `delVarSetList` qtvs
658

659
660
661
662
663
       ; MASSERT2( closeOverKinds promote_tkvs `subVarSet` promote_tkvs
                 , ppr phi_tkvs $$
                   ppr (closeOverKinds phi_tkvs) $$
                   ppr promote_tkvs $$
                   ppr (closeOverKinds promote_tkvs) )
664
665
666
           -- we really don't want a type to be promoted when its kind isn't!

           -- promoteTyVar ignores coercion variables
667
       ; outer_tclvl <- TcM.getTcLevel
niteria's avatar
niteria committed
668
669
670
       ; mapM_ (promoteTyVar outer_tclvl) (nonDetEltsUFM promote_tkvs)
           -- It's OK to use nonDetEltsUFM here because promoteTyVar is
           -- commutative
671
672
673

           -- Emit an implication constraint for the
           -- remaining constraints from the RHS
674
           -- extra_qtvs: see Note [Quantification and partial signatures]
675
       ; bound_theta_vars <- mapM TcM.newEvVar bound_theta
676
       ; psig_theta_vars  <- mapM zonkId psig_theta_vars
677
678
679
680
       ; all_qtvs         <- add_psig_tvs qtvs
                             [ tv | sig <- partial_sigs
                                  , (_,tv) <- sig_inst_skols sig ]

681
682
683
       ; let full_theta      = psig_theta      ++ bound_theta
             full_theta_vars = psig_theta_vars ++ bound_theta_vars
             skol_info   = InferSkol [ (name, mkSigmaTy [] full_theta ty)
684
                                     | (name, ty) <- name_taus ]
685
                        -- Don't add the quantified variables here, because
686
687
                        -- they are also bound in ic_skols and we want them
                        -- to be tidied uniformly
688

689
             implic = Implic { ic_tclvl    = rhs_tclvl
690
                             , ic_skols    = all_qtvs
691
                             , ic_no_eqs   = False
692
                             , ic_given    = full_theta_vars
693
                             , ic_wanted   = wanted_transformed
694
                             , ic_status   = IC_Unsolved
695
                             , ic_binds    = Just ev_binds_var
696
                             , ic_info     = skol_info
697
                             , ic_env      = tc_lcl_env }
698
       ; emitImplication implic
699

700
         -- All done!
701
       ; traceTc "} simplifyInfer/produced residual implication for quantification" $
702
         vcat [ text "quant_pred_candidates =" <+> ppr quant_pred_candidates
703
              , text "promote_tvs=" <+> ppr promote_tkvs
704
              , text "psig_theta =" <+> ppr psig_theta
705
              , text "bound_theta =" <+> ppr bound_theta
706
              , text "full_theta =" <+> ppr full_theta
707
708
              , text "qtvs =" <+> ppr qtvs
              , text "implic =" <+> ppr implic ]
709

710
       ; return ( qtvs, full_theta_vars, TcEvBinds ev_binds_var ) }
711
712
713
714
715
716
717
718
719
720
  where
    add_psig_tvs qtvs [] = return qtvs
    add_psig_tvs qtvs (tv:tvs)
      = do { tv <- zonkTcTyVarToTyVar tv
           ; if tv `elem` qtvs
             then add_psig_tvs qtvs tvs
             else do { mb_tv <- zonkQuantifiedTyVar False tv
                     ; case mb_tv of
                         Nothing -> add_psig_tvs qtvs      tvs
                         Just tv -> add_psig_tvs (tv:qtvs) tvs } }
721
722
723

{- Note [Add signature contexts as givens]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
724
725
726
Consider this (Trac #11016):
  f2 :: (?x :: Int) => _
  f2 = ?x
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
or this
  f3 :: a ~ Bool => (a, _)
  f3 = (True, False)
or theis
  f4 :: (Ord a, _) => a -> Bool
  f4 x = x==x

We'll use plan InferGen because there are holes in the type.  But:
 * For f2 we want to have the (?x :: Int) constraint floating around
   so that the functional dependencies kick in.  Otherwise the
   occurrence of ?x on the RHS produces constraint (?x :: alpha), and
   we won't unify alpha:=Int.
 * For f3 we want the (a ~ Bool) available to solve the wanted (a ~ Bool)
   in the RHS
 * For f4 we want to use the (Ord a) in the signature to solve the Eq a
   constraint.
743
744

Solution: in simplifyInfer, just before simplifying the constraints
745
746
gathered from the RHS, add Given constraints for the context of any
type signatures.
747

Austin Seipp's avatar
Austin Seipp committed
748
749
************************************************************************
*                                                                      *
750
                Quantification
Austin Seipp's avatar
Austin Seipp committed
751
752
*                                                                      *
************************************************************************
753
754
755
756

Note [Deciding quantification]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If the monomorphism restriction does not apply, then we quantify as follows:
757

758
759
760
  * Take the global tyvars, and "grow" them using the equality constraints
    E.g.  if x:alpha is in the environment, and alpha ~ [beta] (which can
          happen because alpha is untouchable here) then do not quantify over
761
762
          beta, because alpha fixes beta, and beta is effectively free in
          the environment too
763
764
765
    These are the mono_tvs

  * Take the free vars of the tau-type (zonked_tau_tvs) and "grow" them
766
    using all the constraints.  These are tau_tvs_plus
767

768
769
770
771
  * Use quantifyTyVars to quantify over (tau_tvs_plus - mono_tvs), being
    careful to close over kinds, and to skolemise the quantified tyvars.
    (This actually unifies each quantifies meta-tyvar with a fresh skolem.)
    Result is qtvs.
Simon Peyton Jones's avatar
Simon Peyton Jones committed
772

773
  * Filter the constraints using pickQuantifiablePreds and the qtvs.
774
775
    We have to zonk the constraints first, so they "see" the freshly
    created skolems.
776

777
778
779
If the MR does apply, mono_tvs includes all the constrained tyvars --
including all covars -- and the quantified constraints are empty/insoluble.

Austin Seipp's avatar
Austin Seipp committed
780
-}
781

782
decideQuantification
783
  :: InferMode
784
  -> [(Name, TcTauType)]   -- Variables to be generalised
785
786
  -> [PredType]            -- All annotated constraints from signatures
  -> [PredType]            -- Candidate theta
787
788
  -> TcM ( [TcTyVar]       -- Quantify over these (skolems)
         , [PredType] )    -- and this context (fully zonked)
789
-- See Note [Deciding quantification]
790
decideQuantification infer_mode name_taus psig_theta candidates
791
  = do { gbl_tvs <- tcGetGlobalTyCoVars
792
793
       ; zonked_taus <- mapM TcM.zonkTcType (psig_theta ++ taus)
                        -- psig_theta: see Note [Quantification and partial signatures]
794
795
       ; ovl_strings <- xoptM LangExt.OverloadedStrings
       ; let DV {dv_kvs = zkvs, dv_tvs = ztvs} = splitDepVarsOfTypes zonked_taus
796
             (gbl_cand, quant_cand)  -- gbl_cand   = do not quantify me
797
798
799
800
801
802
803
804
805
806
807
                = case infer_mode of   -- quant_cand = try to quantify me
                    ApplyMR         -> (candidates, [])
                    NoRestrictions  -> ([], candidates)
                    EagerDefaulting -> partition is_interactive_ct candidates
                      where
                        is_interactive_ct ct
                          | Just (cls, _) <- getClassPredTys_maybe ct
                          = isInteractiveClass ovl_strings cls
                          | otherwise
                          = False

808
809
810
811
812
813
814
             eq_constraints  = filter isEqPred quant_cand
             constrained_tvs = tyCoVarsOfTypes gbl_cand
             mono_tvs        = growThetaTyVars eq_constraints $
                               gbl_tvs `unionVarSet` constrained_tvs
             tau_tvs_plus    = growThetaTyVarsDSet quant_cand ztvs
             dvs_plus        = DV { dv_kvs = zkvs, dv_tvs = tau_tvs_plus }

815
       ; qtvs <- quantifyZonkedTyVars mono_tvs dvs_plus
816
817
818
819
820
          -- We don't grow the kvs, as there's no real need to. Recall
          -- that quantifyTyVars uses the separation between kvs and tvs
          -- only for defaulting, and we don't want (ever) to default a tv
          -- to *. So, don't grow the kvs.

821
       ; quant_cand <- TcM.zonkTcTypes quant_cand
Simon Peyton Jones's avatar
Simon Peyton Jones committed
822
                 -- quantifyTyVars turned some meta tyvars into
823
824
                 -- quantified skolems, so we have to zonk again

825
       ; let qtv_set   = mkVarSet qtvs
826
             theta     = pickQuantifiablePreds qtv_set quant_cand
827
828
829
             min_theta = mkMinimalBySCs theta
               -- See Note [Minimize by Superclasses]

830
831
           -- Warn about the monomorphism restriction
       ; warn_mono <- woptM Opt_WarnMonomorphism
832
833
834
835
       ; let mr_bites | ApplyMR <- infer_mode
                      = constrained_tvs `intersectsVarSet` tcDepVarSet dvs_plus
                      | otherwise
                      = False
836
837
838
839
840
841
842
       ; warnTc (Reason Opt_WarnMonomorphism) (warn_mono && mr_bites) $
         hang (text "The Monomorphism Restriction applies to the binding"
               <> plural bndrs <+> text "for" <+> pp_bndrs)
             2 (text "Consider giving a type signature for"
                <+> if isSingleton bndrs then pp_bndrs
                                         else text "these binders")

843
844
845
       ; traceTc "decideQuantification"
           (vcat [ text "infer_mode:"   <+> ppr infer_mode
                 , text "gbl_cand:"     <+> ppr gbl_cand
846
                 , text "quant_cand:"   <+> ppr quant_cand
847
848
849
850
851
                 , text "gbl_tvs:"      <+> ppr gbl_tvs
                 , text "mono_tvs:"     <+> ppr mono_tvs
                 , text "tau_tvs_plus:" <+> ppr tau_tvs_plus
                 , text "qtvs:"         <+> ppr qtvs
                 , text "min_theta:"    <+> ppr min_theta ])
852
       ; return (qtvs, min_theta) }
853
  where
854
    pp_bndrs = pprWithCommas (quotes . ppr) bndrs
855
    (bndrs, taus) = unzip name_taus
856

857
------------------
858
growThetaTyVars :: ThetaType -> TyCoVarSet -> TyVarSet
859
-- See Note [Growing the tau-tvs using constraints]
860
-- NB: only returns tyvars, never covars
861
growThetaTyVars theta tvs
862
863
864
  | null theta = tvs_only
  | otherwise  = filterVarSet isTyVar $
                 transCloVarSet mk_next seed_tvs
865
  where
866
867
    tvs_only = filterVarSet isTyVar tvs
    seed_tvs = tvs `unionVarSet` tyCoVarsOfTypes ips
868
    (ips, non_ips) = partition isIPPred theta
869
                         -- See Note [Inheriting implicit parameters] in TcType
870
871
872
873
874
875

    mk_next :: VarSet -> VarSet -- Maps current set to newly-grown ones
    mk_next so_far = foldr (grow_one so_far) emptyVarSet non_ips
    grow_one so_far pred tvs
       | pred_tvs `intersectsVarSet` so_far = tvs `unionVarSet` pred_tvs
       | otherwise                          = tvs
876
       where
877
         pred_tvs = tyCoVarsOfType pred
878

879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
------------------
growThetaTyVarsDSet :: ThetaType -> DTyCoVarSet -> DTyVarSet
-- See Note [Growing the tau-tvs using constraints]
-- NB: only returns tyvars, never covars
-- It takes a deterministic set of TyCoVars and returns a deterministic set
-- of TyVars.
-- The implementation mirrors growThetaTyVars, the only difference is that
-- it avoids unionDVarSet and uses more efficient extendDVarSetList.
growThetaTyVarsDSet theta tvs
  | null theta = tvs_only
  | otherwise  = filterDVarSet isTyVar $
                 transCloDVarSet mk_next seed_tvs
  where
    tvs_only = filterDVarSet isTyVar tvs
    seed_tvs = tvs `extendDVarSetList` tyCoVarsOfTypesList ips
    (ips, non_ips) = partition isIPPred theta
                         -- See Note [Inheriting implicit parameters] in TcType

    mk_next :: DVarSet -> DVarSet -- Maps current set to newly-grown ones
    mk_next so_far = foldr (grow_one so_far) emptyDVarSet non_ips
    grow_one so_far pred tvs
       | any (`elemDVarSet` so_far) pred_tvs = tvs `extendDVarSetList` pred_tvs
       | otherwise                           = tvs
       where
         pred_tvs = tyCoVarsOfTypeList pred

905
906
{- Note [Quantification and partial signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
907
908
909
910
When choosing type variables to quantify, the basic plan is to
quantify over all type variables that are
 * free in the tau_tvs, and
 * not forced to be monomorphic (mono_tvs),
911
   for example by being free in the environment.
912

913
914
However, in the case of a partial type signature, be doing inference
*in the presence of a type signature*. For example:
915
916
   f :: _ -> a
   f x = ...
917
918
or
   g :: (Eq _a) => _b -> _b
919
In both cases we use plan InferGen, and hence call simplifyInfer.
920
But those 'a' variables are skolems, and we should be sure to quantify
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
over them, for two reasons

* In the case of a type error
     f :: _ -> Maybe a
     f x = True && x
  The inferred type of 'f' is f :: Bool -> Bool, but there's a
  left-over error of form (HoleCan (Maybe a ~ Bool)).  The error-reporting
  machine expects to find a binding site for the skolem 'a', so we
  add it to the ic_skols of the residual implication.

  Note that we /only/ do this to the residual implication. We don't
  complicate the quantified type varialbes of 'f' for downstream code;
  it's just a device to make the error message generator know what to
  report.

* Consider the partial type signature
     f :: (Eq _) => Int -> Int
     f x = x
  In normal cases that makes sense; e.g.
     g :: Eq _a => _a -> _a
     g x = x
  where the signature makes the type less general than it could
  be. But for 'f' we must therefore quantify over the user-annotated
  constraints, to get
     f :: forall a. Eq a => Int -> Int
  (thereby correctly triggering an ambiguity error later).  If we don't
  we'll end up with a strange open type
     f :: Eq alpha => Int -> Int
  which isn't ambiguous but is still very wrong.  That's why include
  psig_theta in the variables to quantify over, passed to
  decideQuantification.
952

953
954
955
956
957
958
959
960
Note [Quantifying over equality constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Should we quantify over an equality constraint (s ~ t)?  In general, we don't.
Doing so may simply postpone a type error from the function definition site to
its call site.  (At worst, imagine (Int ~ Bool)).

However, consider this
         forall a. (F [a] ~ Int) => blah
961
Should we quantify over the (F [a] ~ Int)?  Perhaps yes, because at the call
962
963
964
965
site we will know 'a', and perhaps we have instance  F [Bool] = Int.
So we *do* quantify over a type-family equality where the arguments mention
the quantified variables.

966
967
968
Note [Growing the tau-tvs using constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(growThetaTyVars insts tvs) is the result of extending the set
969
    of tyvars, tvs, using all conceivable links from pred
970
971
972
973
974
975
976
977

E.g. tvs = {a}, preds = {H [a] b, K (b,Int) c, Eq e}
Then growThetaTyVars preds tvs = {a,b,c}

Notice that
   growThetaTyVars is conservative       if v might be fixed by vs
                                         => v `elem` grow(vs,C)

978
979
980
981
982
983
984
985
Note [Quantification with errors]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If we find that the RHS of the definition has some absolutely-insoluble
constraints, we abandon all attempts to find a context to quantify
over, and instead make the function fully-polymorphic in whatever
type we have found.  For two reasons
  a) Minimise downstream errors
  b) Avoid spurious errors from this function
986

987
But NB that we must include *derived* errors in the check. Example:
988
989
990
    (a::*) ~ Int#
We get an insoluble derived error *~#, and we don't want to discard
it before doing the isInsolubleWC test!  (Trac #8262)
991

992
993
Note [Default while Inferring]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
994
Our current plan is that defaulting only happens at simplifyTop and
995
not simplifyInfer.  This may lead to some insoluble deferred constraints.
996
997
Example:

998
instance D g => C g Int b
999
1000

constraint inferred = (forall b. 0 => C gamma alpha b) /\ Num alpha
1001
type inferred       = gamma -> gamma
1002

1003
1004
1005
Now, if we try to default (alpha := Int) we will be able to refine the implication to
  (forall b. 0 => C gamma Int b)
which can then be simplified further to
1006
  (forall b. 0 => D gamma)
1007
Finally, we /can/ approximate this implication with (D gamma) and infer the quantified
1008
1009
type:  forall g. D g => g -> g

1010
Instead what will currently happen is that we will get a quantified type
1011
1012
1013
(forall g. g -> g) and an implication:
       forall g. 0 => (forall b. 0 => C g alpha b) /\ Num alpha

1014
Which, even if the simplifyTop defaults (alpha := Int) we will still be left with an
1015
1016
1017
unsolvable implication:
       forall g. 0 => (forall b. 0 => D g)

1018
The concrete example would be:
1019
1020
1021
       h :: C g a s => g -> a -> ST s a
       f (x::gamma) = (\_ -> x) (runST (h x (undefined::alpha)) + 1)

1022
1023
But it is quite tedious to do defaulting and resolve the implication constraints, and
we have not observed code breaking because of the lack of defaulting in inference, so
1024
1025
1026
1027
we don't do it for now.



1028
Note [Minimize by Superclasses]
1029
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1030
1031
1032
1033
1034
1035
1036
When we quantify over a constraint, in simplifyInfer we need to
quantify over a constraint that is minimal in some sense: For
instance, if the final wanted constraint is (Eq alpha, Ord alpha),
we'd like to quantify over Ord alpha, because we can just get Eq alpha
from superclass selection from Ord alpha. This minimization is what
mkMinimalBySCs does. Then, simplifyInfer uses the minimal constraint
to check the original wanted.
1037

1038

1039
Note [Avoid unnecessary constraint simplification]
1040
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1041
    -------- NB NB NB (Jun 12) -------------
1042
1043
1044
    This note not longer applies; see the notes with Trac #4361.
    But I'm leaving it in here so we remember the issue.)
    ----------------------------------------
1045
When inferring the type of a let-binding, with simplifyInfer,
1046
try to avoid unnecessarily simplifying class constraints.
1047
Doing so aids sharing, but it also helps with delicate
1048
situations like
1049

1050
   instance C t => C [t] where ..
1051

1052
   f :: C [t] => ....
1053
   f x = let g y = ...(constraint C [t])...
1054
1055
1056
1057
         in ...
When inferring a type for 'g', we don't want to apply the<