{-# LANGUAGE CPP #-}

module TcSimplify(
       simplifyInfer, InferMode(..),
       growThetaTyVars,
       simplifyAmbiguityCheck,
       simplifyDefault,
       simplifyTop, simplifyTopImplic,
       simplifyInteractive,
       solveEqualities, solveLocalEqualities, solveLocalEqualitiesX,
       simplifyWantedsTcM,
       tcCheckSatisfiability,
       tcNormalise,

       captureTopConstraints,

       simpl_top,

       promoteTyVar,
       promoteTyVarSet,

       -- For Rules we need these
       solveWanteds, solveWantedsAndDrop,
       approximateWC, runTcSDeriveds
  ) where

#include "HsVersions.h"

import GhcPrelude

import Bag
import Class         ( Class, classKey, classTyCon )
import DynFlags      ( WarningFlag ( Opt_WarnMonomorphism )
                     , WarnReason ( Reason )
                     , DynFlags( solverIterations ) )
import HsExpr        ( UnboundVar(..) )
import Id            ( idType, mkLocalId )
import Inst
import ListSetOps
import Name
import Outputable
import PrelInfo
import PrelNames
import RdrName       ( emptyGlobalRdrEnv )
import TcErrors
import TcEvidence
import TcInteract
import TcCanonical   ( makeSuperClasses, solveCallStack )
import TcMType   as TcM
import TcRnMonad as TcM
import TcSMonad  as TcS
import TcType
import TrieMap       () -- DV: for now
import Type
import TysWiredIn    ( liftedRepTy )
import Unify         ( tcMatchTyKi )
import Util
import Var
import VarSet
import UniqSet
import BasicTypes    ( IntWithInf, intGtLimit )
import ErrUtils      ( emptyMessages )
import qualified GHC.LanguageExtensions as LangExt

import Control.Monad
import Data.Foldable      ( toList )
import Data.List          ( partition )
import Data.List.NonEmpty ( NonEmpty(..) )
import Maybes             ( isJust )

{-
*********************************************************************************
*                                                                               *
*                           External interface                                  *
*                                                                               *
*********************************************************************************
-}

captureTopConstraints :: TcM a -> TcM (a, WantedConstraints)
-- (captureTopConstraints m) runs m, and returns the type constraints it
-- generates plus the constraints produced by static forms inside.
-- If it fails with an exception, it reports any insolubles
-- (out of scope variables) before doing so
-- NB: bring any environments into scope before calling this, so that
-- the reportUnsolved has access to the most complete GlobalRdrEnv
captureTopConstraints :: TcM a -> TcM (a, WantedConstraints)
captureTopConstraints thing_inside :: TcM a
thing_inside
  = do { TcRef WantedConstraints
static_wc_var <- WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv (TcRef WantedConstraints)
forall a gbl lcl. a -> TcRnIf gbl lcl (TcRef a)
TcM.newTcRef WantedConstraints
emptyWC ;
       ; (mb_res :: Either IOEnvFailure a
mb_res, lie :: WantedConstraints
lie) <- (TcGblEnv -> TcGblEnv)
-> TcRnIf
     TcGblEnv TcLclEnv (Either IOEnvFailure a, WantedConstraints)
-> TcRnIf
     TcGblEnv TcLclEnv (Either IOEnvFailure a, WantedConstraints)
forall gbl lcl a.
(gbl -> gbl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
TcM.updGblEnv (\env :: TcGblEnv
env -> TcGblEnv
env { tcg_static_wc :: TcRef WantedConstraints
tcg_static_wc = TcRef WantedConstraints
static_wc_var } ) (TcRnIf
   TcGblEnv TcLclEnv (Either IOEnvFailure a, WantedConstraints)
 -> TcRnIf
      TcGblEnv TcLclEnv (Either IOEnvFailure a, WantedConstraints))
-> TcRnIf
     TcGblEnv TcLclEnv (Either IOEnvFailure a, WantedConstraints)
-> TcRnIf
     TcGblEnv TcLclEnv (Either IOEnvFailure a, WantedConstraints)
forall a b. (a -> b) -> a -> b
$
                          TcM a
-> TcRnIf
     TcGblEnv TcLclEnv (Either IOEnvFailure a, WantedConstraints)
forall a. TcM a -> TcM (Either IOEnvFailure a, WantedConstraints)
TcM.tryCaptureConstraints TcM a
thing_inside
       ; WantedConstraints
stWC <- TcRef WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a gbl lcl. TcRef a -> TcRnIf gbl lcl a
TcM.readTcRef TcRef WantedConstraints
static_wc_var

       -- See TcRnMonad Note [Constraints and errors]
       -- If the thing_inside threw an exception, but generated some insoluble
       -- constraints, report the latter before propagating the exception
       -- Otherwise they will be lost altogether
       ; case Either IOEnvFailure a
mb_res of
           Right res :: a
res -> (a, WantedConstraints) -> TcM (a, WantedConstraints)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
res, WantedConstraints
lie WantedConstraints -> WantedConstraints -> WantedConstraints
`andWC` WantedConstraints
stWC)
           Left {}   -> do { Bag EvBind
_ <- WantedConstraints -> TcM (Bag EvBind)
reportUnsolved WantedConstraints
lie; TcM (a, WantedConstraints)
forall env a. IOEnv env a
failM } }
                -- This call to reportUnsolved is the reason
                -- this function is here instead of TcRnMonad

simplifyTopImplic :: Bag Implication -> TcM ()
simplifyTopImplic :: Bag Implication -> TcM ()
simplifyTopImplic implics :: Bag Implication
implics
  = do { Bag EvBind
empty_binds <- WantedConstraints -> TcM (Bag EvBind)
simplifyTop (Bag Implication -> WantedConstraints
mkImplicWC Bag Implication
implics)

       -- Since all the inputs are implications the returned bindings will be empty
       ; MASSERT2( isEmptyBag empty_binds, ppr empty_binds )

       ; () -> TcM ()
forall (m :: * -> *) a. Monad m => a -> m a
return () }

simplifyTop :: WantedConstraints -> TcM (Bag EvBind)
-- Simplify top-level constraints
-- 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
simplifyTop :: WantedConstraints -> TcM (Bag EvBind)
simplifyTop wanteds :: WantedConstraints
wanteds
  = do { String -> SDoc -> TcM ()
traceTc "simplifyTop {" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$ String -> SDoc
text "wanted = " SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanteds
       ; ((final_wc :: WantedConstraints
final_wc, unsafe_ol :: Cts
unsafe_ol), binds1 :: EvBindMap
binds1) <- TcS (WantedConstraints, Cts)
-> TcM ((WantedConstraints, Cts), EvBindMap)
forall a. TcS a -> TcM (a, EvBindMap)
runTcS (TcS (WantedConstraints, Cts)
 -> TcM ((WantedConstraints, Cts), EvBindMap))
-> TcS (WantedConstraints, Cts)
-> TcM ((WantedConstraints, Cts), EvBindMap)
forall a b. (a -> b) -> a -> b
$
            do { WantedConstraints
final_wc <- WantedConstraints -> TcS WantedConstraints
simpl_top WantedConstraints
wanteds
               ; Cts
unsafe_ol <- TcS Cts
getSafeOverlapFailures
               ; (WantedConstraints, Cts) -> TcS (WantedConstraints, Cts)
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints
final_wc, Cts
unsafe_ol) }
       ; String -> SDoc -> TcM ()
traceTc "End simplifyTop }" SDoc
empty

       ; Bag EvBind
binds2 <- WantedConstraints -> TcM (Bag EvBind)
reportUnsolved WantedConstraints
final_wc

       ; String -> SDoc -> TcM ()
traceTc "reportUnsolved (unsafe overlapping) {" SDoc
empty
       ; Bool -> TcM () -> TcM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Cts -> Bool
isEmptyCts Cts
unsafe_ol) (TcM () -> TcM ()) -> TcM () -> TcM ()
forall a b. (a -> b) -> a -> b
$ do {
           -- grab current error messages and clear, warnAllUnsolved will
           -- update error messages which we'll grab and then restore saved
           -- messages.
           ; TcRef Messages
errs_var  <- TcRn (TcRef Messages)
getErrsVar
           ; Messages
saved_msg <- TcRef Messages -> TcRnIf TcGblEnv TcLclEnv Messages
forall a gbl lcl. TcRef a -> TcRnIf gbl lcl a
TcM.readTcRef TcRef Messages
errs_var
           ; TcRef Messages -> Messages -> TcM ()
forall a gbl lcl. TcRef a -> a -> TcRnIf gbl lcl ()
TcM.writeTcRef TcRef Messages
errs_var Messages
emptyMessages

           ; WantedConstraints -> TcM ()
warnAllUnsolved (WantedConstraints -> TcM ()) -> WantedConstraints -> TcM ()
forall a b. (a -> b) -> a -> b
$ WC :: Cts -> Bag Implication -> WantedConstraints
WC { wc_simple :: Cts
wc_simple = Cts
unsafe_ol
                                  , wc_impl :: Bag Implication
wc_impl = Bag Implication
forall a. Bag a
emptyBag }

           ; WarningMessages
whyUnsafe <- Messages -> WarningMessages
forall a b. (a, b) -> a
fst (Messages -> WarningMessages)
-> TcRnIf TcGblEnv TcLclEnv Messages
-> IOEnv (Env TcGblEnv TcLclEnv) WarningMessages
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TcRef Messages -> TcRnIf TcGblEnv TcLclEnv Messages
forall a gbl lcl. TcRef a -> TcRnIf gbl lcl a
TcM.readTcRef TcRef Messages
errs_var
           ; TcRef Messages -> Messages -> TcM ()
forall a gbl lcl. TcRef a -> a -> TcRnIf gbl lcl ()
TcM.writeTcRef TcRef Messages
errs_var Messages
saved_msg
           ; WarningMessages -> TcM ()
recordUnsafeInfer WarningMessages
whyUnsafe
           }
       ; String -> SDoc -> TcM ()
traceTc "reportUnsolved (unsafe overlapping) }" SDoc
empty

       ; Bag EvBind -> TcM (Bag EvBind)
forall (m :: * -> *) a. Monad m => a -> m a
return (EvBindMap -> Bag EvBind
evBindMapBinds EvBindMap
binds1 Bag EvBind -> Bag EvBind -> Bag EvBind
forall a. Bag a -> Bag a -> Bag a
`unionBags` Bag EvBind
binds2) }


-- | Type-check a thing that emits only equality constraints, solving any
-- constraints we can and re-emitting constraints that we can't. The thing_inside
-- should generally bump the TcLevel to make sure that this run of the solver
-- doesn't affect anything lying around.
solveLocalEqualities :: String -> TcM a -> TcM a
solveLocalEqualities :: String -> TcM a -> TcM a
solveLocalEqualities callsite :: String
callsite thing_inside :: TcM a
thing_inside
  = do { (wanted :: WantedConstraints
wanted, res :: a
res) <- String -> TcM a -> TcM (WantedConstraints, a)
forall a. String -> TcM a -> TcM (WantedConstraints, a)
solveLocalEqualitiesX String
callsite TcM a
thing_inside
       ; WantedConstraints -> TcM ()
emitConstraints WantedConstraints
wanted

       -- See Note [Fail fast if there are insoluble kind equalities]
       ; Bool -> TcM () -> TcM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (WantedConstraints -> Bool
insolubleWC WantedConstraints
wanted) (TcM () -> TcM ()) -> TcM () -> TcM ()
forall a b. (a -> b) -> a -> b
$
           TcM ()
forall env a. IOEnv env a
failM

       ; a -> TcM a
forall (m :: * -> *) a. Monad m => a -> m a
return a
res }

{- Note [Fail fast if there are insoluble kind equalities]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Rather like in simplifyInfer, fail fast if there is an insoluble
constraint.  Otherwise we'll just succeed in kind-checking a nonsense
type, with a cascade of follow-up errors.

For example polykinds/T12593, T15577, and many others.

Take care to ensure that you emit the insoluble constraints before
failing, because they are what will ulimately lead to the error
messsage!
-}

solveLocalEqualitiesX :: String -> TcM a -> TcM (WantedConstraints, a)
solveLocalEqualitiesX :: String -> TcM a -> TcM (WantedConstraints, a)
solveLocalEqualitiesX callsite :: String
callsite thing_inside :: TcM a
thing_inside
  = do { String -> SDoc -> TcM ()
traceTc "solveLocalEqualitiesX {" ([SDoc] -> SDoc
vcat [ String -> SDoc
text "Called from" SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
callsite ])

       ; (result :: a
result, wanted :: WantedConstraints
wanted) <- TcM a -> TcM (a, WantedConstraints)
forall a. TcM a -> TcM (a, WantedConstraints)
captureConstraints TcM a
thing_inside

       ; String -> SDoc -> TcM ()
traceTc "solveLocalEqualities: running solver" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanted)
       ; WantedConstraints
residual_wanted <- TcS WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. TcS a -> TcM a
runTcSEqualities (WantedConstraints -> TcS WantedConstraints
solveWanteds WantedConstraints
wanted)

       ; String -> SDoc -> TcM ()
traceTc "solveLocalEqualitiesX end }" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$
         String -> SDoc
text "residual_wanted =" SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
residual_wanted

       ; (WantedConstraints, a) -> TcM (WantedConstraints, a)
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints
residual_wanted, a
result) }

-- | Type-check a thing that emits only equality constraints, then
-- solve those constraints. Fails outright if there is trouble.
-- Use this if you're not going to get another crack at solving
-- (because, e.g., you're checking a datatype declaration)
solveEqualities :: TcM a -> TcM a
solveEqualities :: TcM a -> TcM a
solveEqualities thing_inside :: TcM a
thing_inside
  = TcM a -> TcM a
forall r. TcM r -> TcM r
checkNoErrs (TcM a -> TcM a) -> TcM a -> TcM a
forall a b. (a -> b) -> a -> b
$  -- See Note [Fail fast on kind errors]
    do { TcLevel
lvl <- TcM TcLevel
TcM.getTcLevel
       ; String -> SDoc -> TcM ()
traceTc "solveEqualities {" (String -> SDoc
text "level =" SDoc -> SDoc -> SDoc
<+> TcLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcLevel
lvl)

       ; (result :: a
result, wanted :: WantedConstraints
wanted) <- TcM a -> TcM (a, WantedConstraints)
forall a. TcM a -> TcM (a, WantedConstraints)
captureConstraints TcM a
thing_inside

       ; String -> SDoc -> TcM ()
traceTc "solveEqualities: running solver" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$ String -> SDoc
text "wanted = " SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanted
       ; WantedConstraints
final_wc <- TcS WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. TcS a -> TcM a
runTcSEqualities (TcS WantedConstraints
 -> TcRnIf TcGblEnv TcLclEnv WantedConstraints)
-> TcS WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a b. (a -> b) -> a -> b
$ WantedConstraints -> TcS WantedConstraints
simpl_top WantedConstraints
wanted
          -- NB: Use simpl_top here so that we potentially default RuntimeRep
          -- vars to LiftedRep. This is needed to avoid #14991.

       ; String -> SDoc -> TcM ()
traceTc "End solveEqualities }" SDoc
empty
       ; WantedConstraints -> TcM ()
reportAllUnsolved WantedConstraints
final_wc
       ; a -> TcM a
forall (m :: * -> *) a. Monad m => a -> m a
return a
result }

-- | Simplify top-level constraints, but without reporting any unsolved
-- constraints nor unsafe overlapping.
simpl_top :: WantedConstraints -> TcS WantedConstraints
    -- See Note [Top-level Defaulting Plan]
simpl_top :: WantedConstraints -> TcS WantedConstraints
simpl_top wanteds :: WantedConstraints
wanteds
  = do { WantedConstraints
wc_first_go <- TcS WantedConstraints -> TcS WantedConstraints
forall a. TcS a -> TcS a
nestTcS (WantedConstraints -> TcS WantedConstraints
solveWantedsAndDrop WantedConstraints
wanteds)
                            -- This is where the main work happens
       ; WantedConstraints -> TcS WantedConstraints
try_tyvar_defaulting WantedConstraints
wc_first_go }
  where
    try_tyvar_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_tyvar_defaulting :: WantedConstraints -> TcS WantedConstraints
try_tyvar_defaulting wc :: WantedConstraints
wc
      | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wc
      = WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wc
      | Bool
otherwise
      = do { [TcTyCoVar]
free_tvs <- [TcTyCoVar] -> TcS [TcTyCoVar]
TcS.zonkTyCoVarsAndFVList (WantedConstraints -> [TcTyCoVar]
tyCoVarsOfWCList WantedConstraints
wc)
           ; let meta_tvs :: [TcTyCoVar]
meta_tvs = (TcTyCoVar -> Bool) -> [TcTyCoVar] -> [TcTyCoVar]
forall a. (a -> Bool) -> [a] -> [a]
filter (TcTyCoVar -> Bool
isTyVar (TcTyCoVar -> Bool) -> (TcTyCoVar -> Bool) -> TcTyCoVar -> Bool
forall (f :: * -> *). Applicative f => f Bool -> f Bool -> f Bool
<&&> TcTyCoVar -> Bool
isMetaTyVar) [TcTyCoVar]
free_tvs
                   -- zonkTyCoVarsAndFV: the wc_first_go is not yet zonked
                   -- filter isMetaTyVar: we might have runtime-skolems in GHCi,
                   -- and we definitely don't want to try to assign to those!
                   -- The isTyVar is needed to weed out coercion variables

           ; [Bool]
defaulted <- (TcTyCoVar -> TcS Bool) -> [TcTyCoVar] -> TcS [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM TcTyCoVar -> TcS Bool
defaultTyVarTcS [TcTyCoVar]
meta_tvs   -- Has unification side effects
           ; if [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
defaulted
             then do { WantedConstraints
wc_residual <- TcS WantedConstraints -> TcS WantedConstraints
forall a. TcS a -> TcS a
nestTcS (WantedConstraints -> TcS WantedConstraints
solveWanteds WantedConstraints
wc)
                            -- See Note [Must simplify after defaulting]
                     ; WantedConstraints -> TcS WantedConstraints
try_class_defaulting WantedConstraints
wc_residual }
             else WantedConstraints -> TcS WantedConstraints
try_class_defaulting WantedConstraints
wc }     -- No defaulting took place

    try_class_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_class_defaulting :: WantedConstraints -> TcS WantedConstraints
try_class_defaulting wc :: WantedConstraints
wc
      | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wc
      = WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wc
      | Bool
otherwise  -- See Note [When to do type-class defaulting]
      = do { Bool
something_happened <- WantedConstraints -> TcS Bool
applyDefaultingRules WantedConstraints
wc
                                   -- See Note [Top-level Defaulting Plan]
           ; if Bool
something_happened
             then do { WantedConstraints
wc_residual <- TcS WantedConstraints -> TcS WantedConstraints
forall a. TcS a -> TcS a
nestTcS (WantedConstraints -> TcS WantedConstraints
solveWantedsAndDrop WantedConstraints
wc)
                     ; WantedConstraints -> TcS WantedConstraints
try_class_defaulting WantedConstraints
wc_residual }
                  -- See Note [Overview of implicit CallStacks] in TcEvidence
             else WantedConstraints -> TcS WantedConstraints
try_callstack_defaulting WantedConstraints
wc }

    try_callstack_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_callstack_defaulting :: WantedConstraints -> TcS WantedConstraints
try_callstack_defaulting wc :: WantedConstraints
wc
      | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wc
      = WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wc
      | Bool
otherwise
      = WantedConstraints -> TcS WantedConstraints
defaultCallStacks WantedConstraints
wc

-- | Default any remaining @CallStack@ constraints to empty @CallStack@s.
defaultCallStacks :: WantedConstraints -> TcS WantedConstraints
-- See Note [Overview of implicit CallStacks] in TcEvidence
defaultCallStacks :: WantedConstraints -> TcS WantedConstraints
defaultCallStacks wanteds :: WantedConstraints
wanteds
  = do Cts
simples <- Cts -> TcS Cts
handle_simples (WantedConstraints -> Cts
wc_simple WantedConstraints
wanteds)
       Bag (Maybe Implication)
mb_implics <- (Implication -> TcS (Maybe Implication))
-> Bag Implication -> TcS (Bag (Maybe Implication))
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bag a -> m (Bag b)
mapBagM Implication -> TcS (Maybe Implication)
handle_implic (WantedConstraints -> Bag Implication
wc_impl WantedConstraints
wanteds)
       WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints
wanteds { wc_simple :: Cts
wc_simple = Cts
simples
                       , wc_impl :: Bag Implication
wc_impl = Bag (Maybe Implication) -> Bag Implication
forall a. Bag (Maybe a) -> Bag a
catBagMaybes Bag (Maybe Implication)
mb_implics })

  where

  handle_simples :: Cts -> TcS Cts
handle_simples simples :: Cts
simples
    = Bag (Maybe Ct) -> Cts
forall a. Bag (Maybe a) -> Bag a
catBagMaybes (Bag (Maybe Ct) -> Cts) -> TcS (Bag (Maybe Ct)) -> TcS Cts
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ct -> TcS (Maybe Ct)) -> Cts -> TcS (Bag (Maybe Ct))
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bag a -> m (Bag b)
mapBagM Ct -> TcS (Maybe Ct)
defaultCallStack Cts
simples

  handle_implic :: Implication -> TcS (Maybe Implication)
  -- The Maybe is because solving the CallStack constraint
  -- may well allow us to discard the implication entirely
  handle_implic :: Implication -> TcS (Maybe Implication)
handle_implic implic :: Implication
implic
    | ImplicStatus -> Bool
isSolvedStatus (Implication -> ImplicStatus
ic_status Implication
implic)
    = Maybe Implication -> TcS (Maybe Implication)
forall (m :: * -> *) a. Monad m => a -> m a
return (Implication -> Maybe Implication
forall a. a -> Maybe a
Just Implication
implic)
    | Bool
otherwise
    = do { WantedConstraints
wanteds <- EvBindsVar -> TcS WantedConstraints -> TcS WantedConstraints
forall a. EvBindsVar -> TcS a -> TcS a
setEvBindsTcS (Implication -> EvBindsVar
ic_binds Implication
implic) (TcS WantedConstraints -> TcS WantedConstraints)
-> TcS WantedConstraints -> TcS WantedConstraints
forall a b. (a -> b) -> a -> b
$
                      -- defaultCallStack sets a binding, so
                      -- we must set the correct binding group
                      WantedConstraints -> TcS WantedConstraints
defaultCallStacks (Implication -> WantedConstraints
ic_wanted Implication
implic)
         ; Implication -> TcS (Maybe Implication)
setImplicationStatus (Implication
implic { ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints
wanteds }) }

  defaultCallStack :: Ct -> TcS (Maybe Ct)
defaultCallStack ct :: Ct
ct
    | ClassPred cls :: Class
cls tys :: [Type]
tys <- Type -> PredTree
classifyPredType (Ct -> Type
ctPred Ct
ct)
    , Just {} <- Class -> [Type] -> Maybe FastString
isCallStackPred Class
cls [Type]
tys
    = do { CtEvidence -> EvCallStack -> TcS ()
solveCallStack (Ct -> CtEvidence
ctEvidence Ct
ct) EvCallStack
EvCsEmpty
         ; Maybe Ct -> TcS (Maybe Ct)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Ct
forall a. Maybe a
Nothing }

  defaultCallStack ct :: Ct
ct
    = Maybe Ct -> TcS (Maybe Ct)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ct -> Maybe Ct
forall a. a -> Maybe a
Just Ct
ct)


{- 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:

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

  * 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
           <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!

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
   run = fromInteger 0
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)
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
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.

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.

Note [Top-level Defaulting Plan]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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
       simple constraints, maybe deep inside the context of implications.
       This used to be the case in GHC 7.4.1.
   (ii) Do it in a tight loop at simplifyTop, once all other constraints have
        finished. This is the current story.

Option (i) had many disadvantages:
   a) Firstly, it was deep inside the actual solver.
   b) Secondly, it was dependent on the context (Infer a type signature,
      or Check a type signature, or Interactive) since we did not want
      to always start defaulting when inferring (though there is an exception to
      this, see Note [Default while Inferring]).
   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
go with option (ii), implemented at SimplifyTop. Namely:
     - First, have a go at solving the residual constraint of the whole
       program
     - Try to approximate it with a simple constraint
     - Figure out derived defaulting equations for that simple constraint
     - 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:
     - At the top-level, once you had a go at solving the constraint, do
       figure out /all/ the touchable unification variables of the wanted constraints.
     - Apply defaulting to their kinds

More details in Note [DefaultTyVar].

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]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

 1) `InstEnv.lookupInstEnv` -- Performs instance resolution, so this is where
    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.

 2) `TcInteract.matchClassInst` -- This module drives the instance resolution
    / dictionary generation. The return type is `ClsInstResult`, which either
    says no instance matched, or one found, and if it was a safe or unsafe
    overlap.

 3) `TcInteract.doTopReactDict` -- Takes a dictionary / class constraint and
     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.

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.
-}

------------------
simplifyAmbiguityCheck :: Type -> WantedConstraints -> TcM ()
simplifyAmbiguityCheck :: Type -> WantedConstraints -> TcM ()
simplifyAmbiguityCheck ty :: Type
ty wanteds :: WantedConstraints
wanteds
  = do { String -> SDoc -> TcM ()
traceTc "simplifyAmbiguityCheck {" (String -> SDoc
text "type = " SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
ty SDoc -> SDoc -> SDoc
$$ String -> SDoc
text "wanted = " SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanteds)
       ; (final_wc :: WantedConstraints
final_wc, _) <- TcS WantedConstraints -> TcM (WantedConstraints, EvBindMap)
forall a. TcS a -> TcM (a, EvBindMap)
runTcS (TcS WantedConstraints -> TcM (WantedConstraints, EvBindMap))
-> TcS WantedConstraints -> TcM (WantedConstraints, EvBindMap)
forall a b. (a -> b) -> a -> b
$ WantedConstraints -> TcS WantedConstraints
solveWantedsAndDrop WantedConstraints
wanteds
             -- NB: no defaulting!  See Note [No defaulting in the ambiguity check]

       ; String -> SDoc -> TcM ()
traceTc "End simplifyAmbiguityCheck }" SDoc
empty

       -- Normally report all errors; but with -XAllowAmbiguousTypes
       -- report only insoluble ones, since they represent genuinely
       -- inaccessible code
       ; Bool
allow_ambiguous <- Extension -> TcRnIf TcGblEnv TcLclEnv Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.AllowAmbiguousTypes
       ; String -> SDoc -> TcM ()
traceTc "reportUnsolved(ambig) {" SDoc
empty
       ; Bool -> TcM () -> TcM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Bool
allow_ambiguous Bool -> Bool -> Bool
&& Bool -> Bool
not (WantedConstraints -> Bool
insolubleWC WantedConstraints
final_wc))
                (TcM (Bag EvBind) -> TcM ()
forall a. TcM a -> TcM ()
discardResult (WantedConstraints -> TcM (Bag EvBind)
reportUnsolved WantedConstraints
final_wc))
       ; String -> SDoc -> TcM ()
traceTc "reportUnsolved(ambig) }" SDoc
empty

       ; () -> TcM ()
forall (m :: * -> *) a. Monad m => a -> m a
return () }

------------------
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
simplifyInteractive wanteds :: WantedConstraints
wanteds
  = String -> SDoc -> TcM ()
traceTc "simplifyInteractive" SDoc
empty TcM () -> TcM (Bag EvBind) -> TcM (Bag EvBind)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    WantedConstraints -> TcM (Bag EvBind)
simplifyTop WantedConstraints
wanteds

------------------
simplifyDefault :: ThetaType    -- Wanted; has no type variables in it
                -> TcM ()       -- Succeeds if the constraint is soluble
simplifyDefault :: [Type] -> TcM ()
simplifyDefault theta :: [Type]
theta
  = do { String -> SDoc -> TcM ()
traceTc "simplifyDefault" SDoc
empty
       ; [CtEvidence]
wanteds  <- CtOrigin -> [Type] -> TcM [CtEvidence]
newWanteds CtOrigin
DefaultOrigin [Type]
theta
       ; WantedConstraints
unsolved <- TcS WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. TcS a -> TcM a
runTcSDeriveds (WantedConstraints -> TcS WantedConstraints
solveWantedsAndDrop ([CtEvidence] -> WantedConstraints
mkSimpleWC [CtEvidence]
wanteds))
       ; WantedConstraints -> TcM ()
reportAllUnsolved WantedConstraints
unsolved
       ; () -> TcM ()
forall (m :: * -> *) a. Monad m => a -> m a
return () }

------------------
tcCheckSatisfiability :: Bag EvVar -> TcM Bool
-- Return True if satisfiable, False if definitely contradictory
tcCheckSatisfiability :: Bag TcTyCoVar -> TcRnIf TcGblEnv TcLclEnv Bool
tcCheckSatisfiability given_ids :: Bag TcTyCoVar
given_ids
  = do { TcLclEnv
lcl_env <- TcRnIf TcGblEnv TcLclEnv TcLclEnv
forall gbl lcl. TcRnIf gbl lcl lcl
TcM.getLclEnv
       ; let given_loc :: CtLoc
given_loc = TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
topTcLevel SkolemInfo
UnkSkol TcLclEnv
lcl_env
       ; (res :: Bool
res, _ev_binds :: EvBindMap
_ev_binds) <- TcS Bool -> TcM (Bool, EvBindMap)
forall a. TcS a -> TcM (a, EvBindMap)
runTcS (TcS Bool -> TcM (Bool, EvBindMap))
-> TcS Bool -> TcM (Bool, EvBindMap)
forall a b. (a -> b) -> a -> b
$
             do { String -> SDoc -> TcS ()
traceTcS "checkSatisfiability {" (Bag TcTyCoVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bag TcTyCoVar
given_ids)
                ; let given_cts :: [Ct]
given_cts = CtLoc -> [TcTyCoVar] -> [Ct]
mkGivens CtLoc
given_loc (Bag TcTyCoVar -> [TcTyCoVar]
forall a. Bag a -> [a]
bagToList Bag TcTyCoVar
given_ids)
                     -- See Note [Superclasses and satisfiability]
                ; [Ct] -> TcS ()
solveSimpleGivens [Ct]
given_cts
                ; Cts
insols <- TcS Cts
getInertInsols
                ; Cts
insols <- Cts -> TcS Cts
try_harder Cts
insols
                ; String -> SDoc -> TcS ()
traceTcS "checkSatisfiability }" (Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
insols)
                ; Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Cts -> Bool
forall a. Bag a -> Bool
isEmptyBag Cts
insols) }
       ; Bool -> TcRnIf TcGblEnv TcLclEnv Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
res }
 where
    try_harder :: Cts -> TcS Cts
    -- Maybe we have to search up the superclass chain to find
    -- an unsatisfiable constraint.  Example: pmcheck/T3927b.
    -- At the moment we try just once
    try_harder :: Cts -> TcS Cts
try_harder insols :: Cts
insols
      | Bool -> Bool
not (Cts -> Bool
forall a. Bag a -> Bool
isEmptyBag Cts
insols)   -- We've found that it's definitely unsatisfiable
      = Cts -> TcS Cts
forall (m :: * -> *) a. Monad m => a -> m a
return Cts
insols             -- Hurrah -- stop now.
      | Bool
otherwise
      = do { [Ct]
pending_given <- TcS [Ct]
getPendingGivenScs
           ; [Ct]
new_given <- [Ct] -> TcS [Ct]
makeSuperClasses [Ct]
pending_given
           ; [Ct] -> TcS ()
solveSimpleGivens [Ct]
new_given
           ; TcS Cts
getInertInsols }

-- | Normalise a type as much as possible using the given constraints.
-- See @Note [tcNormalise]@.
tcNormalise :: Bag EvVar -> Type -> TcM Type
tcNormalise :: Bag TcTyCoVar -> Type -> TcM Type
tcNormalise given_ids :: Bag TcTyCoVar
given_ids ty :: Type
ty
  = do { TcLclEnv
lcl_env <- TcRnIf TcGblEnv TcLclEnv TcLclEnv
forall gbl lcl. TcRnIf gbl lcl lcl
TcM.getLclEnv
       ; let given_loc :: CtLoc
given_loc = TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
topTcLevel SkolemInfo
UnkSkol TcLclEnv
lcl_env
       ; Ct
wanted_ct <- TcM Ct
mk_wanted_ct
       ; (res :: Type
res, _ev_binds :: EvBindMap
_ev_binds) <- TcS Type -> TcM (Type, EvBindMap)
forall a. TcS a -> TcM (a, EvBindMap)
runTcS (TcS Type -> TcM (Type, EvBindMap))
-> TcS Type -> TcM (Type, EvBindMap)
forall a b. (a -> b) -> a -> b
$
             do { String -> SDoc -> TcS ()
traceTcS "tcNormalise {" (Bag TcTyCoVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bag TcTyCoVar
given_ids)
                ; let given_cts :: [Ct]
given_cts = CtLoc -> [TcTyCoVar] -> [Ct]
mkGivens CtLoc
given_loc (Bag TcTyCoVar -> [TcTyCoVar]
forall a. Bag a -> [a]
bagToList Bag TcTyCoVar
given_ids)
                ; [Ct] -> TcS ()
solveSimpleGivens [Ct]
given_cts
                ; WantedConstraints
wcs <- Cts -> TcS WantedConstraints
solveSimpleWanteds (Ct -> Cts
forall a. a -> Bag a
unitBag Ct
wanted_ct)
                  -- It's an invariant that this wc_simple will always be
                  -- a singleton Ct, since that's what we fed in as input.
                ; let ty' :: Type
ty' = case Cts -> [Ct]
forall a. Bag a -> [a]
bagToList (WantedConstraints -> Cts
wc_simple WantedConstraints
wcs) of
                              (ct :: Ct
ct:_) -> CtEvidence -> Type
ctEvPred (Ct -> CtEvidence
ctEvidence Ct
ct)
                              cts :: [Ct]
cts    -> String -> SDoc -> Type
forall a. HasCallStack => String -> SDoc -> a
pprPanic "tcNormalise" ([Ct] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Ct]
cts)
                ; String -> SDoc -> TcS ()
traceTcS "tcNormalise }" (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
ty')
                ; Type -> TcS Type
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
ty' }
       ; Type -> TcM Type
forall (m :: * -> *) a. Monad m => a -> m a
return Type
res }
  where
    mk_wanted_ct :: TcM Ct
    mk_wanted_ct :: TcM Ct
mk_wanted_ct = do
      let occ :: OccName
occ = String -> OccName
mkVarOcc "$tcNorm"
      Name
name <- OccName -> TcRnIf TcGblEnv TcLclEnv Name
forall gbl lcl. OccName -> TcRnIf gbl lcl Name
newSysName OccName
occ
      let ev :: TcTyCoVar
ev = Name -> Type -> TcTyCoVar
mkLocalId Name
name Type
ty
          hole :: Hole
hole = UnboundVar -> Hole
ExprHole (UnboundVar -> Hole) -> UnboundVar -> Hole
forall a b. (a -> b) -> a -> b
$ OccName -> GlobalRdrEnv -> UnboundVar
OutOfScope OccName
occ GlobalRdrEnv
emptyGlobalRdrEnv
      Hole -> TcTyCoVar -> Type -> TcM Ct
newHoleCt Hole
hole TcTyCoVar
ev Type
ty

{- Note [Superclasses 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 recursive 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.

Note [tcNormalise]
~~~~~~~~~~~~~~~~~~
tcNormalise is a rather atypical entrypoint to the constraint solver. Whereas
most invocations of the constraint solver are intended to simplify a set of
constraints or to decide if a particular set of constraints is satisfiable,
the purpose of tcNormalise is to take a type, plus some local constraints, and
normalise the type as much as possible with respect to those constraints.

Why is this useful? As one example, when coverage-checking an EmptyCase
expression, it's possible that the type of the scrutinee will only reduce
if some local equalities are solved for. See "Wrinkle: Local equalities"
in Note [Type normalisation for EmptyCase] in Check.

To accomplish its stated goal, tcNormalise first feeds the local constraints
into solveSimpleGivens, then stuffs the argument type in a CHoleCan, and feeds
that singleton Ct into solveSimpleWanteds, which reduces the type in the
CHoleCan as much as possible with respect to the local given constraints. When
solveSimpleWanteds is finished, we dig out the type from the CHoleCan and
return that.

***********************************************************************************
*                                                                                 *
*                            Inference
*                                                                                 *
***********************************************************************************

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
        pushLevelAndCaptureConstraints (tcMonoBinds...)
   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,
   here called rhs_tclvl.

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

-}

-- | 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 :: InferMode -> SDoc
ppr ApplyMR         = String -> SDoc
text "ApplyMR"
  ppr EagerDefaulting = String -> SDoc
text "EagerDefaulting"
  ppr NoRestrictions  = String -> SDoc
text "NoRestrictions"

simplifyInfer :: TcLevel               -- Used when generating the constraints
              -> InferMode
              -> [TcIdSigInst]         -- Any signatures (possibly partial)
              -> [(Name, TcTauType)]   -- Variables to be generalised,
                                       -- and their tau-types
              -> WantedConstraints
              -> TcM ([TcTyVar],    -- Quantify over these type variables
                      [EvVar],      -- ... and these constraints (fully zonked)
                      TcEvBinds,    -- ... binding these evidence variables
                      WantedConstraints, -- Redidual as-yet-unsolved constraints
                      Bool)         -- True <=> the residual constraints are insoluble

simplifyInfer :: TcLevel
-> InferMode
-> [TcIdSigInst]
-> [(Name, Type)]
-> WantedConstraints
-> TcM
     ([TcTyCoVar], [TcTyCoVar], TcEvBinds, WantedConstraints, Bool)
simplifyInfer rhs_tclvl :: TcLevel
rhs_tclvl infer_mode :: InferMode
infer_mode sigs :: [TcIdSigInst]
sigs name_taus :: [(Name, Type)]
name_taus wanteds :: WantedConstraints
wanteds
  | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wanteds
   = do { -- When quantifying, we want to preserve any order of variables as they
          -- appear in partial signatures. cf. decideQuantifiedTyVars
          let psig_tv_tys :: [Type]
psig_tv_tys = [ TcTyCoVar -> Type
mkTyVarTy TcTyCoVar
tv | TcIdSigInst
sig <- [TcIdSigInst]
partial_sigs
                                          , (_,tv :: TcTyCoVar
tv) <- TcIdSigInst -> [(Name, TcTyCoVar)]
sig_inst_skols TcIdSigInst
sig ]
              psig_theta :: [Type]
psig_theta  = [ Type
pred | TcIdSigInst
sig <- [TcIdSigInst]
partial_sigs
                                   , Type
pred <- TcIdSigInst -> [Type]
sig_inst_theta TcIdSigInst
sig ]

       ; TcTyVarSet
gbl_tvs <- TcM TcTyVarSet
tcGetGlobalTyCoVars
       ; CandidatesQTvs
dep_vars <- [Type] -> TcM CandidatesQTvs
candidateQTyVarsOfTypes ([Type]
psig_tv_tys [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
psig_theta [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ ((Name, Type) -> Type) -> [(Name, Type)] -> [Type]
forall a b. (a -> b) -> [a] -> [b]
map (Name, Type) -> Type
forall a b. (a, b) -> b
snd [(Name, Type)]
name_taus)
       ; [TcTyCoVar]
qtkvs <- TcTyVarSet -> CandidatesQTvs -> TcM [TcTyCoVar]
quantifyTyVars TcTyVarSet
gbl_tvs CandidatesQTvs
dep_vars
       ; String -> SDoc -> TcM ()
traceTc "simplifyInfer: empty WC" ([(Name, Type)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(Name, Type)]
name_taus SDoc -> SDoc -> SDoc
$$ [TcTyCoVar] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TcTyCoVar]
qtkvs)
       ; ([TcTyCoVar], [TcTyCoVar], TcEvBinds, WantedConstraints, Bool)
-> TcM
     ([TcTyCoVar], [TcTyCoVar], TcEvBinds, WantedConstraints, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return ([TcTyCoVar]
qtkvs, [], TcEvBinds
emptyTcEvBinds, WantedConstraints
emptyWC, Bool
False) }

  | Bool
otherwise
  = do { String -> SDoc -> TcM ()
traceTc "simplifyInfer {"  (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
vcat
             [ String -> SDoc
text "sigs =" SDoc -> SDoc -> SDoc
<+> [TcIdSigInst] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TcIdSigInst]
sigs
             , String -> SDoc
text "binds =" SDoc -> SDoc -> SDoc
<+> [(Name, Type)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(Name, Type)]
name_taus
             , String -> SDoc
text "rhs_tclvl =" SDoc -> SDoc -> SDoc
<+> TcLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcLevel
rhs_tclvl
             , String -> SDoc
text "infer_mode =" SDoc -> SDoc -> SDoc
<+> InferMode -> SDoc
forall a. Outputable a => a -> SDoc
ppr InferMode
infer_mode
             , String -> SDoc
text "(unzonked) wanted =" SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanteds
             ]

       ; let psig_theta :: [Type]
psig_theta = (TcIdSigInst -> [Type]) -> [TcIdSigInst] -> [Type]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TcIdSigInst -> [Type]
sig_inst_theta [TcIdSigInst]
partial_sigs

       -- 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.

       ; Env TcGblEnv TcLclEnv
tc_env          <- IOEnv (Env TcGblEnv TcLclEnv) (Env TcGblEnv TcLclEnv)
forall env. IOEnv env env
TcM.getEnv
       ; EvBindsVar
ev_binds_var    <- TcM EvBindsVar
TcM.newTcEvBinds
       ; [TcTyCoVar]
psig_theta_vars <- (Type -> IOEnv (Env TcGblEnv TcLclEnv) TcTyCoVar)
-> [Type] -> TcM [TcTyCoVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Type -> IOEnv (Env TcGblEnv TcLclEnv) TcTyCoVar
forall gbl lcl. Type -> TcRnIf gbl lcl TcTyCoVar
TcM.newEvVar [Type]
psig_theta
       ; WantedConstraints
wanted_transformed_incl_derivs
            <- TcLevel
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. TcLevel -> TcM a -> TcM a
setTcLevel TcLevel
rhs_tclvl (TcRnIf TcGblEnv TcLclEnv WantedConstraints
 -> TcRnIf TcGblEnv TcLclEnv WantedConstraints)
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a b. (a -> b) -> a -> b
$
               EvBindsVar
-> TcS WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. EvBindsVar -> TcS a -> TcM a
runTcSWithEvBinds EvBindsVar
ev_binds_var (TcS WantedConstraints
 -> TcRnIf TcGblEnv TcLclEnv WantedConstraints)
-> TcS WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a b. (a -> b) -> a -> b
$
               do { let loc :: CtLoc
loc         = TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
rhs_tclvl SkolemInfo
UnkSkol (TcLclEnv -> CtLoc) -> TcLclEnv -> CtLoc
forall a b. (a -> b) -> a -> b
$
                                      Env TcGblEnv TcLclEnv -> TcLclEnv
forall gbl lcl. Env gbl lcl -> lcl
env_lcl Env TcGblEnv TcLclEnv
tc_env
                        psig_givens :: [Ct]
psig_givens = CtLoc -> [TcTyCoVar] -> [Ct]
mkGivens CtLoc
loc [TcTyCoVar]
psig_theta_vars
                  ; ()
_ <- [Ct] -> TcS ()
solveSimpleGivens [Ct]
psig_givens
                         -- See Note [Add signature contexts as givens]
                  ; WantedConstraints -> TcS WantedConstraints
solveWanteds WantedConstraints
wanteds }

       -- Find quant_pred_candidates, the predicates that
       -- we'll consider quantifying over
       -- 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]
       ; WantedConstraints
wanted_transformed_incl_derivs <- WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
TcM.zonkWC WantedConstraints
wanted_transformed_incl_derivs
       ; let definite_error :: Bool
definite_error = WantedConstraints -> Bool
insolubleWC WantedConstraints
wanted_transformed_incl_derivs
                              -- See Note [Quantification with errors]
                              -- NB: must include derived errors in this test,
                              --     hence "incl_derivs"
             wanted_transformed :: WantedConstraints
wanted_transformed = WantedConstraints -> WantedConstraints
dropDerivedWC WantedConstraints
wanted_transformed_incl_derivs
             quant_pred_candidates :: [Type]
quant_pred_candidates
               | Bool
definite_error = []
               | Bool
otherwise      = Cts -> [Type]
ctsPreds (Bool -> WantedConstraints -> Cts
approximateWC Bool
False WantedConstraints
wanted_transformed)

       -- Decide what type variables and constraints to quantify
       -- NB: quant_pred_candidates is already fully zonked
       -- NB: bound_theta are constraints we want to quantify over,
       --     including the psig_theta, which we always quantify over
       -- NB: bound_theta are fully zonked
       ; (qtvs :: [TcTyCoVar]
qtvs, bound_theta :: [Type]
bound_theta, co_vars :: TcTyVarSet
co_vars) <- InferMode
-> TcLevel
-> [(Name, Type)]
-> [TcIdSigInst]
-> [Type]
-> TcM ([TcTyCoVar], [Type], TcTyVarSet)
decideQuantification InferMode
infer_mode TcLevel
rhs_tclvl
                                                     [(Name, Type)]
name_taus [TcIdSigInst]
partial_sigs
                                                     [Type]
quant_pred_candidates
       ; [TcTyCoVar]
bound_theta_vars <- (Type -> IOEnv (Env TcGblEnv TcLclEnv) TcTyCoVar)
-> [Type] -> TcM [TcTyCoVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Type -> IOEnv (Env TcGblEnv TcLclEnv) TcTyCoVar
forall gbl lcl. Type -> TcRnIf gbl lcl TcTyCoVar
TcM.newEvVar [Type]
bound_theta

       -- We must produce bindings for the psig_theta_vars, because we may have
       -- used them in evidence bindings constructed by solveWanteds earlier
       -- Easiest way to do this is to emit them as new Wanteds (Trac #14643)
       ; CtLoc
ct_loc <- CtOrigin -> Maybe TypeOrKind -> TcM CtLoc
getCtLocM CtOrigin
AnnOrigin Maybe TypeOrKind
forall a. Maybe a
Nothing
       ; let psig_wanted :: [CtEvidence]
psig_wanted = [ CtWanted :: Type -> TcEvDest -> ShadowInfo -> CtLoc -> CtEvidence
CtWanted { ctev_pred :: Type
ctev_pred = TcTyCoVar -> Type
idType TcTyCoVar
psig_theta_var
                                      , ctev_dest :: TcEvDest
ctev_dest = TcTyCoVar -> TcEvDest
EvVarDest TcTyCoVar
psig_theta_var
                                      , ctev_nosh :: ShadowInfo
ctev_nosh = ShadowInfo
WDeriv
                                      , ctev_loc :: CtLoc
ctev_loc  = CtLoc
ct_loc }
                           | TcTyCoVar
psig_theta_var <- [TcTyCoVar]
psig_theta_vars ]

       -- Now construct the residual constraint
       ; WantedConstraints
residual_wanted <- TcLevel
-> Env TcGblEnv TcLclEnv
-> EvBindsVar
-> [(Name, Type)]
-> TcTyVarSet
-> [TcTyCoVar]
-> [TcTyCoVar]
-> WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
mkResidualConstraints TcLevel
rhs_tclvl Env TcGblEnv TcLclEnv
tc_env EvBindsVar
ev_binds_var
                                 [(Name, Type)]
name_taus TcTyVarSet
co_vars [TcTyCoVar]
qtvs [TcTyCoVar]
bound_theta_vars
                                 (WantedConstraints
wanted_transformed WantedConstraints -> WantedConstraints -> WantedConstraints
`andWC` [CtEvidence] -> WantedConstraints
mkSimpleWC [CtEvidence]
psig_wanted)

         -- All done!
       ; String -> SDoc -> TcM ()
traceTc "} simplifyInfer/produced residual implication for quantification" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$
         [SDoc] -> SDoc
vcat [ String -> SDoc
text "quant_pred_candidates =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
quant_pred_candidates
              , String -> SDoc
text "psig_theta =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
psig_theta
              , String -> SDoc
text "bound_theta =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
bound_theta
              , String -> SDoc
text "qtvs ="       SDoc -> SDoc -> SDoc
<+> [TcTyCoVar] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TcTyCoVar]
qtvs
              , String -> SDoc
text "definite_error =" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
definite_error ]

       ; ([TcTyCoVar], [TcTyCoVar], TcEvBinds, WantedConstraints, Bool)
-> TcM
     ([TcTyCoVar], [TcTyCoVar], TcEvBinds, WantedConstraints, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return ( [TcTyCoVar]
qtvs, [TcTyCoVar]
bound_theta_vars, EvBindsVar -> TcEvBinds
TcEvBinds EvBindsVar
ev_binds_var
                , WantedConstraints
residual_wanted, Bool
definite_error ) }
         -- NB: bound_theta_vars must be fully zonked
  where
    partial_sigs :: [TcIdSigInst]
partial_sigs = (TcIdSigInst -> Bool) -> [TcIdSigInst] -> [TcIdSigInst]
forall a. (a -> Bool) -> [a] -> [a]
filter TcIdSigInst -> Bool
isPartialSig [TcIdSigInst]
sigs

--------------------
mkResidualConstraints :: TcLevel -> Env TcGblEnv TcLclEnv -> EvBindsVar
                      -> [(Name, TcTauType)]
                      -> VarSet -> [TcTyVar] -> [EvVar]
                      -> WantedConstraints -> TcM WantedConstraints
-- Emit the remaining constraints from the RHS.
-- See Note [Emitting the residual implication in simplifyInfer]
mkResidualConstraints :: TcLevel
-> Env TcGblEnv TcLclEnv
-> EvBindsVar
-> [(Name, Type)]
-> TcTyVarSet
-> [TcTyCoVar]
-> [TcTyCoVar]
-> WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
mkResidualConstraints rhs_tclvl :: TcLevel
rhs_tclvl tc_env :: Env TcGblEnv TcLclEnv
tc_env ev_binds_var :: EvBindsVar
ev_binds_var
                        name_taus :: [(Name, Type)]
name_taus co_vars :: TcTyVarSet
co_vars qtvs :: [TcTyCoVar]
qtvs full_theta_vars :: [TcTyCoVar]
full_theta_vars wanteds :: WantedConstraints
wanteds
  | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wanteds
  = WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wanteds

  | Bool
otherwise
  = do { Cts
wanted_simple <- Cts -> TcM Cts
TcM.zonkSimples (WantedConstraints -> Cts
wc_simple WantedConstraints
wanteds)
       ; let (outer_simple :: Cts
outer_simple, inner_simple :: Cts
inner_simple) = (Ct -> Bool) -> Cts -> (Cts, Cts)
forall a. (a -> Bool) -> Bag a -> (Bag a, Bag a)
partitionBag Ct -> Bool
is_mono Cts
wanted_simple
             is_mono :: Ct -> Bool
is_mono ct :: Ct
ct = Ct -> Bool
isWantedCt Ct
ct Bool -> Bool -> Bool
&& Ct -> TcTyCoVar
ctEvId Ct
ct TcTyCoVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
co_vars

        ; (Bool, TcTyVarSet)
_ <- TcTyVarSet -> TcM (Bool, TcTyVarSet)
promoteTyVarSet (Cts -> TcTyVarSet
tyCoVarsOfCts Cts
outer_simple)

        ; let inner_wanted :: WantedConstraints
inner_wanted = WantedConstraints
wanteds { wc_simple :: Cts
wc_simple = Cts
inner_simple }
        ; WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return (WC :: Cts -> Bag Implication -> WantedConstraints
WC { wc_simple :: Cts
wc_simple = Cts
outer_simple
                     , wc_impl :: Bag Implication
wc_impl   = WantedConstraints -> Bag Implication
mk_implic WantedConstraints
inner_wanted })}
  where
    mk_implic :: WantedConstraints -> Bag Implication
mk_implic inner_wanted :: WantedConstraints
inner_wanted
      | WantedConstraints -> Bool
isEmptyWC WantedConstraints
inner_wanted
      = Bag Implication
forall a. Bag a
emptyBag
      | Bool
otherwise
      = Implication -> Bag Implication
forall a. a -> Bag a
unitBag (Implication
implicationPrototype { ic_tclvl :: TcLevel
ic_tclvl  = TcLevel
rhs_tclvl
                                      , ic_skols :: [TcTyCoVar]
ic_skols  = [TcTyCoVar]
qtvs
                                      , ic_telescope :: Maybe SDoc
ic_telescope = Maybe SDoc
forall a. Maybe a
Nothing
                                      , ic_given :: [TcTyCoVar]
ic_given  = [TcTyCoVar]
full_theta_vars
                                      , ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints
inner_wanted
                                      , ic_binds :: EvBindsVar
ic_binds  = EvBindsVar
ev_binds_var
                                      , ic_no_eqs :: Bool
ic_no_eqs = Bool
False
                                      , ic_info :: SkolemInfo
ic_info   = SkolemInfo
skol_info
                                      , ic_env :: Env TcGblEnv TcLclEnv
ic_env    = Env TcGblEnv TcLclEnv
tc_env })

    full_theta :: [Type]
full_theta = (TcTyCoVar -> Type) -> [TcTyCoVar] -> [Type]
forall a b. (a -> b) -> [a] -> [b]
map TcTyCoVar -> Type
idType [TcTyCoVar]
full_theta_vars
    skol_info :: SkolemInfo
skol_info  = [(Name, Type)] -> SkolemInfo
InferSkol [ (Name
name, [TyCoVarBinder] -> [Type] -> Type -> Type
mkSigmaTy [] [Type]
full_theta Type
ty)
                           | (name :: Name
name, ty :: Type
ty) <- [(Name, Type)]
name_taus ]
                 -- Don't add the quantified variables here, because
                 -- they are also bound in ic_skols and we want them
                 -- to be tidied uniformly

--------------------
ctsPreds :: Cts -> [PredType]
ctsPreds :: Cts -> [Type]
ctsPreds cts :: Cts
cts = [ CtEvidence -> Type
ctEvPred CtEvidence
ev | Ct
ct <- Cts -> [Ct]
forall a. Bag a -> [a]
bagToList Cts
cts
                             , let ev :: CtEvidence
ev = Ct -> CtEvidence
ctEvidence Ct
ct ]

{- Note [Emitting the residual implication in simplifyInfer]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
   f = e
where f's type is inferred to be something like (a, Proxy k (Int |> co))
and we have an as-yet-unsolved, or perhaps insoluble, constraint
   [W] co :: Type ~ k
We can't form types like (forall co. blah), so we can't generalise over
the coercion variable, and hence we can't generalise over things free in
its kind, in the case 'k'.  But we can still generalise over 'a'.  So
we'll generalise to
   f :: forall a. (a, Proxy k (Int |> co))
Now we do NOT want to form the residual implication constraint
   forall a. [W] co :: Type ~ k
because then co's eventual binding (which will be a value binding if we
use -fdefer-type-errors) won't scope over the entire binding for 'f' (whose
type mentions 'co').  Instead, just as we don't generalise over 'co', we
should not bury its constraint inside the implication.  Instead, we must
put it outside.

That is the reason for the partitionBag in emitResidualConstraints,
which takes the CoVars free in the inferred type, and pulls their
constraints out.  (NB: this set of CoVars should be closed-over-kinds.)

All rather subtle; see Trac #14584.

Note [Add signature contexts as givens]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this (Trac #11016):
  f2 :: (?x :: Int) => _
  f2 = ?x
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.

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

************************************************************************
*                                                                      *
                Quantification
*                                                                      *
************************************************************************

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

* Step 1. 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
          beta, because alpha fixes beta, and beta is effectively free in
          the environment too

  We also account for the monomorphism restriction; if it applies,
  add the free vars of all the constraints.

  Result is mono_tvs; we will not quantify over these.

* Step 2. Default any non-mono tyvars (i.e ones that are definitely
  not going to become further constrained), and re-simplify the
  candidate constraints.

  Motivation for re-simplification (Trac #7857): imagine we have a
  constraint (C (a->b)), where 'a :: TYPE l1' and 'b :: TYPE l2' are
  not free in the envt, and instance forall (a::*) (b::*). (C a) => C
  (a -> b) The instance doesn't match while l1,l2 are polymorphic, but
  it will match when we default them to LiftedRep.

  This is all very tiresome.

* Step 3: decide which variables to quantify over, as follows:

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

  - 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.

* Step 4: Filter the constraints using pickQuantifiablePreds and the
  qtvs. We have to zonk the constraints first, so they "see" the
  freshly created skolems.

-}

decideQuantification
  :: InferMode
  -> TcLevel
  -> [(Name, TcTauType)]   -- Variables to be generalised
  -> [TcIdSigInst]         -- Partial type signatures (if any)
  -> [PredType]            -- Candidate theta; already zonked
  -> TcM ( [TcTyVar]       -- Quantify over these (skolems)
         , [PredType]      -- and this context (fully zonked)
         , VarSet)
-- See Note [Deciding quantification]
decideQuantification :: InferMode
-> TcLevel
-> [(Name, Type)]
-> [TcIdSigInst]
-> [Type]
-> TcM ([TcTyCoVar], [Type], TcTyVarSet)
decideQuantification infer_mode :: InferMode
infer_mode rhs_tclvl :: TcLevel
rhs_tclvl name_taus :: [(Name, Type)]
name_taus psigs :: [TcIdSigInst]
psigs candidates :: [Type]
candidates
  = do { -- Step 1: find the mono_tvs
       ; (mono_tvs :: TcTyVarSet
mono_tvs, candidates :: [Type]
candidates, co_vars :: TcTyVarSet
co_vars) <- InferMode
-> [(Name, Type)]
-> [TcIdSigInst]
-> [Type]
-> TcM (TcTyVarSet, [Type], TcTyVarSet)
decideMonoTyVars InferMode
infer_mode
                                              [(Name, Type)]
name_taus [TcIdSigInst]
psigs [Type]
candidates

       -- Step 2: default any non-mono tyvars, and re-simplify
       -- This step may do some unification, but result candidates is zonked
       ; [Type]
candidates <- TcLevel -> TcTyVarSet -> [Type] -> TcM [Type]
defaultTyVarsAndSimplify TcLevel
rhs_tclvl TcTyVarSet
mono_tvs [Type]
candidates

       -- Step 3: decide which kind/type variables to quantify over
       ; [TcTyCoVar]
qtvs <- TcTyVarSet
-> [(Name, Type)] -> [TcIdSigInst] -> [Type] -> TcM [TcTyCoVar]
decideQuantifiedTyVars TcTyVarSet
mono_tvs [(Name, Type)]
name_taus [TcIdSigInst]
psigs [Type]
candidates

       -- Step 4: choose which of the remaining candidate
       --         predicates to actually quantify over
       -- NB: decideQuantifiedTyVars turned some meta tyvars
       -- into quantified skolems, so we have to zonk again
       ; [Type]
candidates <- [Type] -> TcM [Type]
TcM.zonkTcTypes [Type]
candidates
       ; [Type]
psig_theta <- [Type] -> TcM [Type]
TcM.zonkTcTypes ((TcIdSigInst -> [Type]) -> [TcIdSigInst] -> [Type]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TcIdSigInst -> [Type]
sig_inst_theta [TcIdSigInst]
psigs)
       ; let quantifiable_candidates :: [Type]
quantifiable_candidates
               = TcTyVarSet -> [Type] -> [Type]
pickQuantifiablePreds ([TcTyCoVar] -> TcTyVarSet
mkVarSet [TcTyCoVar]
qtvs) [Type]
candidates
             -- NB: do /not/ run pickQuantifiablePreds over psig_theta,
             -- because we always want to quantify over psig_theta, and not
             -- drop any of them; e.g. CallStack constraints.  c.f Trac #14658

             theta :: [Type]
theta = (Type -> Type) -> [Type] -> [Type]
forall a. (a -> Type) -> [a] -> [a]
mkMinimalBySCs Type -> Type
forall a. a -> a
id ([Type] -> [Type]) -> [Type] -> [Type]
forall a b. (a -> b) -> a -> b
$  -- See Note [Minimize by Superclasses]
                     ([Type]
psig_theta [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
quantifiable_candidates)

       ; String -> SDoc -> TcM ()
traceTc "decideQuantification"
           ([SDoc] -> SDoc
vcat [ String -> SDoc
text "infer_mode:" SDoc -> SDoc -> SDoc
<+> InferMode -> SDoc
forall a. Outputable a => a -> SDoc
ppr InferMode
infer_mode
                 , String -> SDoc
text "candidates:" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
candidates
                 , String -> SDoc
text "psig_theta:" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
psig_theta
                 , String -> SDoc
text "mono_tvs:"   SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
mono_tvs
                 , String -> SDoc
text "co_vars:"    SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
co_vars
                 , String -> SDoc
text "qtvs:"       SDoc -> SDoc -> SDoc
<+> [TcTyCoVar] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TcTyCoVar]
qtvs
                 , String -> SDoc
text "theta:"      SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
theta ])
       ; ([TcTyCoVar], [Type], TcTyVarSet)
-> TcM ([TcTyCoVar], [Type], TcTyVarSet)
forall (m :: * -> *) a. Monad m => a -> m a
return ([TcTyCoVar]
qtvs, [Type]
theta, TcTyVarSet
co_vars) }

------------------
decideMonoTyVars :: InferMode
                 -> [(Name,TcType)]
                 -> [TcIdSigInst]
                 -> [PredType]
                 -> TcM (TcTyCoVarSet, [PredType], CoVarSet)
-- Decide which tyvars and covars cannot be generalised:
--   (a) Free in the environment
--   (b) Mentioned in a constraint we can't generalise
--   (c) Connected by an equality to (a) or (b)
-- Also return CoVars that appear free in the final quatified types
--   we can't quantify over these, and we must make sure they are in scope
decideMonoTyVars :: InferMode
-> [(Name, Type)]
-> [TcIdSigInst]
-> [Type]
-> TcM (TcTyVarSet, [Type], TcTyVarSet)
decideMonoTyVars infer_mode :: InferMode
infer_mode name_taus :: [(Name, Type)]
name_taus psigs :: [TcIdSigInst]
psigs candidates :: [Type]
candidates
  = do { (no_quant :: [Type]
no_quant, maybe_quant :: [Type]
maybe_quant) <- InferMode -> [Type] -> TcM ([Type], [Type])
pick InferMode
infer_mode [Type]
candidates

       -- If possible, we quantify over partial-sig qtvs, so they are
       -- not mono. Need to zonk them because they are meta-tyvar TyVarTvs
       ; [TcTyCoVar]
psig_qtvs <- (TcTyCoVar -> IOEnv (Env TcGblEnv TcLclEnv) TcTyCoVar)
-> [TcTyCoVar] -> TcM [TcTyCoVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasDebugCallStack =>
TcTyCoVar -> IOEnv (Env TcGblEnv TcLclEnv) TcTyCoVar
TcTyCoVar -> IOEnv (Env TcGblEnv TcLclEnv) TcTyCoVar
zonkTcTyVarToTyVar ([TcTyCoVar] -> TcM [TcTyCoVar]) -> [TcTyCoVar] -> TcM [TcTyCoVar]
forall a b. (a -> b) -> a -> b
$
                      (TcIdSigInst -> [TcTyCoVar]) -> [TcIdSigInst] -> [TcTyCoVar]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (((Name, TcTyCoVar) -> TcTyCoVar)
-> [(Name, TcTyCoVar)] -> [TcTyCoVar]
forall a b. (a -> b) -> [a] -> [b]
map (Name, TcTyCoVar) -> TcTyCoVar
forall a b. (a, b) -> b
snd ([(Name, TcTyCoVar)] -> [TcTyCoVar])
-> (TcIdSigInst -> [(Name, TcTyCoVar)])
-> TcIdSigInst
-> [TcTyCoVar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TcIdSigInst -> [(Name, TcTyCoVar)]
sig_inst_skols) [TcIdSigInst]
psigs

       ; [Type]
psig_theta <- (Type -> TcM Type) -> [Type] -> TcM [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Type -> TcM Type
TcM.zonkTcType ([Type] -> TcM [Type]) -> [Type] -> TcM [Type]
forall a b. (a -> b) -> a -> b
$
                       (TcIdSigInst -> [Type]) -> [TcIdSigInst] -> [Type]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TcIdSigInst -> [Type]
sig_inst_theta [TcIdSigInst]
psigs

       ; [Type]
taus <- ((Name, Type) -> TcM Type) -> [(Name, Type)] -> TcM [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Type -> TcM Type
TcM.zonkTcType (Type -> TcM Type)
-> ((Name, Type) -> Type) -> (Name, Type) -> TcM Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name, Type) -> Type
forall a b. (a, b) -> b
snd) [(Name, Type)]
name_taus

       ; TcTyVarSet
mono_tvs0 <- TcM TcTyVarSet
tcGetGlobalTyCoVars
       ; let psig_tys :: [Type]
psig_tys = [TcTyCoVar] -> [Type]
mkTyVarTys [TcTyCoVar]
psig_qtvs [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
psig_theta

             co_vars :: TcTyVarSet
co_vars = [Type] -> TcTyVarSet
coVarsOfTypes ([Type]
psig_tys [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
taus)
             co_var_tvs :: TcTyVarSet
co_var_tvs = TcTyVarSet -> TcTyVarSet
closeOverKinds TcTyVarSet
co_vars
               -- The co_var_tvs are tvs mentioned in the types of covars or
               -- coercion holes. We can't quantify over these covars, so we
               -- must include the variable in their types in the mono_tvs.
               -- E.g.  If we can't quantify over co :: k~Type, then we can't
               --       quantify over k either!  Hence closeOverKinds

             mono_tvs1 :: TcTyVarSet
mono_tvs1 = TcTyVarSet
mono_tvs0 TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
co_var_tvs

             eq_constraints :: [Type]
eq_constraints = (Type -> Bool) -> [Type] -> [Type]
forall a. (a -> Bool) -> [a] -> [a]
filter Type -> Bool
isEqPred [Type]
candidates
             mono_tvs2 :: TcTyVarSet
mono_tvs2      = [Type] -> TcTyVarSet -> TcTyVarSet
growThetaTyVars [Type]
eq_constraints TcTyVarSet
mono_tvs1

             constrained_tvs :: TcTyVarSet
constrained_tvs = ([Type] -> TcTyVarSet -> TcTyVarSet
growThetaTyVars [Type]
eq_constraints
                                               ([Type] -> TcTyVarSet
tyCoVarsOfTypes [Type]
no_quant)
                                TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`minusVarSet` TcTyVarSet
mono_tvs2)
                               TcTyVarSet -> [TcTyCoVar] -> TcTyVarSet
`delVarSetList` [TcTyCoVar]
psig_qtvs
             -- constrained_tvs: the tyvars that we are not going to
             -- quantify solely because of the moonomorphism restriction
             --
             -- (`minusVarSet` mono_tvs1`): a type variable is only
             --   "constrained" (so that the MR bites) if it is not
             --   free in the environment (Trac #13785)
             --
             -- (`delVarSetList` psig_qtvs): if the user has explicitly
             --   asked for quantification, then that request "wins"
             --   over the MR.  Note: do /not/ delete psig_qtvs from
             --   mono_tvs1, because mono_tvs1 cannot under any circumstances
             --   be quantified (Trac #14479); see
             --   Note [Quantification and partial signatures], Wrinkle 3, 4

             mono_tvs :: TcTyVarSet
mono_tvs = TcTyVarSet
mono_tvs2 TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
constrained_tvs

           -- Warn about the monomorphism restriction
       ; Bool
warn_mono <- WarningFlag -> TcRnIf TcGblEnv TcLclEnv Bool
forall gbl lcl. WarningFlag -> TcRnIf gbl lcl Bool
woptM WarningFlag
Opt_WarnMonomorphism
       ; Bool -> TcM () -> TcM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (case InferMode
infer_mode of { ApplyMR -> Bool
warn_mono; _ -> Bool
False}) (TcM () -> TcM ()) -> TcM () -> TcM ()
forall a b. (a -> b) -> a -> b
$
         WarnReason -> Bool -> SDoc -> TcM ()
warnTc (WarningFlag -> WarnReason
Reason WarningFlag
Opt_WarnMonomorphism)
                (TcTyVarSet
constrained_tvs TcTyVarSet -> TcTyVarSet -> Bool
`intersectsVarSet` [Type] -> TcTyVarSet
tyCoVarsOfTypes [Type]
taus)
                SDoc
mr_msg

       ; String -> SDoc -> TcM ()
traceTc "decideMonoTyVars" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
vcat
           [ String -> SDoc
text "mono_tvs0 =" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
mono_tvs0
           , String -> SDoc
text "mono_tvs1 =" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
mono_tvs1
           , String -> SDoc
text "no_quant =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
no_quant
           , String -> SDoc
text "maybe_quant =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
maybe_quant
           , String -> SDoc
text "eq_constraints =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
eq_constraints
           , String -> SDoc
text "mono_tvs =" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
mono_tvs
           , String -> SDoc
text "co_vars =" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
co_vars ]

       ; (TcTyVarSet, [Type], TcTyVarSet)
-> TcM (TcTyVarSet, [Type], TcTyVarSet)
forall (m :: * -> *) a. Monad m => a -> m a
return (TcTyVarSet
mono_tvs, [Type]
maybe_quant, TcTyVarSet
co_vars) }
  where
    pick :: InferMode -> [PredType] -> TcM ([PredType], [PredType])
    -- Split the candidates into ones we definitely
    -- won't quantify, and ones that we might
    pick :: InferMode -> [Type] -> TcM ([Type], [Type])
pick NoRestrictions  cand :: [Type]
cand = ([Type], [Type]) -> TcM ([Type], [Type])
forall (m :: * -> *) a. Monad m => a -> m a
return ([], [Type]
cand)
    pick ApplyMR         cand :: [Type]
cand = ([Type], [Type]) -> TcM ([Type], [Type])
forall (m :: * -> *) a. Monad m => a -> m a
return ([Type]
cand, [])
    pick EagerDefaulting cand :: [Type]
cand = do { Bool
os <- Extension -> TcRnIf TcGblEnv TcLclEnv Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.OverloadedStrings
                                   ; ([Type], [Type]) -> TcM ([Type], [Type])
forall (m :: * -> *) a. Monad m => a -> m a
return ((Type -> Bool) -> [Type] -> ([Type], [Type])
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition (Bool -> Type -> Bool
is_int_ct Bool
os) [Type]
cand) }

    -- For EagerDefaulting, do not quantify over
    -- over any interactive class constraint
    is_int_ct :: Bool -> Type -> Bool
is_int_ct ovl_strings :: Bool
ovl_strings pred :: Type
pred
      | Just (cls :: Class
cls, _) <- Type -> Maybe (Class, [Type])
getClassPredTys_maybe Type
pred
      = Bool -> Class -> Bool
isInteractiveClass Bool
ovl_strings Class
cls
      | Bool
otherwise
      = Bool
False

    pp_bndrs :: SDoc
pp_bndrs = ((Name, Type) -> SDoc) -> [(Name, Type)] -> SDoc
forall a. (a -> SDoc) -> [a] -> SDoc
pprWithCommas (SDoc -> SDoc
quotes (SDoc -> SDoc) -> ((Name, Type) -> SDoc) -> (Name, Type) -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Name -> SDoc) -> ((Name, Type) -> Name) -> (Name, Type) -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name, Type) -> Name
forall a b. (a, b) -> a
fst) [(Name, Type)]
name_taus
    mr_msg :: SDoc
mr_msg =
         SDoc -> Int -> SDoc -> SDoc
hang ([SDoc] -> SDoc
sep [ String -> SDoc
text "The Monomorphism Restriction applies to the binding"
                     SDoc -> SDoc -> SDoc
<> [(Name, Type)] -> SDoc
forall a. [a] -> SDoc
plural [(Name, Type)]
name_taus
                   , String -> SDoc
text "for" SDoc -> SDoc -> SDoc
<+> SDoc
pp_bndrs ])
            2 ([SDoc] -> SDoc
hsep [ String -> SDoc
text "Consider giving"
                    , String -> SDoc
text (if [(Name, Type)] -> Bool
forall a. [a] -> Bool
isSingleton [(Name, Type)]
name_taus then "it" else "them")
                    , String -> SDoc
text "a type signature"])

-------------------
defaultTyVarsAndSimplify :: TcLevel
                         -> TyCoVarSet
                         -> [PredType]          -- Assumed zonked
                         -> TcM [PredType]      -- Guaranteed zonked
-- Default any tyvar free in the constraints,
-- and re-simplify in case the defaulting allows further simplification
defaultTyVarsAndSimplify :: TcLevel -> TcTyVarSet -> [Type] -> TcM [Type]
defaultTyVarsAndSimplify rhs_tclvl :: TcLevel
rhs_tclvl mono_tvs :: TcTyVarSet
mono_tvs candidates :: [Type]
candidates
  = do {  -- Promote any tyvars that we cannot generalise
          -- See Note [Promote momomorphic tyvars]
       ; String -> SDoc -> TcM ()
traceTc "decideMonoTyVars: promotion:" (TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
mono_tvs)
       ; (prom :: Bool
prom, _) <- TcTyVarSet -> TcM (Bool, TcTyVarSet)
promoteTyVarSet TcTyVarSet
mono_tvs

       -- Default any kind/levity vars
       ; DV {dv_kvs :: CandidatesQTvs -> DTyVarSet
dv_kvs = DTyVarSet
cand_kvs, dv_tvs :: CandidatesQTvs -> DTyVarSet
dv_tvs = DTyVarSet
cand_tvs}
                <- [Type] -> TcM CandidatesQTvs
candidateQTyVarsOfTypes [Type]
candidates
                -- any covars should already be handled by
                -- the logic in decideMonoTyVars, which looks at
                -- the constraints generated

       ; Bool
poly_kinds  <- Extension -> TcRnIf TcGblEnv TcLclEnv Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.PolyKinds
       ; [Bool]
default_kvs <- (TcTyCoVar -> TcRnIf TcGblEnv TcLclEnv Bool)
-> [TcTyCoVar] -> IOEnv (Env TcGblEnv TcLclEnv) [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Bool -> Bool -> TcTyCoVar -> TcRnIf TcGblEnv TcLclEnv Bool
default_one Bool
poly_kinds Bool
True)
                             (DTyVarSet -> [TcTyCoVar]
dVarSetElems DTyVarSet
cand_kvs)
       ; [Bool]
default_tvs <- (TcTyCoVar -> TcRnIf TcGblEnv TcLclEnv Bool)
-> [TcTyCoVar] -> IOEnv (Env TcGblEnv TcLclEnv) [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Bool -> Bool -> TcTyCoVar -> TcRnIf TcGblEnv TcLclEnv Bool
default_one Bool
poly_kinds Bool
False)
                             (DTyVarSet -> [TcTyCoVar]
dVarSetElems (DTyVarSet
cand_tvs DTyVarSet -> DTyVarSet -> DTyVarSet
`minusDVarSet` DTyVarSet
cand_kvs))
       ; let some_default :: Bool
some_default = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
default_kvs Bool -> Bool -> Bool
|| [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
default_tvs

       ; case () of
           _ | Bool
some_default -> [Type] -> TcM [Type]
simplify_cand [Type]
candidates
             | Bool
prom         -> (Type -> TcM Type) -> [Type] -> TcM [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Type -> TcM Type
TcM.zonkTcType [Type]
candidates
             | Bool
otherwise    -> [Type] -> TcM [Type]
forall (m :: * -> *) a. Monad m => a -> m a
return [Type]
candidates
       }
  where
    default_one :: Bool -> Bool -> TcTyCoVar -> TcRnIf TcGblEnv TcLclEnv Bool
default_one poly_kinds :: Bool
poly_kinds is_kind_var :: Bool
is_kind_var tv :: TcTyCoVar
tv
      | Bool -> Bool
not (TcTyCoVar -> Bool
isMetaTyVar TcTyCoVar
tv)
      = Bool -> TcRnIf TcGblEnv TcLclEnv Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
      | TcTyCoVar
tv TcTyCoVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
mono_tvs
      = Bool -> TcRnIf TcGblEnv TcLclEnv Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
      | Bool
otherwise
      = Bool -> TcTyCoVar -> TcRnIf TcGblEnv TcLclEnv Bool
defaultTyVar (Bool -> Bool
not Bool
poly_kinds Bool -> Bool -> Bool
&& Bool
is_kind_var) TcTyCoVar
tv

    simplify_cand :: [Type] -> TcM [Type]
simplify_cand candidates :: [Type]
candidates
      = do { [CtEvidence]
clone_wanteds <- CtOrigin -> [Type] -> TcM [CtEvidence]
newWanteds CtOrigin
DefaultOrigin [Type]
candidates
           ; WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples } <- TcLevel
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. TcLevel -> TcM a -> TcM a
setTcLevel TcLevel
rhs_tclvl (TcRnIf TcGblEnv TcLclEnv WantedConstraints
 -> TcRnIf TcGblEnv TcLclEnv WantedConstraints)
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
-> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a b. (a -> b) -> a -> b
$
                                           [CtEvidence] -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
simplifyWantedsTcM [CtEvidence]
clone_wanteds
              -- Discard evidence; simples is fully zonked

           ; let new_candidates :: [Type]
new_candidates = Cts -> [Type]
ctsPreds Cts
simples
           ; String -> SDoc -> TcM ()
traceTc "Simplified after defaulting" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$
                      [SDoc] -> SDoc
vcat [ String -> SDoc
text "Before:" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
candidates
                           , String -> SDoc
text "After:"  SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
new_candidates ]
           ; [Type] -> TcM [Type]
forall (m :: * -> *) a. Monad m => a -> m a
return [Type]
new_candidates }

------------------
decideQuantifiedTyVars
   :: TyCoVarSet        -- Monomorphic tyvars
   -> [(Name,TcType)]   -- Annotated theta and (name,tau) pairs
   -> [TcIdSigInst]     -- Partial signatures
   -> [PredType]        -- Candidates, zonked
   -> TcM [TyVar]
-- Fix what tyvars we are going to quantify over, and quantify them
decideQuantifiedTyVars :: TcTyVarSet
-> [(Name, Type)] -> [TcIdSigInst] -> [Type] -> TcM [TcTyCoVar]
decideQuantifiedTyVars mono_tvs :: TcTyVarSet
mono_tvs name_taus :: [(Name, Type)]
name_taus psigs :: [TcIdSigInst]
psigs candidates :: [Type]
candidates
  = do {     -- Why psig_tys? We try to quantify over everything free in here
             -- See Note [Quantification and partial signatures]
             --     Wrinkles 2 and 3
       ; [Type]
psig_tv_tys <- (TcTyCoVar -> TcM Type) -> [TcTyCoVar] -> TcM [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM TcTyCoVar -> TcM Type
TcM.zonkTcTyVar [ TcTyCoVar
tv | TcIdSigInst
sig <- [TcIdSigInst]
psigs
                                                  , (_,tv :: TcTyCoVar
tv) <- TcIdSigInst -> [(Name, TcTyCoVar)]
sig_inst_skols TcIdSigInst
sig ]
       ; [Type]
psig_theta <- (Type -> TcM Type) -> [Type] -> TcM [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Type -> TcM Type
TcM.zonkTcType [ Type
pred | TcIdSigInst
sig <- [TcIdSigInst]
psigs
                                                  , Type
pred <- TcIdSigInst -> [Type]
sig_inst_theta TcIdSigInst
sig ]
       ; [Type]
tau_tys  <- ((Name, Type) -> TcM Type) -> [(Name, Type)] -> TcM [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Type -> TcM Type
TcM.zonkTcType (Type -> TcM Type)
-> ((Name, Type) -> Type) -> (Name, Type) -> TcM Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name, Type) -> Type
forall a b. (a, b) -> b
snd) [(Name, Type)]
name_taus
       ; TcTyVarSet
mono_tvs <- TcTyVarSet -> TcM TcTyVarSet
TcM.zonkTyCoVarsAndFV TcTyVarSet
mono_tvs

       ; let -- Try to quantify over variables free in these types
             psig_tys :: [Type]
psig_tys = [Type]
psig_tv_tys [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
psig_theta
             seed_tys :: [Type]
seed_tys = [Type]
psig_tys [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
tau_tys

             -- Now "grow" those seeds to find ones reachable via 'candidates'
             grown_tcvs :: TcTyVarSet
grown_tcvs = [Type] -> TcTyVarSet -> TcTyVarSet
growThetaTyVars [Type]
candidates ([Type] -> TcTyVarSet
tyCoVarsOfTypes [Type]
seed_tys)

       -- Now we have to classify them into kind variables and type variables
       -- (sigh) just for the benefit of -XNoPolyKinds; see quantifyTyVars
       --
       -- Keep the psig_tys first, so that candidateQTyVarsOfTypes produces
       -- them in that order, so that the final qtvs quantifies in the same
       -- order as the partial signatures do (Trac #13524)
       ; dv :: CandidatesQTvs
dv@DV {dv_kvs :: CandidatesQTvs -> DTyVarSet
dv_kvs = DTyVarSet
cand_kvs, dv_tvs :: CandidatesQTvs -> DTyVarSet
dv_tvs = DTyVarSet
cand_tvs} <- [Type] -> TcM CandidatesQTvs
candidateQTyVarsOfTypes ([Type] -> TcM CandidatesQTvs) -> [Type] -> TcM CandidatesQTvs
forall a b. (a -> b) -> a -> b
$
                                                         [Type]
psig_tys [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
candidates [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
tau_tys
       ; let pick :: DTyVarSet -> DTyVarSet
pick     = (DTyVarSet -> TcTyVarSet -> DTyVarSet
`dVarSetIntersectVarSet` TcTyVarSet
grown_tcvs)
             dvs_plus :: CandidatesQTvs
dvs_plus = CandidatesQTvs
dv { dv_kvs :: DTyVarSet
dv_kvs = DTyVarSet -> DTyVarSet
pick DTyVarSet
cand_kvs, dv_tvs :: DTyVarSet
dv_tvs = DTyVarSet -> DTyVarSet
pick DTyVarSet
cand_tvs }

       ; String -> SDoc -> TcM ()
traceTc "decideQuantifiedTyVars" ([SDoc] -> SDoc
vcat
           [ String -> SDoc
text "candidates =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
candidates
           , String -> SDoc
text "tau_tys =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
tau_tys
           , String -> SDoc
text "seed_tys =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
seed_tys
           , String -> SDoc
text "seed_tcvs =" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr ([Type] -> TcTyVarSet
tyCoVarsOfTypes [Type]
seed_tys)
           , String -> SDoc
text "grown_tcvs =" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
grown_tcvs
           , String -> SDoc
text "dvs =" SDoc -> SDoc -> SDoc
<+> CandidatesQTvs -> SDoc
forall a. Outputable a => a -> SDoc
ppr CandidatesQTvs
dvs_plus])

       ; TcTyVarSet -> CandidatesQTvs -> TcM [TcTyCoVar]
quantifyTyVars TcTyVarSet
mono_tvs CandidatesQTvs
dvs_plus }

------------------
growThetaTyVars :: ThetaType -> TyCoVarSet -> TyCoVarSet
-- See Note [Growing the tau-tvs using constraints]
growThetaTyVars :: [Type] -> TcTyVarSet -> TcTyVarSet
growThetaTyVars theta :: [Type]
theta tcvs :: TcTyVarSet
tcvs
  | [Type] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Type]
theta = TcTyVarSet
tcvs
  | Bool
otherwise  = (TcTyVarSet -> TcTyVarSet) -> TcTyVarSet -> TcTyVarSet
transCloVarSet TcTyVarSet -> TcTyVarSet
mk_next TcTyVarSet
seed_tcvs
  where
    seed_tcvs :: TcTyVarSet
seed_tcvs = TcTyVarSet
tcvs TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` [Type] -> TcTyVarSet
tyCoVarsOfTypes [Type]
ips
    (ips :: [Type]
ips, non_ips :: [Type]
non_ips) = (Type -> Bool) -> [Type] -> ([Type], [Type])
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition Type -> Bool
isIPPred [Type]
theta
                         -- See Note [Inheriting implicit parameters] in TcType

    mk_next :: VarSet -> VarSet -- Maps current set to newly-grown ones
    mk_next :: TcTyVarSet -> TcTyVarSet
mk_next so_far :: TcTyVarSet
so_far = (Type -> TcTyVarSet -> TcTyVarSet)
-> TcTyVarSet -> [Type] -> TcTyVarSet
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (TcTyVarSet -> Type -> TcTyVarSet -> TcTyVarSet
grow_one TcTyVarSet
so_far) TcTyVarSet
emptyVarSet [Type]
non_ips
    grow_one :: TcTyVarSet -> Type -> TcTyVarSet -> TcTyVarSet
grow_one so_far :: TcTyVarSet
so_far pred :: Type
pred tcvs :: TcTyVarSet
tcvs
       | TcTyVarSet
pred_tcvs TcTyVarSet -> TcTyVarSet -> Bool
`intersectsVarSet` TcTyVarSet
so_far = TcTyVarSet
tcvs TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
pred_tcvs
       | Bool
otherwise                           = TcTyVarSet
tcvs
       where
         pred_tcvs :: TcTyVarSet
pred_tcvs = Type -> TcTyVarSet
tyCoVarsOfType Type
pred


{- Note [Promote momomorphic tyvars]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Promote any type variables that are free in the environment.  Eg
   f :: forall qtvs. bound_theta => zonked_tau
The free vars of f's type 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]
           constraints = 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

NB: promoteTyVar ignores coercion variables

Note [Quantification and partial signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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),
   for example by being free in the environment.

However, in the case of a partial type signature, be doing inference
*in the presence of a type signature*. For example:
   f :: _ -> a
   f x = ...
or
   g :: (Eq _a) => _b -> _b
In both cases we use plan InferGen, and hence call simplifyInfer.  But
those 'a' variables are skolems (actually TyVarTvs), and we should be
sure to quantify over them.  This leads to several wrinkles:

* Wrinkle 1.  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 quantified tyvars.

* Wrinkle 2.  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.

  Bottom line: Try to quantify over any variable free in psig_theta,
  just like the tau-part of the type.

* Wrinkle 3 (Trac #13482). Also consider
    f :: forall a. _ => Int -> Int
    f x = if (undefined :: a) == undefined then x else 0
  Here we get an (Eq a) constraint, but it's not mentioned in the
  psig_theta nor the type of 'f'.  But we still want to quantify
  over 'a' even if the monomorphism restriction is on.

* Wrinkle 4 (Trac #14479)
    foo :: Num a => a -> a
    foo xxx = g xxx
      where
        g :: forall b. Num b => _ -> b
        g y = xxx + y

  In the signature for 'g', we cannot quantify over 'b' because it turns out to
  get unified with 'a', which is free in g's environment.  So we carefully
  refrain from bogusly quantifying, in TcSimplify.decideMonoTyVars.  We
  report the error later, in TcBinds.chooseInferredQuantifiers.

Note [Growing the tau-tvs using constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(growThetaTyVars insts tvs) is the result of extending the set
    of tyvars, tvs, using all conceivable links from pred

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)

Note [Quantification with errors]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If we find that the RHS of the definition has some absolutely-insoluble
constraints (including especially "variable not in scope"), we

* Abandon all attempts to find a context to quantify over,
  and instead make the function fully-polymorphic in whatever
  type we have found

* Return a flag from simplifyInfer, indicating that we found an
  insoluble constraint.  This flag is used to suppress the ambiguity
  check for the inferred type, which may well be bogus, and which
  tends to obscure the real error.  This fix feels a bit clunky,
  but I failed to come up with anything better.

Reasons:
    - Avoid downstream errors
    - Do not perform an ambiguity test on a bogus type, which might well
      fail spuriously, thereby obfuscating the original insoluble error.
      Trac #14000 is an example

I tried an alternative approach: simply failM, after emitting the
residual implication constraint; the exception will be caught in
TcBinds.tcPolyBinds, which gives all the binders in the group the type
(forall a. a).  But that didn't work with -fdefer-type-errors, because
the recovery from failM emits no code at all, so there is no function
to run!   But -fdefer-type-errors aspires to produce a runnable program.

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

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

instance D g => C g Int b

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

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

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

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

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

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
we don't do it for now.



Note [Minimize by Superclasses]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.


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

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

   f :: C [t] => ....
   f x = let g y = ...(constraint C [t])...
         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
the constraints before simplifying.

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

*********************************************************************************
*                                                                                 *
*                                 Main Simplifier                                 *
*                                                                                 *
***********************************************************************************

-}

simplifyWantedsTcM :: [CtEvidence] -> TcM WantedConstraints
-- Solve the specified Wanted constraints
-- Discard the evidence binds
-- Discards all Derived stuff in result
-- Postcondition: fully zonked and unflattened constraints
simplifyWantedsTcM :: [CtEvidence] -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
simplifyWantedsTcM wanted :: [CtEvidence]
wanted
  = do { String -> SDoc -> TcM ()
traceTc "simplifyWantedsTcM {" ([CtEvidence] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [CtEvidence]
wanted)
       ; (result :: WantedConstraints
result, _) <- TcS WantedConstraints -> TcM (WantedConstraints, EvBindMap)
forall a. TcS a -> TcM (a, EvBindMap)
runTcS (WantedConstraints -> TcS WantedConstraints
solveWantedsAndDrop ([CtEvidence] -> WantedConstraints
mkSimpleWC [CtEvidence]
wanted))
       ; WantedConstraints
result <- WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
TcM.zonkWC WantedConstraints
result
       ; String -> SDoc -> TcM ()
traceTc "simplifyWantedsTcM }" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
result)
       ; WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
result }

solveWantedsAndDrop :: WantedConstraints -> TcS WantedConstraints
-- Since solveWanteds returns the residual WantedConstraints,
-- it should always be called within a runTcS or something similar,
-- Result is not zonked
solveWantedsAndDrop :: WantedConstraints -> TcS WantedConstraints
solveWantedsAndDrop wanted :: WantedConstraints
wanted
  = do { WantedConstraints
wc <- WantedConstraints -> TcS WantedConstraints
solveWanteds WantedConstraints
wanted
       ; WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints -> WantedConstraints
dropDerivedWC WantedConstraints
wc) }

solveWanteds :: WantedConstraints -> TcS WantedConstraints
-- so that the inert set doesn't mindlessly propagate.
-- NB: wc_simples may be wanted /or/ derived now
solveWanteds :: WantedConstraints -> TcS WantedConstraints
solveWanteds wc :: WantedConstraints
wc@(WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics })
  = do { TcLevel
cur_lvl <- TcS TcLevel
TcS.getTcLevel
       ; String -> SDoc -> TcS ()
traceTcS "solveWanteds {" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
         [SDoc] -> SDoc
vcat [ String -> SDoc
text "Level =" SDoc -> SDoc -> SDoc
<+> TcLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcLevel
cur_lvl
              , WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wc ]

       ; WantedConstraints
wc1 <- Cts -> TcS WantedConstraints
solveSimpleWanteds Cts
simples
                -- Any insoluble constraints are in 'simples' and so get rewritten
                -- See Note [Rewrite insolubles] in TcSMonad

       ; (floated_eqs :: Cts
floated_eqs, implics2 :: Bag Implication
implics2) <- Bag Implication -> TcS (Cts, Bag Implication)
solveNestedImplications (Bag Implication -> TcS (Cts, Bag Implication))
-> Bag Implication -> TcS (Cts, Bag Implication)
forall a b. (a -> b) -> a -> b
$
                                    Bag Implication
implics Bag Implication -> Bag Implication -> Bag Implication
forall a. Bag a -> Bag a -> Bag a
`unionBags` WantedConstraints -> Bag Implication
wc_impl WantedConstraints
wc1

       ; DynFlags
dflags   <- TcS DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
       ; WantedConstraints
final_wc <- Int
-> IntWithInf -> Cts -> WantedConstraints -> TcS WantedConstraints
simpl_loop 0 (DynFlags -> IntWithInf
solverIterations DynFlags
dflags) Cts
floated_eqs
                                (WantedConstraints
wc1 { wc_impl :: Bag Implication
wc_impl = Bag Implication
implics2 })

       ; EvBindsVar
ev_binds_var <- TcS EvBindsVar
getTcEvBindsVar
       ; EvBindMap
bb <- EvBindsVar -> TcS EvBindMap
TcS.getTcEvBindsMap EvBindsVar
ev_binds_var
       ; String -> SDoc -> TcS ()
traceTcS "solveWanteds }" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
                 [SDoc] -> SDoc
vcat [ String -> SDoc
text "final wc =" SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
final_wc
                      , String -> SDoc
text "current evbinds  =" SDoc -> SDoc -> SDoc
<+> Bag EvBind -> SDoc
forall a. Outputable a => a -> SDoc
ppr (EvBindMap -> Bag EvBind
evBindMapBinds EvBindMap
bb) ]

       ; WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
final_wc }

simpl_loop :: Int -> IntWithInf -> Cts
           -> WantedConstraints -> TcS WantedConstraints
simpl_loop :: Int
-> IntWithInf -> Cts -> WantedConstraints -> TcS WantedConstraints
simpl_loop n :: Int
n limit :: IntWithInf
limit floated_eqs :: Cts
floated_eqs wc :: WantedConstraints
wc@(WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples })
  | Int
n Int -> IntWithInf -> Bool
`intGtLimit` IntWithInf
limit
  = do { -- Add an error (not a warning) if we blow the limit,
         -- Typically if we blow the limit we are going to report some other error
         -- (an unsolved constraint), and we don't want that error to suppress
         -- the iteration limit warning!
         SDoc -> TcS ()
addErrTcS (SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "solveWanteds: too many iterations"
                   SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
parens (String -> SDoc
text "limit =" SDoc -> SDoc -> SDoc
<+> IntWithInf -> SDoc
forall a. Outputable a => a -> SDoc
ppr IntWithInf
limit))
                2 ([SDoc] -> SDoc
vcat [ String -> SDoc
text "Unsolved:" SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wc
                        , Bool -> SDoc -> SDoc
ppUnless (Cts -> Bool
forall a. Bag a -> Bool
isEmptyBag Cts
floated_eqs) (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$
                          String -> SDoc
text "Floated equalities:" SDoc -> SDoc -> SDoc
<+> Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
floated_eqs
                        , String -> SDoc
text "Set limit with -fconstraint-solver-iterations=n; n=0 for no limit"
                  ]))
       ; WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wc }

  | Bool -> Bool
not (Cts -> Bool
forall a. Bag a -> Bool
isEmptyBag Cts
floated_eqs)
  = Int
-> IntWithInf -> Bool -> WantedConstraints -> TcS WantedConstraints
simplify_again Int
n IntWithInf
limit Bool
True (WantedConstraints
wc { wc_simple :: Cts
wc_simple = Cts
floated_eqs Cts -> Cts -> Cts
forall a. Bag a -> Bag a -> Bag a
`unionBags` Cts
simples })
            -- Put floated_eqs first so they get solved first
            -- NB: the floated_eqs may include /derived/ equalities
            -- arising from fundeps inside an implication

  | WantedConstraints -> Bool
superClassesMightHelp WantedConstraints
wc
  = -- We still have unsolved goals, and apparently no way to solve them,
    -- so try expanding superclasses at this level, both Given and Wanted
    do { [Ct]
pending_given <- TcS [Ct]
getPendingGivenScs
       ; let (pending_wanted :: [Ct]
pending_wanted, simples1 :: Cts
simples1) = Cts -> ([Ct], Cts)
getPendingWantedScs Cts
simples
       ; if [Ct] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Ct]
pending_given Bool -> Bool -> Bool
&& [Ct] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Ct]
pending_wanted
           then WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wc  -- After all, superclasses did not help
           else
    do { [Ct]
new_given  <- [Ct] -> TcS [Ct]
makeSuperClasses [Ct]
pending_given
       ; [Ct]
new_wanted <- [Ct] -> TcS [Ct]
makeSuperClasses [Ct]
pending_wanted
       ; [Ct] -> TcS ()
solveSimpleGivens [Ct]
new_given -- Add the new Givens to the inert set
       ; Int
-> IntWithInf -> Bool -> WantedConstraints -> TcS WantedConstraints
simplify_again Int
n IntWithInf
limit ([Ct] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Ct]
pending_given)
         WantedConstraints
wc { wc_simple :: Cts
wc_simple = Cts
simples1 Cts -> Cts -> Cts
forall a. Bag a -> Bag a -> Bag a
`unionBags` [Ct] -> Cts
forall a. [a] -> Bag a
listToBag [Ct]
new_wanted } } }

  | Bool
otherwise
  = WantedConstraints -> TcS WantedConstraints
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wc

simplify_again :: Int -> IntWithInf -> Bool
               -> WantedConstraints -> TcS WantedConstraints
-- We have definitely decided to have another go at solving
-- the wanted constraints (we have tried at least once already
simplify_again :: Int
-> IntWithInf -> Bool -> WantedConstraints -> TcS WantedConstraints
simplify_again n :: Int
n limit :: IntWithInf
limit no_new_given_scs :: Bool
no_new_given_scs
               wc :: WantedConstraints
wc@(WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics })
  = do { SDoc -> TcS ()
csTraceTcS (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
         String -> SDoc
text "simpl_loop iteration=" SDoc -> SDoc -> SDoc
<> Int -> SDoc
int Int
n
         SDoc -> SDoc -> SDoc
<+> (SDoc -> SDoc
parens (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
hsep [ String -> SDoc
text "no new given superclasses =" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
no_new_given_scs SDoc -> SDoc -> SDoc
<> SDoc
comma
                            , Int -> SDoc
int (Cts -> Int
forall a. Bag a -> Int
lengthBag Cts
simples) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "simples to solve" ])
       ; String -> SDoc -> TcS ()
traceTcS "simpl_loop: wc =" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wc)

       ; (unifs1 :: Int
unifs1, wc1 :: WantedConstraints
wc1) <- TcS WantedConstraints -> TcS (Int, WantedConstraints)
forall a. TcS a -> TcS (Int, a)
reportUnifications (TcS WantedConstraints -> TcS (Int, WantedConstraints))
-> TcS WantedConstraints -> TcS (Int, WantedConstraints)
forall a b. (a -> b) -> a -> b
$
                          Cts -> TcS WantedConstraints
solveSimpleWanteds (Cts -> TcS WantedConstraints) -> Cts -> TcS WantedConstraints
forall a b. (a -> b) -> a -> b
$
                          Cts
simples

       -- See Note [Cutting off simpl_loop]
       -- We have already tried to solve the nested implications once
       -- Try again only if we have unified some meta-variables
       -- (which is a bit like adding more givens), or we have some
       -- new Given superclasses
       ; let new_implics :: Bag Implication
new_implics = WantedConstraints -> Bag Implication
wc_impl WantedConstraints
wc1
       ; if Int
unifs1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0       Bool -> Bool -> Bool
&&
            Bool
no_new_given_scs  Bool -> Bool -> Bool
&&
            Bag Implication -> Bool
forall a. Bag a -> Bool
isEmptyBag Bag Implication
new_implics

           then -- Do not even try to solve the implications
                Int
-> IntWithInf -> Cts -> WantedConstraints -> TcS WantedConstraints
simpl_loop (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) IntWithInf
limit Cts
forall a. Bag a
emptyBag (WantedConstraints
wc1 { wc_impl :: Bag Implication
wc_impl = Bag Implication
implics })

           else -- Try to solve the implications
                do { (floated_eqs2 :: Cts
floated_eqs2, implics2 :: Bag Implication
implics2) <- Bag Implication -> TcS (Cts, Bag Implication)
solveNestedImplications (Bag Implication -> TcS (Cts, Bag Implication))
-> Bag Implication -> TcS (Cts, Bag Implication)
forall a b. (a -> b) -> a -> b
$
                                                 Bag Implication
implics Bag Implication -> Bag Implication -> Bag Implication
forall a. Bag a -> Bag a -> Bag a
`unionBags` Bag Implication
new_implics
                   ; Int
-> IntWithInf -> Cts -> WantedConstraints -> TcS WantedConstraints
simpl_loop (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) IntWithInf
limit Cts
floated_eqs2 (WantedConstraints
wc1 { wc_impl :: Bag Implication
wc_impl = Bag Implication
implics2 })
    } }

solveNestedImplications :: Bag Implication
                        -> TcS (Cts, Bag Implication)
-- Precondition: the TcS inerts may contain unsolved simples which have
-- to be converted to givens before we go inside a nested implication.
solveNestedImplications :: Bag Implication -> TcS (Cts, Bag Implication)
solveNestedImplications implics :: Bag Implication
implics
  | Bag Implication -> Bool
forall a. Bag a -> Bool
isEmptyBag Bag Implication
implics
  = (Cts, Bag Implication) -> TcS (Cts, Bag Implication)
forall (m :: * -> *) a. Monad m => a -> m a
return (Cts
forall a. Bag a
emptyBag, Bag Implication
forall a. Bag a
emptyBag)
  | Bool
otherwise
  = do { String -> SDoc -> TcS ()
traceTcS "solveNestedImplications starting {" SDoc
empty
       ; (floated_eqs_s :: Bag Cts
floated_eqs_s, unsolved_implics :: Bag (Maybe Implication)
unsolved_implics) <- (Implication -> TcS (Cts, Maybe Implication))
-> Bag Implication -> TcS (Bag Cts, Bag (Maybe Implication))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m (b, c)) -> Bag a -> m (Bag b, Bag c)
mapAndUnzipBagM Implication -> TcS (Cts, Maybe Implication)
solveImplication Bag Implication
implics
       ; let floated_eqs :: Cts
floated_eqs = Bag Cts -> Cts
forall a. Bag (Bag a) -> Bag a
concatBag Bag Cts
floated_eqs_s

       -- ... and we are back in the original TcS inerts
       -- Notice that the original includes the _insoluble_simples so it was safe to ignore
       -- them in the beginning of this function.
       ; String -> SDoc -> TcS ()
traceTcS "solveNestedImplications end }" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
                  [SDoc] -> SDoc
vcat [ String -> SDoc
text "all floated_eqs ="  SDoc -> SDoc -> SDoc
<+> Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
floated_eqs
                       , String -> SDoc
text "unsolved_implics =" SDoc -> SDoc -> SDoc
<+> Bag (Maybe Implication) -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bag (Maybe Implication)
unsolved_implics ]

       ; (Cts, Bag Implication) -> TcS (Cts, Bag Implication)
forall (m :: * -> *) a. Monad m => a -> m a
return (Cts
floated_eqs, Bag (Maybe Implication) -> Bag Implication
forall a. Bag (Maybe a) -> Bag a
catBagMaybes Bag (Maybe Implication)
unsolved_implics) }

solveImplication :: Implication    -- Wanted
                 -> TcS (Cts,      -- All wanted or derived floated equalities: var = type
                         Maybe Implication) -- Simplified implication (empty or singleton)
-- Precondition: The TcS monad contains an empty worklist and given-only inerts
-- which after trying to solve this implication we must restore to their original value
solveImplication :: Implication -> TcS (Cts, Maybe Implication)
solveImplication imp :: Implication
imp@(Implic { ic_tclvl :: Implication -> TcLevel
ic_tclvl  = TcLevel
tclvl
                             , ic_binds :: Implication -> EvBindsVar
ic_binds  = EvBindsVar
ev_binds_var
                             , ic_skols :: Implication -> [TcTyCoVar]
ic_skols  = [TcTyCoVar]
skols
                             , ic_given :: Implication -> [TcTyCoVar]
ic_given  = [TcTyCoVar]
given_ids
                             , ic_wanted :: Implication -> WantedConstraints
ic_wanted = WantedConstraints
wanteds
                             , ic_info :: Implication -> SkolemInfo
ic_info   = SkolemInfo
info
                             , ic_status :: Implication -> ImplicStatus
ic_status = ImplicStatus
status })
  | ImplicStatus -> Bool
isSolvedStatus ImplicStatus
status
  = (Cts, Maybe Implication) -> TcS (Cts, Maybe Implication)
forall (m :: * -> *) a. Monad m => a -> m a
return (Cts
emptyCts, Implication -> Maybe Implication
forall a. a -> Maybe a
Just Implication
imp)  -- Do nothing

  | Bool
otherwise  -- Even for IC_Insoluble it is worth doing more work
               -- The insoluble stuff might be in one sub-implication
               -- and other unsolved goals in another; and we want to
               -- solve the latter as much as possible
  = do { InertSet
inerts <- TcS InertSet
getTcSInerts
       ; String -> SDoc -> TcS ()
traceTcS "solveImplication {" (Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
imp SDoc -> SDoc -> SDoc
$$ String -> SDoc
text "Inerts" SDoc -> SDoc -> SDoc
<+> InertSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr InertSet
inerts)

       -- commented out; see `where` clause below
       -- ; when debugIsOn check_tc_level

         -- Solve the nested constraints
       ; (no_given_eqs :: Bool
no_given_eqs, given_insols :: Cts
given_insols, residual_wanted :: WantedConstraints
residual_wanted)
            <- EvBindsVar
-> TcLevel
-> TcS (Bool, Cts, WantedConstraints)
-> TcS (Bool, Cts, WantedConstraints)
forall a. EvBindsVar -> TcLevel -> TcS a -> TcS a
nestImplicTcS EvBindsVar
ev_binds_var TcLevel
tclvl (TcS (Bool, Cts, WantedConstraints)
 -> TcS (Bool, Cts, WantedConstraints))
-> TcS (Bool, Cts, WantedConstraints)
-> TcS (Bool, Cts, WantedConstraints)
forall a b. (a -> b) -> a -> b
$
               do { let loc :: CtLoc
loc    = TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
tclvl SkolemInfo
info (Implication -> TcLclEnv
implicLclEnv Implication
imp)
                        givens :: [Ct]
givens = CtLoc -> [TcTyCoVar] -> [Ct]
mkGivens CtLoc
loc [TcTyCoVar]
given_ids
                  ; [Ct] -> TcS ()
solveSimpleGivens [Ct]
givens

                  ; WantedConstraints
residual_wanted <- WantedConstraints -> TcS WantedConstraints
solveWanteds WantedConstraints
wanteds
                        -- solveWanteds, *not* solveWantedsAndDrop, because
                        -- we want to retain derived equalities so we can float
                        -- them out in floatEqualities

                  ; (no_eqs :: Bool
no_eqs, given_insols :: Cts
given_insols) <- TcLevel -> [TcTyCoVar] -> TcS (Bool, Cts)
getNoGivenEqs TcLevel
tclvl [TcTyCoVar]
skols
                        -- Call getNoGivenEqs /after/ solveWanteds, because
                        -- solveWanteds can augment the givens, via expandSuperClasses,
                        -- to reveal given superclass equalities

                  ; (Bool, Cts, WantedConstraints)
-> TcS (Bool, Cts, WantedConstraints)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
no_eqs, Cts
given_insols, WantedConstraints
residual_wanted) }

       ; (floated_eqs :: Cts
floated_eqs, residual_wanted :: WantedConstraints
residual_wanted)
             <- [TcTyCoVar]
-> [TcTyCoVar]
-> EvBindsVar
-> Bool
-> WantedConstraints
-> TcS (Cts, WantedConstraints)
floatEqualities [TcTyCoVar]
skols [TcTyCoVar]
given_ids EvBindsVar
ev_binds_var
                                Bool
no_given_eqs WantedConstraints
residual_wanted

       ; String -> SDoc -> TcS ()
traceTcS "solveImplication 2"
           (Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
given_insols SDoc -> SDoc -> SDoc
$$ WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
residual_wanted)
       ; let final_wanted :: WantedConstraints
final_wanted = WantedConstraints
residual_wanted WantedConstraints -> Cts -> WantedConstraints
`addInsols` Cts
given_insols
             -- Don't lose track of the insoluble givens,
             -- which signal unreachable code; put them in ic_wanted

       ; Maybe Implication
res_implic <- Implication -> TcS (Maybe Implication)
setImplicationStatus (Implication
imp { ic_no_eqs :: Bool
ic_no_eqs = Bool
no_given_eqs
                                                 , ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints
final_wanted })

       ; EvBindMap
evbinds <- EvBindsVar -> TcS EvBindMap
TcS.getTcEvBindsMap EvBindsVar
ev_binds_var
       ; TcTyVarSet
tcvs    <- EvBindsVar -> TcS TcTyVarSet
TcS.getTcEvTyCoVars EvBindsVar
ev_binds_var
       ; String -> SDoc -> TcS ()
traceTcS "solveImplication end }" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
vcat
             [ String -> SDoc
text "no_given_eqs =" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
no_given_eqs
             , String -> SDoc
text "floated_eqs =" SDoc -> SDoc -> SDoc
<+> Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
floated_eqs
             , String -> SDoc
text "res_implic =" SDoc -> SDoc -> SDoc
<+> Maybe Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Maybe Implication
res_implic
             , String -> SDoc
text "implication evbinds =" SDoc -> SDoc -> SDoc
<+> Bag EvBind -> SDoc
forall a. Outputable a => a -> SDoc
ppr (EvBindMap -> Bag EvBind
evBindMapBinds EvBindMap
evbinds)
             , String -> SDoc
text "implication tvcs =" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
tcvs ]

       ; (Cts, Maybe Implication) -> TcS (Cts, Maybe Implication)
forall (m :: * -> *) a. Monad m => a -> m a
return (Cts
floated_eqs, Maybe Implication
res_implic) }

  where
    -- TcLevels must be strictly increasing (see (ImplicInv) in
    -- Note [TcLevel and untouchable type variables] in TcType),
    -- and in fact I thinkthey should always increase one level at a time.

    -- Though sensible, this check causes lots of testsuite failures. It is
    -- remaining commented out for now.
    {-
    check_tc_level = do { cur_lvl <- TcS.getTcLevel
                        ; MASSERT2( tclvl == pushTcLevel cur_lvl , text "Cur lvl =" <+> ppr cur_lvl $$ text "Imp lvl =" <+> ppr tclvl ) }
    -}

----------------------
setImplicationStatus :: Implication -> TcS (Maybe Implication)
-- Finalise the implication returned from solveImplication:
--    * Set the ic_status field
--    * Trim the ic_wanted field to remove Derived constraints
-- Precondition: the ic_status field is not already IC_Solved
-- Return Nothing if we can discard the implication altogether
setImplicationStatus :: Implication -> TcS (Maybe Implication)
setImplicationStatus implic :: Implication
implic@(Implic { ic_status :: Implication -> ImplicStatus
ic_status     = ImplicStatus
status
                                    , ic_info :: Implication -> SkolemInfo
ic_info       = SkolemInfo
info
                                    , ic_wanted :: Implication -> WantedConstraints
ic_wanted     = WantedConstraints
wc
                                    , ic_given :: Implication -> [TcTyCoVar]
ic_given      = [TcTyCoVar]
givens })
 | ASSERT2( not (isSolvedStatus status ), ppr info )
   -- Precondition: we only set the status if it is not already solved
   Bool -> Bool
not (WantedConstraints -> Bool
isSolvedWC WantedConstraints
pruned_wc)
 = do { String -> SDoc -> TcS ()
traceTcS "setImplicationStatus(not-all-solved) {" (Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
implic)

      ; Implication
implic <- Implication -> TcS Implication
neededEvVars Implication
implic

      ; let new_status :: ImplicStatus
new_status | WantedConstraints -> Bool
insolubleWC WantedConstraints
pruned_wc = ImplicStatus
IC_Insoluble
                       | Bool
otherwise             = ImplicStatus
IC_Unsolved
            new_implic :: Implication
new_implic = Implication
implic { ic_status :: ImplicStatus
ic_status = ImplicStatus
new_status
                                , ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints
pruned_wc }

      ; String -> SDoc -> TcS ()
traceTcS "setImplicationStatus(not-all-solved) }" (Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
new_implic)

      ; Maybe Implication -> TcS (Maybe Implication)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Implication -> TcS (Maybe Implication))
-> Maybe Implication -> TcS (Maybe Implication)
forall a b. (a -> b) -> a -> b
$ Implication -> Maybe Implication
forall a. a -> Maybe a
Just Implication
new_implic }

 | Bool
otherwise  -- Everything is solved
              -- Set status to IC_Solved,
              -- and compute the dead givens and outer needs
              -- See Note [Tracking redundant constraints]
 = do { String -> SDoc -> TcS ()
traceTcS "setImplicationStatus(all-solved) {" (Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
implic)

      ; implic :: Implication
implic@(Implic { ic_need_inner :: Implication -> TcTyVarSet
ic_need_inner = TcTyVarSet
need_inner
                       , ic_need_outer :: Implication -> TcTyVarSet
ic_need_outer = TcTyVarSet
need_outer }) <- Implication -> TcS Implication
neededEvVars Implication
implic

      ; Bool
bad_telescope <- Implication -> TcS Bool
checkBadTelescope Implication
implic

      ; let dead_givens :: [TcTyCoVar]
dead_givens | SkolemInfo -> Bool
warnRedundantGivens SkolemInfo
info
                        = (TcTyCoVar -> Bool) -> [TcTyCoVar] -> [TcTyCoVar]
forall a. (a -> Bool) -> [a] -> [a]
filterOut (TcTyCoVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
need_inner) [TcTyCoVar]
givens
                        | Bool
otherwise = []   -- None to report

            discard_entire_implication :: Bool
discard_entire_implication  -- Can we discard the entire implication?
              =  [TcTyCoVar] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TcTyCoVar]
dead_givens           -- No warning from this implication
              Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
bad_telescope
              Bool -> Bool -> Bool
&& WantedConstraints -> Bool
isEmptyWC WantedConstraints
pruned_wc        -- No live children
              Bool -> Bool -> Bool
&& TcTyVarSet -> Bool
isEmptyVarSet TcTyVarSet
need_outer   -- No needed vars to pass up to parent

            final_status :: ImplicStatus
final_status
              | Bool
bad_telescope = ImplicStatus
IC_BadTelescope
              | Bool
otherwise     = IC_Solved :: [TcTyCoVar] -> ImplicStatus
IC_Solved { ics_dead :: [TcTyCoVar]
ics_dead = [TcTyCoVar]
dead_givens }
            final_implic :: Implication
final_implic = Implication
implic { ic_status :: ImplicStatus
ic_status = ImplicStatus
final_status
                                  , ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints
pruned_wc }

      ; String -> SDoc -> TcS ()
traceTcS "setImplicationStatus(all-solved) }" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
        [SDoc] -> SDoc
vcat [ String -> SDoc
text "discard:" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
discard_entire_implication
             , String -> SDoc
text "new_implic:" SDoc -> SDoc -> SDoc
<+> Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
final_implic ]

      ; Maybe Implication -> TcS (Maybe Implication)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Implication -> TcS (Maybe Implication))
-> Maybe Implication -> TcS (Maybe Implication)
forall a b. (a -> b) -> a -> b
$ if Bool
discard_entire_implication
                 then Maybe Implication
forall a. Maybe a
Nothing
                 else Implication -> Maybe Implication
forall a. a -> Maybe a
Just Implication
final_implic }
 where
   WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics } = WantedConstraints
wc

   pruned_simples :: Cts
pruned_simples = Cts -> Cts
dropDerivedSimples Cts
simples
   pruned_implics :: Bag Implication
pruned_implics = (Implication -> Bool) -> Bag Implication -> Bag Implication
forall a. (a -> Bool) -> Bag a -> Bag a
filterBag Implication -> Bool
keep_me Bag Implication
implics
   pruned_wc :: WantedConstraints
pruned_wc = WC :: Cts -> Bag Implication -> WantedConstraints
WC { wc_simple :: Cts
wc_simple = Cts
pruned_simples
                  , wc_impl :: Bag Implication
wc_impl   = Bag Implication
pruned_implics }

   keep_me :: Implication -> Bool
   keep_me :: Implication -> Bool
keep_me ic :: Implication
ic
     | IC_Solved { ics_dead :: ImplicStatus -> [TcTyCoVar]
ics_dead = [TcTyCoVar]
dead_givens } <- Implication -> ImplicStatus
ic_status Implication
ic
                          -- Fully solved
     , [TcTyCoVar] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TcTyCoVar]
dead_givens   -- No redundant givens to report
     , Bag Implication -> Bool
forall a. Bag a -> Bool
isEmptyBag (WantedConstraints -> Bag Implication
wc_impl (Implication -> WantedConstraints
ic_wanted Implication
ic))
           -- And no children that might have things to report
     = Bool
False       -- Tnen we don't need to keep it
     | Bool
otherwise
     = Bool
True        -- Otherwise, keep it

checkBadTelescope :: Implication -> TcS Bool
-- True <=> the skolems form a bad telescope
-- See Note [Keeping scoped variables in order: Explicit] in TcHsType
checkBadTelescope :: Implication -> TcS Bool
checkBadTelescope (Implic { ic_telescope :: Implication -> Maybe SDoc
ic_telescope  = Maybe SDoc
m_telescope
                          , ic_skols :: Implication -> [TcTyCoVar]
ic_skols      = [TcTyCoVar]
skols })
  | Maybe SDoc -> Bool
forall a. Maybe a -> Bool
isJust Maybe SDoc
m_telescope
  = do{ [TcTyCoVar]
skols <- (TcTyCoVar -> TcS TcTyCoVar) -> [TcTyCoVar] -> TcS [TcTyCoVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM TcTyCoVar -> TcS TcTyCoVar
TcS.zonkTyCoVarKind [TcTyCoVar]
skols
      ; Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (TcTyVarSet -> [TcTyCoVar] -> Bool
go TcTyVarSet
emptyVarSet ([TcTyCoVar] -> [TcTyCoVar]
forall a. [a] -> [a]
reverse [TcTyCoVar]
skols))}

  | Bool
otherwise
  = Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False

  where
    go :: TyVarSet   -- skolems that appear *later* than the current ones
       -> [TcTyVar]  -- ordered skolems, in reverse order
       -> Bool       -- True <=> there is an out-of-order skolem
    go :: TcTyVarSet -> [TcTyCoVar] -> Bool
go _ [] = Bool
False
    go later_skols :: TcTyVarSet
later_skols (one_skol :: TcTyCoVar
one_skol : earlier_skols :: [TcTyCoVar]
earlier_skols)
      | Type -> TcTyVarSet
tyCoVarsOfType (TcTyCoVar -> Type
tyVarKind TcTyCoVar
one_skol) TcTyVarSet -> TcTyVarSet -> Bool
`intersectsVarSet` TcTyVarSet
later_skols
      = Bool
True
      | Bool
otherwise
      = TcTyVarSet -> [TcTyCoVar] -> Bool
go (TcTyVarSet
later_skols TcTyVarSet -> TcTyCoVar -> TcTyVarSet
`extendVarSet` TcTyCoVar
one_skol) [TcTyCoVar]
earlier_skols

warnRedundantGivens :: SkolemInfo -> Bool
warnRedundantGivens :: SkolemInfo -> Bool
warnRedundantGivens (SigSkol ctxt :: UserTypeCtxt
ctxt _ _)
  = case UserTypeCtxt
ctxt of
       FunSigCtxt _ warn_redundant :: Bool
warn_redundant -> Bool
warn_redundant
       ExprSigCtxt                 -> Bool
True
       _                           -> Bool
False

  -- To think about: do we want to report redundant givens for
  -- pattern synonyms, PatSynSigSkol? c.f Trac #9953, comment:21.
warnRedundantGivens (InstSkol {}) = Bool
True
warnRedundantGivens _             = Bool
False

neededEvVars :: Implication -> TcS Implication
-- Find all the evidence variables that are "needed",
-- and delete dead evidence bindings
--   See Note [Tracking redundant constraints]
--   See Note [Delete dead Given evidence bindings]
--
--   - Start from initial_seeds (from nested implications)
--
--   - Add free vars of RHS of all Wanted evidence bindings
--     and coercion variables accumulated in tcvs (all Wanted)
--
--   - Generate 'needed', the needed set of EvVars, by doing transitive
--     closure through Given bindings
--     e.g.   Needed {a,b}
--            Given  a = sc_sel a2
--            Then a2 is needed too
--
--   - Prune out all Given bindings that are not needed
--
--   - From the 'needed' set, delete ev_bndrs, the binders of the
--     evidence bindings, to give the final needed variables
--
neededEvVars :: Implication -> TcS Implication
neededEvVars implic :: Implication
implic@(Implic { ic_given :: Implication -> [TcTyCoVar]
ic_given = [TcTyCoVar]
givens
                            , ic_binds :: Implication -> EvBindsVar
ic_binds = EvBindsVar
ev_binds_var
                            , ic_wanted :: Implication -> WantedConstraints
ic_wanted = WC { wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics }
                            , ic_need_inner :: Implication -> TcTyVarSet
ic_need_inner = TcTyVarSet
old_needs })
 = do { EvBindMap
ev_binds <- EvBindsVar -> TcS EvBindMap
TcS.getTcEvBindsMap EvBindsVar
ev_binds_var
      ; TcTyVarSet
tcvs     <- EvBindsVar -> TcS TcTyVarSet
TcS.getTcEvTyCoVars EvBindsVar
ev_binds_var

      ; let seeds1 :: TcTyVarSet
seeds1        = (Implication -> TcTyVarSet -> TcTyVarSet)
-> TcTyVarSet -> Bag Implication -> TcTyVarSet
forall a r. (a -> r -> r) -> r -> Bag a -> r
foldrBag Implication -> TcTyVarSet -> TcTyVarSet
add_implic_seeds TcTyVarSet
old_needs Bag Implication
implics
            seeds2 :: TcTyVarSet
seeds2        = (EvBind -> TcTyVarSet -> TcTyVarSet)
-> TcTyVarSet -> EvBindMap -> TcTyVarSet
forall a. (EvBind -> a -> a) -> a -> EvBindMap -> a
foldEvBindMap EvBind -> TcTyVarSet -> TcTyVarSet
add_wanted TcTyVarSet
seeds1 EvBindMap
ev_binds
            seeds3 :: TcTyVarSet
seeds3        = TcTyVarSet
seeds2 TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
tcvs
            need_inner :: TcTyVarSet
need_inner    = EvBindMap -> TcTyVarSet -> TcTyVarSet
findNeededEvVars EvBindMap
ev_binds TcTyVarSet
seeds3
            live_ev_binds :: EvBindMap
live_ev_binds = (EvBind -> Bool) -> EvBindMap -> EvBindMap
filterEvBindMap (TcTyVarSet -> EvBind -> Bool
needed_ev_bind TcTyVarSet
need_inner) EvBindMap
ev_binds
            need_outer :: TcTyVarSet
need_outer    = (EvBind -> TcTyVarSet -> TcTyVarSet)
-> TcTyVarSet -> EvBindMap -> TcTyVarSet
forall a. (EvBind -> a -> a) -> a -> EvBindMap -> a
foldEvBindMap EvBind -> TcTyVarSet -> TcTyVarSet
del_ev_bndr TcTyVarSet
need_inner EvBindMap
live_ev_binds
                            TcTyVarSet -> [TcTyCoVar] -> TcTyVarSet
`delVarSetList` [TcTyCoVar]
givens

      ; EvBindsVar -> EvBindMap -> TcS ()
TcS.setTcEvBindsMap EvBindsVar
ev_binds_var EvBindMap
live_ev_binds
           -- See Note [Delete dead Given evidence bindings]

      ; String -> SDoc -> TcS ()
traceTcS "neededEvVars" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
        [SDoc] -> SDoc
vcat [ String -> SDoc
text "old_needs:" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
old_needs
             , String -> SDoc
text "seeds3:" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
seeds3
             , String -> SDoc
text "tcvs:" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
tcvs
             , String -> SDoc
text "ev_binds:" SDoc -> SDoc -> SDoc
<+> EvBindMap -> SDoc
forall a. Outputable a => a -> SDoc
ppr EvBindMap
ev_binds
             , String -> SDoc
text "live_ev_binds:" SDoc -> SDoc -> SDoc
<+> EvBindMap -> SDoc
forall a. Outputable a => a -> SDoc
ppr EvBindMap
live_ev_binds ]

      ; Implication -> TcS Implication
forall (m :: * -> *) a. Monad m => a -> m a
return (Implication
implic { ic_need_inner :: TcTyVarSet
ic_need_inner = TcTyVarSet
need_inner
                       , ic_need_outer :: TcTyVarSet
ic_need_outer = TcTyVarSet
need_outer }) }
 where
   add_implic_seeds :: Implication -> TcTyVarSet -> TcTyVarSet
add_implic_seeds (Implic { ic_need_outer :: Implication -> TcTyVarSet
ic_need_outer = TcTyVarSet
needs }) acc :: TcTyVarSet
acc
      = TcTyVarSet
needs TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
acc

   needed_ev_bind :: TcTyVarSet -> EvBind -> Bool
needed_ev_bind needed :: TcTyVarSet
needed (EvBind { eb_lhs :: EvBind -> TcTyCoVar
eb_lhs = TcTyCoVar
ev_var
                                 , eb_is_given :: EvBind -> Bool
eb_is_given = Bool
is_given })
     | Bool
is_given  = TcTyCoVar
ev_var TcTyCoVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
needed
     | Bool
otherwise = Bool
True   -- Keep all wanted bindings

   del_ev_bndr :: EvBind -> VarSet -> VarSet
   del_ev_bndr :: EvBind -> TcTyVarSet -> TcTyVarSet
del_ev_bndr (EvBind { eb_lhs :: EvBind -> TcTyCoVar
eb_lhs = TcTyCoVar
v }) needs :: TcTyVarSet
needs = TcTyVarSet -> TcTyCoVar -> TcTyVarSet
delVarSet TcTyVarSet
needs TcTyCoVar
v

   add_wanted :: EvBind -> VarSet -> VarSet
   add_wanted :: EvBind -> TcTyVarSet -> TcTyVarSet
add_wanted (EvBind { eb_is_given :: EvBind -> Bool
eb_is_given = Bool
is_given, eb_rhs :: EvBind -> EvTerm
eb_rhs = EvTerm
rhs }) needs :: TcTyVarSet
needs
     | Bool
is_given  = TcTyVarSet
needs  -- Add the rhs vars of the Wanted bindings only
     | Bool
otherwise = EvTerm -> TcTyVarSet
evVarsOfTerm EvTerm
rhs TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
needs


{- Note [Delete dead Given evidence bindings]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
As a result of superclass expansion, we speculatively
generate evidence bindings for Givens. E.g.
   f :: (a ~ b) => a -> b -> Bool
   f x y = ...
We'll have
   [G] d1 :: (a~b)
and we'll specuatively generate the evidence binding
   [G] d2 :: (a ~# b) = sc_sel d

Now d2 is available for solving.  But it may not be needed!  Usually
such dead superclass selections will eventually be dropped as dead
code, but:

 * It won't always be dropped (Trac #13032).  In the case of an
   unlifted-equality superclass like d2 above, we generate
       case heq_sc d1 of d2 -> ...
   and we can't (in general) drop that case exrpession in case
   d1 is bottom.  So it's technically unsound to have added it
   in the first place.

 * Simply generating all those extra superclasses can generate lots of
   code that has to be zonked, only to be discarded later.  Better not
   to generate it in the first place.

   Moreover, if we simplify this implication more than once
   (e.g. because we can't solve it completely on the first iteration
   of simpl_looop), we'll generate all the same bindings AGAIN!

Easy solution: take advantage of the work we are doing to track dead
(unused) Givens, and use it to prune the Given bindings too.  This is
all done by neededEvVars.

This led to a remarkable 25% overall compiler allocation decrease in
test T12227.

But we don't get to discard all redundant equality superclasses, alas;
see Trac #15205.

Note [Tracking redundant constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
With Opt_WarnRedundantConstraints, GHC can report which
constraints of a type signature (or instance declaration) are
redundant, and can be omitted.  Here is an overview of how it
works:

----- What is a redundant constraint?

* The things that can be redundant are precisely the Given
  constraints of an implication.

* A constraint can be redundant in two different ways:
  a) It is implied by other givens.  E.g.
       f :: (Eq a, Ord a)     => blah   -- Eq a unnecessary
       g :: (Eq a, a~b, Eq b) => blah   -- Either Eq a or Eq b unnecessary
  b) It is not needed by the Wanted constraints covered by the
     implication E.g.
       f :: Eq a => a -> Bool
       f x = True  -- Equality not used

*  To find (a), when we have two Given constraints,
   we must be careful to drop the one that is a naked variable (if poss).
   So if we have
       f :: (Eq a, Ord a) => blah
   then we may find [G] sc_sel (d1::Ord a) :: Eq a
                    [G] d2 :: Eq a
   We want to discard d2 in favour of the superclass selection from
   the Ord dictionary.  This is done by TcInteract.solveOneFromTheOther
   See Note [Replacement vs keeping].

* To find (b) we need to know which evidence bindings are 'wanted';
  hence the eb_is_given field on an EvBind.

----- How tracking works

* The ic_need fields of an Implic records in-scope (given) evidence
  variables bound by the context, that were needed to solve this
  implication (so far).  See the declaration of Implication.

* When the constraint solver finishes solving all the wanteds in
  an implication, it sets its status to IC_Solved

  - The ics_dead field, of IC_Solved, records the subset of this
    implication's ic_given that are redundant (not needed).

* We compute which evidence variables are needed by an implication
  in setImplicationStatus.  A variable is needed if
    a) it is free in the RHS of a Wanted EvBind,
    b) it is free in the RHS of an EvBind whose LHS is needed,
    c) it is in the ics_need of a nested implication.

* We need to be careful not to discard an implication
  prematurely, even one that is fully solved, because we might
  thereby forget which variables it needs, and hence wrongly
  report a constraint as redundant.  But we can discard it once
  its free vars have been incorporated into its parent; or if it
  simply has no free vars. This careful discarding is also
  handled in setImplicationStatus.

----- Reporting redundant constraints

* TcErrors does the actual warning, in warnRedundantConstraints.

* We don't report redundant givens for *every* implication; only
  for those which reply True to TcSimplify.warnRedundantGivens:

   - For example, in a class declaration, the default method *can*
     use the class constraint, but it certainly doesn't *have* to,
     and we don't want to report an error there.

   - More subtly, in a function definition
       f :: (Ord a, Ord a, Ix a) => a -> a
       f x = rhs
     we do an ambiguity check on the type (which would find that one
     of the Ord a constraints was redundant), and then we check that
     the definition has that type (which might find that both are
     redundant).  We don't want to report the same error twice, so we
     disable it for the ambiguity check.  Hence using two different
     FunSigCtxts, one with the warn-redundant field set True, and the
     other set False in
        - TcBinds.tcSpecPrag
        - TcBinds.tcTySig

  This decision is taken in setImplicationStatus, rather than TcErrors
  so that we can discard implication constraints that we don't need.
  So ics_dead consists only of the *reportable* redundant givens.

----- Shortcomings

Consider (see Trac #9939)
    f2 :: (Eq a, Ord a) => a -> a -> Bool
    -- Ord a redundant, but Eq a is reported
    f2 x y = (x == y)

We report (Eq a) as redundant, whereas actually (Ord a) is.  But it's
really not easy to detect that!


Note [Cutting off simpl_loop]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
It is very important not to iterate in simpl_loop unless there is a chance
of progress.  Trac #8474 is a classic example:

  * There's a deeply-nested chain of implication constraints.
       ?x:alpha => ?y1:beta1 => ... ?yn:betan => [W] ?x:Int

  * From the innermost one we get a [D] alpha ~ Int,
    but alpha is untouchable until we get out to the outermost one

  * We float [D] alpha~Int out (it is in floated_eqs), but since alpha
    is untouchable, the solveInteract in simpl_loop makes no progress

  * So there is no point in attempting to re-solve
       ?yn:betan => [W] ?x:Int
    via solveNestedImplications, because we'll just get the
    same [D] again

  * If we *do* re-solve, we'll get an ininite loop. It is cut off by
    the fixed bound of 10, but solving the next takes 10*10*...*10 (ie
    exponentially many) iterations!

Conclusion: we should call solveNestedImplications only if we did
some unification in solveSimpleWanteds; because that's the only way
we'll get more Givens (a unification is like adding a Given) to
allow the implication to make progress.
-}

promoteTyVar :: TcTyVar -> TcM (Bool, TcTyVar)
-- When we float a constraint out of an implication we must restore
-- invariant (WantedInv) in Note [TcLevel and untouchable type variables] in TcType
-- Return True <=> we did some promotion
-- Also returns either the original tyvar (no promotion) or the new one
-- See Note [Promoting unification variables]
promoteTyVar :: TcTyCoVar -> TcM (Bool, TcTyCoVar)
promoteTyVar tv :: TcTyCoVar
tv
  = do { TcLevel
tclvl <- TcM TcLevel
TcM.getTcLevel
       ; if (TcLevel -> TcTyCoVar -> Bool
isFloatedTouchableMetaTyVar TcLevel
tclvl TcTyCoVar
tv)
         then do { TcTyCoVar
cloned_tv <- TcTyCoVar -> IOEnv (Env TcGblEnv TcLclEnv) TcTyCoVar
TcM.cloneMetaTyVar TcTyCoVar
tv
                 ; let rhs_tv :: TcTyCoVar
rhs_tv = TcTyCoVar -> TcLevel -> TcTyCoVar
setMetaTyVarTcLevel TcTyCoVar
cloned_tv TcLevel
tclvl
                 ; TcTyCoVar -> Type -> TcM ()
TcM.writeMetaTyVar TcTyCoVar
tv (TcTyCoVar -> Type
mkTyVarTy TcTyCoVar
rhs_tv)
                 ; (Bool, TcTyCoVar) -> TcM (Bool, TcTyCoVar)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
True, TcTyCoVar
rhs_tv) }
         else (Bool, TcTyCoVar) -> TcM (Bool, TcTyCoVar)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
False, TcTyCoVar
tv) }

-- Returns whether or not *any* tyvar is defaulted
promoteTyVarSet :: TcTyVarSet -> TcM (Bool, TcTyVarSet)
promoteTyVarSet :: TcTyVarSet -> TcM (Bool, TcTyVarSet)
promoteTyVarSet tvs :: TcTyVarSet
tvs
  = do { (bools :: [Bool]
bools, tyvars :: [TcTyCoVar]
tyvars) <- (TcTyCoVar -> TcM (Bool, TcTyCoVar))
-> [TcTyCoVar]
-> IOEnv (Env TcGblEnv TcLclEnv) ([Bool], [TcTyCoVar])
forall (m :: * -> *) a b c.
Applicative m =>
(a -> m (b, c)) -> [a] -> m ([b], [c])
mapAndUnzipM TcTyCoVar -> TcM (Bool, TcTyCoVar)
promoteTyVar (TcTyVarSet -> [TcTyCoVar]
forall elt. UniqSet elt -> [elt]
nonDetEltsUniqSet TcTyVarSet
tvs)
           -- non-determinism is OK because order of promotion doesn't matter

       ; (Bool, TcTyVarSet) -> TcM (Bool, TcTyVarSet)
forall (m :: * -> *) a. Monad m => a -> m a
return ([Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
bools, [TcTyCoVar] -> TcTyVarSet
mkVarSet [TcTyCoVar]
tyvars) }

promoteTyVarTcS :: TcTyVar  -> TcS ()
-- When we float a constraint out of an implication we must restore
-- invariant (WantedInv) in Note [TcLevel and untouchable type variables] in TcType
-- See Note [Promoting unification variables]
-- We don't just call promoteTyVar because we want to use unifyTyVar,
-- not writeMetaTyVar
promoteTyVarTcS :: TcTyCoVar -> TcS ()
promoteTyVarTcS tv :: TcTyCoVar
tv
  = do { TcLevel
tclvl <- TcS TcLevel
TcS.getTcLevel
       ; Bool -> TcS () -> TcS ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (TcLevel -> TcTyCoVar -> Bool
isFloatedTouchableMetaTyVar TcLevel
tclvl TcTyCoVar
tv) (TcS () -> TcS ()) -> TcS () -> TcS ()
forall a b. (a -> b) -> a -> b
$
         do { TcTyCoVar
cloned_tv <- TcTyCoVar -> TcS TcTyCoVar
TcS.cloneMetaTyVar TcTyCoVar
tv
            ; let rhs_tv :: TcTyCoVar
rhs_tv = TcTyCoVar -> TcLevel -> TcTyCoVar
setMetaTyVarTcLevel TcTyCoVar
cloned_tv TcLevel
tclvl
            ; TcTyCoVar -> Type -> TcS ()
unifyTyVar TcTyCoVar
tv (TcTyCoVar -> Type
mkTyVarTy TcTyCoVar
rhs_tv) } }

-- | Like 'defaultTyVar', but in the TcS monad.
defaultTyVarTcS :: TcTyVar -> TcS Bool
defaultTyVarTcS :: TcTyCoVar -> TcS Bool
defaultTyVarTcS the_tv :: TcTyCoVar
the_tv
  | TcTyCoVar -> Bool
isRuntimeRepVar TcTyCoVar
the_tv
  , Bool -> Bool
not (TcTyCoVar -> Bool
isTyVarTyVar TcTyCoVar
the_tv)
    -- TyVarTvs should only be unified with a tyvar
    -- never with a type; c.f. TcMType.defaultTyVar
    -- and Note [Inferring kinds for type declarations] in TcTyClsDecls
  = do { String -> SDoc -> TcS ()
traceTcS "defaultTyVarTcS RuntimeRep" (TcTyCoVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyCoVar
the_tv)
       ; TcTyCoVar -> Type -> TcS ()
unifyTyVar TcTyCoVar
the_tv Type
liftedRepTy
       ; Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True }
  | Bool
otherwise
  = Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False  -- the common case

approximateWC :: Bool -> WantedConstraints -> Cts
-- Postcondition: Wanted or Derived Cts
-- See Note [ApproximateWC]
approximateWC :: Bool -> WantedConstraints -> Cts
approximateWC float_past_equalities :: Bool
float_past_equalities wc :: WantedConstraints
wc
  = TcTyVarSet -> WantedConstraints -> Cts
float_wc TcTyVarSet
emptyVarSet WantedConstraints
wc
  where
    float_wc :: TcTyCoVarSet -> WantedConstraints -> Cts
    float_wc :: TcTyVarSet -> WantedConstraints -> Cts
float_wc trapping_tvs :: TcTyVarSet
trapping_tvs (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics })
      = (Ct -> Bool) -> Cts -> Cts
forall a. (a -> Bool) -> Bag a -> Bag a
filterBag (TcTyVarSet -> Ct -> Bool
is_floatable TcTyVarSet
trapping_tvs) Cts
simples Cts -> Cts -> Cts
forall a. Bag a -> Bag a -> Bag a
`unionBags`
        (Implication -> Cts) -> Bag Implication -> Cts
forall a c. (a -> Bag c) -> Bag a -> Bag c
do_bag (TcTyVarSet -> Implication -> Cts
float_implic TcTyVarSet
trapping_tvs) Bag Implication
implics
      where

    float_implic :: TcTyCoVarSet -> Implication -> Cts
    float_implic :: TcTyVarSet -> Implication -> Cts
float_implic trapping_tvs :: TcTyVarSet
trapping_tvs imp :: Implication
imp
      | Bool
float_past_equalities Bool -> Bool -> Bool
|| Implication -> Bool
ic_no_eqs Implication
imp
      = TcTyVarSet -> WantedConstraints -> Cts
float_wc TcTyVarSet
new_trapping_tvs (Implication -> WantedConstraints
ic_wanted Implication
imp)
      | Bool
otherwise   -- Take care with equalities
      = Cts
emptyCts    -- See (1) under Note [ApproximateWC]
      where
        new_trapping_tvs :: TcTyVarSet
new_trapping_tvs = TcTyVarSet
trapping_tvs TcTyVarSet -> [TcTyCoVar] -> TcTyVarSet
`extendVarSetList` Implication -> [TcTyCoVar]
ic_skols Implication
imp

    do_bag :: (a -> Bag c) -> Bag a -> Bag c
    do_bag :: (a -> Bag c) -> Bag a -> Bag c
do_bag f :: a -> Bag c
f = (a -> Bag c -> Bag c) -> Bag c -> Bag a -> Bag c
forall a r. (a -> r -> r) -> r -> Bag a -> r
foldrBag (Bag c -> Bag c -> Bag c
forall a. Bag a -> Bag a -> Bag a
unionBags(Bag c -> Bag c -> Bag c) -> (a -> Bag c) -> a -> Bag c -> Bag c
forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> Bag c
f) Bag c
forall a. Bag a
emptyBag

    is_floatable :: TcTyVarSet -> Ct -> Bool
is_floatable skol_tvs :: TcTyVarSet
skol_tvs ct :: Ct
ct
       | Ct -> Bool
isGivenCt Ct
ct     = Bool
False
       | Ct -> Bool
isHoleCt Ct
ct      = Bool
False
       | Ct -> Bool
insolubleEqCt Ct
ct = Bool
False
       | Bool
otherwise        = Ct -> TcTyVarSet
tyCoVarsOfCt Ct
ct TcTyVarSet -> TcTyVarSet -> Bool
`disjointVarSet` TcTyVarSet
skol_tvs

{- Note [ApproximateWC]
~~~~~~~~~~~~~~~~~~~~~~~
approximateWC takes a constraint, typically arising from the RHS of a
let-binding whose type we are *inferring*, and extracts from it some
*simple* constraints that we might plausibly abstract over.  Of course
the top-level simple constraints are plausible, but we also float constraints
out from inside, if they are not captured by skolems.

The same function is used when doing type-class defaulting (see the call
to applyDefaultingRules) to extract constraints that that might be defaulted.

There is one caveat:

1.  When infering most-general types (in simplifyInfer), we do *not*
    float anything out if the implication binds equality constraints,
    because that defeats the OutsideIn story.  Consider
       data T a where
         TInt :: T Int
         MkT :: T a

       f TInt = 3::Int

    We get the implication (a ~ Int => res ~ Int), where so far we've decided
      f :: T a -> res
    We don't want to float (res~Int) out because then we'll infer
      f :: T a -> Int
    which is only on of the possible types. (GHC 7.6 accidentally *did*
    float out of such implications, which meant it would happily infer
    non-principal types.)

   HOWEVER (Trac #12797) in findDefaultableGroups we are not worried about
   the most-general type; and we /do/ want to float out of equalities.
   Hence the boolean flag to approximateWC.

------ Historical note -----------
There used to be a second caveat, driven by Trac #8155

   2. We do not float out an inner constraint that shares a type variable
      (transitively) with one that is trapped by a skolem.  Eg
          forall a.  F a ~ beta, Integral beta
      We don't want to float out (Integral beta).  Doing so would be bad
      when defaulting, because then we'll default beta:=Integer, and that
      makes the error message much worse; we'd get
          Can't solve  F a ~ Integer
      rather than
          Can't solve  Integral (F a)

      Moreover, floating out these "contaminated" constraints doesn't help
      when generalising either. If we generalise over (Integral b), we still
      can't solve the retained implication (forall a. F a ~ b).  Indeed,
      arguably that too would be a harder error to understand.

But this transitive closure stuff gives rise to a complex rule for
when defaulting actually happens, and one that was never documented.
Moreover (Trac #12923), the more complex rule is sometimes NOT what
you want.  So I simply removed the extra code to implement the
contamination stuff.  There was zero effect on the testsuite (not even
#8155).
------ End of historical note -----------


Note [DefaultTyVar]
~~~~~~~~~~~~~~~~~~~
defaultTyVar is used on any un-instantiated meta type variables to
default any RuntimeRep variables to LiftedRep.  This is important
to ensure that instance declarations match.  For example consider

     instance Show (a->b)
     foo x = show (\_ -> True)

Then we'll get a constraint (Show (p ->q)) where p has kind (TYPE r),
and that won't match the tcTypeKind (*) in the instance decl.  See tests
tc217 and tc175.

We look only at touchable type variables. No further constraints
are going to affect these type variables, so it's time to do it by
hand.  However we aren't ready to default them fully to () or
whatever, because the type-class defaulting rules have yet to run.

An alternate implementation would be to emit a derived constraint setting
the RuntimeRep variable to LiftedRep, but this seems unnecessarily indirect.

Note [Promote _and_ default when inferring]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When we are inferring a type, we simplify the constraint, and then use
approximateWC to produce a list of candidate constraints.  Then we MUST

  a) Promote any meta-tyvars that have been floated out by
     approximateWC, to restore invariant (WantedInv) described in
     Note [TcLevel and untouchable type variables] in TcType.

  b) Default the kind of any meta-tyvars that are not mentioned in
     in the environment.

To see (b), suppose the constraint is (C ((a :: OpenKind) -> Int)), and we
have an instance (C ((x:*) -> Int)).  The instance doesn't match -- but it
should!  If we don't solve the constraint, we'll stupidly quantify over
(C (a->Int)) and, worse, in doing so skolemiseQuantifiedTyVar will quantify over
(b:*) instead of (a:OpenKind), which can lead to disaster; see Trac #7332.
Trac #7641 is a simpler example.

Note [Promoting unification variables]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When we float an equality out of an implication we must "promote" free
unification variables of the equality, in order to maintain Invariant
(WantedInv) from Note [TcLevel and untouchable type variables] in
TcType.  for the leftover implication.

This is absolutely necessary. Consider the following example. We start
with two implications and a class with a functional dependency.

    class C x y | x -> y
    instance C [a] [a]

    (I1)      [untch=beta]forall b. 0 => F Int ~ [beta]
    (I2)      [untch=beta]forall c. 0 => F Int ~ [[alpha]] /\ C beta [c]

We float (F Int ~ [beta]) out of I1, and we float (F Int ~ [[alpha]]) out of I2.
They may react to yield that (beta := [alpha]) which can then be pushed inwards
the leftover of I2 to get (C [alpha] [a]) which, using the FunDep, will mean that
(alpha := a). In the end we will have the skolem 'b' escaping in the untouchable
beta! Concrete example is in indexed_types/should_fail/ExtraTcsUntch.hs:

    class C x y | x -> y where
     op :: x -> y -> ()

    instance C [a] [a]

    type family F a :: *

    h :: F Int -> ()
    h = undefined

    data TEx where
      TEx :: a -> TEx

    f (x::beta) =
        let g1 :: forall b. b -> ()
            g1 _ = h [x]
            g2 z = case z of TEx y -> (h [[undefined]], op x [y])
        in (g1 '3', g2 undefined)



*********************************************************************************
*                                                                               *
*                          Floating equalities                                  *
*                                                                               *
*********************************************************************************

Note [Float Equalities out of Implications]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For ordinary pattern matches (including existentials) we float
equalities out of implications, for instance:
     data T where
       MkT :: Eq a => a -> T
     f x y = case x of MkT _ -> (y::Int)
We get the implication constraint (x::T) (y::alpha):
     forall a. [untouchable=alpha] Eq a => alpha ~ Int
We want to float out the equality into a scope where alpha is no
longer untouchable, to solve the implication!

But we cannot float equalities out of implications whose givens may
yield or contain equalities:

      data T a where
        T1 :: T Int
        T2 :: T Bool
        T3 :: T a

      h :: T a -> a -> Int

      f x y = case x of
                T1 -> y::Int
                T2 -> y::Bool
                T3 -> h x y

We generate constraint, for (x::T alpha) and (y :: beta):
   [untouchables = beta] (alpha ~ Int => beta ~ Int)   -- From 1st branch
   [untouchables = beta] (alpha ~ Bool => beta ~ Bool) -- From 2nd branch
   (alpha ~ beta)                                      -- From 3rd branch

If we float the equality (beta ~ Int) outside of the first implication and
the equality (beta ~ Bool) out of the second we get an insoluble constraint.
But if we just leave them inside the implications, we unify alpha := beta and
solve everything.

Principle:
    We do not want to float equalities out which may
    need the given *evidence* to become soluble.

Consequence: classes with functional dependencies don't matter (since there is
no evidence for a fundep equality), but equality superclasses do matter (since
they carry evidence).
-}

floatEqualities :: [TcTyVar] -> [EvId] -> EvBindsVar -> Bool
                -> WantedConstraints
                -> TcS (Cts, WantedConstraints)
-- Main idea: see Note [Float Equalities out of Implications]
--
-- Precondition: the wc_simple of the incoming WantedConstraints are
--               fully zonked, so that we can see their free variables
--
-- Postcondition: The returned floated constraints (Cts) are only
--                Wanted or Derived
--
-- Also performs some unifications (via promoteTyVar), adding to
-- monadically-carried ty_binds. These will be used when processing
-- floated_eqs later
--
-- Subtleties: Note [Float equalities from under a skolem binding]
--             Note [Skolem escape]
--             Note [What prevents a constraint from floating]
floatEqualities :: [TcTyCoVar]
-> [TcTyCoVar]
-> EvBindsVar
-> Bool
-> WantedConstraints
-> TcS (Cts, WantedConstraints)
floatEqualities skols :: [TcTyCoVar]
skols given_ids :: [TcTyCoVar]
given_ids ev_binds_var :: EvBindsVar
ev_binds_var no_given_eqs :: Bool
no_given_eqs
                wanteds :: WantedConstraints
wanteds@(WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples })
  | Bool -> Bool
not Bool
no_given_eqs  -- There are some given equalities, so don't float
  = (Cts, WantedConstraints) -> TcS (Cts, WantedConstraints)
forall (m :: * -> *) a. Monad m => a -> m a
return (Cts
forall a. Bag a
emptyBag, WantedConstraints
wanteds)   -- Note [Float Equalities out of Implications]

  | Bool
otherwise
  = do { -- First zonk: the inert set (from whence they came) is fully
         -- zonked, but unflattening may have filled in unification
         -- variables, and we /must/ see them.  Otherwise we may float
         -- constraints that mention the skolems!
         Cts
simples <- Cts -> TcS Cts
TcS.zonkSimples Cts
simples
       ; EvBindMap
binds   <- EvBindsVar -> TcS EvBindMap
TcS.getTcEvBindsMap EvBindsVar
ev_binds_var

       -- Now we can pick the ones to float
       -- The constraints are un-flattened and de-canonicalised
       ; let (candidate_eqs :: Cts
candidate_eqs, no_float_cts :: Cts
no_float_cts) = (Ct -> Bool) -> Cts -> (Cts, Cts)
forall a. (a -> Bool) -> Bag a -> (Bag a, Bag a)
partitionBag Ct -> Bool
is_float_eq_candidate Cts
simples

             seed_skols :: TcTyVarSet
seed_skols = [TcTyCoVar] -> TcTyVarSet
mkVarSet [TcTyCoVar]
skols     TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet`
                          [TcTyCoVar] -> TcTyVarSet
mkVarSet [TcTyCoVar]
given_ids TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet`
                          (Ct -> TcTyVarSet -> TcTyVarSet) -> TcTyVarSet -> Cts -> TcTyVarSet
forall a r. (a -> r -> r) -> r -> Bag a -> r
foldrBag Ct -> TcTyVarSet -> TcTyVarSet
add_non_flt_ct TcTyVarSet
emptyVarSet Cts
no_float_cts TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet`
                          (EvBind -> TcTyVarSet -> TcTyVarSet)
-> TcTyVarSet -> EvBindMap -> TcTyVarSet
forall a. (EvBind -> a -> a) -> a -> EvBindMap -> a
foldEvBindMap EvBind -> TcTyVarSet -> TcTyVarSet
add_one_bind TcTyVarSet
emptyVarSet EvBindMap
binds
             -- seed_skols: See Note [What prevents a constraint from floating] (1,2,3)
             -- Include the EvIds of any non-floating constraints

             extended_skols :: TcTyVarSet
extended_skols = (TcTyVarSet -> TcTyVarSet) -> TcTyVarSet -> TcTyVarSet
transCloVarSet (Cts -> TcTyVarSet -> TcTyVarSet
add_captured_ev_ids Cts
candidate_eqs) TcTyVarSet
seed_skols
                 -- extended_skols contains the EvIds of all the trapped constraints
                 -- See Note [What prevents a constraint from floating] (3)

             (flt_eqs :: Cts
flt_eqs, no_flt_eqs :: Cts
no_flt_eqs) = (Ct -> Bool) -> Cts -> (Cts, Cts)
forall a. (a -> Bool) -> Bag a -> (Bag a, Bag a)
partitionBag (TcTyVarSet -> Ct -> Bool
is_floatable TcTyVarSet
extended_skols)
                                                  Cts
candidate_eqs

             remaining_simples :: Cts
remaining_simples = Cts
no_float_cts Cts -> Cts -> Cts
`andCts` Cts
no_flt_eqs

       -- Promote any unification variables mentioned in the floated equalities
       -- See Note [Promoting unification variables]
       ; (TcTyCoVar -> TcS ()) -> [TcTyCoVar] -> TcS ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ TcTyCoVar -> TcS ()
promoteTyVarTcS (Cts -> [TcTyCoVar]
tyCoVarsOfCtsList Cts
flt_eqs)

       ; String -> SDoc -> TcS ()
traceTcS "floatEqualities" ([SDoc] -> SDoc
vcat [ String -> SDoc
text "Skols =" SDoc -> SDoc -> SDoc
<+> [TcTyCoVar] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TcTyCoVar]
skols
                                          , String -> SDoc
text "Extended skols =" SDoc -> SDoc -> SDoc
<+> TcTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVarSet
extended_skols
                                          , String -> SDoc
text "Simples =" SDoc -> SDoc -> SDoc
<+> Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
simples
                                          , String -> SDoc
text "Candidate eqs =" SDoc -> SDoc -> SDoc
<+> Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
candidate_eqs
                                          , String -> SDoc
text "Floated eqs =" SDoc -> SDoc -> SDoc
<+> Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
flt_eqs])
       ; (Cts, WantedConstraints) -> TcS (Cts, WantedConstraints)
forall (m :: * -> *) a. Monad m => a -> m a
return ( Cts
flt_eqs, WantedConstraints
wanteds { wc_simple :: Cts
wc_simple = Cts
remaining_simples } ) }

  where
    add_one_bind :: EvBind -> VarSet -> VarSet
    add_one_bind :: EvBind -> TcTyVarSet -> TcTyVarSet
add_one_bind bind :: EvBind
bind acc :: TcTyVarSet
acc = TcTyVarSet -> TcTyCoVar -> TcTyVarSet
extendVarSet TcTyVarSet
acc (EvBind -> TcTyCoVar
evBindVar EvBind
bind)

    add_non_flt_ct :: Ct -> VarSet -> VarSet
    add_non_flt_ct :: Ct -> TcTyVarSet -> TcTyVarSet
add_non_flt_ct ct :: Ct
ct acc :: TcTyVarSet
acc | Ct -> Bool
isDerivedCt Ct
ct = TcTyVarSet
acc
                          | Bool
otherwise      = TcTyVarSet -> TcTyCoVar -> TcTyVarSet
extendVarSet TcTyVarSet
acc (Ct -> TcTyCoVar
ctEvId Ct
ct)

    is_floatable :: VarSet -> Ct -> Bool
    is_floatable :: TcTyVarSet -> Ct -> Bool
is_floatable skols :: TcTyVarSet
skols ct :: Ct
ct
      | Ct -> Bool
isDerivedCt Ct
ct = Bool -> Bool
not (Ct -> TcTyVarSet
tyCoVarsOfCt Ct
ct TcTyVarSet -> TcTyVarSet -> Bool
`intersectsVarSet` TcTyVarSet
skols)
      | Bool
otherwise      = Bool -> Bool
not (Ct -> TcTyCoVar
ctEvId Ct
ct TcTyCoVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
skols)

    add_captured_ev_ids :: Cts -> VarSet -> VarSet
    add_captured_ev_ids :: Cts -> TcTyVarSet -> TcTyVarSet
add_captured_ev_ids cts :: Cts
cts skols :: TcTyVarSet
skols = (Ct -> TcTyVarSet -> TcTyVarSet) -> TcTyVarSet -> Cts -> TcTyVarSet
forall a r. (a -> r -> r) -> r -> Bag a -> r
foldrBag Ct -> TcTyVarSet -> TcTyVarSet
extra_skol TcTyVarSet
emptyVarSet Cts
cts
       where
         extra_skol :: Ct -> TcTyVarSet -> TcTyVarSet
extra_skol ct :: Ct
ct acc :: TcTyVarSet
acc
           | Ct -> Bool
isDerivedCt Ct
ct                           = TcTyVarSet
acc
           | Ct -> TcTyVarSet
tyCoVarsOfCt Ct
ct TcTyVarSet -> TcTyVarSet -> Bool
`intersectsVarSet` TcTyVarSet
skols = TcTyVarSet -> TcTyCoVar -> TcTyVarSet
extendVarSet TcTyVarSet
acc (Ct -> TcTyCoVar
ctEvId Ct
ct)
           | Bool
otherwise                                = TcTyVarSet
acc

    -- Identify which equalities are candidates for floating
    -- Float out alpha ~ ty, or ty ~ alpha which might be unified outside
    -- See Note [Which equalities to float]
    is_float_eq_candidate :: Ct -> Bool
is_float_eq_candidate ct :: Ct
ct
      | Type
pred <- Ct -> Type
ctPred Ct
ct
      , EqPred NomEq ty1 :: Type
ty1 ty2 :: Type
ty2 <- Type -> PredTree
classifyPredType Type
pred
      , HasDebugCallStack => Type -> Type
Type -> Type
tcTypeKind Type
ty1 HasDebugCallStack => Type -> Type -> Bool
Type -> Type -> Bool
`tcEqType` HasDebugCallStack => Type -> Type
Type -> Type
tcTypeKind Type
ty2
      = case (Type -> Maybe TcTyCoVar
tcGetTyVar_maybe Type
ty1, Type -> Maybe TcTyCoVar
tcGetTyVar_maybe Type
ty2) of
          (Just tv1 :: TcTyCoVar
tv1, _) -> TcTyCoVar -> Type -> Bool
float_tv_eq_candidate TcTyCoVar
tv1 Type
ty2
          (_, Just tv2 :: TcTyCoVar
tv2) -> TcTyCoVar -> Type -> Bool
float_tv_eq_candidate TcTyCoVar
tv2 Type
ty1
          _             -> Bool
False
      | Bool
otherwise = Bool
False

    float_tv_eq_candidate :: TcTyCoVar -> Type -> Bool
float_tv_eq_candidate tv1 :: TcTyCoVar
tv1 ty2 :: Type
ty2  -- See Note [Which equalities to float]
      =  TcTyCoVar -> Bool
isMetaTyVar TcTyCoVar
tv1
      Bool -> Bool -> Bool
&& (Bool -> Bool
not (TcTyCoVar -> Bool
isTyVarTyVar TcTyCoVar
tv1) Bool -> Bool -> Bool
|| Type -> Bool
isTyVarTy Type
ty2)


{- Note [Float equalities from under a skolem binding]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Which of the simple equalities can we float out?  Obviously, only
ones that don't mention the skolem-bound variables.  But that is
over-eager. Consider
   [2] forall a. F a beta[1] ~ gamma[2], G beta[1] gamma[2] ~ Int
The second constraint doesn't mention 'a'.  But if we float it,
we'll promote gamma[2] to gamma'[1].  Now suppose that we learn that
beta := Bool, and F a Bool = a, and G Bool _ = Int.  Then we'll
we left with the constraint
   [2] forall a. a ~ gamma'[1]
which is insoluble because gamma became untouchable.

Solution: float only constraints that stand a jolly good chance of
being soluble simply by being floated, namely ones of form
      a ~ ty
where 'a' is a currently-untouchable unification variable, but may
become touchable by being floated (perhaps by more than one level).

We had a very complicated rule previously, but this is nice and
simple.  (To see the notes, look at this Note in a version of
TcSimplify prior to Oct 2014).

Note [Which equalities to float]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Which equalities should we float?  We want to float ones where there
is a decent chance that floating outwards will allow unification to
happen.  In particular, float out equalities that are:

* Of form (alpha ~# ty) or (ty ~# alpha), where
   * alpha is a meta-tyvar.
   * And 'alpha' is not a TyVarTv with 'ty' being a non-tyvar.  In that
     case, floating out won't help either, and it may affect grouping
     of error messages.

* Homogeneous (both sides have the same kind). Why only homogeneous?
  Because heterogeneous equalities have derived kind equalities.
  See Note [Equalities with incompatible kinds] in TcCanonical.
  If we float out a hetero equality, then it will spit out the same
  derived kind equality again, which might create duplicate error
  messages.

  Instead, we do float out the kind equality (if it's worth floating
  out, as above). If/when we solve it, we'll be able to rewrite the
  original hetero equality to be homogeneous, and then perhaps make
  progress / float it out. The duplicate error message was spotted in
  typecheck/should_fail/T7368.

* Nominal.  No point in floating (alpha ~R# ty), because we do not
  unify representational equalities even if alpha is touchable.
  See Note [Do not unify representational equalities] in TcInteract.

Note [Skolem escape]
~~~~~~~~~~~~~~~~~~~~
You might worry about skolem escape with all this floating.
For example, consider
    [2] forall a. (a ~ F beta[2] delta,
                   Maybe beta[2] ~ gamma[1])

The (Maybe beta ~ gamma) doesn't mention 'a', so we float it, and
solve with gamma := beta. But what if later delta:=Int, and
  F b Int = b.
Then we'd get a ~ beta[2], and solve to get beta:=a, and now the
skolem has escaped!

But it's ok: when we float (Maybe beta[2] ~ gamma[1]), we promote beta[2]
to beta[1], and that means the (a ~ beta[1]) will be stuck, as it should be.

Note [What prevents a constraint from floating]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
What /prevents/ a constraint from floating?  If it mentions one of the
"bound variables of the implication".  What are they?

The "bound variables of the implication" are

  1. The skolem type variables `ic_skols`

  2. The "given" evidence variables `ic_given`.  Example:
         forall a. (co :: t1 ~# t2) =>  [W] co2 : (a ~# b |> co)
     Here 'co' is bound

  3. The binders of all evidence bindings in `ic_binds`. Example
         forall a. (d :: t1 ~ t2)
            EvBinds { (co :: t1 ~# t2) = superclass-sel d }
            => [W] co2 : (a ~# b |> co)
     Here `co` is gotten by superclass selection from `d`, and the
     wanted constraint co2 must not float.

  4. And the evidence variable of any equality constraint (incl
     Wanted ones) whose type mentions a bound variable.  Example:
        forall k. [W] co1 :: t1 ~# t2 |> co2
                  [W] co2 :: k ~# *
     Here, since `k` is bound, so is `co2` and hence so is `co1`.

Here (1,2,3) are handled by the "seed_skols" calculation, and
(4) is done by the transCloVarSet call.

The possible dependence on givens, and evidence bindings, is more
subtle than we'd realised at first.  See Trac #14584.


*********************************************************************************
*                                                                               *
*                          Defaulting and disambiguation                        *
*                                                                               *
*********************************************************************************
-}

applyDefaultingRules :: WantedConstraints -> TcS Bool
-- True <=> I did some defaulting, by unifying a meta-tyvar
-- Input WantedConstraints are not necessarily zonked

applyDefaultingRules :: WantedConstraints -> TcS Bool
applyDefaultingRules wanteds :: WantedConstraints
wanteds
  | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wanteds
  = Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
  | Bool
otherwise
  = do { info :: ([Type], (Bool, Bool))
info@(default_tys :: [Type]
default_tys, _) <- TcS ([Type], (Bool, Bool))
getDefaultInfo
       ; WantedConstraints
wanteds               <- WantedConstraints -> TcS WantedConstraints
TcS.zonkWC WantedConstraints
wanteds

       ; let groups :: [(TcTyCoVar, [Ct])]
groups = ([Type], (Bool, Bool)) -> WantedConstraints -> [(TcTyCoVar, [Ct])]
findDefaultableGroups ([Type], (Bool, Bool))
info WantedConstraints
wanteds

       ; String -> SDoc -> TcS ()
traceTcS "applyDefaultingRules {" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
                  [SDoc] -> SDoc
vcat [ String -> SDoc
text "wanteds =" SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanteds
                       , String -> SDoc
text "groups  =" SDoc -> SDoc -> SDoc
<+> [(TcTyCoVar, [Ct])] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(TcTyCoVar, [Ct])]
groups
                       , String -> SDoc
text "info    =" SDoc -> SDoc -> SDoc
<+> ([Type], (Bool, Bool)) -> SDoc
forall a. Outputable a => a -> SDoc
ppr ([Type], (Bool, Bool))
info ]

       ; [Bool]
something_happeneds <- ((TcTyCoVar, [Ct]) -> TcS Bool)
-> [(TcTyCoVar, [Ct])] -> TcS [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([Type] -> (TcTyCoVar, [Ct]) -> TcS Bool
disambigGroup [Type]
default_tys) [(TcTyCoVar, [Ct])]
groups

       ; String -> SDoc -> TcS ()
traceTcS "applyDefaultingRules }" ([Bool] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Bool]
something_happeneds)

       ; Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return ([Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
something_happeneds) }

findDefaultableGroups
    :: ( [Type]
       , (Bool,Bool) )     -- (Overloaded strings, extended default rules)
    -> WantedConstraints   -- Unsolved (wanted or derived)
    -> [(TyVar, [Ct])]
findDefaultableGroups :: ([Type], (Bool, Bool)) -> WantedConstraints -> [(TcTyCoVar, [Ct])]
findDefaultableGroups (default_tys :: [Type]
default_tys, (ovl_strings :: Bool
ovl_strings, extended_defaults :: Bool
extended_defaults)) wanteds :: WantedConstraints
wanteds
  | [Type] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Type]
default_tys
  = []
  | Bool
otherwise
  = [ (TcTyCoVar
tv, ((Ct, Class, TcTyCoVar) -> Ct) -> [(Ct, Class, TcTyCoVar)] -> [Ct]
forall a b. (a -> b) -> [a] -> [b]
map (Ct, Class, TcTyCoVar) -> Ct
forall a b c. (a, b, c) -> a
fstOf3 [(Ct, Class, TcTyCoVar)]
group)
    | group' :: NonEmpty (Ct, Class, TcTyCoVar)
group'@((_,_,tv :: TcTyCoVar
tv) :| _) <- [NonEmpty (Ct, Class, TcTyCoVar)]
unary_groups
    , let group :: [(Ct, Class, TcTyCoVar)]
group = NonEmpty (Ct, Class, TcTyCoVar) -> [(Ct, Class, TcTyCoVar)]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty (Ct, Class, TcTyCoVar)
group'
    , TcTyCoVar -> Bool
defaultable_tyvar TcTyCoVar
tv
    , [Class] -> Bool
defaultable_classes (((Ct, Class, TcTyCoVar) -> Class)
-> [(Ct, Class, TcTyCoVar)] -> [Class]
forall a b. (a -> b) -> [a] -> [b]
map (Ct, Class, TcTyCoVar) -> Class
forall a b c. (a, b, c) -> b
sndOf3 [(Ct, Class, TcTyCoVar)]
group) ]
  where
    simples :: Cts
simples                = Bool -> WantedConstraints -> Cts
approximateWC Bool
True WantedConstraints
wanteds
    (unaries :: [(Ct, Class, TcTyCoVar)]
unaries, non_unaries :: [Ct]
non_unaries) = (Ct -> Either (Ct, Class, TcTyCoVar) Ct)
-> [Ct] -> ([(Ct, Class, TcTyCoVar)], [Ct])
forall a b c. (a -> Either b c) -> [a] -> ([b], [c])
partitionWith Ct -> Either (Ct, Class, TcTyCoVar) Ct
find_unary (Cts -> [Ct]
forall a. Bag a -> [a]
bagToList Cts
simples)
    unary_groups :: [NonEmpty (Ct, Class, TcTyCoVar)]
unary_groups           = ((Ct, Class, TcTyCoVar) -> (Ct, Class, TcTyCoVar) -> Ordering)
-> [(Ct, Class, TcTyCoVar)] -> [NonEmpty (Ct, Class, TcTyCoVar)]
forall a. (a -> a -> Ordering) -> [a] -> [NonEmpty a]
equivClasses (Ct, Class, TcTyCoVar) -> (Ct, Class, TcTyCoVar) -> Ordering
forall a a b a b. Ord a => (a, b, a) -> (a, b, a) -> Ordering
cmp_tv [(Ct, Class, TcTyCoVar)]
unaries

    unary_groups :: [NonEmpty (Ct, Class, TcTyVar)] -- (C tv) constraints
    unaries      :: [(Ct, Class, TcTyVar)]          -- (C tv) constraints
    non_unaries  :: [Ct]                            -- and *other* constraints

        -- Finds unary type-class constraints
        -- But take account of polykinded classes like Typeable,
        -- which may look like (Typeable * (a:*))   (Trac #8931)
    find_unary :: Ct -> Either (Ct, Class, TyVar) Ct
    find_unary :: Ct -> Either (Ct, Class, TcTyCoVar) Ct
find_unary cc :: Ct
cc
        | Just (cls :: Class
cls,tys :: [Type]
tys)   <- Type -> Maybe (Class, [Type])
getClassPredTys_maybe (Ct -> Type
ctPred Ct
cc)
        , [ty :: Type
ty] <- TyCon -> [Type] -> [Type]
filterOutInvisibleTypes (Class -> TyCon
classTyCon Class
cls) [Type]
tys
              -- Ignore invisible arguments for this purpose
        , Just tv :: TcTyCoVar
tv <- Type -> Maybe TcTyCoVar
tcGetTyVar_maybe Type
ty
        , TcTyCoVar -> Bool
isMetaTyVar TcTyCoVar
tv  -- We might have runtime-skolems in GHCi, and
                          -- we definitely don't want to try to assign to those!
        = (Ct, Class, TcTyCoVar) -> Either (Ct, Class, TcTyCoVar) Ct
forall a b. a -> Either a b
Left (Ct
cc, Class
cls, TcTyCoVar
tv)
    find_unary cc :: Ct
cc = Ct -> Either (Ct, Class, TcTyCoVar) Ct
forall a b. b -> Either a b
Right Ct
cc  -- Non unary or non dictionary

    bad_tvs :: TcTyCoVarSet  -- TyVars mentioned by non-unaries
    bad_tvs :: TcTyVarSet
bad_tvs = (Ct -> TcTyVarSet) -> [Ct] -> TcTyVarSet
forall a. (a -> TcTyVarSet) -> [a] -> TcTyVarSet
mapUnionVarSet Ct -> TcTyVarSet
tyCoVarsOfCt [Ct]
non_unaries

    cmp_tv :: (a, b, a) -> (a, b, a) -> Ordering
cmp_tv (_,_,tv1 :: a
tv1) (_,_,tv2 :: a
tv2) = a
tv1 a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` a
tv2

    defaultable_tyvar :: TcTyVar -> Bool
    defaultable_tyvar :: TcTyCoVar -> Bool
defaultable_tyvar tv :: TcTyCoVar
tv
        = let b1 :: Bool
b1 = TcTyCoVar -> Bool
isTyConableTyVar TcTyCoVar
tv  -- Note [Avoiding spurious errors]
              b2 :: Bool
b2 = Bool -> Bool
not (TcTyCoVar
tv TcTyCoVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
bad_tvs)
          in Bool
b1 Bool -> Bool -> Bool
&& (Bool
b2 Bool -> Bool -> Bool
|| Bool
extended_defaults) -- Note [Multi-parameter defaults]

    defaultable_classes :: [Class] -> Bool
    defaultable_classes :: [Class] -> Bool
defaultable_classes clss :: [Class]
clss
        | Bool
extended_defaults = (Class -> Bool) -> [Class] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Bool -> Class -> Bool
isInteractiveClass Bool
ovl_strings) [Class]
clss
        | Bool
otherwise         = (Class -> Bool) -> [Class] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Class -> Bool
is_std_class [Class]
clss Bool -> Bool -> Bool
&& ((Class -> Bool) -> [Class] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Bool -> Class -> Bool
isNumClass Bool
ovl_strings) [Class]
clss)

    -- is_std_class adds IsString to the standard numeric classes,
    -- when -foverloaded-strings is enabled
    is_std_class :: Class -> Bool
is_std_class cls :: Class
cls = Class -> Bool
isStandardClass Class
cls Bool -> Bool -> Bool
||
                       (Bool
ovl_strings Bool -> Bool -> Bool
&& (Class
cls Class -> Unique -> Bool
forall a. Uniquable a => a -> Unique -> Bool
`hasKey` Unique
isStringClassKey))

------------------------------
disambigGroup :: [Type]            -- The default types
              -> (TcTyVar, [Ct])   -- All classes of the form (C a)
                                   --  sharing same type variable
              -> TcS Bool   -- True <=> something happened, reflected in ty_binds

disambigGroup :: [Type] -> (TcTyCoVar, [Ct]) -> TcS Bool
disambigGroup [] _
  = Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
disambigGroup (default_ty :: Type
default_ty:default_tys :: [Type]
default_tys) group :: (TcTyCoVar, [Ct])
group@(the_tv :: TcTyCoVar
the_tv, wanteds :: [Ct]
wanteds)
  = do { String -> SDoc -> TcS ()
traceTcS "disambigGroup {" ([SDoc] -> SDoc
vcat [ Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
default_ty, TcTyCoVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyCoVar
the_tv, [Ct] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Ct]
wanteds ])
       ; EvBindsVar
fake_ev_binds_var <- TcS EvBindsVar
TcS.newTcEvBinds
       ; TcLevel
tclvl             <- TcS TcLevel
TcS.getTcLevel
       ; Bool
success <- EvBindsVar -> TcLevel -> TcS Bool -> TcS Bool
forall a. EvBindsVar -> TcLevel -> TcS a -> TcS a
nestImplicTcS EvBindsVar
fake_ev_binds_var (TcLevel -> TcLevel
pushTcLevel TcLevel
tclvl) TcS Bool
try_group

       ; if Bool
success then
             -- Success: record the type variable binding, and return
             do { TcTyCoVar -> Type -> TcS ()
unifyTyVar TcTyCoVar
the_tv Type
default_ty
                ; TcM () -> TcS ()
forall a. TcM a -> TcS a
wrapWarnTcS (TcM () -> TcS ()) -> TcM () -> TcS ()
forall a b. (a -> b) -> a -> b
$ [Ct] -> Type -> TcM ()
warnDefaulting [Ct]
wanteds Type
default_ty
                ; String -> SDoc -> TcS ()
traceTcS "disambigGroup succeeded }" (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
default_ty)
                ; Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True }
         else
             -- Failure: try with the next type
             do { String -> SDoc -> TcS ()
traceTcS "disambigGroup failed, will try other default types }"
                           (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
default_ty)
                ; [Type] -> (TcTyCoVar, [Ct]) -> TcS Bool
disambigGroup [Type]
default_tys (TcTyCoVar, [Ct])
group } }
  where
    try_group :: TcS Bool
try_group
      | Just subst :: TCvSubst
subst <- Maybe TCvSubst
mb_subst
      = do { TcLclEnv
lcl_env <- TcS TcLclEnv
TcS.getLclEnv
           ; TcLevel
tc_lvl <- TcS TcLevel
TcS.getTcLevel
           ; let loc :: CtLoc
loc = TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
tc_lvl SkolemInfo
UnkSkol TcLclEnv
lcl_env
           ; [CtEvidence]
wanted_evs <- (Ct -> TcS CtEvidence) -> [Ct] -> TcS [CtEvidence]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (CtLoc -> Type -> TcS CtEvidence
newWantedEvVarNC CtLoc
loc (Type -> TcS CtEvidence) -> (Ct -> Type) -> Ct -> TcS CtEvidence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => TCvSubst -> Type -> Type
TCvSubst -> Type -> Type
substTy TCvSubst
subst (Type -> Type) -> (Ct -> Type) -> Ct -> Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> Type
ctPred)
                                [Ct]
wanteds
           ; (WantedConstraints -> Bool) -> TcS WantedConstraints -> TcS Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WantedConstraints -> Bool
isEmptyWC (TcS WantedConstraints -> TcS Bool)
-> TcS WantedConstraints -> TcS Bool
forall a b. (a -> b) -> a -> b
$
             Cts -> TcS WantedConstraints
solveSimpleWanteds (Cts -> TcS WantedConstraints) -> Cts -> TcS WantedConstraints
forall a b. (a -> b) -> a -> b
$ [Ct] -> Cts
forall a. [a] -> Bag a
listToBag ([Ct] -> Cts) -> [Ct] -> Cts
forall a b. (a -> b) -> a -> b
$
             (CtEvidence -> Ct) -> [CtEvidence] -> [Ct]
forall a b. (a -> b) -> [a] -> [b]
map CtEvidence -> Ct
mkNonCanonical [CtEvidence]
wanted_evs }

      | Bool
otherwise
      = Bool -> TcS Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False

    the_ty :: Type
the_ty   = TcTyCoVar -> Type
mkTyVarTy TcTyCoVar
the_tv
    mb_subst :: Maybe TCvSubst
mb_subst = Type -> Type -> Maybe TCvSubst
tcMatchTyKi Type
the_ty Type
default_ty
      -- Make sure the kinds match too; hence this call to tcMatchTyKi
      -- E.g. suppose the only constraint was (Typeable k (a::k))
      -- With the addition of polykinded defaulting we also want to reject
      -- ill-kinded defaulting attempts like (Eq []) or (Foldable Int) here.

-- In interactive mode, or with -XExtendedDefaultRules,
-- we default Show a to Show () to avoid graututious errors on "show []"
isInteractiveClass :: Bool   -- -XOverloadedStrings?
                   -> Class -> Bool
isInteractiveClass :: Bool -> Class -> Bool
isInteractiveClass ovl_strings :: Bool
ovl_strings cls :: Class
cls
    = Bool -> Class -> Bool
isNumClass Bool
ovl_strings Class
cls Bool -> Bool -> Bool
|| (Class -> Unique
classKey Class
cls Unique -> [Unique] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Unique]
interactiveClassKeys)

    -- isNumClass adds IsString to the standard numeric classes,
    -- when -foverloaded-strings is enabled
isNumClass :: Bool   -- -XOverloadedStrings?
           -> Class -> Bool
isNumClass :: Bool -> Class -> Bool
isNumClass ovl_strings :: Bool
ovl_strings cls :: Class
cls
  = Class -> Bool
isNumericClass Class
cls Bool -> Bool -> Bool
|| (Bool
ovl_strings Bool -> Bool -> Bool
&& (Class
cls Class -> Unique -> Bool
forall a. Uniquable a => a -> Unique -> Bool
`hasKey` Unique
isStringClassKey))


{-
Note [Avoiding spurious errors]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When doing the unification for defaulting, we check for skolem
type variables, and simply don't default them.  For example:
   f = (*)      -- Monomorphic
   g :: Num a => a -> a
   g x = f x x
Here, we get a complaint when checking the type signature for g,
that g isn't polymorphic enough; but then we get another one when
dealing with the (Num a) context arising from f's definition;
we try to unify a with Int (to default it), but find that it's
already been unified with the rigid variable from g's type sig.

Note [Multi-parameter defaults]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
With -XExtendedDefaultRules, we default only based on single-variable
constraints, but do not exclude from defaulting any type variables which also
appear in multi-variable constraints. This means that the following will
default properly:

   default (Integer, Double)

   class A b (c :: Symbol) where
      a :: b -> Proxy c

   instance A Integer c where a _ = Proxy

   main = print (a 5 :: Proxy "5")

Note that if we change the above instance ("instance A Integer") to
"instance A Double", we get an error:

   No instance for (A Integer "5")

This is because the first defaulted type (Integer) has successfully satisfied
its single-parameter constraints (in this case Num).
-}