{-# LANGUAGE RecursiveDo #-}

module GHC.Tc.Solver(
       InferMode(..), simplifyInfer, findInferredDiff,
       growThetaTyVars,
       simplifyAmbiguityCheck,
       simplifyDefault,
       simplifyTop, simplifyTopImplic,
       simplifyInteractive,
       solveEqualities,
       pushLevelAndSolveEqualities, pushLevelAndSolveEqualitiesX,
       reportUnsolvedEqualities,
       simplifyWantedsTcM,
       tcCheckGivens,
       tcCheckWanteds,
       tcNormalise,

       captureTopConstraints,

       simplifyTopWanteds,

       promoteTyVarSet, simplifyAndEmitFlatConstraints,

       -- For Rules we need these
       solveWanteds,
       approximateWC

  ) where

import GHC.Prelude

import GHC.Data.Bag
import GHC.Core.Class
import GHC.Driver.Session
import GHC.Tc.Utils.Instantiate
import GHC.Data.List.SetOps
import GHC.Types.Name
import GHC.Types.Id( idType )
import GHC.Utils.Outputable
import GHC.Builtin.Utils
import GHC.Builtin.Names
import GHC.Tc.Errors
import GHC.Tc.Errors.Types
import GHC.Tc.Types.Evidence
import GHC.Tc.Solver.Interact
import GHC.Tc.Solver.Canonical   ( makeSuperClasses, solveCallStack )
import GHC.Tc.Solver.Rewrite     ( rewriteType )
import GHC.Tc.Utils.Unify        ( buildTvImplication )
import GHC.Tc.Utils.TcMType as TcM
import GHC.Tc.Utils.Monad   as TcM
import GHC.Tc.Solver.InertSet
import GHC.Tc.Solver.Monad  as TcS
import GHC.Tc.Types.Constraint
import GHC.Tc.Instance.FunDeps
import GHC.Core.Predicate
import GHC.Tc.Types.Origin
import GHC.Tc.Utils.TcType
import GHC.Core.Type
import GHC.Core.Ppr
import GHC.Core.TyCon    ( TyConBinder, isTypeFamilyTyCon )
import GHC.Builtin.Types ( liftedRepTy, manyDataConTy, liftedDataConTy )
import GHC.Core.Unify    ( tcMatchTyKi )
import GHC.Utils.Misc
import GHC.Utils.Panic
import GHC.Types.Var
import GHC.Types.Var.Set
import GHC.Types.Basic    ( IntWithInf, intGtLimit
                          , DefaultingStrategy(..), NonStandardDefaultingStrategy(..) )
import GHC.Types.Error
import qualified GHC.LanguageExtensions as LangExt

import Control.Monad
import Data.Foldable      ( toList )
import Data.List          ( partition )
import Data.List.NonEmpty ( NonEmpty(..) )
import GHC.Data.Maybe     ( mapMaybe )

{-
*********************************************************************************
*                                                                               *
*                           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
--
-- captureTopConstraints is used exclusively by GHC.Tc.Module at the top
-- level of a module.
--
-- Importantly, if captureTopConstraints propagates an exception, it
-- reports any insoluble constraints first, lest they be lost
-- altogether.  This is important, because solveEqualities (maybe
-- other things too) throws an exception without adding any error
-- messages; it just puts the unsolved constraints back into the
-- monad. See GHC.Tc.Utils.Monad Note [Constraints and errors]
-- #16376 is an example of what goes wrong if you don't do this.
--
-- NB: the caller should bring any environments into scope before
-- calling this, so that the reportUnsolved has access to the most
-- complete GlobalRdrEnv
captureTopConstraints :: forall a. TcM a -> TcM (a, WantedConstraints)
captureTopConstraints 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 ;
       ; (Maybe a
mb_res, WantedConstraints
lie) <- (TcGblEnv -> TcGblEnv)
-> TcRnIf TcGblEnv TcLclEnv (Maybe a, WantedConstraints)
-> TcRnIf TcGblEnv TcLclEnv (Maybe a, WantedConstraints)
forall gbl lcl a.
(gbl -> gbl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
TcM.updGblEnv (\TcGblEnv
env -> TcGblEnv
env { tcg_static_wc :: TcRef WantedConstraints
tcg_static_wc = TcRef WantedConstraints
static_wc_var } ) (TcRnIf TcGblEnv TcLclEnv (Maybe a, WantedConstraints)
 -> TcRnIf TcGblEnv TcLclEnv (Maybe a, WantedConstraints))
-> TcRnIf TcGblEnv TcLclEnv (Maybe a, WantedConstraints)
-> TcRnIf TcGblEnv TcLclEnv (Maybe a, WantedConstraints)
forall a b. (a -> b) -> a -> b
$
                          TcM a -> TcRnIf TcGblEnv TcLclEnv (Maybe a, WantedConstraints)
forall a. TcM a -> TcM (Maybe 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 GHC.Tc.Utils.Monad 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 Maybe a
mb_res of
           Just a
res -> (a, WantedConstraints) -> TcM (a, WantedConstraints)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
res, WantedConstraints
lie WantedConstraints -> WantedConstraints -> WantedConstraints
`andWC` WantedConstraints
stWC)
           Maybe a
Nothing  -> do { Bag EvBind
_ <- WantedConstraints -> TcM (Bag EvBind)
simplifyTop WantedConstraints
lie; TcM (a, WantedConstraints)
forall env a. IOEnv env a
failM } }
                -- This call to simplifyTop is the reason
                -- this function is here instead of GHC.Tc.Utils.Monad
                -- We call simplifyTop so that it does defaulting
                -- (esp of runtime-reps) before reporting errors

simplifyTopImplic :: Bag Implication -> TcM ()
simplifyTopImplic :: Bag Implication -> TcM ()
simplifyTopImplic 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
       ; Bool -> SDoc -> TcM ()
forall (m :: * -> *).
(HasCallStack, Applicative m) =>
Bool -> SDoc -> m ()
massertPpr (Bag EvBind -> Bool
forall a. Bag a -> Bool
isEmptyBag Bag EvBind
empty_binds) (Bag EvBind -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bag EvBind
empty_binds)

       ; () -> TcM ()
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
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 WantedConstraints
wanteds
  = do { String -> SDoc -> TcM ()
traceTc String
"simplifyTop {" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$ String -> SDoc
text String
"wanted = " SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanteds
       ; ((WantedConstraints
final_wc, Cts
unsafe_ol), 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
simplifyTopWanteds WantedConstraints
wanteds
               ; Cts
unsafe_ol <- TcS Cts
getSafeOverlapFailures
               ; (WantedConstraints, Cts) -> TcS (WantedConstraints, Cts)
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints
final_wc, Cts
unsafe_ol) }
       ; String -> SDoc -> TcM ()
traceTc String
"End simplifyTop }" SDoc
empty

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

       ; String -> SDoc -> TcM ()
traceTc String
"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 TcRnMessage)
errs_var  <- TcRn (TcRef (Messages TcRnMessage))
getErrsVar
           ; Messages TcRnMessage
saved_msg <- TcRef (Messages TcRnMessage)
-> TcRnIf TcGblEnv TcLclEnv (Messages TcRnMessage)
forall a gbl lcl. TcRef a -> TcRnIf gbl lcl a
TcM.readTcRef TcRef (Messages TcRnMessage)
errs_var
           ; TcRef (Messages TcRnMessage) -> Messages TcRnMessage -> TcM ()
forall a gbl lcl. TcRef a -> a -> TcRnIf gbl lcl ()
TcM.writeTcRef TcRef (Messages TcRnMessage)
errs_var Messages TcRnMessage
forall e. Messages e
emptyMessages

           ; WantedConstraints -> TcM ()
warnAllUnsolved (WantedConstraints -> TcM ()) -> WantedConstraints -> TcM ()
forall a b. (a -> b) -> a -> b
$ WantedConstraints
emptyWC { wc_simple :: Cts
wc_simple = Cts
unsafe_ol }

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

       ; Bag EvBind -> TcM (Bag EvBind)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
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) }

pushLevelAndSolveEqualities :: SkolemInfoAnon -> [TyConBinder] -> TcM a -> TcM a
-- Push level, and solve all resulting equalities
-- If there are any unsolved equalities, report them
-- and fail (in the monad)
--
-- Panics if we solve any non-equality constraints.  (In runTCSEqualities
-- we use an error thunk for the evidence bindings.)
pushLevelAndSolveEqualities :: forall a. SkolemInfoAnon -> [TyConBinder] -> TcM a -> TcM a
pushLevelAndSolveEqualities SkolemInfoAnon
skol_info_anon [TyConBinder]
tcbs TcM a
thing_inside
  = do { (TcLevel
tclvl, WantedConstraints
wanted, a
res) <- String -> TcM a -> TcM (TcLevel, WantedConstraints, a)
forall a. String -> TcM a -> TcM (TcLevel, WantedConstraints, a)
pushLevelAndSolveEqualitiesX
                                      String
"pushLevelAndSolveEqualities" TcM a
thing_inside
       ; SkolemInfoAnon
-> [TcTyVar] -> TcLevel -> WantedConstraints -> TcM ()
report_unsolved_equalities SkolemInfoAnon
skol_info_anon ([TyConBinder] -> [TcTyVar]
forall tv argf. [VarBndr tv argf] -> [tv]
binderVars [TyConBinder]
tcbs) TcLevel
tclvl WantedConstraints
wanted
       ; a -> TcM a
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return a
res }

pushLevelAndSolveEqualitiesX :: String -> TcM a
                             -> TcM (TcLevel, WantedConstraints, a)
-- Push the level, gather equality constraints, and then solve them.
-- Returns any remaining unsolved equalities.
-- Does not report errors.
--
-- Panics if we solve any non-equality constraints.  (In runTCSEqualities
-- we use an error thunk for the evidence bindings.)
pushLevelAndSolveEqualitiesX :: forall a. String -> TcM a -> TcM (TcLevel, WantedConstraints, a)
pushLevelAndSolveEqualitiesX String
callsite TcM a
thing_inside
  = do { String -> SDoc -> TcM ()
traceTc String
"pushLevelAndSolveEqualitiesX {" (String -> SDoc
text String
"Called from" SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
callsite)
       ; (TcLevel
tclvl, (WantedConstraints
wanted, a
res))
            <- TcM (WantedConstraints, a) -> TcM (TcLevel, (WantedConstraints, a))
forall a. TcM a -> TcM (TcLevel, a)
pushTcLevelM (TcM (WantedConstraints, a)
 -> TcM (TcLevel, (WantedConstraints, a)))
-> TcM (WantedConstraints, a)
-> TcM (TcLevel, (WantedConstraints, a))
forall a b. (a -> b) -> a -> b
$
               do { (a
res, WantedConstraints
wanted) <- TcM a -> TcM (a, WantedConstraints)
forall a. TcM a -> TcM (a, WantedConstraints)
captureConstraints TcM a
thing_inside
                  ; WantedConstraints
wanted <- TcS WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. TcS a -> TcM a
runTcSEqualities (WantedConstraints -> TcS WantedConstraints
simplifyTopWanteds WantedConstraints
wanted)
                  ; (WantedConstraints, a) -> TcM (WantedConstraints, a)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints
wanted,a
res) }
       ; String -> SDoc -> TcM ()
traceTc String
"pushLevelAndSolveEqualities }" ([SDoc] -> SDoc
vcat [ String -> SDoc
text String
"Residual:" SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanted
                                                       , String -> SDoc
text String
"Level:" SDoc -> SDoc -> SDoc
<+> TcLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcLevel
tclvl ])
       ; (TcLevel, WantedConstraints, a)
-> TcM (TcLevel, WantedConstraints, a)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (TcLevel
tclvl, WantedConstraints
wanted, a
res) }

-- | Type-check a thing that emits only equality constraints, solving any
-- constraints we can and re-emitting constraints that we can't.
-- Use this variant only when we'll get another crack at it later
-- See Note [Failure in local type signatures]
--
-- Panics if we solve any non-equality constraints.  (In runTCSEqualities
-- we use an error thunk for the evidence bindings.)
solveEqualities :: String -> TcM a -> TcM a
solveEqualities :: forall a. String -> TcM a -> TcM a
solveEqualities String
callsite TcM a
thing_inside
  = do { String -> SDoc -> TcM ()
traceTc String
"solveEqualities {" (String -> SDoc
text String
"Called from" SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
callsite)
       ; (a
res, WantedConstraints
wanted)   <- TcM a -> TcM (a, WantedConstraints)
forall a. TcM a -> TcM (a, WantedConstraints)
captureConstraints TcM a
thing_inside
       ; WantedConstraints -> TcM ()
simplifyAndEmitFlatConstraints WantedConstraints
wanted
            -- simplifyAndEmitFlatConstraints fails outright unless
            --  the only unsolved constraints are soluble-looking
            --  equalities that can float out
       ; String -> SDoc -> TcM ()
traceTc String
"solveEqualities }" SDoc
empty
       ; a -> TcM a
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return a
res }

simplifyAndEmitFlatConstraints :: WantedConstraints -> TcM ()
-- See Note [Failure in local type signatures]
simplifyAndEmitFlatConstraints :: WantedConstraints -> TcM ()
simplifyAndEmitFlatConstraints WantedConstraints
wanted
  = do { -- Solve and zonk to establish the
         -- preconditions for floatKindEqualities
         WantedConstraints
wanted <- TcS WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. TcS a -> TcM a
runTcSEqualities (WantedConstraints -> TcS WantedConstraints
solveWanteds WantedConstraints
wanted)
       ; WantedConstraints
wanted <- WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
TcM.zonkWC WantedConstraints
wanted

       ; String -> SDoc -> TcM ()
traceTc String
"emitFlatConstraints {" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanted)
       ; case WantedConstraints -> Maybe (Cts, Bag DelayedError)
floatKindEqualities WantedConstraints
wanted of
           Maybe (Cts, Bag DelayedError)
Nothing -> do { String -> SDoc -> TcM ()
traceTc String
"emitFlatConstraints } failing" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanted)
                         -- Emit the bad constraints, wrapped in an implication
                         -- See Note [Wrapping failing kind equalities]
                         ; TcLevel
tclvl  <- TcM TcLevel
TcM.getTcLevel
                         ; Implication
implic <- SkolemInfoAnon
-> [TcTyVar] -> TcLevel -> WantedConstraints -> TcM Implication
buildTvImplication SkolemInfoAnon
HasCallStack => SkolemInfoAnon
unkSkolAnon [] (TcLevel -> TcLevel
pushTcLevel TcLevel
tclvl) WantedConstraints
wanted
                                        --                  ^^^^^^   |  ^^^^^^^^^^^^^^^^^
                                        -- it's OK to use unkSkol    |  we must increase the TcLevel,
                                        -- because we don't bind     |  as explained in
                                        -- any skolem variables here |  Note [Wrapping failing kind equalities]
                         ; Implication -> TcM ()
emitImplication Implication
implic
                         ; TcM ()
forall env a. IOEnv env a
failM }
           Just (Cts
simples, Bag DelayedError
errs)
              -> do { Bool
_ <- VarSet -> TcM Bool
promoteTyVarSet (Cts -> VarSet
tyCoVarsOfCts Cts
simples)
                    ; String -> SDoc -> TcM ()
traceTc String
"emitFlatConstraints }" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$
                      [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"simples:" SDoc -> SDoc -> SDoc
<+> Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
simples
                           , String -> SDoc
text String
"errs:   " SDoc -> SDoc -> SDoc
<+> Bag DelayedError -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bag DelayedError
errs ]
                      -- Holes and other delayed errors don't need promotion
                    ; Bag DelayedError -> TcM ()
emitDelayedErrors Bag DelayedError
errs
                    ; Cts -> TcM ()
emitSimples Cts
simples } }

floatKindEqualities :: WantedConstraints -> Maybe (Bag Ct, Bag DelayedError)
-- Float out all the constraints from the WantedConstraints,
-- Return Nothing if any constraints can't be floated (captured
-- by skolems), or if there is an insoluble constraint, or
-- IC_Telescope telescope error
-- Precondition 1: we have tried to solve the 'wanteds', both so that
--    the ic_status field is set, and because solving can make constraints
--    more floatable.
-- Precondition 2: the 'wanteds' are zonked, since floatKindEqualities
--    is not monadic
-- See Note [floatKindEqualities vs approximateWC]
floatKindEqualities :: WantedConstraints -> Maybe (Cts, Bag DelayedError)
floatKindEqualities WantedConstraints
wc = VarSet -> WantedConstraints -> Maybe (Cts, Bag DelayedError)
float_wc VarSet
emptyVarSet WantedConstraints
wc
  where
    float_wc :: TcTyCoVarSet -> WantedConstraints -> Maybe (Bag Ct, Bag DelayedError)
    float_wc :: VarSet -> WantedConstraints -> Maybe (Cts, Bag DelayedError)
float_wc VarSet
trapping_tvs (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples
                              , wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics
                              , wc_errors :: WantedConstraints -> Bag DelayedError
wc_errors = Bag DelayedError
errs })
      | (Ct -> Bool) -> Cts -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Ct -> Bool
is_floatable Cts
simples
      = do { (Cts
inner_simples, Bag DelayedError
inner_errs)
                <- (Implication -> Maybe (Cts, Bag DelayedError))
-> Bag Implication -> Maybe (Cts, Bag DelayedError)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m (Bag b, Bag c)) -> Bag a -> m (Bag b, Bag c)
flatMapBagPairM (VarSet -> Implication -> Maybe (Cts, Bag DelayedError)
float_implic VarSet
trapping_tvs) Bag Implication
implics
           ; (Cts, Bag DelayedError) -> Maybe (Cts, Bag DelayedError)
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return ( Cts
simples Cts -> Cts -> Cts
forall a. Bag a -> Bag a -> Bag a
`unionBags` Cts
inner_simples
                    , Bag DelayedError
errs Bag DelayedError -> Bag DelayedError -> Bag DelayedError
forall a. Bag a -> Bag a -> Bag a
`unionBags` Bag DelayedError
inner_errs) }
      | Bool
otherwise
      = Maybe (Cts, Bag DelayedError)
forall a. Maybe a
Nothing
      where
        is_floatable :: Ct -> Bool
is_floatable Ct
ct
           | Ct -> Bool
insolubleEqCt Ct
ct = Bool
False
           | Bool
otherwise        = Ct -> VarSet
tyCoVarsOfCt Ct
ct VarSet -> VarSet -> Bool
`disjointVarSet` VarSet
trapping_tvs

    float_implic :: TcTyCoVarSet -> Implication -> Maybe (Bag Ct, Bag DelayedError)
    float_implic :: VarSet -> Implication -> Maybe (Cts, Bag DelayedError)
float_implic VarSet
trapping_tvs (Implic { ic_wanted :: Implication -> WantedConstraints
ic_wanted = WantedConstraints
wanted, ic_given_eqs :: Implication -> HasGivenEqs
ic_given_eqs = HasGivenEqs
given_eqs
                                      , ic_skols :: Implication -> [TcTyVar]
ic_skols = [TcTyVar]
skols, ic_status :: Implication -> ImplicStatus
ic_status = ImplicStatus
status })
      | ImplicStatus -> Bool
isInsolubleStatus ImplicStatus
status
      = Maybe (Cts, Bag DelayedError)
forall a. Maybe a
Nothing   -- A short cut /plus/ we must keep track of IC_BadTelescope
      | Bool
otherwise
      = do { (Cts
simples, Bag DelayedError
holes) <- VarSet -> WantedConstraints -> Maybe (Cts, Bag DelayedError)
float_wc VarSet
new_trapping_tvs WantedConstraints
wanted
           ; Bool -> Maybe () -> Maybe ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not (Cts -> Bool
forall a. Bag a -> Bool
isEmptyBag Cts
simples) Bool -> Bool -> Bool
&& HasGivenEqs
given_eqs HasGivenEqs -> HasGivenEqs -> Bool
forall a. Eq a => a -> a -> Bool
== HasGivenEqs
MaybeGivenEqs) (Maybe () -> Maybe ()) -> Maybe () -> Maybe ()
forall a b. (a -> b) -> a -> b
$
             Maybe ()
forall a. Maybe a
Nothing
                 -- If there are some constraints to float out, but we can't
                 -- because we don't float out past local equalities
                 -- (c.f GHC.Tc.Solver.approximateWC), then fail
           ; (Cts, Bag DelayedError) -> Maybe (Cts, Bag DelayedError)
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cts
simples, Bag DelayedError
holes) }
      where
        new_trapping_tvs :: VarSet
new_trapping_tvs = VarSet
trapping_tvs VarSet -> [TcTyVar] -> VarSet
`extendVarSetList` [TcTyVar]
skols


{- Note [Failure in local type signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When kind checking a type signature, we like to fail fast if we can't
solve all the kind equality constraints, 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.  In
    earlier GHCs this led to un-filled-in coercion holes, which caused
    GHC to crash with "fvProv falls into a hole" See #11563, #11520,
    #11516, #11399

But what about /local/ type signatures, mentioning in-scope type
variables for which there might be 'given' equalities?  For these we
might not be able to solve all the equalities locally. Here's an
example (T15076b):

  class (a ~ b) => C a b
  data SameKind :: k -> k -> Type where { SK :: SameKind a b }

  bar :: forall (a :: Type) (b :: Type).
         C a b => Proxy a -> Proxy b -> ()
  bar _ _ = const () (undefined :: forall (x :: a) (y :: b). SameKind x y)

Consider the type signature on 'undefined'. It's ill-kinded unless
a~b.  But the superclass of (C a b) means that indeed (a~b). So all
should be well. BUT it's hard to see that when kind-checking the signature
for undefined.  We want to emit a residual (a~b) constraint, to solve
later.

Another possibility is that we might have something like
   F alpha ~ [Int]
where alpha is bound further out, which might become soluble
"later" when we learn more about alpha.  So we want to emit
those residual constraints.

BUT it's no good simply wrapping all unsolved constraints from
a type signature in an implication constraint to solve later. The
problem is that we are going to /use/ that signature, including
instantiate it.  Say we have
     f :: forall a.  (forall b. blah) -> blah2
     f x = <body>
To typecheck the definition of f, we have to instantiate those
foralls.  Moreover, any unsolved kind equalities will be coercion
holes in the type.  If we naively wrap them in an implication like
     forall a. (co1:k1~k2,  forall b.  co2:k3~k4)
hoping to solve it later, we might end up filling in the holes
co1 and co2 with coercions involving 'a' and 'b' -- but by now
we've instantiated the type.  Chaos!

Moreover, the unsolved constraints might be skolem-escape things, and
if we proceed with f bound to a nonsensical type, we get a cascade of
follow-up errors. For example polykinds/T12593, T15577, and many others.

So here's the plan (see tcHsSigType):

* pushLevelAndSolveEqualitiesX: try to solve the constraints

* kindGeneraliseSome: do kind generalisation

* buildTvImplication: build an implication for the residual, unsolved
  constraint

* simplifyAndEmitFlatConstraints: try to float out every unsolved equality
  inside that implication, in the hope that it constrains only global
  type variables, not the locally-quantified ones.

  * If we fail, or find an insoluble constraint, emit the implication,
    so that the errors will be reported, and fail.

  * If we succeed in floating all the equalities, promote them and
    re-emit them as flat constraint, not wrapped at all (since they
    don't mention any of the quantified variables.

* Note that this float-and-promote step means that anonymous
  wildcards get floated to top level, as we want; see
  Note [Checking partial type signatures] in GHC.Tc.Gen.HsType.

All this is done:

* In GHC.Tc.Gen.HsType.tcHsSigType, as above

* solveEqualities. Use this when there no kind-generalisation
  step to complicate matters; then we don't need to push levels,
  and can solve the equalities immediately without needing to
  wrap it in an implication constraint.  (You'll generally see
  a kindGeneraliseNone nearby.)

* In GHC.Tc.TyCl and GHC.Tc.TyCl.Instance; see calls to
  pushLevelAndSolveEqualitiesX, followed by quantification, and
  then reportUnsolvedEqualities.

  NB: we call reportUnsolvedEqualities before zonkTcTypeToType
  because the latter does not expect to see any un-filled-in
  coercions, which will happen if we have unsolved equalities.
  By calling reportUnsolvedEqualities first, which fails after
  reporting errors, we avoid that happening.

See also #18062, #11506

Note [Wrapping failing kind equalities]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In simplifyAndEmitFlatConstraints, if we fail to get down to simple
flat constraints we will
* re-emit the constraints so that they are reported
* fail in the monad
But there is a Terrible Danger that, if -fdefer-type-errors is on, and
we just re-emit an insoluble constraint like (* ~ (*->*)), that we'll
report only a warning and proceed with compilation.  But if we ever fail
in the monad it should be fatal; we should report an error and stop after
the type checker.  If not, chaos results: #19142.

Our solution is this:
* Even with -fdefer-type-errors, inside an implication with no place for
  value bindings (ic_binds = CoEvBindsVar), report failing equalities as
  errors.  We have to do this anyway; see GHC.Tc.Errors
  Note [Failing equalities with no evidence bindings].

* Right here in simplifyAndEmitFlatConstraints, use buildTvImplication
  to wrap the failing constraint in a degenerate implication (no
  skolems, no theta), with ic_binds = CoEvBindsVar.  This setting of
  `ic_binds` means that any failing equalities will lead to an
  error not a warning, irrespective of -fdefer-type-errors: see
  Note [Failing equalities with no evidence bindings] in GHC.Tc.Errors,
  and `maybeSwitchOffDefer` in that module.

  We still take care to bump the TcLevel of the implication.  Partly,
  that ensures that nested implications have increasing level numbers
  which seems nice.  But more specifically, suppose the outer level
  has a Given `(C ty)`, which has pending (not-yet-expanded)
  superclasses. Consider what happens when we process this implication
  constraint (which we have re-emitted) in that context:
    - in the inner implication we'll call `getPendingGivenScs`,
    - we /do not/ want to get the `(C ty)` from the outer level,
    lest we try to add an evidence term for the superclass,
    which we can't do because we have specifically set
    `ic_binds` = `CoEvBindsVar`.
    - as `getPendingGivenSCcs is careful to only get Givens from
    the /current/ level, and we bumped the `TcLevel` of the implication,
    we're OK.

  TL;DR: bump the `TcLevel` when creating the nested implication.
  If we don't we get a panic in `GHC.Tc.Utils.Monad.addTcEvBind` (#20043).


We re-emit the implication rather than reporting the errors right now,
so that the error mesages are improved by other solving and defaulting.
e.g. we prefer
    Cannot match 'Type->Type' with 'Type'
to  Cannot match 'Type->Type' with 'TYPE r0'


Note [floatKindEqualities vs approximateWC]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
floatKindEqualities and approximateWC are strikingly similar to each
other, but

* floatKindEqualites tries to float /all/ equalities, and fails if
  it can't, or if any implication is insoluble.
* approximateWC just floats out any constraints
  (not just equalities) that can float; it never fails.
-}


reportUnsolvedEqualities :: SkolemInfo -> [TcTyVar] -> TcLevel
                         -> WantedConstraints -> TcM ()
-- Reports all unsolved wanteds provided; fails in the monad if there are any.
--
-- The provided SkolemInfo and [TcTyVar] arguments are used in an implication to
-- provide skolem info for any errors.
reportUnsolvedEqualities :: SkolemInfo -> [TcTyVar] -> TcLevel -> WantedConstraints -> TcM ()
reportUnsolvedEqualities SkolemInfo
skol_info [TcTyVar]
skol_tvs TcLevel
tclvl WantedConstraints
wanted
  = SkolemInfoAnon
-> [TcTyVar] -> TcLevel -> WantedConstraints -> TcM ()
report_unsolved_equalities (SkolemInfo -> SkolemInfoAnon
getSkolemInfo SkolemInfo
skol_info) [TcTyVar]
skol_tvs TcLevel
tclvl WantedConstraints
wanted

report_unsolved_equalities :: SkolemInfoAnon -> [TcTyVar] -> TcLevel
                           -> WantedConstraints -> TcM ()
report_unsolved_equalities :: SkolemInfoAnon
-> [TcTyVar] -> TcLevel -> WantedConstraints -> TcM ()
report_unsolved_equalities SkolemInfoAnon
skol_info_anon [TcTyVar]
skol_tvs TcLevel
tclvl WantedConstraints
wanted
  | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wanted
  = () -> TcM ()
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

  | Bool
otherwise  -- NB: we build an implication /even if skol_tvs is empty/,
               -- just to ensure that our level invariants hold, specifically
               -- (WantedInv).  See Note [TcLevel invariants].
  = TcM () -> TcM ()
forall r. TcM r -> TcM r
checkNoErrs (TcM () -> TcM ()) -> TcM () -> TcM ()
forall a b. (a -> b) -> a -> b
$   -- Fail
    do { Implication
implic <- SkolemInfoAnon
-> [TcTyVar] -> TcLevel -> WantedConstraints -> TcM Implication
buildTvImplication SkolemInfoAnon
skol_info_anon [TcTyVar]
skol_tvs TcLevel
tclvl WantedConstraints
wanted
       ; WantedConstraints -> TcM ()
reportAllUnsolved (Bag Implication -> WantedConstraints
mkImplicWC (Implication -> Bag Implication
forall a. a -> Bag a
unitBag Implication
implic)) }


-- | Simplify top-level constraints, but without reporting any unsolved
-- constraints nor unsafe overlapping.
simplifyTopWanteds :: WantedConstraints -> TcS WantedConstraints
    -- See Note [Top-level Defaulting Plan]
simplifyTopWanteds :: WantedConstraints -> TcS WantedConstraints
simplifyTopWanteds WantedConstraints
wanteds
  = do { WantedConstraints
wc_first_go <- TcS WantedConstraints -> TcS WantedConstraints
forall a. TcS a -> TcS a
nestTcS (WantedConstraints -> TcS WantedConstraints
solveWanteds WantedConstraints
wanteds)
                            -- This is where the main work happens
       ; DynFlags
dflags <- TcS DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
       ; DynFlags -> WantedConstraints -> TcS WantedConstraints
try_tyvar_defaulting DynFlags
dflags WantedConstraints
wc_first_go }
  where
    try_tyvar_defaulting :: DynFlags -> WantedConstraints -> TcS WantedConstraints
    try_tyvar_defaulting :: DynFlags -> WantedConstraints -> TcS WantedConstraints
try_tyvar_defaulting DynFlags
dflags WantedConstraints
wc
      | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wc
      = WantedConstraints -> TcS WantedConstraints
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wc
      | WantedConstraints -> Bool
insolubleWC WantedConstraints
wc
      , GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintExplicitRuntimeReps DynFlags
dflags -- See Note [Defaulting insolubles]
      = WantedConstraints -> TcS WantedConstraints
try_class_defaulting WantedConstraints
wc
      | Bool
otherwise
      = do { -- Need to zonk first, as the WantedConstraints are not yet zonked.
           ; [TcTyVar]
free_tvs <- [TcTyVar] -> TcS [TcTyVar]
TcS.zonkTyCoVarsAndFVList (WantedConstraints -> [TcTyVar]
tyCoVarsOfWCList WantedConstraints
wc)
           ; let defaultable_tvs :: [TcTyVar]
defaultable_tvs = (TcTyVar -> Bool) -> [TcTyVar] -> [TcTyVar]
forall a. (a -> Bool) -> [a] -> [a]
filter TcTyVar -> Bool
can_default [TcTyVar]
free_tvs
                 can_default :: TcTyVar -> Bool
can_default TcTyVar
tv
                   =   TcTyVar -> Bool
isTyVar TcTyVar
tv
                       -- Weed out coercion variables.

                    Bool -> Bool -> Bool
&& TcTyVar -> Bool
isMetaTyVar TcTyVar
tv
                       -- Weed out runtime-skolems in GHCi, which we definitely
                       -- shouldn't try to default.

                    Bool -> Bool -> Bool
&& Bool -> Bool
not (TcTyVar
tv TcTyVar -> VarSet -> Bool
`elemVarSet` WantedConstraints -> VarSet
nonDefaultableTyVarsOfWC WantedConstraints
wc)
                       -- Weed out variables for which defaulting would be unhelpful,
                       -- e.g. alpha appearing in [W] alpha[conc] ~# rr[sk].

           ; [Bool]
defaulted <- (TcTyVar -> TcS Bool) -> [TcTyVar] -> TcS [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM TcTyVar -> TcS Bool
defaultTyVarTcS [TcTyVar]
defaultable_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 WantedConstraints
wc
      | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wc Bool -> Bool -> Bool
|| WantedConstraints -> Bool
insolubleWC WantedConstraints
wc -- See Note [Defaulting insolubles]
      = WantedConstraints -> TcS WantedConstraints
try_callstack_defaulting 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
solveWanteds WantedConstraints
wc)
                     ; WantedConstraints -> TcS WantedConstraints
try_class_defaulting WantedConstraints
wc_residual }
                  -- See Note [Overview of implicit CallStacks] in GHC.Tc.Types.Evidence
             else WantedConstraints -> TcS WantedConstraints
try_callstack_defaulting WantedConstraints
wc }

    try_callstack_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_callstack_defaulting :: WantedConstraints -> TcS WantedConstraints
try_callstack_defaulting WantedConstraints
wc
      | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wc
      = WantedConstraints -> TcS WantedConstraints
forall a. a -> TcS a
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 GHC.Tc.Types.Evidence
defaultCallStacks :: WantedConstraints -> TcS WantedConstraints
defaultCallStacks 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 a. a -> TcS a
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 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 Implication
implic
    | ImplicStatus -> Bool
isSolvedStatus (Implication -> ImplicStatus
ic_status Implication
implic)
    = Maybe Implication -> TcS (Maybe Implication)
forall a. a -> TcS a
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
    | ClassPred Class
cls [Type]
tys <- Type -> Pred
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 a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Ct
forall a. Maybe a
Nothing }

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


{- 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: #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 (#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 [Don't default in syntactic equalities]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When there are unsolved syntactic equalities such as

  rr[sk] ~S# alpha[conc]

we should not default alpha, lest we obtain a poor error message such as

  Couldn't match kind `rr' with `LiftedRep'

We would rather preserve the original syntactic equality to be
reported to the user, especially as the concrete metavariable alpha
might store an informative origin for the user.

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!  #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 inference 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) `GHC.Tc.Solver.Interact.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) `GHC.Tc.Solver.Interact.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) `GHC.Tc.Solver.simplifyTop`:
       * Call simplifyTopWanteds, 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 `GHC.Tc.Errors.reportUnsolved`,
         while for resolved but unsafe overlapping dictionary constraints, call
         `GHC.Tc.Errors.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 `GHC.Tc.Utils.Monad.recordUnsafeInfer` to
         mark the module we are compiling as unsafe, passing the
         warning message along as the reason.

 5) `GHC.Tc.Errors.*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) `GHC.Tc.Utils.Monad.recordUnsafeInfer` -- Save the unsafe result and reason in
      IORefs called `tcg_safe_infer` and `tcg_safe_infer_reason`.

 7) `GHC.Driver.Main.tcRnModule'` -- Reads `tcg_safe_infer` after type-checking, calling
    `GHC.Driver.Main.markUnsafeInfer` (passing the reason along) when safe-inference
    failed.

Note [No defaulting in the ambiguity check]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When simplifying constraints for the ambiguity check, we use
solveWanteds, not simplifyTopWanteds, so that we do no defaulting.
#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.

Note [Defaulting insolubles]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If a set of wanteds is insoluble, we have no hope of accepting the
program. Yet we do not stop constraint solving, etc., because we may
simplify the wanteds to produce better error messages. So, once
we have an insoluble constraint, everything we do is just about producing
helpful error messages.

Should we default in this case or not? Let's look at an example (tcfail004):

  (f,g) = (1,2,3)

With defaulting, we get a conflict between (a0,b0) and (Integer,Integer,Integer).
Without defaulting, we get a conflict between (a0,b0) and (a1,b1,c1). I (Richard)
find the latter more helpful. Several other test cases (e.g. tcfail005) suggest
similarly. So: we should not do class defaulting with insolubles.

On the other hand, RuntimeRep-defaulting is different. Witness tcfail078:

  f :: Integer i => i
  f =               0

Without RuntimeRep-defaulting, we GHC suggests that Integer should have kind
TYPE r0 -> Constraint and then complains that r0 is actually untouchable
(presumably, because it can't be sure if `Integer i` entails an equality).
If we default, we are told of a clash between (* -> Constraint) and Constraint.
The latter seems far better, suggesting we *should* do RuntimeRep-defaulting
even on insolubles.

But, evidently, not always. Witness UnliftedNewtypesInfinite:

  newtype Foo = FooC (# Int#, Foo #)

This should fail with an occurs-check error on the kind of Foo (with -XUnliftedNewtypes).
If we default RuntimeRep-vars, we get

  Expecting a lifted type, but ‘(# Int#, Foo #)’ is unlifted

which is just plain wrong.

Another situation in which we don't want to default involves concrete metavariables.

In equalities such as   alpha[conc] ~# rr[sk]  ,  alpha[conc] ~# RR beta[tau]
for a type family RR (all at kind RuntimeRep), we would prefer to report a
representation-polymorphism error rather than default alpha and get error:

  Could not unify `rr` with `Lifted` / Could not unify `RR b0` with `Lifted`

which is very confusing. For this reason, we weed out the concrete
metavariables participating in such equalities in nonDefaultableTyVarsOfWC.
Just looking at insolublity is not enough, as `alpha[conc] ~# RR beta[tau]` could
become soluble after defaulting beta (see also #21430).

Conclusion: we should do RuntimeRep-defaulting on insolubles only when the
user does not want to hear about RuntimeRep stuff -- that is, when
-fprint-explicit-runtime-reps is not set.
However, we must still take care not to default concrete type variables
participating in an equality with a non-concrete type, as seen in the
last example above.
-}

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

       ; String -> SDoc -> TcM ()
traceTc String
"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 -> TcM Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.AllowAmbiguousTypes
       ; String -> SDoc -> TcM ()
traceTc String
"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 String
"reportUnsolved(ambig) }" SDoc
empty

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

------------------
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
simplifyInteractive WantedConstraints
wanteds
  = String -> SDoc -> TcM ()
traceTc String
"simplifyInteractive" SDoc
empty TcM () -> TcM (Bag EvBind) -> TcM (Bag EvBind)
forall a b.
IOEnv (Env TcGblEnv TcLclEnv) a
-> IOEnv (Env TcGblEnv TcLclEnv) b
-> IOEnv (Env TcGblEnv TcLclEnv) b
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 Bool     -- Return if the constraint is soluble
simplifyDefault :: [Type] -> TcM Bool
simplifyDefault [Type]
theta
  = do { String -> SDoc -> TcM ()
traceTc String
"simplifyDefault" SDoc
empty
       ; [CtEvidence]
wanteds  <- CtOrigin -> [Type] -> TcM [CtEvidence]
newWanteds CtOrigin
DefaultOrigin [Type]
theta
       ; (WantedConstraints
unsolved, EvBindMap
_) <- TcS WantedConstraints -> TcM (WantedConstraints, EvBindMap)
forall a. TcS a -> TcM (a, EvBindMap)
runTcS (WantedConstraints -> TcS WantedConstraints
solveWanteds ([CtEvidence] -> WantedConstraints
mkSimpleWC [CtEvidence]
wanteds))
       ; Bool -> TcM Bool
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints -> Bool
isEmptyWC WantedConstraints
unsolved) }

------------------
{- Note [Pattern match warnings with insoluble Givens]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A pattern match on a GADT can introduce new type-level information, which needs
to be analysed in order to get the expected pattern match warnings.

For example:

> type IsBool :: Type -> Constraint
> type family IsBool a where
>   IsBool Bool = ()
>   IsBool b    = b ~ Bool
>
> data T a where
>   MkTInt  :: Int -> T Int
>   MkTBool :: IsBool b => b -> T b
>
> f :: T Int -> Int
> f (MkTInt i) = i

The pattern matching performed by `f` is complete: we can't ever call
`f (MkTBool b)`, as type-checking that application would require producing
evidence for `Int ~ Bool`, which can't be done.

The pattern match checker uses `tcCheckGivens` to accumulate all the Given
constraints, and relies on `tcCheckGivens` to return Nothing if the
Givens become insoluble.   `tcCheckGivens` in turn relies on `insolubleCt`
to identify these insoluble constraints.  So the precise definition of
`insolubleCt` has a big effect on pattern match overlap warnings.

To detect this situation, we check whether there are any insoluble Given
constraints. In the example above, the insoluble constraint was an
equality constraint, but it is also important to detect custom type errors:

> type NotInt :: Type -> Constraint
> type family NotInt a where
>   NotInt Int = TypeError (Text "That's Int, silly.")
>   NotInt _   = ()
>
> data R a where
>   MkT1 :: a -> R a
>   MkT2 :: NotInt a => R a
>
> foo :: R Int -> Int
> foo (MkT1 x) = x

To see that we can't call `foo (MkT2)`, we must detect that `NotInt Int` is insoluble
because it is a custom type error.
Failing to do so proved quite inconvenient for users, as evidence by the
tickets #11503 #14141 #16377 #20180.
Test cases: T11503, T14141.

Examples of constraints that tcCheckGivens considers insoluble:
  - Int ~ Bool,
  - Coercible Float Word,
  - TypeError msg.

Non-examples:
  - constraints which we know aren't satisfied,
    e.g. Show (Int -> Int) when no such instance is in scope,
  - Eq (TypeError msg),
  - C (Int ~ Bool), with @class C (c :: Constraint)@.
-}

tcCheckGivens :: InertSet -> Bag EvVar -> TcM (Maybe InertSet)
-- ^ Return (Just new_inerts) if the Givens are satisfiable, Nothing if definitely
-- contradictory.
--
-- See Note [Pattern match warnings with insoluble Givens] above.
tcCheckGivens :: InertSet -> Bag TcTyVar -> TcM (Maybe InertSet)
tcCheckGivens InertSet
inerts Bag TcTyVar
given_ids = do
  (Bool
sat, InertSet
new_inerts) <- InertSet -> TcS Bool -> TcM (Bool, InertSet)
forall a. InertSet -> TcS a -> TcM (a, InertSet)
runTcSInerts InertSet
inerts (TcS Bool -> TcM (Bool, InertSet))
-> TcS Bool -> TcM (Bool, InertSet)
forall a b. (a -> b) -> a -> b
$ do
    String -> SDoc -> TcS ()
traceTcS String
"checkGivens {" (InertSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr InertSet
inerts SDoc -> SDoc -> SDoc
<+> Bag TcTyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bag TcTyVar
given_ids)
    TcLclEnv
lcl_env <- TcS TcLclEnv
TcS.getLclEnv
    let given_loc :: CtLoc
given_loc = TcLevel -> SkolemInfoAnon -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
topTcLevel (SkolemInfo -> SkolemInfoAnon
getSkolemInfo SkolemInfo
HasCallStack => SkolemInfo
unkSkol) TcLclEnv
lcl_env
    let given_cts :: [Ct]
given_cts = CtLoc -> [TcTyVar] -> [Ct]
mkGivens CtLoc
given_loc (Bag TcTyVar -> [TcTyVar]
forall a. Bag a -> [a]
bagToList Bag TcTyVar
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 String
"checkGivens }" (Cts -> SDoc
forall a. Outputable a => a -> SDoc
ppr Cts
insols)
    Bool -> TcS Bool
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cts -> Bool
forall a. Bag a -> Bool
isEmptyBag Cts
insols)
  Maybe InertSet -> TcM (Maybe InertSet)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe InertSet -> TcM (Maybe InertSet))
-> Maybe InertSet -> TcM (Maybe InertSet)
forall a b. (a -> b) -> a -> b
$ if Bool
sat then InertSet -> Maybe InertSet
forall a. a -> Maybe a
Just InertSet
new_inerts else Maybe InertSet
forall a. Maybe a
Nothing
  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 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 a. a -> TcS a
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 }

tcCheckWanteds :: InertSet -> ThetaType -> TcM Bool
-- ^ Return True if the Wanteds are soluble, False if not
tcCheckWanteds :: InertSet -> [Type] -> TcM Bool
tcCheckWanteds InertSet
inerts [Type]
wanteds = do
  [CtEvidence]
cts <- CtOrigin -> [Type] -> TcM [CtEvidence]
newWanteds CtOrigin
PatCheckOrigin [Type]
wanteds
  (Bool
sat, InertSet
_new_inerts) <- InertSet -> TcS Bool -> TcM (Bool, InertSet)
forall a. InertSet -> TcS a -> TcM (a, InertSet)
runTcSInerts InertSet
inerts (TcS Bool -> TcM (Bool, InertSet))
-> TcS Bool -> TcM (Bool, InertSet)
forall a b. (a -> b) -> a -> b
$ do
    String -> SDoc -> TcS ()
traceTcS String
"checkWanteds {" (InertSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr InertSet
inerts SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
wanteds)
    -- See Note [Superclasses and satisfiability]
    WantedConstraints
wcs <- WantedConstraints -> TcS WantedConstraints
solveWanteds ([CtEvidence] -> WantedConstraints
mkSimpleWC [CtEvidence]
cts)
    String -> SDoc -> TcS ()
traceTcS String
"checkWanteds }" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wcs)
    Bool -> TcS Bool
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints -> Bool
isSolvedWC WantedConstraints
wcs)
  Bool -> TcM Bool
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
sat

-- | Normalise a type as much as possible using the given constraints.
-- See @Note [tcNormalise]@.
tcNormalise :: InertSet -> Type -> TcM Type
tcNormalise :: InertSet -> Type -> TcM Type
tcNormalise InertSet
inerts Type
ty
  = do { CtLoc
norm_loc <- CtOrigin -> Maybe TypeOrKind -> TcM CtLoc
getCtLocM CtOrigin
PatCheckOrigin Maybe TypeOrKind
forall a. Maybe a
Nothing
       ; (Type
res, InertSet
_new_inerts) <- InertSet -> TcS Type -> TcM (Type, InertSet)
forall a. InertSet -> TcS a -> TcM (a, InertSet)
runTcSInerts InertSet
inerts (TcS Type -> TcM (Type, InertSet))
-> TcS Type -> TcM (Type, InertSet)
forall a b. (a -> b) -> a -> b
$
             do { String -> SDoc -> TcS ()
traceTcS String
"tcNormalise {" (InertSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr InertSet
inerts)
                ; Type
ty' <- CtLoc -> Type -> TcS Type
rewriteType CtLoc
norm_loc Type
ty
                ; String -> SDoc -> TcS ()
traceTcS String
"tcNormalise }" (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
ty')
                ; Type -> TcS Type
forall a. a -> TcS a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
ty' }
       ; Type -> TcM Type
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return Type
res }

{- 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 GHC.Builtin.Types.Prim.

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 #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 (#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 locally solved
constraints in the form of an InertSet, and normalise the type as much as
possible with respect to those constraints.

It does *not* reduce type or data family applications or look through newtypes.

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] in "GHC.HsToCore.Pmc".

To accomplish its stated goal, tcNormalise first initialises the solver monad
with the given InertCans, then uses rewriteType to simplify the desired type
with respect to the Givens in the InertCans.

***********************************************************************************
*                                                                                 *
*                            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 GHC.Tc.Gen.Bind.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.

Note [Inferring principal types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We don't always infer principal types. For instance, the inferred type for

> f x = show [x]

is

> f :: Show a => a -> String

This is not the most general type if we allow flexible contexts.
Indeed, if we try to write the following

> g :: Show [a] => a -> String
> g x = f x

we get the error:

  * Could not deduce (Show a) arising from a use of `f'
    from the context: Show [a]

Though replacing f x in the right-hand side of g with the definition
of f x works, the call to f x does not. This is the hallmark of
unprincip{led,al} types.

Another example:

> class C a
> class D a where
>   d :: a
> instance C a => D a where
>   d = undefined
> h _ = d   -- argument is to avoid the monomorphism restriction

The inferred type for h is

> h :: C a => t -> a

even though

> h :: D a => t -> a

is more general.

The fix is easy: don't simplify constraints before inferring a type.
That is, have the inferred type quantify over all constraints that arise
in a definition's right-hand side, even if they are simplifiable.
Unfortunately, this would yield all manner of unwieldy types,
and so we won't do so.
-}

-- | 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 "GHC.Tc.Module",
                                  -- the :type +d case; this mode refuses
                                  -- to quantify over any defaultable constraint
               | NoRestrictions   -- ^ Quantify over any constraint that
                                  -- satisfies pickQuantifiablePreds

instance Outputable InferMode where
  ppr :: InferMode -> SDoc
ppr InferMode
ApplyMR         = String -> SDoc
text String
"ApplyMR"
  ppr InferMode
EagerDefaulting = String -> SDoc
text String
"EagerDefaulting"
  ppr InferMode
NoRestrictions  = String -> SDoc
text String
"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
                      Bool)         -- True <=> the residual constraints are insoluble

simplifyInfer :: TcLevel
-> InferMode
-> [TcIdSigInst]
-> [(Name, Type)]
-> WantedConstraints
-> TcM ([TcTyVar], [TcTyVar], TcEvBinds, Bool)
simplifyInfer TcLevel
rhs_tclvl InferMode
infer_mode [TcIdSigInst]
sigs [(Name, Type)]
name_taus 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 = [ TcTyVar -> Type
mkTyVarTy TcTyVar
tv | TcIdSigInst
sig <- [TcIdSigInst]
partial_sigs
                                          , (Name
_,Bndr TcTyVar
tv Specificity
_) <- TcIdSigInst -> [(Name, InvisTVBinder)]
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 ]

       ; 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)

       ; SkolemInfo
skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
mkSkolemInfo ([(Name, Type)] -> SkolemInfoAnon
InferSkol [(Name, Type)]
name_taus)
       ; [TcTyVar]
qtkvs <- SkolemInfo
-> NonStandardDefaultingStrategy -> CandidatesQTvs -> TcM [TcTyVar]
quantifyTyVars SkolemInfo
skol_info NonStandardDefaultingStrategy
DefaultNonStandardTyVars CandidatesQTvs
dep_vars
       ; String -> SDoc -> TcM ()
traceTc String
"simplifyInfer: empty WC" ([(Name, Type)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(Name, Type)]
name_taus SDoc -> SDoc -> SDoc
$$ [TcTyVar] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TcTyVar]
qtkvs)
       ; ([TcTyVar], [TcTyVar], TcEvBinds, Bool)
-> TcM ([TcTyVar], [TcTyVar], TcEvBinds, Bool)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([TcTyVar]
qtkvs, [], TcEvBinds
emptyTcEvBinds, Bool
False) }

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

       ; EvBindsVar
ev_binds_var <- TcM EvBindsVar
TcM.newTcEvBinds
       ; [CtEvidence]
psig_evs     <- CtOrigin -> [Type] -> TcM [CtEvidence]
newWanteds CtOrigin
AnnOrigin [Type]
psig_theta
       ; WantedConstraints
wanted_transformed
            <- 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
$
               WantedConstraints -> TcS WantedConstraints
solveWanteds ([CtEvidence] -> WantedConstraints
mkSimpleWC [CtEvidence]
psig_evs WantedConstraints -> WantedConstraints -> WantedConstraints
`andWC` WantedConstraints
wanteds)
               -- psig_evs : see Note [Add signature contexts as wanteds]
               -- See Note [Inferring principal types]

       -- 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 <- WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
TcM.zonkWC WantedConstraints
wanted_transformed
       ; let definite_error :: Bool
definite_error = WantedConstraints -> Bool
insolubleWC WantedConstraints
wanted_transformed
                              -- See Note [Quantification with errors]
             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
       ; rec { ([TcTyVar]
qtvs, [Type]
bound_theta, VarSet
co_vars) <- SkolemInfo
-> InferMode
-> TcLevel
-> [(Name, Type)]
-> [TcIdSigInst]
-> [Type]
-> TcM ([TcTyVar], [Type], VarSet)
decideQuantification SkolemInfo
skol_info InferMode
infer_mode TcLevel
rhs_tclvl
                                                     [(Name, Type)]
name_taus [TcIdSigInst]
partial_sigs
                                                     [Type]
quant_pred_candidates
             ;  [TcTyVar]
bound_theta_vars <- (Type -> IOEnv (Env TcGblEnv TcLclEnv) TcTyVar)
-> [Type] -> TcM [TcTyVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Type -> IOEnv (Env TcGblEnv TcLclEnv) TcTyVar
forall gbl lcl. Type -> TcRnIf gbl lcl TcTyVar
TcM.newEvVar [Type]
bound_theta

             ; let full_theta :: [Type]
full_theta = (TcTyVar -> Type) -> [TcTyVar] -> [Type]
forall a b. (a -> b) -> [a] -> [b]
map TcTyVar -> Type
idType [TcTyVar]
bound_theta_vars
             ; SkolemInfo
skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
mkSkolemInfo ([(Name, Type)] -> SkolemInfoAnon
InferSkol [ (Name
name, [TyCoVarBinder] -> [Type] -> Type -> Type
mkSigmaTy [] [Type]
full_theta Type
ty)
                                                    | (Name
name, Type
ty) <- [(Name, Type)]
name_taus ])
       }


       -- Now emit the residual constraint
       ; TcLevel
-> EvBindsVar
-> [(Name, Type)]
-> VarSet
-> [TcTyVar]
-> [TcTyVar]
-> WantedConstraints
-> TcM ()
emitResidualConstraints TcLevel
rhs_tclvl EvBindsVar
ev_binds_var
                                 [(Name, Type)]
name_taus VarSet
co_vars [TcTyVar]
qtvs [TcTyVar]
bound_theta_vars
                                 WantedConstraints
wanted_transformed

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

       ; ([TcTyVar], [TcTyVar], TcEvBinds, Bool)
-> TcM ([TcTyVar], [TcTyVar], TcEvBinds, Bool)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ( [TcTyVar]
qtvs, [TcTyVar]
bound_theta_vars, EvBindsVar -> TcEvBinds
TcEvBinds EvBindsVar
ev_binds_var, 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

--------------------
emitResidualConstraints :: TcLevel -> EvBindsVar
                        -> [(Name, TcTauType)]
                        -> CoVarSet -> [TcTyVar] -> [EvVar]
                        -> WantedConstraints -> TcM ()
-- Emit the remaining constraints from the RHS.
emitResidualConstraints :: TcLevel
-> EvBindsVar
-> [(Name, Type)]
-> VarSet
-> [TcTyVar]
-> [TcTyVar]
-> WantedConstraints
-> TcM ()
emitResidualConstraints TcLevel
rhs_tclvl EvBindsVar
ev_binds_var
                        [(Name, Type)]
name_taus VarSet
co_vars [TcTyVar]
qtvs [TcTyVar]
full_theta_vars WantedConstraints
wanteds
  | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wanteds
  = () -> TcM ()
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

  | Bool
otherwise
  = do { Cts
wanted_simple <- Cts -> TcM Cts
TcM.zonkSimples (WantedConstraints -> Cts
wc_simple WantedConstraints
wanteds)
       ; let (Cts
outer_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
               | Just TcTyVar
ct_ev_id <- Ct -> Maybe TcTyVar
wantedEvId_maybe Ct
ct
               = TcTyVar
ct_ev_id TcTyVar -> VarSet -> Bool
`elemVarSet` VarSet
co_vars
               | Bool
otherwise
               = Bool
False
             -- Reason for the partition:
             -- see Note [Emitting the residual implication in simplifyInfer]

-- Already done by defaultTyVarsAndSimplify
--      ; _ <- TcM.promoteTyVarSet (tyCoVarsOfCts outer_simple)

        ; let inner_wanted :: WantedConstraints
inner_wanted = WantedConstraints
wanteds { wc_simple :: Cts
wc_simple = Cts
inner_simple }
        ; Bag Implication
implics <- if WantedConstraints -> Bool
isEmptyWC WantedConstraints
inner_wanted
                     then Bag Implication -> IOEnv (Env TcGblEnv TcLclEnv) (Bag Implication)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bag Implication
forall a. Bag a
emptyBag
                     else do Implication
implic1 <- TcM Implication
newImplication
                             Bag Implication -> IOEnv (Env TcGblEnv TcLclEnv) (Bag Implication)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bag Implication
 -> IOEnv (Env TcGblEnv TcLclEnv) (Bag Implication))
-> Bag Implication
-> IOEnv (Env TcGblEnv TcLclEnv) (Bag Implication)
forall a b. (a -> b) -> a -> b
$ Implication -> Bag Implication
forall a. a -> Bag a
unitBag (Implication -> Bag Implication) -> Implication -> Bag Implication
forall a b. (a -> b) -> a -> b
$
                                      Implication
implic1  { ic_tclvl :: TcLevel
ic_tclvl     = TcLevel
rhs_tclvl
                                               , ic_skols :: [TcTyVar]
ic_skols     = [TcTyVar]
qtvs
                                               , ic_given :: [TcTyVar]
ic_given     = [TcTyVar]
full_theta_vars
                                               , ic_wanted :: WantedConstraints
ic_wanted    = WantedConstraints
inner_wanted
                                               , ic_binds :: EvBindsVar
ic_binds     = EvBindsVar
ev_binds_var
                                               , ic_given_eqs :: HasGivenEqs
ic_given_eqs = HasGivenEqs
MaybeGivenEqs
                                               , ic_info :: SkolemInfoAnon
ic_info      = SkolemInfoAnon
skol_info }

        ; WantedConstraints -> TcM ()
emitConstraints (WantedConstraints
emptyWC { wc_simple :: Cts
wc_simple = Cts
outer_simple
                                   , wc_impl :: Bag Implication
wc_impl   = Bag Implication
implics }) }
  where
    full_theta :: [Type]
full_theta = (TcTyVar -> Type) -> [TcTyVar] -> [Type]
forall a b. (a -> b) -> [a] -> [b]
map TcTyVar -> Type
idType [TcTyVar]
full_theta_vars
    skol_info :: SkolemInfoAnon
skol_info = [(Name, Type)] -> SkolemInfoAnon
InferSkol [ (Name
name, [TyCoVarBinder] -> [Type] -> Type -> Type
mkSigmaTy [] [Type]
full_theta Type
ty)
                          | (Name
name, Type
ty) <- [(Name, Type)]
name_taus ]
    -- We 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 = [ 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 ]

findInferredDiff :: TcThetaType -> TcThetaType -> TcM TcThetaType
-- Given a partial type signature f :: (C a, D a, _) => blah
-- and the inferred constraints (X a, D a, Y a, C a)
-- compute the difference, which is what will fill in the "_" underscore,
-- In this case the diff is (X a, Y a).
findInferredDiff :: [Type] -> [Type] -> TcM [Type]
findInferredDiff [Type]
annotated_theta [Type]
inferred_theta
  | [Type] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Type]
annotated_theta   -- Short cut the common case when the user didn't
  = [Type] -> TcM [Type]
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return [Type]
inferred_theta  -- write any constraints in the partial signature
  | Bool
otherwise
  = TcM [Type] -> TcM [Type]
forall r. TcM r -> TcM r
pushTcLevelM_ (TcM [Type] -> TcM [Type]) -> TcM [Type] -> TcM [Type]
forall a b. (a -> b) -> a -> b
$
    do { TcLclEnv
lcl_env   <- TcRnIf TcGblEnv TcLclEnv TcLclEnv
forall gbl lcl. TcRnIf gbl lcl lcl
TcM.getLclEnv
       ; [TcTyVar]
given_ids <- (Type -> IOEnv (Env TcGblEnv TcLclEnv) TcTyVar)
-> [Type] -> TcM [TcTyVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Type -> IOEnv (Env TcGblEnv TcLclEnv) TcTyVar
forall gbl lcl. Type -> TcRnIf gbl lcl TcTyVar
TcM.newEvVar [Type]
annotated_theta
       ; [CtEvidence]
wanteds   <- CtOrigin -> [Type] -> TcM [CtEvidence]
newWanteds CtOrigin
AnnOrigin [Type]
inferred_theta
       ; let given_loc :: CtLoc
given_loc = TcLevel -> SkolemInfoAnon -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
topTcLevel (SkolemInfo -> SkolemInfoAnon
getSkolemInfo SkolemInfo
HasCallStack => SkolemInfo
unkSkol) TcLclEnv
lcl_env
             given_cts :: [Ct]
given_cts = CtLoc -> [TcTyVar] -> [Ct]
mkGivens CtLoc
given_loc [TcTyVar]
given_ids

       ; (WantedConstraints
residual, EvBindMap
_) <- 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
$
                          do { ()
_ <- [Ct] -> TcS ()
solveSimpleGivens [Ct]
given_cts
                             ; Cts -> TcS WantedConstraints
solveSimpleWanteds ([Ct] -> Cts
forall a. [a] -> Bag a
listToBag ((CtEvidence -> Ct) -> [CtEvidence] -> [Ct]
forall a b. (a -> b) -> [a] -> [b]
map CtEvidence -> Ct
mkNonCanonical [CtEvidence]
wanteds)) }
         -- NB: There are no meta tyvars fromn this level annotated_theta
         -- because we have either promoted them or unified them
         -- See `Note [Quantification and partial signatures]` Wrinkle 2

       ; [Type] -> TcM [Type]
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ((Ct -> Type) -> [Ct] -> [Type]
forall a b. (a -> b) -> [a] -> [b]
map (Type -> Type
box_pred (Type -> Type) -> (Ct -> Type) -> Ct -> Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> Type
ctPred) ([Ct] -> [Type]) -> [Ct] -> [Type]
forall a b. (a -> b) -> a -> b
$
                 Cts -> [Ct]
forall a. Bag a -> [a]
bagToList               (Cts -> [Ct]) -> Cts -> [Ct]
forall a b. (a -> b) -> a -> b
$
                 WantedConstraints -> Cts
wc_simple WantedConstraints
residual) }
  where
     box_pred :: PredType -> PredType
     box_pred :: Type -> Type
box_pred Type
pred = case Type -> Pred
classifyPredType Type
pred of
                        EqPred EqRel
rel Type
ty1 Type
ty2
                          | Just (Class
cls,[Type]
tys) <- EqRel -> Type -> Type -> Maybe (Class, [Type])
boxEqPred EqRel
rel Type
ty1 Type
ty2
                          -> Class -> [Type] -> Type
mkClassPred Class
cls [Type]
tys
                          | Bool
otherwise
                          -> String -> SDoc -> Type
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"findInferredDiff" (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
pred)
                        Pred
_other -> Type
pred

{- 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 #14584.

Note [Add signature contexts as wanteds]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this (#11016):
  f2 :: (?x :: Int) => _
  f2 = ?x

or this
  class C a b | a -> b
  g :: C p q => p -> q
  f3 :: C Int b => _
  f3 = g (3::Int)

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 want the (C Int b) constraint from the partial signature
   to meet the (C Int beta) constraint we get from the call to g; again,
   fundeps

Solution: in simplifyInfer, we add the constraints from the signature
as extra Wanteds.

Why Wanteds?  Wouldn't it be neater to treat them as Givens?  Alas
that would mess up (GivenInv) in Note [TcLevel invariants].  Consider
    f :: (Eq a, _) => blah1
    f = ....g...
    g :: (Eq b, _) => blah2
    g = ...f...

Then we have two psig_theta constraints (Eq a[tv], Eq b[tv]), both with
TyVarTvs inside.  Ultimately a[tv] := b[tv], but only when we've solved
all those constraints.  And both have level 1, so we can't put them as
Givens when solving at level 1.

Best to treat them as Wanteds.

But see also #20076, which would be solved if they were Givens.


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

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

* Step 1: decideMonoTyVars.
  Take the global tyvars, and "grow" them using functional dependencies
     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; this logic extends to general fundeps, not
          just equalities

  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: defaultTyVarsAndSimplify.
  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 (#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.

  This step also promotes the mono_tvs from Step 1. See
  Note [Promote monomorphic tyvars]. In fact, the *only*
  use of the mono_tvs from Step 1 is to promote them here.
  This promotion effectively stops us from quantifying over them
  later, in Step 3. Because the actual variables to quantify
  over are determined in Step 3 (not in Step 1), it is OK for
  the mono_tvs to be missing some variables free in the
  environment. This is why removing the psig_qtvs is OK in
  decideMonoTyVars. Test case for this scenario: T14479.

* Step 3: decideQuantifiedTyVars.
  Decide which variables to quantify over, as follows:

  - Take the free vars of the partial-type-signature types and constraints,
    and the tau-type (zonked_tau_tvs), and then "grow"
    them using all the constraints.  These are grown_tcvs.
    See Note [growThetaTyVars vs closeWrtFunDeps].

  - Use quantifyTyVars to quantify over the free variables of all the types
    involved, but only those in the grown_tcvs.

  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.

Note [Lift equality constraints when quantifying]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We can't quantify over a constraint (t1 ~# t2) because that isn't a
predicate type; see Note [Types for coercions, predicates, and evidence]
in GHC.Core.TyCo.Rep.

So we have to 'lift' it to (t1 ~ t2).  Similarly (~R#) must be lifted
to Coercible.

This tiresome lifting is the reason that pick_me (in
pickQuantifiablePreds) returns a Maybe rather than a Bool.

Note [Inheriting implicit parameters]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this:

        f x = (x::Int) + ?y

where f is *not* a top-level binding.
From the RHS of f we'll get the constraint (?y::Int).
There are two types we might infer for f:

        f :: Int -> Int

(so we get ?y from the context of f's definition), or

        f :: (?y::Int) => Int -> Int

At first you might think the first was better, because then
?y behaves like a free variable of the definition, rather than
having to be passed at each call site.  But of course, the WHOLE
IDEA is that ?y should be passed at each call site (that's what
dynamic binding means) so we'd better infer the second.

BOTTOM LINE: when *inferring types* you must quantify over implicit
parameters, *even if* they don't mention the bound type variables.
Reason: because implicit parameters, uniquely, have local instance
declarations. See pickQuantifiablePreds.

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

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

Note [Unconditionally resimplify constraints when quantifying]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
During quantification (in defaultTyVarsAndSimplify, specifically), we re-invoke
the solver to simplify the constraints before quantifying them. We do this for
two reasons, enumerated below. We could, in theory, detect when either of these
cases apply and simplify only then, but collecting this information is bothersome,
and simplifying redundantly causes no real harm. Note that this code path
happens only for definitions
  * without a type signature
  * when -XMonoLocalBinds does not apply
  * with unsolved constraints
and so the performance cost will be small.

1. Defaulting

Defaulting the variables handled by defaultTyVar may unlock instance simplifications.
Example (typecheck/should_compile/T20584b):

  with (t :: Double) (u :: String) = printf "..." t u

We know the types of t and u, but we do not know the return type of `with`. So, we
assume `with :: alpha`, where `alpha :: TYPE rho`. The type of printf is
  printf :: PrintfType r => String -> r
The occurrence of printf is instantiated with a fresh var beta. We then get
  beta := Double -> String -> alpha
and
  [W] PrintfType (Double -> String -> alpha)

Module Text.Printf exports
  instance (PrintfArg a, PrintfType r) => PrintfType (a -> r)
and it looks like that instance should apply.

But I have elided some key details: (->) is polymorphic over multiplicity and
runtime representation. Here it is in full glory:
  [W] PrintfType ((Double :: Type) %m1 -> (String :: Type) %m2 -> (alpha :: TYPE rho))
  instance (PrintfArg a, PrintfType r) => PrintfType ((a :: Type) %Many -> (r :: Type))

Because we do not know that m1 is Many, we cannot use the instance. (Perhaps a better instance
would have an explicit equality constraint to the left of =>, but that's not what we have.)
Then, in defaultTyVarsAndSimplify, we get m1 := Many, m2 := Many, and rho := LiftedRep.
Yet it's too late to simplify the quantified constraint, and thus GHC infers
  wait :: PrintfType (Double -> String -> t) => Double -> String -> t
which is silly. Simplifying again after defaulting solves this problem.

2. Interacting functional dependencies

Suppose we have

  class C a b | a -> b

and we are running simplifyInfer over

  forall[2] x. () => [W] C a beta1[1]
  forall[2] y. () => [W] C a beta2[1]

These are two implication constraints, both of which contain a
wanted for the class C. Neither constraint mentions the bound
skolem. We might imagine that these constraint could thus float
out of their implications and then interact, causing beta1 to unify
with beta2, but constraints do not currently float out of implications.

Unifying the beta1 and beta2 is important. Without doing so, then we might
infer a type like (C a b1, C a b2) => a -> a, which will fail to pass the
ambiguity check, which will say (rightly) that it cannot unify b1 with b2, as
required by the fundep interactions. This happens in the parsec library, and
in test case typecheck/should_compile/FloatFDs.

If we re-simplify, however, the two fundep constraints will interact, causing
a unification between beta1 and beta2, and all will be well. The key step
is that this simplification happens *after* the call to approximateWC in
simplifyInfer.

Note [Do not quantify over constraints that determine a variable]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider (typecheck/should_compile/tc231), where we're trying to infer
the type of a top-level declaration. We have
  class Zork s a b | a -> b
and the candidate constraint at the end of simplifyInfer is
  [W] Zork alpha (Z [Char]) beta
We definitely do want to quantify over alpha (which is mentioned in
the tau-type). But we do *not* want to quantify over beta: it is
determined by the functional dependency on Zork: note that the second
argument to Zork in the Wanted is a variable-free Z [Char].

The question here: do we want to quantify over the constraint? Definitely not.
Since we're not quantifying over beta, GHC has no choice but to zap beta
to Any, and then we infer a type involving (Zork a (Z [Char]) Any => ...). No no no.

The no_fixed_dependencies check in pickQuantifiablePreds eliminates this
candidate from the pool. Because there are no Zork instances in scope, this
program is rejected.

-}

decideQuantification
  :: SkolemInfo
  -> 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)
         , CoVarSet)
-- See Note [Deciding quantification]
decideQuantification :: SkolemInfo
-> InferMode
-> TcLevel
-> [(Name, Type)]
-> [TcIdSigInst]
-> [Type]
-> TcM ([TcTyVar], [Type], VarSet)
decideQuantification SkolemInfo
skol_info InferMode
infer_mode TcLevel
rhs_tclvl [(Name, Type)]
name_taus [TcIdSigInst]
psigs [Type]
candidates
  = do { -- Step 1: find the mono_tvs
       ; (VarSet
mono_tvs, [Type]
candidates, VarSet
co_vars) <- InferMode
-> [(Name, Type)]
-> [TcIdSigInst]
-> [Type]
-> TcM (VarSet, [Type], VarSet)
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 -> VarSet -> [Type] -> TcM [Type]
defaultTyVarsAndSimplify TcLevel
rhs_tclvl VarSet
mono_tvs [Type]
candidates

       -- Step 3: decide which kind/type variables to quantify over
       ; [TcTyVar]
qtvs <- SkolemInfo
-> [(Name, Type)] -> [TcIdSigInst] -> [Type] -> TcM [TcTyVar]
decideQuantifiedTyVars SkolemInfo
skol_info [(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 min_theta :: [Type]
min_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]
                         VarSet -> [Type] -> [Type]
pickQuantifiablePreds ([TcTyVar] -> VarSet
mkVarSet [TcTyVar]
qtvs) [Type]
candidates

             min_psig_theta :: [Type]
min_psig_theta = (Type -> Type) -> [Type] -> [Type]
forall a. (a -> Type) -> [a] -> [a]
mkMinimalBySCs Type -> Type
forall a. a -> a
id [Type]
psig_theta

       -- Add psig_theta back in here, even though it's already
       -- part of candidates, because we always want to quantify over
       -- psig_theta, and pickQuantifiableCandidates might have
       -- dropped some e.g. CallStack constraints.  c.f #14658
       --                   equalities (a ~ Bool)
       -- It's helpful to use the same "find difference" algorithm here as
       -- we use in GHC.Tc.Gen.Bind.chooseInferredQuantifiers (#20921)
       -- See Note [Constraints in partial type signatures]
       ; [Type]
theta <- if [Type] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Type]
psig_theta
                  then [Type] -> TcM [Type]
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return [Type]
min_theta  -- Fast path for the non-partial-sig case
                  else do { [Type]
diff <- [Type] -> [Type] -> TcM [Type]
findInferredDiff [Type]
min_psig_theta [Type]
min_theta
                          ; [Type] -> TcM [Type]
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Type]
min_psig_theta [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
diff) }

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

{- Note [Constraints in partial type signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Suppose we have a partial type signature
    f :: (Eq a, C a, _) => blah

We will ultimately quantify f over (Eq a, C a, <diff>), where

   * <diff> is the result of
         findInferredDiff (Eq a, C a) <quant-theta>
     in GHC.Tc.Gen.Bind.chooseInferredQuantifiers

   * <quant-theta> is the theta returned right here,
     by decideQuantification

At least for single functions we would like to quantify f over
precisely the same theta as <quant-theta>, so that we get to take
the short-cut path in GHC.Tc.Gen.Bind.mkExport, and avoid calling
tcSubTypeSigma for impedence matching. Why avoid?  Because it falls
over for ambiguous types (#20921).

We can get precisely the same theta by using the same algorithm,
findInferredDiff.

All of this goes wrong if we have (a) mutual recursion, (b) mutiple
partial type signatures, (c) with different constraints, and (d)
ambiguous types.  Something like
    f :: forall a. Eq a => F a -> _
    f x = (undefined :: a) == g x undefined
    g :: forall b. Show b => F b -> _ -> b
    g x y = let _ = (f y, show x) in x
But that's a battle for another day.
-}

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 or fundep to (a) or (b)
-- Also return CoVars that appear free in the final quantified types
--   we can't quantify over these, and we must make sure they are in scope
decideMonoTyVars :: InferMode
-> [(Name, Type)]
-> [TcIdSigInst]
-> [Type]
-> TcM (VarSet, [Type], VarSet)
decideMonoTyVars InferMode
infer_mode [(Name, Type)]
name_taus [TcIdSigInst]
psigs [Type]
candidates
  = do { ([Type]
no_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
       ; [TcTyVar]
psig_qtvs <-  [TcTyVar] -> TcM [TcTyVar]
(() :: Constraint) => [TcTyVar] -> TcM [TcTyVar]
zonkTcTyVarsToTcTyVars ([TcTyVar] -> TcM [TcTyVar]) -> [TcTyVar] -> TcM [TcTyVar]
forall a b. (a -> b) -> a -> b
$ [InvisTVBinder] -> [TcTyVar]
forall tv argf. [VarBndr tv argf] -> [tv]
binderVars ([InvisTVBinder] -> [TcTyVar]) -> [InvisTVBinder] -> [TcTyVar]
forall a b. (a -> b) -> a -> b
$
                      (TcIdSigInst -> [InvisTVBinder])
-> [TcIdSigInst] -> [InvisTVBinder]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (((Name, InvisTVBinder) -> InvisTVBinder)
-> [(Name, InvisTVBinder)] -> [InvisTVBinder]
forall a b. (a -> b) -> [a] -> [b]
map (Name, InvisTVBinder) -> InvisTVBinder
forall a b. (a, b) -> b
snd ([(Name, InvisTVBinder)] -> [InvisTVBinder])
-> (TcIdSigInst -> [(Name, InvisTVBinder)])
-> TcIdSigInst
-> [InvisTVBinder]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TcIdSigInst -> [(Name, InvisTVBinder)]
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)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [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)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [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

       ; TcLevel
tc_lvl <- TcM TcLevel
TcM.getTcLevel
       ; let psig_tys :: [Type]
psig_tys = [TcTyVar] -> [Type]
mkTyVarTys [TcTyVar]
psig_qtvs [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
psig_theta

             co_vars :: VarSet
co_vars = [Type] -> VarSet
coVarsOfTypes ([Type]
psig_tys [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
taus [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
candidates)
             co_var_tvs :: VarSet
co_var_tvs = VarSet -> VarSet
closeOverKinds VarSet
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_tvs0 :: VarSet
mono_tvs0 = (TcTyVar -> Bool) -> VarSet -> VarSet
filterVarSet (Bool -> Bool
not (Bool -> Bool) -> (TcTyVar -> Bool) -> TcTyVar -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TcLevel -> TcTyVar -> Bool
isQuantifiableTv TcLevel
tc_lvl) (VarSet -> VarSet) -> VarSet -> VarSet
forall a b. (a -> b) -> a -> b
$
                         [Type] -> VarSet
tyCoVarsOfTypes [Type]
candidates
               -- We need to grab all the non-quantifiable tyvars in the
               -- types so that we can grow this set to find other
               -- non-quantifiable tyvars. This can happen with something
               -- like
               --    f x y = ...
               --      where z = x 3
               -- The body of z tries to unify the type of x (call it alpha[1])
               -- with (beta[2] -> gamma[2]). This unification fails because
               -- alpha is untouchable. But we need to know not to quantify over
               -- beta or gamma, because they are in the equality constraint with
               -- alpha. Actual test case: typecheck/should_compile/tc213

             mono_tvs1 :: VarSet
mono_tvs1 = VarSet
mono_tvs0 VarSet -> VarSet -> VarSet
`unionVarSet` VarSet
co_var_tvs
               -- mono_tvs1 is now the set of variables from an outer scope
               -- (that's mono_tvs0) and the set of covars, closed over kinds.
               -- Given this set of variables we know we will not quantify,
               -- we want to find any other variables that are determined by this
               -- set, by functional dependencies or equalities. We thus use
               -- closeWrtFunDeps to find all further variables determined by this root
               -- set. See Note [growThetaTyVars vs closeWrtFunDeps]

             non_ip_candidates :: [Type]
non_ip_candidates = (Type -> Bool) -> [Type] -> [Type]
forall a. (a -> Bool) -> [a] -> [a]
filterOut Type -> Bool
isIPLikePred [Type]
candidates
               -- implicit params don't really determine a type variable
               -- (that is, we might have IP "c" Bool and IP "c" Int in different
               -- places within the same program), and
               -- skipping this causes implicit params to monomorphise too many
               -- variables; see Note [Inheriting implicit parameters] in
               -- GHC.Tc.Solver. Skipping causes typecheck/should_compile/tc219
               -- to fail.

             mono_tvs2 :: VarSet
mono_tvs2 = [Type] -> VarSet -> VarSet
closeWrtFunDeps [Type]
non_ip_candidates VarSet
mono_tvs1
               -- mono_tvs2 now contains any variable determined by the "root
               -- set" of monomorphic tyvars in mono_tvs1.

             constrained_tvs :: VarSet
constrained_tvs = (TcTyVar -> Bool) -> VarSet -> VarSet
filterVarSet (TcLevel -> TcTyVar -> Bool
isQuantifiableTv TcLevel
tc_lvl) (VarSet -> VarSet) -> VarSet -> VarSet
forall a b. (a -> b) -> a -> b
$
                               [Type] -> VarSet -> VarSet
closeWrtFunDeps [Type]
non_ip_candidates ([Type] -> VarSet
tyCoVarsOfTypes [Type]
no_quant)
                                VarSet -> VarSet -> VarSet
`minusVarSet` VarSet
mono_tvs2
             -- constrained_tvs: the tyvars that we are not going to
             -- quantify solely because of the monomorphism restriction
             --
             -- (`minusVarSet` mono_tvs2): a type variable is only
             --   "constrained" (so that the MR bites) if it is not
             --   free in the environment (#13785) or is determined
             --   by some variable that is free in the env't

             mono_tvs :: VarSet
mono_tvs = (VarSet
mono_tvs2 VarSet -> VarSet -> VarSet
`unionVarSet` VarSet
constrained_tvs)
                          VarSet -> [TcTyVar] -> VarSet
`delVarSetList` [TcTyVar]
psig_qtvs
             -- (`delVarSetList` psig_qtvs): if the user has explicitly
             --   asked for quantification, then that request "wins"
             --   over the MR.
             --
             -- What if a psig variable is also free in the environment
             -- (i.e. says "no" to isQuantifiableTv)? That's OK: explanation
             -- in Step 2 of Note [Deciding quantification].

           -- Warn about the monomorphism restriction
       ; Bool -> TcM () -> TcM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (case InferMode
infer_mode of { InferMode
ApplyMR -> Bool
True; InferMode
_ -> Bool
False}) (TcM () -> TcM ()) -> TcM () -> TcM ()
forall a b. (a -> b) -> a -> b
$ do
           let dia :: TcRnMessage
dia = [Name] -> TcRnMessage
TcRnMonomorphicBindings (((Name, Type) -> Name) -> [(Name, Type)] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map (Name, Type) -> Name
forall a b. (a, b) -> a
fst [(Name, Type)]
name_taus)
           Bool -> TcRnMessage -> TcM ()
diagnosticTc (VarSet
constrained_tvs VarSet -> VarSet -> Bool
`intersectsVarSet` [Type] -> VarSet
tyCoVarsOfTypes [Type]
taus) TcRnMessage
dia

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

       ; (VarSet, [Type], VarSet) -> TcM (VarSet, [Type], VarSet)
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (VarSet
mono_tvs, [Type]
maybe_quant, VarSet
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 InferMode
NoRestrictions  [Type]
cand = ([Type], [Type]) -> TcM ([Type], [Type])
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([], [Type]
cand)
    pick InferMode
ApplyMR         [Type]
cand = ([Type], [Type]) -> TcM ([Type], [Type])
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Type]
cand, [])
    pick InferMode
EagerDefaulting [Type]
cand = do { Bool
os <- Extension -> TcM Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.OverloadedStrings
                                   ; ([Type], [Type]) -> TcM ([Type], [Type])
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
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 Bool
ovl_strings Type
pred
      | Just (Class
cls, [Type]
_) <- Type -> Maybe (Class, [Type])
getClassPredTys_maybe Type
pred
      = Bool -> Class -> Bool
isInteractiveClass Bool
ovl_strings Class
cls
      | Bool
otherwise
      = Bool
False

-------------------
defaultTyVarsAndSimplify :: TcLevel
                         -> TyCoVarSet          -- Promote these mono-tyvars
                         -> [PredType]          -- Assumed zonked
                         -> TcM [PredType]      -- Guaranteed zonked
-- Promote the known-monomorphic tyvars;
-- Default any tyvar free in the constraints;
-- and re-simplify in case the defaulting allows further simplification
defaultTyVarsAndSimplify :: TcLevel -> VarSet -> [Type] -> TcM [Type]
defaultTyVarsAndSimplify TcLevel
rhs_tclvl VarSet
mono_tvs [Type]
candidates
  = do {  -- Promote any tyvars that we cannot generalise
          -- See Note [Promote monomorphic tyvars]
       ; String -> SDoc -> TcM ()
traceTc String
"decideMonoTyVars: promotion:" (VarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr VarSet
mono_tvs)
       ; Bool
_ <- VarSet -> TcM Bool
promoteTyVarSet VarSet
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 -> TcM Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.PolyKinds
       ; (TcTyVar -> TcM ()) -> [TcTyVar] -> TcM ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (Bool -> Bool -> TcTyVar -> TcM ()
default_one Bool
poly_kinds Bool
True) (DTyVarSet -> [TcTyVar]
dVarSetElems DTyVarSet
cand_kvs)
       ; (TcTyVar -> TcM ()) -> [TcTyVar] -> TcM ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (Bool -> Bool -> TcTyVar -> TcM ()
default_one Bool
poly_kinds Bool
False) (DTyVarSet -> [TcTyVar]
dVarSetElems (DTyVarSet
cand_tvs DTyVarSet -> DTyVarSet -> DTyVarSet
`minusDVarSet` DTyVarSet
cand_kvs))

       ; [Type] -> TcM [Type]
simplify_cand [Type]
candidates
       }
  where
    default_one :: Bool -> Bool -> TcTyVar -> TcM ()
default_one Bool
poly_kinds Bool
is_kind_var TcTyVar
tv
      | Bool -> Bool
not (TcTyVar -> Bool
isMetaTyVar TcTyVar
tv)
      = () -> TcM ()
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      | TcTyVar
tv TcTyVar -> VarSet -> Bool
`elemVarSet` VarSet
mono_tvs
      = () -> TcM ()
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      | Bool
otherwise
      = TcM Bool -> TcM ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (TcM Bool -> TcM ()) -> TcM Bool -> TcM ()
forall a b. (a -> b) -> a -> b
$ DefaultingStrategy -> TcTyVar -> TcM Bool
defaultTyVar
          (if Bool -> Bool
not Bool
poly_kinds Bool -> Bool -> Bool
&& Bool
is_kind_var
           then DefaultingStrategy
DefaultKindVars
           else NonStandardDefaultingStrategy -> DefaultingStrategy
NonStandardDefaulting NonStandardDefaultingStrategy
DefaultNonStandardTyVars)
          -- NB: only pass 'DefaultKindVars' when we know we're dealing with a kind variable.
          TcTyVar
tv

       -- this common case (no inferred contraints) should be fast
    simplify_cand :: [Type] -> TcM [Type]
simplify_cand [] = [Type] -> TcM [Type]
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
       -- see Note [Unconditionally resimplify constraints when quantifying]
    simplify_cand [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 String
"Simplified after defaulting" (SDoc -> TcM ()) -> SDoc -> TcM ()
forall a b. (a -> b) -> a -> b
$
                      [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"Before:" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
candidates
                           , String -> SDoc
text String
"After:"  SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
new_candidates ]
           ; [Type] -> TcM [Type]
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return [Type]
new_candidates }

------------------
decideQuantifiedTyVars
   :: SkolemInfo
   -> [(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 :: SkolemInfo
-> [(Name, Type)] -> [TcIdSigInst] -> [Type] -> TcM [TcTyVar]
decideQuantifiedTyVars SkolemInfo
skol_info [(Name, Type)]
name_taus [TcIdSigInst]
psigs [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 <- (TcTyVar -> TcM Type) -> [TcTyVar] -> TcM [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM TcTyVar -> TcM Type
TcM.zonkTcTyVar [ TcTyVar
tv | TcIdSigInst
sig <- [TcIdSigInst]
psigs
                                                  , (Name
_,Bndr TcTyVar
tv Specificity
_) <- TcIdSigInst -> [(Name, InvisTVBinder)]
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)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [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)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [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

       ; 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'
             -- See Note [growThetaTyVars vs closeWrtFunDeps]
             grown_tcvs :: VarSet
grown_tcvs = [Type] -> VarSet -> VarSet
growThetaTyVars [Type]
candidates ([Type] -> VarSet
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 (#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 -> VarSet -> DTyVarSet
`dVarSetIntersectVarSet` VarSet
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 String
"decideQuantifiedTyVars" ([SDoc] -> SDoc
vcat
           [ String -> SDoc
text String
"tau_tys =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
tau_tys
           , String -> SDoc
text String
"candidates =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
candidates
           , String -> SDoc
text String
"cand_kvs =" SDoc -> SDoc -> SDoc
<+> DTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr DTyVarSet
cand_kvs
           , String -> SDoc
text String
"cand_tvs =" SDoc -> SDoc -> SDoc
<+> DTyVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr DTyVarSet
cand_tvs
           , String -> SDoc
text String
"tau_tys =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
tau_tys
           , String -> SDoc
text String
"seed_tys =" SDoc -> SDoc -> SDoc
<+> [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
seed_tys
           , String -> SDoc
text String
"seed_tcvs =" SDoc -> SDoc -> SDoc
<+> VarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr ([Type] -> VarSet
tyCoVarsOfTypes [Type]
seed_tys)
           , String -> SDoc
text String
"grown_tcvs =" SDoc -> SDoc -> SDoc
<+> VarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr VarSet
grown_tcvs
           , String -> SDoc
text String
"dvs =" SDoc -> SDoc -> SDoc
<+> CandidatesQTvs -> SDoc
forall a. Outputable a => a -> SDoc
ppr CandidatesQTvs
dvs_plus])

       ; SkolemInfo
-> NonStandardDefaultingStrategy -> CandidatesQTvs -> TcM [TcTyVar]
quantifyTyVars SkolemInfo
skol_info NonStandardDefaultingStrategy
DefaultNonStandardTyVars CandidatesQTvs
dvs_plus }

------------------
-- | When inferring types, should we quantify over a given predicate?
-- Generally true of classes; generally false of equality constraints.
-- Equality constraints that mention quantified type variables and
-- implicit variables complicate the story. See Notes
-- [Inheriting implicit parameters] and [Quantifying over equality constraints]
pickQuantifiablePreds
  :: TyVarSet           -- Quantifying over these
  -> TcThetaType        -- Proposed constraints to quantify
  -> TcThetaType        -- A subset that we can actually quantify
-- This function decides whether a particular constraint should be
-- quantified over, given the type variables that are being quantified
pickQuantifiablePreds :: VarSet -> [Type] -> [Type]
pickQuantifiablePreds VarSet
qtvs [Type]
theta
  = let flex_ctxt :: Bool
flex_ctxt = Bool
True in  -- Quantify over non-tyvar constraints, even without
                             -- -XFlexibleContexts: see #10608, #10351
         -- flex_ctxt <- xoptM Opt_FlexibleContexts
    (Type -> Maybe Type) -> [Type] -> [Type]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (Bool -> Type -> Maybe Type
pick_me Bool
flex_ctxt) [Type]
theta
  where
    pick_me :: Bool -> Type -> Maybe Type
pick_me Bool
flex_ctxt Type
pred
      = case Type -> Pred
classifyPredType Type
pred of

          ClassPred Class
cls [Type]
tys
            | Just {} <- Class -> [Type] -> Maybe FastString
isCallStackPred Class
cls [Type]
tys
              -- NEVER infer a CallStack constraint.  Otherwise we let
              -- the constraints bubble up to be solved from the outer
              -- context, or be defaulted when we reach the top-level.
              -- See Note [Overview of implicit CallStacks] in GHC.Tc.Types.Evidence
            -> Maybe Type
forall a. Maybe a
Nothing

            | Class -> Bool
isIPClass Class
cls
            -> Type -> Maybe Type
forall a. a -> Maybe a
Just Type
pred -- See Note [Inheriting implicit parameters]

            | Bool -> Class -> [Type] -> Bool
pick_cls_pred Bool
flex_ctxt Class
cls [Type]
tys
            -> Type -> Maybe Type
forall a. a -> Maybe a
Just Type
pred

          EqPred EqRel
eq_rel Type
ty1 Type
ty2
            | EqRel -> Type -> Type -> Bool
quantify_equality EqRel
eq_rel Type
ty1 Type
ty2
            , Just (Class
cls, [Type]
tys) <- EqRel -> Type -> Type -> Maybe (Class, [Type])
boxEqPred EqRel
eq_rel Type
ty1 Type
ty2
              -- boxEqPred: See Note [Lift equality constraints when quantifying]
            , Bool -> Class -> [Type] -> Bool
pick_cls_pred Bool
flex_ctxt Class
cls [Type]
tys
            -> Type -> Maybe Type
forall a. a -> Maybe a
Just (Class -> [Type] -> Type
mkClassPred Class
cls [Type]
tys)

          IrredPred Type
ty
            | Type -> VarSet
tyCoVarsOfType Type
ty VarSet -> VarSet -> Bool
`intersectsVarSet` VarSet
qtvs
            -> Type -> Maybe Type
forall a. a -> Maybe a
Just Type
pred

          Pred
_ -> Maybe Type
forall a. Maybe a
Nothing


    pick_cls_pred :: Bool -> Class -> [Type] -> Bool
pick_cls_pred Bool
flex_ctxt Class
cls [Type]
tys
      = [Type] -> VarSet
tyCoVarsOfTypes [Type]
tys VarSet -> VarSet -> Bool
`intersectsVarSet` VarSet
qtvs
        Bool -> Bool -> Bool
&& (Bool -> Class -> [Type] -> Bool
checkValidClsArgs Bool
flex_ctxt Class
cls [Type]
tys)
           -- Only quantify over predicates that checkValidType
           -- will pass!  See #10351.
        Bool -> Bool -> Bool
&& (Class -> [Type] -> Bool
no_fixed_dependencies Class
cls [Type]
tys)

    -- See Note [Do not quantify over constraints that determine a variable]
    no_fixed_dependencies :: Class -> [Type] -> Bool
no_fixed_dependencies Class
cls [Type]
tys
      = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [ VarSet
qtvs VarSet -> VarSet -> Bool
`intersectsVarSet` [Type] -> VarSet
tyCoVarsOfTypes [Type]
fd_lhs_tys
            | FunDep TcTyVar
fd <- [FunDep TcTyVar]
cls_fds
            , let ([Type]
fd_lhs_tys, [Type]
_) = FunDep TcTyVar -> [TcTyVar] -> [Type] -> ([Type], [Type])
instFD FunDep TcTyVar
fd [TcTyVar]
cls_tvs [Type]
tys ]
      where
        ([TcTyVar]
cls_tvs, [FunDep TcTyVar]
cls_fds) = Class -> ([TcTyVar], [FunDep TcTyVar])
classTvsFds Class
cls

    -- See Note [Quantifying over equality constraints]
    quantify_equality :: EqRel -> Type -> Type -> Bool
quantify_equality EqRel
NomEq  Type
ty1 Type
ty2 = Type -> Bool
quant_fun Type
ty1 Bool -> Bool -> Bool
|| Type -> Bool
quant_fun Type
ty2
    quantify_equality EqRel
ReprEq Type
_   Type
_   = Bool
True

    quant_fun :: Type -> Bool
quant_fun Type
ty
      = case HasCallStack => Type -> Maybe (TyCon, [Type])
Type -> Maybe (TyCon, [Type])
tcSplitTyConApp_maybe Type
ty of
          Just (TyCon
tc, [Type]
tys) | TyCon -> Bool
isTypeFamilyTyCon TyCon
tc
                         -> [Type] -> VarSet
tyCoVarsOfTypes [Type]
tys VarSet -> VarSet -> Bool
`intersectsVarSet` VarSet
qtvs
          Maybe (TyCon, [Type])
_ -> Bool
False


------------------
growThetaTyVars :: ThetaType -> TyCoVarSet -> TyCoVarSet
-- See Note [growThetaTyVars vs closeWrtFunDeps]
growThetaTyVars :: [Type] -> VarSet -> VarSet
growThetaTyVars [Type]
theta VarSet
tcvs
  | [Type] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Type]
theta = VarSet
tcvs
  | Bool
otherwise  = (VarSet -> VarSet) -> VarSet -> VarSet
transCloVarSet VarSet -> VarSet
mk_next VarSet
seed_tcvs
  where
    seed_tcvs :: VarSet
seed_tcvs = VarSet
tcvs VarSet -> VarSet -> VarSet
`unionVarSet` [Type] -> VarSet
tyCoVarsOfTypes [Type]
ips
    ([Type]
ips, [Type]
non_ips) = (Type -> Bool) -> [Type] -> ([Type], [Type])
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition Type -> Bool
isIPLikePred [Type]
theta
                         -- See Note [Inheriting implicit parameters]

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


{- Note [Promote monomorphic 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: promoteTyVarSet 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, we are 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 (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 (#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 (#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 GHC.Tc.Solver.decideMonoTyVars.  We
  report the error later, in GHC.Tc.Gen.Bind.chooseInferredQuantifiers.

Note [growThetaTyVars vs closeWrtFunDeps]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
GHC has two functions, growThetaTyVars and closeWrtFunDeps, both with
the same type and similar behavior. This Note outlines the differences
and why we use one or the other.

Both functions take a list of constraints. We will call these the
*candidates*.

closeWrtFunDeps takes a set of "determined" type variables and finds the
closure of that set with respect to the functional dependencies
within the class constraints in the set of candidates. So, if we
have

  class C a b | a -> b
  class D a b   -- no fundep
  candidates = {C (Maybe a) (Either b c), D (Maybe a) (Either d e)}

then closeWrtFunDeps {a} will return the set {a,b,c}.
This is because, if `a` is determined, then `b` and `c` are, too,
by functional dependency. closeWrtFunDeps called with any seed set not including
`a` will just return its argument, as only `a` determines any other
type variable (in this example).

growThetaTyVars operates similarly, but it behaves as if every
constraint has a functional dependency among all its arguments.
So, continuing our example, growThetaTyVars {a} will return
{a,b,c,d,e}. Put another way, growThetaTyVars grows the set of
variables to include all variables that are mentioned in the same
constraint (transitively).

We use closeWrtFunDeps in places where we need to know which variables are
*always* determined by some seed set. This includes
  * when determining the mono-tyvars in decideMonoTyVars. If `a`
    is going to be monomorphic, we need b and c to be also: they
    are determined by the choice for `a`.
  * when checking instance coverage, in
    GHC.Tc.Instance.FunDeps.checkInstCoverage

On the other hand, we use growThetaTyVars where we need to know
which variables *might* be determined by some seed set. This includes
  * deciding quantification (GHC.Tc.Gen.Bind.chooseInferredQuantifiers
    and decideQuantifiedTyVars
How can `a` determine (say) `d` in the example above without a fundep?
Suppose we have
  instance (b ~ a, c ~ a) => D (Maybe [a]) (Either b c)
Now, if `a` turns out to be a list, it really does determine b and c.
The danger in overdoing quantification is the creation of an ambiguous
type signature, but this is conveniently caught in the validity checker.

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.
      #14000 is an example

I tried an alternative approach: simply failM, after emitting the
residual implication constraint; the exception will be caught in
GHC.Tc.Gen.Bind.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.

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 #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
-- Postcondition: fully zonked
simplifyWantedsTcM :: [CtEvidence] -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
simplifyWantedsTcM [CtEvidence]
wanted
  = do { String -> SDoc -> TcM ()
traceTc String
"simplifyWantedsTcM {" ([CtEvidence] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [CtEvidence]
wanted)
       ; (WantedConstraints
result, EvBindMap
_) <- TcS WantedConstraints -> TcM (WantedConstraints, EvBindMap)
forall a. TcS a -> TcM (a, EvBindMap)
runTcS (WantedConstraints -> TcS WantedConstraints
solveWanteds ([CtEvidence] -> WantedConstraints
mkSimpleWC [CtEvidence]
wanted))
       ; WantedConstraints
result <- WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
TcM.zonkWC WantedConstraints
result
       ; String -> SDoc -> TcM ()
traceTc String
"simplifyWantedsTcM }" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
result)
       ; WantedConstraints -> TcRnIf TcGblEnv TcLclEnv WantedConstraints
forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
result }

solveWanteds :: WantedConstraints -> TcS WantedConstraints
solveWanteds :: WantedConstraints -> TcS WantedConstraints
solveWanteds wc :: WantedConstraints
wc@(WC { wc_errors :: WantedConstraints -> Bag DelayedError
wc_errors = Bag DelayedError
errs })
  = do { TcLevel
cur_lvl <- TcS TcLevel
TcS.getTcLevel
       ; String -> SDoc -> TcS ()
traceTcS String
"solveWanteds {" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
         [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"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 ]

       ; DynFlags
dflags <- TcS DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
       ; WantedConstraints
solved_wc <- Int
-> IntWithInf -> Bool -> WantedConstraints -> TcS WantedConstraints
simplify_loop Int
0 (DynFlags -> IntWithInf
solverIterations DynFlags
dflags) Bool
True WantedConstraints
wc

       ; Bag DelayedError
errs' <- Bag DelayedError -> TcS (Bag DelayedError)
simplifyDelayedErrors Bag DelayedError
errs
       ; let final_wc :: WantedConstraints
final_wc = WantedConstraints
solved_wc { wc_errors :: Bag DelayedError
wc_errors = Bag DelayedError
errs' }

       ; EvBindsVar
ev_binds_var <- TcS EvBindsVar
getTcEvBindsVar
       ; EvBindMap
bb <- EvBindsVar -> TcS EvBindMap
TcS.getTcEvBindsMap EvBindsVar
ev_binds_var
       ; String -> SDoc -> TcS ()
traceTcS String
"solveWanteds }" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
                 [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"final wc =" SDoc -> SDoc -> SDoc
<+> WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
final_wc
                      , String -> SDoc
text String
"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 a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
final_wc }

simplify_loop :: Int -> IntWithInf -> Bool
              -> WantedConstraints -> TcS WantedConstraints
-- Do a round of solving, and call maybe_simplify_again to iterate
-- The 'definitely_redo_implications' flags is False if the only reason we
-- are iterating is that we have added some new Wanted superclasses
-- hoping for fundeps to help us; see Note [Superclass iteration]
--
-- Does not affect wc_holes at all; reason: wc_holes never affects anything
-- else, so we do them once, at the end in solveWanteds
simplify_loop :: Int
-> IntWithInf -> Bool -> WantedConstraints -> TcS WantedConstraints
simplify_loop Int
n IntWithInf
limit Bool
definitely_redo_implications
              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 String
"simplify_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 String
"definitely_redo =" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
definitely_redo_implications SDoc -> SDoc -> SDoc
<> SDoc
comma
                            , Int -> SDoc
int (Cts -> Int
forall a. Bag a -> Int
lengthBag Cts
simples) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"simples to solve" ])
       ; String -> SDoc -> TcS ()
traceTcS String
"simplify_loop: wc =" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wc)

       ; (Int
unifs1, 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
$  -- See Note [Superclass iteration]
                          Cts -> TcS WantedConstraints
solveSimpleWanteds Cts
simples
                -- Any insoluble constraints are in 'simples' and so get rewritten
                -- See Note [Rewrite insolubles] in GHC.Tc.Solver.InertSet

       ; WantedConstraints
wc2 <- if Bool -> Bool
not Bool
definitely_redo_implications  -- See Note [Superclass iteration]
                   Bool -> Bool -> Bool
&& Int
unifs1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0                    -- for this conditional
                   Bool -> Bool -> Bool
&& Bag Implication -> Bool
forall a. Bag a -> Bool
isEmptyBag (WantedConstraints -> Bag Implication
wc_impl WantedConstraints
wc1)
                then WantedConstraints -> TcS WantedConstraints
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints
wc { wc_simple :: Cts
wc_simple = WantedConstraints -> Cts
wc_simple WantedConstraints
wc1 })  -- Short cut
                else do { Bag Implication
implics2 <- Bag Implication -> TcS (Bag Implication)
solveNestedImplications (Bag Implication -> TcS (Bag Implication))
-> Bag Implication -> TcS (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)
                        ; WantedConstraints -> TcS WantedConstraints
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (WantedConstraints
wc { wc_simple :: Cts
wc_simple = WantedConstraints -> Cts
wc_simple WantedConstraints
wc1
                                     , wc_impl :: Bag Implication
wc_impl = Bag Implication
implics2 }) }

       ; Bool
unif_happened <- TcS Bool
resetUnificationFlag
       ; SDoc -> TcS ()
csTraceTcS (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$ String -> SDoc
text String
"unif_happened" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
unif_happened
         -- Note [The Unification Level Flag] in GHC.Tc.Solver.Monad
       ; Int
-> IntWithInf -> Bool -> WantedConstraints -> TcS WantedConstraints
maybe_simplify_again (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) IntWithInf
limit Bool
unif_happened WantedConstraints
wc2 }

maybe_simplify_again :: Int -> IntWithInf -> Bool
                     -> WantedConstraints -> TcS WantedConstraints
maybe_simplify_again :: Int
-> IntWithInf -> Bool -> WantedConstraints -> TcS WantedConstraints
maybe_simplify_again Int
n IntWithInf
limit Bool
unif_happened 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!
         TcRnMessage -> TcS ()
addErrTcS (TcRnMessage -> TcS ()) -> TcRnMessage -> TcS ()
forall a b. (a -> b) -> a -> b
$ Cts -> IntWithInf -> WantedConstraints -> TcRnMessage
TcRnSimplifierTooManyIterations Cts
simples IntWithInf
limit WantedConstraints
wc
       ; WantedConstraints -> TcS WantedConstraints
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return WantedConstraints
wc }

  | Bool
unif_happened
  = Int
-> IntWithInf -> Bool -> WantedConstraints -> TcS WantedConstraints
simplify_loop Int
n IntWithInf
limit Bool
True WantedConstraints
wc

  | 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 ([Ct]
pending_wanted, Cts
simples1) = Cts -> ([Ct], Cts)
getPendingWantedScs Cts
simples
       ; if [Ct] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Ct]
pending_given Bool -> Bool -> Bool
&& [Ct] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Ct]
pending_wanted
           then WantedConstraints -> TcS WantedConstraints
forall a. a -> TcS a
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_loop Int
n IntWithInf
limit (Bool -> Bool
not ([Ct] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Ct]
pending_given)) (WantedConstraints -> TcS WantedConstraints)
-> WantedConstraints -> TcS WantedConstraints
forall a b. (a -> b) -> a -> b
$
         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 } } }
         -- (not (null pending_given)): see Note [Superclass iteration]

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

{- Note [Superclass iteration]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this implication constraint
    forall a.
       [W] d: C Int beta
       forall b. blah
where
  class D a b | a -> b
  class D a b => C a b
We will expand d's superclasses, giving [W] D Int beta, in the hope of geting
fundeps to unify beta.  Doing so is usually fruitless (no useful fundeps),
and if so it seems a pity to waste time iterating the implications (forall b. blah)
(If we add new Given superclasses it's a different matter: it's really worth looking
at the implications.)

Hence the definitely_redo_implications flag to simplify_loop.  It's usually
True, but False in the case where the only reason to iterate is new Wanted
superclasses.  In that case we check whether the new Wanteds actually led to
any new unifications, and iterate the implications only if so.
-}

solveNestedImplications :: Bag Implication
                        -> TcS (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 (Bag Implication)
solveNestedImplications Bag Implication
implics
  | Bag Implication -> Bool
forall a. Bag a -> Bool
isEmptyBag Bag Implication
implics
  = Bag Implication -> TcS (Bag Implication)
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bag Implication
forall a. Bag a
emptyBag)
  | Bool
otherwise
  = do { String -> SDoc -> TcS ()
traceTcS String
"solveNestedImplications starting {" SDoc
empty
       ; Bag (Maybe Implication)
unsolved_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)
solveImplication Bag Implication
implics

       -- ... 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 String
"solveNestedImplications end }" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
                  [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"unsolved_implics =" SDoc -> SDoc -> SDoc
<+> Bag (Maybe Implication) -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bag (Maybe Implication)
unsolved_implics ]

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

solveImplication :: Implication    -- Wanted
                 -> TcS (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 (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_given :: Implication -> [TcTyVar]
ic_given  = [TcTyVar]
given_ids
                             , ic_wanted :: Implication -> WantedConstraints
ic_wanted = WantedConstraints
wanteds
                             , ic_info :: Implication -> SkolemInfoAnon
ic_info   = SkolemInfoAnon
info
                             , ic_status :: Implication -> ImplicStatus
ic_status = ImplicStatus
status })
  | ImplicStatus -> Bool
isSolvedStatus ImplicStatus
status
  = Maybe Implication -> TcS (Maybe Implication)
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (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 String
"solveImplication {" (Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
imp SDoc -> SDoc -> SDoc
$$ String -> SDoc
text String
"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
       ; (HasGivenEqs
has_given_eqs, Cts
given_insols, WantedConstraints
residual_wanted)
            <- EvBindsVar
-> TcLevel
-> TcS (HasGivenEqs, Cts, WantedConstraints)
-> TcS (HasGivenEqs, Cts, WantedConstraints)
forall a. EvBindsVar -> TcLevel -> TcS a -> TcS a
nestImplicTcS EvBindsVar
ev_binds_var TcLevel
tclvl (TcS (HasGivenEqs, Cts, WantedConstraints)
 -> TcS (HasGivenEqs, Cts, WantedConstraints))
-> TcS (HasGivenEqs, Cts, WantedConstraints)
-> TcS (HasGivenEqs, Cts, WantedConstraints)
forall a b. (a -> b) -> a -> b
$
               do { let loc :: CtLoc
loc    = TcLevel -> SkolemInfoAnon -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
tclvl SkolemInfoAnon
info (Implication -> TcLclEnv
ic_env Implication
imp)
                        givens :: [Ct]
givens = CtLoc -> [TcTyVar] -> [Ct]
mkGivens CtLoc
loc [TcTyVar]
given_ids
                  ; [Ct] -> TcS ()
solveSimpleGivens [Ct]
givens

                  ; WantedConstraints
residual_wanted <- WantedConstraints -> TcS WantedConstraints
solveWanteds WantedConstraints
wanteds

                  ; (HasGivenEqs
has_eqs, Cts
given_insols) <- TcLevel -> TcS (HasGivenEqs, Cts)
getHasGivenEqs TcLevel
tclvl
                        -- Call getHasGivenEqs /after/ solveWanteds, because
                        -- solveWanteds can augment the givens, via expandSuperClasses,
                        -- to reveal given superclass equalities

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

       ; String -> SDoc -> TcS ()
traceTcS String
"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_given_eqs :: HasGivenEqs
ic_given_eqs = HasGivenEqs
has_given_eqs
                                                 , ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints
final_wanted })

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

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

    -- TcLevels must be strictly increasing (see (ImplicInv) in
    -- Note [TcLevel invariants] in GHC.Tc.Utils.TcType),
    -- and in fact I think they 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
                        ; massertPpr (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,
-- setting the ic_status field
-- 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 -> SkolemInfoAnon
ic_info       = SkolemInfoAnon
info
                                    , ic_wanted :: Implication -> WantedConstraints
ic_wanted     = WantedConstraints
wc
                                    , ic_given :: Implication -> [TcTyVar]
ic_given      = [TcTyVar]
givens })
 | Bool -> SDoc -> Bool -> Bool
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (Bool -> Bool
not (ImplicStatus -> Bool
isSolvedStatus ImplicStatus
status)) (SkolemInfoAnon -> SDoc
forall a. Outputable a => a -> SDoc
ppr SkolemInfoAnon
info) (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$
   -- 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 String
"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 String
"setImplicationStatus(not-all-solved) }" (Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
new_implic)

      ; Maybe Implication -> TcS (Maybe Implication)
forall a. a -> TcS a
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 String
"setImplicationStatus(all-solved) {" (Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
implic)

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

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

      ; let ([TcTyVar]
used_givens, [TcTyVar]
unused_givens)
              | SkolemInfoAnon -> Bool
warnRedundantGivens SkolemInfoAnon
info
              = (TcTyVar -> Bool) -> [TcTyVar] -> FunDep TcTyVar
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition (TcTyVar -> VarSet -> Bool
`elemVarSet` VarSet
need_inner) [TcTyVar]
givens
              | Bool
otherwise = ([TcTyVar]
givens, [])   -- None to report

            minimal_used_givens :: [TcTyVar]
minimal_used_givens = (TcTyVar -> Type) -> [TcTyVar] -> [TcTyVar]
forall a. (a -> Type) -> [a] -> [a]
mkMinimalBySCs TcTyVar -> Type
evVarPred [TcTyVar]
used_givens
            is_minimal :: TcTyVar -> Bool
is_minimal = (TcTyVar -> VarSet -> Bool
`elemVarSet` [TcTyVar] -> VarSet
mkVarSet [TcTyVar]
minimal_used_givens)

            warn_givens :: [TcTyVar]
warn_givens
              | Bool -> Bool
not ([TcTyVar] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TcTyVar]
unused_givens) = [TcTyVar]
unused_givens
              | SkolemInfoAnon -> Bool
warnRedundantGivens SkolemInfoAnon
info = (TcTyVar -> Bool) -> [TcTyVar] -> [TcTyVar]
forall a. (a -> Bool) -> [a] -> [a]
filterOut TcTyVar -> Bool
is_minimal [TcTyVar]
used_givens
              | Bool
otherwise                = []

            discard_entire_implication :: Bool
discard_entire_implication  -- Can we discard the entire implication?
              =  [TcTyVar] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TcTyVar]
warn_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
&& VarSet -> Bool
isEmptyVarSet VarSet
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 { ics_dead :: [TcTyVar]
ics_dead = [TcTyVar]
warn_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 String
"setImplicationStatus(all-solved) }" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
        [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"discard:" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
discard_entire_implication
             , String -> SDoc
text String
"new_implic:" SDoc -> SDoc -> SDoc
<+> Implication -> SDoc
forall a. Outputable a => a -> SDoc
ppr Implication
final_implic ]

      ; Maybe Implication -> TcS (Maybe Implication)
forall a. a -> TcS a
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, wc_errors :: WantedConstraints -> Bag DelayedError
wc_errors = Bag DelayedError
errs } = WantedConstraints
wc

   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 { wc_simple :: Cts
wc_simple = Cts
simples
                  , wc_impl :: Bag Implication
wc_impl   = Bag Implication
pruned_implics
                  , wc_errors :: Bag DelayedError
wc_errors = Bag DelayedError
errs }   -- do not prune holes; these should be reported

   keep_me :: Implication -> Bool
   keep_me :: Implication -> Bool
keep_me Implication
ic
     | IC_Solved { ics_dead :: ImplicStatus -> [TcTyVar]
ics_dead = [TcTyVar]
dead_givens } <- Implication -> ImplicStatus
ic_status Implication
ic
                          -- Fully solved
     , [TcTyVar] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TcTyVar]
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 [Checking telescopes] in GHC.Tc.Types.Constraint
checkBadTelescope :: Implication -> TcS Bool
checkBadTelescope (Implic { ic_info :: Implication -> SkolemInfoAnon
ic_info  = SkolemInfoAnon
info
                          , ic_skols :: Implication -> [TcTyVar]
ic_skols = [TcTyVar]
skols })
  | SkolemInfoAnon -> Bool
checkTelescopeSkol SkolemInfoAnon
info
  = do{ [TcTyVar]
skols <- (TcTyVar -> TcS TcTyVar) -> [TcTyVar] -> TcS [TcTyVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM TcTyVar -> TcS TcTyVar
TcS.zonkTyCoVarKind [TcTyVar]
skols
      ; Bool -> TcS Bool
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (VarSet -> [TcTyVar] -> Bool
go VarSet
emptyVarSet ([TcTyVar] -> [TcTyVar]
forall a. [a] -> [a]
reverse [TcTyVar]
skols))}

  | Bool
otherwise
  = Bool -> TcS Bool
forall a. a -> TcS a
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 :: VarSet -> [TcTyVar] -> Bool
go VarSet
_ [] = Bool
False
    go VarSet
later_skols (TcTyVar
one_skol : [TcTyVar]
earlier_skols)
      | Type -> VarSet
tyCoVarsOfType (TcTyVar -> Type
tyVarKind TcTyVar
one_skol) VarSet -> VarSet -> Bool
`intersectsVarSet` VarSet
later_skols
      = Bool
True
      | Bool
otherwise
      = VarSet -> [TcTyVar] -> Bool
go (VarSet
later_skols VarSet -> TcTyVar -> VarSet
`extendVarSet` TcTyVar
one_skol) [TcTyVar]
earlier_skols

warnRedundantGivens :: SkolemInfoAnon -> Bool
warnRedundantGivens :: SkolemInfoAnon -> Bool
warnRedundantGivens (SigSkol UserTypeCtxt
ctxt Type
_ [(Name, TcTyVar)]
_)
  = case UserTypeCtxt
ctxt of
       FunSigCtxt Name
_ ReportRedundantConstraints
rrc -> ReportRedundantConstraints -> Bool
reportRedundantConstraints ReportRedundantConstraints
rrc
       ExprSigCtxt ReportRedundantConstraints
rrc  -> ReportRedundantConstraints -> Bool
reportRedundantConstraints ReportRedundantConstraints
rrc
       UserTypeCtxt
_                -> Bool
False

  -- To think about: do we want to report redundant givens for
  -- pattern synonyms, PatSynSigSkol? c.f #9953, comment:21.
warnRedundantGivens (InstSkol {}) = Bool
True
warnRedundantGivens SkolemInfoAnon
_             = 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 -> [TcTyVar]
ic_given = [TcTyVar]
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 -> VarSet
ic_need_inner = VarSet
old_needs })
 = do { EvBindMap
ev_binds <- EvBindsVar -> TcS EvBindMap
TcS.getTcEvBindsMap EvBindsVar
ev_binds_var
      ; VarSet
tcvs     <- EvBindsVar -> TcS VarSet
TcS.getTcEvTyCoVars EvBindsVar
ev_binds_var

      ; let seeds1 :: VarSet
seeds1        = (Implication -> VarSet -> VarSet)
-> VarSet -> Bag Implication -> VarSet
forall a b. (a -> b -> b) -> b -> Bag a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Implication -> VarSet -> VarSet
add_implic_seeds VarSet
old_needs Bag Implication
implics
            seeds2 :: VarSet
seeds2        = (EvBind -> VarSet -> VarSet) -> VarSet -> EvBindMap -> VarSet
forall a. (EvBind -> a -> a) -> a -> EvBindMap -> a
nonDetStrictFoldEvBindMap EvBind -> VarSet -> VarSet
add_wanted VarSet
seeds1 EvBindMap
ev_binds
                            -- It's OK to use a non-deterministic fold here
                            -- because add_wanted is commutative
            seeds3 :: VarSet
seeds3        = VarSet
seeds2 VarSet -> VarSet -> VarSet
`unionVarSet` VarSet
tcvs
            need_inner :: VarSet
need_inner    = EvBindMap -> VarSet -> VarSet
findNeededEvVars EvBindMap
ev_binds VarSet
seeds3
            live_ev_binds :: EvBindMap
live_ev_binds = (EvBind -> Bool) -> EvBindMap -> EvBindMap
filterEvBindMap (VarSet -> EvBind -> Bool
needed_ev_bind VarSet
need_inner) EvBindMap
ev_binds
            need_outer :: VarSet
need_outer    = VarSet -> EvBindMap -> VarSet
varSetMinusEvBindMap VarSet
need_inner EvBindMap
live_ev_binds
                            VarSet -> [TcTyVar] -> VarSet
`delVarSetList` [TcTyVar]
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 String
"neededEvVars" (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$
        [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"old_needs:" SDoc -> SDoc -> SDoc
<+> VarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr VarSet
old_needs
             , String -> SDoc
text String
"seeds3:" SDoc -> SDoc -> SDoc
<+> VarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr VarSet
seeds3
             , String -> SDoc
text String
"tcvs:" SDoc -> SDoc -> SDoc
<+> VarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr VarSet
tcvs
             , String -> SDoc
text String
"ev_binds:" SDoc -> SDoc -> SDoc
<+> EvBindMap -> SDoc
forall a. Outputable a => a -> SDoc
ppr EvBindMap
ev_binds
             , String -> SDoc
text String
"live_ev_binds:" SDoc -> SDoc -> SDoc
<+> EvBindMap -> SDoc
forall a. Outputable a => a -> SDoc
ppr EvBindMap
live_ev_binds ]

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

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

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

-------------------------------------------------
simplifyDelayedErrors :: Bag DelayedError -> TcS (Bag DelayedError)
simplifyDelayedErrors :: Bag DelayedError -> TcS (Bag DelayedError)
simplifyDelayedErrors = (DelayedError -> TcS DelayedError)
-> Bag DelayedError -> TcS (Bag DelayedError)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bag a -> m (Bag b)
mapBagM DelayedError -> TcS DelayedError
simpl_err
  where
    simpl_err :: DelayedError -> TcS DelayedError
    simpl_err :: DelayedError -> TcS DelayedError
simpl_err (DE_Hole Hole
hole) = Hole -> DelayedError
DE_Hole (Hole -> DelayedError) -> TcS Hole -> TcS DelayedError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Hole -> TcS Hole
simpl_hole Hole
hole
    simpl_err err :: DelayedError
err@(DE_NotConcrete {}) = DelayedError -> TcS DelayedError
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return DelayedError
err

    simpl_hole :: Hole -> TcS Hole

     -- See Note [Do not simplify ConstraintHoles]
    simpl_hole :: Hole -> TcS Hole
simpl_hole h :: Hole
h@(Hole { hole_sort :: Hole -> HoleSort
hole_sort = HoleSort
ConstraintHole }) = Hole -> TcS Hole
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return Hole
h

     -- other wildcards should be simplified for printing
     -- we must do so here, and not in the error-message generation
     -- code, because we have all the givens already set up
    simpl_hole h :: Hole
h@(Hole { hole_ty :: Hole -> Type
hole_ty = Type
ty, hole_loc :: Hole -> CtLoc
hole_loc = CtLoc
loc })
      = do { Type
ty' <- CtLoc -> Type -> TcS Type
rewriteType CtLoc
loc Type
ty
           ; Hole -> TcS Hole
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (Hole
h { hole_ty :: Type
hole_ty = Type
ty' }) }

{- 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 speculatively 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 (#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 expression 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 #15205.

Note [Do not simplify ConstraintHoles]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Before printing the inferred value for a type hole (a _ wildcard in
a partial type signature), we simplify it w.r.t. any Givens. This
makes for an easier-to-understand diagnostic for the user.

However, we do not wish to do this for extra-constraint holes. Here is
the example for why (partial-sigs/should_compile/T12844):

  bar :: _ => FooData rngs
  bar = foo

  data FooData rngs

  class Foo xs where foo :: (Head xs ~ '(r,r')) => FooData xs

  type family Head (xs :: [k]) where Head (x ': xs) = x

GHC correctly infers that the extra-constraints wildcard on `bar`
should be (Head rngs ~ '(r, r'), Foo rngs). It then adds this
constraint as a Given on the implication constraint for `bar`. (This
implication is emitted by emitResidualConstraints.) The Hole for the _
is stored within the implication's WantedConstraints.  When
simplifyHoles is called, that constraint is already assumed as a
Given. Simplifying with respect to it turns it into ('(r, r') ~ '(r,
r'), Foo rngs), which is disastrous.

Furthermore, there is no need to simplify here: extra-constraints wildcards
are filled in with the output of the solver, in chooseInferredQuantifiers
(choose_psig_context), so they are already simplified. (Contrast to normal
type holes, which are just bound to a meta-variable.) Avoiding the poor output
is simple: just don't simplify extra-constraints wildcards.

This is the only reason we need to track ConstraintHole separately
from TypeHole in HoleSort.

See also Note [Extra-constraint holes in partial type signatures]
in GHC.Tc.Gen.HsType.

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.

This is all tested in typecheck/should_compile/T20602 (among
others).

----- 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 not needed by the Wanted constraints covered by the
     implication E.g.
       f :: Eq a => a -> Bool
       f x = True  -- Equality not used
  b) 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

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

*  To find (b), we use mkMinimalBySCs on the Givens to see if any
   are unnecessary.

----- How tracking works

* When two Givens are the same, we drop the evidence for the one
  that requires more superclass selectors. This is done
  according to Note [Replacement vs keeping] in GHC.Tc.Solver.Interact.

* 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, or
    c) it is in the ics_need of a nested implication.

* After computing which variables are needed, we then look at the
  remaining variables for internal redundancies. This is case (b)
  from above. This is also done in setImplicationStatus.
  Note that we only look for case (b) if case (a) shows up empty,
  as exemplified below.

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

* Examples:

    f, g, h :: (Eq a, Ord a) => a -> Bool
    f x = x == x
    g x = x > x
    h x = x == x && x > x

    All three will discover that they have two [G] Eq a constraints:
    one as given and one extracted from the Ord a constraint. They will
    both discard the latter, as noted above and in
    Note [Replacement vs keeping] in GHC.Tc.Solver.Interact.

    The body of f uses the [G] Eq a, but not the [G] Ord a. It will
    report a redundant Ord a using the logic for case (a).

    The body of g uses the [G] Ord a, but not the [G] Eq a. It will
    report a redundant Eq a using the logic for case (a).

    The body of h uses both [G] Ord a and [G] Eq a. Case (a) will
    thus come up with nothing redundant. But then, the case (b)
    check will discover that Eq a is redundant and report this.

    If we did case (b) even when case (a) reports something, then
    we would report both constraints as redundant for f, which is
    terrible.

----- Reporting redundant constraints

* GHC.Tc.Errors does the actual warning, in warnRedundantConstraints.

* We don't report redundant givens for *every* implication; only
  for those which reply True to GHC.Tc.Solver.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
        - GHC.Tc.Gen.Bind.tcSpecPrag
        - GHC.Tc.Gen.Bind.tcTySig

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

----- Shortcomings

Consider

  j :: (Eq a, a ~ b) => a -> Bool
  j x = x == x

  k :: (Eq a, b ~ a) => a -> Bool
  k x = x == x

Currently (Nov 2021), j issues no warning, while k says that b ~ a
is redundant. This is because j uses the a ~ b constraint to rewrite
everything to be in terms of b, while k does none of that. This is
ridiculous, but I (Richard E) don't see a good fix.

-}

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

approximateWC :: Bool -> WantedConstraints -> Cts
-- Second return value is the depleted wc
-- Third return value is YesFDsCombined <=> multiple constraints for the same fundep floated
-- Postcondition: Wanted Cts
-- See Note [ApproximateWC]
-- See Note [floatKindEqualities vs approximateWC]
approximateWC :: Bool -> WantedConstraints -> Cts
approximateWC Bool
float_past_equalities WantedConstraints
wc
  = VarSet -> WantedConstraints -> Cts
float_wc VarSet
emptyVarSet WantedConstraints
wc
  where
    float_wc :: TcTyCoVarSet -> WantedConstraints -> Cts
    float_wc :: VarSet -> WantedConstraints -> Cts
float_wc VarSet
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 (VarSet -> Ct -> Bool
is_floatable VarSet
trapping_tvs) Cts
simples Cts -> Cts -> Cts
forall a. Bag a -> Bag a -> Bag a
`unionBags`
        (Implication -> Cts) -> Bag Implication -> Cts
forall a b. (a -> Bag b) -> Bag a -> Bag b
concatMapBag (VarSet -> Implication -> Cts
float_implic VarSet
trapping_tvs) Bag Implication
implics
    float_implic :: TcTyCoVarSet -> Implication -> Cts
    float_implic :: VarSet -> Implication -> Cts
float_implic VarSet
trapping_tvs Implication
imp
      | Bool
float_past_equalities Bool -> Bool -> Bool
|| Implication -> HasGivenEqs
ic_given_eqs Implication
imp HasGivenEqs -> HasGivenEqs -> Bool
forall a. Eq a => a -> a -> Bool
/= HasGivenEqs
MaybeGivenEqs
      = VarSet -> WantedConstraints -> Cts
float_wc VarSet
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 :: VarSet
new_trapping_tvs = VarSet
trapping_tvs VarSet -> [TcTyVar] -> VarSet
`extendVarSetList` Implication -> [TcTyVar]
ic_skols Implication
imp

    is_floatable :: VarSet -> Ct -> Bool
is_floatable VarSet
skol_tvs Ct
ct
       | Ct -> Bool
isGivenCt Ct
ct     = Bool
False
       | Ct -> Bool
insolubleEqCt Ct
ct = Bool
False
       | Bool
otherwise        = Ct -> VarSet
tyCoVarsOfCt Ct
ct VarSet -> VarSet -> Bool
`disjointVarSet` VarSet
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 might be defaulted.

There is one caveat:

1.  When inferring 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 (#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 #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 (#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 Wanted 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 invariants] in GHC.Tc.Utils.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 #7332.
#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 invariants] in GHC.Tc.Types.TcType.

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)


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

       ; TcGblEnv
tcg_env <- TcS TcGblEnv
TcS.getGblEnv
       ; let plugins :: [FillDefaulting]
plugins = TcGblEnv -> [FillDefaulting]
tcg_defaulting_plugins TcGblEnv
tcg_env

       ; [Bool]
plugin_defaulted <- if [FillDefaulting] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [FillDefaulting]
plugins then [Bool] -> TcS [Bool]
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return [] else
           do {
             ; String -> SDoc -> TcS ()
traceTcS String
"defaultingPlugins {" (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanteds)
             ; [Bool]
defaultedGroups <- (FillDefaulting -> TcS Bool) -> [FillDefaulting] -> TcS [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (WantedConstraints -> FillDefaulting -> TcS Bool
forall {t}. t -> (t -> TcPluginM [DefaultingProposal]) -> TcS Bool
run_defaulting_plugin WantedConstraints
wanteds) [FillDefaulting]
plugins
             ; String -> SDoc -> TcS ()
traceTcS String
"defaultingPlugins }" ([Bool] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Bool]
defaultedGroups)
             ; [Bool] -> TcS [Bool]
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return [Bool]
defaultedGroups
             }

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

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

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

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

       ; Bool -> TcS Bool
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> TcS Bool) -> Bool -> TcS Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
something_happeneds Bool -> Bool -> Bool
|| [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
plugin_defaulted }
    where run_defaulting_plugin :: t -> (t -> TcPluginM [DefaultingProposal]) -> TcS Bool
run_defaulting_plugin t
wanteds t -> TcPluginM [DefaultingProposal]
p =
            do { [DefaultingProposal]
groups <- TcPluginM [DefaultingProposal] -> TcS [DefaultingProposal]
forall a. TcPluginM a -> TcS a
runTcPluginTcS (t -> TcPluginM [DefaultingProposal]
p t
wanteds)
               ; [DefaultingProposal]
defaultedGroups <-
                    (DefaultingProposal -> TcS Bool)
-> [DefaultingProposal] -> TcS [DefaultingProposal]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM (\DefaultingProposal
g -> [Type] -> (TcTyVar, [Ct]) -> TcS Bool
disambigGroup
                                   (DefaultingProposal -> [Type]
deProposalCandidates DefaultingProposal
g)
                                   (DefaultingProposal -> TcTyVar
deProposalTyVar DefaultingProposal
g, DefaultingProposal -> [Ct]
deProposalCts DefaultingProposal
g))
                    [DefaultingProposal]
groups
               ; String -> SDoc -> TcS ()
traceTcS String
"defaultingPlugin " (SDoc -> TcS ()) -> SDoc -> TcS ()
forall a b. (a -> b) -> a -> b
$ [DefaultingProposal] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [DefaultingProposal]
defaultedGroups
               ; case [DefaultingProposal]
defaultedGroups of
                 [] -> Bool -> TcS Bool
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
                 [DefaultingProposal]
_  -> Bool -> TcS Bool
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
               }


findDefaultableGroups
    :: ( [Type]
       , (Bool,Bool) )     -- (Overloaded strings, extended default rules)
    -> WantedConstraints   -- Unsolved
    -> [(TyVar, [Ct])]
findDefaultableGroups :: ([Type], (Bool, Bool)) -> WantedConstraints -> [(TcTyVar, [Ct])]
findDefaultableGroups ([Type]
default_tys, (Bool
ovl_strings, Bool
extended_defaults)) WantedConstraints
wanteds
  | [Type] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Type]
default_tys
  = []
  | Bool
otherwise
  = [ (TcTyVar
tv, ((Ct, Class, TcTyVar) -> Ct) -> [(Ct, Class, TcTyVar)] -> [Ct]
forall a b. (a -> b) -> [a] -> [b]
map (Ct, Class, TcTyVar) -> Ct
forall a b c. (a, b, c) -> a
fstOf3 [(Ct, Class, TcTyVar)]
group)
    | group' :: NonEmpty (Ct, Class, TcTyVar)
group'@((Ct
_,Class
_,TcTyVar
tv) :| [(Ct, Class, TcTyVar)]
_) <- [NonEmpty (Ct, Class, TcTyVar)]
unary_groups
    , let group :: [(Ct, Class, TcTyVar)]
group = NonEmpty (Ct, Class, TcTyVar) -> [(Ct, Class, TcTyVar)]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty (Ct, Class, TcTyVar)
group'
    , TcTyVar -> Bool
defaultable_tyvar TcTyVar
tv
    , [Class] -> Bool
defaultable_classes (((Ct, Class, TcTyVar) -> Class)
-> [(Ct, Class, TcTyVar)] -> [Class]
forall a b. (a -> b) -> [a] -> [b]
map (Ct, Class, TcTyVar) -> Class
forall a b c. (a, b, c) -> b
sndOf3 [(Ct, Class, TcTyVar)]
group) ]
  where
    simples :: Cts
simples                = Bool -> WantedConstraints -> Cts
approximateWC Bool
True WantedConstraints
wanteds
    ([(Ct, Class, TcTyVar)]
unaries, [Ct]
non_unaries) = (Ct -> Either (Ct, Class, TcTyVar) Ct)
-> [Ct] -> ([(Ct, Class, TcTyVar)], [Ct])
forall a b c. (a -> Either b c) -> [a] -> ([b], [c])
partitionWith Ct -> Either (Ct, Class, TcTyVar) Ct
find_unary (Cts -> [Ct]
forall a. Bag a -> [a]
bagToList Cts
simples)
    unary_groups :: [NonEmpty (Ct, Class, TcTyVar)]
unary_groups           = ((Ct, Class, TcTyVar) -> (Ct, Class, TcTyVar) -> Ordering)
-> [(Ct, Class, TcTyVar)] -> [NonEmpty (Ct, Class, TcTyVar)]
forall a. (a -> a -> Ordering) -> [a] -> [NonEmpty a]
equivClasses (Ct, Class, TcTyVar) -> (Ct, Class, TcTyVar) -> Ordering
forall {a} {a} {b} {a} {b}.
Ord a =>
(a, b, a) -> (a, b, a) -> Ordering
cmp_tv [(Ct, Class, TcTyVar)]
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:*))   (#8931)
    find_unary :: Ct -> Either (Ct, Class, TyVar) Ct
    find_unary :: Ct -> Either (Ct, Class, TcTyVar) Ct
find_unary Ct
cc
        | Just (Class
cls,[Type]
tys)   <- Type -> Maybe (Class, [Type])
getClassPredTys_maybe (Ct -> Type
ctPred Ct
cc)
        , [Type
ty] <- TyCon -> [Type] -> [Type]
filterOutInvisibleTypes (Class -> TyCon
classTyCon Class
cls) [Type]
tys
              -- Ignore invisible arguments for this purpose
        , Just TcTyVar
tv <- Type -> Maybe TcTyVar
tcGetTyVar_maybe Type
ty
        , TcTyVar -> Bool
isMetaTyVar TcTyVar
tv  -- We might have runtime-skolems in GHCi, and
                          -- we definitely don't want to try to assign to those!
        = (Ct, Class, TcTyVar) -> Either (Ct, Class, TcTyVar) Ct
forall a b. a -> Either a b
Left (Ct
cc, Class
cls, TcTyVar
tv)
    find_unary Ct
cc = Ct -> Either (Ct, Class, TcTyVar) 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 :: VarSet
bad_tvs = (Ct -> VarSet) -> [Ct] -> VarSet
forall a. (a -> VarSet) -> [a] -> VarSet
mapUnionVarSet Ct -> VarSet
tyCoVarsOfCt [Ct]
non_unaries

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

    defaultable_tyvar :: TcTyVar -> Bool
    defaultable_tyvar :: TcTyVar -> Bool
defaultable_tyvar TcTyVar
tv
        = let b1 :: Bool
b1 = TcTyVar -> Bool
isTyConableTyVar TcTyVar
tv  -- Note [Avoiding spurious errors]
              b2 :: Bool
b2 = Bool -> Bool
not (TcTyVar
tv TcTyVar -> VarSet -> Bool
`elemVarSet` VarSet
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 [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 -XOverloadedStrings is enabled
    is_std_class :: Class -> Bool
is_std_class 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 constraints sharing same type variable
              -> TcS Bool   -- True <=> something happened, reflected in ty_binds

disambigGroup :: [Type] -> (TcTyVar, [Ct]) -> TcS Bool
disambigGroup [] (TcTyVar, [Ct])
_
  = Bool -> TcS Bool
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
disambigGroup (Type
default_ty:[Type]
default_tys) group :: (TcTyVar, [Ct])
group@(TcTyVar
the_tv, [Ct]
wanteds)
  = do { String -> SDoc -> TcS ()
traceTcS String
"disambigGroup {" ([SDoc] -> SDoc
vcat [ Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
default_ty, TcTyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVar
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 { TcTyVar -> Type -> TcS ()
unifyTyVar TcTyVar
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
$ TcTyVar -> [Ct] -> Type -> TcM ()
warnDefaulting TcTyVar
the_tv [Ct]
wanteds Type
default_ty
                ; String -> SDoc -> TcS ()
traceTcS String
"disambigGroup succeeded }" (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
default_ty)
                ; Bool -> TcS Bool
forall a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True }
         else
             -- Failure: try with the next type
             do { String -> SDoc -> TcS ()
traceTcS String
"disambigGroup failed, will try other default types }"
                           (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
default_ty)
                ; [Type] -> (TcTyVar, [Ct]) -> TcS Bool
disambigGroup [Type]
default_tys (TcTyVar, [Ct])
group } }
  where
    try_group :: TcS Bool
try_group
      | Just 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 -> SkolemInfoAnon -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
tc_lvl (SkolemInfo -> SkolemInfoAnon
getSkolemInfo SkolemInfo
HasCallStack => SkolemInfo
unkSkol) TcLclEnv
lcl_env
           -- Equality constraints are possible due to type defaulting plugins
           ; [CtEvidence]
wanted_evs <- [TcS CtEvidence] -> TcS [CtEvidence]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [ CtLoc -> RewriterSet -> Type -> TcS CtEvidence
newWantedNC CtLoc
loc RewriterSet
rewriters Type
pred'
                                    | Ct
wanted <- [Ct]
wanteds
                                    , CtWanted { ctev_pred :: CtEvidence -> Type
ctev_pred = Type
pred
                                               , ctev_rewriters :: CtEvidence -> RewriterSet
ctev_rewriters = RewriterSet
rewriters }
                                        <- CtEvidence -> [CtEvidence]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (Ct -> CtEvidence
ctEvidence Ct
wanted)
                                    , let pred' :: Type
pred' = (() :: Constraint) => TCvSubst -> Type -> Type
TCvSubst -> Type -> Type
substTy TCvSubst
subst Type
pred ]
           ; (WantedConstraints -> Bool) -> TcS WantedConstraints -> TcS Bool
forall a b. (a -> b) -> TcS a -> TcS b
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 a. a -> TcS a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False

    the_ty :: Type
the_ty   = TcTyVar -> Type
mkTyVarTy TcTyVar
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 gratuitous errors on "show []"
isInteractiveClass :: Bool   -- -XOverloadedStrings?
                   -> Class -> Bool
isInteractiveClass :: Bool -> Class -> Bool
isInteractiveClass Bool
ovl_strings Class
cls
    = Bool -> Class -> Bool
isNumClass Bool
ovl_strings Class
cls Bool -> Bool -> Bool
|| (Class -> Unique
classKey Class
cls Unique -> [Unique] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Unique]
interactiveClassKeys)

    -- isNumClass adds IsString to the standard numeric classes,
    -- when -XOverloadedStrings is enabled
isNumClass :: Bool   -- -XOverloadedStrings?
           -> Class -> Bool
isNumClass :: Bool -> Class -> Bool
isNumClass Bool
ovl_strings 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).
-}