{-# 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 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 HsMatchContext GhcTc
_)       (PatSkol ConLike
c2 HsMatchContext GhcTc
_)       = 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)]