{-# LANGUAGE CPP, GeneralizedNewtypeDeriving #-}
module Constraint (
QCInst(..), isPendingScInst,
Xi, Ct(..), Cts, emptyCts, andCts, andManyCts, pprCts,
singleCt, listToCts, ctsElts, consCts, snocCts, extendCtsList,
isEmptyCts, isCTyEqCan, isCFunEqCan,
isPendingScDict, superClassesMightHelp, getPendingWantedScs,
isCDictCan_Maybe, isCFunEqCan_maybe,
isCNonCanonical, isWantedCt, isDerivedCt,
isGivenCt, isHoleCt, isOutOfScopeCt, isExprHoleCt, isTypeHoleCt,
isUserTypeErrorCt, getUserTypeErrorMsg,
ctEvidence, ctLoc, setCtLoc, ctPred, ctFlavour, ctEqRel, ctOrigin,
ctEvId, mkTcEqPredLikeEv,
mkNonCanonical, mkNonCanonicalCt, mkGivens,
mkIrredCt, mkInsolubleCt,
ctEvPred, ctEvLoc, ctEvOrigin, ctEvEqRel,
ctEvExpr, ctEvTerm, ctEvCoercion, ctEvEvId,
tyCoVarsOfCt, tyCoVarsOfCts,
tyCoVarsOfCtList, tyCoVarsOfCtsList,
WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC,
isSolvedWC, andWC, unionsWC, mkSimpleWC, mkImplicWC,
addInsols, insolublesOnly, addSimples, addImplics,
tyCoVarsOfWC, dropDerivedWC, dropDerivedSimples,
tyCoVarsOfWCList, insolubleCt, insolubleEqCt,
isDroppableCt, insolubleImplic,
arisesFromGivens,
Implication(..), implicationPrototype,
ImplicStatus(..), isInsolubleStatus, isSolvedStatus,
SubGoalDepth, initialSubGoalDepth, maxSubGoalDepth,
bumpSubGoalDepth, subGoalDepthExceeded,
CtLoc(..), ctLocSpan, ctLocEnv, ctLocLevel, ctLocOrigin,
ctLocTypeOrKind_maybe,
ctLocDepth, bumpCtLocDepth, isGivenLoc,
setCtLocOrigin, updateCtLocOrigin, setCtLocEnv, setCtLocSpan,
pprCtLoc,
CtEvidence(..), TcEvDest(..),
mkKindLoc, toKindLoc, mkGivenLoc,
isWanted, isGiven, isDerived, isGivenOrWDeriv,
ctEvRole,
wrapType, wrapTypeWithImplication,
CtFlavour(..), ShadowInfo(..), ctEvFlavour,
CtFlavourRole, ctEvFlavourRole, ctFlavourRole,
eqCanRewrite, eqCanRewriteFR, eqMayRewriteFR,
eqCanDischargeFR,
funEqCanDischarge, funEqCanDischargeF,
pprEvVarTheta,
pprEvVars, pprEvVarWithType,
Hole(..), holeOcc,
)
where
#include "GhclibHsVersions.h"
import GhcPrelude
import {-# SOURCE #-} TcRnTypes ( TcLclEnv, setLclEnvTcLevel, getLclEnvTcLevel
, setLclEnvLoc, getLclEnvLoc )
import GHC.Hs.Expr ( UnboundVar(..), unboundVarOcc )
import Predicate
import Type
import Coercion
import Class
import TyCon
import Var
import Id
import TcType
import TcEvidence
import TcOrigin
import CoreSyn
import TyCoPpr
import OccName
import FV
import VarSet
import DynFlags
import BasicTypes
import Outputable
import SrcLoc
import Bag
import Util
import Control.Monad ( msum )
type Xi = Type
type Cts = Bag Ct
data Ct
= CDictCan {
Ct -> CtEvidence
cc_ev :: CtEvidence,
Ct -> Class
cc_class :: Class,
Ct -> [Xi]
cc_tyargs :: [Xi],
Ct -> Bool
cc_pend_sc :: Bool
}
| CIrredCan {
cc_ev :: CtEvidence,
Ct -> Bool
cc_insol :: Bool
}
| CTyEqCan {
cc_ev :: CtEvidence,
Ct -> TcTyVar
cc_tyvar :: TcTyVar,
Ct -> Xi
cc_rhs :: TcType,
Ct -> EqRel
cc_eq_rel :: EqRel
}
| CFunEqCan {
cc_ev :: CtEvidence,
Ct -> TyCon
cc_fun :: TyCon,
cc_tyargs :: [Xi],
Ct -> TcTyVar
cc_fsk :: TcTyVar
}
| CNonCanonical {
cc_ev :: CtEvidence
}
| CHoleCan {
cc_ev :: CtEvidence,
Ct -> Hole
cc_hole :: Hole
}
| CQuantCan QCInst
data QCInst
= QCI { QCInst -> CtEvidence
qci_ev :: CtEvidence
, QCInst -> [TcTyVar]
qci_tvs :: [TcTyVar]
, QCInst -> Xi
qci_pred :: TcPredType
, QCInst -> Bool
qci_pend_sc :: Bool
}
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
data Hole = ExprHole UnboundVar
| TypeHole OccName
instance Outputable Hole where
ppr :: Hole -> SDoc
ppr (ExprHole ub :: UnboundVar
ub) = UnboundVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr UnboundVar
ub
ppr (TypeHole occ :: OccName
occ) = String -> SDoc
text "TypeHole" SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
parens (OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr OccName
occ)
holeOcc :: Hole -> OccName
holeOcc :: Hole -> OccName
holeOcc (ExprHole uv :: UnboundVar
uv) = UnboundVar -> OccName
unboundVarOcc UnboundVar
uv
holeOcc (TypeHole occ :: OccName
occ) = OccName
occ
mkNonCanonical :: CtEvidence -> Ct
mkNonCanonical :: CtEvidence -> Ct
mkNonCanonical ev :: CtEvidence
ev = CNonCanonical :: CtEvidence -> Ct
CNonCanonical { cc_ev :: CtEvidence
cc_ev = CtEvidence
ev }
mkNonCanonicalCt :: Ct -> Ct
mkNonCanonicalCt :: Ct -> Ct
mkNonCanonicalCt ct :: Ct
ct = CNonCanonical :: CtEvidence -> Ct
CNonCanonical { cc_ev :: CtEvidence
cc_ev = Ct -> CtEvidence
cc_ev Ct
ct }
mkIrredCt :: CtEvidence -> Ct
mkIrredCt :: CtEvidence -> Ct
mkIrredCt ev :: CtEvidence
ev = CIrredCan :: CtEvidence -> Bool -> Ct
CIrredCan { cc_ev :: CtEvidence
cc_ev = CtEvidence
ev, cc_insol :: Bool
cc_insol = Bool
False }
mkInsolubleCt :: CtEvidence -> Ct
mkInsolubleCt :: CtEvidence -> Ct
mkInsolubleCt ev :: CtEvidence
ev = CIrredCan :: CtEvidence -> Bool -> Ct
CIrredCan { cc_ev :: CtEvidence
cc_ev = CtEvidence
ev, cc_insol :: Bool
cc_insol = Bool
True }
mkGivens :: CtLoc -> [EvId] -> [Ct]
mkGivens :: CtLoc -> [TcTyVar] -> [Ct]
mkGivens loc :: CtLoc
loc ev_ids :: [TcTyVar]
ev_ids
= (TcTyVar -> Ct) -> [TcTyVar] -> [Ct]
forall a b. (a -> b) -> [a] -> [b]
map TcTyVar -> Ct
mk [TcTyVar]
ev_ids
where
mk :: TcTyVar -> Ct
mk ev_id :: TcTyVar
ev_id = CtEvidence -> Ct
mkNonCanonical (CtGiven :: Xi -> TcTyVar -> CtLoc -> CtEvidence
CtGiven { ctev_evar :: TcTyVar
ctev_evar = TcTyVar
ev_id
, ctev_pred :: Xi
ctev_pred = TcTyVar -> Xi
evVarPred TcTyVar
ev_id
, ctev_loc :: CtLoc
ctev_loc = CtLoc
loc })
ctEvidence :: Ct -> CtEvidence
ctEvidence :: Ct -> CtEvidence
ctEvidence (CQuantCan (QCI { qci_ev :: QCInst -> CtEvidence
qci_ev = CtEvidence
ev })) = CtEvidence
ev
ctEvidence ct :: Ct
ct = Ct -> CtEvidence
cc_ev Ct
ct
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
setCtLoc :: Ct -> CtLoc -> Ct
setCtLoc :: Ct -> CtLoc -> Ct
setCtLoc ct :: Ct
ct loc :: CtLoc
loc = Ct
ct { cc_ev :: CtEvidence
cc_ev = (Ct -> CtEvidence
cc_ev Ct
ct) { ctev_loc :: CtLoc
ctev_loc = CtLoc
loc } }
ctOrigin :: Ct -> CtOrigin
ctOrigin :: Ct -> CtOrigin
ctOrigin = CtLoc -> CtOrigin
ctLocOrigin (CtLoc -> CtOrigin) -> (Ct -> CtLoc) -> Ct -> CtOrigin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtLoc
ctLoc
ctPred :: Ct -> PredType
ctPred :: Ct -> Xi
ctPred ct :: Ct
ct = CtEvidence -> Xi
ctEvPred (Ct -> CtEvidence
ctEvidence Ct
ct)
ctEvId :: Ct -> EvVar
ctEvId :: Ct -> TcTyVar
ctEvId ct :: Ct
ct = CtEvidence -> TcTyVar
ctEvEvId (Ct -> CtEvidence
ctEvidence Ct
ct)
mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType
mkTcEqPredLikeEv :: CtEvidence -> Xi -> Xi -> Xi
mkTcEqPredLikeEv ev :: CtEvidence
ev
= case Xi -> EqRel
predTypeEqRel Xi
pred of
NomEq -> Xi -> Xi -> Xi
mkPrimEqPred
ReprEq -> Xi -> Xi -> Xi
mkReprPrimEqPred
where
pred :: Xi
pred = CtEvidence -> Xi
ctEvPred CtEvidence
ev
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
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
ct = CtEvidence -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Ct -> CtEvidence
ctEvidence Ct
ct) SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
parens SDoc
pp_sort
where
pp_sort :: SDoc
pp_sort = case Ct
ct of
CTyEqCan {} -> String -> SDoc
text "CTyEqCan"
CFunEqCan {} -> String -> SDoc
text "CFunEqCan"
CNonCanonical {} -> String -> SDoc
text "CNonCanonical"
CDictCan { cc_pend_sc :: Ct -> Bool
cc_pend_sc = Bool
pend_sc }
| Bool
pend_sc -> String -> SDoc
text "CDictCan(psc)"
| Bool
otherwise -> String -> SDoc
text "CDictCan"
CIrredCan { cc_insol :: Ct -> Bool
cc_insol = Bool
insol }
| Bool
insol -> String -> SDoc
text "CIrredCan(insol)"
| Bool
otherwise -> String -> SDoc
text "CIrredCan(sol)"
CHoleCan { cc_hole :: Ct -> Hole
cc_hole = Hole
hole } -> String -> SDoc
text "CHoleCan:" SDoc -> SDoc -> SDoc
<+> Hole -> SDoc
forall a. Outputable a => a -> SDoc
ppr Hole
hole
CQuantCan (QCI { qci_pend_sc :: QCInst -> Bool
qci_pend_sc = Bool
pend_sc })
| Bool
pend_sc -> String -> SDoc
text "CQuantCan(psc)"
| Bool
otherwise -> String -> SDoc
text "CQuantCan"
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
tyCoVarsOfCtList :: Ct -> [TcTyCoVar]
tyCoVarsOfCtList :: Ct -> [TcTyVar]
tyCoVarsOfCtList = FV -> [TcTyVar]
fvVarList (FV -> [TcTyVar]) -> (Ct -> FV) -> Ct -> [TcTyVar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> FV
tyCoFVsOfCt
tyCoFVsOfCt :: Ct -> FV
tyCoFVsOfCt :: Ct -> FV
tyCoFVsOfCt (CTyEqCan { cc_tyvar :: Ct -> TcTyVar
cc_tyvar = TcTyVar
tv, cc_rhs :: Ct -> Xi
cc_rhs = Xi
xi })
= Xi -> FV
tyCoFVsOfType Xi
xi FV -> FV -> FV
`unionFV` TcTyVar -> FV
FV.unitFV TcTyVar
tv
FV -> FV -> FV
`unionFV` Xi -> FV
tyCoFVsOfType (TcTyVar -> Xi
tyVarKind TcTyVar
tv)
tyCoFVsOfCt (CFunEqCan { cc_tyargs :: Ct -> [Xi]
cc_tyargs = [Xi]
tys, cc_fsk :: Ct -> TcTyVar
cc_fsk = TcTyVar
fsk })
= [Xi] -> FV
tyCoFVsOfTypes [Xi]
tys FV -> FV -> FV
`unionFV` TcTyVar -> FV
FV.unitFV TcTyVar
fsk
FV -> FV -> FV
`unionFV` Xi -> FV
tyCoFVsOfType (TcTyVar -> Xi
tyVarKind TcTyVar
fsk)
tyCoFVsOfCt (CDictCan { cc_tyargs :: Ct -> [Xi]
cc_tyargs = [Xi]
tys }) = [Xi] -> FV
tyCoFVsOfTypes [Xi]
tys
tyCoFVsOfCt ct :: Ct
ct = Xi -> FV
tyCoFVsOfType (Ct -> Xi
ctPred Ct
ct)
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
tyCoVarsOfCtsList :: Cts -> [TcTyCoVar]
tyCoVarsOfCtsList :: Cts -> [TcTyVar]
tyCoVarsOfCtsList = FV -> [TcTyVar]
fvVarList (FV -> [TcTyVar]) -> (Cts -> FV) -> Cts -> [TcTyVar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cts -> FV
tyCoFVsOfCts
tyCoFVsOfCts :: Cts -> FV
tyCoFVsOfCts :: Cts -> FV
tyCoFVsOfCts = (Ct -> FV -> FV) -> FV -> Cts -> FV
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
tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet
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
tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar]
tyCoVarsOfWCList :: WantedConstraints -> [TcTyVar]
tyCoVarsOfWCList = FV -> [TcTyVar]
fvVarList (FV -> [TcTyVar])
-> (WantedConstraints -> FV) -> WantedConstraints -> [TcTyVar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WantedConstraints -> FV
tyCoFVsOfWC
tyCoFVsOfWC :: WantedConstraints -> FV
tyCoFVsOfWC :: WantedConstraints -> FV
tyCoFVsOfWC (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simple, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implic })
= 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
tyCoFVsOfImplic :: Implication -> FV
tyCoFVsOfImplic :: Implication -> FV
tyCoFVsOfImplic (Implic { ic_skols :: Implication -> [TcTyVar]
ic_skols = [TcTyVar]
skols
, ic_given :: Implication -> [TcTyVar]
ic_given = [TcTyVar]
givens
, ic_wanted :: Implication -> WantedConstraints
ic_wanted = WantedConstraints
wanted })
| WantedConstraints -> Bool
isEmptyWC WantedConstraints
wanted
= FV
emptyFV
| Bool
otherwise
= [TcTyVar] -> FV -> FV
tyCoFVsVarBndrs [TcTyVar]
skols (FV -> FV) -> FV -> FV
forall a b. (a -> b) -> a -> b
$
[TcTyVar] -> FV -> FV
tyCoFVsVarBndrs [TcTyVar]
givens (FV -> FV) -> FV -> FV
forall a b. (a -> b) -> a -> b
$
WantedConstraints -> FV
tyCoFVsOfWC WantedConstraints
wanted
tyCoFVsOfBag :: (a -> FV) -> Bag a -> FV
tyCoFVsOfBag :: (a -> FV) -> Bag a -> FV
tyCoFVsOfBag tvs_of :: a -> FV
tvs_of = (a -> FV -> FV) -> FV -> Bag a -> FV
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
dropDerivedWC :: WantedConstraints -> WantedConstraints
dropDerivedWC :: WantedConstraints -> WantedConstraints
dropDerivedWC wc :: WantedConstraints
wc@(WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples })
= WantedConstraints
wc { wc_simple :: Cts
wc_simple = Cts -> Cts
dropDerivedSimples Cts
simples }
dropDerivedSimples :: Cts -> Cts
dropDerivedSimples :: Cts -> Cts
dropDerivedSimples simples :: Cts
simples = (Ct -> Maybe Ct) -> Cts -> Cts
forall a b. (a -> Maybe b) -> Bag a -> Bag b
mapMaybeBag Ct -> Maybe Ct
dropDerivedCt Cts
simples
dropDerivedCt :: Ct -> Maybe Ct
dropDerivedCt :: Ct -> Maybe Ct
dropDerivedCt ct :: Ct
ct
= case CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev of
Wanted WOnly -> Ct -> Maybe Ct
forall a. a -> Maybe a
Just (Ct
ct' { cc_ev :: CtEvidence
cc_ev = CtEvidence
ev_wd })
Wanted _ -> Ct -> Maybe Ct
forall a. a -> Maybe a
Just Ct
ct'
_ | Ct -> Bool
isDroppableCt Ct
ct -> Maybe Ct
forall a. Maybe a
Nothing
| Bool
otherwise -> Ct -> Maybe Ct
forall a. a -> Maybe a
Just Ct
ct
where
ev :: CtEvidence
ev = Ct -> CtEvidence
ctEvidence Ct
ct
ev_wd :: CtEvidence
ev_wd = CtEvidence
ev { ctev_nosh :: ShadowInfo
ctev_nosh = ShadowInfo
WDeriv }
ct' :: Ct
ct' = Ct -> Ct
setPendingScDict Ct
ct
isDroppableCt :: Ct -> Bool
isDroppableCt :: Ct -> Bool
isDroppableCt ct :: Ct
ct
= CtEvidence -> Bool
isDerived CtEvidence
ev Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
keep_deriv
where
ev :: CtEvidence
ev = Ct -> CtEvidence
ctEvidence Ct
ct
loc :: CtLoc
loc = CtEvidence -> CtLoc
ctEvLoc CtEvidence
ev
orig :: CtOrigin
orig = CtLoc -> CtOrigin
ctLocOrigin CtLoc
loc
keep_deriv :: Bool
keep_deriv
= case Ct
ct of
CHoleCan {} -> Bool
True
CIrredCan { cc_insol :: Ct -> Bool
cc_insol = Bool
insoluble }
-> Bool -> Bool
keep_eq Bool
insoluble
_ -> Bool -> Bool
keep_eq Bool
False
keep_eq :: Bool -> Bool
keep_eq definitely_insoluble :: Bool
definitely_insoluble
| CtOrigin -> Bool
isGivenOrigin CtOrigin
orig
= Bool
definitely_insoluble
| Bool
otherwise
= case CtOrigin
orig of
KindEqOrigin {} -> Bool
True
FunDepOrigin2 {} -> Bool
True
FunDepOrigin1 _ orig1 :: CtOrigin
orig1 _ _ orig2 :: CtOrigin
orig2 _
| Bool
g1 Bool -> Bool -> Bool
|| Bool
g2 -> Bool
True
| Bool
otherwise -> Bool
False
where
g1 :: Bool
g1 = CtOrigin -> Bool
isGivenOrigin CtOrigin
orig1
g2 :: Bool
g2 = CtOrigin -> Bool
isGivenOrigin CtOrigin
orig2
_ -> Bool
False
arisesFromGivens :: Ct -> Bool
arisesFromGivens :: Ct -> Bool
arisesFromGivens ct :: Ct
ct
= case Ct -> CtEvidence
ctEvidence Ct
ct of
CtGiven {} -> Bool
True
CtWanted {} -> Bool
False
CtDerived { ctev_loc :: CtEvidence -> CtLoc
ctev_loc = CtLoc
loc } -> CtLoc -> Bool
isGivenLoc CtLoc
loc
isGivenLoc :: CtLoc -> Bool
isGivenLoc :: CtLoc -> Bool
isGivenLoc loc :: CtLoc
loc = CtOrigin -> Bool
isGivenOrigin (CtLoc -> CtOrigin
ctLocOrigin CtLoc
loc)
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
isDerivedCt :: Ct -> Bool
isDerivedCt :: Ct -> Bool
isDerivedCt = CtEvidence -> Bool
isDerived (CtEvidence -> Bool) -> (Ct -> CtEvidence) -> Ct -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ct -> CtEvidence
ctEvidence
isCTyEqCan :: Ct -> Bool
isCTyEqCan :: Ct -> Bool
isCTyEqCan (CTyEqCan {}) = Bool
True
isCTyEqCan (CFunEqCan {}) = Bool
False
isCTyEqCan _ = Bool
False
isCDictCan_Maybe :: Ct -> Maybe Class
isCDictCan_Maybe :: Ct -> Maybe Class
isCDictCan_Maybe (CDictCan {cc_class :: Ct -> Class
cc_class = Class
cls }) = Class -> Maybe Class
forall a. a -> Maybe a
Just Class
cls
isCDictCan_Maybe _ = Maybe Class
forall a. Maybe a
Nothing
isCFunEqCan_maybe :: Ct -> Maybe (TyCon, [Type])
isCFunEqCan_maybe :: Ct -> Maybe (TyCon, [Xi])
isCFunEqCan_maybe (CFunEqCan { cc_fun :: Ct -> TyCon
cc_fun = TyCon
tc, cc_tyargs :: Ct -> [Xi]
cc_tyargs = [Xi]
xis }) = (TyCon, [Xi]) -> Maybe (TyCon, [Xi])
forall a. a -> Maybe a
Just (TyCon
tc, [Xi]
xis)
isCFunEqCan_maybe _ = Maybe (TyCon, [Xi])
forall a. Maybe a
Nothing
isCFunEqCan :: Ct -> Bool
isCFunEqCan :: Ct -> Bool
isCFunEqCan (CFunEqCan {}) = Bool
True
isCFunEqCan _ = Bool
False
isCNonCanonical :: Ct -> Bool
isCNonCanonical :: Ct -> Bool
isCNonCanonical (CNonCanonical {}) = Bool
True
isCNonCanonical _ = Bool
False
isHoleCt:: Ct -> Bool
isHoleCt :: Ct -> Bool
isHoleCt (CHoleCan {}) = Bool
True
isHoleCt _ = Bool
False
isOutOfScopeCt :: Ct -> Bool
isOutOfScopeCt :: Ct -> Bool
isOutOfScopeCt (CHoleCan { cc_hole :: Ct -> Hole
cc_hole = ExprHole (OutOfScope {}) }) = Bool
True
isOutOfScopeCt _ = Bool
False
isExprHoleCt :: Ct -> Bool
isExprHoleCt :: Ct -> Bool
isExprHoleCt (CHoleCan { cc_hole :: Ct -> Hole
cc_hole = ExprHole {} }) = Bool
True
isExprHoleCt _ = Bool
False
isTypeHoleCt :: Ct -> Bool
isTypeHoleCt :: Ct -> Bool
isTypeHoleCt (CHoleCan { cc_hole :: Ct -> Hole
cc_hole = TypeHole {} }) = Bool
True
isTypeHoleCt _ = Bool
False
getUserTypeErrorMsg :: Ct -> Maybe Type
getUserTypeErrorMsg :: Ct -> Maybe Xi
getUserTypeErrorMsg ct :: Ct
ct = Xi -> Maybe Xi
findUserTypeError (Ct -> Xi
ctPred Ct
ct)
where
findUserTypeError :: Xi -> Maybe Xi
findUserTypeError t :: Xi
t = [Maybe Xi] -> Maybe Xi
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum ( Xi -> Maybe Xi
userTypeError_maybe Xi
t
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
findUserTypeError (Xi -> [Xi]
subTys Xi
t)
)
subTys :: Xi -> [Xi]
subTys t :: Xi
t = case Xi -> (Xi, [Xi])
splitAppTys Xi
t of
(t :: Xi
t,[]) ->
case HasDebugCallStack => Xi -> Maybe (TyCon, [Xi])
Xi -> Maybe (TyCon, [Xi])
splitTyConApp_maybe Xi
t of
Nothing -> []
Just (_,ts :: [Xi]
ts) -> [Xi]
ts
(t :: Xi
t,ts :: [Xi]
ts) -> Xi
t Xi -> [Xi] -> [Xi]
forall a. a -> [a] -> [a]
: [Xi]
ts
isUserTypeErrorCt :: Ct -> Bool
isUserTypeErrorCt :: Ct -> Bool
isUserTypeErrorCt ct :: Ct
ct = case Ct -> Maybe Xi
getUserTypeErrorMsg Ct
ct of
Just _ -> Bool
True
_ -> Bool
False
isPendingScDict :: Ct -> Maybe Ct
isPendingScDict :: Ct -> Maybe Ct
isPendingScDict ct :: Ct
ct@(CDictCan { cc_pend_sc :: Ct -> Bool
cc_pend_sc = Bool
True })
= Ct -> Maybe Ct
forall a. a -> Maybe a
Just (Ct
ct { cc_pend_sc :: Bool
cc_pend_sc = Bool
False })
isPendingScDict _ = Maybe Ct
forall a. Maybe a
Nothing
isPendingScInst :: QCInst -> Maybe QCInst
isPendingScInst :: QCInst -> Maybe QCInst
isPendingScInst qci :: QCInst
qci@(QCI { qci_pend_sc :: QCInst -> Bool
qci_pend_sc = Bool
True })
= QCInst -> Maybe QCInst
forall a. a -> Maybe a
Just (QCInst
qci { qci_pend_sc :: Bool
qci_pend_sc = Bool
False })
isPendingScInst _ = Maybe QCInst
forall a. Maybe a
Nothing
setPendingScDict :: Ct -> Ct
setPendingScDict :: Ct -> Ct
setPendingScDict ct :: Ct
ct@(CDictCan { cc_pend_sc :: Ct -> Bool
cc_pend_sc = Bool
False })
= Ct
ct { cc_pend_sc :: Bool
cc_pend_sc = Bool
True }
setPendingScDict ct :: Ct
ct = Ct
ct
superClassesMightHelp :: WantedConstraints -> Bool
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 ic :: Implication
ic
| ImplicStatus
IC_Unsolved <- Implication -> ImplicStatus
ic_status Implication
ic = WantedConstraints -> Bool
superClassesMightHelp (Implication -> WantedConstraints
ic_wanted Implication
ic)
| Bool
otherwise = Bool
False
might_help_ct :: Ct -> Bool
might_help_ct ct :: Ct
ct = Ct -> Bool
isWantedCt Ct
ct Bool -> Bool -> Bool
&& Bool -> Bool
not (Ct -> Bool
is_ip Ct
ct)
is_ip :: Ct -> Bool
is_ip (CDictCan { cc_class :: Ct -> Class
cc_class = Class
cls }) = Class -> Bool
isIPClass Class
cls
is_ip _ = Bool
False
getPendingWantedScs :: Cts -> ([Ct], Cts)
getPendingWantedScs :: Cts -> ([Ct], Cts)
getPendingWantedScs simples :: 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 acc :: [Ct]
acc ct :: Ct
ct | Just ct' :: Ct
ct' <- Ct -> Maybe Ct
isPendingScDict Ct
ct
= (Ct
ct'Ct -> [Ct] -> [Ct]
forall a. a -> [a] -> [a]
:[Ct]
acc, Ct
ct')
| Bool
otherwise
= ([Ct]
acc, Ct
ct)
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
cts xs :: [Ct]
xs | [Ct] -> 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
andManyCts :: [Cts] -> Cts
andManyCts :: [Cts] -> Cts
andManyCts = [Cts] -> Cts
forall a. [Bag a] -> Bag a
unionManyBags
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
pprCts :: Cts -> SDoc
pprCts :: Cts -> SDoc
pprCts cts :: Cts
cts = [SDoc] -> SDoc
vcat ((Ct -> SDoc) -> [Ct] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map Ct -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Cts -> [Ct]
forall a. Bag a -> [a]
bagToList Cts
cts))
data WantedConstraints
= WC { WantedConstraints -> Cts
wc_simple :: Cts
, WantedConstraints -> Bag Implication
wc_impl :: Bag Implication
}
emptyWC :: WantedConstraints
emptyWC :: WantedConstraints
emptyWC = WC :: Cts -> Bag Implication -> WantedConstraints
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 }
mkSimpleWC :: [CtEvidence] -> WantedConstraints
mkSimpleWC :: [CtEvidence] -> WantedConstraints
mkSimpleWC cts :: [CtEvidence]
cts
= WC :: Cts -> Bag Implication -> WantedConstraints
WC { wc_simple :: Cts
wc_simple = [Ct] -> Cts
forall a. [a] -> Bag a
listToBag ((CtEvidence -> Ct) -> [CtEvidence] -> [Ct]
forall a b. (a -> b) -> [a] -> [b]
map CtEvidence -> Ct
mkNonCanonical [CtEvidence]
cts)
, wc_impl :: Bag Implication
wc_impl = Bag Implication
forall a. Bag a
emptyBag }
mkImplicWC :: Bag Implication -> WantedConstraints
mkImplicWC :: Bag Implication -> WantedConstraints
mkImplicWC implic :: Bag Implication
implic
= WC :: Cts -> Bag Implication -> WantedConstraints
WC { wc_simple :: Cts
wc_simple = Cts
forall a. Bag a
emptyBag, wc_impl :: Bag Implication
wc_impl = Bag Implication
implic }
isEmptyWC :: WantedConstraints -> Bool
isEmptyWC :: WantedConstraints -> Bool
isEmptyWC (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
f, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
i })
= 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
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} =
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
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 { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
f2, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
i2 })
= WC :: Cts -> Bag Implication -> WantedConstraints
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 }
unionsWC :: [WantedConstraints] -> WantedConstraints
unionsWC :: [WantedConstraints] -> WantedConstraints
unionsWC = (WantedConstraints -> WantedConstraints -> WantedConstraints)
-> WantedConstraints -> [WantedConstraints] -> WantedConstraints
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 wc :: WantedConstraints
wc cts :: Cts
cts
= WantedConstraints
wc { wc_simple :: Cts
wc_simple = WantedConstraints -> Cts
wc_simple WantedConstraints
wc Cts -> Cts -> Cts
forall a. Bag a -> Bag a -> Bag a
`unionBags` Cts
cts }
addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints
addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints
addImplics wc :: WantedConstraints
wc implic :: Bag Implication
implic = WantedConstraints
wc { wc_impl :: Bag Implication
wc_impl = WantedConstraints -> Bag Implication
wc_impl WantedConstraints
wc Bag Implication -> Bag Implication -> Bag Implication
forall a. Bag a -> Bag a -> Bag a
`unionBags` Bag Implication
implic }
addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints
addInsols :: WantedConstraints -> Cts -> WantedConstraints
addInsols wc :: WantedConstraints
wc cts :: Cts
cts
= WantedConstraints
wc { wc_simple :: Cts
wc_simple = WantedConstraints -> Cts
wc_simple WantedConstraints
wc Cts -> Cts -> Cts
forall a. Bag a -> Bag a -> Bag a
`unionBags` Cts
cts }
insolublesOnly :: WantedConstraints -> WantedConstraints
insolublesOnly :: WantedConstraints -> WantedConstraints
insolublesOnly (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics })
= WC :: Cts -> Bag Implication -> WantedConstraints
WC { wc_simple :: Cts
wc_simple = (Ct -> Bool) -> Cts -> Cts
forall a. (a -> Bool) -> Bag a -> Bag a
filterBag Ct -> Bool
insolubleCt 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
implic_insols_only Bag Implication
implics }
where
implic_insols_only :: Implication -> Implication
implic_insols_only implic :: Implication
implic
= Implication
implic { ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints -> WantedConstraints
insolublesOnly (Implication -> WantedConstraints
ic_wanted Implication
implic) }
isSolvedStatus :: ImplicStatus -> Bool
isSolvedStatus :: ImplicStatus -> Bool
isSolvedStatus (IC_Solved {}) = Bool
True
isSolvedStatus _ = Bool
False
isInsolubleStatus :: ImplicStatus -> Bool
isInsolubleStatus :: ImplicStatus -> Bool
isInsolubleStatus IC_Insoluble = Bool
True
isInsolubleStatus IC_BadTelescope = Bool
True
isInsolubleStatus _ = Bool
False
insolubleImplic :: Implication -> Bool
insolubleImplic :: Implication -> Bool
insolubleImplic ic :: Implication
ic = ImplicStatus -> Bool
isInsolubleStatus (Implication -> ImplicStatus
ic_status Implication
ic)
insolubleWC :: WantedConstraints -> Bool
insolubleWC :: WantedConstraints -> Bool
insolubleWC (WC { wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics, wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples })
= (Ct -> Bool) -> Cts -> Bool
forall a. (a -> Bool) -> Bag a -> Bool
anyBag Ct -> Bool
insolubleCt Cts
simples
Bool -> Bool -> Bool
|| (Implication -> Bool) -> Bag Implication -> Bool
forall a. (a -> Bool) -> Bag a -> Bool
anyBag Implication -> Bool
insolubleImplic Bag Implication
implics
insolubleCt :: Ct -> Bool
insolubleCt :: Ct -> Bool
insolubleCt ct :: Ct
ct
| Ct -> Bool
isHoleCt Ct
ct = Ct -> Bool
isOutOfScopeCt Ct
ct
| Bool -> Bool
not (Ct -> Bool
insolubleEqCt Ct
ct) = Bool
False
| Ct -> Bool
arisesFromGivens Ct
ct = Bool
False
| Bool
otherwise = Bool
True
insolubleEqCt :: Ct -> Bool
insolubleEqCt :: Ct -> Bool
insolubleEqCt (CIrredCan { cc_insol :: Ct -> Bool
cc_insol = Bool
insol }) = Bool
insol
insolubleEqCt _ = Bool
False
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})
= String -> SDoc
text "WC" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
braces ([SDoc] -> SDoc
vcat
[ SDoc -> Cts -> SDoc
forall a. Outputable a => SDoc -> Bag a -> SDoc
ppr_bag (String -> SDoc
text "wc_simple") Cts
s
, SDoc -> Bag Implication -> SDoc
forall a. Outputable a => SDoc -> Bag a -> SDoc
ppr_bag (String -> SDoc
text "wc_impl") Bag Implication
i ])
ppr_bag :: Outputable a => SDoc -> Bag a -> SDoc
ppr_bag :: SDoc -> Bag a -> SDoc
ppr_bag doc :: SDoc
doc bag :: Bag a
bag
| Bag a -> Bool
forall a. Bag a -> Bool
isEmptyBag Bag a
bag = SDoc
empty
| Bool
otherwise = SDoc -> Int -> SDoc -> SDoc
hang (SDoc
doc SDoc -> SDoc -> SDoc
<+> SDoc
equals)
2 ((a -> SDoc -> SDoc) -> SDoc -> Bag a -> SDoc
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (SDoc -> SDoc -> SDoc
($$) (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
empty Bag a
bag)
data Implication
= Implic {
Implication -> TcLevel
ic_tclvl :: TcLevel,
Implication -> [TcTyVar]
ic_skols :: [TcTyVar],
Implication -> SkolemInfo
ic_info :: SkolemInfo,
Implication -> Maybe SDoc
ic_telescope :: Maybe SDoc,
Implication -> [TcTyVar]
ic_given :: [EvVar],
Implication -> Bool
ic_no_eqs :: Bool,
Implication -> Bool
ic_warn_inaccessible :: Bool,
Implication -> TcLclEnv
ic_env :: TcLclEnv,
Implication -> WantedConstraints
ic_wanted :: WantedConstraints,
Implication -> EvBindsVar
ic_binds :: EvBindsVar,
Implication -> TcTyCoVarSet
ic_need_inner :: VarSet,
Implication -> TcTyCoVarSet
ic_need_outer :: VarSet,
Implication -> ImplicStatus
ic_status :: ImplicStatus
}
implicationPrototype :: Implication
implicationPrototype :: Implication
implicationPrototype
= Implic :: TcLevel
-> [TcTyVar]
-> SkolemInfo
-> Maybe SDoc
-> [TcTyVar]
-> Bool
-> Bool
-> TcLclEnv
-> WantedConstraints
-> EvBindsVar
-> TcTyCoVarSet
-> TcTyCoVarSet
-> ImplicStatus
-> Implication
Implic {
ic_tclvl :: TcLevel
ic_tclvl = String -> TcLevel
forall a. String -> a
panic "newImplic:tclvl"
, ic_binds :: EvBindsVar
ic_binds = String -> EvBindsVar
forall a. String -> a
panic "newImplic:binds"
, ic_info :: SkolemInfo
ic_info = String -> SkolemInfo
forall a. String -> a
panic "newImplic:info"
, ic_env :: TcLclEnv
ic_env = String -> TcLclEnv
forall a. String -> a
panic "newImplic:env"
, ic_warn_inaccessible :: Bool
ic_warn_inaccessible = String -> Bool
forall a. String -> a
panic "newImplic:warn_inaccessible"
, ic_skols :: [TcTyVar]
ic_skols = []
, ic_telescope :: Maybe SDoc
ic_telescope = Maybe SDoc
forall a. Maybe a
Nothing
, ic_given :: [TcTyVar]
ic_given = []
, ic_wanted :: WantedConstraints
ic_wanted = WantedConstraints
emptyWC
, ic_no_eqs :: Bool
ic_no_eqs = Bool
False
, 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
{ ImplicStatus -> [TcTyVar]
ics_dead :: [EvVar] }
| IC_Insoluble
| IC_BadTelescope
| IC_Unsolved
instance Outputable Implication where
ppr :: Implication -> SDoc
ppr (Implic { ic_tclvl :: Implication -> TcLevel
ic_tclvl = TcLevel
tclvl, ic_skols :: Implication -> [TcTyVar]
ic_skols = [TcTyVar]
skols
, ic_given :: Implication -> [TcTyVar]
ic_given = [TcTyVar]
given, ic_no_eqs :: Implication -> Bool
ic_no_eqs = Bool
no_eqs
, ic_wanted :: Implication -> WantedConstraints
ic_wanted = WantedConstraints
wanted, ic_status :: Implication -> ImplicStatus
ic_status = ImplicStatus
status
, ic_binds :: Implication -> EvBindsVar
ic_binds = EvBindsVar
binds
, ic_need_inner :: Implication -> TcTyCoVarSet
ic_need_inner = TcTyCoVarSet
need_in, ic_need_outer :: Implication -> TcTyCoVarSet
ic_need_outer = TcTyCoVarSet
need_out
, ic_info :: Implication -> SkolemInfo
ic_info = SkolemInfo
info })
= SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "Implic" SDoc -> SDoc -> SDoc
<+> SDoc
lbrace)
2 ([SDoc] -> SDoc
sep [ String -> SDoc
text "TcLevel =" SDoc -> SDoc -> SDoc
<+> TcLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcLevel
tclvl
, String -> SDoc
text "Skolems =" SDoc -> SDoc -> SDoc
<+> [TcTyVar] -> SDoc
pprTyVars [TcTyVar]
skols
, String -> SDoc
text "No-eqs =" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
no_eqs
, String -> SDoc
text "Status =" SDoc -> SDoc -> SDoc
<+> ImplicStatus -> SDoc
forall a. Outputable a => a -> SDoc
ppr ImplicStatus
status
, SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "Given =") 2 ([TcTyVar] -> SDoc
pprEvVars [TcTyVar]
given)
, SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "Wanted =") 2 (WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanted)
, String -> SDoc
text "Binds =" SDoc -> SDoc -> SDoc
<+> EvBindsVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr EvBindsVar
binds
, SDoc -> SDoc
whenPprDebug (String -> SDoc
text "Needed inner =" SDoc -> SDoc -> SDoc
<+> TcTyCoVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyCoVarSet
need_in)
, SDoc -> SDoc
whenPprDebug (String -> SDoc
text "Needed outer =" SDoc -> SDoc -> SDoc
<+> TcTyCoVarSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyCoVarSet
need_out)
, SkolemInfo -> SDoc
pprSkolInfo SkolemInfo
info ] SDoc -> SDoc -> SDoc
<+> SDoc
rbrace)
instance Outputable ImplicStatus where
ppr :: ImplicStatus -> SDoc
ppr IC_Insoluble = String -> SDoc
text "Insoluble"
ppr IC_BadTelescope = String -> SDoc
text "Bad telescope"
ppr IC_Unsolved = String -> SDoc
text "Unsolved"
ppr (IC_Solved { ics_dead :: ImplicStatus -> [TcTyVar]
ics_dead = [TcTyVar]
dead })
= String -> SDoc
text "Solved" SDoc -> SDoc -> SDoc
<+> (SDoc -> SDoc
braces (String -> SDoc
text "Dead givens =" SDoc -> SDoc -> SDoc
<+> [TcTyVar] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TcTyVar]
dead))
pprEvVars :: [EvVar] -> SDoc
pprEvVars :: [TcTyVar] -> SDoc
pprEvVars ev_vars :: [TcTyVar]
ev_vars = [SDoc] -> SDoc
vcat ((TcTyVar -> SDoc) -> [TcTyVar] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map TcTyVar -> SDoc
pprEvVarWithType [TcTyVar]
ev_vars)
pprEvVarTheta :: [EvVar] -> SDoc
pprEvVarTheta :: [TcTyVar] -> SDoc
pprEvVarTheta ev_vars :: [TcTyVar]
ev_vars = [Xi] -> SDoc
pprTheta ((TcTyVar -> Xi) -> [TcTyVar] -> [Xi]
forall a b. (a -> b) -> [a] -> [b]
map TcTyVar -> Xi
evVarPred [TcTyVar]
ev_vars)
pprEvVarWithType :: EvVar -> SDoc
pprEvVarWithType :: TcTyVar -> SDoc
pprEvVarWithType v :: TcTyVar
v = TcTyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVar
v SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Xi -> SDoc
pprType (TcTyVar -> Xi
evVarPred TcTyVar
v)
wrapTypeWithImplication :: Type -> Implication -> Type
wrapTypeWithImplication :: Xi -> Implication -> Xi
wrapTypeWithImplication ty :: Xi
ty impl :: Implication
impl = Xi -> [TcTyVar] -> [Xi] -> Xi
wrapType Xi
ty [TcTyVar]
mentioned_skols [Xi]
givens
where givens :: [Xi]
givens = (TcTyVar -> Xi) -> [TcTyVar] -> [Xi]
forall a b. (a -> b) -> [a] -> [b]
map TcTyVar -> Xi
idType ([TcTyVar] -> [Xi]) -> [TcTyVar] -> [Xi]
forall a b. (a -> b) -> a -> b
$ Implication -> [TcTyVar]
ic_given Implication
impl
skols :: [TcTyVar]
skols = Implication -> [TcTyVar]
ic_skols Implication
impl
freeVars :: TcTyCoVarSet
freeVars = FV -> TcTyCoVarSet
fvVarSet (FV -> TcTyCoVarSet) -> FV -> TcTyCoVarSet
forall a b. (a -> b) -> a -> b
$ [Xi] -> FV
tyCoFVsOfTypes (Xi
tyXi -> [Xi] -> [Xi]
forall a. a -> [a] -> [a]
:[Xi]
givens)
mentioned_skols :: [TcTyVar]
mentioned_skols = (TcTyVar -> Bool) -> [TcTyVar] -> [TcTyVar]
forall a. (a -> Bool) -> [a] -> [a]
filter (TcTyVar -> TcTyCoVarSet -> Bool
`elemVarSet` TcTyCoVarSet
freeVars) [TcTyVar]
skols
wrapType :: Type -> [TyVar] -> [PredType] -> Type
wrapType :: Xi -> [TcTyVar] -> [Xi] -> Xi
wrapType ty :: Xi
ty skols :: [TcTyVar]
skols givens :: [Xi]
givens = [TcTyVar] -> Xi -> Xi
mkSpecForAllTys [TcTyVar]
skols (Xi -> Xi) -> Xi -> Xi
forall a b. (a -> b) -> a -> b
$ [Xi] -> Xi -> Xi
mkPhiTy [Xi]
givens Xi
ty
data TcEvDest
= EvVarDest EvVar
| HoleDest CoercionHole
data CtEvidence
= CtGiven
{ CtEvidence -> Xi
ctev_pred :: TcPredType
, CtEvidence -> TcTyVar
ctev_evar :: EvVar
, CtEvidence -> CtLoc
ctev_loc :: CtLoc }
| CtWanted
{ ctev_pred :: TcPredType
, CtEvidence -> TcEvDest
ctev_dest :: TcEvDest
, CtEvidence -> ShadowInfo
ctev_nosh :: ShadowInfo
, ctev_loc :: CtLoc }
| CtDerived
{ ctev_pred :: TcPredType
, ctev_loc :: CtLoc }
ctEvPred :: CtEvidence -> TcPredType
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
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
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 ev :: CtEvidence
ev = EvExpr -> EvTerm
EvExpr (CtEvidence -> EvExpr
ctEvExpr CtEvidence
ev)
ctEvExpr :: CtEvidence -> EvExpr
ctEvExpr :: CtEvidence -> EvExpr
ctEvExpr ev :: CtEvidence
ev@(CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = HoleDest _ })
= 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 ev :: CtEvidence
ev = TcTyVar -> EvExpr
evId (CtEvidence -> TcTyVar
ctEvEvId CtEvidence
ev)
ctEvCoercion :: HasDebugCallStack => CtEvidence -> TcCoercion
ctEvCoercion :: CtEvidence -> Coercion
ctEvCoercion (CtGiven { ctev_evar :: CtEvidence -> TcTyVar
ctev_evar = TcTyVar
ev_id })
= TcTyVar -> Coercion
mkTcCoVarCo TcTyVar
ev_id
ctEvCoercion (CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = TcEvDest
dest })
| HoleDest hole :: CoercionHole
hole <- TcEvDest
dest
=
CoercionHole -> Coercion
mkHoleCo CoercionHole
hole
ctEvCoercion ev :: CtEvidence
ev
= String -> SDoc -> Coercion
forall a. HasCallStack => String -> SDoc -> a
pprPanic "ctEvCoercion" (CtEvidence -> SDoc
forall a. Outputable a => a -> SDoc
ppr CtEvidence
ev)
ctEvEvId :: CtEvidence -> EvVar
ctEvEvId :: CtEvidence -> TcTyVar
ctEvEvId (CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = EvVarDest ev :: TcTyVar
ev }) = TcTyVar
ev
ctEvEvId (CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = HoleDest h :: CoercionHole
h }) = CoercionHole -> TcTyVar
coHoleCoVar CoercionHole
h
ctEvEvId (CtGiven { ctev_evar :: CtEvidence -> TcTyVar
ctev_evar = TcTyVar
ev }) = TcTyVar
ev
ctEvEvId ctev :: CtEvidence
ctev@(CtDerived {}) = String -> SDoc -> TcTyVar
forall a. HasCallStack => String -> SDoc -> a
pprPanic "ctEvId:" (CtEvidence -> SDoc
forall a. Outputable a => a -> SDoc
ppr CtEvidence
ctev)
instance Outputable TcEvDest where
ppr :: TcEvDest -> SDoc
ppr (HoleDest h :: CoercionHole
h) = String -> SDoc
text "hole" SDoc -> SDoc -> SDoc
<> CoercionHole -> SDoc
forall a. Outputable a => a -> SDoc
ppr CoercionHole
h
ppr (EvVarDest ev :: TcTyVar
ev) = TcTyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVar
ev
instance Outputable CtEvidence where
ppr :: CtEvidence -> SDoc
ppr ev :: CtEvidence
ev = CtFlavour -> SDoc
forall a. Outputable a => a -> SDoc
ppr (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev)
SDoc -> SDoc -> SDoc
<+> SDoc
pp_ev
SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
braces (SubGoalDepth -> SDoc
forall a. Outputable a => a -> SDoc
ppr (CtLoc -> SubGoalDepth
ctl_depth (CtEvidence -> CtLoc
ctEvLoc CtEvidence
ev))) SDoc -> SDoc -> SDoc
<> SDoc
dcolon
SDoc -> SDoc -> SDoc
<+> 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 -> TcTyVar
ctev_evar = TcTyVar
v } -> TcTyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcTyVar
v
CtWanted {ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = TcEvDest
d } -> TcEvDest -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcEvDest
d
CtDerived {} -> String -> SDoc
text "_"
isWanted :: CtEvidence -> Bool
isWanted :: CtEvidence -> Bool
isWanted (CtWanted {}) = Bool
True
isWanted _ = Bool
False
isGiven :: CtEvidence -> Bool
isGiven :: CtEvidence -> Bool
isGiven (CtGiven {}) = Bool
True
isGiven _ = Bool
False
isDerived :: CtEvidence -> Bool
isDerived :: CtEvidence -> Bool
isDerived (CtDerived {}) = Bool
True
isDerived _ = Bool
False
data CtFlavour
= Given
| Wanted ShadowInfo
| Derived
deriving CtFlavour -> CtFlavour -> Bool
(CtFlavour -> CtFlavour -> Bool)
-> (CtFlavour -> CtFlavour -> Bool) -> Eq CtFlavour
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CtFlavour -> CtFlavour -> Bool
$c/= :: CtFlavour -> CtFlavour -> Bool
== :: CtFlavour -> CtFlavour -> Bool
$c== :: CtFlavour -> CtFlavour -> Bool
Eq
data ShadowInfo
= WDeriv
| WOnly
deriving( ShadowInfo -> ShadowInfo -> Bool
(ShadowInfo -> ShadowInfo -> Bool)
-> (ShadowInfo -> ShadowInfo -> Bool) -> Eq ShadowInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShadowInfo -> ShadowInfo -> Bool
$c/= :: ShadowInfo -> ShadowInfo -> Bool
== :: ShadowInfo -> ShadowInfo -> Bool
$c== :: ShadowInfo -> ShadowInfo -> Bool
Eq )
isGivenOrWDeriv :: CtFlavour -> Bool
isGivenOrWDeriv :: CtFlavour -> Bool
isGivenOrWDeriv Given = Bool
True
isGivenOrWDeriv (Wanted WDeriv) = Bool
True
isGivenOrWDeriv _ = Bool
False
instance Outputable CtFlavour where
ppr :: CtFlavour -> SDoc
ppr Given = String -> SDoc
text "[G]"
ppr (Wanted WDeriv) = String -> SDoc
text "[WD]"
ppr (Wanted WOnly) = String -> SDoc
text "[W]"
ppr Derived = String -> SDoc
text "[D]"
ctEvFlavour :: CtEvidence -> CtFlavour
ctEvFlavour :: CtEvidence -> CtFlavour
ctEvFlavour (CtWanted { ctev_nosh :: CtEvidence -> ShadowInfo
ctev_nosh = ShadowInfo
nosh }) = ShadowInfo -> CtFlavour
Wanted ShadowInfo
nosh
ctEvFlavour (CtGiven {}) = CtFlavour
Given
ctEvFlavour (CtDerived {}) = CtFlavour
Derived
type CtFlavourRole = (CtFlavour, EqRel)
ctEvFlavourRole :: CtEvidence -> CtFlavourRole
ctEvFlavourRole :: CtEvidence -> CtFlavourRole
ctEvFlavourRole ev :: CtEvidence
ev = (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, CtEvidence -> EqRel
ctEvEqRel CtEvidence
ev)
ctFlavourRole :: Ct -> CtFlavourRole
ctFlavourRole :: Ct -> CtFlavourRole
ctFlavourRole (CDictCan { cc_ev :: Ct -> CtEvidence
cc_ev = CtEvidence
ev })
= (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, EqRel
NomEq)
ctFlavourRole (CTyEqCan { cc_ev :: Ct -> CtEvidence
cc_ev = CtEvidence
ev, cc_eq_rel :: Ct -> EqRel
cc_eq_rel = EqRel
eq_rel })
= (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, EqRel
eq_rel)
ctFlavourRole (CFunEqCan { cc_ev :: Ct -> CtEvidence
cc_ev = CtEvidence
ev })
= (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, EqRel
NomEq)
ctFlavourRole (CHoleCan { cc_ev :: Ct -> CtEvidence
cc_ev = CtEvidence
ev })
= (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, EqRel
NomEq)
ctFlavourRole ct :: Ct
ct
= CtEvidence -> CtFlavourRole
ctEvFlavourRole (Ct -> CtEvidence
ctEvidence Ct
ct)
eqCanRewrite :: EqRel -> EqRel -> Bool
eqCanRewrite :: EqRel -> EqRel -> Bool
eqCanRewrite NomEq _ = Bool
True
eqCanRewrite ReprEq ReprEq = Bool
True
eqCanRewrite ReprEq NomEq = Bool
False
eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqCanRewriteFR (Given, r1 :: EqRel
r1) (_, r2 :: EqRel
r2) = EqRel -> EqRel -> Bool
eqCanRewrite EqRel
r1 EqRel
r2
eqCanRewriteFR (Wanted WDeriv, NomEq) (Derived, NomEq) = Bool
True
eqCanRewriteFR (Derived, NomEq) (Derived, NomEq) = Bool
True
eqCanRewriteFR _ _ = Bool
False
eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqMayRewriteFR (Wanted WDeriv, NomEq) (Wanted WDeriv, NomEq) = Bool
True
eqMayRewriteFR (Derived, NomEq) (Wanted WDeriv, NomEq) = Bool
True
eqMayRewriteFR fr1 :: CtFlavourRole
fr1 fr2 :: CtFlavourRole
fr2 = CtFlavourRole -> CtFlavourRole -> Bool
eqCanRewriteFR CtFlavourRole
fr1 CtFlavourRole
fr2
funEqCanDischarge
:: CtEvidence -> CtEvidence
-> ( SwapFlag
, Bool)
funEqCanDischarge :: CtEvidence -> CtEvidence -> (SwapFlag, Bool)
funEqCanDischarge ev1 :: CtEvidence
ev1 ev2 :: CtEvidence
ev2
= ASSERT2( ctEvEqRel ev1 == NomEq, ppr ev1 )
ASSERT2( ctEvEqRel ev2 == NomEq, ppr ev2 )
CtFlavour -> CtFlavour -> (SwapFlag, Bool)
funEqCanDischargeF (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev1) (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev2)
funEqCanDischargeF :: CtFlavour -> CtFlavour -> (SwapFlag, Bool)
funEqCanDischargeF :: CtFlavour -> CtFlavour -> (SwapFlag, Bool)
funEqCanDischargeF Given _ = (SwapFlag
NotSwapped, Bool
False)
funEqCanDischargeF _ Given = (SwapFlag
IsSwapped, Bool
False)
funEqCanDischargeF (Wanted WDeriv) _ = (SwapFlag
NotSwapped, Bool
False)
funEqCanDischargeF _ (Wanted WDeriv) = (SwapFlag
IsSwapped, Bool
True)
funEqCanDischargeF (Wanted WOnly) (Wanted WOnly) = (SwapFlag
NotSwapped, Bool
False)
funEqCanDischargeF (Wanted WOnly) Derived = (SwapFlag
NotSwapped, Bool
True)
funEqCanDischargeF Derived (Wanted WOnly) = (SwapFlag
IsSwapped, Bool
True)
funEqCanDischargeF Derived Derived = (SwapFlag
NotSwapped, Bool
False)
eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool
eqCanDischargeFR (f1 :: CtFlavour
f1,r1 :: EqRel
r1) (f2 :: CtFlavour
f2, r2 :: EqRel
r2) = EqRel -> EqRel -> Bool
eqCanRewrite EqRel
r1 EqRel
r2
Bool -> Bool -> Bool
&& CtFlavour -> CtFlavour -> Bool
eqCanDischargeF CtFlavour
f1 CtFlavour
f2
eqCanDischargeF :: CtFlavour -> CtFlavour -> Bool
eqCanDischargeF :: CtFlavour -> CtFlavour -> Bool
eqCanDischargeF Given _ = Bool
True
eqCanDischargeF (Wanted _) (Wanted _) = Bool
True
eqCanDischargeF (Wanted WDeriv) Derived = Bool
True
eqCanDischargeF Derived Derived = Bool
True
eqCanDischargeF _ _ = Bool
False
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
/= :: SubGoalDepth -> SubGoalDepth -> Bool
$c/= :: SubGoalDepth -> SubGoalDepth -> Bool
== :: SubGoalDepth -> SubGoalDepth -> Bool
$c== :: 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
min :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
$cmin :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
max :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
$cmax :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
>= :: SubGoalDepth -> SubGoalDepth -> Bool
$c>= :: SubGoalDepth -> SubGoalDepth -> Bool
> :: SubGoalDepth -> SubGoalDepth -> Bool
$c> :: SubGoalDepth -> SubGoalDepth -> Bool
<= :: SubGoalDepth -> SubGoalDepth -> Bool
$c<= :: SubGoalDepth -> SubGoalDepth -> Bool
< :: SubGoalDepth -> SubGoalDepth -> Bool
$c< :: SubGoalDepth -> SubGoalDepth -> Bool
compare :: SubGoalDepth -> SubGoalDepth -> Ordering
$ccompare :: SubGoalDepth -> SubGoalDepth -> Ordering
$cp1Ord :: Eq SubGoalDepth
Ord, Rational -> SubGoalDepth -> SDoc
SubGoalDepth -> SDoc
(SubGoalDepth -> SDoc)
-> (Rational -> SubGoalDepth -> SDoc) -> Outputable SubGoalDepth
forall a. (a -> SDoc) -> (Rational -> a -> SDoc) -> Outputable a
pprPrec :: Rational -> SubGoalDepth -> SDoc
$cpprPrec :: Rational -> SubGoalDepth -> SDoc
ppr :: SubGoalDepth -> SDoc
$cppr :: SubGoalDepth -> SDoc
Outputable)
initialSubGoalDepth :: SubGoalDepth
initialSubGoalDepth :: SubGoalDepth
initialSubGoalDepth = Int -> SubGoalDepth
SubGoalDepth 0
bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth
bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth
bumpSubGoalDepth (SubGoalDepth n :: Int
n) = Int -> SubGoalDepth
SubGoalDepth (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1)
maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth
maxSubGoalDepth (SubGoalDepth n :: Int
n) (SubGoalDepth m :: Int
m) = Int -> SubGoalDepth
SubGoalDepth (Int
n Int -> Int -> Int
forall a. Ord a => a -> a -> a
`max` Int
m)
subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool
subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool
subGoalDepthExceeded dflags :: DynFlags
dflags (SubGoalDepth d :: Int
d)
= Int -> IntWithInf
mkIntWithInf Int
d IntWithInf -> IntWithInf -> Bool
forall a. Ord a => a -> a -> Bool
> DynFlags -> IntWithInf
reductionDepth DynFlags
dflags
data CtLoc = CtLoc { CtLoc -> CtOrigin
ctl_origin :: CtOrigin
, CtLoc -> TcLclEnv
ctl_env :: TcLclEnv
, CtLoc -> Maybe TypeOrKind
ctl_t_or_k :: Maybe TypeOrKind
, CtLoc -> SubGoalDepth
ctl_depth :: !SubGoalDepth }
mkKindLoc :: TcType -> TcType
-> CtLoc -> CtLoc
mkKindLoc :: Xi -> Xi -> CtLoc -> CtLoc
mkKindLoc s1 :: Xi
s1 s2 :: Xi
s2 loc :: CtLoc
loc = CtLoc -> CtOrigin -> CtLoc
setCtLocOrigin (CtLoc -> CtLoc
toKindLoc CtLoc
loc)
(Xi -> Maybe Xi -> CtOrigin -> Maybe TypeOrKind -> CtOrigin
KindEqOrigin Xi
s1 (Xi -> Maybe Xi
forall a. a -> Maybe a
Just Xi
s2) (CtLoc -> CtOrigin
ctLocOrigin CtLoc
loc)
(CtLoc -> Maybe TypeOrKind
ctLocTypeOrKind_maybe CtLoc
loc))
toKindLoc :: CtLoc -> CtLoc
toKindLoc :: CtLoc -> CtLoc
toKindLoc loc :: CtLoc
loc = CtLoc
loc { ctl_t_or_k :: Maybe TypeOrKind
ctl_t_or_k = TypeOrKind -> Maybe TypeOrKind
forall a. a -> Maybe a
Just TypeOrKind
KindLevel }
mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc
mkGivenLoc tclvl :: TcLevel
tclvl skol_info :: SkolemInfo
skol_info env :: TcLclEnv
env
= $WCtLoc :: CtOrigin -> TcLclEnv -> Maybe TypeOrKind -> SubGoalDepth -> CtLoc
CtLoc { ctl_origin :: CtOrigin
ctl_origin = SkolemInfo -> CtOrigin
GivenOrigin SkolemInfo
skol_info
, ctl_env :: TcLclEnv
ctl_env = TcLclEnv -> TcLevel -> TcLclEnv
setLclEnvTcLevel TcLclEnv
env TcLevel
tclvl
, ctl_t_or_k :: Maybe TypeOrKind
ctl_t_or_k = Maybe TypeOrKind
forall a. Maybe a
Nothing
, ctl_depth :: SubGoalDepth
ctl_depth = SubGoalDepth
initialSubGoalDepth }
ctLocEnv :: CtLoc -> TcLclEnv
ctLocEnv :: CtLoc -> TcLclEnv
ctLocEnv = CtLoc -> TcLclEnv
ctl_env
ctLocLevel :: CtLoc -> TcLevel
ctLocLevel :: CtLoc -> TcLevel
ctLocLevel loc :: CtLoc
loc = TcLclEnv -> TcLevel
getLclEnvTcLevel (CtLoc -> TcLclEnv
ctLocEnv CtLoc
loc)
ctLocDepth :: CtLoc -> SubGoalDepth
ctLocDepth :: CtLoc -> SubGoalDepth
ctLocDepth = CtLoc -> SubGoalDepth
ctl_depth
ctLocOrigin :: CtLoc -> CtOrigin
ctLocOrigin :: CtLoc -> CtOrigin
ctLocOrigin = CtLoc -> CtOrigin
ctl_origin
ctLocSpan :: CtLoc -> RealSrcSpan
ctLocSpan :: CtLoc -> RealSrcSpan
ctLocSpan (CtLoc { ctl_env :: CtLoc -> TcLclEnv
ctl_env = TcLclEnv
lcl}) = TcLclEnv -> RealSrcSpan
getLclEnvLoc TcLclEnv
lcl
ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind
ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind
ctLocTypeOrKind_maybe = CtLoc -> Maybe TypeOrKind
ctl_t_or_k
setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc
setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc
setCtLocSpan ctl :: CtLoc
ctl@(CtLoc { ctl_env :: CtLoc -> TcLclEnv
ctl_env = TcLclEnv
lcl }) loc :: RealSrcSpan
loc = CtLoc -> TcLclEnv -> CtLoc
setCtLocEnv CtLoc
ctl (TcLclEnv -> RealSrcSpan -> TcLclEnv
setLclEnvLoc TcLclEnv
lcl RealSrcSpan
loc)
bumpCtLocDepth :: CtLoc -> CtLoc
bumpCtLocDepth :: CtLoc -> CtLoc
bumpCtLocDepth loc :: CtLoc
loc@(CtLoc { ctl_depth :: CtLoc -> SubGoalDepth
ctl_depth = SubGoalDepth
d }) = CtLoc
loc { ctl_depth :: SubGoalDepth
ctl_depth = SubGoalDepth -> SubGoalDepth
bumpSubGoalDepth SubGoalDepth
d }
setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc
setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc
setCtLocOrigin ctl :: CtLoc
ctl orig :: CtOrigin
orig = CtLoc
ctl { ctl_origin :: CtOrigin
ctl_origin = CtOrigin
orig }
updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc
updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc
updateCtLocOrigin ctl :: CtLoc
ctl@(CtLoc { ctl_origin :: CtLoc -> CtOrigin
ctl_origin = CtOrigin
orig }) upd :: CtOrigin -> CtOrigin
upd
= CtLoc
ctl { ctl_origin :: CtOrigin
ctl_origin = CtOrigin -> CtOrigin
upd CtOrigin
orig }
setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc
setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc
setCtLocEnv ctl :: CtLoc
ctl env :: TcLclEnv
env = CtLoc
ctl { ctl_env :: TcLclEnv
ctl_env = TcLclEnv
env }
pprCtLoc :: CtLoc -> SDoc
pprCtLoc :: CtLoc -> SDoc
pprCtLoc (CtLoc { ctl_origin :: CtLoc -> CtOrigin
ctl_origin = CtOrigin
o, ctl_env :: CtLoc -> TcLclEnv
ctl_env = TcLclEnv
lcl})
= [SDoc] -> SDoc
sep [ CtOrigin -> SDoc
pprCtOrigin CtOrigin
o
, String -> SDoc
text "at" SDoc -> SDoc -> SDoc
<+> RealSrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcLclEnv -> RealSrcSpan
getLclEnvLoc TcLclEnv
lcl)]