    {-# LANGUAGE DerivingStrategies #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE TypeApplications #-}

    -- | This module defines types and simple operations over constraints, as used
    -- in the type-checker and constraint solver.
    module GHC.Tc.Types.Constraint (
            -- Constraints
            Xi, Ct(..), Cts,
            singleCt, listToCts, ctsElts, consCts, snocCts, extendCtsList,
            isEmptyCts, emptyCts, andCts, ctsPreds,
            isPendingScDictCt, isPendingScDict, pendingScDict_maybe,
            superClassesMightHelp, getPendingWantedScs,
            isWantedCt, isGivenCt,
            isTopLevelUserTypeError, containsUserTypeError, getUserTypeErrorMsg,
            isUnsatisfiableCt_maybe,
            ctEvidence, updCtEvidence,
            ctLoc, ctPred, ctFlavour, ctEqRel, ctOrigin,
            ctRewriters,
            ctEvId, wantedEvId_maybe, mkTcEqPredLikeEv,
            mkNonCanonical, mkGivens,
            tyCoVarsOfCt, tyCoVarsOfCts,
            tyCoVarsOfCtList, tyCoVarsOfCtsList,

            -- Particular forms of constraint
            EqCt(..),    eqCtEvidence, eqCtLHS,
            DictCt(..),  dictCtEvidence,
            IrredCt(..), irredCtEvidence, mkIrredCt, ctIrredCt, irredCtPred,

            -- QCInst
            QCInst(..), pendingScInst_maybe,

            ExpansionFuel, doNotExpand, consumeFuel, pendingFuel,
            assertFuelPrecondition, assertFuelPreconditionStrict,

            CtIrredReason(..), isInsolubleReason,

            CheckTyEqResult, CheckTyEqProblem, cteProblem, cterClearOccursCheck,
            cteOK, cteImpredicative, cteTypeFamily, cteCoercionHole,
            cteInsolubleOccurs, cteSolubleOccurs, cterSetOccursCheckSoluble,
            cteConcrete, cteSkolemEscape,
            impredicativeProblem, insolubleOccursProblem, solubleOccursProblem,

            cterHasNoProblem, cterHasProblem, cterHasOnlyProblem, cterHasOnlyProblems,
            cterRemoveProblem, cterHasOccursCheck, cterFromKind,

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

            Hole(..), HoleSort(..), isOutOfScopeHole,
            DelayedError(..), NotConcreteError(..),
            NotConcreteReason(..),

            WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC,
            isSolvedWC, andWC, unionsWC, mkSimpleWC, mkImplicWC,
            addInsols, dropMisleading, addSimples, addImplics, addHoles,
            addNotConcreteError, addDelayedErrors,
            tyCoVarsOfWC, tyCoVarsOfWCList,
            insolubleWantedCt, insolubleCt, insolubleIrredCt,
            insolubleImplic, nonDefaultableTyVarsOfWC,

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

            -- CtLocEnv
            CtLocEnv(..), setCtLocEnvLoc, setCtLocEnvLvl, getCtLocEnvLoc, getCtLocEnvLvl, ctLocEnvInGeneratedCode,

            -- CtEvidence
            CtEvidence(..), TcEvDest(..),
            isWanted, isGiven,
            ctEvPred, ctEvLoc, ctEvOrigin, ctEvEqRel,
            ctEvExpr, ctEvTerm, ctEvCoercion, ctEvEvId,
            ctEvRewriters, ctEvUnique, tcEvDestUnique,
            mkKindEqLoc, toKindLoc, toInvisibleLoc, mkGivenLoc,
            ctEvRole, setCtEvPredType, setCtEvLoc, arisesFromGivens,
            tyCoVarsOfCtEvList, tyCoVarsOfCtEv, tyCoVarsOfCtEvsList,

            -- RewriterSet
            RewriterSet(..), emptyRewriterSet, isEmptyRewriterSet,
               -- exported concretely only for zonkRewriterSet
            addRewriter, unitRewriterSet, unionRewriterSet, rewriterSetFromCts,

            wrapType,

            CtFlavour(..), ctEvFlavour,
            CtFlavourRole, ctEvFlavourRole, ctFlavourRole, eqCtFlavourRole,
            eqCanRewrite, eqCanRewriteFR,

            -- Pretty printing
            pprEvVarTheta,
            pprEvVars, pprEvVarWithType,

      )
      where

    import GHC.Prelude

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

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

    import GHC.Core

    import GHC.Core.TyCo.Ppr
    import GHC.Utils.FV
    import GHC.Types.Var.Set
    import GHC.Builtin.Names
    import GHC.Types.Basic
    import GHC.Types.Unique.Set

    import GHC.Utils.Outputable
    import GHC.Types.SrcLoc
    import GHC.Data.Bag
    import GHC.Utils.Misc
    import GHC.Utils.Panic
    import GHC.Utils.Constants (debugIsOn)
    import GHC.Types.Name.Reader

    import Data.Coerce
    import qualified Data.Semigroup as S
    import Control.Monad ( msum, when )
    import Data.Maybe ( mapMaybe, isJust )
    import Data.List.NonEmpty ( NonEmpty )

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

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

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

    -- | Says how many layers of superclasses can we expand.
    --   Invariant: ExpansionFuel should always be >= 0
    -- see Note [Expanding Recursive Superclasses and ExpansionFuel]
    type ExpansionFuel = Int

    -- | Do not expand superclasses any further
    doNotExpand :: ExpansionFuel
    doNotExpand :: Int
    doNotExpand = Int
    0

    -- | Consumes one unit of fuel.
    --   Precondition: fuel > 0
    consumeFuel :: ExpansionFuel -> ExpansionFuel
    consumeFuel :: Int -> Int
    consumeFuel Int
    fuel = Int -> Int -> Int
    forall a. Int -> a -> a
    assertFuelPreconditionStrict Int
    fuel (Int -> Int) -> Int -> Int
    forall a b. (a -> b) -> a -> b
    $ Int
    fuel Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1

    -- | Returns True if we have any fuel left for superclass expansion
    pendingFuel :: ExpansionFuel -> Bool
    pendingFuel :: Int -> Bool
    pendingFuel Int
    n = Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0

    insufficientFuelError :: SDoc
    insufficientFuelError :: SDoc
    insufficientFuelError = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Superclass expansion fuel should be > 0"

    -- | asserts if fuel is non-negative
    assertFuelPrecondition :: ExpansionFuel -> a -> a
    {-# INLINE assertFuelPrecondition #-}
    assertFuelPrecondition :: forall a. Int -> a -> a
    assertFuelPrecondition Int
    fuel = Bool -> SDoc -> a -> a
    forall a. HasCallStack => Bool -> SDoc -> a -> a
    assertPpr (Int
    fuel Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    0) SDoc
    insufficientFuelError

    -- | asserts if fuel is strictly greater than 0
    assertFuelPreconditionStrict :: ExpansionFuel -> a -> a
    {-# INLINE assertFuelPreconditionStrict #-}
    assertFuelPreconditionStrict :: forall a. Int -> a -> a
    assertFuelPreconditionStrict Int
    fuel = Bool -> SDoc -> a -> a
    forall a. HasCallStack => Bool -> SDoc -> a -> a
    assertPpr (Int -> Bool
    pendingFuel Int
    fuel) SDoc
    insufficientFuelError

    data Ct
      = CDictCan      DictCt
      | CIrredCan     IrredCt      -- A "irreducible" constraint (non-canonical)
      | CEqCan        EqCt         -- A canonical equality constraint
      | CQuantCan     QCInst       -- A quantified constraint
      | CNonCanonical CtEvidence   -- See Note [NonCanonical Semantics] in GHC.Tc.Solver.Monad

    --------------- DictCt --------------

    data DictCt   -- e.g.  Num ty
      = DictCt { DictCt -> CtEvidence
    di_ev  :: CtEvidence  -- See Note [Ct/evidence invariant]

               , DictCt -> Class
    di_cls :: Class
               , DictCt -> [Xi]
    di_tys :: [Xi]   -- di_tys are rewritten w.r.t. inerts, so Xi

               , DictCt -> Int
    di_pend_sc :: ExpansionFuel
                   -- See Note [The superclass story] in GHC.Tc.Solver.Dict
                   -- See Note [Expanding Recursive Superclasses and ExpansionFuel] in GHC.Tc.Solver
                   -- Invariants: di_pend_sc > 0 <=>
                   --                    (a) di_cls has superclasses
                   --                    (b) those superclasses are not yet explored
        }

    dictCtEvidence :: DictCt -> CtEvidence
    dictCtEvidence :: DictCt -> CtEvidence
    dictCtEvidence = DictCt -> CtEvidence
    di_ev

    instance Outputable DictCt where
      ppr :: DictCt -> SDoc
    ppr DictCt
    dict = Ct -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (DictCt -> Ct
    CDictCan DictCt
    dict)

    --------------- EqCt --------------

    {- Note [Canonical equalities]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    An EqCt is a canonical equality constraint, one that can live in the inert set,
    and that can be used to rewrite other constrtaints. It satisfies these invariants:
      * (TyEq:OC) lhs does not occur in rhs (occurs check)
                  Note [EqCt occurs check]
      * (TyEq:F) rhs has no foralls
          (this avoids substituting a forall for the tyvar in other types)
      * (TyEq:K) typeKind lhs `tcEqKind` typeKind rhs; Note [Ct kind invariant]
      * (TyEq:N) If the equality is representational, rhs is not headed by a saturated
        application of a newtype TyCon. See GHC.Tc.Solver.Equality
        Note [No top-level newtypes on RHS of representational equalities].
        (Applies only when constructor of newtype is in scope.)
      * (TyEq:U) An EqCt is not immediately unifiable. If we can unify a:=ty, we
        will not form an EqCt (a ~ ty).
      * (TyEq:CH) rhs does not mention any coercion holes that resulted from fixing up
        a hetero-kinded equality.  See Note [Equalities with incompatible kinds] in
        GHC.Tc.Solver.Equality, wrinkle (EIK2)

    These invariants ensure that the EqCts in inert_eqs constitute a terminating
    generalised substitution. See Note [inert_eqs: the inert equalities]
    in GHC.Tc.Solver.InertSet for what these words mean!

    Note [EqCt 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 including kinds of
      type variables. This is because a CEqCan over a meta-variable is
      also used to inform unification, in
      GHC.Tc.Solver.Monad.checkTouchableTyVarEq. If the LHS appears
      anywhere in the RHS, at all, 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.checkTyEqRhs
    and forms condition T3 in Note [Extending the inert equalities]
    in GHC.Tc.Solver.InertSet.
    -}

    data EqCt -- An equality constraint; see Note [Canonical equalities]
      = EqCt {  -- CanEqLHS ~ rhs
          EqCt -> CtEvidence
    eq_ev     :: CtEvidence, -- See Note [Ct/evidence invariant]
          EqCt -> CanEqLHS
    eq_lhs    :: CanEqLHS,
          EqCt -> Xi
    eq_rhs    :: Xi,         -- See invariants above
          EqCt -> EqRel
    eq_eq_rel :: EqRel       -- INVARIANT: cc_eq_rel = ctEvEqRel cc_ev
        }

    -- | 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  -- ^ TyCon of the family
                 [Xi]   -- ^ Arguments, /exactly saturating/ the family

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

    eqCtEvidence :: EqCt -> CtEvidence
    eqCtEvidence :: EqCt -> CtEvidence
    eqCtEvidence = EqCt -> CtEvidence
    eq_ev

    eqCtLHS :: EqCt -> CanEqLHS
    eqCtLHS :: EqCt -> CanEqLHS
    eqCtLHS = EqCt -> CanEqLHS
    eq_lhs

    --------------- IrredCt --------------

    data IrredCt    -- These stand for yet-unusable predicates
                    -- See Note [CIrredCan constraints]
      = IrredCt { IrredCt -> CtEvidence
    ir_ev     :: CtEvidence   -- See Note [Ct/evidence invariant]
                , IrredCt -> CtIrredReason
    ir_reason :: CtIrredReason }

    mkIrredCt :: CtIrredReason -> CtEvidence -> Ct
    mkIrredCt :: CtIrredReason -> CtEvidence -> Ct
    mkIrredCt CtIrredReason
    reason CtEvidence
    ev = IrredCt -> Ct
    CIrredCan (IrredCt { ir_ev :: CtEvidence
    ir_ev = CtEvidence
    ev, ir_reason :: CtIrredReason
    ir_reason = CtIrredReason
    reason })

    irredCtEvidence :: IrredCt -> CtEvidence
    irredCtEvidence :: IrredCt -> CtEvidence
    irredCtEvidence = IrredCt -> CtEvidence
    ir_ev

    irredCtPred :: IrredCt -> PredType
    irredCtPred :: IrredCt -> Xi
    irredCtPred = CtEvidence -> Xi
    ctEvPred (CtEvidence -> Xi) -> (IrredCt -> CtEvidence) -> IrredCt -> Xi
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IrredCt -> CtEvidence
    irredCtEvidence

    ctIrredCt :: CtIrredReason -> Ct -> IrredCt
    ctIrredCt :: CtIrredReason -> Ct -> IrredCt
    ctIrredCt CtIrredReason
    _      (CIrredCan IrredCt
    ir) = IrredCt
    ir
    ctIrredCt CtIrredReason
    reason Ct
    ct             = IrredCt { ir_ev :: CtEvidence
    ir_ev = Ct -> CtEvidence
    ctEvidence Ct
    ct
                                              , ir_reason :: CtIrredReason
    ir_reason = CtIrredReason
    reason }

    instance Outputable IrredCt where
      ppr :: IrredCt -> SDoc
    ppr IrredCt
    irred = Ct -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (IrredCt -> Ct
    CIrredCan IrredCt
    irred)

    --------------- QCInst --------------

    data QCInst  -- A much simplified version of ClsInst
                 -- See Note [Quantified constraints] in GHC.Tc.Solver.Solve
      = 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 -> Int
    qci_pend_sc :: ExpansionFuel
                 -- Invariants: qci_pend_sc > 0 =>
                 --       (a) qci_pred is a ClassPred
                 --       (b) this class has superclass(es), and
                 --       (c) the superclass(es) are not explored yet
                 -- Same as di_pend_sc flag in DictCt
                 -- See Note [Expanding Recursive Superclasses and ExpansionFuel] in GHC.Tc.Solver
        }

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

    ------------------------------------------------------------------------------
    --
    -- Holes and other delayed errors
    --
    ------------------------------------------------------------------------------

    -- | A delayed error, to be reported after constraint solving, in order to benefit
    -- from deferred unifications.
    data DelayedError
      = DE_Hole Hole
        -- ^ A hole (in a type or in a term).
        --
        -- See Note [Holes].
      | DE_NotConcrete NotConcreteError
        -- ^ A type could not be ensured to be concrete.
        --
        -- See Note [The Concrete mechanism] in GHC.Tc.Utils.Concrete.

    instance Outputable DelayedError where
      ppr :: DelayedError -> SDoc
    ppr (DE_Hole Hole
    hole) = Hole -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Hole
    hole
      ppr (DE_NotConcrete NotConcreteError
    err) = NotConcreteError -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr NotConcreteError
    err

    -- | 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 -> RdrName
    hole_occ  :: RdrName  -- ^ 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 -> RdrName
    hole_occ  = RdrName
    occ
                , hole_ty :: Hole -> Xi
    hole_ty   = Xi
    ty })
        = SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ (SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ RdrName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RdrName
    occ SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> HoleExprRef -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HoleExprRef
    ref) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Xi -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Xi
    ty
      ppr (Hole { hole_sort :: Hole -> HoleSort
    hole_sort = HoleSort
    _other
                , hole_occ :: Hole -> RdrName
    hole_occ  = RdrName
    occ
                , hole_ty :: Hole -> Xi
    hole_ty   = Xi
    ty })
        = SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ RdrName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RdrName
    occ SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> Xi -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Xi
    ty

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

    -- | Why did we require that a certain type be concrete?
    data NotConcreteError
      -- | Concreteness was required by a representation-polymorphism
      -- check.
      --
      -- See Note [The Concrete mechanism] in GHC.Tc.Utils.Concrete.
      = NCE_FRR
        { NotConcreteError -> CtLoc
    nce_loc        :: CtLoc
          -- ^ Where did this check take place?
        , NotConcreteError -> FixedRuntimeRepOrigin
    nce_frr_origin :: FixedRuntimeRepOrigin
          -- ^ Which representation-polymorphism check did we perform?
        , NotConcreteError -> NonEmpty NotConcreteReason
    nce_reasons    :: NonEmpty NotConcreteReason
          -- ^ Why did the check fail?
        }

    -- | Why did we decide that a type was not concrete?
    data NotConcreteReason
      -- | The type contains a 'TyConApp' of a non-concrete 'TyCon'.
      --
      -- See Note [Concrete types] in GHC.Tc.Utils.Concrete.
      = NonConcreteTyCon TyCon [TcType]

      -- | The type contains a type variable that could not be made
      -- concrete (e.g. a skolem type variable).
      | NonConcretisableTyVar TyVar

      -- | The type contains a cast.
      | ContainsCast TcType TcCoercionN

      -- | The type contains a forall.
      | ContainsForall ForAllTyBinder TcType

      -- | The type contains a 'CoercionTy'.
      | ContainsCoercionTy TcCoercion

    instance Outputable NotConcreteError where
      ppr :: NotConcreteError -> SDoc
    ppr (NCE_FRR { nce_frr_origin :: NotConcreteError -> FixedRuntimeRepOrigin
    nce_frr_origin = FixedRuntimeRepOrigin
    frr_orig })
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NCE_FRR" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens (Xi -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (FixedRuntimeRepOrigin -> Xi
    frr_type FixedRuntimeRepOrigin
    frr_orig))

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

      | NonCanonicalReason CheckTyEqResult
       -- ^ An equality where some invariant other than (TyEq:H) of 'CEqCan' is not satisfied;
       -- the 'CheckTyEqResult' states exactly why

      | 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

      | PluginReason
        -- ^ A typechecker plugin returned this in the pluginBadCts field
        -- of TcPluginProgress

    instance Outputable CtIrredReason where
      ppr :: CtIrredReason -> SDoc
    ppr CtIrredReason
    IrredShapeReason          = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "(irred)"
      ppr (NonCanonicalReason CheckTyEqResult
    cter) = CheckTyEqResult -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr CheckTyEqResult
    cter
      ppr CtIrredReason
    ReprEqReason              = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "(repr)"
      ppr CtIrredReason
    ShapeMismatchReason       = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "(shape)"
      ppr CtIrredReason
    AbstractTyConReason       = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "(abstc)"
      ppr CtIrredReason
    PluginReason              = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "(plugin)"

    -- | Are we sure that more solving will never solve this constraint?
    isInsolubleReason :: CtIrredReason -> Bool
    isInsolubleReason :: CtIrredReason -> Bool
    isInsolubleReason CtIrredReason
    IrredShapeReason          = 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
    isInsolubleReason CtIrredReason
    PluginReason              = 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 Word8
    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, cteInsolubleOccurs,
      cteSolubleOccurs, cteCoercionHole, cteConcrete,
      cteSkolemEscape :: CheckTyEqProblem
    cteImpredicative :: CheckTyEqProblem
    cteImpredicative   = Word8 -> CheckTyEqProblem
    CTEP (Int -> Word8
    forall a. Bits a => Int -> a
    bit Int
    0)   -- Forall or (=>) encountered
    cteTypeFamily :: CheckTyEqProblem
    cteTypeFamily      = Word8 -> CheckTyEqProblem
    CTEP (Int -> Word8
    forall a. Bits a => Int -> a
    bit Int
    1)   -- Type family encountered

    cteInsolubleOccurs :: CheckTyEqProblem
    cteInsolubleOccurs = Word8 -> CheckTyEqProblem
    CTEP (Int -> Word8
    forall a. Bits a => Int -> a
    bit Int
    2)   -- Occurs-check
    cteSolubleOccurs :: CheckTyEqProblem
    cteSolubleOccurs   = Word8 -> CheckTyEqProblem
    CTEP (Int -> Word8
    forall a. Bits a => Int -> a
    bit Int
    3)   -- Occurs-check under a type function, or in a coercion,
                                        -- or in a representational equality; see
       -- See Note [Occurs check and representational equality]
       -- cteSolubleOccurs must be one bit to the left of cteInsolubleOccurs
       -- See also Note [Insoluble mis-match] in GHC.Tc.Errors

    cteCoercionHole :: CheckTyEqProblem
    cteCoercionHole    = Word8 -> CheckTyEqProblem
    CTEP (Int -> Word8
    forall a. Bits a => Int -> a
    bit Int
    4)   -- Coercion hole encountered
    cteConcrete :: CheckTyEqProblem
    cteConcrete        = Word8 -> CheckTyEqProblem
    CTEP (Int -> Word8
    forall a. Bits a => Int -> a
    bit Int
    5)   -- Type variable that can't be made concrete
                                        --    e.g. alpha[conc] ~ Maybe beta[tv]
    cteSkolemEscape :: CheckTyEqProblem
    cteSkolemEscape    = Word8 -> CheckTyEqProblem
    CTEP (Int -> Word8
    forall a. Bits a => Int -> a
    bit Int
    6)   -- Skolem escape e.g.  alpha[2] ~ b[sk,4]

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

    impredicativeProblem, insolubleOccursProblem, solubleOccursProblem :: CheckTyEqResult
    impredicativeProblem :: CheckTyEqResult
    impredicativeProblem   = CheckTyEqProblem -> CheckTyEqResult
    cteProblem CheckTyEqProblem
    cteImpredicative
    insolubleOccursProblem :: CheckTyEqResult
    insolubleOccursProblem = CheckTyEqProblem -> CheckTyEqResult
    cteProblem CheckTyEqProblem
    cteInsolubleOccurs
    solubleOccursProblem :: CheckTyEqResult
    solubleOccursProblem   = CheckTyEqProblem -> CheckTyEqResult
    cteProblem CheckTyEqProblem
    cteSolubleOccurs

    occurs_mask :: Word8
    occurs_mask :: Word8
    occurs_mask = Word8
    insoluble_mask Word8 -> Word8 -> Word8
    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 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    mask) Word8 -> Word8 -> Bool
    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 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    mask

    cterHasOnlyProblems :: CheckTyEqResult -> CheckTyEqResult -> Bool
    CTER Word8
    bits cterHasOnlyProblems :: CheckTyEqResult -> CheckTyEqResult -> Bool
    `cterHasOnlyProblems` CTER Word8
    mask = (Word8
    bits Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8 -> Word8
    forall a. Bits a => a -> a
    complement Word8
    mask) Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    0

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

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

    cterClearOccursCheck :: CheckTyEqResult -> CheckTyEqResult
    cterClearOccursCheck :: CheckTyEqResult -> CheckTyEqResult
    cterClearOccursCheck (CTER Word8
    bits) = Word8 -> CheckTyEqResult
    CTER (Word8
    bits Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8 -> Word8
    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 (Word8 -> CheckTyEqResult) -> Word8 -> CheckTyEqResult
    forall a b. (a -> b) -> a -> b
    $ ((Word8
    bits Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    insoluble_mask) Word8 -> Int -> Word8
    forall a. Bits a => a -> Int -> a
    `shift` Int
    1) Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .|. (Word8
    bits Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8 -> Word8
    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 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    occurs_mask)

    cterIsInsoluble :: CheckTyEqResult -> Bool
    cterIsInsoluble :: CheckTyEqResult -> Bool
    cterIsInsoluble (CTER Word8
    bits) = (Word8
    bits Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    mask) Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Word8
    0
      where
        mask :: Word8
    mask = Word8
    impredicative_mask Word8 -> Word8 -> Word8
    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 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .|. Word8
    bits2)
    instance Monoid CheckTyEqResult where
      mempty :: CheckTyEqResult
    mempty = CheckTyEqResult
    cteOK

    instance Eq CheckTyEqProblem where
      (CTEP Word8
    b1) == :: CheckTyEqProblem -> CheckTyEqProblem -> Bool
    == (CTEP Word8
    b2) = Word8
    b1Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Word8
    b2

    instance Outputable CheckTyEqProblem where
      ppr :: CheckTyEqProblem -> SDoc
    ppr prob :: CheckTyEqProblem
    prob@(CTEP Word8
    bits) = case CheckTyEqProblem -> [(CheckTyEqProblem, String)] -> Maybe String
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup CheckTyEqProblem
    prob [(CheckTyEqProblem, String)]
    allBits of
                    Just String
    s  -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    s
                    Maybe String
    Nothing -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "unknown:" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Word8 -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Word8
    bits

    instance Outputable CheckTyEqResult where
      ppr :: CheckTyEqResult -> SDoc
    ppr CheckTyEqResult
    cter | CheckTyEqResult -> Bool
    cterHasNoProblem CheckTyEqResult
    cter
               = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "cteOK"
               | Bool
    otherwise
               = SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ [SDoc] -> SDoc
    fcat ([SDoc] -> SDoc) -> [SDoc] -> SDoc
    forall a b. (a -> b) -> a -> b
    $ SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    intersperse SDoc
    forall doc. IsLine doc => doc
    vbar ([SDoc] -> [SDoc]) -> [SDoc] -> [SDoc]
    forall a b. (a -> b) -> a -> b
    $
                 [ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    str
                 | (CheckTyEqProblem
    bitmask, String
    str) <- [(CheckTyEqProblem, String)]
    allBits
                 , CheckTyEqResult
    cter CheckTyEqResult -> CheckTyEqProblem -> Bool
    `cterHasProblem` CheckTyEqProblem
    bitmask ]

    allBits :: [(CheckTyEqProblem, String)]
    allBits :: [(CheckTyEqProblem, String)]
    allBits = [ (CheckTyEqProblem
    cteImpredicative,   String
    "cteImpredicative")
              , (CheckTyEqProblem
    cteTypeFamily,      String
    "cteTypeFamily")
              , (CheckTyEqProblem
    cteInsolubleOccurs, String
    "cteInsolubleOccurs")
              , (CheckTyEqProblem
    cteSolubleOccurs,   String
    "cteSolubleOccurs")
              , (CheckTyEqProblem
    cteConcrete,        String
    "cteConcrete")
              , (CheckTyEqProblem
    cteSkolemEscape,    String
    "cteSkolemEscape")
              , (CheckTyEqProblem
    cteCoercionHole,    String
    "cteCoercionHole") ]

    {- 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 DictCt,
       ctev_pred (di_ev ct) = (di_cls ct) (di_tys ct)
    This holds by construction; look at the unique place where DictCt is
    built (in GHC.Tc.Solver.Dict.canDictNC).

    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
    representation-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 = CtEvidence -> Ct
    CNonCanonical CtEvidence
    ev

    mkGivens :: CtLoc -> [EvId] -> [Ct]
    mkGivens :: CtLoc -> [EvVar] -> [Ct]
    mkGivens CtLoc
    loc [EvVar]
    ev_ids
      = (EvVar -> Ct) -> [EvVar] -> [Ct]
    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 (CEqCan (EqCt { eq_ev :: EqCt -> CtEvidence
    eq_ev = CtEvidence
    ev }))       = CtEvidence
    ev
    ctEvidence (CIrredCan (IrredCt { ir_ev :: IrredCt -> CtEvidence
    ir_ev = CtEvidence
    ev })) = CtEvidence
    ev
    ctEvidence (CNonCanonical CtEvidence
    ev)                   = CtEvidence
    ev
    ctEvidence (CDictCan (DictCt { di_ev :: DictCt -> CtEvidence
    di_ev = CtEvidence
    ev }))   = CtEvidence
    ev

    updCtEvidence :: (CtEvidence -> CtEvidence) -> Ct -> Ct
    updCtEvidence :: (CtEvidence -> CtEvidence) -> Ct -> Ct
    updCtEvidence CtEvidence -> CtEvidence
    upd Ct
    ct
     = case Ct
    ct of
         CQuantCan qci :: QCInst
    qci@(QCI { qci_ev :: QCInst -> CtEvidence
    qci_ev = CtEvidence
    ev })   -> QCInst -> Ct
    CQuantCan (QCInst
    qci { qci_ev = upd ev })
         CEqCan eq :: EqCt
    eq@(EqCt { eq_ev :: EqCt -> CtEvidence
    eq_ev = CtEvidence
    ev })       -> EqCt -> Ct
    CEqCan    (EqCt
    eq { eq_ev = upd ev })
         CIrredCan ir :: IrredCt
    ir@(IrredCt { ir_ev :: IrredCt -> CtEvidence
    ir_ev = CtEvidence
    ev }) -> IrredCt -> Ct
    CIrredCan (IrredCt
    ir { ir_ev = upd ev })
         CNonCanonical CtEvidence
    ev                      -> CtEvidence -> Ct
    CNonCanonical (CtEvidence -> CtEvidence
    upd CtEvidence
    ev)
         CDictCan di :: DictCt
    di@(DictCt { di_ev :: DictCt -> CtEvidence
    di_ev = CtEvidence
    ev })   -> DictCt -> Ct
    CDictCan (DictCt
    di { di_ev = upd ev })

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

    ctOrigin :: Ct -> CtOrigin
    ctOrigin :: Ct -> CtOrigin
    ctOrigin = CtLoc -> CtOrigin
    ctLocOrigin (CtLoc -> CtOrigin) -> (Ct -> CtLoc) -> Ct -> CtOrigin
    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)

    ctRewriters :: Ct -> RewriterSet
    ctRewriters :: Ct -> RewriterSet
    ctRewriters = CtEvidence -> RewriterSet
    ctEvRewriters (CtEvidence -> RewriterSet)
    -> (Ct -> CtEvidence) -> Ct -> RewriterSet
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Ct -> CtEvidence
    ctEvidence

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

    -- | Returns the evidence 'Id' for the argument 'Ct'
    -- when this 'Ct' is a 'Wanted'.
    --
    -- Returns 'Nothing' otherwise.
    wantedEvId_maybe :: Ct -> Maybe EvVar
    wantedEvId_maybe :: Ct -> Maybe EvVar
    wantedEvId_maybe Ct
    ct
      = case Ct -> CtEvidence
    ctEvidence Ct
    ct of
        ctev :: CtEvidence
    ctev@(CtWanted {})
          | Bool
    otherwise
          -> EvVar -> Maybe EvVar
    forall a. a -> Maybe a
    Just (EvVar -> Maybe EvVar) -> EvVar -> Maybe EvVar
    forall a b. (a -> b) -> a -> b
    $ CtEvidence -> EvVar
    ctEvEvId CtEvidence
    ctev
        CtGiven {}
          -> Maybe EvVar
    forall a. Maybe a
    Nothing

    -- | 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 (CtEvidence -> CtFlavour) -> (Ct -> CtEvidence) -> Ct -> CtFlavour
    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 (CtEvidence -> EqRel) -> (Ct -> CtEvidence) -> Ct -> EqRel
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Ct -> CtEvidence
    ctEvidence

    instance Outputable Ct where
      ppr :: Ct -> SDoc
    ppr Ct
    ct = CtEvidence -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (Ct -> CtEvidence
    ctEvidence Ct
    ct) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens SDoc
    pp_sort
        where
          pp_sort :: SDoc
    pp_sort = case Ct
    ct of
             CEqCan {}        -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CEqCan"
             CNonCanonical {} -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CNonCanonical"
             CDictCan (DictCt { di_pend_sc :: DictCt -> Int
    di_pend_sc = Int
    psc })
                | Int
    psc Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0       -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CDictCan" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "psc" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    psc)
                | Bool
    otherwise     -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CDictCan"
             CIrredCan (IrredCt { ir_reason :: IrredCt -> CtIrredReason
    ir_reason = CtIrredReason
    reason }) -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CIrredCan" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> CtIrredReason -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr CtIrredReason
    reason
             CQuantCan (QCI { qci_pend_sc :: QCInst -> Int
    qci_pend_sc = Int
    psc })
                | Int
    psc Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0  -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CQuantCan"  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "psc" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    psc)
                | Bool
    otherwise -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CQuantCan"

    instance Outputable EqCt where
      ppr :: EqCt -> SDoc
    ppr (EqCt { eq_ev :: EqCt -> CtEvidence
    eq_ev = CtEvidence
    ev }) = CtEvidence -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr CtEvidence
    ev

    -----------------------------------
    -- | 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
    getTyVar_maybe Xi
    xi
      = CanEqLHS -> Maybe CanEqLHS
    forall a. a -> Maybe a
    Just (CanEqLHS -> Maybe CanEqLHS) -> CanEqLHS -> Maybe CanEqLHS
    forall a b. (a -> b) -> a -> b
    $ EvVar -> CanEqLHS
    TyVarLHS EvVar
    tv

      | Bool
    otherwise
      = Xi -> Maybe CanEqLHS
    canTyFamEqLHS_maybe Xi
    xi

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

      | Bool
    otherwise
      = Maybe CanEqLHS
    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
    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 EvVar -> EvVar -> Bool
    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 (FV -> TcTyCoVarSet) -> (Ct -> FV) -> Ct -> TcTyCoVarSet
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Ct -> FV
    tyCoFVsOfCt

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

    -- | 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 (FV -> [EvVar]) -> (Ct -> FV) -> Ct -> [EvVar]
    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.
    tyCoVarsOfCtEvList :: CtEvidence -> [TcTyCoVar]
    tyCoVarsOfCtEvList :: CtEvidence -> [EvVar]
    tyCoVarsOfCtEvList = FV -> [EvVar]
    fvVarList (FV -> [EvVar]) -> (CtEvidence -> FV) -> CtEvidence -> [EvVar]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Xi -> FV
    tyCoFVsOfType (Xi -> FV) -> (CtEvidence -> Xi) -> CtEvidence -> FV
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CtEvidence -> Xi
    ctEvPred

    -- | 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 constraints as a composable FV computation.
    -- See Note [Deterministic FV] in GHC.Utils.FV.
    tyCoFVsOfCtEv :: CtEvidence -> FV
    tyCoFVsOfCtEv :: CtEvidence -> FV
    tyCoFVsOfCtEv CtEvidence
    ct = Xi -> FV
    tyCoFVsOfType (CtEvidence -> Xi
    ctEvPred CtEvidence
    ct)

    -- | 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 (FV -> TcTyCoVarSet) -> (Cts -> FV) -> Cts -> TcTyCoVarSet
    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 (FV -> [EvVar]) -> (Cts -> FV) -> Cts -> [EvVar]
    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.
    tyCoVarsOfCtEvsList :: [CtEvidence] -> [TcTyCoVar]
    tyCoVarsOfCtEvsList :: [CtEvidence] -> [EvVar]
    tyCoVarsOfCtEvsList = FV -> [EvVar]
    fvVarList (FV -> [EvVar]) -> ([CtEvidence] -> FV) -> [CtEvidence] -> [EvVar]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [CtEvidence] -> FV
    tyCoFVsOfCtEvs

    -- | 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 = (Ct -> FV -> FV) -> FV -> Cts -> FV
    forall a b. (a -> b -> b) -> b -> Bag a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (FV -> FV -> FV
    unionFV (FV -> FV -> FV) -> (Ct -> FV) -> Ct -> FV -> FV
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Ct -> FV
    tyCoFVsOfCt) FV
    emptyFV

    -- | Returns free variables of a bag of constraints as a composable FV
    -- computation. See Note [Deterministic FV] in GHC.Utils.FV.
    tyCoFVsOfCtEvs :: [CtEvidence] -> FV
    tyCoFVsOfCtEvs :: [CtEvidence] -> FV
    tyCoFVsOfCtEvs = (CtEvidence -> FV -> FV) -> FV -> [CtEvidence] -> FV
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (FV -> FV -> FV
    unionFV (FV -> FV -> FV) -> (CtEvidence -> FV) -> CtEvidence -> FV -> FV
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CtEvidence -> FV
    tyCoFVsOfCtEv) 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 (FV -> TcTyCoVarSet)
    -> (WantedConstraints -> FV) -> WantedConstraints -> TcTyCoVarSet
    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 (FV -> [EvVar])
    -> (WantedConstraints -> FV) -> WantedConstraints -> [EvVar]
    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_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    errors })
      = Cts -> FV
    tyCoFVsOfCts Cts
    simple FV -> FV -> FV
    `unionFV`
        (Implication -> FV) -> Bag Implication -> FV
    forall a. (a -> FV) -> Bag a -> FV
    tyCoFVsOfBag Implication -> FV
    tyCoFVsOfImplic Bag Implication
    implic FV -> FV -> FV
    `unionFV`
        (DelayedError -> FV) -> Bag DelayedError -> FV
    forall a. (a -> FV) -> Bag a -> FV
    tyCoFVsOfBag DelayedError -> FV
    tyCoFVsOfDelayedError Bag DelayedError
    errors

    -- | 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  (FV -> FV) -> FV -> FV
    forall a b. (a -> b) -> a -> b
    $
        [EvVar] -> FV -> FV
    tyCoFVsVarBndrs [EvVar]
    givens (FV -> FV) -> FV -> FV
    forall a b. (a -> b) -> a -> b
    $
        WantedConstraints -> FV
    tyCoFVsOfWC WantedConstraints
    wanted

    tyCoFVsOfDelayedError :: DelayedError -> FV
    tyCoFVsOfDelayedError :: DelayedError -> FV
    tyCoFVsOfDelayedError (DE_Hole Hole
    hole) = Hole -> FV
    tyCoFVsOfHole Hole
    hole
    tyCoFVsOfDelayedError (DE_NotConcrete {}) = FV
    emptyFV

    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 = (a -> FV -> FV) -> FV -> Bag a -> FV
    forall a b. (a -> b -> b) -> b -> Bag a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (FV -> FV -> FV
    unionFV (FV -> FV -> FV) -> (a -> FV) -> a -> FV -> FV
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> FV
    tvs_of) FV
    emptyFV

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

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

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

    isGivenCt :: Ct -> Bool
    isGivenCt :: Ct -> Bool
    isGivenCt = CtEvidence -> Bool
    isGiven (CtEvidence -> Bool) -> (Ct -> CtEvidence) -> Ct -> Bool
    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 :: PredType -> Maybe ErrorMsgType
    getUserTypeErrorMsg :: Xi -> Maybe Xi
    getUserTypeErrorMsg Xi
    pred = [Maybe Xi] -> Maybe Xi
    forall (t :: * -> *) (m :: * -> *) a.
    (Foldable t, MonadPlus m) =>
    t (m a) -> m a
    msum ([Maybe Xi] -> Maybe Xi) -> [Maybe Xi] -> Maybe Xi
    forall a b. (a -> b) -> a -> b
    $ Xi -> Maybe Xi
    userTypeError_maybe Xi
    pred
                                      Maybe Xi -> [Maybe Xi] -> [Maybe Xi]
    forall a. a -> [a] -> [a]
    : (Xi -> Maybe Xi) -> [Xi] -> [Maybe Xi]
    forall a b. (a -> b) -> [a] -> [b]
    map Xi -> Maybe Xi
    getUserTypeErrorMsg (Xi -> [Xi]
    subTys Xi
    pred)
      where
       -- Richard thinks this function is very broken. What is subTys
       -- supposed to be doing? Why are exactly-saturated tyconapps special?
       -- What stops this from accidentally ripping apart a call to TypeError?
        subTys :: Xi -> [Xi]
    subTys Xi
    t = case HasDebugCallStack => Xi -> (Xi, [Xi])
    Xi -> (Xi, [Xi])
    splitAppTys Xi
    t of
                     (Xi
    t,[]) ->
                       case HasDebugCallStack => Xi -> Maybe (TyCon, [Xi])
    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 Xi -> [Xi] -> [Xi]
    forall a. a -> [a] -> [a]
    : [Xi]
    ts

    -- | Is this an user error message type, i.e. either the form @TypeError err@ or
    -- @Unsatisfiable err@?
    isTopLevelUserTypeError :: PredType -> Bool
    isTopLevelUserTypeError :: Xi -> Bool
    isTopLevelUserTypeError Xi
    pred =
      Maybe Xi -> Bool
    forall a. Maybe a -> Bool
    isJust (Xi -> Maybe Xi
    userTypeError_maybe Xi
    pred) Bool -> Bool -> Bool
    || Maybe Xi -> Bool
    forall a. Maybe a -> Bool
    isJust (Xi -> Maybe Xi
    isUnsatisfiableCt_maybe Xi
    pred)

    -- | Does this constraint contain an user error message?
    --
    -- That is, the type is either of the form @Unsatisfiable err@, or it contains
    -- a type of the form @TypeError msg@, either at the top level or nested inside
    -- the type.
    containsUserTypeError :: PredType -> Bool
    containsUserTypeError :: Xi -> Bool
    containsUserTypeError Xi
    pred =
      Maybe Xi -> Bool
    forall a. Maybe a -> Bool
    isJust (Xi -> Maybe Xi
    getUserTypeErrorMsg Xi
    pred) Bool -> Bool -> Bool
    || Maybe Xi -> Bool
    forall a. Maybe a -> Bool
    isJust (Xi -> Maybe Xi
    isUnsatisfiableCt_maybe Xi
    pred)

    -- | Is this type an unsatisfiable constraint?
    -- If so, return the error message.
    isUnsatisfiableCt_maybe :: Type -> Maybe ErrorMsgType
    isUnsatisfiableCt_maybe :: Xi -> Maybe Xi
    isUnsatisfiableCt_maybe Xi
    t
      | Just (TyCon
    tc, [Xi
    msg]) <- HasDebugCallStack => Xi -> Maybe (TyCon, [Xi])
    Xi -> Maybe (TyCon, [Xi])
    splitTyConApp_maybe Xi
    t
      , TyCon
    tc TyCon -> Unique -> Bool
    forall a. Uniquable a => a -> Unique -> Bool
    `hasKey` Unique
    unsatisfiableClassNameKey
      = Xi -> Maybe Xi
    forall a. a -> Maybe a
    Just Xi
    msg
      | Bool
    otherwise
      = Maybe Xi
    forall a. Maybe a
    Nothing

    isPendingScDict :: Ct -> Bool
    isPendingScDict :: Ct -> Bool
    isPendingScDict (CDictCan DictCt
    dict_ct) = DictCt -> Bool
    isPendingScDictCt DictCt
    dict_ct
    isPendingScDict Ct
    _                  = Bool
    False

    isPendingScDictCt :: DictCt -> Bool
    -- Says whether this is a CDictCan with di_pend_sc has positive fuel;
    -- i.e. pending un-expanded superclasses
    isPendingScDictCt :: DictCt -> Bool
    isPendingScDictCt (DictCt { di_pend_sc :: DictCt -> Int
    di_pend_sc = Int
    f }) = Int -> Bool
    pendingFuel Int
    f

    pendingScDict_maybe :: Ct -> Maybe Ct
    -- Says whether this is a CDictCan with di_pend_sc has fuel left,
    -- AND if so exhausts the fuel so that they are not expanded again
    pendingScDict_maybe :: Ct -> Maybe Ct
    pendingScDict_maybe (CDictCan dict :: DictCt
    dict@(DictCt { di_pend_sc :: DictCt -> Int
    di_pend_sc = Int
    f }))
      | Int -> Bool
    pendingFuel Int
    f = Ct -> Maybe Ct
    forall a. a -> Maybe a
    Just (DictCt -> Ct
    CDictCan (DictCt
    dict { di_pend_sc = doNotExpand }))
      | Bool
    otherwise     = Maybe Ct
    forall a. Maybe a
    Nothing
    pendingScDict_maybe Ct
    _ = Maybe Ct
    forall a. Maybe a
    Nothing

    pendingScInst_maybe :: QCInst -> Maybe QCInst
    -- Same as isPendingScDict, but for QCInsts
    pendingScInst_maybe :: QCInst -> Maybe QCInst
    pendingScInst_maybe qci :: QCInst
    qci@(QCI { qci_pend_sc :: QCInst -> Int
    qci_pend_sc = Int
    f })
      | Int -> Bool
    pendingFuel Int
    f = QCInst -> Maybe QCInst
    forall a. a -> Maybe a
    Just (QCInst
    qci { qci_pend_sc = doNotExpand })
      | Bool
    otherwise     = Maybe QCInst
    forall a. Maybe a
    Nothing

    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 })
      = (Ct -> Bool) -> Cts -> Bool
    forall a. (a -> Bool) -> Bag a -> Bool
    anyBag Ct -> Bool
    might_help_ct Cts
    simples Bool -> Bool -> Bool
    || (Implication -> Bool) -> Bag Implication -> 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 = Bool -> Bool
    not (Ct -> Bool
    is_ip Ct
    ct)

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

    getPendingWantedScs :: Cts -> ([Ct], Cts)
    -- in the return values [Ct] has original fuel while Cts has fuel exhausted
    getPendingWantedScs :: Cts -> ([Ct], Cts)
    getPendingWantedScs Cts
    simples
      = ([Ct] -> Ct -> ([Ct], Ct)) -> [Ct] -> Cts -> ([Ct], Cts)
    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_exhausted <- Ct -> Maybe Ct
    pendingScDict_maybe Ct
    ct
                   = (Ct
    ctCt -> [Ct] -> [Ct]
    forall a. a -> [a] -> [a]
    :[Ct]
    acc, Ct
    ct_exhausted)
                   | Bool
    otherwise
                   = ([Ct]
    acc,     Ct
    ct)

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

    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

      * 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
            [W] 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 = Ct -> Cts
    forall a. a -> Bag a
    unitBag

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

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

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

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

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

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

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

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

    ctsPreds :: Cts -> [PredType]
    ctsPreds :: Cts -> [Xi]
    ctsPreds Cts
    cts = (Ct -> [Xi] -> [Xi]) -> [Xi] -> Cts -> [Xi]
    forall a b. (a -> b -> b) -> b -> Bag a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr ((:) (Xi -> [Xi] -> [Xi]) -> (Ct -> Xi) -> Ct -> [Xi] -> [Xi]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Ct -> Xi
    ctPred) [] Cts
    cts

    {-
    ************************************************************************
    *                                                                      *
                    Wanted constraints
    *                                                                      *
    ************************************************************************
    -}

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

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

    mkSimpleWC :: [CtEvidence] -> WantedConstraints
    mkSimpleWC :: [CtEvidence] -> WantedConstraints
    mkSimpleWC [CtEvidence]
    cts
      = WantedConstraints
    emptyWC { wc_simple = listToBag (map mkNonCanonical cts) }

    mkImplicWC :: Bag Implication -> WantedConstraints
    mkImplicWC :: Bag Implication -> WantedConstraints
    mkImplicWC Bag Implication
    implic
      = WantedConstraints
    emptyWC { wc_impl = 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_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    errors })
      = Cts -> Bool
    forall a. Bag a -> Bool
    isEmptyBag Cts
    f Bool -> Bool -> Bool
    && Bag Implication -> Bool
    forall a. Bag a -> Bool
    isEmptyBag Bag Implication
    i Bool -> Bool -> Bool
    && Bag DelayedError -> Bool
    forall a. Bag a -> Bool
    isEmptyBag Bag DelayedError
    errors

    -- | 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_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    errors} =
      Cts -> Bool
    forall a. Bag a -> Bool
    isEmptyBag Cts
    wc_simple Bool -> Bool -> Bool
    && (Implication -> Bool) -> Bag Implication -> Bool
    forall a. (a -> Bool) -> Bag a -> Bool
    allBag (ImplicStatus -> Bool
    isSolvedStatus (ImplicStatus -> Bool)
    -> (Implication -> ImplicStatus) -> Implication -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Implication -> ImplicStatus
    ic_status) Bag Implication
    wc_impl Bool -> Bool -> Bool
    && Bag DelayedError -> Bool
    forall a. Bag a -> Bool
    isEmptyBag Bag DelayedError
    errors

    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_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    e1 })
          (WC { wc_simple :: WantedConstraints -> Cts
    wc_simple = Cts
    f2, wc_impl :: WantedConstraints -> Bag Implication
    wc_impl = Bag Implication
    i2, wc_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    e2 })
      = WC { wc_simple :: Cts
    wc_simple = Cts
    f1 Cts -> Cts -> Cts
    forall a. Bag a -> Bag a -> Bag a
    `unionBags` Cts
    f2
           , wc_impl :: Bag Implication
    wc_impl   = Bag Implication
    i1 Bag Implication -> Bag Implication -> Bag Implication
    forall a. Bag a -> Bag a -> Bag a
    `unionBags` Bag Implication
    i2
           , wc_errors :: Bag DelayedError
    wc_errors = Bag DelayedError
    e1 Bag DelayedError -> Bag DelayedError -> Bag DelayedError
    forall a. Bag a -> Bag a -> Bag a
    `unionBags` Bag DelayedError
    e2 }

    unionsWC :: [WantedConstraints] -> WantedConstraints
    unionsWC :: [WantedConstraints] -> WantedConstraints
    unionsWC = (WantedConstraints -> WantedConstraints -> WantedConstraints)
    -> WantedConstraints -> [WantedConstraints] -> WantedConstraints
    forall a b. (a -> b -> b) -> b -> [a] -> b
    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 = wc_simple wc `unionBags` 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 = wc_impl wc `unionBags` implic }

    addInsols :: WantedConstraints -> Bag IrredCt -> WantedConstraints
    addInsols :: WantedConstraints -> Bag IrredCt -> WantedConstraints
    addInsols WantedConstraints
    wc Bag IrredCt
    insols
      = WantedConstraints
    wc { wc_simple = wc_simple wc `unionBags` fmap CIrredCan insols }

    addHoles :: WantedConstraints -> Bag Hole -> WantedConstraints
    addHoles :: WantedConstraints -> Bag Hole -> WantedConstraints
    addHoles WantedConstraints
    wc Bag Hole
    holes
      = WantedConstraints
    wc { wc_errors = mapBag DE_Hole holes `unionBags` wc_errors wc }

    addNotConcreteError :: WantedConstraints -> NotConcreteError -> WantedConstraints
    addNotConcreteError :: WantedConstraints -> NotConcreteError -> WantedConstraints
    addNotConcreteError WantedConstraints
    wc NotConcreteError
    err
      = WantedConstraints
    wc { wc_errors = unitBag (DE_NotConcrete err) `unionBags` wc_errors wc }

    addDelayedErrors :: WantedConstraints -> Bag DelayedError -> WantedConstraints
    addDelayedErrors :: WantedConstraints -> Bag DelayedError -> WantedConstraints
    addDelayedErrors WantedConstraints
    wc Bag DelayedError
    errs
      = WantedConstraints
    wc { wc_errors = errs `unionBags` wc_errors 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_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    errors })
      = WC { wc_simple :: Cts
    wc_simple = (Ct -> Bool) -> Cts -> Cts
    forall a. (a -> Bool) -> Bag a -> Bag a
    filterBag Ct -> Bool
    insolubleWantedCt Cts
    simples
           , wc_impl :: Bag Implication
    wc_impl   = (Implication -> Implication) -> Bag Implication -> Bag Implication
    forall a b. (a -> b) -> Bag a -> Bag b
    mapBag Implication -> Implication
    drop_implic Bag Implication
    implics
           , wc_errors :: Bag DelayedError
    wc_errors = (DelayedError -> Bool) -> Bag DelayedError -> Bag DelayedError
    forall a. (a -> Bool) -> Bag a -> Bag a
    filterBag DelayedError -> Bool
    keep_delayed_error Bag DelayedError
    errors }
      where
        drop_implic :: Implication -> Implication
    drop_implic Implication
    implic
          = Implication
    implic { ic_wanted = drop_wanted (ic_wanted 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_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    errors })
          = WC { wc_simple :: Cts
    wc_simple = (Ct -> Bool) -> Cts -> Cts
    forall a. (a -> Bool) -> Bag a -> Bag a
    filterBag Ct -> Bool
    keep_ct Cts
    simples
               , wc_impl :: Bag Implication
    wc_impl   = (Implication -> Implication) -> Bag Implication -> Bag Implication
    forall a b. (a -> b) -> Bag a -> Bag b
    mapBag Implication -> Implication
    drop_implic Bag Implication
    implics
               , wc_errors :: Bag DelayedError
    wc_errors  = (DelayedError -> Bool) -> Bag DelayedError -> Bag DelayedError
    forall a. (a -> Bool) -> Bag a -> Bag a
    filterBag DelayedError -> Bool
    keep_delayed_error Bag DelayedError
    errors }

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

        keep_delayed_error :: DelayedError -> Bool
    keep_delayed_error (DE_Hole Hole
    hole) = Hole -> Bool
    isOutOfScopeHole Hole
    hole
        keep_delayed_error (DE_NotConcrete {}) = 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)

    -- | Gather all the type variables from 'WantedConstraints'
    -- that it would be unhelpful to default. For the moment,
    -- these are only 'ConcreteTv' metavariables participating
    -- in a nominal equality whose other side is not concrete;
    -- it's usually better to report those as errors instead of
    -- defaulting.
    nonDefaultableTyVarsOfWC :: WantedConstraints -> TyCoVarSet
    -- Currently used in simplifyTop and in tcRule.
    -- TODO: should we also use this in decideQuantifiedTyVars, kindGeneralize{All,Some}?
    nonDefaultableTyVarsOfWC :: WantedConstraints -> TcTyCoVarSet
    nonDefaultableTyVarsOfWC (WC { wc_simple :: WantedConstraints -> Cts
    wc_simple = Cts
    simples, wc_impl :: WantedConstraints -> Bag Implication
    wc_impl = Bag Implication
    implics, wc_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    errs })
      =             (Ct -> TcTyCoVarSet) -> Cts -> TcTyCoVarSet
    forall a. (a -> TcTyCoVarSet) -> Bag a -> TcTyCoVarSet
    concatMapBag Ct -> TcTyCoVarSet
    non_defaultable_tvs_of_ct Cts
    simples
      TcTyCoVarSet -> TcTyCoVarSet -> TcTyCoVarSet
    `unionVarSet` (Implication -> TcTyCoVarSet) -> Bag Implication -> TcTyCoVarSet
    forall a. (a -> TcTyCoVarSet) -> Bag a -> TcTyCoVarSet
    concatMapBag (WantedConstraints -> TcTyCoVarSet
    nonDefaultableTyVarsOfWC (WantedConstraints -> TcTyCoVarSet)
    -> (Implication -> WantedConstraints)
    -> Implication
    -> TcTyCoVarSet
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Implication -> WantedConstraints
    ic_wanted) Bag Implication
    implics
      TcTyCoVarSet -> TcTyCoVarSet -> TcTyCoVarSet
    `unionVarSet` (DelayedError -> TcTyCoVarSet) -> Bag DelayedError -> TcTyCoVarSet
    forall a. (a -> TcTyCoVarSet) -> Bag a -> TcTyCoVarSet
    concatMapBag DelayedError -> TcTyCoVarSet
    non_defaultable_tvs_of_err Bag DelayedError
    errs
        where

          concatMapBag :: (a -> TyVarSet) -> Bag a -> TyCoVarSet
          concatMapBag :: forall a. (a -> TcTyCoVarSet) -> Bag a -> TcTyCoVarSet
    concatMapBag a -> TcTyCoVarSet
    f = (a -> TcTyCoVarSet -> TcTyCoVarSet)
    -> TcTyCoVarSet -> Bag a -> TcTyCoVarSet
    forall a b. (a -> b -> b) -> b -> Bag a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\ a
    r TcTyCoVarSet
    acc -> a -> TcTyCoVarSet
    f a
    r TcTyCoVarSet -> TcTyCoVarSet -> TcTyCoVarSet
    `unionVarSet` TcTyCoVarSet
    acc) TcTyCoVarSet
    emptyVarSet

          -- Don't default ConcreteTv metavariables involved
          -- in an equality with something non-concrete: it's usually
          -- better to report the unsolved Wanted.
          --
          -- Example: alpha[conc] ~# rr[sk].
          non_defaultable_tvs_of_ct :: Ct -> TyCoVarSet
          non_defaultable_tvs_of_ct :: Ct -> TcTyCoVarSet
    non_defaultable_tvs_of_ct Ct
    ct =
            -- NB: using classifyPredType instead of inspecting the Ct
            -- so that we deal uniformly with CNonCanonical (which come up in tcRule),
            -- CEqCan (unsolved but potentially soluble, e.g. @alpha[conc] ~# RR@)
            -- and CIrredCan.
            case Xi -> Pred
    classifyPredType (Xi -> Pred) -> Xi -> Pred
    forall a b. (a -> b) -> a -> b
    $ Ct -> Xi
    ctPred Ct
    ct of
              EqPred EqRel
    NomEq Xi
    lhs Xi
    rhs
                | Just EvVar
    tv <- Xi -> Maybe EvVar
    getTyVar_maybe Xi
    lhs
                , EvVar -> Bool
    isConcreteTyVar EvVar
    tv
                , Bool -> Bool
    not (Xi -> Bool
    isConcreteType Xi
    rhs)
                -> EvVar -> TcTyCoVarSet
    unitVarSet EvVar
    tv
                | Just EvVar
    tv <- Xi -> Maybe EvVar
    getTyVar_maybe Xi
    rhs
                , EvVar -> Bool
    isConcreteTyVar EvVar
    tv
                , Bool -> Bool
    not (Xi -> Bool
    isConcreteType Xi
    lhs)
                -> EvVar -> TcTyCoVarSet
    unitVarSet EvVar
    tv
              Pred
    _ -> TcTyCoVarSet
    emptyVarSet

          -- Make sure to apply the same logic as above to delayed errors.
          non_defaultable_tvs_of_err :: DelayedError -> TcTyCoVarSet
    non_defaultable_tvs_of_err (DE_NotConcrete NotConcreteError
    err)
            = case NotConcreteError
    err of
                NCE_FRR { nce_frr_origin :: NotConcreteError -> FixedRuntimeRepOrigin
    nce_frr_origin = FixedRuntimeRepOrigin
    frr } -> Xi -> TcTyCoVarSet
    tyCoVarsOfType (FixedRuntimeRepOrigin -> Xi
    frr_type FixedRuntimeRepOrigin
    frr)
          non_defaultable_tvs_of_err (DE_Hole {}) = TcTyCoVarSet
    emptyVarSet

    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_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    errors })
      =  (Ct -> Bool) -> Cts -> Bool
    forall a. (a -> Bool) -> Bag a -> Bool
    anyBag Ct -> Bool
    insolubleWantedCt Cts
    simples
      Bool -> Bool -> Bool
    || (Implication -> Bool) -> Bag Implication -> Bool
    forall a. (a -> Bool) -> Bag a -> Bool
    anyBag Implication -> Bool
    insolubleImplic Bag Implication
    implics
      Bool -> Bool -> Bool
    || (DelayedError -> Bool) -> Bag DelayedError -> Bool
    forall a. (a -> Bool) -> Bag a -> Bool
    anyBag DelayedError -> Bool
    is_insoluble Bag DelayedError
    errors

        where
          is_insoluble :: DelayedError -> Bool
    is_insoluble (DE_Hole Hole
    hole) = Hole -> Bool
    isOutOfScopeHole Hole
    hole -- See Note [Insoluble holes]
          is_insoluble (DE_NotConcrete {}) = Bool
    True

    insolubleWantedCt :: Ct -> Bool
    -- Definitely insoluble, in particular /excluding/ type-hole constraints
    -- Namely:
    --   a) an insoluble constraint as per 'insolubleCt', i.e. either
    --        - an insoluble equality constraint (e.g. Int ~ Bool), or
    --        - a custom type error constraint, TypeError msg :: Constraint
    --   b) that does not arise from a Given or a Wanted/Wanted fundep interaction
    --
    -- See Note [Given insolubles].
    insolubleWantedCt :: Ct -> Bool
    insolubleWantedCt Ct
    ct = Ct -> Bool
    insolubleCt Ct
    ct Bool -> Bool -> Bool
    &&
                           Bool -> Bool
    not (Ct -> Bool
    arisesFromGivens Ct
    ct) Bool -> Bool -> Bool
    &&
                           Bool -> Bool
    not (CtOrigin -> Bool
    isWantedWantedFunDepOrigin (Ct -> CtOrigin
    ctOrigin Ct
    ct))

    insolubleIrredCt :: IrredCt -> Bool
    -- Returns True of Irred constraints that are /definitely/ insoluble
    --
    -- This function is critical for accurate pattern-match overlap warnings.
    -- See Note [Pattern match warnings with insoluble Givens] in GHC.Tc.Solver
    --
    -- Note that this does not traverse through the constraint to find
    -- nested custom type errors: it only detects @TypeError msg :: Constraint@,
    -- and not e.g. @Eq (TypeError msg)@.
    insolubleIrredCt :: IrredCt -> Bool
    insolubleIrredCt (IrredCt { ir_ev :: IrredCt -> CtEvidence
    ir_ev = CtEvidence
    ev, ir_reason :: IrredCt -> CtIrredReason
    ir_reason = CtIrredReason
    reason })
      =  CtIrredReason -> Bool
    isInsolubleReason CtIrredReason
    reason
      Bool -> Bool -> Bool
    || Xi -> Bool
    isTopLevelUserTypeError (CtEvidence -> Xi
    ctEvPred CtEvidence
    ev)
      -- NB: 'isTopLevelUserTypeError' detects constraints of the form "TypeError msg"
      -- and "Unsatisfiable msg". It deliberately does not detect TypeError
      -- nested in a type (e.g. it does not use "containsUserTypeError"), as that
      -- would be too eager: the TypeError might appear inside a type family
      -- application which might later reduce, but we only want to return 'True'
      -- for constraints that are definitely insoluble.
      --
      -- For example: Num (F Int (TypeError "msg")), where F is a type family.
      --
      -- Test case: T11503, with the 'Assert' type family:
      --
      -- > type Assert :: Bool -> Constraint -> Constraint
      -- > type family Assert check errMsg where
      -- >   Assert 'True  _errMsg = ()
      -- >   Assert _check errMsg  = errMsg

    -- | Returns True of constraints that are definitely insoluble,
    --   as well as TypeError constraints.
    -- Can return 'True' for Given constraints, unlike 'insolubleWantedCt'.
    --
    -- The function is tuned for application /after/ constraint solving
    --       i.e. assuming canonicalisation has been done
    -- That's why it looks only for IrredCt; all insoluble constraints
    -- are put into CIrredCan
    insolubleCt :: Ct -> Bool
    insolubleCt :: Ct -> Bool
    insolubleCt (CIrredCan IrredCt
    ir_ct) = IrredCt -> Bool
    insolubleIrredCt IrredCt
    ir_ct
    insolubleCt 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 -> RdrName
    hole_occ = RdrName
    occ }) = Bool -> Bool
    not (OccName -> Bool
    startsWithUnderscore (RdrName -> OccName
    forall name. HasOccName name => name -> OccName
    occName RdrName
    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_errors :: WantedConstraints -> Bag DelayedError
    wc_errors = Bag DelayedError
    e})
       = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "WC" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat
            [ SDoc -> Cts -> SDoc
    forall a. Outputable a => SDoc -> Bag a -> SDoc
    ppr_bag (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "wc_simple") Cts
    s
            , SDoc -> Bag Implication -> SDoc
    forall a. Outputable a => SDoc -> Bag a -> SDoc
    ppr_bag (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "wc_impl") Bag Implication
    i
            , SDoc -> Bag DelayedError -> SDoc
    forall a. Outputable a => SDoc -> Bag a -> SDoc
    ppr_bag (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "wc_errors") Bag DelayedError
    e ])

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

    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 -> SkolemInfoAnon
    ic_info  :: SkolemInfoAnon,    -- See Note [Skolems in an implication]
                                         -- See Note [Shadowing in a constraint]

          Implication -> [EvVar]
    ic_skols :: [TcTyVar],     -- Introduced skolems; always skolem TcTyVars
                                     -- Their level numbers should be precisely ic_tclvl
                                     -- Their SkolemInfo should be precisely ic_info (almost)
                                     --       See Note [Implication invariants]

          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 <=> we should report inaccessible code
                                     -- Note [Avoid -Winaccessible-code when deriving]
                                     -- in GHC.Tc.TyCl.Instance

          Implication -> CtLocEnv
    ic_env   :: !CtLocEnv,
                                     -- Records the context at the time of creation.
                                     --
                                     -- This provides all the information needed about
                                     -- the context to report the source of errors linked
                                     -- to this implication.

          Implication -> WantedConstraints
    ic_wanted :: WantedConstraints,  -- The wanteds
                                           -- See Invariant (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]
          -- and (RC2) in Note [Tracking redundant constraints]a
          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 :: CtLocEnv -> Implication
    implicationPrototype :: CtLocEnv -> Implication
    implicationPrototype CtLocEnv
    ct_loc_env
       = Implic { -- These fields must be initialised
                  ic_tclvl :: TcLevel
    ic_tclvl      = String -> TcLevel
    forall a. HasCallStack => String -> a
    panic String
    "newImplic:tclvl"
                , ic_binds :: EvBindsVar
    ic_binds      = String -> EvBindsVar
    forall a. HasCallStack => String -> a
    panic String
    "newImplic:binds"
                , ic_info :: SkolemInfoAnon
    ic_info       = String -> SkolemInfoAnon
    forall a. HasCallStack => String -> a
    panic String
    "newImplic:info"
                , ic_warn_inaccessible :: Bool
    ic_warn_inaccessible = String -> Bool
    forall a. HasCallStack => String -> a
    panic String
    "newImplic:warn_inaccessible"

                , ic_env :: CtLocEnv
    ic_env        = CtLocEnv
    ct_loc_env
                  -- 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 Wanted 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.InertSet
      | 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
    (HasGivenEqs -> HasGivenEqs -> Bool)
    -> (HasGivenEqs -> HasGivenEqs -> Bool) -> Eq HasGivenEqs
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HasGivenEqs -> HasGivenEqs -> Bool
    == :: HasGivenEqs -> HasGivenEqs -> Bool
    $c/= :: HasGivenEqs -> HasGivenEqs -> Bool
    /= :: HasGivenEqs -> HasGivenEqs -> Bool
    Eq

    type UserGiven = Implication

    getUserGivensFromImplics :: [Implication] -> [UserGiven]
    getUserGivensFromImplics :: [Implication] -> [Implication]
    getUserGivensFromImplics [Implication]
    implics
      = [Implication] -> [Implication]
    forall a. [a] -> [a]
    reverse ((Implication -> Bool) -> [Implication] -> [Implication]
    forall a. (a -> Bool) -> [a] -> [a]
    filterOut ([EvVar] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null ([EvVar] -> Bool)
    -> (Implication -> [EvVar]) -> Implication -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Implication -> [EvVar]
    ic_given) [Implication]
    implics)

    {- 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.InertSet
      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 principal 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 -> SkolemInfoAnon
    ic_info = SkolemInfoAnon
    info })
       = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Implic" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    forall doc. IsLine doc => doc
    lbrace)
            Int
    2 ([SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep [ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "TcLevel =" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TcLevel -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TcLevel
    tclvl
                   , String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Skolems =" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [EvVar] -> SDoc
    pprTyVars [EvVar]
    skols
                   , String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Given-eqs =" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> HasGivenEqs -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HasGivenEqs
    given_eqs
                   , String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Status =" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> ImplicStatus -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ImplicStatus
    status
                   , SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Given =")  Int
    2 ([EvVar] -> SDoc
    pprEvVars [EvVar]
    given)
                   , SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Wanted =") Int
    2 (WantedConstraints -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr WantedConstraints
    wanted)
                   , String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Binds =" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EvBindsVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EvBindsVar
    binds
                   , SDoc -> SDoc
    forall doc. IsOutput doc => doc -> doc
    whenPprDebug (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Needed inner =" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TcTyCoVarSet -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TcTyCoVarSet
    need_in)
                   , SDoc -> SDoc
    forall doc. IsOutput doc => doc -> doc
    whenPprDebug (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Needed outer =" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TcTyCoVarSet -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TcTyCoVarSet
    need_out)
                   , SkolemInfoAnon -> SDoc
    pprSkolInfo SkolemInfoAnon
    info ] SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    forall doc. IsLine doc => doc
    rbrace)

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

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

    instance Outputable HasGivenEqs where
      ppr :: HasGivenEqs -> SDoc
    ppr HasGivenEqs
    NoGivenEqs    = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NoGivenEqs"
      ppr HasGivenEqs
    LocalGivenEqs = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "LocalGivenEqs"
      ppr HasGivenEqs
    MaybeGivenEqs = String -> SDoc
    forall doc. IsLine doc => String -> doc
    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 fresh 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'

    ************************************************************************
    *                                                                      *
                Invariant checking (debug only)
    *                                                                      *
    ************************************************************************

    Note [Implication invariants]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The skolems of an implication have the following invariants, which are checked
    by checkImplicationInvariants:

    a) They are all SkolemTv TcTyVars; no TyVars, no unification variables
    b) Their TcLevel matches the ic_lvl for the implication
    c) Their SkolemInfo matches the implication.

    Actually (c) is not quite true.  Consider
       data T a = forall b. MkT a b

    In tcConDecl for MkT we'll create an implication with ic_info of
    DataConSkol; but the type variable 'a' will have a SkolemInfo of
    TyConSkol.  So we allow the tyvar to have a SkolemInfo of TyConFlav if
    the implication SkolemInfo is DataConSkol.
    -}

    checkImplicationInvariants, check_implic :: (HasCallStack, Applicative m) => Implication -> m ()
    {-# INLINE checkImplicationInvariants #-}
    -- Nothing => OK, Just doc => doc gives info
    checkImplicationInvariants :: forall (m :: * -> *).
    (HasCallStack, Applicative m) =>
    Implication -> m ()
    checkImplicationInvariants Implication
    implic = Bool -> m () -> m ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when Bool
    debugIsOn (Implication -> m ()
    forall (m :: * -> *).
    (HasCallStack, Applicative m) =>
    Implication -> m ()
    check_implic Implication
    implic)

    check_implic :: forall (m :: * -> *).
    (HasCallStack, Applicative m) =>
    Implication -> m ()
    check_implic implic :: Implication
    implic@(Implic { ic_tclvl :: Implication -> TcLevel
    ic_tclvl = TcLevel
    lvl
                                , ic_info :: Implication -> SkolemInfoAnon
    ic_info = SkolemInfoAnon
    skol_info
                                , ic_skols :: Implication -> [EvVar]
    ic_skols = [EvVar]
    skols })
      | [SDoc] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [SDoc]
    bads = () -> m ()
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ()
      | Bool
    otherwise = Bool -> SDoc -> m ()
    forall (m :: * -> *).
    (HasCallStack, Applicative m) =>
    Bool -> SDoc -> m ()
    massertPpr Bool
    False ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "checkImplicationInvariants failure"
                                           , Int -> SDoc -> SDoc
    nest Int
    2 ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [SDoc]
    bads)
                                           , Implication -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Implication
    implic ])
      where
        bads :: [SDoc]
    bads = (EvVar -> Maybe SDoc) -> [EvVar] -> [SDoc]
    forall a b. (a -> Maybe b) -> [a] -> [b]
    mapMaybe EvVar -> Maybe SDoc
    check [EvVar]
    skols

        check :: TcTyVar -> Maybe SDoc
        check :: EvVar -> Maybe SDoc
    check EvVar
    tv | Bool -> Bool
    not (EvVar -> Bool
    isTcTyVar EvVar
    tv)
                 = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just (EvVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EvVar
    tv SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "is not a TcTyVar")
                 | Bool
    otherwise
                 = EvVar -> TcTyVarDetails -> Maybe SDoc
    check_details EvVar
    tv (EvVar -> TcTyVarDetails
    tcTyVarDetails EvVar
    tv)

        check_details :: TcTyVar -> TcTyVarDetails -> Maybe SDoc
        check_details :: EvVar -> TcTyVarDetails -> Maybe SDoc
    check_details EvVar
    tv (SkolemTv SkolemInfo
    tv_skol_info TcLevel
    tv_lvl Bool
    _)
          | Bool -> Bool
    not (TcLevel
    tv_lvl TcLevel -> TcLevel -> Bool
    forall a. Eq a => a -> a -> Bool
    == TcLevel
    lvl)
          = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ EvVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EvVar
    tv SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "has level" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TcLevel -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TcLevel
    tv_lvl
                       , String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ic_lvl" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TcLevel -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TcLevel
    lvl ])
          | Bool -> Bool
    not (SkolemInfoAnon
    skol_info SkolemInfoAnon -> SkolemInfoAnon -> Bool
    `checkSkolInfoAnon` SkolemInfoAnon
    skol_info_anon)
          = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ EvVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EvVar
    tv SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "has skol info" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SkolemInfoAnon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr SkolemInfoAnon
    skol_info_anon
                       , String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ic_info" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SkolemInfoAnon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr SkolemInfoAnon
    skol_info ])
          | Bool
    otherwise
          = Maybe SDoc
    forall a. Maybe a
    Nothing
          where
            skol_info_anon :: SkolemInfoAnon
    skol_info_anon = SkolemInfo -> SkolemInfoAnon
    getSkolemInfo SkolemInfo
    tv_skol_info
        check_details EvVar
    tv TcTyVarDetails
    details
          = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just (EvVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EvVar
    tv SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "is not a SkolemTv" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TcTyVarDetails -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TcTyVarDetails
    details)

    checkSkolInfoAnon :: SkolemInfoAnon   -- From the implication
                      -> SkolemInfoAnon   -- From the type variable
                      -> Bool             -- True <=> ok
    -- Used only for debug-checking; checkImplicationInvariants
    -- So it doesn't matter much if its's incomplete
    checkSkolInfoAnon :: SkolemInfoAnon -> SkolemInfoAnon -> Bool
    checkSkolInfoAnon SkolemInfoAnon
    sk1 SkolemInfoAnon
    sk2 = SkolemInfoAnon -> SkolemInfoAnon -> Bool
    go SkolemInfoAnon
    sk1 SkolemInfoAnon
    sk2
      where
        go :: SkolemInfoAnon -> SkolemInfoAnon -> Bool
    go (SigSkol UserTypeCtxt
    c1 Xi
    t1 [(Name, EvVar)]
    s1)   (SigSkol UserTypeCtxt
    c2 Xi
    t2 [(Name, EvVar)]
    s2)   = UserTypeCtxt
    c1UserTypeCtxt -> UserTypeCtxt -> Bool
    forall a. Eq a => a -> a -> Bool
    ==UserTypeCtxt
    c2 Bool -> Bool -> Bool
    && Xi
    t1 HasDebugCallStack => Xi -> Xi -> Bool
    Xi -> Xi -> Bool
    `tcEqType` Xi
    t2 Bool -> Bool -> Bool
    && [(Name, EvVar)]
    s1[(Name, EvVar)] -> [(Name, EvVar)] -> Bool
    forall a. Eq a => a -> a -> Bool
    ==[(Name, EvVar)]
    s2
        go (SigTypeSkol UserTypeCtxt
    cx1)    (SigTypeSkol UserTypeCtxt
    cx2)    = UserTypeCtxt
    cx1UserTypeCtxt -> UserTypeCtxt -> Bool
    forall a. Eq a => a -> a -> Bool
    ==UserTypeCtxt
    cx2

        go (ForAllSkol TyVarBndrs
    _)       (ForAllSkol TyVarBndrs
    _)       = Bool
    True

        go (IPSkol [HsIPName]
    ips1)        (IPSkol [HsIPName]
    ips2)        = [HsIPName]
    ips1 [HsIPName] -> [HsIPName] -> Bool
    forall a. Eq a => a -> a -> Bool
    == [HsIPName]
    ips2
        go (DerivSkol Xi
    pred1)    (DerivSkol Xi
    pred2)    = Xi
    pred1 HasDebugCallStack => Xi -> Xi -> Bool
    Xi -> Xi -> Bool
    `tcEqType` Xi
    pred2
        go (TyConSkol TyConFlavour TyCon
    f1 Name
    n1)    (TyConSkol TyConFlavour TyCon
    f2 Name
    n2)    = TyConFlavour TyCon
    f1TyConFlavour TyCon -> TyConFlavour TyCon -> Bool
    forall a. Eq a => a -> a -> Bool
    ==TyConFlavour TyCon
    f2 Bool -> Bool -> Bool
    && Name
    n1Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Name
    n2
        go (DataConSkol Name
    n1)     (DataConSkol Name
    n2)     = Name
    n1Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Name
    n2
        go (InstSkol {})        (InstSkol {})        = Bool
    True
        go SkolemInfoAnon
    FamInstSkol          SkolemInfoAnon
    FamInstSkol          = Bool
    True
        go SkolemInfoAnon
    BracketSkol          SkolemInfoAnon
    BracketSkol          = Bool
    True
        go (RuleSkol RuleName
    n1)        (RuleSkol RuleName
    n2)        = RuleName
    n1RuleName -> RuleName -> Bool
    forall a. Eq a => a -> a -> Bool
    ==RuleName
    n2
        go (PatSkol ConLike
    c1 HsMatchContextRn
    _)       (PatSkol ConLike
    c2 HsMatchContextRn
    _)       = ConLike -> Name
    forall a. NamedThing a => a -> Name
    getName ConLike
    c1 Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    == ConLike -> Name
    forall a. NamedThing a => a -> Name
    getName ConLike
    c2
           -- Too tedious to compare the HsMatchContexts
        go (InferSkol [(Name, Xi)]
    ids1)     (InferSkol [(Name, Xi)]
    ids2)     = [(Name, Xi)] -> [(Name, Xi)] -> Bool
    forall a b. [a] -> [b] -> Bool
    equalLength [(Name, Xi)]
    ids1 [(Name, Xi)]
    ids2 Bool -> Bool -> Bool
    &&
                                                       [Bool] -> Bool
    forall (t :: * -> *). Foldable t => t Bool -> Bool
    and (((Name, Xi) -> (Name, Xi) -> Bool)
    -> [(Name, Xi)] -> [(Name, Xi)] -> [Bool]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith (Name, Xi) -> (Name, Xi) -> Bool
    eq_pr [(Name, Xi)]
    ids1 [(Name, Xi)]
    ids2)
        go (UnifyForAllSkol Xi
    t1) (UnifyForAllSkol Xi
    t2) = Xi
    t1 HasDebugCallStack => Xi -> Xi -> Bool
    Xi -> Xi -> Bool
    `tcEqType` Xi
    t2
        go SkolemInfoAnon
    ReifySkol            SkolemInfoAnon
    ReifySkol            = Bool
    True
        go SkolemInfoAnon
    RuntimeUnkSkol       SkolemInfoAnon
    RuntimeUnkSkol       = Bool
    True
        go SkolemInfoAnon
    ArrowReboundIfSkol   SkolemInfoAnon
    ArrowReboundIfSkol   = Bool
    True
        go (UnkSkol CallStack
    _)          (UnkSkol CallStack
    _)          = Bool
    True

        -------- Three slightly strange special cases --------
        go (DataConSkol Name
    _)      (TyConSkol TyConFlavour TyCon
    f Name
    _)      = TyConFlavour TyCon -> Bool
    forall {tc}. TyConFlavour tc -> Bool
    h98_data_decl TyConFlavour TyCon
    f
        -- In the H98 declaration  data T a = forall b. MkT a b
        -- in tcConDecl for MkT we'll have a SkolemInfo in the implication of
        -- DataConSkol, but the type variable 'a' will have a SkolemInfo of TyConSkol

        go (DataConSkol Name
    _)      SkolemInfoAnon
    FamInstSkol          = Bool
    True
        -- In  data/newtype instance T a = MkT (a -> a),
        -- in tcConDecl for MkT we'll have a SkolemInfo in the implication of
        -- DataConSkol, but 'a' will have SkolemInfo of FamInstSkol

        go SkolemInfoAnon
    FamInstSkol          (InstSkol {})         = Bool
    True
        -- In instance C (T a) where { type F (T a) b = ... }
        -- we have 'a' with SkolemInfo InstSkol, but we make an implication wi
        -- SkolemInfo of FamInstSkol.  Very like the ConDecl/TyConSkol case

        go (ForAllSkol TyVarBndrs
    _)       SkolemInfoAnon
    _                    = Bool
    True
        -- Telescope tests: we need a ForAllSkol to force the telescope
        -- test, but the skolems might come from (say) a family instance decl
        --    type instance forall a. F [a] = a->a

        go (SigTypeSkol UserTypeCtxt
    DerivClauseCtxt) (TyConSkol TyConFlavour TyCon
    f Name
    _) = TyConFlavour TyCon -> Bool
    forall {tc}. TyConFlavour tc -> Bool
    h98_data_decl TyConFlavour TyCon
    f
        -- e.g.   newtype T a = MkT ... deriving blah
        -- We use the skolems from T (TyConSkol) when typechecking
        -- the deriving clauses (SigTypeSkol DerivClauseCtxt)

        go SkolemInfoAnon
    _ SkolemInfoAnon
    _ = Bool
    False

        eq_pr :: (Name,TcType) -> (Name,TcType) -> Bool
        eq_pr :: (Name, Xi) -> (Name, Xi) -> Bool
    eq_pr (Name
    i1,Xi
    _) (Name
    i2,Xi
    _) = Name
    i1Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Name
    i2 -- Types may be differently zonked

        h98_data_decl :: TyConFlavour tc -> Bool
    h98_data_decl TyConFlavour tc
    DataTypeFlavour = Bool
    True
        h98_data_decl TyConFlavour tc
    NewtypeFlavour  = Bool
    True
        h98_data_decl TyConFlavour tc
    _               = Bool
    False

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

    pprEvVars :: [EvVar] -> SDoc    -- Print with their types
    pprEvVars :: [EvVar] -> SDoc
    pprEvVars [EvVar]
    ev_vars = [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat ((EvVar -> SDoc) -> [EvVar] -> [SDoc]
    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 ((EvVar -> Xi) -> [EvVar] -> [Xi]
    forall a b. (a -> b) -> [a] -> [b]
    map EvVar -> Xi
    evVarPred [EvVar]
    ev_vars)

    pprEvVarWithType :: EvVar -> SDoc
    pprEvVarWithType :: EvVar -> SDoc
    pprEvVarWithType EvVar
    v = EvVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EvVar
    v SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> 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 (Xi -> Xi) -> Xi -> Xi
    forall a b. (a -> b) -> a -> b
    $ [Xi] -> Xi -> Xi
    HasDebugCallStack => [Xi] -> Xi -> Xi
    mkPhiTy [Xi]
    givens Xi
    ty

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

    Note [CtEvidence invariants]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The `ctev_pred` field of a `CtEvidence` is a just a cache for the type
    of the evidence. More precisely:

    * For Givens, `ctev_pred` = `varType ctev_evar`
    * For Wanteds, `ctev_pred` = `evDestType ctev_dest`

    where

      evDestType :: TcEvDest -> TcType
      evDestType (EvVarDest evVar)       = varType evVar
      evDestType (HoleDest coercionHole) = varType (coHoleCoVar coercionHole)

    The invariant is maintained by `setCtEvPredType`, the only function that
    updates the `ctev_pred` field of a `CtEvidence`.

    Why is the invariant important? Because when the evidence is a coercion, it may
    be used in (CastTy ty co); and then we may call `typeKind` on that type (e.g.
    in the kind-check of `eqType`); and expect to see a fully zonked kind.
    (This came up in test T13333, in the MR that fixed #20641, namely !6942.)

    Historical Note [Evidence field of CtEvidence]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In the past we tried leaving the `ctev_evar`/`ctev_dest` field of a
    constraint untouched (and hence un-zonked) on the grounds that it is
    never looked at.  But in fact it is: the evidence can become part of a
    type (via `CastTy ty kco`) and we may later ask the kind of that type
    and expect a zonked result.  (For example, in the kind-check
    of `eqType`.)

    The safest thing is simply to keep `ctev_evar`/`ctev_dest` in sync
    with `ctev_pref`, as stated in `Note [CtEvidence invariants]`.

    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 use HoleDest,
    --  - other Wanteds use 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 [CtEvidence invariants]
          , CtEvidence -> CtLoc
    ctev_loc  :: CtLoc }

      | CtWanted   -- Wanted goal
          { ctev_pred      :: TcPredType     -- See Note [Ct/evidence invariant]
          , CtEvidence -> TcEvDest
    ctev_dest      :: TcEvDest       -- See Note [CtEvidence invariants]
          , ctev_loc       :: CtLoc
          , CtEvidence -> RewriterSet
    ctev_rewriters :: RewriterSet }  -- See Note [Wanteds rewrite Wanteds]

    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 (CtLoc -> CtOrigin)
    -> (CtEvidence -> CtLoc) -> CtEvidence -> CtOrigin
    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 (Xi -> EqRel) -> (CtEvidence -> Xi) -> CtEvidence -> EqRel
    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 (EqRel -> Role) -> (CtEvidence -> EqRel) -> CtEvidence -> Role
    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 (HasDebugCallStack => CtEvidence -> EvExpr
    CtEvidence -> EvExpr
    ctEvExpr CtEvidence
    ev)

    -- | Extract the set of rewriters from a 'CtEvidence'
    -- See Note [Wanteds rewrite Wanteds]
    -- If the provided CtEvidence is not for a Wanted, just
    -- return an empty set.
    ctEvRewriters :: CtEvidence -> RewriterSet
    ctEvRewriters :: CtEvidence -> RewriterSet
    ctEvRewriters (CtWanted { ctev_rewriters :: CtEvidence -> RewriterSet
    ctev_rewriters = RewriterSet
    rewriters }) = RewriterSet
    rewriters
    ctEvRewriters CtEvidence
    _other                                    = RewriterSet
    emptyRewriterSet

    ctEvExpr :: HasDebugCallStack => CtEvidence -> EvExpr
    ctEvExpr :: HasDebugCallStack => CtEvidence -> EvExpr
    ctEvExpr ev :: CtEvidence
    ev@(CtWanted { ctev_dest :: CtEvidence -> TcEvDest
    ctev_dest = HoleDest CoercionHole
    _ })
                = Coercion -> EvExpr
    forall b. Coercion -> Expr b
    Coercion (Coercion -> EvExpr) -> Coercion -> EvExpr
    forall a b. (a -> b) -> a -> b
    $ HasDebugCallStack => CtEvidence -> Coercion
    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
    mkCoVarCo 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
      = String -> SDoc -> Coercion
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "ctEvCoercion" (CtEvidence -> SDoc
    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

    ctEvUnique :: CtEvidence -> Unique
    ctEvUnique :: CtEvidence -> Unique
    ctEvUnique (CtGiven { ctev_evar :: CtEvidence -> EvVar
    ctev_evar = EvVar
    ev })    = EvVar -> Unique
    varUnique EvVar
    ev
    ctEvUnique (CtWanted { ctev_dest :: CtEvidence -> TcEvDest
    ctev_dest = TcEvDest
    dest }) = TcEvDest -> Unique
    tcEvDestUnique TcEvDest
    dest

    tcEvDestUnique :: TcEvDest -> Unique
    tcEvDestUnique :: TcEvDest -> Unique
    tcEvDestUnique (EvVarDest EvVar
    ev_var) = EvVar -> Unique
    varUnique EvVar
    ev_var
    tcEvDestUnique (HoleDest CoercionHole
    co_hole) = EvVar -> Unique
    varUnique (CoercionHole -> EvVar
    coHoleCoVar CoercionHole
    co_hole)

    setCtEvLoc :: CtEvidence -> CtLoc -> CtEvidence
    setCtEvLoc :: CtEvidence -> CtLoc -> CtEvidence
    setCtEvLoc CtEvidence
    ctev CtLoc
    loc = CtEvidence
    ctev { ctev_loc = loc }

    arisesFromGivens :: Ct -> Bool
    arisesFromGivens :: Ct -> Bool
    arisesFromGivens Ct
    ct = Ct -> Bool
    isGivenCt Ct
    ct Bool -> Bool -> Bool
    || CtLoc -> Bool
    isGivenLoc (Ct -> CtLoc
    ctLoc Ct
    ct)

    -- | Set the type of CtEvidence.
    --
    -- This function ensures that the invariants on 'CtEvidence' hold, by updating
    -- the evidence and the ctev_pred in sync with each other.
    -- See Note [CtEvidence invariants].
    setCtEvPredType :: HasDebugCallStack => CtEvidence -> Type -> CtEvidence
    setCtEvPredType :: HasDebugCallStack => CtEvidence -> Xi -> CtEvidence
    setCtEvPredType old_ctev :: CtEvidence
    old_ctev@(CtGiven { ctev_evar :: CtEvidence -> EvVar
    ctev_evar = EvVar
    ev }) Xi
    new_pred
      = CtEvidence
    old_ctev { ctev_pred = new_pred
                 , ctev_evar = setVarType ev new_pred }

    setCtEvPredType old_ctev :: CtEvidence
    old_ctev@(CtWanted { ctev_dest :: CtEvidence -> TcEvDest
    ctev_dest = TcEvDest
    dest }) Xi
    new_pred
      = CtEvidence
    old_ctev { ctev_pred = new_pred
                 , ctev_dest = new_dest }
      where
        new_dest :: TcEvDest
    new_dest = case TcEvDest
    dest of
          EvVarDest EvVar
    ev -> EvVar -> TcEvDest
    EvVarDest (EvVar -> Xi -> EvVar
    setVarType EvVar
    ev Xi
    new_pred)
          HoleDest CoercionHole
    h   -> CoercionHole -> TcEvDest
    HoleDest  (CoercionHole -> Xi -> CoercionHole
    setCoHoleType CoercionHole
    h Xi
    new_pred)

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

    instance Outputable CtEvidence where
      ppr :: CtEvidence -> SDoc
    ppr CtEvidence
    ev = CtFlavour -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (CtEvidence -> CtFlavour
    ctEvFlavour CtEvidence
    ev)
               SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    pp_ev SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces (SubGoalDepth -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (CtLoc -> SubGoalDepth
    ctl_depth (CtEvidence -> CtLoc
    ctEvLoc CtEvidence
    ev)) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    pp_rewriters)
                             -- Show the sub-goal depth too
                   SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Xi -> 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 } -> EvVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EvVar
    v
                 CtWanted {ctev_dest :: CtEvidence -> TcEvDest
    ctev_dest = TcEvDest
    d } -> TcEvDest -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TcEvDest
    d

          rewriters :: RewriterSet
    rewriters = CtEvidence -> RewriterSet
    ctEvRewriters CtEvidence
    ev
          pp_rewriters :: SDoc
    pp_rewriters | RewriterSet -> Bool
    isEmptyRewriterSet RewriterSet
    rewriters = SDoc
    forall doc. IsOutput doc => doc
    empty
                       | Bool
    otherwise                    = SDoc
    forall doc. IsLine doc => doc
    semi SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> RewriterSet -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RewriterSet
    rewriters

    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

    {-
    ************************************************************************
    *                                                                      *
               RewriterSet
    *                                                                      *
    ************************************************************************
    -}

    -- | Stores a set of CoercionHoles that have been used to rewrite a constraint.
    -- See Note [Wanteds rewrite Wanteds].
    newtype RewriterSet = RewriterSet (UniqSet CoercionHole)
      deriving newtype (RewriterSet -> SDoc
    (RewriterSet -> SDoc) -> Outputable RewriterSet
    forall a. (a -> SDoc) -> Outputable a
    $cppr :: RewriterSet -> SDoc
    ppr :: RewriterSet -> SDoc
    Outputable, NonEmpty RewriterSet -> RewriterSet
    RewriterSet -> RewriterSet -> RewriterSet
    (RewriterSet -> RewriterSet -> RewriterSet)
    -> (NonEmpty RewriterSet -> RewriterSet)
    -> (forall b. Integral b => b -> RewriterSet -> RewriterSet)
    -> Semigroup RewriterSet
    forall b. Integral b => b -> RewriterSet -> RewriterSet
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: RewriterSet -> RewriterSet -> RewriterSet
    <> :: RewriterSet -> RewriterSet -> RewriterSet
    $csconcat :: NonEmpty RewriterSet -> RewriterSet
    sconcat :: NonEmpty RewriterSet -> RewriterSet
    $cstimes :: forall b. Integral b => b -> RewriterSet -> RewriterSet
    stimes :: forall b. Integral b => b -> RewriterSet -> RewriterSet
    Semigroup, Semigroup RewriterSet
    RewriterSet
    Semigroup RewriterSet =>
    RewriterSet
    -> (RewriterSet -> RewriterSet -> RewriterSet)
    -> ([RewriterSet] -> RewriterSet)
    -> Monoid RewriterSet
    [RewriterSet] -> RewriterSet
    RewriterSet -> RewriterSet -> RewriterSet
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    $cmempty :: RewriterSet
    mempty :: RewriterSet
    $cmappend :: RewriterSet -> RewriterSet -> RewriterSet
    mappend :: RewriterSet -> RewriterSet -> RewriterSet
    $cmconcat :: [RewriterSet] -> RewriterSet
    mconcat :: [RewriterSet] -> RewriterSet
    Monoid)

    emptyRewriterSet :: RewriterSet
    emptyRewriterSet :: RewriterSet
    emptyRewriterSet = UniqSet CoercionHole -> RewriterSet
    RewriterSet UniqSet CoercionHole
    forall a. UniqSet a
    emptyUniqSet

    unitRewriterSet :: CoercionHole -> RewriterSet
    unitRewriterSet :: CoercionHole -> RewriterSet
    unitRewriterSet = (CoercionHole -> UniqSet CoercionHole)
    -> CoercionHole -> RewriterSet
    forall a b. Coercible a b => a -> b
    coerce (forall a. Uniquable a => a -> UniqSet a
    unitUniqSet @CoercionHole)

    unionRewriterSet :: RewriterSet -> RewriterSet -> RewriterSet
    unionRewriterSet :: RewriterSet -> RewriterSet -> RewriterSet
    unionRewriterSet = (UniqSet CoercionHole
     -> UniqSet CoercionHole -> UniqSet CoercionHole)
    -> RewriterSet -> RewriterSet -> RewriterSet
    forall a b. Coercible a b => a -> b
    coerce (forall a. UniqSet a -> UniqSet a -> UniqSet a
    unionUniqSets @CoercionHole)

    isEmptyRewriterSet :: RewriterSet -> Bool
    isEmptyRewriterSet :: RewriterSet -> Bool
    isEmptyRewriterSet = (UniqSet CoercionHole -> Bool) -> RewriterSet -> Bool
    forall a b. Coercible a b => a -> b
    coerce (forall a. UniqSet a -> Bool
    isEmptyUniqSet @CoercionHole)

    addRewriter :: RewriterSet -> CoercionHole -> RewriterSet
    addRewriter :: RewriterSet -> CoercionHole -> RewriterSet
    addRewriter = (UniqSet CoercionHole -> CoercionHole -> UniqSet CoercionHole)
    -> RewriterSet -> CoercionHole -> RewriterSet
    forall a b. Coercible a b => a -> b
    coerce (forall a. Uniquable a => UniqSet a -> a -> UniqSet a
    addOneToUniqSet @CoercionHole)

    rewriterSetFromCts :: Bag Ct -> RewriterSet
    -- Take a bag of Wanted equalities, and collect them as a RewriterSet
    rewriterSetFromCts :: Cts -> RewriterSet
    rewriterSetFromCts Cts
    cts
      = (Ct -> RewriterSet -> RewriterSet)
    -> RewriterSet -> Cts -> RewriterSet
    forall a b. (a -> b -> b) -> b -> Bag a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr Ct -> RewriterSet -> RewriterSet
    add RewriterSet
    emptyRewriterSet Cts
    cts
      where
        add :: Ct -> RewriterSet -> RewriterSet
    add Ct
    ct RewriterSet
    rw_set = case Ct -> CtEvidence
    ctEvidence Ct
    ct of
             CtWanted { ctev_dest :: CtEvidence -> TcEvDest
    ctev_dest = HoleDest CoercionHole
    hole } -> RewriterSet
    rw_set RewriterSet -> CoercionHole -> RewriterSet
    `addRewriter` CoercionHole
    hole
             CtEvidence
    _                                      -> RewriterSet
    rw_set

    {-
    ************************************************************************
    *                                                                      *
               CtFlavour
    *                                                                      *
    ************************************************************************
    -}

    data CtFlavour
      = Given     -- we have evidence
      | Wanted    -- we want evidence
      deriving CtFlavour -> CtFlavour -> Bool
    (CtFlavour -> CtFlavour -> Bool)
    -> (CtFlavour -> CtFlavour -> Bool) -> Eq CtFlavour
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CtFlavour -> CtFlavour -> Bool
    == :: CtFlavour -> CtFlavour -> Bool
    $c/= :: CtFlavour -> CtFlavour -> Bool
    /= :: CtFlavour -> CtFlavour -> Bool
    Eq

    instance Outputable CtFlavour where
      ppr :: CtFlavour -> SDoc
    ppr CtFlavour
    Given  = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "[G]"
      ppr CtFlavour
    Wanted = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "[W]"

    ctEvFlavour :: CtEvidence -> CtFlavour
    ctEvFlavour :: CtEvidence -> CtFlavour
    ctEvFlavour (CtWanted {}) = CtFlavour
    Wanted
    ctEvFlavour (CtGiven {})  = CtFlavour
    Given

    -- | 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.InertSet
    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'
    eqCtFlavourRole :: EqCt -> CtFlavourRole
    eqCtFlavourRole :: EqCt -> CtFlavourRole
    eqCtFlavourRole (EqCt { eq_ev :: EqCt -> CtEvidence
    eq_ev = CtEvidence
    ev, eq_eq_rel :: EqCt -> EqRel
    eq_eq_rel = EqRel
    eq_rel })
      = (CtEvidence -> CtFlavour
    ctEvFlavour CtEvidence
    ev, EqRel
    eq_rel)

    dictCtFlavourRole :: DictCt -> CtFlavourRole
    dictCtFlavourRole :: DictCt -> CtFlavourRole
    dictCtFlavourRole (DictCt { di_ev :: DictCt -> CtEvidence
    di_ev = CtEvidence
    ev })
      = (CtEvidence -> CtFlavour
    ctEvFlavour CtEvidence
    ev, EqRel
    NomEq)

    -- | Extract the flavour and role from a 'Ct'
    ctFlavourRole :: Ct -> CtFlavourRole
    -- Uses short-cuts to role for special cases
    ctFlavourRole :: Ct -> CtFlavourRole
    ctFlavourRole (CDictCan DictCt
    di_ct) = DictCt -> CtFlavourRole
    dictCtFlavourRole DictCt
    di_ct
    ctFlavourRole (CEqCan EqCt
    eq_ct)   = EqCt -> CtFlavourRole
    eqCtFlavourRole EqCt
    eq_ct
    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 rewrite Wanteds]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Should one Wanted constraint be allowed to rewrite another?

    This example (along with #8450) suggests not:
       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!

    This example suggests yes (indexed-types/should_fail/T4093a):
      type family Foo a
      f :: (Foo e ~ Maybe e) => Foo e
    In the ambiguity check, we get
      [G] g1 :: Foo e ~ Maybe e
      [W] w1 :: Foo alpha ~ Foo e
      [W] w2 :: Foo alpha ~ Maybe alpha
    w1 gets rewritten by the Given to become
      [W] w3 :: Foo alpha ~ Maybe e
    Now, the only way to make progress is to allow Wanteds to rewrite Wanteds.
    Rewriting w3 with w2 gives us
      [W] w4 :: Maybe alpha ~ Maybe e
    which will soon get us to alpha := e and thence to victory.

    TL;DR we want equality saturation.

    We thus want Wanteds to rewrite Wanteds in order to accept more programs,
    but we don't want Wanteds to rewrite Wanteds because doing so can create
    inscrutable error messages. To solve this dilemma:

    * We allow Wanteds to rewrite Wanteds, but...

    * Each Wanted tracks the set of Wanteds it has been rewritten by, in its
      RewriterSet, stored in the ctev_rewriters field of the CtWanted
      constructor of CtEvidence.  (Only Wanteds have RewriterSets.)

    * In error reporting, we simply suppress any errors that have been rewritten
      by /unsolved/ wanteds. This suppression happens in GHC.Tc.Errors.mkErrorItem,
      which uses GHC.Tc.Zonk.Type.zonkRewriterSet to look through any filled
      coercion holes. The idea is that we wish to report the "root cause" -- the
      error that rewrote all the others.

    * We prioritise Wanteds that have an empty RewriterSet:
      see Note [Prioritise Wanteds with empty RewriterSet].

    Let's continue our first example above:

      inert: [W] w1 :: a ~ Char
      work:  [W] w2 :: a ~ Bool

    Because Wanteds can rewrite Wanteds, w1 will rewrite w2, yielding

      inert: [W] w1 :: a ~ Char
             [W] w2 {w1}:: Char ~ Bool

    The {w1} in the second line of output is the RewriterSet of w1.

    A RewriterSet is just a set of unfilled CoercionHoles. This is sufficient
    because only equalities (evidenced by coercion holes) are used for rewriting;
    other (dictionary) constraints cannot ever rewrite. The rewriter (in
    e.g. GHC.Tc.Solver.Rewrite.rewrite) tracks and returns a RewriterSet,
    consisting of the evidence (a CoercionHole) for any Wanted equalities used in
    rewriting.  Then GHC.Tc.Solver.Solve.rewriteEvidence and
    GHC.Tc.Solver.Equality.rewriteEqEvidence add this RewriterSet to the rewritten
    constraint's rewriter set.

    Note [Prioritise Wanteds with empty RewriterSet]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When extending the WorkList, in GHC.Tc.Solver.InertSet.extendWorkListEq,
    we priorities constraints that have no rewriters. Here's why.

    Consider this, which came up in T22793:
      inert: {}
      work list: [W] co_ayf : awq ~ awo
      work item: [W] co_ayb : awq ~ awp

      ==> {just put work item in inert set}
      inert: co_ayb : awq ~ awp
      work list: {}
      work: [W] co_ayf : awq ~ awo

      ==> {rewrite ayf with co_ayb}
      work list: {}
      inert: co_ayb : awq ~ awp
             co_aym{co_ayb} : awp ~ awo
                    ^ rewritten by ayb

      ----- start again in simplify_loop in Solver.hs -----
      inert: {}
      work list: [W] co_ayb : awq ~ awp
      work: co_aym{co_ayb} : awp ~ awo

      ==> {add to inert set}
      inert: co_aym{co_ayb} : awp ~ awo
      work list: {}
      work: co_ayb : awq ~ awp

      ==> {rewrite co_ayb}
      inert: co_aym{co_ayb} : awp ~ awo
             co_ayp{co_aym} : awq ~ awo
      work list: {}

    Now both wanteds have been rewriten by the other! This happened because
    in our simplify_loop iteration, we happened to start with co_aym. All would have
    been well if we'd started with the (not-rewritten) co_ayb and gotten it into the
    inert set.

    With that in mind, we /prioritise/ the work-list to put constraints
    with no rewriters first.  This prioritisation is done in
    GHC.Tc.Solver.InertSet.extendWorkListEq, and extendWorkListEqs.

    Wrinkles

    (WRW1) Before checking for an empty RewriterSet, we zonk the RewriterSet,
      because some of those CoercionHoles may have been filled in since we last
      looked: see GHC.Tc.Solver.Monad.emitWork.

    (WRW2) Despite the prioritisation, it is hard to be /certain/ that we can't end up
      in a situation where all of the Wanteds have rewritten each other. In
      order to report /some/ error in this case, we simply report all the
      Wanteds. The user will get a perhaps-confusing error message, but they've
      written a confusing program!  (T22707 and T22793 were close, but they do
      not exhibit this behaviour.)  So belt and braces: see the `suppress`
      stuff in GHC.Tc.Errors.mkErrorItem.

    Note [Avoiding rewriting cycles]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Note [inert_eqs: the inert equalities] in GHC.Tc.Solver.InertSet describes
    the can-rewrite relation among CtFlavour/Role pairs, saying which constraints
    can rewrite which other constraints. It puts forth (R2):
      (R2) If f1 >= f, and f2 >= f,
           then either f1 >= f2 or f2 >= f1
    The naive can-rewrite relation says that (Given, Representational) can rewrite
    (Wanted, Representational) and that (Wanted, Nominal) can rewrite
    (Wanted, Representational), but neither of (Given, Representational) and
    (Wanted, Nominal) can rewrite the other. This would violate (R2). See also
    Note [Why R2?] in GHC.Tc.Solver.InertSet.

    To keep R2, we do not allow (Wanted, Nominal) to rewrite (Wanted, Representational).
    This can, in theory, bite, in this scenario:

      type family F a
      data T a
      type role T nominal

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

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

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

    Now we decompose the second W to get

      [W] 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 [W] F alpha ~N T alpha
    should rewrite [W] F alpha ~R T a, we could require splitting the first W
    into [W] F alpha ~NO T alpha, [W] F alpha ~R T alpha. Then, we use the R
    half of the split to rewrite the second W, 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.InertSet.

    However, note that I said that this bites in theory. That's because no
    known program actually gives rise to this scenario. A direct encoding
    ends up starting with

      [G] F a ~ T a
      [W] F alpha ~ T alpha
      [W] Coercible (F alpha) (T a)

    where ~ and Coercible denote lifted class constraints. The ~s quickly
    reduce to ~N: good. But the Coercible constraint gets rewritten to

      [W] Coercible (T alpha) (T a)

    by the first Wanted. This is because Coercible is a class, and arguments
    in class constraints use *nominal* rewriting, not the representational
    rewriting that is restricted due to (R2). Note that reordering the code
    doesn't help, because equalities (including lifted ones) are prioritized
    over Coercible. Thus, I (Richard E.) see no way to write a program that
    is rejected because of this infelicity. I have not proved it impossible,
    exactly, but my usual tricks have not yielded results.

    In the olden days, when we had Derived constraints, this Note was all
    about G/R and D/N both rewriting D/R. Back then, the code in
    typecheck/should_compile/T19665 really did get rejected. But now,
    according to the rewriting of the Coercible constraint, the program
    is accepted.

    -}

    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 rewrite Wanteds]
    -- See Note [Avoiding rewriting cycles]
    eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
    eqCanRewriteFR (CtFlavour
    Given,  EqRel
    r1)    (CtFlavour
    _,      EqRel
    r2)     = EqRel -> EqRel -> Bool
    eqCanRewrite EqRel
    r1 EqRel
    r2
    eqCanRewriteFR (CtFlavour
    Wanted, EqRel
    NomEq) (CtFlavour
    Wanted, EqRel
    ReprEq) = Bool
    False
    eqCanRewriteFR (CtFlavour
    Wanted, EqRel
    r1)    (CtFlavour
    Wanted, EqRel
    r2)     = EqRel -> EqRel -> Bool
    eqCanRewrite EqRel
    r1 EqRel
    r2
    eqCanRewriteFR (CtFlavour
    Wanted, EqRel
    _)     (CtFlavour
    Given, EqRel
    _)       = 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 maximum 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
    (SubGoalDepth -> SubGoalDepth -> Bool)
    -> (SubGoalDepth -> SubGoalDepth -> Bool) -> Eq SubGoalDepth
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SubGoalDepth -> SubGoalDepth -> Bool
    == :: SubGoalDepth -> SubGoalDepth -> Bool
    $c/= :: SubGoalDepth -> SubGoalDepth -> Bool
    /= :: SubGoalDepth -> SubGoalDepth -> Bool
    Eq, Eq SubGoalDepth
    Eq SubGoalDepth =>
    (SubGoalDepth -> SubGoalDepth -> Ordering)
    -> (SubGoalDepth -> SubGoalDepth -> Bool)
    -> (SubGoalDepth -> SubGoalDepth -> Bool)
    -> (SubGoalDepth -> SubGoalDepth -> Bool)
    -> (SubGoalDepth -> SubGoalDepth -> Bool)
    -> (SubGoalDepth -> SubGoalDepth -> SubGoalDepth)
    -> (SubGoalDepth -> SubGoalDepth -> SubGoalDepth)
    -> Ord 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
    $ccompare :: SubGoalDepth -> SubGoalDepth -> Ordering
    compare :: SubGoalDepth -> SubGoalDepth -> Ordering
    $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
    >= :: SubGoalDepth -> SubGoalDepth -> Bool
    $cmax :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
    max :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
    $cmin :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
    min :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
    Ord, SubGoalDepth -> SDoc
    (SubGoalDepth -> SDoc) -> Outputable SubGoalDepth
    forall a. (a -> SDoc) -> Outputable a
    $cppr :: SubGoalDepth -> SDoc
    ppr :: 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 Int -> Int -> Int
    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 Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    `max` Int
    m)

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

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

    -}

    data CtLoc = CtLoc { CtLoc -> CtOrigin
    ctl_origin   :: CtOrigin
                       , CtLoc -> CtLocEnv
    ctl_env      :: CtLocEnv -- Everything we need to know about
                                                  -- the context this Ct arose in.
                       , CtLoc -> Maybe TypeOrKind
    ctl_t_or_k   :: Maybe TypeOrKind  -- OK if we're not sure
                       , CtLoc -> SubGoalDepth
    ctl_depth    :: !SubGoalDepth }

    mkKindEqLoc :: TcType -> TcType   -- original *types* being compared
                -> CtLoc -> CtLoc
    mkKindEqLoc :: Xi -> Xi -> CtLoc -> CtLoc
    mkKindEqLoc Xi
    s1 Xi
    s2 CtLoc
    ctloc
      | CtLoc { ctl_t_or_k :: CtLoc -> Maybe TypeOrKind
    ctl_t_or_k = Maybe TypeOrKind
    t_or_k, ctl_origin :: CtLoc -> CtOrigin
    ctl_origin = CtOrigin
    origin } <- CtLoc
    ctloc
      = CtLoc
    ctloc { ctl_origin = KindEqOrigin s1 s2 origin t_or_k
              , ctl_t_or_k = Just KindLevel }

    adjustCtLocTyConBinder :: TyConBinder -> CtLoc -> CtLoc
    -- Adjust the CtLoc when decomposing a type constructor
    adjustCtLocTyConBinder :: TyConBinder -> CtLoc -> CtLoc
    adjustCtLocTyConBinder TyConBinder
    tc_bndr CtLoc
    loc
      = Bool -> Bool -> CtLoc -> CtLoc
    adjustCtLoc Bool
    is_vis Bool
    is_kind CtLoc
    loc
      where
        is_vis :: Bool
    is_vis  = TyConBinder -> Bool
    forall tv. VarBndr tv TyConBndrVis -> Bool
    isVisibleTyConBinder TyConBinder
    tc_bndr
        is_kind :: Bool
    is_kind = TyConBinder -> Bool
    isNamedTyConBinder TyConBinder
    tc_bndr

    adjustCtLoc :: Bool    -- True <=> A visible argument
                -> Bool    -- True <=> A kind argument
                -> CtLoc -> CtLoc
    -- Adjust the CtLoc when decomposing a type constructor, application, etc
    adjustCtLoc :: Bool -> Bool -> CtLoc -> CtLoc
    adjustCtLoc Bool
    is_vis Bool
    is_kind CtLoc
    loc
      = CtLoc
    loc2
      where
        loc1 :: CtLoc
    loc1 | Bool
    is_kind   = CtLoc -> CtLoc
    toKindLoc CtLoc
    loc
             | Bool
    otherwise = CtLoc
    loc
        loc2 :: CtLoc
    loc2 | Bool
    is_vis    = CtLoc
    loc1
             | Bool
    otherwise = CtLoc -> CtLoc
    toInvisibleLoc CtLoc
    loc1

    -- | 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 = Just KindLevel }

    toInvisibleLoc :: CtLoc -> CtLoc
    toInvisibleLoc :: CtLoc -> CtLoc
    toInvisibleLoc CtLoc
    loc = CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc
    updateCtLocOrigin CtLoc
    loc CtOrigin -> CtOrigin
    toInvisibleOrigin

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

    ctLocEnv :: CtLoc -> CtLocEnv
    ctLocEnv :: CtLoc -> CtLocEnv
    ctLocEnv = CtLoc -> CtLocEnv
    ctl_env

    ctLocLevel :: CtLoc -> TcLevel
    ctLocLevel :: CtLoc -> TcLevel
    ctLocLevel CtLoc
    loc = CtLocEnv -> TcLevel
    getCtLocEnvLvl (CtLoc -> CtLocEnv
    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 -> CtLocEnv
    ctl_env = CtLocEnv
    lcl}) = CtLocEnv -> RealSrcSpan
    getCtLocEnvLoc CtLocEnv
    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 -> CtLocEnv
    ctl_env = CtLocEnv
    lcl }) RealSrcSpan
    loc = CtLoc -> CtLocEnv -> CtLoc
    setCtLocEnv CtLoc
    ctl (CtLocEnv -> RealSrcSpan -> CtLocEnv
    setCtLocRealLoc CtLocEnv
    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 = bumpSubGoalDepth d }

    setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc
    setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc
    setCtLocOrigin CtLoc
    ctl CtOrigin
    orig = CtLoc
    ctl { ctl_origin = 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 = upd orig }

    setCtLocEnv :: CtLoc -> CtLocEnv -> CtLoc
    setCtLocEnv :: CtLoc -> CtLocEnv -> CtLoc
    setCtLocEnv CtLoc
    ctl CtLocEnv
    env = CtLoc
    ctl { ctl_env = 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 -> CtLocEnv
    ctl_env = CtLocEnv
    lcl})
      = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep [ CtOrigin -> SDoc
    pprCtOrigin CtOrigin
    o
            , String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "at" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> RealSrcSpan -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (CtLocEnv -> RealSrcSpan
    getCtLocEnvLoc CtLocEnv
    lcl)]