{-# LANGUAGE CPP #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}

-- | This module defines types and simple operations over constraints, as used
-- in the type-checker and constraint solver.
module GHC.Tc.Types.Constraint (
        -- QCInst
        QCInst(..), isPendingScInst,

        -- Canonical constraints
        Xi, Ct(..), Cts,
        emptyCts, andCts, andManyCts, pprCts,
        singleCt, listToCts, ctsElts, consCts, snocCts, extendCtsList,
        isEmptyCts,
        isPendingScDict, superClassesMightHelp, getPendingWantedScs,
        isWantedCt, isDerivedCt, isGivenCt,
        isUserTypeErrorCt, getUserTypeErrorMsg,
        ctEvidence, ctLoc, setCtLoc, ctPred, ctFlavour, ctEqRel, ctOrigin,
        ctEvId, mkTcEqPredLikeEv,
        mkNonCanonical, mkNonCanonicalCt, mkGivens,
        mkIrredCt,
        ctEvPred, ctEvLoc, ctEvOrigin, ctEvEqRel,
        ctEvExpr, ctEvTerm, ctEvCoercion, ctEvEvId,
        tyCoVarsOfCt, tyCoVarsOfCts,
        tyCoVarsOfCtList, tyCoVarsOfCtsList,

        CtIrredReason(..), HoleSet, isInsolubleReason,

        CheckTyEqResult, CheckTyEqProblem, cteProblem, cterClearOccursCheck,
        cteOK, cteImpredicative, cteTypeFamily, cteHoleBlocker,
        cteInsolubleOccurs, cteSolubleOccurs, cterSetOccursCheckSoluble,
        cterHasNoProblem, cterHasProblem, cterHasOnlyProblem,
        cterRemoveProblem, cterHasOccursCheck, cterFromKind,

        CanEqLHS(..), canEqLHS_maybe, canEqLHSKind, canEqLHSType,
        eqCanEqLHS,

        Hole(..), HoleSort(..), isOutOfScopeHole,

        WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC,
        isSolvedWC, andWC, unionsWC, mkSimpleWC, mkImplicWC,
        addInsols, dropMisleading, addSimples, addImplics, addHoles,
        tyCoVarsOfWC, dropDerivedWC, dropDerivedSimples,
        tyCoVarsOfWCList, insolubleCt, insolubleEqCt,
        isDroppableCt, insolubleImplic,
        arisesFromGivens,

        Implication(..), implicationPrototype, checkTelescopeSkol,
        ImplicStatus(..), isInsolubleStatus, isSolvedStatus,
        HasGivenEqs(..),
        SubGoalDepth, initialSubGoalDepth, maxSubGoalDepth,
        bumpSubGoalDepth, subGoalDepthExceeded,
        CtLoc(..), ctLocSpan, ctLocEnv, ctLocLevel, ctLocOrigin,
        ctLocTypeOrKind_maybe,
        ctLocDepth, bumpCtLocDepth, isGivenLoc,
        setCtLocOrigin, updateCtLocOrigin, setCtLocEnv, setCtLocSpan,
        pprCtLoc,

        -- CtEvidence
        CtEvidence(..), TcEvDest(..),
        mkKindLoc, toKindLoc, mkGivenLoc,
        isWanted, isGiven, isDerived,
        ctEvRole,

        wrapType,

        CtFlavour(..), ShadowInfo(..), ctFlavourContainsDerived, ctEvFlavour,
        CtFlavourRole, ctEvFlavourRole, ctFlavourRole,
        eqCanRewrite, eqCanRewriteFR, eqMayRewriteFR,
        eqCanDischargeFR,

        -- Pretty printing
        pprEvVarTheta,
        pprEvVars, pprEvVarWithType,

  )
  where

#include "HsVersions.h"

import GHC.Prelude

import {-# SOURCE #-} GHC.Tc.Types ( TcLclEnv, setLclEnvTcLevel, getLclEnvTcLevel
                                   , setLclEnvLoc, getLclEnvLoc )

import GHC.Core.Predicate
import GHC.Core.Type
import GHC.Core.Coercion
import GHC.Core.Class
import GHC.Core.TyCon
import GHC.Types.Var

import GHC.Tc.Utils.TcType
import GHC.Tc.Types.Evidence
import GHC.Tc.Types.Origin

import GHC.Core

import GHC.Core.TyCo.Ppr
import GHC.Types.Name.Occurrence
import GHC.Utils.FV
import GHC.Types.Var.Set
import GHC.Driver.Session
import GHC.Types.Basic

import GHC.Utils.Outputable
import GHC.Types.SrcLoc
import GHC.Data.Bag
import GHC.Utils.Misc
import GHC.Utils.Panic

import Control.Monad ( msum )
import qualified Data.Semigroup ( (<>) )

-- these are for CheckTyEqResult
import Data.Word  ( Word8 )
import Data.List  ( intersperse )



{-
************************************************************************
*                                                                      *
*                       Canonical constraints                          *
*                                                                      *
*   These are the constraints the low-level simplifier works with      *
*                                                                      *
************************************************************************

Note [CEqCan occurs check]
~~~~~~~~~~~~~~~~~~~~~~~~~~
A CEqCan relates a CanEqLHS (a type variable or type family applications) on
its left to an arbitrary type on its right. It is used for rewriting.
Because it is used for rewriting, it would be disastrous if the RHS
were to mention the LHS: this would cause a loop in rewriting.

We thus perform an occurs-check. There is, of course, some subtlety:

* For type variables, the occurs-check looks deeply. This is because
  a CEqCan over a meta-variable is also used to inform unification,
  in GHC.Tc.Solver.Interact.solveByUnification. If the LHS appears
  anywhere, at all, in the RHS, unification will create an infinite
  structure, which is bad.

* For type family applications, the occurs-check is shallow; it looks
  only in places where we might rewrite. (Specifically, it does not
  look in kinds or coercions.) An occurrence of the LHS in, say, an
  RHS coercion is OK, as we do not rewrite in coercions. No loop to
  be found.

  You might also worry about the possibility that a type family
  application LHS doesn't exactly appear in the RHS, but something
  that reduces to the LHS does. Yet that can't happen: the RHS is
  already inert, with all type family redexes reduced. So a simple
  syntactic check is just fine.

The occurs check is performed in GHC.Tc.Utils.Unify.checkTypeEq
and forms condition T3 in Note [Extending the inert equalities]
in GHC.Tc.Solver.Monad.

-}

-- | A 'Xi'-type is one that has been fully rewritten with respect
-- to the inert set; that is, it has been rewritten by the algorithm
-- in GHC.Tc.Solver.Rewrite. (Historical note: 'Xi', for years and years,
-- meant that a type was type-family-free. It does *not* mean this
-- any more.)
type Xi = TcType

type Cts = Bag Ct

data Ct
  -- Atomic canonical constraints
  = CDictCan {  -- e.g.  Num ty
      Ct -> CtEvidence
cc_ev     :: CtEvidence, -- See Note [Ct/evidence invariant]

      Ct -> Class
cc_class  :: Class,
      Ct -> [Xi]
cc_tyargs :: [Xi],   -- cc_tyargs are rewritten w.r.t. inerts, so Xi

      Ct -> Bool
cc_pend_sc :: Bool   -- See Note [The superclass story] in GHC.Tc.Solver.Canonical
                           -- True <=> (a) cc_class has superclasses
                           --          (b) we have not (yet) added those
                           --              superclasses as Givens
    }

  | CIrredCan {  -- These stand for yet-unusable predicates
      cc_ev     :: CtEvidence,   -- See Note [Ct/evidence invariant]
      Ct -> CtIrredReason
cc_reason :: CtIrredReason

        -- For the might-be-soluble case, the ctev_pred of the evidence is
        -- of form   (tv xi1 xi2 ... xin)   with a tyvar at the head
        --      or   (lhs1 ~ ty2)  where the CEqCan    kind invariant (TyEq:K) fails
        -- See Note [CIrredCan constraints]

        -- The definitely-insoluble case is for things like
        --    Int ~ Bool      tycons don't match
        --    a ~ [a]         occurs check
    }

  | CEqCan {  -- CanEqLHS ~ rhs
       -- Invariants:
       --   * See Note [inert_eqs: the inert equalities] in GHC.Tc.Solver.Monad
       --   * Many are checked in checkTypeEq in GHC.Tc.Utils.Unify
       --   * (TyEq:OC) lhs does not occur in rhs (occurs check)
       --               Note [CEqCan occurs check]
       --   * (TyEq:F) rhs has no foralls
       --       (this avoids substituting a forall for the tyvar in other types)
       --   * (TyEq:K) tcTypeKind lhs `tcEqKind` tcTypeKind rhs; Note [Ct kind invariant]
       --   * (TyEq:N) If the equality is representational, rhs has no top-level newtype
       --     See Note [No top-level newtypes on RHS of representational equalities]
       --     in GHC.Tc.Solver.Canonical. (Applies only when constructor of newtype is
       --     in scope.)
       --   * (TyEq:TV) If rhs (perhaps under a cast) is also CanEqLHS, then it is oriented
       --     to give best chance of
       --     unification happening; eg if rhs is touchable then lhs is too
       --     Note [TyVar/TyVar orientation] in GHC.Tc.Utils.Unify
       --   * (TyEq:H) The RHS has no blocking coercion holes. See GHC.Tc.Solver.Canonical
       --     Note [Equalities with incompatible kinds], wrinkle (2)
      cc_ev     :: CtEvidence, -- See Note [Ct/evidence invariant]
      Ct -> CanEqLHS
cc_lhs    :: CanEqLHS,
      Ct -> Xi
cc_rhs    :: Xi,         -- See invariants above

      Ct -> EqRel
cc_eq_rel :: EqRel       -- INVARIANT: cc_eq_rel = ctEvEqRel cc_ev
    }

  | CNonCanonical {        -- See Note [NonCanonical Semantics] in GHC.Tc.Solver.Monad
      cc_ev  :: CtEvidence
    }

  | CQuantCan QCInst       -- A quantified constraint
      -- NB: I expect to make more of the cases in Ct
      --     look like this, with the payload in an
      --     auxiliary type

------------
-- | A 'CanEqLHS' is a type that can appear on the left of a canonical
-- equality: a type variable or exactly-saturated type family application.
data CanEqLHS
  = TyVarLHS TcTyVar
  | TyFamLHS TyCon  -- ^ of the family
             [Xi]   -- ^ exactly saturating the family

instance Outputable CanEqLHS where
  ppr :: CanEqLHS -> SDoc
ppr (TyVarLHS EvVar
tv)              = forall a. Outputable a => a -> SDoc
ppr EvVar
tv
  ppr (TyFamLHS TyCon
fam_tc [Xi]
fam_args) = forall a. Outputable a => a -> SDoc
ppr (TyCon -> [Xi] -> Xi
mkTyConApp TyCon
fam_tc [Xi]
fam_args)

------------
data QCInst  -- A much simplified version of ClsInst
             -- See Note [Quantified constraints] in GHC.Tc.Solver.Canonical
  = QCI { QCInst -> CtEvidence
qci_ev   :: CtEvidence -- Always of type forall tvs. context => ty
                                 -- Always Given
        , QCInst -> [EvVar]
qci_tvs  :: [TcTyVar]  -- The tvs
        , QCInst -> Xi
qci_pred :: TcPredType -- The ty
        , QCInst -> Bool
qci_pend_sc :: Bool    -- Same as cc_pend_sc flag in CDictCan
                                 -- Invariant: True => qci_pred is a ClassPred
    }

instance Outputable QCInst where
  ppr :: QCInst -> SDoc
ppr (QCI { qci_ev :: QCInst -> CtEvidence
qci_ev = CtEvidence
ev }) = forall a. Outputable a => a -> SDoc
ppr CtEvidence
ev

------------
-- | A hole stores the information needed to report diagnostics
-- about holes in terms (unbound identifiers or underscores) or
-- in types (also called wildcards, as used in partial type
-- signatures). See Note [Holes].
data Hole
  = Hole { Hole -> HoleSort
hole_sort :: HoleSort -- ^ What flavour of hole is this?
         , Hole -> OccName
hole_occ  :: OccName  -- ^ The name of this hole
         , Hole -> Xi
hole_ty   :: TcType   -- ^ Type to be printed to the user
                                 -- For expression holes: type of expr
                                 -- For type holes: the missing type
         , Hole -> CtLoc
hole_loc  :: CtLoc    -- ^ Where hole was written
         }
           -- For the hole_loc, we usually only want the TcLclEnv stored within.
           -- Except when we rewrite, where we need a whole location. And this
           -- might get reported to the user if reducing type families in a
           -- hole type loops.


-- | Used to indicate which sort of hole we have.
data HoleSort = ExprHole HoleExprRef
                 -- ^ Either an out-of-scope variable or a "true" hole in an
                 -- expression (TypedHoles).
                 -- The HoleExprRef says where to write the
                 -- the erroring expression for -fdefer-type-errors.
              | TypeHole
                 -- ^ A hole in a type (PartialTypeSignatures)
              | ConstraintHole
                 -- ^ A hole in a constraint, like @f :: (_, Eq a) => ...
                 -- Differentiated from TypeHole because a ConstraintHole
                 -- is simplified differently. See
                 -- Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver.

instance Outputable Hole where
  ppr :: Hole -> SDoc
ppr (Hole { hole_sort :: Hole -> HoleSort
hole_sort = ExprHole HoleExprRef
ref
            , hole_occ :: Hole -> OccName
hole_occ  = OccName
occ
            , hole_ty :: Hole -> Xi
hole_ty   = Xi
ty })
    = SDoc -> SDoc
parens forall a b. (a -> b) -> a -> b
$ (SDoc -> SDoc
braces forall a b. (a -> b) -> a -> b
$ forall a. Outputable a => a -> SDoc
ppr OccName
occ SDoc -> SDoc -> SDoc
<> SDoc
colon SDoc -> SDoc -> SDoc
<> forall a. Outputable a => a -> SDoc
ppr HoleExprRef
ref) SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr Xi
ty
  ppr (Hole { hole_sort :: Hole -> HoleSort
hole_sort = HoleSort
_other
            , hole_occ :: Hole -> OccName
hole_occ  = OccName
occ
            , hole_ty :: Hole -> Xi
hole_ty   = Xi
ty })
    = SDoc -> SDoc
braces forall a b. (a -> b) -> a -> b
$ forall a. Outputable a => a -> SDoc
ppr OccName
occ SDoc -> SDoc -> SDoc
<> SDoc
colon SDoc -> SDoc -> SDoc
<> forall a. Outputable a => a -> SDoc
ppr Xi
ty

instance Outputable HoleSort where
  ppr :: HoleSort -> SDoc
ppr (ExprHole HoleExprRef
ref) = String -> SDoc
text String
"ExprHole:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr HoleExprRef
ref
  ppr HoleSort
TypeHole       = String -> SDoc
text String
"TypeHole"
  ppr HoleSort
ConstraintHole = String -> SDoc
text String
"ConstraintHole"

------------
-- | Used to indicate extra information about why a CIrredCan is irreducible
data CtIrredReason
  = IrredShapeReason
      -- ^ this constraint has a non-canonical shape (e.g. @c Int@, for a variable @c@)

  | HoleBlockerReason HoleSet
     -- ^ this constraint is blocked on the coercion hole(s) listed
     -- See Note [Equalities with incompatible kinds] in GHC.Tc.Solver.Canonical
     -- Wrinkle (4a). Why store the HoleSet? See Wrinkle (2) of that
     -- same Note.
     -- INVARIANT: A HoleBlockerReason constraint is a homogeneous equality whose
     --   left hand side can fit in a CanEqLHS.

  | NonCanonicalReason CheckTyEqResult
   -- ^ an equality where some invariant other than (TyEq:H) of 'CEqCan' is not satisfied;
   -- the 'CheckTyEqResult' states exactly why
   -- INVARIANT: the 'CheckTyEqResult' has some bit set other than cteHoleBlocker

  | ReprEqReason
    -- ^ an equality that cannot be decomposed because it is representational.
    -- Example: @a b ~R# Int@.
    -- These might still be solved later.
    -- INVARIANT: The constraint is a representational equality constraint

  | ShapeMismatchReason
    -- ^ a nominal equality that relates two wholly different types,
    -- like @Int ~# Bool@ or @a b ~# 3@.
    -- INVARIANT: The constraint is a nominal equality constraint

  | AbstractTyConReason
    -- ^ an equality like @T a b c ~ Q d e@ where either @T@ or @Q@
    -- is an abstract type constructor. See Note [Skolem abstract data]
    -- in GHC.Core.TyCon.
    -- INVARIANT: The constraint is an equality constraint between two TyConApps

instance Outputable CtIrredReason where
  ppr :: CtIrredReason -> SDoc
ppr CtIrredReason
IrredShapeReason          = String -> SDoc
text String
"(irred)"
  ppr (HoleBlockerReason HoleSet
holes) = SDoc -> SDoc
parens (String -> SDoc
text String
"blocked on" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr HoleSet
holes)
  ppr (NonCanonicalReason CheckTyEqResult
cter) = forall a. Outputable a => a -> SDoc
ppr CheckTyEqResult
cter
  ppr CtIrredReason
ReprEqReason              = String -> SDoc
text String
"(repr)"
  ppr CtIrredReason
ShapeMismatchReason       = String -> SDoc
text String
"(shape)"
  ppr CtIrredReason
AbstractTyConReason       = String -> SDoc
text String
"(abstc)"

-- | Are we sure that more solving will never solve this constraint?
isInsolubleReason :: CtIrredReason -> Bool
isInsolubleReason :: CtIrredReason -> Bool
isInsolubleReason CtIrredReason
IrredShapeReason          = Bool
False
isInsolubleReason (HoleBlockerReason {})    = Bool
False
isInsolubleReason (NonCanonicalReason CheckTyEqResult
cter) = CheckTyEqResult -> Bool
cterIsInsoluble CheckTyEqResult
cter
isInsolubleReason CtIrredReason
ReprEqReason              = Bool
False
isInsolubleReason CtIrredReason
ShapeMismatchReason       = Bool
True
isInsolubleReason CtIrredReason
AbstractTyConReason       = Bool
True

------------------------------------------------------------------------------
--
-- CheckTyEqResult, defined here because it is stored in a CtIrredReason
--
------------------------------------------------------------------------------

-- | A set of problems in checking the validity of a type equality.
-- See 'checkTypeEq'.
newtype CheckTyEqResult = CTER Word8

-- | No problems in checking the validity of a type equality.
cteOK :: CheckTyEqResult
cteOK :: CheckTyEqResult
cteOK = Word8 -> CheckTyEqResult
CTER forall a. Bits a => a
zeroBits

-- | Check whether a 'CheckTyEqResult' is marked successful.
cterHasNoProblem :: CheckTyEqResult -> Bool
cterHasNoProblem :: CheckTyEqResult -> Bool
cterHasNoProblem (CTER Word8
0) = Bool
True
cterHasNoProblem CheckTyEqResult
_        = Bool
False

-- | An individual problem that might be logged in a 'CheckTyEqResult'
newtype CheckTyEqProblem = CTEP Word8

cteImpredicative, cteTypeFamily, cteHoleBlocker, cteInsolubleOccurs,
  cteSolubleOccurs :: CheckTyEqProblem
cteImpredicative :: CheckTyEqProblem
cteImpredicative   = Word8 -> CheckTyEqProblem
CTEP (forall a. Bits a => Int -> a
bit Int
0)   -- forall or (=>) encountered
cteTypeFamily :: CheckTyEqProblem
cteTypeFamily      = Word8 -> CheckTyEqProblem
CTEP (forall a. Bits a => Int -> a
bit Int
1)   -- type family encountered
cteHoleBlocker :: CheckTyEqProblem
cteHoleBlocker     = Word8 -> CheckTyEqProblem
CTEP (forall a. Bits a => Int -> a
bit Int
2)   -- blocking coercion hole
      -- See Note [Equalities with incompatible kinds] in GHC.Tc.Solver.Canonical
cteInsolubleOccurs :: CheckTyEqProblem
cteInsolubleOccurs = Word8 -> CheckTyEqProblem
CTEP (forall a. Bits a => Int -> a
bit Int
3)   -- occurs-check
cteSolubleOccurs :: CheckTyEqProblem
cteSolubleOccurs   = Word8 -> CheckTyEqProblem
CTEP (forall a. Bits a => Int -> a
bit Int
4)   -- occurs-check under a type function or in a coercion
                                    -- must be one bit to the left of cteInsolubleOccurs
-- See also Note [Insoluble occurs check] in GHC.Tc.Errors

cteProblem :: CheckTyEqProblem -> CheckTyEqResult
cteProblem :: CheckTyEqProblem -> CheckTyEqResult
cteProblem (CTEP Word8
mask) = Word8 -> CheckTyEqResult
CTER Word8
mask

occurs_mask :: Word8
occurs_mask :: Word8
occurs_mask = Word8
insoluble_mask forall a. Bits a => a -> a -> a
.|. Word8
soluble_mask
  where
    CTEP Word8
insoluble_mask = CheckTyEqProblem
cteInsolubleOccurs
    CTEP Word8
soluble_mask   = CheckTyEqProblem
cteSolubleOccurs

-- | Check whether a 'CheckTyEqResult' has a 'CheckTyEqProblem'
cterHasProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool
CTER Word8
bits cterHasProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool
`cterHasProblem` CTEP Word8
mask = (Word8
bits forall a. Bits a => a -> a -> a
.&. Word8
mask) forall a. Eq a => a -> a -> Bool
/= Word8
0

-- | Check whether a 'CheckTyEqResult' has one 'CheckTyEqProblem' and no other
cterHasOnlyProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool
CTER Word8
bits cterHasOnlyProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool
`cterHasOnlyProblem` CTEP Word8
mask = Word8
bits forall a. Eq a => a -> a -> Bool
== Word8
mask

cterRemoveProblem :: CheckTyEqResult -> CheckTyEqProblem -> CheckTyEqResult
cterRemoveProblem :: CheckTyEqResult -> CheckTyEqProblem -> CheckTyEqResult
cterRemoveProblem (CTER Word8
bits) (CTEP Word8
mask) = Word8 -> CheckTyEqResult
CTER (Word8
bits forall a. Bits a => a -> a -> a
.&. forall a. Bits a => a -> a
complement Word8
mask)

cterHasOccursCheck :: CheckTyEqResult -> Bool
cterHasOccursCheck :: CheckTyEqResult -> Bool
cterHasOccursCheck (CTER Word8
bits) = (Word8
bits forall a. Bits a => a -> a -> a
.&. Word8
occurs_mask) forall a. Eq a => a -> a -> Bool
/= Word8
0

cterClearOccursCheck :: CheckTyEqResult -> CheckTyEqResult
cterClearOccursCheck :: CheckTyEqResult -> CheckTyEqResult
cterClearOccursCheck (CTER Word8
bits) = Word8 -> CheckTyEqResult
CTER (Word8
bits forall a. Bits a => a -> a -> a
.&. forall a. Bits a => a -> a
complement Word8
occurs_mask)

-- | Mark a 'CheckTyEqResult' as not having an insoluble occurs-check: any occurs
-- check under a type family or in a representation equality is soluble.
cterSetOccursCheckSoluble :: CheckTyEqResult -> CheckTyEqResult
cterSetOccursCheckSoluble :: CheckTyEqResult -> CheckTyEqResult
cterSetOccursCheckSoluble (CTER Word8
bits)
  = Word8 -> CheckTyEqResult
CTER forall a b. (a -> b) -> a -> b
$ ((Word8
bits forall a. Bits a => a -> a -> a
.&. Word8
insoluble_mask) forall a. Bits a => a -> Int -> a
`shift` Int
1) forall a. Bits a => a -> a -> a
.|. (Word8
bits forall a. Bits a => a -> a -> a
.&. forall a. Bits a => a -> a
complement Word8
insoluble_mask)
  where
    CTEP Word8
insoluble_mask = CheckTyEqProblem
cteInsolubleOccurs

-- | Retain only information about occurs-check failures, because only that
-- matters after recurring into a kind.
cterFromKind :: CheckTyEqResult -> CheckTyEqResult
cterFromKind :: CheckTyEqResult -> CheckTyEqResult
cterFromKind (CTER Word8
bits)
  = Word8 -> CheckTyEqResult
CTER (Word8
bits forall a. Bits a => a -> a -> a
.&. Word8
occurs_mask)

cterIsInsoluble :: CheckTyEqResult -> Bool
cterIsInsoluble :: CheckTyEqResult -> Bool
cterIsInsoluble (CTER Word8
bits) = (Word8
bits forall a. Bits a => a -> a -> a
.&. Word8
mask) forall a. Eq a => a -> a -> Bool
/= Word8
0
  where
    mask :: Word8
mask = Word8
impredicative_mask forall a. Bits a => a -> a -> a
.|. Word8
insoluble_occurs_mask

    CTEP Word8
impredicative_mask    = CheckTyEqProblem
cteImpredicative
    CTEP Word8
insoluble_occurs_mask = CheckTyEqProblem
cteInsolubleOccurs

instance Semigroup CheckTyEqResult where
  CTER Word8
bits1 <> :: CheckTyEqResult -> CheckTyEqResult -> CheckTyEqResult
<> CTER Word8
bits2 = Word8 -> CheckTyEqResult
CTER (Word8
bits1 forall a. Bits a => a -> a -> a
.|. Word8
bits2)
instance Monoid CheckTyEqResult where
  mempty :: CheckTyEqResult
mempty = CheckTyEqResult
cteOK

instance Outputable CheckTyEqResult where
  ppr :: CheckTyEqResult -> SDoc
ppr CheckTyEqResult
cter | CheckTyEqResult -> Bool
cterHasNoProblem CheckTyEqResult
cter = String -> SDoc
text String
"cteOK"
           | Bool
otherwise
           = SDoc -> SDoc
parens forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
fcat forall a b. (a -> b) -> a -> b
$ forall a. a -> [a] -> [a]
intersperse SDoc
vbar forall a b. (a -> b) -> a -> b
$ [SDoc]
set_bits
    where
      all_bits :: [(CheckTyEqProblem, String)]
all_bits = [ (CheckTyEqProblem
cteImpredicative,   String
"cteImpredicative")
                 , (CheckTyEqProblem
cteTypeFamily,      String
"cteTypeFamily")
                 , (CheckTyEqProblem
cteHoleBlocker,     String
"cteHoleBlocker")
                 , (CheckTyEqProblem
cteInsolubleOccurs, String
"cteInsolubleOccurs")
                 , (CheckTyEqProblem
cteSolubleOccurs,   String
"cteSolubleOccurs") ]
      set_bits :: [SDoc]
set_bits = [ String -> SDoc
text String
str
                 | (CheckTyEqProblem
bitmask, String
str) <- [(CheckTyEqProblem, String)]
all_bits
                 , CheckTyEqResult
cter CheckTyEqResult -> CheckTyEqProblem -> Bool
`cterHasProblem` CheckTyEqProblem
bitmask ]

{- Note [CIrredCan constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CIrredCan constraints are used for constraints that are "stuck"
   - we can't solve them (yet)
   - we can't use them to solve other constraints
   - but they may become soluble if we substitute for some
     of the type variables in the constraint

Example 1:  (c Int), where c :: * -> Constraint.  We can't do anything
            with this yet, but if later c := Num, *then* we can solve it

Example 2:  a ~ b, where a :: *, b :: k, where k is a kind variable
            We don't want to use this to substitute 'b' for 'a', in case
            'k' is subsequently unified with (say) *->*, because then
            we'd have ill-kinded types floating about.  Rather we want
            to defer using the equality altogether until 'k' get resolved.

Note [Ct/evidence invariant]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If  ct :: Ct, then extra fields of 'ct' cache precisely the ctev_pred field
of (cc_ev ct), and is fully rewritten wrt the substitution.   Eg for CDictCan,
   ctev_pred (cc_ev ct) = (cc_class ct) (cc_tyargs ct)
This holds by construction; look at the unique place where CDictCan is
built (in GHC.Tc.Solver.Canonical).

In contrast, the type of the evidence *term* (ctev_dest / ctev_evar) in
the evidence may *not* be fully zonked; we are careful not to look at it
during constraint solving. See Note [Evidence field of CtEvidence].

Note [Ct kind invariant]
~~~~~~~~~~~~~~~~~~~~~~~~
CEqCan requires that the kind of the lhs matches the kind
of the rhs. This is necessary because these constraints are used for substitutions
during solving. If the kinds differed, then the substitution would take a well-kinded
type to an ill-kinded one.

Note [Holes]
~~~~~~~~~~~~
This Note explains how GHC tracks *holes*.

A hole represents one of two conditions:
 - A missing bit of an expression. Example: foo x = x + _
 - A missing bit of a type. Example: bar :: Int -> _

What these have in common is that both cause GHC to emit a diagnostic to the
user describing the bit that is left out.

When a hole is encountered, a new entry of type Hole is added to the ambient
WantedConstraints. The type (hole_ty) of the hole is then simplified during
solving (with respect to any Givens in surrounding implications). It is
reported with all the other errors in GHC.Tc.Errors.

For expression holes, the user has the option of deferring errors until runtime
with -fdefer-type-errors. In this case, the hole actually has evidence: this
evidence is an erroring expression that prints an error and crashes at runtime.
The ExprHole variant of holes stores an IORef EvTerm that will contain this evidence;
during constraint generation, this IORef was stored in the HsUnboundVar extension
field by the type checker. The desugarer simply dereferences to get the CoreExpr.

Prior to fixing #17812, we used to invent an Id to hold the erroring
expression, and then bind it during type-checking. But this does not support
levity-polymorphic out-of-scope identifiers. See
typecheck/should_compile/T17812. We thus use the mutable-CoreExpr approach
described above.

You might think that the type in the HoleExprRef is the same as the type of the
hole. However, because the hole type (hole_ty) is rewritten with respect to
givens, this might not be the case. That is, the hole_ty is always (~) to the
type of the HoleExprRef, but they might not be `eqType`. We need the type of the generated
evidence to match what is expected in the context of the hole, and so we must
store these types separately.

Type-level holes have no evidence at all.
-}

mkNonCanonical :: CtEvidence -> Ct
mkNonCanonical :: CtEvidence -> Ct
mkNonCanonical CtEvidence
ev = CNonCanonical { cc_ev :: CtEvidence
cc_ev = CtEvidence
ev }

mkNonCanonicalCt :: Ct -> Ct
mkNonCanonicalCt :: Ct -> Ct
mkNonCanonicalCt Ct
ct = CNonCanonical { cc_ev :: CtEvidence
cc_ev = Ct -> CtEvidence
cc_ev Ct
ct }

mkIrredCt :: CtIrredReason -> CtEvidence -> Ct
mkIrredCt :: CtIrredReason -> CtEvidence -> Ct
mkIrredCt CtIrredReason
reason CtEvidence
ev = CIrredCan { cc_ev :: CtEvidence
cc_ev = CtEvidence
ev, cc_reason :: CtIrredReason
cc_reason = CtIrredReason
reason }

mkGivens :: CtLoc -> [EvId] -> [Ct]
mkGivens :: CtLoc -> [EvVar] -> [Ct]
mkGivens CtLoc
loc [EvVar]
ev_ids
  = forall a b. (a -> b) -> [a] -> [b]
map EvVar -> Ct
mk [EvVar]
ev_ids
  where
    mk :: EvVar -> Ct
mk EvVar
ev_id = CtEvidence -> Ct
mkNonCanonical (CtGiven { ctev_evar :: EvVar
ctev_evar = EvVar
ev_id
                                       , ctev_pred :: Xi
ctev_pred = EvVar -> Xi
evVarPred EvVar
ev_id
                                       , ctev_loc :: CtLoc
ctev_loc = CtLoc
loc })

ctEvidence :: Ct -> CtEvidence
ctEvidence :: Ct -> CtEvidence
ctEvidence (CQuantCan (QCI { qci_ev :: QCInst -> CtEvidence
qci_ev = CtEvidence
ev })) = CtEvidence
ev
ctEvidence Ct
ct = Ct -> CtEvidence
cc_ev Ct
ct

ctLoc :: Ct -> CtLoc
ctLoc :: Ct -> CtLoc
ctLoc = CtEvidence -> CtLoc
ctEvLoc forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtEvidence
ctEvidence

setCtLoc :: Ct -> CtLoc -> Ct
setCtLoc :: Ct -> CtLoc -> Ct
setCtLoc Ct
ct CtLoc
loc = Ct
ct { cc_ev :: CtEvidence
cc_ev = (Ct -> CtEvidence
cc_ev Ct
ct) { ctev_loc :: CtLoc
ctev_loc = CtLoc
loc } }

ctOrigin :: Ct -> CtOrigin
ctOrigin :: Ct -> CtOrigin
ctOrigin = CtLoc -> CtOrigin
ctLocOrigin forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtLoc
ctLoc

ctPred :: Ct -> PredType
-- See Note [Ct/evidence invariant]
ctPred :: Ct -> Xi
ctPred Ct
ct = CtEvidence -> Xi
ctEvPred (Ct -> CtEvidence
ctEvidence Ct
ct)

ctEvId :: Ct -> EvVar
-- The evidence Id for this Ct
ctEvId :: Ct -> EvVar
ctEvId Ct
ct = CtEvidence -> EvVar
ctEvEvId (Ct -> CtEvidence
ctEvidence Ct
ct)

-- | Makes a new equality predicate with the same role as the given
-- evidence.
mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType
mkTcEqPredLikeEv :: CtEvidence -> Xi -> Xi -> Xi
mkTcEqPredLikeEv CtEvidence
ev
  = case Xi -> EqRel
predTypeEqRel Xi
pred of
      EqRel
NomEq  -> Xi -> Xi -> Xi
mkPrimEqPred
      EqRel
ReprEq -> Xi -> Xi -> Xi
mkReprPrimEqPred
  where
    pred :: Xi
pred = CtEvidence -> Xi
ctEvPred CtEvidence
ev

-- | Get the flavour of the given 'Ct'
ctFlavour :: Ct -> CtFlavour
ctFlavour :: Ct -> CtFlavour
ctFlavour = CtEvidence -> CtFlavour
ctEvFlavour forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtEvidence
ctEvidence

-- | Get the equality relation for the given 'Ct'
ctEqRel :: Ct -> EqRel
ctEqRel :: Ct -> EqRel
ctEqRel = CtEvidence -> EqRel
ctEvEqRel forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtEvidence
ctEvidence

instance Outputable Ct where
  ppr :: Ct -> SDoc
ppr Ct
ct = forall a. Outputable a => a -> SDoc
ppr (Ct -> CtEvidence
ctEvidence Ct
ct) SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
parens SDoc
pp_sort
    where
      pp_sort :: SDoc
pp_sort = case Ct
ct of
         CEqCan {}        -> String -> SDoc
text String
"CEqCan"
         CNonCanonical {} -> String -> SDoc
text String
"CNonCanonical"
         CDictCan { cc_pend_sc :: Ct -> Bool
cc_pend_sc = Bool
pend_sc }
            | Bool
pend_sc   -> String -> SDoc
text String
"CDictCan(psc)"
            | Bool
otherwise -> String -> SDoc
text String
"CDictCan"
         CIrredCan { cc_reason :: Ct -> CtIrredReason
cc_reason = CtIrredReason
reason } -> String -> SDoc
text String
"CIrredCan" SDoc -> SDoc -> SDoc
<> forall a. Outputable a => a -> SDoc
ppr CtIrredReason
reason
         CQuantCan (QCI { qci_pend_sc :: QCInst -> Bool
qci_pend_sc = Bool
pend_sc })
            | Bool
pend_sc   -> String -> SDoc
text String
"CQuantCan(psc)"
            | Bool
otherwise -> String -> SDoc
text String
"CQuantCan"

-----------------------------------
-- | Is a type a canonical LHS? That is, is it a tyvar or an exactly-saturated
-- type family application?
-- Does not look through type synonyms.
canEqLHS_maybe :: Xi -> Maybe CanEqLHS
canEqLHS_maybe :: Xi -> Maybe CanEqLHS
canEqLHS_maybe Xi
xi
  | Just EvVar
tv <- Xi -> Maybe EvVar
tcGetTyVar_maybe Xi
xi
  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ EvVar -> CanEqLHS
TyVarLHS EvVar
tv

  | Just (TyCon
tc, [Xi]
args) <- HasCallStack => Xi -> Maybe (TyCon, [Xi])
tcSplitTyConApp_maybe Xi
xi
  , TyCon -> Bool
isTypeFamilyTyCon TyCon
tc
  , [Xi]
args forall a. [a] -> Int -> Bool
`lengthIs` TyCon -> Int
tyConArity TyCon
tc
  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ TyCon -> [Xi] -> CanEqLHS
TyFamLHS TyCon
tc [Xi]
args

  | Bool
otherwise
  = forall a. Maybe a
Nothing

-- | Convert a 'CanEqLHS' back into a 'Type'
canEqLHSType :: CanEqLHS -> TcType
canEqLHSType :: CanEqLHS -> Xi
canEqLHSType (TyVarLHS EvVar
tv) = EvVar -> Xi
mkTyVarTy EvVar
tv
canEqLHSType (TyFamLHS TyCon
fam_tc [Xi]
fam_args) = TyCon -> [Xi] -> Xi
mkTyConApp TyCon
fam_tc [Xi]
fam_args

-- | Retrieve the kind of a 'CanEqLHS'
canEqLHSKind :: CanEqLHS -> TcKind
canEqLHSKind :: CanEqLHS -> Xi
canEqLHSKind (TyVarLHS EvVar
tv) = EvVar -> Xi
tyVarKind EvVar
tv
canEqLHSKind (TyFamLHS TyCon
fam_tc [Xi]
fam_args) = HasDebugCallStack => Xi -> [Xi] -> Xi
piResultTys (TyCon -> Xi
tyConKind TyCon
fam_tc) [Xi]
fam_args

-- | Are two 'CanEqLHS's equal?
eqCanEqLHS :: CanEqLHS -> CanEqLHS -> Bool
eqCanEqLHS :: CanEqLHS -> CanEqLHS -> Bool
eqCanEqLHS (TyVarLHS EvVar
tv1) (TyVarLHS EvVar
tv2) = EvVar
tv1 forall a. Eq a => a -> a -> Bool
== EvVar
tv2
eqCanEqLHS (TyFamLHS TyCon
fam_tc1 [Xi]
fam_args1) (TyFamLHS TyCon
fam_tc2 [Xi]
fam_args2)
  = TyCon -> [Xi] -> TyCon -> [Xi] -> Bool
tcEqTyConApps TyCon
fam_tc1 [Xi]
fam_args1 TyCon
fam_tc2 [Xi]
fam_args2
eqCanEqLHS CanEqLHS
_ CanEqLHS
_ = Bool
False

{-
************************************************************************
*                                                                      *
        Simple functions over evidence variables
*                                                                      *
************************************************************************
-}

---------------- Getting free tyvars -------------------------

-- | Returns free variables of constraints as a non-deterministic set
tyCoVarsOfCt :: Ct -> TcTyCoVarSet
tyCoVarsOfCt :: Ct -> TcTyCoVarSet
tyCoVarsOfCt = FV -> TcTyCoVarSet
fvVarSet forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> FV
tyCoFVsOfCt

-- | Returns free variables of constraints as a deterministically ordered.
-- list. See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoVarsOfCtList :: Ct -> [TcTyCoVar]
tyCoVarsOfCtList :: Ct -> [EvVar]
tyCoVarsOfCtList = FV -> [EvVar]
fvVarList forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> FV
tyCoFVsOfCt

-- | Returns free variables of constraints as a composable FV computation.
-- See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoFVsOfCt :: Ct -> FV
tyCoFVsOfCt :: Ct -> FV
tyCoFVsOfCt Ct
ct = Xi -> FV
tyCoFVsOfType (Ct -> Xi
ctPred Ct
ct)
  -- This must consult only the ctPred, so that it gets *tidied* fvs if the
  -- constraint has been tidied. Tidying a constraint does not tidy the
  -- fields of the Ct, only the predicate in the CtEvidence.

-- | Returns free variables of a bag of constraints as a non-deterministic
-- set. See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoVarsOfCts :: Cts -> TcTyCoVarSet
tyCoVarsOfCts :: Cts -> TcTyCoVarSet
tyCoVarsOfCts = FV -> TcTyCoVarSet
fvVarSet forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cts -> FV
tyCoFVsOfCts

-- | Returns free variables of a bag of constraints as a deterministically
-- ordered list. See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoVarsOfCtsList :: Cts -> [TcTyCoVar]
tyCoVarsOfCtsList :: Cts -> [EvVar]
tyCoVarsOfCtsList = FV -> [EvVar]
fvVarList forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cts -> FV
tyCoFVsOfCts

-- | Returns free variables of a bag of constraints as a composable FV
-- computation. See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoFVsOfCts :: Cts -> FV
tyCoFVsOfCts :: Cts -> FV
tyCoFVsOfCts = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (FV -> FV -> FV
unionFV forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> FV
tyCoFVsOfCt) FV
emptyFV

-- | Returns free variables of WantedConstraints as a non-deterministic
-- set. See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet
-- Only called on *zonked* things
tyCoVarsOfWC :: WantedConstraints -> TcTyCoVarSet
tyCoVarsOfWC = FV -> TcTyCoVarSet
fvVarSet forall b c a. (b -> c) -> (a -> b) -> a -> c
. WantedConstraints -> FV
tyCoFVsOfWC

-- | Returns free variables of WantedConstraints as a deterministically
-- ordered list. See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar]
-- Only called on *zonked* things
tyCoVarsOfWCList :: WantedConstraints -> [EvVar]
tyCoVarsOfWCList = FV -> [EvVar]
fvVarList forall b c a. (b -> c) -> (a -> b) -> a -> c
. WantedConstraints -> FV
tyCoFVsOfWC

-- | Returns free variables of WantedConstraints as a composable FV
-- computation. See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoFVsOfWC :: WantedConstraints -> FV
-- Only called on *zonked* things
tyCoFVsOfWC :: WantedConstraints -> FV
tyCoFVsOfWC (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simple, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implic, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
holes })
  = Cts -> FV
tyCoFVsOfCts Cts
simple FV -> FV -> FV
`unionFV`
    forall a. (a -> FV) -> Bag a -> FV
tyCoFVsOfBag Implication -> FV
tyCoFVsOfImplic Bag Implication
implic FV -> FV -> FV
`unionFV`
    forall a. (a -> FV) -> Bag a -> FV
tyCoFVsOfBag Hole -> FV
tyCoFVsOfHole Bag Hole
holes

-- | Returns free variables of Implication as a composable FV computation.
-- See Note [Deterministic FV] in "GHC.Utils.FV".
tyCoFVsOfImplic :: Implication -> FV
-- Only called on *zonked* things
tyCoFVsOfImplic :: Implication -> FV
tyCoFVsOfImplic (Implic { ic_skols :: Implication -> [EvVar]
ic_skols = [EvVar]
skols
                        , ic_given :: Implication -> [EvVar]
ic_given = [EvVar]
givens
                        , ic_wanted :: Implication -> WantedConstraints
ic_wanted = WantedConstraints
wanted })
  | WantedConstraints -> Bool
isEmptyWC WantedConstraints
wanted
  = FV
emptyFV
  | Bool
otherwise
  = [EvVar] -> FV -> FV
tyCoFVsVarBndrs [EvVar]
skols  forall a b. (a -> b) -> a -> b
$
    [EvVar] -> FV -> FV
tyCoFVsVarBndrs [EvVar]
givens forall a b. (a -> b) -> a -> b
$
    WantedConstraints -> FV
tyCoFVsOfWC WantedConstraints
wanted

tyCoFVsOfHole :: Hole -> FV
tyCoFVsOfHole :: Hole -> FV
tyCoFVsOfHole (Hole { hole_ty :: Hole -> Xi
hole_ty = Xi
ty }) = Xi -> FV
tyCoFVsOfType Xi
ty

tyCoFVsOfBag :: (a -> FV) -> Bag a -> FV
tyCoFVsOfBag :: forall a. (a -> FV) -> Bag a -> FV
tyCoFVsOfBag a -> FV
tvs_of = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (FV -> FV -> FV
unionFV forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> FV
tvs_of) FV
emptyFV

---------------------------
dropDerivedWC :: WantedConstraints -> WantedConstraints
-- See Note [Dropping derived constraints]
dropDerivedWC :: WantedConstraints -> WantedConstraints
dropDerivedWC wc :: WantedConstraints
wc@(WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples })
  = WantedConstraints
wc { wc_simple :: Cts
wc_simple = Cts -> Cts
dropDerivedSimples Cts
simples }
    -- The wc_impl implications are already (recursively) filtered

--------------------------
dropDerivedSimples :: Cts -> Cts
-- Drop all Derived constraints, but make [W] back into [WD],
-- so that if we re-simplify these constraints we will get all
-- the right derived constraints re-generated.  Forgetting this
-- step led to #12936
dropDerivedSimples :: Cts -> Cts
dropDerivedSimples Cts
simples = forall a b. (a -> Maybe b) -> Bag a -> Bag b
mapMaybeBag Ct -> Maybe Ct
dropDerivedCt Cts
simples

dropDerivedCt :: Ct -> Maybe Ct
dropDerivedCt :: Ct -> Maybe Ct
dropDerivedCt Ct
ct
  = case CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev of
      Wanted ShadowInfo
WOnly -> forall a. a -> Maybe a
Just (Ct
ct' { cc_ev :: CtEvidence
cc_ev = CtEvidence
ev_wd })
      Wanted ShadowInfo
_     -> forall a. a -> Maybe a
Just Ct
ct'
      CtFlavour
_ | Ct -> Bool
isDroppableCt Ct
ct -> forall a. Maybe a
Nothing
        | Bool
otherwise        -> forall a. a -> Maybe a
Just Ct
ct
  where
    ev :: CtEvidence
ev    = Ct -> CtEvidence
ctEvidence Ct
ct
    ev_wd :: CtEvidence
ev_wd = CtEvidence
ev { ctev_nosh :: ShadowInfo
ctev_nosh = ShadowInfo
WDeriv }
    ct' :: Ct
ct'   = Ct -> Ct
setPendingScDict Ct
ct -- See Note [Resetting cc_pend_sc]

{- Note [Resetting cc_pend_sc]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
When we discard Derived constraints, in dropDerivedSimples, we must
set the cc_pend_sc flag to True, so that if we re-process this
CDictCan we will re-generate its derived superclasses. Otherwise
we might miss some fundeps.  #13662 showed this up.

See Note [The superclass story] in GHC.Tc.Solver.Canonical.
-}

isDroppableCt :: Ct -> Bool
isDroppableCt :: Ct -> Bool
isDroppableCt Ct
ct
  = CtEvidence -> Bool
isDerived CtEvidence
ev Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
keep_deriv
    -- Drop only derived constraints, and then only if they
    -- obey Note [Dropping derived constraints]
  where
    ev :: CtEvidence
ev   = Ct -> CtEvidence
ctEvidence Ct
ct
    loc :: CtLoc
loc  = CtEvidence -> CtLoc
ctEvLoc CtEvidence
ev
    orig :: CtOrigin
orig = CtLoc -> CtOrigin
ctLocOrigin CtLoc
loc

    keep_deriv :: Bool
keep_deriv
      = case Ct
ct of
          CIrredCan { cc_reason :: Ct -> CtIrredReason
cc_reason = CtIrredReason
reason } | CtIrredReason -> Bool
isInsolubleReason CtIrredReason
reason -> Bool -> Bool
keep_eq Bool
True
          Ct
_                                                           -> Bool -> Bool
keep_eq Bool
False

    keep_eq :: Bool -> Bool
keep_eq Bool
definitely_insoluble
       | CtOrigin -> Bool
isGivenOrigin CtOrigin
orig    -- Arising only from givens
       = Bool
definitely_insoluble  -- Keep only definitely insoluble
       | Bool
otherwise
       = case CtOrigin
orig of
           -- See Note [Dropping derived constraints]
           -- For fundeps, drop wanted/wanted interactions
           FunDepOrigin2 {} -> Bool
True   -- Top-level/Wanted
           FunDepOrigin1 Xi
_ CtOrigin
orig1 RealSrcSpan
_ Xi
_ CtOrigin
orig2 RealSrcSpan
_
             | Bool
g1 Bool -> Bool -> Bool
|| Bool
g2  -> Bool
True  -- Given/Wanted errors: keep all
             | Bool
otherwise -> Bool
False -- Wanted/Wanted errors: discard
             where
               g1 :: Bool
g1 = CtOrigin -> Bool
isGivenOrigin CtOrigin
orig1
               g2 :: Bool
g2 = CtOrigin -> Bool
isGivenOrigin CtOrigin
orig2

           CtOrigin
_ -> Bool
False

arisesFromGivens :: Ct -> Bool
arisesFromGivens :: Ct -> Bool
arisesFromGivens Ct
ct
  = case Ct -> CtEvidence
ctEvidence Ct
ct of
      CtGiven {}                   -> Bool
True
      CtWanted {}                  -> Bool
False
      CtDerived { ctev_loc :: CtEvidence -> CtLoc
ctev_loc = CtLoc
loc } -> CtLoc -> Bool
isGivenLoc CtLoc
loc

isGivenLoc :: CtLoc -> Bool
isGivenLoc :: CtLoc -> Bool
isGivenLoc CtLoc
loc = CtOrigin -> Bool
isGivenOrigin (CtLoc -> CtOrigin
ctLocOrigin CtLoc
loc)

{- Note [Dropping derived constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In general we discard derived constraints at the end of constraint solving;
see dropDerivedWC.  For example

 * Superclasses: if we have an unsolved [W] (Ord a), we don't want to
   complain about an unsolved [D] (Eq a) as well.

 * If we have [W] a ~ Int, [W] a ~ Bool, improvement will generate
   [D] Int ~ Bool, and we don't want to report that because it's
   incomprehensible. That is why we don't rewrite wanteds with wanteds!

 * We might float out some Wanteds from an implication, leaving behind
   their insoluble Deriveds. For example:

   forall a[2]. [W] alpha[1] ~ Int
                [W] alpha[1] ~ Bool
                [D] Int ~ Bool

   The Derived is insoluble, but we very much want to drop it when floating
   out.

But (tiresomely) we do keep *some* Derived constraints:

 * Type holes are derived constraints, because they have no evidence
   and we want to keep them, so we get the error report

 * We keep most derived equalities arising from functional dependencies
      - Given/Given interactions (subset of FunDepOrigin1):
        The definitely-insoluble ones reflect unreachable code.

        Others not-definitely-insoluble ones like [D] a ~ Int do not
        reflect unreachable code; indeed if fundeps generated proofs, it'd
        be a useful equality.  See #14763.   So we discard them.

      - Given/Wanted interacGiven or Wanted interacting with an
        instance declaration (FunDepOrigin2)

      - Given/Wanted interactions (FunDepOrigin1); see #9612

      - But for Wanted/Wanted interactions we do /not/ want to report an
        error (#13506).  Consider [W] C Int Int, [W] C Int Bool, with
        a fundep on class C.  We don't want to report an insoluble Int~Bool;
        c.f. "wanteds do not rewrite wanteds".

To distinguish these cases we use the CtOrigin.

NB: we keep *all* derived insolubles under some circumstances:

  * They are looked at by simplifyInfer, to decide whether to
    generalise.  Example: [W] a ~ Int, [W] a ~ Bool
    We get [D] Int ~ Bool, and indeed the constraints are insoluble,
    and we want simplifyInfer to see that, even though we don't
    ultimately want to generate an (inexplicable) error message from it


************************************************************************
*                                                                      *
                    CtEvidence
         The "flavor" of a canonical constraint
*                                                                      *
************************************************************************
-}

isWantedCt :: Ct -> Bool
isWantedCt :: Ct -> Bool
isWantedCt = CtEvidence -> Bool
isWanted forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtEvidence
ctEvidence

isGivenCt :: Ct -> Bool
isGivenCt :: Ct -> Bool
isGivenCt = CtEvidence -> Bool
isGiven forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtEvidence
ctEvidence

isDerivedCt :: Ct -> Bool
isDerivedCt :: Ct -> Bool
isDerivedCt = CtEvidence -> Bool
isDerived forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtEvidence
ctEvidence

{- Note [Custom type errors in constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

When GHC reports a type-error about an unsolved-constraint, we check
to see if the constraint contains any custom-type errors, and if so
we report them.  Here are some examples of constraints containing type
errors:

TypeError msg           -- The actual constraint is a type error

TypError msg ~ Int      -- Some type was supposed to be Int, but ended up
                        -- being a type error instead

Eq (TypeError msg)      -- A class constraint is stuck due to a type error

F (TypeError msg) ~ a   -- A type function failed to evaluate due to a type err

It is also possible to have constraints where the type error is nested deeper,
for example see #11990, and also:

Eq (F (TypeError msg))  -- Here the type error is nested under a type-function
                        -- call, which failed to evaluate because of it,
                        -- and so the `Eq` constraint was unsolved.
                        -- This may happen when one function calls another
                        -- and the called function produced a custom type error.
-}

-- | A constraint is considered to be a custom type error, if it contains
-- custom type errors anywhere in it.
-- See Note [Custom type errors in constraints]
getUserTypeErrorMsg :: Ct -> Maybe Type
getUserTypeErrorMsg :: Ct -> Maybe Xi
getUserTypeErrorMsg Ct
ct = Xi -> Maybe Xi
findUserTypeError (Ct -> Xi
ctPred Ct
ct)
  where
  findUserTypeError :: Xi -> Maybe Xi
findUserTypeError Xi
t = forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum ( Xi -> Maybe Xi
userTypeError_maybe Xi
t
                             forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map Xi -> Maybe Xi
findUserTypeError (Xi -> [Xi]
subTys Xi
t)
                             )

  subTys :: Xi -> [Xi]
subTys Xi
t            = case Xi -> (Xi, [Xi])
splitAppTys Xi
t of
                          (Xi
t,[]) ->
                            case HasDebugCallStack => Xi -> Maybe (TyCon, [Xi])
splitTyConApp_maybe Xi
t of
                              Maybe (TyCon, [Xi])
Nothing     -> []
                              Just (TyCon
_,[Xi]
ts) -> [Xi]
ts
                          (Xi
t,[Xi]
ts) -> Xi
t forall a. a -> [a] -> [a]
: [Xi]
ts




isUserTypeErrorCt :: Ct -> Bool
isUserTypeErrorCt :: Ct -> Bool
isUserTypeErrorCt Ct
ct = case Ct -> Maybe Xi
getUserTypeErrorMsg Ct
ct of
                         Just Xi
_ -> Bool
True
                         Maybe Xi
_      -> Bool
False

isPendingScDict :: Ct -> Maybe Ct
-- Says whether this is a CDictCan with cc_pend_sc is True,
-- AND if so flips the flag
isPendingScDict :: Ct -> Maybe Ct
isPendingScDict ct :: Ct
ct@(CDictCan { cc_pend_sc :: Ct -> Bool
cc_pend_sc = Bool
True })
                  = forall a. a -> Maybe a
Just (Ct
ct { cc_pend_sc :: Bool
cc_pend_sc = Bool
False })
isPendingScDict Ct
_ = forall a. Maybe a
Nothing

isPendingScInst :: QCInst -> Maybe QCInst
-- Same as isPendingScDict, but for QCInsts
isPendingScInst :: QCInst -> Maybe QCInst
isPendingScInst qci :: QCInst
qci@(QCI { qci_pend_sc :: QCInst -> Bool
qci_pend_sc = Bool
True })
                  = forall a. a -> Maybe a
Just (QCInst
qci { qci_pend_sc :: Bool
qci_pend_sc = Bool
False })
isPendingScInst QCInst
_ = forall a. Maybe a
Nothing

setPendingScDict :: Ct -> Ct
-- Set the cc_pend_sc flag to True
setPendingScDict :: Ct -> Ct
setPendingScDict ct :: Ct
ct@(CDictCan { cc_pend_sc :: Ct -> Bool
cc_pend_sc = Bool
False })
                    = Ct
ct { cc_pend_sc :: Bool
cc_pend_sc = Bool
True }
setPendingScDict Ct
ct = Ct
ct

superClassesMightHelp :: WantedConstraints -> Bool
-- ^ True if taking superclasses of givens, or of wanteds (to perhaps
-- expose more equalities or functional dependencies) might help to
-- solve this constraint.  See Note [When superclasses help]
superClassesMightHelp :: WantedConstraints -> Bool
superClassesMightHelp (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics })
  = forall a. (a -> Bool) -> Bag a -> Bool
anyBag Ct -> Bool
might_help_ct Cts
simples Bool -> Bool -> Bool
|| forall a. (a -> Bool) -> Bag a -> Bool
anyBag Implication -> Bool
might_help_implic Bag Implication
implics
  where
    might_help_implic :: Implication -> Bool
might_help_implic Implication
ic
       | ImplicStatus
IC_Unsolved <- Implication -> ImplicStatus
ic_status Implication
ic = WantedConstraints -> Bool
superClassesMightHelp (Implication -> WantedConstraints
ic_wanted Implication
ic)
       | Bool
otherwise                   = Bool
False

    might_help_ct :: Ct -> Bool
might_help_ct Ct
ct = Ct -> Bool
isWantedCt Ct
ct Bool -> Bool -> Bool
&& Bool -> Bool
not (Ct -> Bool
is_ip Ct
ct)

    is_ip :: Ct -> Bool
is_ip (CDictCan { cc_class :: Ct -> Class
cc_class = Class
cls }) = Class -> Bool
isIPClass Class
cls
    is_ip Ct
_                             = Bool
False

getPendingWantedScs :: Cts -> ([Ct], Cts)
getPendingWantedScs :: Cts -> ([Ct], Cts)
getPendingWantedScs Cts
simples
  = forall acc x y.
(acc -> x -> (acc, y)) -> acc -> Bag x -> (acc, Bag y)
mapAccumBagL [Ct] -> Ct -> ([Ct], Ct)
get [] Cts
simples
  where
    get :: [Ct] -> Ct -> ([Ct], Ct)
get [Ct]
acc Ct
ct | Just Ct
ct' <- Ct -> Maybe Ct
isPendingScDict Ct
ct
               = (Ct
ct'forall a. a -> [a] -> [a]
:[Ct]
acc, Ct
ct')
               | Bool
otherwise
               = ([Ct]
acc,     Ct
ct)

{- Note [When superclasses help]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
First read Note [The superclass story] in GHC.Tc.Solver.Canonical.

We expand superclasses and iterate only if there is at unsolved wanted
for which expansion of superclasses (e.g. from given constraints)
might actually help. The function superClassesMightHelp tells if
doing this superclass expansion might help solve this constraint.
Note that

  * We look inside implications; maybe it'll help to expand the Givens
    at level 2 to help solve an unsolved Wanted buried inside an
    implication.  E.g.
        forall a. Ord a => forall b. [W] Eq a

  * Superclasses help only for Wanted constraints.  Derived constraints
    are not really "unsolved" and we certainly don't want them to
    trigger superclass expansion. This was a good part of the loop
    in  #11523

  * Even for Wanted constraints, we say "no" for implicit parameters.
    we have [W] ?x::ty, expanding superclasses won't help:
      - Superclasses can't be implicit parameters
      - If we have a [G] ?x:ty2, then we'll have another unsolved
        [D] ty ~ ty2 (from the functional dependency)
        which will trigger superclass expansion.

    It's a bit of a special case, but it's easy to do.  The runtime cost
    is low because the unsolved set is usually empty anyway (errors
    aside), and the first non-implicit-parameter will terminate the search.

    The special case is worth it (#11480, comment:2) because it
    applies to CallStack constraints, which aren't type errors. If we have
       f :: (C a) => blah
       f x = ...undefined...
    we'll get a CallStack constraint.  If that's the only unsolved
    constraint it'll eventually be solved by defaulting.  So we don't
    want to emit warnings about hitting the simplifier's iteration
    limit.  A CallStack constraint really isn't an unsolved
    constraint; it can always be solved by defaulting.
-}

singleCt :: Ct -> Cts
singleCt :: Ct -> Cts
singleCt = forall a. a -> Bag a
unitBag

andCts :: Cts -> Cts -> Cts
andCts :: Cts -> Cts -> Cts
andCts = forall a. Bag a -> Bag a -> Bag a
unionBags

listToCts :: [Ct] -> Cts
listToCts :: [Ct] -> Cts
listToCts = forall a. [a] -> Bag a
listToBag

ctsElts :: Cts -> [Ct]
ctsElts :: Cts -> [Ct]
ctsElts = forall a. Bag a -> [a]
bagToList

consCts :: Ct -> Cts -> Cts
consCts :: Ct -> Cts -> Cts
consCts = forall a. a -> Bag a -> Bag a
consBag

snocCts :: Cts -> Ct -> Cts
snocCts :: Cts -> Ct -> Cts
snocCts = forall a. Bag a -> a -> Bag a
snocBag

extendCtsList :: Cts -> [Ct] -> Cts
extendCtsList :: Cts -> [Ct] -> Cts
extendCtsList Cts
cts [Ct]
xs | forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Ct]
xs   = Cts
cts
                     | Bool
otherwise = Cts
cts forall a. Bag a -> Bag a -> Bag a
`unionBags` forall a. [a] -> Bag a
listToBag [Ct]
xs

andManyCts :: [Cts] -> Cts
andManyCts :: [Cts] -> Cts
andManyCts = forall a. [Bag a] -> Bag a
unionManyBags

emptyCts :: Cts
emptyCts :: Cts
emptyCts = forall a. Bag a
emptyBag

isEmptyCts :: Cts -> Bool
isEmptyCts :: Cts -> Bool
isEmptyCts = forall a. Bag a -> Bool
isEmptyBag

pprCts :: Cts -> SDoc
pprCts :: Cts -> SDoc
pprCts Cts
cts = [SDoc] -> SDoc
vcat (forall a b. (a -> b) -> [a] -> [b]
map forall a. Outputable a => a -> SDoc
ppr (forall a. Bag a -> [a]
bagToList Cts
cts))

{-
************************************************************************
*                                                                      *
                Wanted constraints
     These are forced to be in GHC.Tc.Types because
           TcLclEnv mentions WantedConstraints
           WantedConstraint mentions CtLoc
           CtLoc mentions ErrCtxt
           ErrCtxt mentions TcM
*                                                                      *
v%************************************************************************
-}

data WantedConstraints
  = WC { WantedConstraints -> Cts
wc_simple :: Cts              -- Unsolved constraints, all wanted
       , WantedConstraints -> Bag Implication
wc_impl   :: Bag Implication
       , WantedConstraints -> Bag Hole
wc_holes  :: Bag Hole
    }

emptyWC :: WantedConstraints
emptyWC :: WantedConstraints
emptyWC = WC { wc_simple :: Cts
wc_simple = forall a. Bag a
emptyBag
             , wc_impl :: Bag Implication
wc_impl   = forall a. Bag a
emptyBag
             , wc_holes :: Bag Hole
wc_holes  = forall a. Bag a
emptyBag }

mkSimpleWC :: [CtEvidence] -> WantedConstraints
mkSimpleWC :: [CtEvidence] -> WantedConstraints
mkSimpleWC [CtEvidence]
cts
  = WantedConstraints
emptyWC { wc_simple :: Cts
wc_simple = forall a. [a] -> Bag a
listToBag (forall a b. (a -> b) -> [a] -> [b]
map CtEvidence -> Ct
mkNonCanonical [CtEvidence]
cts) }

mkImplicWC :: Bag Implication -> WantedConstraints
mkImplicWC :: Bag Implication -> WantedConstraints
mkImplicWC Bag Implication
implic
  = WantedConstraints
emptyWC { wc_impl :: Bag Implication
wc_impl = Bag Implication
implic }

isEmptyWC :: WantedConstraints -> Bool
isEmptyWC :: WantedConstraints -> Bool
isEmptyWC (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
f, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
i, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
holes })
  = forall a. Bag a -> Bool
isEmptyBag Cts
f Bool -> Bool -> Bool
&& forall a. Bag a -> Bool
isEmptyBag Bag Implication
i Bool -> Bool -> Bool
&& forall a. Bag a -> Bool
isEmptyBag Bag Hole
holes

-- | Checks whether a the given wanted constraints are solved, i.e.
-- that there are no simple constraints left and all the implications
-- are solved.
isSolvedWC :: WantedConstraints -> Bool
isSolvedWC :: WantedConstraints -> Bool
isSolvedWC WC {wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
wc_simple, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
wc_impl, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
holes} =
  forall a. Bag a -> Bool
isEmptyBag Cts
wc_simple Bool -> Bool -> Bool
&& forall a. (a -> Bool) -> Bag a -> Bool
allBag (ImplicStatus -> Bool
isSolvedStatus forall b c a. (b -> c) -> (a -> b) -> a -> c
. Implication -> ImplicStatus
ic_status) Bag Implication
wc_impl Bool -> Bool -> Bool
&& forall a. Bag a -> Bool
isEmptyBag Bag Hole
holes

andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints
andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints
andWC (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
f1, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
i1, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
h1 })
      (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
f2, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
i2, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
h2 })
  = WC { wc_simple :: Cts
wc_simple = Cts
f1 forall a. Bag a -> Bag a -> Bag a
`unionBags` Cts
f2
       , wc_impl :: Bag Implication
wc_impl   = Bag Implication
i1 forall a. Bag a -> Bag a -> Bag a
`unionBags` Bag Implication
i2
       , wc_holes :: Bag Hole
wc_holes  = Bag Hole
h1 forall a. Bag a -> Bag a -> Bag a
`unionBags` Bag Hole
h2 }

unionsWC :: [WantedConstraints] -> WantedConstraints
unionsWC :: [WantedConstraints] -> WantedConstraints
unionsWC = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr WantedConstraints -> WantedConstraints -> WantedConstraints
andWC WantedConstraints
emptyWC

addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints
addSimples :: WantedConstraints -> Cts -> WantedConstraints
addSimples WantedConstraints
wc Cts
cts
  = WantedConstraints
wc { wc_simple :: Cts
wc_simple = WantedConstraints -> Cts
wc_simple WantedConstraints
wc forall a. Bag a -> Bag a -> Bag a
`unionBags` Cts
cts }
    -- Consider: Put the new constraints at the front, so they get solved first

addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints
addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints
addImplics WantedConstraints
wc Bag Implication
implic = WantedConstraints
wc { wc_impl :: Bag Implication
wc_impl = WantedConstraints -> Bag Implication
wc_impl WantedConstraints
wc forall a. Bag a -> Bag a -> Bag a
`unionBags` Bag Implication
implic }

addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints
addInsols :: WantedConstraints -> Cts -> WantedConstraints
addInsols WantedConstraints
wc Cts
cts
  = WantedConstraints
wc { wc_simple :: Cts
wc_simple = WantedConstraints -> Cts
wc_simple WantedConstraints
wc forall a. Bag a -> Bag a -> Bag a
`unionBags` Cts
cts }

addHoles :: WantedConstraints -> Bag Hole -> WantedConstraints
addHoles :: WantedConstraints -> Bag Hole -> WantedConstraints
addHoles WantedConstraints
wc Bag Hole
holes
  = WantedConstraints
wc { wc_holes :: Bag Hole
wc_holes = Bag Hole
holes forall a. Bag a -> Bag a -> Bag a
`unionBags` WantedConstraints -> Bag Hole
wc_holes WantedConstraints
wc }

dropMisleading :: WantedConstraints -> WantedConstraints
-- Drop misleading constraints; really just class constraints
-- See Note [Constraints and errors] in GHC.Tc.Utils.Monad
--   for why this function is so strange, treating the 'simples'
--   and the implications differently.  Sigh.
dropMisleading :: WantedConstraints -> WantedConstraints
dropMisleading (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
holes })
  = WC { wc_simple :: Cts
wc_simple = forall a. (a -> Bool) -> Bag a -> Bag a
filterBag Ct -> Bool
insolubleCt Cts
simples
       , wc_impl :: Bag Implication
wc_impl   = forall a b. (a -> b) -> Bag a -> Bag b
mapBag Implication -> Implication
drop_implic Bag Implication
implics
       , wc_holes :: Bag Hole
wc_holes  = forall a. (a -> Bool) -> Bag a -> Bag a
filterBag Hole -> Bool
isOutOfScopeHole Bag Hole
holes }
  where
    drop_implic :: Implication -> Implication
drop_implic Implication
implic
      = Implication
implic { ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints -> WantedConstraints
drop_wanted (Implication -> WantedConstraints
ic_wanted Implication
implic) }
    drop_wanted :: WantedConstraints -> WantedConstraints
drop_wanted (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
holes })
      = WC { wc_simple :: Cts
wc_simple = forall a. (a -> Bool) -> Bag a -> Bag a
filterBag Ct -> Bool
keep_ct Cts
simples
           , wc_impl :: Bag Implication
wc_impl   = forall a b. (a -> b) -> Bag a -> Bag b
mapBag Implication -> Implication
drop_implic Bag Implication
implics
           , wc_holes :: Bag Hole
wc_holes  = forall a. (a -> Bool) -> Bag a -> Bag a
filterBag Hole -> Bool
isOutOfScopeHole Bag Hole
holes }

    keep_ct :: Ct -> Bool
keep_ct Ct
ct = case Xi -> Pred
classifyPredType (Ct -> Xi
ctPred Ct
ct) of
                    ClassPred {} -> Bool
False
                    Pred
_ -> Bool
True

isSolvedStatus :: ImplicStatus -> Bool
isSolvedStatus :: ImplicStatus -> Bool
isSolvedStatus (IC_Solved {}) = Bool
True
isSolvedStatus ImplicStatus
_              = Bool
False

isInsolubleStatus :: ImplicStatus -> Bool
isInsolubleStatus :: ImplicStatus -> Bool
isInsolubleStatus ImplicStatus
IC_Insoluble    = Bool
True
isInsolubleStatus ImplicStatus
IC_BadTelescope = Bool
True
isInsolubleStatus ImplicStatus
_               = Bool
False

insolubleImplic :: Implication -> Bool
insolubleImplic :: Implication -> Bool
insolubleImplic Implication
ic = ImplicStatus -> Bool
isInsolubleStatus (Implication -> ImplicStatus
ic_status Implication
ic)

insolubleWC :: WantedConstraints -> Bool
insolubleWC :: WantedConstraints -> Bool
insolubleWC (WC { wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics, wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
holes })
  =  forall a. (a -> Bool) -> Bag a -> Bool
anyBag Ct -> Bool
insolubleCt Cts
simples
  Bool -> Bool -> Bool
|| forall a. (a -> Bool) -> Bag a -> Bool
anyBag Implication -> Bool
insolubleImplic Bag Implication
implics
  Bool -> Bool -> Bool
|| forall a. (a -> Bool) -> Bag a -> Bool
anyBag Hole -> Bool
isOutOfScopeHole Bag Hole
holes  -- See Note [Insoluble holes]

insolubleCt :: Ct -> Bool
-- Definitely insoluble, in particular /excluding/ type-hole constraints
-- Namely: a) an equality constraint
--         b) that is insoluble
--         c) and does not arise from a Given
insolubleCt :: Ct -> Bool
insolubleCt Ct
ct
  | Bool -> Bool
not (Ct -> Bool
insolubleEqCt Ct
ct) = Bool
False
  | Ct -> Bool
arisesFromGivens Ct
ct    = Bool
False              -- See Note [Given insolubles]
  | Bool
otherwise              = Bool
True

insolubleEqCt :: Ct -> Bool
-- Returns True of /equality/ constraints
-- that are /definitely/ insoluble
-- It won't detect some definite errors like
--       F a ~ T (F a)
-- where F is a type family, which actually has an occurs check
--
-- The function is tuned for application /after/ constraint solving
--       i.e. assuming canonicalisation has been done
-- E.g.  It'll reply True  for     a ~ [a]
--               but False for   [a] ~ a
-- and
--                   True for  Int ~ F a Int
--               but False for  Maybe Int ~ F a Int Int
--               (where F is an arity-1 type function)
insolubleEqCt :: Ct -> Bool
insolubleEqCt (CIrredCan { cc_reason :: Ct -> CtIrredReason
cc_reason = CtIrredReason
reason }) = CtIrredReason -> Bool
isInsolubleReason CtIrredReason
reason
insolubleEqCt Ct
_                                  = Bool
False

-- | Does this hole represent an "out of scope" error?
-- See Note [Insoluble holes]
isOutOfScopeHole :: Hole -> Bool
isOutOfScopeHole :: Hole -> Bool
isOutOfScopeHole (Hole { hole_occ :: Hole -> OccName
hole_occ = OccName
occ }) = Bool -> Bool
not (OccName -> Bool
startsWithUnderscore OccName
occ)

instance Outputable WantedConstraints where
  ppr :: WantedConstraints -> SDoc
ppr (WC {wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
s, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
i, wc_holes :: WantedConstraints -> Bag Hole
wc_holes = Bag Hole
h})
   = String -> SDoc
text String
"WC" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
braces ([SDoc] -> SDoc
vcat
        [ forall a. Outputable a => SDoc -> Bag a -> SDoc
ppr_bag (String -> SDoc
text String
"wc_simple") Cts
s
        , forall a. Outputable a => SDoc -> Bag a -> SDoc
ppr_bag (String -> SDoc
text String
"wc_impl") Bag Implication
i
        , forall a. Outputable a => SDoc -> Bag a -> SDoc
ppr_bag (String -> SDoc
text String
"wc_holes") Bag Hole
h ])

ppr_bag :: Outputable a => SDoc -> Bag a -> SDoc
ppr_bag :: forall a. Outputable a => SDoc -> Bag a -> SDoc
ppr_bag SDoc
doc Bag a
bag
 | forall a. Bag a -> Bool
isEmptyBag Bag a
bag = SDoc
empty
 | Bool
otherwise      = SDoc -> Int -> SDoc -> SDoc
hang (SDoc
doc SDoc -> SDoc -> SDoc
<+> SDoc
equals)
                       Int
2 (forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (SDoc -> SDoc -> SDoc
($$) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Outputable a => a -> SDoc
ppr) SDoc
empty Bag a
bag)

{- Note [Given insolubles]
~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider (#14325, comment:)
    class (a~b) => C a b

    foo :: C a c => a -> c
    foo x = x

    hm3 :: C (f b) b => b -> f b
    hm3 x = foo x

In the RHS of hm3, from the [G] C (f b) b we get the insoluble
[G] f b ~# b.  Then we also get an unsolved [W] C b (f b).
Residual implication looks like
    forall b. C (f b) b => [G] f b ~# b
                           [W] C f (f b)

We do /not/ want to set the implication status to IC_Insoluble,
because that'll suppress reports of [W] C b (f b).  But we
may not report the insoluble [G] f b ~# b either (see Note [Given errors]
in GHC.Tc.Errors), so we may fail to report anything at all!  Yikes.

The same applies to Derived constraints that /arise from/ Givens.
E.g.   f :: (C Int [a]) => blah
where a fundep means we get
       [D] Int ~ [a]
By the same reasoning we must not suppress other errors (#15767)

Bottom line: insolubleWC (called in GHC.Tc.Solver.setImplicationStatus)
             should ignore givens even if they are insoluble.

Note [Insoluble holes]
~~~~~~~~~~~~~~~~~~~~~~
Hole constraints that ARE NOT treated as truly insoluble:
  a) type holes, arising from PartialTypeSignatures,
  b) "true" expression holes arising from TypedHoles

An "expression hole" or "type hole" isn't really an error
at all; it's a report saying "_ :: Int" here.  But an out-of-scope
variable masquerading as expression holes IS treated as truly
insoluble, so that it trumps other errors during error reporting.
Yuk!

************************************************************************
*                                                                      *
                Implication constraints
*                                                                      *
************************************************************************
-}

data Implication
  = Implic {   -- Invariants for a tree of implications:
               -- see TcType Note [TcLevel invariants]

      Implication -> TcLevel
ic_tclvl :: TcLevel,       -- TcLevel of unification variables
                                 -- allocated /inside/ this implication

      Implication -> [EvVar]
ic_skols :: [TcTyVar],     -- Introduced skolems
      Implication -> SkolemInfo
ic_info  :: SkolemInfo,    -- See Note [Skolems in an implication]
                                 -- See Note [Shadowing in a constraint]

      Implication -> [EvVar]
ic_given  :: [EvVar],      -- Given evidence variables
                                 --   (order does not matter)
                                 -- See Invariant (GivenInv) in GHC.Tc.Utils.TcType

      Implication -> HasGivenEqs
ic_given_eqs :: HasGivenEqs,  -- Are there Given equalities here?

      Implication -> Bool
ic_warn_inaccessible :: Bool,
                                 -- True  <=> -Winaccessible-code is enabled
                                 -- at construction. See
                                 -- Note [Avoid -Winaccessible-code when deriving]
                                 -- in GHC.Tc.TyCl.Instance

      Implication -> TcLclEnv
ic_env   :: TcLclEnv,
                                 -- Records the TcLClEnv at the time of creation.
                                 --
                                 -- The TcLclEnv gives the source location
                                 -- and error context for the implication, and
                                 -- hence for all the given evidence variables.

      Implication -> WantedConstraints
ic_wanted :: WantedConstraints,  -- The wanteds
                                       -- See Invariang (WantedInf) in GHC.Tc.Utils.TcType

      Implication -> EvBindsVar
ic_binds  :: EvBindsVar,    -- Points to the place to fill in the
                                  -- abstraction and bindings.

      -- The ic_need fields keep track of which Given evidence
      -- is used by this implication or its children
      -- NB: including stuff used by nested implications that have since
      --     been discarded
      -- See Note [Needed evidence variables]
      Implication -> TcTyCoVarSet
ic_need_inner :: VarSet,    -- Includes all used Given evidence
      Implication -> TcTyCoVarSet
ic_need_outer :: VarSet,    -- Includes only the free Given evidence
                                  --  i.e. ic_need_inner after deleting
                                  --       (a) givens (b) binders of ic_binds

      Implication -> ImplicStatus
ic_status   :: ImplicStatus
    }

implicationPrototype :: Implication
implicationPrototype :: Implication
implicationPrototype
   = Implic { -- These fields must be initialised
              ic_tclvl :: TcLevel
ic_tclvl      = forall a. String -> a
panic String
"newImplic:tclvl"
            , ic_binds :: EvBindsVar
ic_binds      = forall a. String -> a
panic String
"newImplic:binds"
            , ic_info :: SkolemInfo
ic_info       = forall a. String -> a
panic String
"newImplic:info"
            , ic_env :: TcLclEnv
ic_env        = forall a. String -> a
panic String
"newImplic:env"
            , ic_warn_inaccessible :: Bool
ic_warn_inaccessible = forall a. String -> a
panic String
"newImplic:warn_inaccessible"

              -- The rest have sensible default values
            , ic_skols :: [EvVar]
ic_skols      = []
            , ic_given :: [EvVar]
ic_given      = []
            , ic_wanted :: WantedConstraints
ic_wanted     = WantedConstraints
emptyWC
            , ic_given_eqs :: HasGivenEqs
ic_given_eqs  = HasGivenEqs
MaybeGivenEqs
            , ic_status :: ImplicStatus
ic_status     = ImplicStatus
IC_Unsolved
            , ic_need_inner :: TcTyCoVarSet
ic_need_inner = TcTyCoVarSet
emptyVarSet
            , ic_need_outer :: TcTyCoVarSet
ic_need_outer = TcTyCoVarSet
emptyVarSet }

data ImplicStatus
  = IC_Solved     -- All wanteds in the tree are solved, all the way down
       { ImplicStatus -> [EvVar]
ics_dead :: [EvVar] }  -- Subset of ic_given that are not needed
         -- See Note [Tracking redundant constraints] in GHC.Tc.Solver

  | IC_Insoluble  -- At least one insoluble constraint in the tree

  | IC_BadTelescope  -- Solved, but the skolems in the telescope are out of
                     -- dependency order. See Note [Checking telescopes]

  | IC_Unsolved   -- Neither of the above; might go either way

data HasGivenEqs -- See Note [HasGivenEqs]
  = NoGivenEqs      -- Definitely no given equalities,
                    --   except by Note [Let-bound skolems] in GHC.Tc.Solver.Monad
  | LocalGivenEqs   -- Might have Given equalities, but only ones that affect only
                    --   local skolems e.g. forall a b. (a ~ F b) => ...
  | MaybeGivenEqs   -- Might have any kind of Given equalities; no floating out
                    --   is possible.
  deriving HasGivenEqs -> HasGivenEqs -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HasGivenEqs -> HasGivenEqs -> Bool
$c/= :: HasGivenEqs -> HasGivenEqs -> Bool
== :: HasGivenEqs -> HasGivenEqs -> Bool
$c== :: HasGivenEqs -> HasGivenEqs -> Bool
Eq

{- Note [HasGivenEqs]
~~~~~~~~~~~~~~~~~~~~~
The GivenEqs data type describes the Given constraints of an implication constraint:

* NoGivenEqs: definitely no Given equalities, except perhaps let-bound skolems
  which don't count: see Note [Let-bound skolems] in GHC.Tc.Solver.Monad
  Examples: forall a. Eq a => ...
            forall a. (Show a, Num a) => ...
            forall a. a ~ Either Int Bool => ...  -- Let-bound skolem

* LocalGivenEqs: definitely no Given equalities that would affect principal
  types.  But may have equalities that affect only skolems of this implication
  (and hence do not affect princial types)
  Examples: forall a. F a ~ Int => ...
            forall a b. F a ~ G b => ...

* MaybeGivenEqs: may have Given equalities that would affect principal
  types
  Examples: forall. (a ~ b) => ...
            forall a. F a ~ b => ...
            forall a. c a => ...       -- The 'c' might be instantiated to (b ~)
            forall a. C a b => ....
               where class x~y => C a b
               so there is an equality in the superclass of a Given

The HasGivenEqs classifications affect two things:

* Suppressing redundant givens during error reporting; see GHC.Tc.Errors
  Note [Suppress redundant givens during error reporting]

* Floating in approximateWC.

Specifically, here's how it goes:

                 Stops floating    |   Suppresses Givens in errors
                 in approximateWC  |
                 -----------------------------------------------
 NoGivenEqs         NO             |         YES
 LocalGivenEqs      NO             |         NO
 MaybeGivenEqs      YES            |         NO
-}

instance Outputable Implication where
  ppr :: Implication -> SDoc
ppr (Implic { ic_tclvl :: Implication -> TcLevel
ic_tclvl = TcLevel
tclvl, ic_skols :: Implication -> [EvVar]
ic_skols = [EvVar]
skols
              , ic_given :: Implication -> [EvVar]
ic_given = [EvVar]
given, ic_given_eqs :: Implication -> HasGivenEqs
ic_given_eqs = HasGivenEqs
given_eqs
              , ic_wanted :: Implication -> WantedConstraints
ic_wanted = WantedConstraints
wanted, ic_status :: Implication -> ImplicStatus
ic_status = ImplicStatus
status
              , ic_binds :: Implication -> EvBindsVar
ic_binds = EvBindsVar
binds
              , ic_need_inner :: Implication -> TcTyCoVarSet
ic_need_inner = TcTyCoVarSet
need_in, ic_need_outer :: Implication -> TcTyCoVarSet
ic_need_outer = TcTyCoVarSet
need_out
              , ic_info :: Implication -> SkolemInfo
ic_info = SkolemInfo
info })
   = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Implic" SDoc -> SDoc -> SDoc
<+> SDoc
lbrace)
        Int
2 ([SDoc] -> SDoc
sep [ String -> SDoc
text String
"TcLevel =" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr TcLevel
tclvl
               , String -> SDoc
text String
"Skolems =" SDoc -> SDoc -> SDoc
<+> [EvVar] -> SDoc
pprTyVars [EvVar]
skols
               , String -> SDoc
text String
"Given-eqs =" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr HasGivenEqs
given_eqs
               , String -> SDoc
text String
"Status =" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr ImplicStatus
status
               , SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Given =")  Int
2 ([EvVar] -> SDoc
pprEvVars [EvVar]
given)
               , SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Wanted =") Int
2 (forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanted)
               , String -> SDoc
text String
"Binds =" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr EvBindsVar
binds
               , SDoc -> SDoc
whenPprDebug (String -> SDoc
text String
"Needed inner =" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr TcTyCoVarSet
need_in)
               , SDoc -> SDoc
whenPprDebug (String -> SDoc
text String
"Needed outer =" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr TcTyCoVarSet
need_out)
               , SkolemInfo -> SDoc
pprSkolInfo SkolemInfo
info ] SDoc -> SDoc -> SDoc
<+> SDoc
rbrace)

instance Outputable ImplicStatus where
  ppr :: ImplicStatus -> SDoc
ppr ImplicStatus
IC_Insoluble    = String -> SDoc
text String
"Insoluble"
  ppr ImplicStatus
IC_BadTelescope = String -> SDoc
text String
"Bad telescope"
  ppr ImplicStatus
IC_Unsolved     = String -> SDoc
text String
"Unsolved"
  ppr (IC_Solved { ics_dead :: ImplicStatus -> [EvVar]
ics_dead = [EvVar]
dead })
    = String -> SDoc
text String
"Solved" SDoc -> SDoc -> SDoc
<+> (SDoc -> SDoc
braces (String -> SDoc
text String
"Dead givens =" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr [EvVar]
dead))

checkTelescopeSkol :: SkolemInfo -> Bool
-- See Note [Checking telescopes]
checkTelescopeSkol :: SkolemInfo -> Bool
checkTelescopeSkol (ForAllSkol {}) = Bool
True
checkTelescopeSkol SkolemInfo
_               = Bool
False

instance Outputable HasGivenEqs where
  ppr :: HasGivenEqs -> SDoc
ppr HasGivenEqs
NoGivenEqs    = String -> SDoc
text String
"NoGivenEqs"
  ppr HasGivenEqs
LocalGivenEqs = String -> SDoc
text String
"LocalGivenEqs"
  ppr HasGivenEqs
MaybeGivenEqs = String -> SDoc
text String
"MaybeGivenEqs"

-- Used in GHC.Tc.Solver.Monad.getHasGivenEqs
instance Semigroup HasGivenEqs where
  HasGivenEqs
NoGivenEqs <> :: HasGivenEqs -> HasGivenEqs -> HasGivenEqs
<> HasGivenEqs
other = HasGivenEqs
other
  HasGivenEqs
other <> HasGivenEqs
NoGivenEqs = HasGivenEqs
other

  HasGivenEqs
MaybeGivenEqs <> HasGivenEqs
_other = HasGivenEqs
MaybeGivenEqs
  HasGivenEqs
_other <> HasGivenEqs
MaybeGivenEqs = HasGivenEqs
MaybeGivenEqs

  HasGivenEqs
LocalGivenEqs <> HasGivenEqs
LocalGivenEqs = HasGivenEqs
LocalGivenEqs

-- Used in GHC.Tc.Solver.Monad.getHasGivenEqs
instance Monoid HasGivenEqs where
  mempty :: HasGivenEqs
mempty = HasGivenEqs
NoGivenEqs

{- Note [Checking telescopes]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When kind-checking a /user-written/ type, we might have a "bad telescope"
like this one:
  data SameKind :: forall k. k -> k -> Type
  type Foo :: forall a k (b :: k). SameKind a b -> Type

The kind of 'a' mentions 'k' which is bound after 'a'.  Oops.

One approach to doing this would be to bring each of a, k, and b into
scope, one at a time, creating a separate implication constraint for
each one, and bumping the TcLevel. This would work, because the kind
of, say, a would be untouchable when k is in scope (and the constraint
couldn't float out because k blocks it). However, it leads to terrible
error messages, complaining about skolem escape. While it is indeed a
problem of skolem escape, we can do better.

Instead, our approach is to bring the block of variables into scope
all at once, creating one implication constraint for the lot:

* We make a single implication constraint when kind-checking
  the 'forall' in Foo's kind, something like
      forall a k (b::k). { wanted constraints }

* Having solved {wanted}, before discarding the now-solved implication,
  the constraint solver checks the dependency order of the skolem
  variables (ic_skols).  This is done in setImplicationStatus.

* This check is only necessary if the implication was born from a
  'forall' in a user-written signature (the HsForAllTy case in
  GHC.Tc.Gen.HsType.  If, say, it comes from checking a pattern match
  that binds existentials, where the type of the data constructor is
  known to be valid (it in tcConPat), no need for the check.

  So the check is done /if and only if/ ic_info is ForAllSkol.

* If ic_info is (ForAllSkol dt dvs), the dvs::SDoc displays the
  original, user-written type variables.

* Be careful /NOT/ to discard an implication with a ForAllSkol
  ic_info, even if ic_wanted is empty.  We must give the
  constraint solver a chance to make that bad-telescope test!  Hence
  the extra guard in emitResidualTvConstraint; see #16247

* Don't mix up inferred and explicit variables in the same implication
  constraint.  E.g.
      foo :: forall a kx (b :: kx). SameKind a b
  We want an implication
      Implic { ic_skol = [(a::kx), kx, (b::kx)], ... }
  but GHC will attempt to quantify over kx, since it is free in (a::kx),
  and it's hopelessly confusing to report an error about quantified
  variables   kx (a::kx) kx (b::kx).
  Instead, the outer quantification over kx should be in a separate
  implication. TL;DR: an explicit forall should generate an implication
  quantified only over those explicitly quantified variables.

Note [Needed evidence variables]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Th ic_need_evs field holds the free vars of ic_binds, and all the
ic_binds in nested implications.

  * Main purpose: if one of the ic_givens is not mentioned in here, it
    is redundant.

  * solveImplication may drop an implication altogether if it has no
    remaining 'wanteds'. But we still track the free vars of its
    evidence binds, even though it has now disappeared.

Note [Shadowing in a constraint]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We assume NO SHADOWING in a constraint.  Specifically
 * The unification variables are all implicitly quantified at top
   level, and are all unique
 * The skolem variables bound in ic_skols are all freah when the
   implication is created.
So we can safely substitute. For example, if we have
   forall a.  a~Int => ...(forall b. ...a...)...
we can push the (a~Int) constraint inwards in the "givens" without
worrying that 'b' might clash.

Note [Skolems in an implication]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The skolems in an implication are used:

* When considering floating a constraint outside the implication in
  GHC.Tc.Solver.floatEqualities or GHC.Tc.Solver.approximateImplications
  For this, we can treat ic_skols as a set.

* When checking that a /user-specified/ forall (ic_info = ForAllSkol tvs)
  has its variables in the correct order; see Note [Checking telescopes].
  Only for these implications does ic_skols need to be a list.

Nota bene: Although ic_skols is a list, it is not necessarily
in dependency order:
- In the ic_info=ForAllSkol case, the user might have written them
  in the wrong order
- In the case of a type signature like
      f :: [a] -> [b]
  the renamer gathers the implicit "outer" forall'd variables {a,b}, but
  does not know what order to put them in.  The type checker can sort them
  into dependency order, but only after solving all the kind constraints;
  and to do that it's convenient to create the Implication!

So we accept that ic_skols may be out of order.  Think of it as a set or
(in the case of ic_info=ForAllSkol, a list in user-specified, and possibly
wrong, order.

Note [Insoluble constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Some of the errors that we get during canonicalization are best
reported when all constraints have been simplified as much as
possible. For instance, assume that during simplification the
following constraints arise:

 [Wanted]   F alpha ~  uf1
 [Wanted]   beta ~ uf1 beta

When canonicalizing the wanted (beta ~ uf1 beta), if we eagerly fail
we will simply see a message:
    'Can't construct the infinite type  beta ~ uf1 beta'
and the user has no idea what the uf1 variable is.

Instead our plan is that we will NOT fail immediately, but:
    (1) Record the "frozen" error in the ic_insols field
    (2) Isolate the offending constraint from the rest of the inerts
    (3) Keep on simplifying/canonicalizing

At the end, we will hopefully have substituted uf1 := F alpha, and we
will be able to report a more informative error:
    'Can't construct the infinite type beta ~ F alpha beta'

Insoluble constraints *do* include Derived constraints. For example,
a functional dependency might give rise to [D] Int ~ Bool, and we must
report that.  If insolubles did not contain Deriveds, reportErrors would
never see it.


************************************************************************
*                                                                      *
            Pretty printing
*                                                                      *
************************************************************************
-}

pprEvVars :: [EvVar] -> SDoc    -- Print with their types
pprEvVars :: [EvVar] -> SDoc
pprEvVars [EvVar]
ev_vars = [SDoc] -> SDoc
vcat (forall a b. (a -> b) -> [a] -> [b]
map EvVar -> SDoc
pprEvVarWithType [EvVar]
ev_vars)

pprEvVarTheta :: [EvVar] -> SDoc
pprEvVarTheta :: [EvVar] -> SDoc
pprEvVarTheta [EvVar]
ev_vars = [Xi] -> SDoc
pprTheta (forall a b. (a -> b) -> [a] -> [b]
map EvVar -> Xi
evVarPred [EvVar]
ev_vars)

pprEvVarWithType :: EvVar -> SDoc
pprEvVarWithType :: EvVar -> SDoc
pprEvVarWithType EvVar
v = forall a. Outputable a => a -> SDoc
ppr EvVar
v SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Xi -> SDoc
pprType (EvVar -> Xi
evVarPred EvVar
v)



wrapType :: Type -> [TyVar] -> [PredType] -> Type
wrapType :: Xi -> [EvVar] -> [Xi] -> Xi
wrapType Xi
ty [EvVar]
skols [Xi]
givens = [EvVar] -> Xi -> Xi
mkSpecForAllTys [EvVar]
skols forall a b. (a -> b) -> a -> b
$ [Xi] -> Xi -> Xi
mkPhiTy [Xi]
givens Xi
ty


{-
************************************************************************
*                                                                      *
            CtEvidence
*                                                                      *
************************************************************************

Note [Evidence field of CtEvidence]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
During constraint solving we never look at the type of ctev_evar/ctev_dest;
instead we look at the ctev_pred field.  The evtm/evar field
may be un-zonked.

Note [Bind new Givens immediately]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For Givens we make new EvVars and bind them immediately. Two main reasons:
  * Gain sharing.  E.g. suppose we start with g :: C a b, where
       class D a => C a b
       class (E a, F a) => D a
    If we generate all g's superclasses as separate EvTerms we might
    get    selD1 (selC1 g) :: E a
           selD2 (selC1 g) :: F a
           selC1 g :: D a
    which we could do more economically as:
           g1 :: D a = selC1 g
           g2 :: E a = selD1 g1
           g3 :: F a = selD2 g1

  * For *coercion* evidence we *must* bind each given:
      class (a~b) => C a b where ....
      f :: C a b => ....
    Then in f's Givens we have g:(C a b) and the superclass sc(g,0):a~b.
    But that superclass selector can't (yet) appear in a coercion
    (see evTermCoercion), so the easy thing is to bind it to an Id.

So a Given has EvVar inside it rather than (as previously) an EvTerm.

-}

-- | A place for type-checking evidence to go after it is generated.
-- Wanted equalities are always HoleDest; other wanteds are always
-- EvVarDest.
data TcEvDest
  = EvVarDest EvVar         -- ^ bind this var to the evidence
              -- EvVarDest is always used for non-type-equalities
              -- e.g. class constraints

  | HoleDest  CoercionHole  -- ^ fill in this hole with the evidence
              -- HoleDest is always used for type-equalities
              -- See Note [Coercion holes] in GHC.Core.TyCo.Rep

data CtEvidence
  = CtGiven    -- Truly given, not depending on subgoals
      { CtEvidence -> Xi
ctev_pred :: TcPredType      -- See Note [Ct/evidence invariant]
      , CtEvidence -> EvVar
ctev_evar :: EvVar           -- See Note [Evidence field of CtEvidence]
      , CtEvidence -> CtLoc
ctev_loc  :: CtLoc }


  | CtWanted   -- Wanted goal
      { ctev_pred :: TcPredType     -- See Note [Ct/evidence invariant]
      , CtEvidence -> TcEvDest
ctev_dest :: TcEvDest
      , CtEvidence -> ShadowInfo
ctev_nosh :: ShadowInfo     -- See Note [Constraint flavours]
      , ctev_loc  :: CtLoc }

  | CtDerived  -- A goal that we don't really have to solve and can't
               -- immediately rewrite anything other than a derived
               -- (there's no evidence!) but if we do manage to solve
               -- it may help in solving other goals.
      { ctev_pred :: TcPredType
      , ctev_loc  :: CtLoc }

ctEvPred :: CtEvidence -> TcPredType
-- The predicate of a flavor
ctEvPred :: CtEvidence -> Xi
ctEvPred = CtEvidence -> Xi
ctev_pred

ctEvLoc :: CtEvidence -> CtLoc
ctEvLoc :: CtEvidence -> CtLoc
ctEvLoc = CtEvidence -> CtLoc
ctev_loc

ctEvOrigin :: CtEvidence -> CtOrigin
ctEvOrigin :: CtEvidence -> CtOrigin
ctEvOrigin = CtLoc -> CtOrigin
ctLocOrigin forall b c a. (b -> c) -> (a -> b) -> a -> c
. CtEvidence -> CtLoc
ctEvLoc

-- | Get the equality relation relevant for a 'CtEvidence'
ctEvEqRel :: CtEvidence -> EqRel
ctEvEqRel :: CtEvidence -> EqRel
ctEvEqRel = Xi -> EqRel
predTypeEqRel forall b c a. (b -> c) -> (a -> b) -> a -> c
. CtEvidence -> Xi
ctEvPred

-- | Get the role relevant for a 'CtEvidence'
ctEvRole :: CtEvidence -> Role
ctEvRole :: CtEvidence -> Role
ctEvRole = EqRel -> Role
eqRelRole forall b c a. (b -> c) -> (a -> b) -> a -> c
. CtEvidence -> EqRel
ctEvEqRel

ctEvTerm :: CtEvidence -> EvTerm
ctEvTerm :: CtEvidence -> EvTerm
ctEvTerm CtEvidence
ev = EvExpr -> EvTerm
EvExpr (CtEvidence -> EvExpr
ctEvExpr CtEvidence
ev)

ctEvExpr :: CtEvidence -> EvExpr
ctEvExpr :: CtEvidence -> EvExpr
ctEvExpr ev :: CtEvidence
ev@(CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = HoleDest CoercionHole
_ })
            = forall b. Coercion -> Expr b
Coercion forall a b. (a -> b) -> a -> b
$ HasDebugCallStack => CtEvidence -> Coercion
ctEvCoercion CtEvidence
ev
ctEvExpr CtEvidence
ev = EvVar -> EvExpr
evId (CtEvidence -> EvVar
ctEvEvId CtEvidence
ev)

ctEvCoercion :: HasDebugCallStack => CtEvidence -> TcCoercion
ctEvCoercion :: HasDebugCallStack => CtEvidence -> Coercion
ctEvCoercion (CtGiven { ctev_evar :: CtEvidence -> EvVar
ctev_evar = EvVar
ev_id })
  = EvVar -> Coercion
mkTcCoVarCo EvVar
ev_id
ctEvCoercion (CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = TcEvDest
dest })
  | HoleDest CoercionHole
hole <- TcEvDest
dest
  = -- ctEvCoercion is only called on type equalities
    -- and they always have HoleDests
    CoercionHole -> Coercion
mkHoleCo CoercionHole
hole
ctEvCoercion CtEvidence
ev
  = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"ctEvCoercion" (forall a. Outputable a => a -> SDoc
ppr CtEvidence
ev)

ctEvEvId :: CtEvidence -> EvVar
ctEvEvId :: CtEvidence -> EvVar
ctEvEvId (CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = EvVarDest EvVar
ev }) = EvVar
ev
ctEvEvId (CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = HoleDest CoercionHole
h })   = CoercionHole -> EvVar
coHoleCoVar CoercionHole
h
ctEvEvId (CtGiven  { ctev_evar :: CtEvidence -> EvVar
ctev_evar = EvVar
ev })           = EvVar
ev
ctEvEvId ctev :: CtEvidence
ctev@(CtDerived {}) = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"ctEvId:" (forall a. Outputable a => a -> SDoc
ppr CtEvidence
ctev)

instance Outputable TcEvDest where
  ppr :: TcEvDest -> SDoc
ppr (HoleDest CoercionHole
h)   = String -> SDoc
text String
"hole" SDoc -> SDoc -> SDoc
<> forall a. Outputable a => a -> SDoc
ppr CoercionHole
h
  ppr (EvVarDest EvVar
ev) = forall a. Outputable a => a -> SDoc
ppr EvVar
ev

instance Outputable CtEvidence where
  ppr :: CtEvidence -> SDoc
ppr CtEvidence
ev = forall a. Outputable a => a -> SDoc
ppr (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev)
           SDoc -> SDoc -> SDoc
<+> SDoc
pp_ev SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
braces (forall a. Outputable a => a -> SDoc
ppr (CtLoc -> SubGoalDepth
ctl_depth (CtEvidence -> CtLoc
ctEvLoc CtEvidence
ev)))
                         -- Show the sub-goal depth too
               SDoc -> SDoc -> SDoc
<> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr (CtEvidence -> Xi
ctEvPred CtEvidence
ev)
    where
      pp_ev :: SDoc
pp_ev = case CtEvidence
ev of
             CtGiven { ctev_evar :: CtEvidence -> EvVar
ctev_evar = EvVar
v } -> forall a. Outputable a => a -> SDoc
ppr EvVar
v
             CtWanted {ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = TcEvDest
d } -> forall a. Outputable a => a -> SDoc
ppr TcEvDest
d
             CtDerived {}              -> String -> SDoc
text String
"_"

isWanted :: CtEvidence -> Bool
isWanted :: CtEvidence -> Bool
isWanted (CtWanted {}) = Bool
True
isWanted CtEvidence
_ = Bool
False

isGiven :: CtEvidence -> Bool
isGiven :: CtEvidence -> Bool
isGiven (CtGiven {})  = Bool
True
isGiven CtEvidence
_ = Bool
False

isDerived :: CtEvidence -> Bool
isDerived :: CtEvidence -> Bool
isDerived (CtDerived {}) = Bool
True
isDerived CtEvidence
_              = Bool
False

{-
%************************************************************************
%*                                                                      *
            CtFlavour
%*                                                                      *
%************************************************************************

Note [Constraint flavours]
~~~~~~~~~~~~~~~~~~~~~~~~~~
Constraints come in four flavours:

* [G] Given: we have evidence

* [W] Wanted WOnly: we want evidence

* [D] Derived: any solution must satisfy this constraint, but
      we don't need evidence for it.  Examples include:
        - superclasses of [W] class constraints
        - equalities arising from functional dependencies
          or injectivity

* [WD] Wanted WDeriv: a single constraint that represents
                      both [W] and [D]
  We keep them paired as one both for efficiency

The ctev_nosh field of a Wanted distinguishes between [W] and [WD]

Wanted constraints are born as [WD], but are split into [W] and its
"shadow" [D] in GHC.Tc.Solver.Monad.maybeEmitShadow.

See Note [The improvement story and derived shadows] in GHC.Tc.Solver.Monad
-}

data CtFlavour  -- See Note [Constraint flavours]
  = Given
  | Wanted ShadowInfo
  | Derived
  deriving CtFlavour -> CtFlavour -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CtFlavour -> CtFlavour -> Bool
$c/= :: CtFlavour -> CtFlavour -> Bool
== :: CtFlavour -> CtFlavour -> Bool
$c== :: CtFlavour -> CtFlavour -> Bool
Eq

data ShadowInfo
  = WDeriv   -- [WD] This Wanted constraint has no Derived shadow,
             -- so it behaves like a pair of a Wanted and a Derived
  | WOnly    -- [W] It has a separate derived shadow
             -- See Note [The improvement story and derived shadows] in GHC.Tc.Solver.Monad
  deriving( ShadowInfo -> ShadowInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShadowInfo -> ShadowInfo -> Bool
$c/= :: ShadowInfo -> ShadowInfo -> Bool
== :: ShadowInfo -> ShadowInfo -> Bool
$c== :: ShadowInfo -> ShadowInfo -> Bool
Eq )

instance Outputable CtFlavour where
  ppr :: CtFlavour -> SDoc
ppr CtFlavour
Given           = String -> SDoc
text String
"[G]"
  ppr (Wanted ShadowInfo
WDeriv) = String -> SDoc
text String
"[WD]"
  ppr (Wanted ShadowInfo
WOnly)  = String -> SDoc
text String
"[W]"
  ppr CtFlavour
Derived         = String -> SDoc
text String
"[D]"

-- | Does this 'CtFlavour' subsumed 'Derived'? True of @[WD]@ and @[D]@.
ctFlavourContainsDerived :: CtFlavour -> Bool
ctFlavourContainsDerived :: CtFlavour -> Bool
ctFlavourContainsDerived (Wanted ShadowInfo
WDeriv) = Bool
True
ctFlavourContainsDerived CtFlavour
Derived         = Bool
True
ctFlavourContainsDerived CtFlavour
_               = Bool
False

ctEvFlavour :: CtEvidence -> CtFlavour
ctEvFlavour :: CtEvidence -> CtFlavour
ctEvFlavour (CtWanted { ctev_nosh :: CtEvidence -> ShadowInfo
ctev_nosh = ShadowInfo
nosh }) = ShadowInfo -> CtFlavour
Wanted ShadowInfo
nosh
ctEvFlavour (CtGiven {})                    = CtFlavour
Given
ctEvFlavour (CtDerived {})                  = CtFlavour
Derived

-- | Whether or not one 'Ct' can rewrite another is determined by its
-- flavour and its equality relation. See also
-- Note [Flavours with roles] in "GHC.Tc.Solver.Monad"
type CtFlavourRole = (CtFlavour, EqRel)

-- | Extract the flavour, role, and boxity from a 'CtEvidence'
ctEvFlavourRole :: CtEvidence -> CtFlavourRole
ctEvFlavourRole :: CtEvidence -> CtFlavourRole
ctEvFlavourRole CtEvidence
ev = (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, CtEvidence -> EqRel
ctEvEqRel CtEvidence
ev)

-- | Extract the flavour and role from a 'Ct'
ctFlavourRole :: Ct -> CtFlavourRole
-- Uses short-cuts to role for special cases
ctFlavourRole :: Ct -> CtFlavourRole
ctFlavourRole (CDictCan { cc_ev :: Ct -> CtEvidence
cc_ev = CtEvidence
ev })
  = (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, EqRel
NomEq)
ctFlavourRole (CEqCan { cc_ev :: Ct -> CtEvidence
cc_ev = CtEvidence
ev, cc_eq_rel :: Ct -> EqRel
cc_eq_rel = EqRel
eq_rel })
  = (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, EqRel
eq_rel)
ctFlavourRole Ct
ct
  = CtEvidence -> CtFlavourRole
ctEvFlavourRole (Ct -> CtEvidence
ctEvidence Ct
ct)

{- Note [eqCanRewrite]
~~~~~~~~~~~~~~~~~~~~~~
(eqCanRewrite ct1 ct2) holds if the constraint ct1 (a CEqCan of form
lhs ~ ty) can be used to rewrite ct2.  It must satisfy the properties of
a can-rewrite relation, see Definition [Can-rewrite relation] in
GHC.Tc.Solver.Monad.

With the solver handling Coercible constraints like equality constraints,
the rewrite conditions must take role into account, never allowing
a representational equality to rewrite a nominal one.

Note [Wanteds do not rewrite Wanteds]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We don't allow Wanteds to rewrite Wanteds, because that can give rise
to very confusing type error messages.  A good example is #8450.
Here's another
   f :: a -> Bool
   f x = ( [x,'c'], [x,True] ) `seq` True
Here we get
  [W] a ~ Char
  [W] a ~ Bool
but we do not want to complain about Bool ~ Char!

Note [Deriveds do rewrite Deriveds]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
However we DO allow Deriveds to rewrite Deriveds, because that's how
improvement works; see Note [The improvement story] in GHC.Tc.Solver.Interact.

However, for now at least I'm only letting (Derived,NomEq) rewrite
(Derived,NomEq) and not doing anything for ReprEq.  If we have
    eqCanRewriteFR (Derived, NomEq) (Derived, _)  = True
then we lose property R2 of Definition [Can-rewrite relation]
in GHC.Tc.Solver.Monad
  R2.  If f1 >= f, and f2 >= f,
       then either f1 >= f2 or f2 >= f1
Consider f1 = (Given, ReprEq)
         f2 = (Derived, NomEq)
          f = (Derived, ReprEq)

I thought maybe we could never get Derived ReprEq constraints, but
we can; straight from the Wanteds during improvement. And from a Derived
ReprEq we could conceivably get a Derived NomEq improvement (by decomposing
a type constructor with Nomninal role), and hence unify.

This restriction that (Derived, NomEq) cannot rewrite (Derived, ReprEq) bites,
in an obscure scenario:

  data T a
  type role T nominal

  type family F a

  g :: forall b a. (F a ~ T a, Coercible (F a) (T b)) => ()
  g = ()

  f :: forall a. (F a ~ T a) => ()
  f = g @a

The problem is in the body of f. We have

  [G]  F a ~N T a
  [WD] F alpha ~N T alpha
  [WD] F alpha ~R T a

The Wanteds aren't of use, so let's just look at Deriveds:

  [G] F a ~N T a
  [D] F alpha ~N T alpha
  [D] F alpha ~R T a

As written, this makes no progress, and GHC errors. But, if we
allowed D/N to rewrite D/R, the first D could rewrite the second:

  [G] F a ~N T a
  [D] F alpha ~N T alpha
  [D] T alpha ~R T a

Now we decompose the second D to get

  [D] alpha ~N a

noting the role annotation on T. This causes (alpha := a), and then
everything else unlocks.

What to do? We could "decompose" nominal equalities into nominal-only
("NO") equalities and representational ones, where a NO equality rewrites
only nominals. That is, when considering whether [D] F alpha ~N T alpha
should rewrite [D] F alpha ~R T a, we could require splitting the first D
into [D] F alpha ~NO T alpha, [D] F alpha ~R T alpha. Then, we use the R
half of the split to rewrite the second D, and off we go. This splitting
would allow the split-off R equality to be rewritten by other equalities,
thus avoiding the problem in Note [Why R2?] in GHC.Tc.Solver.Monad.

This infelicity is #19665 and tested in typecheck/should_compile/T19665
(marked as expect_broken).

-}

eqCanRewrite :: EqRel -> EqRel -> Bool
eqCanRewrite :: EqRel -> EqRel -> Bool
eqCanRewrite EqRel
NomEq  EqRel
_      = Bool
True
eqCanRewrite EqRel
ReprEq EqRel
ReprEq = Bool
True
eqCanRewrite EqRel
ReprEq EqRel
NomEq  = Bool
False

eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
-- Can fr1 actually rewrite fr2?
-- Very important function!
-- See Note [eqCanRewrite]
-- See Note [Wanteds do not rewrite Wanteds]
-- See Note [Deriveds do rewrite Deriveds]
eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqCanRewriteFR (CtFlavour
Given,         EqRel
r1)    (CtFlavour
_,       EqRel
r2)    = EqRel -> EqRel -> Bool
eqCanRewrite EqRel
r1 EqRel
r2
eqCanRewriteFR (Wanted ShadowInfo
WDeriv, EqRel
NomEq) (CtFlavour
Derived, EqRel
NomEq) = Bool
True
eqCanRewriteFR (CtFlavour
Derived,       EqRel
NomEq) (CtFlavour
Derived, EqRel
NomEq) = Bool
True
eqCanRewriteFR CtFlavourRole
_                      CtFlavourRole
_                = Bool
False

eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
-- Is it /possible/ that fr1 can rewrite fr2?
-- This is used when deciding which inerts to kick out,
-- at which time a [WD] inert may be split into [W] and [D]
eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqMayRewriteFR (Wanted ShadowInfo
WDeriv, EqRel
NomEq) (Wanted ShadowInfo
WDeriv, EqRel
NomEq) = Bool
True
eqMayRewriteFR (CtFlavour
Derived,       EqRel
NomEq) (Wanted ShadowInfo
WDeriv, EqRel
NomEq) = Bool
True
eqMayRewriteFR CtFlavourRole
fr1 CtFlavourRole
fr2 = CtFlavourRole -> CtFlavourRole -> Bool
eqCanRewriteFR CtFlavourRole
fr1 CtFlavourRole
fr2

{- Note [eqCanDischarge]
~~~~~~~~~~~~~~~~~~~~~~~~
Suppose we have two identical CEqCan equality constraints
(i.e. both LHS and RHS are the same)
      (x1:lhs~t) `eqCanDischarge` (xs:lhs~t)
Can we just drop x2 in favour of x1?

Answer: yes if eqCanDischarge is true.

Note that we do /not/ allow Wanted to discharge Derived.
We must keep both.  Why?  Because the Derived may rewrite
other Deriveds in the model whereas the Wanted cannot.

However a Wanted can certainly discharge an identical Wanted.  So
eqCanDischarge does /not/ define a can-rewrite relation in the
sense of Definition [Can-rewrite relation] in GHC.Tc.Solver.Monad.

We /do/ say that a [W] can discharge a [WD].  In evidence terms it
certainly can, and the /caller/ arranges that the otherwise-lost [D]
is spat out as a new Derived.  -}

eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool
-- See Note [eqCanDischarge]
eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqCanDischargeFR (CtFlavour
f1,EqRel
r1) (CtFlavour
f2, EqRel
r2) =  EqRel -> EqRel -> Bool
eqCanRewrite EqRel
r1 EqRel
r2
                                  Bool -> Bool -> Bool
&& CtFlavour -> CtFlavour -> Bool
eqCanDischargeF CtFlavour
f1 CtFlavour
f2

eqCanDischargeF :: CtFlavour -> CtFlavour -> Bool
eqCanDischargeF :: CtFlavour -> CtFlavour -> Bool
eqCanDischargeF CtFlavour
Given   CtFlavour
_                  = Bool
True
eqCanDischargeF (Wanted ShadowInfo
_)      (Wanted ShadowInfo
_) = Bool
True
eqCanDischargeF (Wanted ShadowInfo
WDeriv) CtFlavour
Derived    = Bool
True
eqCanDischargeF CtFlavour
Derived         CtFlavour
Derived    = Bool
True
eqCanDischargeF CtFlavour
_               CtFlavour
_          = Bool
False


{-
************************************************************************
*                                                                      *
            SubGoalDepth
*                                                                      *
************************************************************************

Note [SubGoalDepth]
~~~~~~~~~~~~~~~~~~~
The 'SubGoalDepth' takes care of stopping the constraint solver from looping.

The counter starts at zero and increases. It includes dictionary constraints,
equality simplification, and type family reduction. (Why combine these? Because
it's actually quite easy to mistake one for another, in sufficiently involved
scenarios, like ConstraintKinds.)

The flag -freduction-depth=n fixes the maximium level.

* The counter includes the depth of type class instance declarations.  Example:
     [W] d{7} : Eq [Int]
  That is d's dictionary-constraint depth is 7.  If we use the instance
     $dfEqList :: Eq a => Eq [a]
  to simplify it, we get
     d{7} = $dfEqList d'{8}
  where d'{8} : Eq Int, and d' has depth 8.

  For civilised (decidable) instance declarations, each increase of
  depth removes a type constructor from the type, so the depth never
  gets big; i.e. is bounded by the structural depth of the type.

* The counter also increments when resolving
equalities involving type functions. Example:
  Assume we have a wanted at depth 7:
    [W] d{7} : F () ~ a
  If there is a type function equation "F () = Int", this would be rewritten to
    [W] d{8} : Int ~ a
  and remembered as having depth 8.

  Again, without UndecidableInstances, this counter is bounded, but without it
  can resolve things ad infinitum. Hence there is a maximum level.

* Lastly, every time an equality is rewritten, the counter increases. Again,
  rewriting an equality constraint normally makes progress, but it's possible
  the "progress" is just the reduction of an infinitely-reducing type family.
  Hence we need to track the rewrites.

When compiling a program requires a greater depth, then GHC recommends turning
off this check entirely by setting -freduction-depth=0. This is because the
exact number that works is highly variable, and is likely to change even between
minor releases. Because this check is solely to prevent infinite compilation
times, it seems safe to disable it when a user has ascertained that their program
doesn't loop at the type level.

-}

-- | See Note [SubGoalDepth]
newtype SubGoalDepth = SubGoalDepth Int
  deriving (SubGoalDepth -> SubGoalDepth -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubGoalDepth -> SubGoalDepth -> Bool
$c/= :: SubGoalDepth -> SubGoalDepth -> Bool
== :: SubGoalDepth -> SubGoalDepth -> Bool
$c== :: SubGoalDepth -> SubGoalDepth -> Bool
Eq, Eq SubGoalDepth
SubGoalDepth -> SubGoalDepth -> Bool
SubGoalDepth -> SubGoalDepth -> Ordering
SubGoalDepth -> SubGoalDepth -> SubGoalDepth
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
$cmin :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
max :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
$cmax :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
>= :: SubGoalDepth -> SubGoalDepth -> Bool
$c>= :: SubGoalDepth -> SubGoalDepth -> Bool
> :: SubGoalDepth -> SubGoalDepth -> Bool
$c> :: SubGoalDepth -> SubGoalDepth -> Bool
<= :: SubGoalDepth -> SubGoalDepth -> Bool
$c<= :: SubGoalDepth -> SubGoalDepth -> Bool
< :: SubGoalDepth -> SubGoalDepth -> Bool
$c< :: SubGoalDepth -> SubGoalDepth -> Bool
compare :: SubGoalDepth -> SubGoalDepth -> Ordering
$ccompare :: SubGoalDepth -> SubGoalDepth -> Ordering
Ord, SubGoalDepth -> SDoc
forall a. (a -> SDoc) -> Outputable a
ppr :: SubGoalDepth -> SDoc
$cppr :: SubGoalDepth -> SDoc
Outputable)

initialSubGoalDepth :: SubGoalDepth
initialSubGoalDepth :: SubGoalDepth
initialSubGoalDepth = Int -> SubGoalDepth
SubGoalDepth Int
0

bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth
bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth
bumpSubGoalDepth (SubGoalDepth Int
n) = Int -> SubGoalDepth
SubGoalDepth (Int
n forall a. Num a => a -> a -> a
+ Int
1)

maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
maxSubGoalDepth (SubGoalDepth Int
n) (SubGoalDepth Int
m) = Int -> SubGoalDepth
SubGoalDepth (Int
n forall a. Ord a => a -> a -> a
`max` Int
m)

subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool
subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool
subGoalDepthExceeded DynFlags
dflags (SubGoalDepth Int
d)
  = Int -> IntWithInf
mkIntWithInf Int
d forall a. Ord a => a -> a -> Bool
> DynFlags -> IntWithInf
reductionDepth DynFlags
dflags

{-
************************************************************************
*                                                                      *
            CtLoc
*                                                                      *
************************************************************************

The 'CtLoc' gives information about where a constraint came from.
This is important for decent error message reporting because
dictionaries don't appear in the original source code.
type will evolve...

-}

data CtLoc = CtLoc { CtLoc -> CtOrigin
ctl_origin :: CtOrigin
                   , CtLoc -> TcLclEnv
ctl_env    :: TcLclEnv
                   , CtLoc -> Maybe TypeOrKind
ctl_t_or_k :: Maybe TypeOrKind  -- OK if we're not sure
                   , CtLoc -> SubGoalDepth
ctl_depth  :: !SubGoalDepth }

  -- The TcLclEnv includes particularly
  --    source location:  tcl_loc   :: RealSrcSpan
  --    context:          tcl_ctxt  :: [ErrCtxt]
  --    binder stack:     tcl_bndrs :: TcBinderStack
  --    level:            tcl_tclvl :: TcLevel

mkKindLoc :: TcType -> TcType   -- original *types* being compared
          -> CtLoc -> CtLoc
mkKindLoc :: Xi -> Xi -> CtLoc -> CtLoc
mkKindLoc Xi
s1 Xi
s2 CtLoc
loc = CtLoc -> CtOrigin -> CtLoc
setCtLocOrigin (CtLoc -> CtLoc
toKindLoc CtLoc
loc)
                        (Xi -> Xi -> CtOrigin -> Maybe TypeOrKind -> CtOrigin
KindEqOrigin Xi
s1 Xi
s2 (CtLoc -> CtOrigin
ctLocOrigin CtLoc
loc)
                                      (CtLoc -> Maybe TypeOrKind
ctLocTypeOrKind_maybe CtLoc
loc))

-- | Take a CtLoc and moves it to the kind level
toKindLoc :: CtLoc -> CtLoc
toKindLoc :: CtLoc -> CtLoc
toKindLoc CtLoc
loc = CtLoc
loc { ctl_t_or_k :: Maybe TypeOrKind
ctl_t_or_k = forall a. a -> Maybe a
Just TypeOrKind
KindLevel }

mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc TcLevel
tclvl SkolemInfo
skol_info TcLclEnv
env
  = CtLoc { ctl_origin :: CtOrigin
ctl_origin = SkolemInfo -> CtOrigin
GivenOrigin SkolemInfo
skol_info
          , ctl_env :: TcLclEnv
ctl_env    = TcLclEnv -> TcLevel -> TcLclEnv
setLclEnvTcLevel TcLclEnv
env TcLevel
tclvl
          , ctl_t_or_k :: Maybe TypeOrKind
ctl_t_or_k = forall a. Maybe a
Nothing    -- this only matters for error msgs
          , ctl_depth :: SubGoalDepth
ctl_depth  = SubGoalDepth
initialSubGoalDepth }

ctLocEnv :: CtLoc -> TcLclEnv
ctLocEnv :: CtLoc -> TcLclEnv
ctLocEnv = CtLoc -> TcLclEnv
ctl_env

ctLocLevel :: CtLoc -> TcLevel
ctLocLevel :: CtLoc -> TcLevel
ctLocLevel CtLoc
loc = TcLclEnv -> TcLevel
getLclEnvTcLevel (CtLoc -> TcLclEnv
ctLocEnv CtLoc
loc)

ctLocDepth :: CtLoc -> SubGoalDepth
ctLocDepth :: CtLoc -> SubGoalDepth
ctLocDepth = CtLoc -> SubGoalDepth
ctl_depth

ctLocOrigin :: CtLoc -> CtOrigin
ctLocOrigin :: CtLoc -> CtOrigin
ctLocOrigin = CtLoc -> CtOrigin
ctl_origin

ctLocSpan :: CtLoc -> RealSrcSpan
ctLocSpan :: CtLoc -> RealSrcSpan
ctLocSpan (CtLoc { ctl_env :: CtLoc -> TcLclEnv
ctl_env = TcLclEnv
lcl}) = TcLclEnv -> RealSrcSpan
getLclEnvLoc TcLclEnv
lcl

ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind
ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind
ctLocTypeOrKind_maybe = CtLoc -> Maybe TypeOrKind
ctl_t_or_k

setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc
setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc
setCtLocSpan ctl :: CtLoc
ctl@(CtLoc { ctl_env :: CtLoc -> TcLclEnv
ctl_env = TcLclEnv
lcl }) RealSrcSpan
loc = CtLoc -> TcLclEnv -> CtLoc
setCtLocEnv CtLoc
ctl (TcLclEnv -> RealSrcSpan -> TcLclEnv
setLclEnvLoc TcLclEnv
lcl RealSrcSpan
loc)

bumpCtLocDepth :: CtLoc -> CtLoc
bumpCtLocDepth :: CtLoc -> CtLoc
bumpCtLocDepth loc :: CtLoc
loc@(CtLoc { ctl_depth :: CtLoc -> SubGoalDepth
ctl_depth = SubGoalDepth
d }) = CtLoc
loc { ctl_depth :: SubGoalDepth
ctl_depth = SubGoalDepth -> SubGoalDepth
bumpSubGoalDepth SubGoalDepth
d }

setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc
setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc
setCtLocOrigin CtLoc
ctl CtOrigin
orig = CtLoc
ctl { ctl_origin :: CtOrigin
ctl_origin = CtOrigin
orig }

updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc
updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc
updateCtLocOrigin ctl :: CtLoc
ctl@(CtLoc { ctl_origin :: CtLoc -> CtOrigin
ctl_origin = CtOrigin
orig }) CtOrigin -> CtOrigin
upd
  = CtLoc
ctl { ctl_origin :: CtOrigin
ctl_origin = CtOrigin -> CtOrigin
upd CtOrigin
orig }

setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc
setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc
setCtLocEnv CtLoc
ctl TcLclEnv
env = CtLoc
ctl { ctl_env :: TcLclEnv
ctl_env = TcLclEnv
env }

pprCtLoc :: CtLoc -> SDoc
-- "arising from ... at ..."
-- Not an instance of Outputable because of the "arising from" prefix
pprCtLoc :: CtLoc -> SDoc
pprCtLoc (CtLoc { ctl_origin :: CtLoc -> CtOrigin
ctl_origin = CtOrigin
o, ctl_env :: CtLoc -> TcLclEnv
ctl_env = TcLclEnv
lcl})
  = [SDoc] -> SDoc
sep [ CtOrigin -> SDoc
pprCtOrigin CtOrigin
o
        , String -> SDoc
text String
"at" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr (TcLclEnv -> RealSrcSpan
getLclEnvLoc TcLclEnv
lcl)]