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

3
module TcSimplify(
4
       simplifyInfer,
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
import Pair
29 30
import PrelInfo
import PrelNames
31 32 33
import TcErrors
import TcEvidence
import TcInteract
34
import TcCanonical   ( makeSuperClasses, mkGivensWithSuperClasses )
35
import TcMType   as TcM
36
import TcRnMonad as TcM
37 38 39
import TcSMonad  as TcS
import TcType
import TrieMap       () -- DV: for now
40
import Type
41
import TysWiredIn    ( ptrRepLiftedTy )
42 43 44 45
import Unify         ( tcMatchTy )
import Util
import Var
import VarSet
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 53
import Data.Foldable    ( fold )

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

62 63
simplifyTop :: WantedConstraints -> TcM (Bag EvBind)
-- Simplify top-level constraints
64 65 66
-- 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
67
simplifyTop wanteds
68
  = do { traceTc "simplifyTop {" $ text "wanted = " <+> ppr wanteds
Simon Peyton Jones's avatar
Simon Peyton Jones committed
69 70 71 72
       ; ((final_wc, unsafe_ol), binds1) <- runTcS $
            do { final_wc <- simpl_top wanteds
               ; unsafe_ol <- getSafeOverlapFailures
               ; return (final_wc, unsafe_ol) }
73 74 75
       ; traceTc "End simplifyTop }" empty

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

79 80 81 82
       ; 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
83
           -- messages.
84
           ; errs_var  <- getErrsVar
85 86
           ; saved_msg <- TcM.readTcRef errs_var
           ; TcM.writeTcRef errs_var emptyMessages
87 88 89 90 91

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

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

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

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

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

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

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

142 143
    try_class_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_class_defaulting wc
Austin Seipp's avatar
Austin Seipp committed
144
      | isEmptyWC wc
145 146
      = return wc
      | otherwise  -- See Note [When to do type-class defaulting]
147
      = do { something_happened <- applyDefaultingRules wc
148
                                   -- See Note [Top-level Defaulting Plan]
149
           ; if something_happened
150
             then do { wc_residual <- nestTcS (solveWantedsAndDrop wc)
151
                     ; try_class_defaulting wc_residual }
Simon Peyton Jones's avatar
Simon Peyton Jones committed
152
                  -- See Note [Overview of implicit CallStacks] in TcEvidence
153 154 155 156 157 158 159 160 161 162 163
             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
164
-- See Note [Overview of implicit CallStacks] in TcEvidence
165 166 167 168 169 170 171 172 173 174 175 176 177 178
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

  handle_implic implic = do
    wanteds <- defaultCallStacks (ic_wanted implic)
    return (implic { ic_wanted = wanteds })

179 180 181 182
  defaultCallStack ct
    | Just (cls, tys) <- getClassPredTys_maybe (ctPred ct)
    , Just _ <- isCallStackDict cls tys
    = 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.
Austin Seipp's avatar
Austin Seipp committed
390
-}
391

392
------------------
393 394 395
simplifyAmbiguityCheck :: Type -> WantedConstraints -> TcM ()
simplifyAmbiguityCheck ty wanteds
  = do { traceTc "simplifyAmbiguityCheck {" (text "type = " <+> ppr ty $$ text "wanted = " <+> ppr wanteds)
Simon Peyton Jones's avatar
Simon Peyton Jones committed
396
       ; (final_wc, _) <- runTcS $ simpl_top wanteds
397 398 399 400 401
       ; traceTc "End simplifyAmbiguityCheck }" empty

       -- Normally report all errors; but with -XAllowAmbiguousTypes
       -- report only insoluble ones, since they represent genuinely
       -- inaccessible code
402
       ; allow_ambiguous <- xoptM LangExt.AllowAmbiguousTypes
403
       ; traceTc "reportUnsolved(ambig) {" empty
404
       ; tc_lvl <- TcM.getTcLevel
405
       ; unless (allow_ambiguous && not (insolubleWC tc_lvl final_wc))
406
                (discardResult (reportUnsolved final_wc))
407 408 409 410
       ; traceTc "reportUnsolved(ambig) }" empty

       ; return () }

411 412
------------------
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
413
simplifyInteractive wanteds
414
  = traceTc "simplifyInteractive" empty >>
415
    simplifyTop wanteds
416 417

------------------
418
simplifyDefault :: ThetaType    -- Wanted; has no type variables in it
419
                -> TcM ()       -- Succeeds if the constraint is soluble
420
simplifyDefault theta
421
  = do { traceTc "simplifyInteractive" empty
422 423 424 425 426
       ; loc <- getCtLocM DefaultOrigin Nothing
       ; let wanted = [ CtDerived { ctev_pred = pred
                                  , ctev_loc  = loc }
                      | pred <- theta ]
       ; unsolved <- runTcSDeriveds (solveWanteds (mkSimpleWC wanted))
427
       ; traceTc "reportUnsolved {" empty
428
       ; reportAllUnsolved unsolved
429
       ; traceTc "reportUnsolved }" empty
430
       ; return () }
431

432 433 434
------------------
tcCheckSatisfiability :: Bag EvVar -> TcM Bool
-- Return True if satisfiable, False if definitely contradictory
435
tcCheckSatisfiability given_ids
436
  = do { lcl_env <- TcM.getLclEnv
437 438
       ; let given_loc = mkGivenLoc topTcLevel UnkSkol lcl_env
       ; (res, _ev_binds) <- runTcS $
439 440
             do { traceTcS "checkSatisfiability {" (ppr given_ids)
                ; given_cts <- mkGivensWithSuperClasses given_loc (bagToList given_ids)
441
                     -- See Note [Superclases and satisfiability]
442 443 444 445 446
                ; insols <- solveSimpleGivens given_cts
                ; insols <- try_harder insols
                ; traceTcS "checkSatisfiability }" (ppr insols)
                ; return (isEmptyBag insols) }
       ; return res }
447
 where
448 449 450
    try_harder :: Cts -> TcS Cts
    -- Maybe we have to search up the superclass chain to find
    -- an unsatisfiable constraint.  Example: pmcheck/T3927b.
451
    -- At the moment we try just once
452 453 454 455 456 457
    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
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
           ; solveSimpleGivens new_given }

{- Note [Superclases and satisfiability]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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
the recurisve case, we would go on forever in the common case where
the constraints /are/ satisfiable (Trac #10592 comment:12!).

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

480

481
***********************************************************************************
482
*                                                                                 *
483 484 485
*                            Inference
*                                                                                 *
***********************************************************************************
486

487 488 489 490 491 492 493 494
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
495
        pushLevelAndCaptureConstraints (tcMonoBinds...)
496 497 498 499
   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,
500
   here called rhs_tclvl.
501 502 503 504

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

Austin Seipp's avatar
Austin Seipp committed
506
-}
507

508
simplifyInfer :: TcLevel               -- Used when generating the constraints
509
              -> Bool                  -- Apply monomorphism restriction
510
              -> [TcIdSigInfo]         -- Any signatures (possibly partial)
511 512
              -> [(Name, TcTauType)]   -- Variables to be generalised,
                                       -- and their tau-types
513
              -> WantedConstraints
514
              -> TcM ([TcTyVar],    -- Quantify over these type variables
515
                      [EvVar],      -- ... and these constraints (fully zonked)
516
                      TcEvBinds)    -- ... binding these evidence variables
517
simplifyInfer rhs_tclvl apply_mr sigs name_taus wanteds
518
  | isEmptyWC wanteds
519
  = do { gbl_tvs <- tcGetGlobalTyCoVars
520 521
       ; dep_vars <- zonkTcTypesAndSplitDepVars (map snd name_taus)
       ; qtkvs <- quantify_tvs sigs gbl_tvs dep_vars
522
       ; traceTc "simplifyInfer: empty WC" (ppr name_taus $$ ppr qtkvs)
523
       ; return (qtkvs, [], emptyTcEvBinds) }
524

525
  | otherwise
526
  = do { traceTc "simplifyInfer {"  $ vcat
527 528 529 530 531
             [ text "sigs =" <+> ppr sigs
             , text "binds =" <+> ppr name_taus
             , text "rhs_tclvl =" <+> ppr rhs_tclvl
             , text "apply_mr =" <+> ppr apply_mr
             , text "(unzonked) wanted =" <+> ppr wanteds
532 533
             ]

534 535 536 537 538 539 540
       -- 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.
541

542
       ; ev_binds_var <- TcM.newTcEvBinds
543
       ; wanted_transformed_incl_derivs <- setTcLevel rhs_tclvl $
544
           do { sig_derived <- concatMapM mkSigDerivedWanteds sigs
545 546
                  -- the False says we don't really need to solve all Deriveds
              ; runTcSWithEvBinds False (Just ev_binds_var) $
547
                solveWanteds (wanteds `addSimples` listToBag sig_derived) }
548
       ; wanted_transformed_incl_derivs <- TcM.zonkWC wanted_transformed_incl_derivs
549

550 551 552 553
       -- Find quant_pred_candidates, the predicates that
       -- we'll consider quantifying over
       -- NB: We do not do any defaulting when inferring a type, this can lead
       -- to less polymorphic types, see Note [Default while Inferring]
554

555
       ; tc_lcl_env <- TcM.getLclEnv
556
       ; let wanted_transformed = dropDerivedWC wanted_transformed_incl_derivs
557
       ; quant_pred_candidates   -- Fully zonked
558
           <- if insolubleWC rhs_tclvl wanted_transformed_incl_derivs
559
              then return []   -- See Note [Quantification with errors]
560
                               -- NB: must include derived errors in this test,
561 562 563
                               --     hence "incl_derivs"

              else do { let quant_cand = approximateWC wanted_transformed
564 565 566
                            meta_tvs   = filter isMetaTyVar (varSetElems (tyCoVarsOfCts quant_cand))

                      ; gbl_tvs <- tcGetGlobalTyCoVars
567 568
                            -- Miminise quant_cand.  We are not interested in any evidence
                            -- produced, because we are going to simplify wanted_transformed
569
                            -- again later. All we want here are the predicates over which to
570
                            -- quantify.
571
                            --
572 573
                            -- If any meta-tyvar unifications take place (unlikely),
                            -- we'll pick that up later.
574

575 576 577 578 579 580 581
                      -- 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

582
                      ; WC { wc_simple = simples }
583 584
                           <- setTcLevel rhs_tclvl $
                              runTcSDeriveds       $
585 586 587 588
                              solveSimpleWanteds   $
                              mapBag toDerivedCt quant_cand
                                -- NB: we don't want evidence,
                                -- so use Derived constraints
589 590

                      ; simples <- TcM.zonkSimples simples
591

592
                      ; return [ ctEvPred ev | ct <- bagToList simples
593
                                             , let ev = ctEvidence ct ] }
594

595
       -- NB: quant_pred_candidates is already fully zonked
596

597
       -- Decide what type variables and constraints to quantify
598
       ; zonked_taus <- mapM (TcM.zonkTcType . snd) name_taus
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
       ; let zonked_tau_tkvs = splitDepVarsOfTypes zonked_taus
       ; (qtvs, bound_theta)
           <- decideQuantification apply_mr sigs name_taus
                                   quant_pred_candidates zonked_tau_tkvs

         -- 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
       ; outer_tclvl    <- TcM.getTcLevel
       ; zonked_tau_tvs <- fold <$>
                           traverse TcM.zonkTyCoVarsAndFV zonked_tau_tkvs
              -- decideQuantification turned some meta tyvars into
              -- quantified skolems, so we have to zonk again

       ; let phi_tvs     = tyCoVarsOfTypes bound_theta
                           `unionVarSet` zonked_tau_tvs

             promote_tvs = closeOverKinds phi_tvs `delVarSetList` qtvs
       ; MASSERT2( closeOverKinds promote_tvs `subVarSet` promote_tvs
                 , ppr phi_tvs $$
                   ppr (closeOverKinds phi_tvs) $$
                   ppr promote_tvs $$
                   ppr (closeOverKinds promote_tvs) )
           -- we really don't want a type to be promoted when its kind isn't!

           -- promoteTyVar ignores coercion variables
       ; mapM_ (promoteTyVar outer_tclvl) (varSetElems promote_tvs)

           -- Emit an implication constraint for the
           -- remaining constraints from the RHS
       ; bound_theta_vars <- mapM TcM.newEvVar bound_theta
       ; let skol_info   = InferSkol [ (name, mkSigmaTy [] bound_theta ty)
                                     | (name, ty) <- name_taus ]
641
                        -- Don't add the quantified variables here, because
642 643
                        -- they are also bound in ic_skols and we want them
                        -- to be tidied uniformly
644

645
             implic = Implic { ic_tclvl    = rhs_tclvl
646
                             , ic_skols    = qtvs
647
                             , ic_no_eqs   = False
648
                             , ic_given    = bound_theta_vars
649
                             , ic_wanted   = wanted_transformed
650
                             , ic_status   = IC_Unsolved
651
                             , ic_binds    = Just ev_binds_var
652
                             , ic_info     = skol_info
653
                             , ic_env      = tc_lcl_env }
654
       ; emitImplication implic
655

656
         -- All done!
657
       ; traceTc "} simplifyInfer/produced residual implication for quantification" $
658 659 660 661 662 663 664
         vcat [ text "quant_pred_candidates =" <+> ppr quant_pred_candidates
              , text "zonked_taus" <+> ppr zonked_taus
              , text "zonked_tau_tvs=" <+> ppr zonked_tau_tvs
              , text "promote_tvs=" <+> ppr promote_tvs
              , text "bound_theta =" <+> ppr bound_theta
              , text "qtvs =" <+> ppr qtvs
              , text "implic =" <+> ppr implic ]
665

666
       ; return ( qtvs, bound_theta_vars, TcEvBinds ev_binds_var ) }
667

668 669 670 671 672
mkSigDerivedWanteds :: TcIdSigInfo -> TcM [Ct]
-- See Note [Add deriveds for signature contexts]
mkSigDerivedWanteds (TISI { sig_bndr = PartialSig { sig_name = name }
                          , sig_theta = theta, sig_tau = tau })
 = do { let skol_info = InferSkol [(name, mkSigmaTy [] theta tau)]
673
      ; loc <- getCtLocM (GivenOrigin skol_info) (Just TypeLevel)
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
      ; return [ mkNonCanonical (CtDerived { ctev_pred = pred
                                           , ctev_loc = loc })
               | pred <- theta ] }
mkSigDerivedWanteds _ = return []

{- Note [Add deriveds for signature contexts]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this (Trac #11016):
  f2 :: (?x :: Int) => _
  f2 = ?x
We'll use plan InferGen because there are holes in the type.  But 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 wont unify alpha:=Int.

Solution: in simplifyInfer, just before simplifying the constraints
gathered from the RHS, add Derived constraints for the context of any
type signatures.  This is rare; if there is a type signature we'll usually
be doing CheckGen.  But it happens for signatures with holes.

Austin Seipp's avatar
Austin Seipp committed
694 695
************************************************************************
*                                                                      *
696
                Quantification
Austin Seipp's avatar
Austin Seipp committed
697 698
*                                                                      *
************************************************************************
699 700 701 702 703 704 705

Note [Deciding quantification]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If the monomorphism restriction does not apply, then we quantify as follows:
  * 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
706 707
          beta, because alpha fixes beta, and beta is effectively free in
          the environment too
708 709 710
    These are the mono_tvs

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

713 714 715 716
  * 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
717

718
  * Filter the constraints using pickQuantifiablePreds and the qtvs.
719 720
    We have to zonk the constraints first, so they "see" the freshly
    created skolems.
721

722 723 724
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
725
-}
726

727
decideQuantification
728 729 730 731 732 733 734
  :: Bool                  -- try the MR restriction?
  -> [TcIdSigInfo]
  -> [(Name, TcTauType)]   -- variables to be generalised (for errors only)
  -> [PredType]            -- candidate theta
  -> Pair TcTyCoVarSet     -- dependent (kind) variables & type variables
  -> TcM ( [TcTyVar]       -- Quantify over these (skolems)
         , [PredType] )    -- and this context (fully zonked)
735
-- See Note [Deciding quantification]
736 737
decideQuantification apply_mr sigs name_taus constraints
                     zonked_pair@(Pair zonked_tau_kvs zonked_tau_tvs)
738
  | apply_mr     -- Apply the Monomorphism restriction
739 740 741
  = do { gbl_tvs <- tcGetGlobalTyCoVars
       ; let constrained_tvs = tyCoVarsOfTypes constraints `unionVarSet`
                               filterVarSet isCoVar zonked_tkvs
742
             mono_tvs = gbl_tvs `unionVarSet` constrained_tvs
743
       ; qtvs <- quantify_tvs sigs mono_tvs zonked_pair
744

745
           -- Warn about the monomorphism restriction
746
       ; warn_mono <- woptM Opt_WarnMonomorphism
747
       ; let mr_bites = constrained_tvs `intersectsVarSet` zonked_tkvs
748
       ; warnTc (Reason Opt_WarnMonomorphism) (warn_mono && mr_bites) $
749
         hang (text "The Monomorphism Restriction applies to the binding"
750
               <> plural bndrs <+> text "for" <+> pp_bndrs)
751 752
             2 (text "Consider giving a type signature for"
                <+> if isSingleton bndrs then pp_bndrs
753
                                         else text "these binders")
754

755 756 757
       -- All done
       ; traceTc "decideQuantification 1" (vcat [ppr constraints, ppr gbl_tvs, ppr mono_tvs
                                                , ppr qtvs, ppr mr_bites])
758
       ; return (qtvs, []) }
759 760

  | otherwise
761
  = do { gbl_tvs <- tcGetGlobalTyCoVars
762
       ; let mono_tvs     = growThetaTyVars equality_constraints gbl_tvs
763
             tau_tvs_plus = growThetaTyVars constraints zonked_tau_tvs
764 765 766 767 768 769 770
       ; qtvs <- quantify_tvs sigs mono_tvs (Pair zonked_tau_kvs tau_tvs_plus)
          -- 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.

       ; constraints <- TcM.zonkTcTypes constraints
Simon Peyton Jones's avatar
Simon Peyton Jones committed
771
                 -- quantifyTyVars turned some meta tyvars into
772 773 774 775 776 777 778 779 780 781 782 783 784 785
                 -- quantified skolems, so we have to zonk again

       ; let theta     = pickQuantifiablePreds (mkVarSet qtvs) constraints
             min_theta = mkMinimalBySCs theta
               -- See Note [Minimize by Superclasses]

       ; traceTc "decideQuantification 2"
           (vcat [ text "constraints:"  <+> ppr constraints
                 , text "gbl_tvs:"      <+> ppr gbl_tvs
                 , text "mono_tvs:"     <+> ppr mono_tvs
                 , text "zonked_kvs:"   <+> ppr zonked_tau_kvs
                 , text "tau_tvs_plus:" <+> ppr tau_tvs_plus
                 , text "qtvs:"         <+> ppr qtvs
                 , text "min_theta:"    <+> ppr min_theta ])
786
       ; return (qtvs, min_theta) }
787
  where
788
    zonked_tkvs = zonked_tau_kvs `unionVarSet` zonked_tau_tvs
789 790
    bndrs    = map fst name_taus
    pp_bndrs = pprWithCommas (quotes . ppr) bndrs
791 792
    equality_constraints = filter isEqPred constraints

793 794 795 796 797 798
quantify_tvs :: [TcIdSigInfo]
             -> TcTyVarSet   -- the monomorphic tvs
             -> Pair TcTyVarSet   -- kvs, tvs to quantify
             -> TcM [TcTyVar]
-- See Note [Which type variables to quantify]
quantify_tvs sigs mono_tvs (Pair tau_kvs tau_tvs)
799 800
   -- NB: don't use quantifyZonkedTyVars because the sig stuff might
   -- be unzonked
801 802 803 804
  = quantifyTyVars (mono_tvs `delVarSetList` sig_qtvs)
                   (Pair tau_kvs
                         (tau_tvs `extendVarSetList` sig_qtvs
                                  `extendVarSetList` sig_wcs))
805 806 807 808 809
                   -- NB: quantifyTyVars zonks its arguments
  where
    sig_qtvs = [ skol | sig <- sigs, (_, skol) <- sig_skols sig ]
    sig_wcs  = [ wc   | TISI { sig_bndr = PartialSig { sig_wcs = wcs } } <- sigs
                      , (_, wc) <- wcs ]
810

811 812

------------------
813
growThetaTyVars :: ThetaType -> TyCoVarSet -> TyVarSet
814
-- See Note [Growing the tau-tvs using constraints]
815
-- NB: only returns tyvars, never covars
816
growThetaTyVars theta tvs
817 818 819
  | null theta = tvs_only
  | otherwise  = filterVarSet isTyVar $
                 transCloVarSet mk_next seed_tvs
820
  where
821 822
    tvs_only = filterVarSet isTyVar tvs
    seed_tvs = tvs `unionVarSet` tyCoVarsOfTypes ips
823
    (ips, non_ips) = partition isIPPred theta
824
                         -- See Note [Inheriting implicit parameters] in TcType
825 826 827 828 829 830

    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
831
       where
832
         pred_tvs = tyCoVarsOfType pred
833

834 835 836 837 838 839
{- Note [Which type variables to quantify]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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),
840
   for example by being free in the environment.
841

842
However, for a pattern binding, or with wildcards, we might
843
be doing inference *in the presence of a type signature*.
844 845
Mostly, if there is a signature we use CheckGen, not InferGen,
but with pattern bindings or wildcards we might do InferGen
846 847 848
and still have a type signature.  For example:
   f :: _ -> a
   f x = ...
849 850
or
   g :: (Eq _a) => _b -> _b
851 852 853
or
   p :: a -> a
   (p,q) = e
854
In all these cases we use plan InferGen, and hence call simplifyInfer.
855 856 857 858 859
But those 'a' variables are skolems, and we should be sure to quantify
over them, regardless of the monomorphism restriction etc.  If we
don't, when reporting a type error we panic when we find that a
skolem isn't bound by any enclosing implication.

860 861 862 863 864 865 866 867 868 869
Moreover we must quantify over all wildcards that are not free in
the environment.  In the case of 'g' for example, silly though it is,
we want to get the inferred type
   g :: forall t. Eq t => Int -> Int
and then report ambiguity, rather than *not* quantifying over 't'
and getting some much more mysterious error later.  A similar case
is
  h :: F _a -> Int

That's why we pass sigs to simplifyInfer, and make sure (in
870 871 872
quantify_tvs) that we do quantify over them.  Trac #10615 is
a case in point.

873 874 875 876 877 878 879 880
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
881
Should we quantify over the (F [a] ~ Int)?  Perhaps yes, because at the call
882 883 884 885
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.

886 887 888
Note [Growing the tau-tvs using constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(growThetaTyVars insts tvs) is the result of extending the set
889
    of tyvars, tvs, using all conceivable links from pred
890 891 892 893 894 895 896 897

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)

898 899 900 901 902 903 904 905
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
906

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

912 913
Note [Default while Inferring]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
914
Our current plan is that defaulting only happens at simplifyTop and
915
not simplifyInfer.  This may lead to some insoluble deferred constraints.
916 917
Example:

918
instance D g => C g Int b
919 920

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

923 924 925
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
926
  (forall b. 0 => D gamma)
927
Finally, we /can/ approximate this implication with (D gamma) and infer the quantified
928 929
type:  forall g. D g => g -> g

930
Instead what will currently happen is that we will get a quantified type
931 932 933
(forall g. g -> g) and an implication:
       forall g. 0 => (forall b. 0 => C g alpha b) /\ Num alpha

934
Which, even if the simplifyTop defaults (alpha := Int) we will still be left with an
935 936 937
unsolvable implication:
       forall g. 0 => (forall b. 0 => D g)

938
The concrete example would be:
939 940 941
       h :: C g a s => g -> a -> ST s a
       f (x::gamma) = (\_ -> x) (runST (h x (undefined::alpha)) + 1)

942 943
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
944 945 946 947
we don't do it for now.



948
Note [Minimize by Superclasses]
949
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
950 951 952 953 954 955 956
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.
957

958

959
Note [Avoid unnecessary constraint simplification]
960
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
961
    -------- NB NB NB (Jun 12) -------------
962 963 964
    This note not longer applies; see the notes with Trac #4361.
    But I'm leaving it in here so we remember the issue.)
    ----------------------------------------
965
When inferring the type of a let-binding, with simplifyInfer,
966
try to avoid unnecessarily simplifying class constraints.
967
Doing so aids sharing, but it also helps with delicate
968
situations like
969

970
   instance C t => C [t] where ..
971

972
   f :: C [t] => ....
973
   f x = let g y = ...(constraint C [t])...
974 975 976 977
         in ...
When inferring a type for 'g', we don't want to apply the
instance decl, because then we can't satisfy (C t).  So we
just notice that g isn't quantified over 't' and partition
Gabor Greif's avatar
Gabor Greif committed
978
the constraints before simplifying.
979 980 981

This only half-works, but then let-generalisation only half-works.

982
*********************************************************************************
983
*                                                                                 *
984 985 986
*                                 Main Simplifier                                 *
*                                                                                 *
***********************************************************************************
987

Austin Seipp's avatar
Austin Seipp committed
988
-}
989