{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE TypeApplications #-}
module GHC.Tc.Types.Constraint (
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,
boundOccNamesOfWC,
EqCt(..), eqCtEvidence, eqCtLHS,
DictCt(..), dictCtEvidence, dictCtPred,
IrredCt(..), irredCtEvidence, mkIrredCt, ctIrredCt, irredCtPred,
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, addMultiplicityCoercionError, addDelayedErrors,
tyCoVarsOfWC, tyCoVarsOfWCList,
insolubleWantedCt, insolubleCt, insolubleIrredCt,
insolubleImplic, nonDefaultableTyVarsOfWC,
approximateWCX, approximateWC,
Implication(..), implicationPrototype, checkTelescopeSkol,
ImplicStatus(..), isInsolubleStatus, isSolvedStatus,
UserGiven, getUserGivensFromImplics,
HasGivenEqs(..), checkImplicationInvariants,
CtLocEnv(..), setCtLocEnvLoc, setCtLocEnvLvl, getCtLocEnvLoc, getCtLocEnvLvl, ctLocEnvInGeneratedCode,
CtEvidence(..), TcEvDest(..),
isWanted, isGiven,
ctEvPred, ctEvLoc, ctEvOrigin, ctEvEqRel,
ctEvExpr, ctEvTerm, ctEvCoercion, ctEvEvId,
ctEvRewriters, ctEvUnique, tcEvDestUnique,
ctEvRewriteRole, ctEvRewriteEqRel, setCtEvPredType, setCtEvLoc,
tyCoVarsOfCtEvList, tyCoVarsOfCtEv, tyCoVarsOfCtEvsList,
RewriterSet(..), emptyRewriterSet, isEmptyRewriterSet,
addRewriter, unitRewriterSet, unionRewriterSet, rewriterSetFromCts,
wrapType,
CtFlavour(..), ctEvFlavour,
CtFlavourRole, ctEvFlavourRole, ctFlavourRole, eqCtFlavourRole,
eqCanRewrite, eqCanRewriteFR,
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.CtLoc
import GHC.Core
import GHC.Core.TyCo.Ppr
import GHC.Utils.FV
import GHC.Types.Var.Set
import GHC.Builtin.Names
import GHC.Types.Unique.Set
import GHC.Utils.Outputable
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 )
import Data.Word ( Word8 )
import Data.List ( intersperse )
type Xi = TcType
type Cts = Bag Ct
type ExpansionFuel = Int
doNotExpand :: ExpansionFuel
doNotExpand :: ExpansionFuel
doNotExpand = ExpansionFuel
0
consumeFuel :: ExpansionFuel -> ExpansionFuel
consumeFuel :: ExpansionFuel -> ExpansionFuel
consumeFuel ExpansionFuel
fuel = ExpansionFuel -> ExpansionFuel -> ExpansionFuel
forall a. ExpansionFuel -> a -> a
assertFuelPreconditionStrict ExpansionFuel
fuel (ExpansionFuel -> ExpansionFuel) -> ExpansionFuel -> ExpansionFuel
forall a b. (a -> b) -> a -> b
$ ExpansionFuel
fuel ExpansionFuel -> ExpansionFuel -> ExpansionFuel
forall a. Num a => a -> a -> a
- ExpansionFuel
1
pendingFuel :: ExpansionFuel -> Bool
pendingFuel :: ExpansionFuel -> Bool
pendingFuel ExpansionFuel
n = ExpansionFuel
n ExpansionFuel -> ExpansionFuel -> Bool
forall a. Ord a => a -> a -> Bool
> ExpansionFuel
0
insufficientFuelError :: SDoc
insufficientFuelError :: SDoc
insufficientFuelError = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"Superclass expansion fuel should be > 0"
assertFuelPrecondition :: ExpansionFuel -> a -> a
{-# INLINE assertFuelPrecondition #-}
assertFuelPrecondition :: forall a. ExpansionFuel -> a -> a
assertFuelPrecondition ExpansionFuel
fuel = Bool -> SDoc -> a -> a
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (ExpansionFuel
fuel ExpansionFuel -> ExpansionFuel -> Bool
forall a. Ord a => a -> a -> Bool
>= ExpansionFuel
0) SDoc
insufficientFuelError
assertFuelPreconditionStrict :: ExpansionFuel -> a -> a
{-# INLINE assertFuelPreconditionStrict #-}
assertFuelPreconditionStrict :: forall a. ExpansionFuel -> a -> a
assertFuelPreconditionStrict ExpansionFuel
fuel = Bool -> SDoc -> a -> a
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (ExpansionFuel -> Bool
pendingFuel ExpansionFuel
fuel) SDoc
insufficientFuelError
data Ct
= CDictCan DictCt
| CIrredCan IrredCt
| CEqCan EqCt
| CQuantCan QCInst
| CNonCanonical CtEvidence
data DictCt
= DictCt { DictCt -> CtEvidence
di_ev :: CtEvidence
, DictCt -> Class
di_cls :: Class
, DictCt -> [Xi]
di_tys :: [Xi]
, DictCt -> ExpansionFuel
di_pend_sc :: ExpansionFuel
}
dictCtEvidence :: DictCt -> CtEvidence
dictCtEvidence :: DictCt -> CtEvidence
dictCtEvidence = DictCt -> CtEvidence
di_ev
dictCtPred :: DictCt -> TcPredType
dictCtPred :: DictCt -> Xi
dictCtPred (DictCt { di_cls :: DictCt -> Class
di_cls = Class
cls, di_tys :: DictCt -> [Xi]
di_tys = [Xi]
tys }) = Class -> [Xi] -> Xi
mkClassPred Class
cls [Xi]
tys
instance Outputable DictCt where
ppr :: DictCt -> SDoc
ppr DictCt
dict = Ct -> SDoc
forall a. Outputable a => a -> SDoc
ppr (DictCt -> Ct
CDictCan DictCt
dict)
data EqCt
= EqCt {
EqCt -> CtEvidence
eq_ev :: CtEvidence,
EqCt -> CanEqLHS
eq_lhs :: CanEqLHS,
EqCt -> Xi
eq_rhs :: Xi,
EqCt -> EqRel
eq_eq_rel :: EqRel
}
data CanEqLHS
= TyVarLHS TcTyVar
| TyFamLHS TyCon
[Xi]
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
data IrredCt
= IrredCt { IrredCt -> CtEvidence
ir_ev :: CtEvidence
, 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)
data QCInst
= QCI { QCInst -> CtEvidence
qci_ev :: CtEvidence
, QCInst -> [EvVar]
qci_tvs :: [TcTyVar]
, QCInst -> Xi
qci_pred :: TcPredType
, QCInst -> ExpansionFuel
qci_pend_sc :: ExpansionFuel
}
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 DelayedError
= DE_Hole Hole
| DE_NotConcrete NotConcreteError
| DE_Multiplicity TcCoercion CtLoc
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
ppr (DE_Multiplicity TcCoercion
co CtLoc
_) = TcCoercion -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcCoercion
co
data Hole
= Hole { Hole -> HoleSort
hole_sort :: HoleSort
, Hole -> RdrName
hole_occ :: RdrName
, Hole -> Xi
hole_ty :: TcType
, Hole -> CtLoc
hole_loc :: CtLoc
}
data HoleSort = ExprHole HoleExprRef
| TypeHole
| ConstraintHole
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"
data NotConcreteError
= NCE_FRR
{ NotConcreteError -> CtLoc
nce_loc :: CtLoc
, NotConcreteError -> FixedRuntimeRepOrigin
nce_frr_origin :: FixedRuntimeRepOrigin
, NotConcreteError -> NonEmpty NotConcreteReason
nce_reasons :: NonEmpty NotConcreteReason
}
data NotConcreteReason
= NonConcreteTyCon TyCon [TcType]
| NonConcretisableTyVar TyVar
| ContainsCast TcType TcCoercionN
| ContainsForall ForAllTyBinder TcType
| 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))
data CtIrredReason
= IrredShapeReason
| NonCanonicalReason CheckTyEqResult
| ReprEqReason
| ShapeMismatchReason
| AbstractTyConReason
| PluginReason
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)"
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
newtype CheckTyEqResult = CTER Word8
cteOK :: CheckTyEqResult
cteOK :: CheckTyEqResult
cteOK = Word8 -> CheckTyEqResult
CTER Word8
forall a. Bits a => a
zeroBits
cterHasNoProblem :: CheckTyEqResult -> Bool
cterHasNoProblem :: CheckTyEqResult -> Bool
cterHasNoProblem (CTER Word8
0) = Bool
True
cterHasNoProblem CheckTyEqResult
_ = Bool
False
newtype CheckTyEqProblem = CTEP Word8
cteImpredicative, cteTypeFamily, cteInsolubleOccurs,
cteSolubleOccurs, cteCoercionHole, cteConcrete,
cteSkolemEscape :: CheckTyEqProblem
cteImpredicative :: CheckTyEqProblem
cteImpredicative = Word8 -> CheckTyEqProblem
CTEP (ExpansionFuel -> Word8
forall a. (Num a, Bits a) => ExpansionFuel -> a
bit ExpansionFuel
0)
cteTypeFamily :: CheckTyEqProblem
cteTypeFamily = Word8 -> CheckTyEqProblem
CTEP (ExpansionFuel -> Word8
forall a. (Num a, Bits a) => ExpansionFuel -> a
bit ExpansionFuel
1)
cteInsolubleOccurs :: CheckTyEqProblem
cteInsolubleOccurs = Word8 -> CheckTyEqProblem
CTEP (ExpansionFuel -> Word8
forall a. (Num a, Bits a) => ExpansionFuel -> a
bit ExpansionFuel
2)
cteSolubleOccurs :: CheckTyEqProblem
cteSolubleOccurs = Word8 -> CheckTyEqProblem
CTEP (ExpansionFuel -> Word8
forall a. (Num a, Bits a) => ExpansionFuel -> a
bit ExpansionFuel
3)
cteCoercionHole :: CheckTyEqProblem
cteCoercionHole = Word8 -> CheckTyEqProblem
CTEP (ExpansionFuel -> Word8
forall a. (Num a, Bits a) => ExpansionFuel -> a
bit ExpansionFuel
4)
cteConcrete :: CheckTyEqProblem
cteConcrete = Word8 -> CheckTyEqProblem
CTEP (ExpansionFuel -> Word8
forall a. (Num a, Bits a) => ExpansionFuel -> a
bit ExpansionFuel
5)
cteSkolemEscape :: CheckTyEqProblem
cteSkolemEscape = Word8 -> CheckTyEqProblem
CTEP (ExpansionFuel -> Word8
forall a. (Num a, Bits a) => ExpansionFuel -> a
bit ExpansionFuel
6)
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
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
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)
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 -> ExpansionFuel -> Word8
forall a. Bits a => a -> ExpansionFuel -> a
`shift` ExpansionFuel
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
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") ]
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
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
ctEvId :: HasDebugCallStack => Ct -> EvVar
ctEvId Ct
ct = CtEvidence -> EvVar
ctEvEvId (Ct -> CtEvidence
ctEvidence Ct
ct)
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
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
mkNomEqPred
EqRel
ReprEq -> Xi -> Xi -> Xi
mkReprEqPred
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 = HasDebugCallStack => CtEvidence -> EqRel
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 -> ExpansionFuel
di_pend_sc = ExpansionFuel
psc })
| ExpansionFuel
psc ExpansionFuel -> ExpansionFuel -> Bool
forall a. Ord a => a -> a -> Bool
> ExpansionFuel
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
<+> ExpansionFuel -> SDoc
forall a. Outputable a => a -> SDoc
ppr ExpansionFuel
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 -> ExpansionFuel
qci_pend_sc = ExpansionFuel
psc })
| ExpansionFuel
psc ExpansionFuel -> ExpansionFuel -> Bool
forall a. Ord a => a -> a -> Bool
> ExpansionFuel
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
<+> ExpansionFuel -> SDoc
forall a. Outputable a => a -> SDoc
ppr ExpansionFuel
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
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) <- HasDebugCallStack => Xi -> Maybe (TyCon, [Xi])
Xi -> Maybe (TyCon, [Xi])
tcSplitTyConApp_maybe Xi
xi
, TyCon -> Bool
isTypeFamilyTyCon TyCon
tc
, [Xi]
args [Xi] -> ExpansionFuel -> Bool
forall a. [a] -> ExpansionFuel -> Bool
`lengthIs` TyCon -> ExpansionFuel
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
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
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
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
boundOccNamesOfWC :: WantedConstraints -> [OccName]
boundOccNamesOfWC :: WantedConstraints -> [OccName]
boundOccNamesOfWC WantedConstraints
wc = Bag OccName -> [OccName]
forall a. Bag a -> [a]
bagToList (WantedConstraints -> Bag OccName
go_wc WantedConstraints
wc)
where
go_wc :: WantedConstraints -> Bag OccName
go_wc (WC { wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics })
= (Implication -> Bag OccName) -> Bag Implication -> Bag OccName
forall a b. (a -> Bag b) -> Bag a -> Bag b
concatMapBag Implication -> Bag OccName
go_implic Bag Implication
implics
go_implic :: Implication -> Bag OccName
go_implic (Implic { ic_skols :: Implication -> [EvVar]
ic_skols = [EvVar]
tvs, ic_wanted :: Implication -> WantedConstraints
ic_wanted = WantedConstraints
wc })
= [OccName] -> Bag OccName
forall a. [a] -> Bag a
listToBag ((EvVar -> OccName) -> [EvVar] -> [OccName]
forall a b. (a -> b) -> [a] -> [b]
map EvVar -> OccName
forall a. NamedThing a => a -> OccName
getOccName [EvVar]
tvs) Bag OccName -> Bag OccName -> Bag OccName
forall a. Bag a -> Bag a -> Bag a
`unionBags` WantedConstraints -> Bag OccName
go_wc WantedConstraints
wc
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
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
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
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
tyCoFVsOfCt :: Ct -> FV
tyCoFVsOfCt :: Ct -> FV
tyCoFVsOfCt Ct
ct = Xi -> FV
tyCoFVsOfType (Ct -> Xi
ctPred Ct
ct)
tyCoFVsOfCtEv :: CtEvidence -> FV
tyCoFVsOfCtEv :: CtEvidence -> FV
tyCoFVsOfCtEv CtEvidence
ct = Xi -> FV
tyCoFVsOfType (CtEvidence -> Xi
ctEvPred CtEvidence
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 -> [EvVar]
tyCoVarsOfCtsList = FV -> [EvVar]
fvVarList (FV -> [EvVar]) -> (Cts -> FV) -> Cts -> [EvVar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cts -> FV
tyCoFVsOfCts
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
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
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
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 -> [EvVar]
tyCoVarsOfWCList = FV -> [EvVar]
fvVarList (FV -> [EvVar])
-> (WantedConstraints -> FV) -> WantedConstraints -> [EvVar]
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, 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
tyCoFVsOfImplic :: Implication -> FV
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
tyCoFVsOfDelayedError (DE_Multiplicity TcCoercion
co CtLoc
_) = TcCoercion -> FV
tyCoFVsOfCo TcCoercion
co
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
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
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
subTys :: Xi -> [Xi]
subTys Xi
t = case HasDebugCallStack => Xi -> (Xi, [Xi])
Xi -> (Xi, [Xi])
splitAppTys Xi
t of
(Xi
t,[]) ->
case HasDebugCallStack => Xi -> Maybe (TyCon, [Xi])
Xi -> Maybe (TyCon, [Xi])
splitTyConApp_maybe Xi
t of
Maybe (TyCon, [Xi])
Nothing -> []
Just (TyCon
_,[Xi]
ts) -> [Xi]
ts
(Xi
t,[Xi]
ts) -> Xi
t Xi -> [Xi] -> [Xi]
forall a. a -> [a] -> [a]
: [Xi]
ts
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)
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)
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
isPendingScDictCt :: DictCt -> Bool
isPendingScDictCt (DictCt { di_pend_sc :: DictCt -> ExpansionFuel
di_pend_sc = ExpansionFuel
f }) = ExpansionFuel -> Bool
pendingFuel ExpansionFuel
f
pendingScDict_maybe :: Ct -> Maybe Ct
pendingScDict_maybe :: Ct -> Maybe Ct
pendingScDict_maybe (CDictCan dict :: DictCt
dict@(DictCt { di_pend_sc :: DictCt -> ExpansionFuel
di_pend_sc = ExpansionFuel
f }))
| ExpansionFuel -> Bool
pendingFuel ExpansionFuel
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
pendingScInst_maybe :: QCInst -> Maybe QCInst
pendingScInst_maybe qci :: QCInst
qci@(QCI { qci_pend_sc :: QCInst -> ExpansionFuel
qci_pend_sc = ExpansionFuel
f })
| ExpansionFuel -> Bool
pendingFuel ExpansionFuel
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
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)
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)
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
data WantedConstraints
= WC { WantedConstraints -> Cts
wc_simple :: Cts
, 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
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 }
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 }
addMultiplicityCoercionError :: WantedConstraints -> TcCoercion -> CtLoc -> WantedConstraints
addMultiplicityCoercionError :: WantedConstraints -> TcCoercion -> CtLoc -> WantedConstraints
addMultiplicityCoercionError WantedConstraints
wc TcCoercion
mult_co CtLoc
loc
= WantedConstraints
wc { wc_errors = unitBag (DE_Multiplicity mult_co loc) `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
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
keep_delayed_error (DE_Multiplicity {}) = 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)
nonDefaultableTyVarsOfWC :: WantedConstraints -> TyCoVarSet
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
non_defaultable_tvs_of_ct :: Ct -> TyCoVarSet
non_defaultable_tvs_of_ct :: Ct -> TcTyCoVarSet
non_defaultable_tvs_of_ct Ct
ct =
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
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
non_defaultable_tvs_of_err (DE_Multiplicity {}) = 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
is_insoluble (DE_NotConcrete {}) = Bool
True
is_insoluble (DE_Multiplicity {}) = Bool
False
insolubleWantedCt :: Ct -> Bool
insolubleWantedCt :: Ct -> Bool
insolubleWantedCt Ct
ct
| CIrredCan IrredCt
ir_ct <- Ct
ct
, IrredCt { ir_ev :: IrredCt -> CtEvidence
ir_ev = CtEvidence
ev } <- IrredCt
ir_ct
, CtWanted { ctev_loc :: CtEvidence -> CtLoc
ctev_loc = CtLoc
loc, ctev_rewriters :: CtEvidence -> RewriterSet
ctev_rewriters = RewriterSet
rewriters } <- CtEvidence
ev
, IrredCt -> Bool
insolubleIrredCt IrredCt
ir_ct
, RewriterSet -> Bool
isEmptyRewriterSet RewriterSet
rewriters
, Bool -> Bool
not (CtLoc -> Bool
isGivenLoc CtLoc
loc)
, Bool -> Bool
not (CtOrigin -> Bool
isWantedWantedFunDepOrigin (CtLoc -> CtOrigin
ctLocOrigin CtLoc
loc))
= Bool
True
| Bool
otherwise
= Bool
False
insolubleCt :: Ct -> Bool
insolubleCt :: Ct -> Bool
insolubleCt (CIrredCan IrredCt
ir_ct) = IrredCt -> Bool
insolubleIrredCt IrredCt
ir_ct
insolubleCt Ct
_ = Bool
False
insolubleIrredCt :: IrredCt -> Bool
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)
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 -> ExpansionFuel -> SDoc -> SDoc
hang (SDoc
doc SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
forall doc. IsLine doc => doc
equals)
ExpansionFuel
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)
data Implication
= Implic {
Implication -> TcLevel
ic_tclvl :: TcLevel,
Implication -> SkolemInfoAnon
ic_info :: SkolemInfoAnon,
Implication -> [EvVar]
ic_skols :: [TcTyVar],
Implication -> [EvVar]
ic_given :: [EvVar],
Implication -> HasGivenEqs
ic_given_eqs :: HasGivenEqs,
Implication -> Bool
ic_warn_inaccessible :: Bool,
Implication -> CtLocEnv
ic_env :: !CtLocEnv,
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 :: CtLocEnv -> Implication
implicationPrototype :: CtLocEnv -> Implication
implicationPrototype CtLocEnv
ct_loc_env
= Implic {
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
, 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
{ ImplicStatus -> [EvVar]
ics_dead :: [EvVar] }
| IC_Insoluble
| IC_BadTelescope
| IC_Unsolved
data HasGivenEqs
= NoGivenEqs
| LocalGivenEqs
| MaybeGivenEqs
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)
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 -> ExpansionFuel -> 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)
ExpansionFuel
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 -> ExpansionFuel -> SDoc -> SDoc
hang (String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"Given =") ExpansionFuel
2 ([EvVar] -> SDoc
pprEvVars [EvVar]
given)
, SDoc -> ExpansionFuel -> SDoc -> SDoc
hang (String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"Wanted =") ExpansionFuel
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
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"
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
instance Monoid HasGivenEqs where
mempty :: HasGivenEqs
mempty = HasGivenEqs
NoGivenEqs
type ApproxWC = ( Bag Ct
, Bag Ct )
approximateWC :: Bool -> WantedConstraints -> Bag Ct
approximateWC :: Bool -> WantedConstraints -> Cts
approximateWC Bool
include_non_quantifiable WantedConstraints
cts
| Bool
include_non_quantifiable = Cts
quant Cts -> Cts -> Cts
forall a. Bag a -> Bag a -> Bag a
`unionBags` Cts
no_quant
| Bool
otherwise = Cts
quant
where
(Cts
quant, Cts
no_quant) = WantedConstraints -> (Cts, Cts)
approximateWCX WantedConstraints
cts
approximateWCX :: WantedConstraints -> ApproxWC
approximateWCX :: WantedConstraints -> (Cts, Cts)
approximateWCX WantedConstraints
wc
= Bool
-> TcTyCoVarSet -> WantedConstraints -> (Cts, Cts) -> (Cts, Cts)
float_wc Bool
False TcTyCoVarSet
emptyVarSet WantedConstraints
wc (Cts
forall a. Bag a
emptyBag, Cts
forall a. Bag a
emptyBag)
where
float_wc :: Bool
-> TcTyCoVarSet
-> WantedConstraints
-> ApproxWC -> ApproxWC
float_wc :: Bool
-> TcTyCoVarSet -> WantedConstraints -> (Cts, Cts) -> (Cts, Cts)
float_wc Bool
encl_eqs TcTyCoVarSet
trapping_tvs (WC { wc_simple :: WantedConstraints -> Cts
wc_simple = Cts
simples, wc_impl :: WantedConstraints -> Bag Implication
wc_impl = Bag Implication
implics }) (Cts, Cts)
acc
= (Ct -> (Cts, Cts) -> (Cts, Cts)) -> Cts -> (Cts, Cts) -> (Cts, Cts)
forall a b. (a -> b -> b) -> Bag a -> b -> b
foldBag_flip (Bool -> TcTyCoVarSet -> Ct -> (Cts, Cts) -> (Cts, Cts)
float_ct Bool
encl_eqs TcTyCoVarSet
trapping_tvs) Cts
simples ((Cts, Cts) -> (Cts, Cts)) -> (Cts, Cts) -> (Cts, Cts)
forall a b. (a -> b) -> a -> b
$
(Implication -> (Cts, Cts) -> (Cts, Cts))
-> Bag Implication -> (Cts, Cts) -> (Cts, Cts)
forall a b. (a -> b -> b) -> Bag a -> b -> b
foldBag_flip (Bool -> TcTyCoVarSet -> Implication -> (Cts, Cts) -> (Cts, Cts)
float_implic Bool
encl_eqs TcTyCoVarSet
trapping_tvs) Bag Implication
implics ((Cts, Cts) -> (Cts, Cts)) -> (Cts, Cts) -> (Cts, Cts)
forall a b. (a -> b) -> a -> b
$
(Cts, Cts)
acc
float_implic :: Bool -> TcTyCoVarSet -> Implication
-> ApproxWC -> ApproxWC
float_implic :: Bool -> TcTyCoVarSet -> Implication -> (Cts, Cts) -> (Cts, Cts)
float_implic Bool
encl_eqs TcTyCoVarSet
trapping_tvs Implication
imp
= Bool
-> TcTyCoVarSet -> WantedConstraints -> (Cts, Cts) -> (Cts, Cts)
float_wc Bool
new_encl_eqs TcTyCoVarSet
new_trapping_tvs (Implication -> WantedConstraints
ic_wanted Implication
imp)
where
new_trapping_tvs :: TcTyCoVarSet
new_trapping_tvs = TcTyCoVarSet
trapping_tvs TcTyCoVarSet -> [EvVar] -> TcTyCoVarSet
`extendVarSetList` Implication -> [EvVar]
ic_skols Implication
imp
new_encl_eqs :: Bool
new_encl_eqs = Bool
encl_eqs Bool -> Bool -> Bool
|| Implication -> HasGivenEqs
ic_given_eqs Implication
imp HasGivenEqs -> HasGivenEqs -> Bool
forall a. Eq a => a -> a -> Bool
== HasGivenEqs
MaybeGivenEqs
float_ct :: Bool -> TcTyCoVarSet -> Ct
-> ApproxWC -> ApproxWC
float_ct :: Bool -> TcTyCoVarSet -> Ct -> (Cts, Cts) -> (Cts, Cts)
float_ct Bool
encl_eqs TcTyCoVarSet
skol_tvs Ct
ct acc :: (Cts, Cts)
acc@(Cts
quant, Cts
no_quant)
| Ct -> Bool
isGivenCt Ct
ct = (Cts, Cts)
acc
| Ct -> Bool
insolubleCt Ct
ct = (Cts, Cts)
acc
| Ct -> TcTyCoVarSet
tyCoVarsOfCt Ct
ct TcTyCoVarSet -> TcTyCoVarSet -> Bool
`intersectsVarSet` TcTyCoVarSet
skol_tvs = (Cts, Cts)
acc
| Bool
otherwise
= case Xi -> Pred
classifyPredType (Ct -> Xi
ctPred Ct
ct) of
EqPred EqRel
eq_rel Xi
ty1 Xi
ty2
| Bool -> Bool
not Bool
encl_eqs
, EqRel -> Xi -> Xi -> Bool
quantify_equality EqRel
eq_rel Xi
ty1 Xi
ty2
-> (Cts, Cts)
add_to_quant
| Bool
otherwise
-> (Cts, Cts)
add_to_no_quant
ClassPred Class
cls [Xi]
tys
| Just {} <- Class -> [Xi] -> Maybe FastString
isCallStackPred Class
cls [Xi]
tys
-> (Cts, Cts)
add_to_no_quant
| Bool
otherwise
-> (Cts, Cts)
add_to_quant
IrredPred {} -> (Cts, Cts)
add_to_quant
ForAllPred {} -> (Cts, Cts)
add_to_no_quant
where
add_to_quant :: (Cts, Cts)
add_to_quant = (Ct
ct Ct -> Cts -> Cts
forall a. a -> Bag a -> Bag a
`consBag` Cts
quant, Cts
no_quant)
add_to_no_quant :: (Cts, Cts)
add_to_no_quant = (Cts
quant, Ct
ct Ct -> Cts -> Cts
forall a. a -> Bag a -> Bag a
`consBag` Cts
no_quant)
quantify_equality :: EqRel -> Xi -> Xi -> Bool
quantify_equality EqRel
NomEq Xi
ty1 Xi
ty2 = Xi -> Bool
quant_fun Xi
ty1 Bool -> Bool -> Bool
|| Xi -> Bool
quant_fun Xi
ty2
quantify_equality EqRel
ReprEq Xi
_ Xi
_ = Bool
True
quant_fun :: Xi -> Bool
quant_fun Xi
ty
= case HasDebugCallStack => Xi -> Maybe (TyCon, [Xi])
Xi -> Maybe (TyCon, [Xi])
tcSplitTyConApp_maybe Xi
ty of
Just (TyCon
tc, [Xi]
_) -> TyCon -> Bool
isTypeFamilyTyCon TyCon
tc
Maybe (TyCon, [Xi])
_ -> Bool
False
checkImplicationInvariants, check_implic :: (HasCallStack, Applicative m) => Implication -> m ()
{-# INLINE checkImplicationInvariants #-}
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"
, ExpansionFuel -> SDoc -> SDoc
nest ExpansionFuel
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
`sameDepthAs` 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
-> SkolemInfoAnon
-> Bool
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 FastString
n1) (RuleSkol FastString
n2) = FastString
n1FastString -> FastString -> Bool
forall a. Eq a => a -> a -> Bool
==FastString
n2
go (PatSkol ConLike
c1 HsMatchContextRn
_) (PatSkol ConLike
c2 HsMatchContextRn
_) = ConLike -> Name
forall a. NamedThing a => a -> Name
getName ConLike
c1 Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== ConLike -> Name
forall a. NamedThing a => a -> Name
getName ConLike
c2
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
go (DataConSkol Name
_) (TyConSkol TyConFlavour TyCon
f Name
_) = TyConFlavour TyCon -> Bool
forall {tc}. TyConFlavour tc -> Bool
h98_data_decl TyConFlavour TyCon
f
go (DataConSkol Name
_) SkolemInfoAnon
FamInstSkol = Bool
True
go SkolemInfoAnon
FamInstSkol (InstSkol {}) = Bool
True
go (ForAllSkol TyVarBndrs
_) SkolemInfoAnon
_ = Bool
True
go (SigTypeSkol UserTypeCtxt
DerivClauseCtxt) (TyConSkol TyConFlavour TyCon
f Name
_) = TyConFlavour TyCon -> Bool
forall {tc}. TyConFlavour tc -> Bool
h98_data_decl TyConFlavour TyCon
f
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
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
pprEvVars :: [EvVar] -> SDoc
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
data TcEvDest
= EvVarDest EvVar
| HoleDest CoercionHole
data CtEvidence
= CtGiven
{ CtEvidence -> Xi
ctev_pred :: TcPredType
, CtEvidence -> EvVar
ctev_evar :: EvVar
, CtEvidence -> CtLoc
ctev_loc :: CtLoc }
| CtWanted
{ ctev_pred :: TcPredType
, CtEvidence -> TcEvDest
ctev_dest :: TcEvDest
, ctev_loc :: CtLoc
, CtEvidence -> RewriterSet
ctev_rewriters :: RewriterSet }
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 :: HasDebugCallStack => CtEvidence -> EqRel
ctEvEqRel :: HasDebugCallStack => 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
ctEvRewriteRole :: HasDebugCallStack => CtEvidence -> Role
ctEvRewriteRole :: HasDebugCallStack => CtEvidence -> Role
ctEvRewriteRole = EqRel -> Role
eqRelRole (EqRel -> Role) -> (CtEvidence -> EqRel) -> CtEvidence -> Role
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CtEvidence -> EqRel
ctEvRewriteEqRel
ctEvRewriteEqRel :: CtEvidence -> EqRel
ctEvRewriteEqRel :: CtEvidence -> EqRel
ctEvRewriteEqRel = Xi -> EqRel
predTypeEqRel (Xi -> EqRel) -> (CtEvidence -> Xi) -> CtEvidence -> EqRel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CtEvidence -> Xi
ctEvPred
ctEvTerm :: CtEvidence -> EvTerm
ctEvTerm :: CtEvidence -> EvTerm
ctEvTerm CtEvidence
ev = EvExpr -> EvTerm
EvExpr (HasDebugCallStack => CtEvidence -> EvExpr
CtEvidence -> EvExpr
ctEvExpr CtEvidence
ev)
ctEvRewriters :: CtEvidence -> RewriterSet
ctEvRewriters :: CtEvidence -> RewriterSet
ctEvRewriters (CtWanted { ctev_rewriters :: CtEvidence -> RewriterSet
ctev_rewriters = RewriterSet
rewriters }) = RewriterSet
rewriters
ctEvRewriters (CtGiven {}) = RewriterSet
emptyRewriterSet
ctEvExpr :: HasDebugCallStack => CtEvidence -> EvExpr
ctEvExpr :: HasDebugCallStack => CtEvidence -> EvExpr
ctEvExpr ev :: CtEvidence
ev@(CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = HoleDest CoercionHole
_ })
= TcCoercion -> EvExpr
forall b. TcCoercion -> Expr b
Coercion (TcCoercion -> EvExpr) -> TcCoercion -> EvExpr
forall a b. (a -> b) -> a -> b
$ HasDebugCallStack => CtEvidence -> TcCoercion
CtEvidence -> TcCoercion
ctEvCoercion CtEvidence
ev
ctEvExpr CtEvidence
ev = EvVar -> EvExpr
evId (CtEvidence -> EvVar
ctEvEvId CtEvidence
ev)
ctEvCoercion :: HasDebugCallStack => CtEvidence -> TcCoercion
ctEvCoercion :: HasDebugCallStack => CtEvidence -> TcCoercion
ctEvCoercion _given :: CtEvidence
_given@(CtGiven { ctev_evar :: CtEvidence -> EvVar
ctev_evar = EvVar
ev_id })
= Bool -> SDoc -> TcCoercion -> TcCoercion
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (EvVar -> Bool
isCoVar EvVar
ev_id)
(String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"ctEvCoercion used on non-equality Given constraint:" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> CtEvidence -> SDoc
forall a. Outputable a => a -> SDoc
ppr CtEvidence
_given)
(TcCoercion -> TcCoercion) -> TcCoercion -> TcCoercion
forall a b. (a -> b) -> a -> b
$ EvVar -> TcCoercion
mkCoVarCo EvVar
ev_id
ctEvCoercion (CtWanted { ctev_dest :: CtEvidence -> TcEvDest
ctev_dest = TcEvDest
dest })
| HoleDest CoercionHole
hole <- TcEvDest
dest
=
CoercionHole -> TcCoercion
mkHoleCo CoercionHole
hole
ctEvCoercion CtEvidence
ev
= String -> SDoc -> TcCoercion
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 }
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)
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
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
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
data CtFlavour
= Given
| Wanted
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
type CtFlavourRole = (CtFlavour, EqRel)
ctEvFlavourRole :: HasDebugCallStack => CtEvidence -> CtFlavourRole
ctEvFlavourRole :: HasDebugCallStack => CtEvidence -> CtFlavourRole
ctEvFlavourRole CtEvidence
ev = (CtEvidence -> CtFlavour
ctEvFlavour CtEvidence
ev, CtEvidence -> EqRel
ctEvRewriteEqRel CtEvidence
ev)
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)
ctFlavourRole :: HasDebugCallStack => Ct -> CtFlavourRole
ctFlavourRole :: HasDebugCallStack => 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 = HasDebugCallStack => CtEvidence -> CtFlavourRole
CtEvidence -> CtFlavourRole
ctEvFlavourRole (Ct -> CtEvidence
ctEvidence Ct
ct)
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
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