{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# OPTIONS_GHC -Wno-incomplete-record-updates #-} -- | This module defines types and simple operations over constraints, as used -- in the type-checker and constraint solver. module GHC.Tc.Types.Constraint ( -- QCInst QCInst(..), isPendingScInst, -- Canonical constraints Xi, Ct(..), Cts, emptyCts, andCts, andManyCts, pprCts, singleCt, listToCts, ctsElts, consCts, snocCts, extendCtsList, isEmptyCts, isPendingScDict, superClassesMightHelp, getPendingWantedScs, isWantedCt, isDerivedCt, isGivenCt, isUserTypeErrorCt, getUserTypeErrorMsg, ctEvidence, ctLoc, setCtLoc, ctPred, ctFlavour, ctEqRel, ctOrigin, ctEvId, mkTcEqPredLikeEv, mkNonCanonical, mkNonCanonicalCt, mkGivens, mkIrredCt, ctEvPred, ctEvLoc, ctEvOrigin, ctEvEqRel, ctEvExpr, ctEvTerm, ctEvCoercion, ctEvEvId, tyCoVarsOfCt, tyCoVarsOfCts, tyCoVarsOfCtList, tyCoVarsOfCtsList, CtIrredReason(..), HoleSet, isInsolubleReason, CheckTyEqResult, CheckTyEqProblem, cteProblem, cterClearOccursCheck, cteOK, cteImpredicative, cteTypeFamily, cteHoleBlocker, cteInsolubleOccurs, cteSolubleOccurs, cterSetOccursCheckSoluble, cterHasNoProblem, cterHasProblem, cterHasOnlyProblem, cterRemoveProblem, cterHasOccursCheck, cterFromKind, CanEqLHS(..), canEqLHS_maybe, canEqLHSKind, canEqLHSType, eqCanEqLHS, Hole(..), HoleSort(..), isOutOfScopeHole, WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC, isSolvedWC, andWC, unionsWC, mkSimpleWC, mkImplicWC, addInsols, dropMisleading, addSimples, addImplics, addHoles, tyCoVarsOfWC, dropDerivedWC, dropDerivedSimples, tyCoVarsOfWCList, insolubleCt, insolubleEqCt, isDroppableCt, insolubleImplic, arisesFromGivens, Implication(..), implicationPrototype, checkTelescopeSkol, ImplicStatus(..), isInsolubleStatus, isSolvedStatus, HasGivenEqs(..), SubGoalDepth, initialSubGoalDepth, maxSubGoalDepth, bumpSubGoalDepth, subGoalDepthExceeded, CtLoc(..), ctLocSpan, ctLocEnv, ctLocLevel, ctLocOrigin, ctLocTypeOrKind_maybe, ctLocDepth, bumpCtLocDepth, isGivenLoc, setCtLocOrigin, updateCtLocOrigin, setCtLocEnv, setCtLocSpan, pprCtLoc, -- CtEvidence CtEvidence(..), TcEvDest(..), mkKindLoc, toKindLoc, mkGivenLoc, isWanted, isGiven, isDerived, ctEvRole, wrapType, CtFlavour(..), ShadowInfo(..), ctFlavourContainsDerived, ctEvFlavour, CtFlavourRole, ctEvFlavourRole, ctFlavourRole, eqCanRewrite, eqCanRewriteFR, eqMayRewriteFR, eqCanDischargeFR, -- Pretty printing pprEvVarTheta, pprEvVars, pprEvVarWithType, ) where #include "HsVersions.h" import GHC.Prelude import {-# SOURCE #-} GHC.Tc.Types ( TcLclEnv, setLclEnvTcLevel, getLclEnvTcLevel , setLclEnvLoc, getLclEnvLoc ) import GHC.Core.Predicate import GHC.Core.Type import GHC.Core.Coercion import GHC.Core.Class import GHC.Core.TyCon import GHC.Types.Var import GHC.Tc.Utils.TcType import GHC.Tc.Types.Evidence import GHC.Tc.Types.Origin import GHC.Core import GHC.Core.TyCo.Ppr import GHC.Types.Name.Occurrence import GHC.Utils.FV import GHC.Types.Var.Set import GHC.Driver.Session import GHC.Types.Basic import GHC.Utils.Outputable import GHC.Types.SrcLoc import GHC.Data.Bag import GHC.Utils.Misc import GHC.Utils.Panic import Control.Monad ( msum ) import qualified Data.Semigroup ( (<>) ) -- these are for CheckTyEqResult import Data.Word ( Word8 ) import Data.List ( intersperse ) {- ************************************************************************ * * * Canonical constraints * * * * These are the constraints the low-level simplifier works with * * * ************************************************************************ Note [CEqCan occurs check] ~~~~~~~~~~~~~~~~~~~~~~~~~~ A CEqCan relates a CanEqLHS (a type variable or type family applications) on its left to an arbitrary type on its right. It is used for rewriting. Because it is used for rewriting, it would be disastrous if the RHS were to mention the LHS: this would cause a loop in rewriting. We thus perform an occurs-check. There is, of course, some subtlety: * For type variables, the occurs-check looks deeply. This is because a CEqCan over a meta-variable is also used to inform unification, in GHC.Tc.Solver.Interact.solveByUnification. If the LHS appears anywhere, at all, in the RHS, unification will create an infinite structure, which is bad. * For type family applications, the occurs-check is shallow; it looks only in places where we might rewrite. (Specifically, it does not look in kinds or coercions.) An occurrence of the LHS in, say, an RHS coercion is OK, as we do not rewrite in coercions. No loop to be found. You might also worry about the possibility that a type family application LHS doesn't exactly appear in the RHS, but something that reduces to the LHS does. Yet that can't happen: the RHS is already inert, with all type family redexes reduced. So a simple syntactic check is just fine. The occurs check is performed in GHC.Tc.Utils.Unify.checkTypeEq and forms condition T3 in Note [Extending the inert equalities] in GHC.Tc.Solver.Monad. -} -- | A 'Xi'-type is one that has been fully rewritten with respect -- to the inert set; that is, it has been rewritten by the algorithm -- in GHC.Tc.Solver.Rewrite. (Historical note: 'Xi', for years and years, -- meant that a type was type-family-free. It does *not* mean this -- any more.) type Xi = TcType type Cts = Bag Ct data Ct -- Atomic canonical constraints = CDictCan { -- e.g. Num ty Ct -> CtEvidence cc_ev :: CtEvidence, -- See Note [Ct/evidence invariant] Ct -> Class cc_class :: Class, Ct -> [Xi] cc_tyargs :: [Xi], -- cc_tyargs are rewritten w.r.t. inerts, so Xi Ct -> Bool cc_pend_sc :: Bool -- See Note [The superclass story] in GHC.Tc.Solver.Canonical -- True <=> (a) cc_class has superclasses -- (b) we have not (yet) added those -- superclasses as Givens } | CIrredCan { -- These stand for yet-unusable predicates cc_ev :: CtEvidence, -- See Note [Ct/evidence invariant] Ct -> CtIrredReason cc_reason :: CtIrredReason -- For the might-be-soluble case, the ctev_pred of the evidence is -- of form (tv xi1 xi2 ... xin) with a tyvar at the head -- or (lhs1 ~ ty2) where the CEqCan kind invariant (TyEq:K) fails -- See Note [CIrredCan constraints] -- The definitely-insoluble case is for things like -- Int ~ Bool tycons don't match -- a ~ [a] occurs check } | CEqCan { -- CanEqLHS ~ rhs -- Invariants: -- * See Note [inert_eqs: the inert equalities] in GHC.Tc.Solver.Monad -- * Many are checked in checkTypeEq in GHC.Tc.Utils.Unify -- * (TyEq:OC) lhs does not occur in rhs (occurs check) -- Note [CEqCan occurs check] -- * (TyEq:F) rhs has no foralls -- (this avoids substituting a forall for the tyvar in other types) -- * (TyEq:K) tcTypeKind lhs `tcEqKind` tcTypeKind rhs; Note [Ct kind invariant] -- * (TyEq:N) If the equality is representational, rhs has no top-level newtype -- See Note [No top-level newtypes on RHS of representational equalities] -- in GHC.Tc.Solver.Canonical. (Applies only when constructor of newtype is -- in scope.) -- * (TyEq:TV) If rhs (perhaps under a cast) is also CanEqLHS, then it is oriented -- to give best chance of -- unification happening; eg if rhs is touchable then lhs is too -- Note [TyVar/TyVar orientation] in GHC.Tc.Utils.Unify -- * (TyEq:H) The RHS has no blocking coercion holes. See GHC.Tc.Solver.Canonical -- Note [Equalities with incompatible kinds], wrinkle (2) cc_ev :: CtEvidence, -- See Note [Ct/evidence invariant] Ct -> CanEqLHS cc_lhs :: CanEqLHS, Ct -> Xi cc_rhs :: Xi, -- See invariants above Ct -> EqRel cc_eq_rel :: EqRel -- INVARIANT: cc_eq_rel = ctEvEqRel cc_ev } | CNonCanonical { -- See Note [NonCanonical Semantics] in GHC.Tc.Solver.Monad cc_ev :: CtEvidence } | CQuantCan QCInst -- A quantified constraint -- NB: I expect to make more of the cases in Ct -- look like this, with the payload in an -- auxiliary type ------------ -- | A 'CanEqLHS' is a type that can appear on the left of a canonical -- equality: a type variable or exactly-saturated type family application. data CanEqLHS = TyVarLHS TcTyVar | TyFamLHS TyCon -- ^ of the family [Xi] -- ^ exactly saturating the family instance Outputable CanEqLHS where ppr :: CanEqLHS -> SDoc ppr (TyVarLHS EvVar tv) = forall a. Outputable a => a -> SDoc ppr EvVar tv ppr (TyFamLHS TyCon fam_tc [Xi] fam_args) = forall a. Outputable a => a -> SDoc ppr (TyCon -> [Xi] -> Xi mkTyConApp TyCon fam_tc [Xi] fam_args) ------------ data QCInst -- A much simplified version of ClsInst -- See Note [Quantified constraints] in GHC.Tc.Solver.Canonical = QCI { QCInst -> CtEvidence qci_ev :: CtEvidence -- Always of type forall tvs. context => ty -- Always Given , QCInst -> [EvVar] qci_tvs :: [TcTyVar] -- The tvs , QCInst -> Xi qci_pred :: TcPredType -- The ty , QCInst -> Bool qci_pend_sc :: Bool -- Same as cc_pend_sc flag in CDictCan -- Invariant: True => qci_pred is a ClassPred } instance Outputable QCInst where ppr :: QCInst -> SDoc ppr (QCI { qci_ev :: QCInst -> CtEvidence qci_ev = CtEvidence ev }) = forall a. Outputable a => a -> SDoc ppr CtEvidence ev ------------ -- | A hole stores the information needed to report diagnostics -- about holes in terms (unbound identifiers or underscores) or -- in types (also called wildcards, as used in partial type -- signatures). See Note [Holes]. data Hole = Hole { Hole -> HoleSort hole_sort :: HoleSort -- ^ What flavour of hole is this? , Hole -> OccName hole_occ :: OccName -- ^ The name of this hole , Hole -> Xi hole_ty :: TcType -- ^ Type to be printed to the user -- For expression holes: type of expr -- For type holes: the missing type , Hole -> CtLoc hole_loc :: CtLoc -- ^ Where hole was written } -- For the hole_loc, we usually only want the TcLclEnv stored within. -- Except when we rewrite, where we need a whole location. And this -- might get reported to the user if reducing type families in a -- hole type loops. -- | Used to indicate which sort of hole we have. data HoleSort = ExprHole HoleExprRef -- ^ Either an out-of-scope variable or a "true" hole in an -- expression (TypedHoles). -- The HoleExprRef says where to write the -- the erroring expression for -fdefer-type-errors. | TypeHole -- ^ A hole in a type (PartialTypeSignatures) | ConstraintHole -- ^ A hole in a constraint, like @f :: (_, Eq a) => ... -- Differentiated from TypeHole because a ConstraintHole -- is simplified differently. See -- Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver. instance Outputable Hole where ppr :: Hole -> SDoc ppr (Hole { hole_sort :: Hole -> HoleSort hole_sort = ExprHole HoleExprRef ref , hole_occ :: Hole -> OccName hole_occ = OccName occ , hole_ty :: Hole -> Xi hole_ty = Xi ty }) = SDoc -> SDoc parens forall a b. (a -> b) -> a -> b $ (SDoc -> SDoc braces forall a b. (a -> b) -> a -> b $ forall a. Outputable a => a -> SDoc ppr OccName occ SDoc -> SDoc -> SDoc <> SDoc colon SDoc -> SDoc -> SDoc <> forall a. Outputable a => a -> SDoc ppr HoleExprRef ref) SDoc -> SDoc -> SDoc <+> SDoc dcolon SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr Xi ty ppr (Hole { hole_sort :: Hole -> HoleSort hole_sort = HoleSort _other , hole_occ :: Hole -> OccName hole_occ = OccName occ , hole_ty :: Hole -> Xi hole_ty = Xi ty }) = SDoc -> SDoc braces forall a b. (a -> b) -> a -> b $ forall a. Outputable a => a -> SDoc ppr OccName occ SDoc -> SDoc -> SDoc <> SDoc colon SDoc -> SDoc -> SDoc <> forall a. Outputable a => a -> SDoc ppr Xi ty instance Outputable HoleSort where ppr :: HoleSort -> SDoc ppr (ExprHole HoleExprRef ref) = String -> SDoc text String "ExprHole:" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr HoleExprRef ref ppr HoleSort TypeHole = String -> SDoc text String "TypeHole" ppr HoleSort ConstraintHole = String -> SDoc text String "ConstraintHole" ------------ -- | Used to indicate extra information about why a CIrredCan is irreducible data CtIrredReason = IrredShapeReason -- ^ this constraint has a non-canonical shape (e.g. @c Int@, for a variable @c@) | HoleBlockerReason HoleSet -- ^ this constraint is blocked on the coercion hole(s) listed -- See Note [Equalities with incompatible kinds] in GHC.Tc.Solver.Canonical -- Wrinkle (4a). Why store the HoleSet? See Wrinkle (2) of that -- same Note. -- INVARIANT: A HoleBlockerReason constraint is a homogeneous equality whose -- left hand side can fit in a CanEqLHS. | NonCanonicalReason CheckTyEqResult -- ^ an equality where some invariant other than (TyEq:H) of 'CEqCan' is not satisfied; -- the 'CheckTyEqResult' states exactly why -- INVARIANT: the 'CheckTyEqResult' has some bit set other than cteHoleBlocker | ReprEqReason -- ^ an equality that cannot be decomposed because it is representational. -- Example: @a b ~R# Int@. -- These might still be solved later. -- INVARIANT: The constraint is a representational equality constraint | ShapeMismatchReason -- ^ a nominal equality that relates two wholly different types, -- like @Int ~# Bool@ or @a b ~# 3@. -- INVARIANT: The constraint is a nominal equality constraint | AbstractTyConReason -- ^ an equality like @T a b c ~ Q d e@ where either @T@ or @Q@ -- is an abstract type constructor. See Note [Skolem abstract data] -- in GHC.Core.TyCon. -- INVARIANT: The constraint is an equality constraint between two TyConApps instance Outputable CtIrredReason where ppr :: CtIrredReason -> SDoc ppr CtIrredReason IrredShapeReason = String -> SDoc text String "(irred)" ppr (HoleBlockerReason HoleSet holes) = SDoc -> SDoc parens (String -> SDoc text String "blocked on" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr HoleSet holes) ppr (NonCanonicalReason CheckTyEqResult cter) = forall a. Outputable a => a -> SDoc ppr CheckTyEqResult cter ppr CtIrredReason ReprEqReason = String -> SDoc text String "(repr)" ppr CtIrredReason ShapeMismatchReason = String -> SDoc text String "(shape)" ppr CtIrredReason AbstractTyConReason = String -> SDoc text String "(abstc)" -- | Are we sure that more solving will never solve this constraint? isInsolubleReason :: CtIrredReason -> Bool isInsolubleReason :: CtIrredReason -> Bool isInsolubleReason CtIrredReason IrredShapeReason = Bool False isInsolubleReason (HoleBlockerReason {}) = Bool False isInsolubleReason (NonCanonicalReason CheckTyEqResult cter) = CheckTyEqResult -> Bool cterIsInsoluble CheckTyEqResult cter isInsolubleReason CtIrredReason ReprEqReason = Bool False isInsolubleReason CtIrredReason ShapeMismatchReason = Bool True isInsolubleReason CtIrredReason AbstractTyConReason = Bool True ------------------------------------------------------------------------------ -- -- CheckTyEqResult, defined here because it is stored in a CtIrredReason -- ------------------------------------------------------------------------------ -- | A set of problems in checking the validity of a type equality. -- See 'checkTypeEq'. newtype CheckTyEqResult = CTER Word8 -- | No problems in checking the validity of a type equality. cteOK :: CheckTyEqResult cteOK :: CheckTyEqResult cteOK = Word8 -> CheckTyEqResult CTER forall a. Bits a => a zeroBits -- | Check whether a 'CheckTyEqResult' is marked successful. cterHasNoProblem :: CheckTyEqResult -> Bool cterHasNoProblem :: CheckTyEqResult -> Bool cterHasNoProblem (CTER Word8 0) = Bool True cterHasNoProblem CheckTyEqResult _ = Bool False -- | An individual problem that might be logged in a 'CheckTyEqResult' newtype CheckTyEqProblem = CTEP Word8 cteImpredicative, cteTypeFamily, cteHoleBlocker, cteInsolubleOccurs, cteSolubleOccurs :: CheckTyEqProblem cteImpredicative :: CheckTyEqProblem cteImpredicative = Word8 -> CheckTyEqProblem CTEP (forall a. Bits a => Int -> a bit Int 0) -- forall or (=>) encountered cteTypeFamily :: CheckTyEqProblem cteTypeFamily = Word8 -> CheckTyEqProblem CTEP (forall a. Bits a => Int -> a bit Int 1) -- type family encountered cteHoleBlocker :: CheckTyEqProblem cteHoleBlocker = Word8 -> CheckTyEqProblem CTEP (forall a. Bits a => Int -> a bit Int 2) -- blocking coercion hole -- See Note [Equalities with incompatible kinds] in GHC.Tc.Solver.Canonical cteInsolubleOccurs :: CheckTyEqProblem cteInsolubleOccurs = Word8 -> CheckTyEqProblem CTEP (forall a. Bits a => Int -> a bit Int 3) -- occurs-check cteSolubleOccurs :: CheckTyEqProblem cteSolubleOccurs = Word8 -> CheckTyEqProblem CTEP (forall a. Bits a => Int -> a bit Int 4) -- occurs-check under a type function or in a coercion -- must be one bit to the left of cteInsolubleOccurs -- See also Note [Insoluble occurs check] in GHC.Tc.Errors cteProblem :: CheckTyEqProblem -> CheckTyEqResult cteProblem :: CheckTyEqProblem -> CheckTyEqResult cteProblem (CTEP Word8 mask) = Word8 -> CheckTyEqResult CTER Word8 mask occurs_mask :: Word8 occurs_mask :: Word8 occurs_mask = Word8 insoluble_mask forall a. Bits a => a -> a -> a .|. Word8 soluble_mask where CTEP Word8 insoluble_mask = CheckTyEqProblem cteInsolubleOccurs CTEP Word8 soluble_mask = CheckTyEqProblem cteSolubleOccurs -- | Check whether a 'CheckTyEqResult' has a 'CheckTyEqProblem' cterHasProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool CTER Word8 bits cterHasProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool `cterHasProblem` CTEP Word8 mask = (Word8 bits forall a. Bits a => a -> a -> a .&. Word8 mask) forall a. Eq a => a -> a -> Bool /= Word8 0 -- | Check whether a 'CheckTyEqResult' has one 'CheckTyEqProblem' and no other cterHasOnlyProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool CTER Word8 bits cterHasOnlyProblem :: CheckTyEqResult -> CheckTyEqProblem -> Bool `cterHasOnlyProblem` CTEP Word8 mask = Word8 bits forall a. Eq a => a -> a -> Bool == Word8 mask cterRemoveProblem :: CheckTyEqResult -> CheckTyEqProblem -> CheckTyEqResult cterRemoveProblem :: CheckTyEqResult -> CheckTyEqProblem -> CheckTyEqResult cterRemoveProblem (CTER Word8 bits) (CTEP Word8 mask) = Word8 -> CheckTyEqResult CTER (Word8 bits forall a. Bits a => a -> a -> a .&. forall a. Bits a => a -> a complement Word8 mask) cterHasOccursCheck :: CheckTyEqResult -> Bool cterHasOccursCheck :: CheckTyEqResult -> Bool cterHasOccursCheck (CTER Word8 bits) = (Word8 bits forall a. Bits a => a -> a -> a .&. Word8 occurs_mask) forall a. Eq a => a -> a -> Bool /= Word8 0 cterClearOccursCheck :: CheckTyEqResult -> CheckTyEqResult cterClearOccursCheck :: CheckTyEqResult -> CheckTyEqResult cterClearOccursCheck (CTER Word8 bits) = Word8 -> CheckTyEqResult CTER (Word8 bits forall a. Bits a => a -> a -> a .&. forall a. Bits a => a -> a complement Word8 occurs_mask) -- | Mark a 'CheckTyEqResult' as not having an insoluble occurs-check: any occurs -- check under a type family or in a representation equality is soluble. cterSetOccursCheckSoluble :: CheckTyEqResult -> CheckTyEqResult cterSetOccursCheckSoluble :: CheckTyEqResult -> CheckTyEqResult cterSetOccursCheckSoluble (CTER Word8 bits) = Word8 -> CheckTyEqResult CTER forall a b. (a -> b) -> a -> b $ ((Word8 bits forall a. Bits a => a -> a -> a .&. Word8 insoluble_mask) forall a. Bits a => a -> Int -> a `shift` Int 1) forall a. Bits a => a -> a -> a .|. (Word8 bits forall a. Bits a => a -> a -> a .&. forall a. Bits a => a -> a complement Word8 insoluble_mask) where CTEP Word8 insoluble_mask = CheckTyEqProblem cteInsolubleOccurs -- | Retain only information about occurs-check failures, because only that -- matters after recurring into a kind. cterFromKind :: CheckTyEqResult -> CheckTyEqResult cterFromKind :: CheckTyEqResult -> CheckTyEqResult cterFromKind (CTER Word8 bits) = Word8 -> CheckTyEqResult CTER (Word8 bits forall a. Bits a => a -> a -> a .&. Word8 occurs_mask) cterIsInsoluble :: CheckTyEqResult -> Bool cterIsInsoluble :: CheckTyEqResult -> Bool cterIsInsoluble (CTER Word8 bits) = (Word8 bits forall a. Bits a => a -> a -> a .&. Word8 mask) forall a. Eq a => a -> a -> Bool /= Word8 0 where mask :: Word8 mask = Word8 impredicative_mask forall a. Bits a => a -> a -> a .|. Word8 insoluble_occurs_mask CTEP Word8 impredicative_mask = CheckTyEqProblem cteImpredicative CTEP Word8 insoluble_occurs_mask = CheckTyEqProblem cteInsolubleOccurs instance Semigroup CheckTyEqResult where CTER Word8 bits1 <> :: CheckTyEqResult -> CheckTyEqResult -> CheckTyEqResult <> CTER Word8 bits2 = Word8 -> CheckTyEqResult CTER (Word8 bits1 forall a. Bits a => a -> a -> a .|. Word8 bits2) instance Monoid CheckTyEqResult where mempty :: CheckTyEqResult mempty = CheckTyEqResult cteOK instance Outputable CheckTyEqResult where ppr :: CheckTyEqResult -> SDoc ppr CheckTyEqResult cter | CheckTyEqResult -> Bool cterHasNoProblem CheckTyEqResult cter = String -> SDoc text String "cteOK" | Bool otherwise = SDoc -> SDoc parens forall a b. (a -> b) -> a -> b $ [SDoc] -> SDoc fcat forall a b. (a -> b) -> a -> b $ forall a. a -> [a] -> [a] intersperse SDoc vbar forall a b. (a -> b) -> a -> b $ [SDoc] set_bits where all_bits :: [(CheckTyEqProblem, String)] all_bits = [ (CheckTyEqProblem cteImpredicative, String "cteImpredicative") , (CheckTyEqProblem cteTypeFamily, String "cteTypeFamily") , (CheckTyEqProblem cteHoleBlocker, String "cteHoleBlocker") , (CheckTyEqProblem cteInsolubleOccurs, String "cteInsolubleOccurs") , (CheckTyEqProblem cteSolubleOccurs, String "cteSolubleOccurs") ] set_bits :: [SDoc] set_bits = [ String -> SDoc text String str | (CheckTyEqProblem bitmask, String str) <- [(CheckTyEqProblem, String)] all_bits , CheckTyEqResult cter CheckTyEqResult -> CheckTyEqProblem -> Bool `cterHasProblem` CheckTyEqProblem bitmask ] {- Note [CIrredCan constraints] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CIrredCan constraints are used for constraints that are "stuck" - we can't solve them (yet) - we can't use them to solve other constraints - but they may become soluble if we substitute for some of the type variables in the constraint Example 1: (c Int), where c :: * -> Constraint. We can't do anything with this yet, but if later c := Num, *then* we can solve it Example 2: a ~ b, where a :: *, b :: k, where k is a kind variable We don't want to use this to substitute 'b' for 'a', in case 'k' is subsequently unified with (say) *->*, because then we'd have ill-kinded types floating about. Rather we want to defer using the equality altogether until 'k' get resolved. Note [Ct/evidence invariant] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ If ct :: Ct, then extra fields of 'ct' cache precisely the ctev_pred field of (cc_ev ct), and is fully rewritten wrt the substitution. Eg for CDictCan, ctev_pred (cc_ev ct) = (cc_class ct) (cc_tyargs ct) This holds by construction; look at the unique place where CDictCan is built (in GHC.Tc.Solver.Canonical). In contrast, the type of the evidence *term* (ctev_dest / ctev_evar) in the evidence may *not* be fully zonked; we are careful not to look at it during constraint solving. See Note [Evidence field of CtEvidence]. Note [Ct kind invariant] ~~~~~~~~~~~~~~~~~~~~~~~~ CEqCan requires that the kind of the lhs matches the kind of the rhs. This is necessary because these constraints are used for substitutions during solving. If the kinds differed, then the substitution would take a well-kinded type to an ill-kinded one. Note [Holes] ~~~~~~~~~~~~ This Note explains how GHC tracks *holes*. A hole represents one of two conditions: - A missing bit of an expression. Example: foo x = x + _ - A missing bit of a type. Example: bar :: Int -> _ What these have in common is that both cause GHC to emit a diagnostic to the user describing the bit that is left out. When a hole is encountered, a new entry of type Hole is added to the ambient WantedConstraints. The type (hole_ty) of the hole is then simplified during solving (with respect to any Givens in surrounding implications). It is reported with all the other errors in GHC.Tc.Errors. For expression holes, the user has the option of deferring errors until runtime with -fdefer-type-errors. In this case, the hole actually has evidence: this evidence is an erroring expression that prints an error and crashes at runtime. The ExprHole variant of holes stores an IORef EvTerm that will contain this evidence; during constraint generation, this IORef was stored in the HsUnboundVar extension field by the type checker. The desugarer simply dereferences to get the CoreExpr. Prior to fixing #17812, we used to invent an Id to hold the erroring expression, and then bind it during type-checking. But this does not support levity-polymorphic out-of-scope identifiers. See typecheck/should_compile/T17812. We thus use the mutable-CoreExpr approach described above. You might think that the type in the HoleExprRef is the same as the type of the hole. However, because the hole type (hole_ty) is rewritten with respect to givens, this might not be the case. That is, the hole_ty is always (~) to the type of the HoleExprRef, but they might not be `eqType`. We need the type of the generated evidence to match what is expected in the context of the hole, and so we must store these types separately. Type-level holes have no evidence at all. -} mkNonCanonical :: CtEvidence -> Ct mkNonCanonical :: CtEvidence -> Ct mkNonCanonical CtEvidence ev = CNonCanonical { cc_ev :: CtEvidence cc_ev = CtEvidence ev } mkNonCanonicalCt :: Ct -> Ct mkNonCanonicalCt :: Ct -> Ct mkNonCanonicalCt Ct ct = CNonCanonical { cc_ev :: CtEvidence cc_ev = Ct -> CtEvidence cc_ev Ct ct } mkIrredCt :: CtIrredReason -> CtEvidence -> Ct mkIrredCt :: CtIrredReason -> CtEvidence -> Ct mkIrredCt CtIrredReason reason CtEvidence ev = CIrredCan { cc_ev :: CtEvidence cc_ev = CtEvidence ev, cc_reason :: CtIrredReason cc_reason = CtIrredReason reason } mkGivens :: CtLoc -> [EvId] -> [Ct] mkGivens :: CtLoc -> [EvVar] -> [Ct] mkGivens CtLoc loc [EvVar] ev_ids = forall a b. (a -> b) -> [a] -> [b] map EvVar -> Ct mk [EvVar] ev_ids where mk :: EvVar -> Ct mk EvVar ev_id = CtEvidence -> Ct mkNonCanonical (CtGiven { ctev_evar :: EvVar ctev_evar = EvVar ev_id , ctev_pred :: Xi ctev_pred = EvVar -> Xi evVarPred EvVar ev_id , ctev_loc :: CtLoc ctev_loc = CtLoc loc }) ctEvidence :: Ct -> CtEvidence ctEvidence :: Ct -> CtEvidence ctEvidence (CQuantCan (QCI { qci_ev :: QCInst -> CtEvidence qci_ev = CtEvidence ev })) = CtEvidence ev ctEvidence Ct ct = Ct -> CtEvidence cc_ev Ct ct ctLoc :: Ct -> CtLoc ctLoc :: Ct -> CtLoc ctLoc = CtEvidence -> CtLoc ctEvLoc forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> CtEvidence ctEvidence setCtLoc :: Ct -> CtLoc -> Ct setCtLoc :: Ct -> CtLoc -> Ct setCtLoc Ct ct CtLoc loc = Ct ct { cc_ev :: CtEvidence cc_ev = (Ct -> CtEvidence cc_ev Ct ct) { ctev_loc :: CtLoc ctev_loc = CtLoc loc } } ctOrigin :: Ct -> CtOrigin ctOrigin :: Ct -> CtOrigin ctOrigin = CtLoc -> CtOrigin ctLocOrigin forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> CtLoc ctLoc ctPred :: Ct -> PredType -- See Note [Ct/evidence invariant] ctPred :: Ct -> Xi ctPred Ct ct = CtEvidence -> Xi ctEvPred (Ct -> CtEvidence ctEvidence Ct ct) ctEvId :: Ct -> EvVar -- The evidence Id for this Ct ctEvId :: Ct -> EvVar ctEvId Ct ct = CtEvidence -> EvVar ctEvEvId (Ct -> CtEvidence ctEvidence Ct ct) -- | Makes a new equality predicate with the same role as the given -- evidence. mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType mkTcEqPredLikeEv :: CtEvidence -> Xi -> Xi -> Xi mkTcEqPredLikeEv CtEvidence ev = case Xi -> EqRel predTypeEqRel Xi pred of EqRel NomEq -> Xi -> Xi -> Xi mkPrimEqPred EqRel ReprEq -> Xi -> Xi -> Xi mkReprPrimEqPred where pred :: Xi pred = CtEvidence -> Xi ctEvPred CtEvidence ev -- | Get the flavour of the given 'Ct' ctFlavour :: Ct -> CtFlavour ctFlavour :: Ct -> CtFlavour ctFlavour = CtEvidence -> CtFlavour ctEvFlavour forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> CtEvidence ctEvidence -- | Get the equality relation for the given 'Ct' ctEqRel :: Ct -> EqRel ctEqRel :: Ct -> EqRel ctEqRel = CtEvidence -> EqRel ctEvEqRel forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> CtEvidence ctEvidence instance Outputable Ct where ppr :: Ct -> SDoc ppr Ct ct = forall a. Outputable a => a -> SDoc ppr (Ct -> CtEvidence ctEvidence Ct ct) SDoc -> SDoc -> SDoc <+> SDoc -> SDoc parens SDoc pp_sort where pp_sort :: SDoc pp_sort = case Ct ct of CEqCan {} -> String -> SDoc text String "CEqCan" CNonCanonical {} -> String -> SDoc text String "CNonCanonical" CDictCan { cc_pend_sc :: Ct -> Bool cc_pend_sc = Bool pend_sc } | Bool pend_sc -> String -> SDoc text String "CDictCan(psc)" | Bool otherwise -> String -> SDoc text String "CDictCan" CIrredCan { cc_reason :: Ct -> CtIrredReason cc_reason = CtIrredReason reason } -> String -> SDoc text String "CIrredCan" SDoc -> SDoc -> SDoc <> forall a. Outputable a => a -> SDoc ppr CtIrredReason reason CQuantCan (QCI { qci_pend_sc :: QCInst -> Bool qci_pend_sc = Bool pend_sc }) | Bool pend_sc -> String -> SDoc text String "CQuantCan(psc)" | Bool otherwise -> String -> SDoc text String "CQuantCan" ----------------------------------- -- | Is a type a canonical LHS? That is, is it a tyvar or an exactly-saturated -- type family application? -- Does not look through type synonyms. canEqLHS_maybe :: Xi -> Maybe CanEqLHS canEqLHS_maybe :: Xi -> Maybe CanEqLHS canEqLHS_maybe Xi xi | Just EvVar tv <- Xi -> Maybe EvVar tcGetTyVar_maybe Xi xi = forall a. a -> Maybe a Just forall a b. (a -> b) -> a -> b $ EvVar -> CanEqLHS TyVarLHS EvVar tv | Just (TyCon tc, [Xi] args) <- HasCallStack => Xi -> Maybe (TyCon, [Xi]) tcSplitTyConApp_maybe Xi xi , TyCon -> Bool isTypeFamilyTyCon TyCon tc , [Xi] args forall a. [a] -> Int -> Bool `lengthIs` TyCon -> Int tyConArity TyCon tc = forall a. a -> Maybe a Just forall a b. (a -> b) -> a -> b $ TyCon -> [Xi] -> CanEqLHS TyFamLHS TyCon tc [Xi] args | Bool otherwise = forall a. Maybe a Nothing -- | Convert a 'CanEqLHS' back into a 'Type' canEqLHSType :: CanEqLHS -> TcType canEqLHSType :: CanEqLHS -> Xi canEqLHSType (TyVarLHS EvVar tv) = EvVar -> Xi mkTyVarTy EvVar tv canEqLHSType (TyFamLHS TyCon fam_tc [Xi] fam_args) = TyCon -> [Xi] -> Xi mkTyConApp TyCon fam_tc [Xi] fam_args -- | Retrieve the kind of a 'CanEqLHS' canEqLHSKind :: CanEqLHS -> TcKind canEqLHSKind :: CanEqLHS -> Xi canEqLHSKind (TyVarLHS EvVar tv) = EvVar -> Xi tyVarKind EvVar tv canEqLHSKind (TyFamLHS TyCon fam_tc [Xi] fam_args) = HasDebugCallStack => Xi -> [Xi] -> Xi piResultTys (TyCon -> Xi tyConKind TyCon fam_tc) [Xi] fam_args -- | Are two 'CanEqLHS's equal? eqCanEqLHS :: CanEqLHS -> CanEqLHS -> Bool eqCanEqLHS :: CanEqLHS -> CanEqLHS -> Bool eqCanEqLHS (TyVarLHS EvVar tv1) (TyVarLHS EvVar tv2) = EvVar tv1 forall a. Eq a => a -> a -> Bool == EvVar tv2 eqCanEqLHS (TyFamLHS TyCon fam_tc1 [Xi] fam_args1) (TyFamLHS TyCon fam_tc2 [Xi] fam_args2) = TyCon -> [Xi] -> TyCon -> [Xi] -> Bool tcEqTyConApps TyCon fam_tc1 [Xi] fam_args1 TyCon fam_tc2 [Xi] fam_args2 eqCanEqLHS CanEqLHS _ CanEqLHS _ = Bool False {- ************************************************************************ * * Simple functions over evidence variables * * ************************************************************************ -} ---------------- Getting free tyvars ------------------------- -- | Returns free variables of constraints as a non-deterministic set tyCoVarsOfCt :: Ct -> TcTyCoVarSet tyCoVarsOfCt :: Ct -> TcTyCoVarSet tyCoVarsOfCt = FV -> TcTyCoVarSet fvVarSet forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> FV tyCoFVsOfCt -- | Returns free variables of constraints as a deterministically ordered. -- list. See Note [Deterministic FV] in "GHC.Utils.FV". tyCoVarsOfCtList :: Ct -> [TcTyCoVar] tyCoVarsOfCtList :: Ct -> [EvVar] tyCoVarsOfCtList = FV -> [EvVar] fvVarList forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> FV tyCoFVsOfCt -- | Returns free variables of constraints as a composable FV computation. -- See Note [Deterministic FV] in "GHC.Utils.FV". tyCoFVsOfCt :: Ct -> FV tyCoFVsOfCt :: Ct -> FV tyCoFVsOfCt Ct ct = Xi -> FV tyCoFVsOfType (Ct -> Xi ctPred Ct ct) -- This must consult only the ctPred, so that it gets *tidied* fvs if the -- constraint has been tidied. Tidying a constraint does not tidy the -- fields of the Ct, only the predicate in the CtEvidence. -- | Returns free variables of a bag of constraints as a non-deterministic -- set. See Note [Deterministic FV] in "GHC.Utils.FV". tyCoVarsOfCts :: Cts -> TcTyCoVarSet tyCoVarsOfCts :: Cts -> TcTyCoVarSet tyCoVarsOfCts = FV -> TcTyCoVarSet fvVarSet forall b c a. (b -> c) -> (a -> b) -> a -> c . Cts -> FV tyCoFVsOfCts -- | Returns free variables of a bag of constraints as a deterministically -- ordered list. See Note [Deterministic FV] in "GHC.Utils.FV". tyCoVarsOfCtsList :: Cts -> [TcTyCoVar] tyCoVarsOfCtsList :: Cts -> [EvVar] tyCoVarsOfCtsList = FV -> [EvVar] fvVarList forall b c a. (b -> c) -> (a -> b) -> a -> c . Cts -> FV tyCoFVsOfCts -- | Returns free variables of a bag of constraints as a composable FV -- computation. See Note [Deterministic FV] in "GHC.Utils.FV". tyCoFVsOfCts :: Cts -> FV tyCoFVsOfCts :: Cts -> FV tyCoFVsOfCts = forall (t :: * -> *) a b. Foldable t => (a -> b -> b) -> b -> t a -> b foldr (FV -> FV -> FV unionFV forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> FV tyCoFVsOfCt) FV emptyFV -- | Returns free variables of WantedConstraints as a non-deterministic -- set. See Note [Deterministic FV] in "GHC.Utils.FV". tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet -- Only called on *zonked* things tyCoVarsOfWC :: WantedConstraints -> TcTyCoVarSet tyCoVarsOfWC = FV -> TcTyCoVarSet fvVarSet forall b c a. (b -> c) -> (a -> b) -> a -> c . WantedConstraints -> FV tyCoFVsOfWC -- | Returns free variables of WantedConstraints as a deterministically -- ordered list. See Note [Deterministic FV] in "GHC.Utils.FV". tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar] -- Only called on *zonked* things tyCoVarsOfWCList :: WantedConstraints -> [EvVar] tyCoVarsOfWCList = FV -> [EvVar] fvVarList forall b c a. (b -> c) -> (a -> b) -> a -> c . WantedConstraints -> FV tyCoFVsOfWC -- | Returns free variables of WantedConstraints as a composable FV -- computation. See Note [Deterministic FV] in "GHC.Utils.FV". tyCoFVsOfWC :: WantedConstraints -> FV -- Only called on *zonked* things tyCoFVsOfWC :: WantedConstraints -> FV tyCoFVsOfWC (WC { wc_simple :: WantedConstraints -> Cts wc_simple = Cts simple, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication implic, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole holes }) = Cts -> FV tyCoFVsOfCts Cts simple FV -> FV -> FV `unionFV` forall a. (a -> FV) -> Bag a -> FV tyCoFVsOfBag Implication -> FV tyCoFVsOfImplic Bag Implication implic FV -> FV -> FV `unionFV` forall a. (a -> FV) -> Bag a -> FV tyCoFVsOfBag Hole -> FV tyCoFVsOfHole Bag Hole holes -- | Returns free variables of Implication as a composable FV computation. -- See Note [Deterministic FV] in "GHC.Utils.FV". tyCoFVsOfImplic :: Implication -> FV -- Only called on *zonked* things tyCoFVsOfImplic :: Implication -> FV tyCoFVsOfImplic (Implic { ic_skols :: Implication -> [EvVar] ic_skols = [EvVar] skols , ic_given :: Implication -> [EvVar] ic_given = [EvVar] givens , ic_wanted :: Implication -> WantedConstraints ic_wanted = WantedConstraints wanted }) | WantedConstraints -> Bool isEmptyWC WantedConstraints wanted = FV emptyFV | Bool otherwise = [EvVar] -> FV -> FV tyCoFVsVarBndrs [EvVar] skols forall a b. (a -> b) -> a -> b $ [EvVar] -> FV -> FV tyCoFVsVarBndrs [EvVar] givens forall a b. (a -> b) -> a -> b $ WantedConstraints -> FV tyCoFVsOfWC WantedConstraints wanted tyCoFVsOfHole :: Hole -> FV tyCoFVsOfHole :: Hole -> FV tyCoFVsOfHole (Hole { hole_ty :: Hole -> Xi hole_ty = Xi ty }) = Xi -> FV tyCoFVsOfType Xi ty tyCoFVsOfBag :: (a -> FV) -> Bag a -> FV tyCoFVsOfBag :: forall a. (a -> FV) -> Bag a -> FV tyCoFVsOfBag a -> FV tvs_of = forall (t :: * -> *) a b. Foldable t => (a -> b -> b) -> b -> t a -> b foldr (FV -> FV -> FV unionFV forall b c a. (b -> c) -> (a -> b) -> a -> c . a -> FV tvs_of) FV emptyFV --------------------------- dropDerivedWC :: WantedConstraints -> WantedConstraints -- See Note [Dropping derived constraints] dropDerivedWC :: WantedConstraints -> WantedConstraints dropDerivedWC wc :: WantedConstraints wc@(WC { wc_simple :: WantedConstraints -> Cts wc_simple = Cts simples }) = WantedConstraints wc { wc_simple :: Cts wc_simple = Cts -> Cts dropDerivedSimples Cts simples } -- The wc_impl implications are already (recursively) filtered -------------------------- dropDerivedSimples :: Cts -> Cts -- Drop all Derived constraints, but make [W] back into [WD], -- so that if we re-simplify these constraints we will get all -- the right derived constraints re-generated. Forgetting this -- step led to #12936 dropDerivedSimples :: Cts -> Cts dropDerivedSimples Cts simples = forall a b. (a -> Maybe b) -> Bag a -> Bag b mapMaybeBag Ct -> Maybe Ct dropDerivedCt Cts simples dropDerivedCt :: Ct -> Maybe Ct dropDerivedCt :: Ct -> Maybe Ct dropDerivedCt Ct ct = case CtEvidence -> CtFlavour ctEvFlavour CtEvidence ev of Wanted ShadowInfo WOnly -> forall a. a -> Maybe a Just (Ct ct' { cc_ev :: CtEvidence cc_ev = CtEvidence ev_wd }) Wanted ShadowInfo _ -> forall a. a -> Maybe a Just Ct ct' CtFlavour _ | Ct -> Bool isDroppableCt Ct ct -> forall a. Maybe a Nothing | Bool otherwise -> forall a. a -> Maybe a Just Ct ct where ev :: CtEvidence ev = Ct -> CtEvidence ctEvidence Ct ct ev_wd :: CtEvidence ev_wd = CtEvidence ev { ctev_nosh :: ShadowInfo ctev_nosh = ShadowInfo WDeriv } ct' :: Ct ct' = Ct -> Ct setPendingScDict Ct ct -- See Note [Resetting cc_pend_sc] {- Note [Resetting cc_pend_sc] ~~~~~~~~~~~~~~~~~~~~~~~~~~~ When we discard Derived constraints, in dropDerivedSimples, we must set the cc_pend_sc flag to True, so that if we re-process this CDictCan we will re-generate its derived superclasses. Otherwise we might miss some fundeps. #13662 showed this up. See Note [The superclass story] in GHC.Tc.Solver.Canonical. -} isDroppableCt :: Ct -> Bool isDroppableCt :: Ct -> Bool isDroppableCt Ct ct = CtEvidence -> Bool isDerived CtEvidence ev Bool -> Bool -> Bool && Bool -> Bool not Bool keep_deriv -- Drop only derived constraints, and then only if they -- obey Note [Dropping derived constraints] where ev :: CtEvidence ev = Ct -> CtEvidence ctEvidence Ct ct loc :: CtLoc loc = CtEvidence -> CtLoc ctEvLoc CtEvidence ev orig :: CtOrigin orig = CtLoc -> CtOrigin ctLocOrigin CtLoc loc keep_deriv :: Bool keep_deriv = case Ct ct of CIrredCan { cc_reason :: Ct -> CtIrredReason cc_reason = CtIrredReason reason } | CtIrredReason -> Bool isInsolubleReason CtIrredReason reason -> Bool -> Bool keep_eq Bool True Ct _ -> Bool -> Bool keep_eq Bool False keep_eq :: Bool -> Bool keep_eq Bool definitely_insoluble | CtOrigin -> Bool isGivenOrigin CtOrigin orig -- Arising only from givens = Bool definitely_insoluble -- Keep only definitely insoluble | Bool otherwise = case CtOrigin orig of -- See Note [Dropping derived constraints] -- For fundeps, drop wanted/wanted interactions FunDepOrigin2 {} -> Bool True -- Top-level/Wanted FunDepOrigin1 Xi _ CtOrigin orig1 RealSrcSpan _ Xi _ CtOrigin orig2 RealSrcSpan _ | Bool g1 Bool -> Bool -> Bool || Bool g2 -> Bool True -- Given/Wanted errors: keep all | Bool otherwise -> Bool False -- Wanted/Wanted errors: discard where g1 :: Bool g1 = CtOrigin -> Bool isGivenOrigin CtOrigin orig1 g2 :: Bool g2 = CtOrigin -> Bool isGivenOrigin CtOrigin orig2 CtOrigin _ -> Bool False arisesFromGivens :: Ct -> Bool arisesFromGivens :: Ct -> Bool arisesFromGivens Ct ct = case Ct -> CtEvidence ctEvidence Ct ct of CtGiven {} -> Bool True CtWanted {} -> Bool False CtDerived { ctev_loc :: CtEvidence -> CtLoc ctev_loc = CtLoc loc } -> CtLoc -> Bool isGivenLoc CtLoc loc isGivenLoc :: CtLoc -> Bool isGivenLoc :: CtLoc -> Bool isGivenLoc CtLoc loc = CtOrigin -> Bool isGivenOrigin (CtLoc -> CtOrigin ctLocOrigin CtLoc loc) {- Note [Dropping derived constraints] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In general we discard derived constraints at the end of constraint solving; see dropDerivedWC. For example * Superclasses: if we have an unsolved [W] (Ord a), we don't want to complain about an unsolved [D] (Eq a) as well. * If we have [W] a ~ Int, [W] a ~ Bool, improvement will generate [D] Int ~ Bool, and we don't want to report that because it's incomprehensible. That is why we don't rewrite wanteds with wanteds! * We might float out some Wanteds from an implication, leaving behind their insoluble Deriveds. For example: forall a[2]. [W] alpha[1] ~ Int [W] alpha[1] ~ Bool [D] Int ~ Bool The Derived is insoluble, but we very much want to drop it when floating out. But (tiresomely) we do keep *some* Derived constraints: * Type holes are derived constraints, because they have no evidence and we want to keep them, so we get the error report * We keep most derived equalities arising from functional dependencies - Given/Given interactions (subset of FunDepOrigin1): The definitely-insoluble ones reflect unreachable code. Others not-definitely-insoluble ones like [D] a ~ Int do not reflect unreachable code; indeed if fundeps generated proofs, it'd be a useful equality. See #14763. So we discard them. - Given/Wanted interacGiven or Wanted interacting with an instance declaration (FunDepOrigin2) - Given/Wanted interactions (FunDepOrigin1); see #9612 - But for Wanted/Wanted interactions we do /not/ want to report an error (#13506). Consider [W] C Int Int, [W] C Int Bool, with a fundep on class C. We don't want to report an insoluble Int~Bool; c.f. "wanteds do not rewrite wanteds". To distinguish these cases we use the CtOrigin. NB: we keep *all* derived insolubles under some circumstances: * They are looked at by simplifyInfer, to decide whether to generalise. Example: [W] a ~ Int, [W] a ~ Bool We get [D] Int ~ Bool, and indeed the constraints are insoluble, and we want simplifyInfer to see that, even though we don't ultimately want to generate an (inexplicable) error message from it ************************************************************************ * * CtEvidence The "flavor" of a canonical constraint * * ************************************************************************ -} isWantedCt :: Ct -> Bool isWantedCt :: Ct -> Bool isWantedCt = CtEvidence -> Bool isWanted forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> CtEvidence ctEvidence isGivenCt :: Ct -> Bool isGivenCt :: Ct -> Bool isGivenCt = CtEvidence -> Bool isGiven forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> CtEvidence ctEvidence isDerivedCt :: Ct -> Bool isDerivedCt :: Ct -> Bool isDerivedCt = CtEvidence -> Bool isDerived forall b c a. (b -> c) -> (a -> b) -> a -> c . Ct -> CtEvidence ctEvidence {- Note [Custom type errors in constraints] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ When GHC reports a type-error about an unsolved-constraint, we check to see if the constraint contains any custom-type errors, and if so we report them. Here are some examples of constraints containing type errors: TypeError msg -- The actual constraint is a type error TypError msg ~ Int -- Some type was supposed to be Int, but ended up -- being a type error instead Eq (TypeError msg) -- A class constraint is stuck due to a type error F (TypeError msg) ~ a -- A type function failed to evaluate due to a type err It is also possible to have constraints where the type error is nested deeper, for example see #11990, and also: Eq (F (TypeError msg)) -- Here the type error is nested under a type-function -- call, which failed to evaluate because of it, -- and so the `Eq` constraint was unsolved. -- This may happen when one function calls another -- and the called function produced a custom type error. -} -- | A constraint is considered to be a custom type error, if it contains -- custom type errors anywhere in it. -- See Note [Custom type errors in constraints] getUserTypeErrorMsg :: Ct -> Maybe Type getUserTypeErrorMsg :: Ct -> Maybe Xi getUserTypeErrorMsg Ct ct = Xi -> Maybe Xi findUserTypeError (Ct -> Xi ctPred Ct ct) where findUserTypeError :: Xi -> Maybe Xi findUserTypeError Xi t = forall (t :: * -> *) (m :: * -> *) a. (Foldable t, MonadPlus m) => t (m a) -> m a msum ( Xi -> Maybe Xi userTypeError_maybe Xi t forall a. a -> [a] -> [a] : forall a b. (a -> b) -> [a] -> [b] map Xi -> Maybe Xi findUserTypeError (Xi -> [Xi] subTys Xi t) ) subTys :: Xi -> [Xi] subTys Xi t = case Xi -> (Xi, [Xi]) splitAppTys Xi t of (Xi t,[]) -> case HasDebugCallStack => Xi -> Maybe (TyCon, [Xi]) splitTyConApp_maybe Xi t of Maybe (TyCon, [Xi]) Nothing -> [] Just (TyCon _,[Xi] ts) -> [Xi] ts (Xi t,[Xi] ts) -> Xi t forall a. a -> [a] -> [a] : [Xi] ts isUserTypeErrorCt :: Ct -> Bool isUserTypeErrorCt :: Ct -> Bool isUserTypeErrorCt Ct ct = case Ct -> Maybe Xi getUserTypeErrorMsg Ct ct of Just Xi _ -> Bool True Maybe Xi _ -> Bool False isPendingScDict :: Ct -> Maybe Ct -- Says whether this is a CDictCan with cc_pend_sc is True, -- AND if so flips the flag isPendingScDict :: Ct -> Maybe Ct isPendingScDict ct :: Ct ct@(CDictCan { cc_pend_sc :: Ct -> Bool cc_pend_sc = Bool True }) = forall a. a -> Maybe a Just (Ct ct { cc_pend_sc :: Bool cc_pend_sc = Bool False }) isPendingScDict Ct _ = forall a. Maybe a Nothing isPendingScInst :: QCInst -> Maybe QCInst -- Same as isPendingScDict, but for QCInsts isPendingScInst :: QCInst -> Maybe QCInst isPendingScInst qci :: QCInst qci@(QCI { qci_pend_sc :: QCInst -> Bool qci_pend_sc = Bool True }) = forall a. a -> Maybe a Just (QCInst qci { qci_pend_sc :: Bool qci_pend_sc = Bool False }) isPendingScInst QCInst _ = forall a. Maybe a Nothing setPendingScDict :: Ct -> Ct -- Set the cc_pend_sc flag to True setPendingScDict :: Ct -> Ct setPendingScDict ct :: Ct ct@(CDictCan { cc_pend_sc :: Ct -> Bool cc_pend_sc = Bool False }) = Ct ct { cc_pend_sc :: Bool cc_pend_sc = Bool True } setPendingScDict Ct ct = Ct ct superClassesMightHelp :: WantedConstraints -> Bool -- ^ True if taking superclasses of givens, or of wanteds (to perhaps -- expose more equalities or functional dependencies) might help to -- solve this constraint. See Note [When superclasses help] superClassesMightHelp :: WantedConstraints -> Bool superClassesMightHelp (WC { wc_simple :: WantedConstraints -> Cts wc_simple = Cts simples, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication implics }) = forall a. (a -> Bool) -> Bag a -> Bool anyBag Ct -> Bool might_help_ct Cts simples Bool -> Bool -> Bool || forall a. (a -> Bool) -> Bag a -> Bool anyBag Implication -> Bool might_help_implic Bag Implication implics where might_help_implic :: Implication -> Bool might_help_implic Implication ic | ImplicStatus IC_Unsolved <- Implication -> ImplicStatus ic_status Implication ic = WantedConstraints -> Bool superClassesMightHelp (Implication -> WantedConstraints ic_wanted Implication ic) | Bool otherwise = Bool False might_help_ct :: Ct -> Bool might_help_ct Ct ct = Ct -> Bool isWantedCt Ct ct Bool -> Bool -> Bool && Bool -> Bool not (Ct -> Bool is_ip Ct ct) is_ip :: Ct -> Bool is_ip (CDictCan { cc_class :: Ct -> Class cc_class = Class cls }) = Class -> Bool isIPClass Class cls is_ip Ct _ = Bool False getPendingWantedScs :: Cts -> ([Ct], Cts) getPendingWantedScs :: Cts -> ([Ct], Cts) getPendingWantedScs Cts simples = forall acc x y. (acc -> x -> (acc, y)) -> acc -> Bag x -> (acc, Bag y) mapAccumBagL [Ct] -> Ct -> ([Ct], Ct) get [] Cts simples where get :: [Ct] -> Ct -> ([Ct], Ct) get [Ct] acc Ct ct | Just Ct ct' <- Ct -> Maybe Ct isPendingScDict Ct ct = (Ct ct'forall a. a -> [a] -> [a] :[Ct] acc, Ct ct') | Bool otherwise = ([Ct] acc, Ct ct) {- Note [When superclasses help] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ First read Note [The superclass story] in GHC.Tc.Solver.Canonical. We expand superclasses and iterate only if there is at unsolved wanted for which expansion of superclasses (e.g. from given constraints) might actually help. The function superClassesMightHelp tells if doing this superclass expansion might help solve this constraint. Note that * We look inside implications; maybe it'll help to expand the Givens at level 2 to help solve an unsolved Wanted buried inside an implication. E.g. forall a. Ord a => forall b. [W] Eq a * Superclasses help only for Wanted constraints. Derived constraints are not really "unsolved" and we certainly don't want them to trigger superclass expansion. This was a good part of the loop in #11523 * Even for Wanted constraints, we say "no" for implicit parameters. we have [W] ?x::ty, expanding superclasses won't help: - Superclasses can't be implicit parameters - If we have a [G] ?x:ty2, then we'll have another unsolved [D] ty ~ ty2 (from the functional dependency) which will trigger superclass expansion. It's a bit of a special case, but it's easy to do. The runtime cost is low because the unsolved set is usually empty anyway (errors aside), and the first non-implicit-parameter will terminate the search. The special case is worth it (#11480, comment:2) because it applies to CallStack constraints, which aren't type errors. If we have f :: (C a) => blah f x = ...undefined... we'll get a CallStack constraint. If that's the only unsolved constraint it'll eventually be solved by defaulting. So we don't want to emit warnings about hitting the simplifier's iteration limit. A CallStack constraint really isn't an unsolved constraint; it can always be solved by defaulting. -} singleCt :: Ct -> Cts singleCt :: Ct -> Cts singleCt = forall a. a -> Bag a unitBag andCts :: Cts -> Cts -> Cts andCts :: Cts -> Cts -> Cts andCts = forall a. Bag a -> Bag a -> Bag a unionBags listToCts :: [Ct] -> Cts listToCts :: [Ct] -> Cts listToCts = forall a. [a] -> Bag a listToBag ctsElts :: Cts -> [Ct] ctsElts :: Cts -> [Ct] ctsElts = forall a. Bag a -> [a] bagToList consCts :: Ct -> Cts -> Cts consCts :: Ct -> Cts -> Cts consCts = forall a. a -> Bag a -> Bag a consBag snocCts :: Cts -> Ct -> Cts snocCts :: Cts -> Ct -> Cts snocCts = forall a. Bag a -> a -> Bag a snocBag extendCtsList :: Cts -> [Ct] -> Cts extendCtsList :: Cts -> [Ct] -> Cts extendCtsList Cts cts [Ct] xs | forall (t :: * -> *) a. Foldable t => t a -> Bool null [Ct] xs = Cts cts | Bool otherwise = Cts cts forall a. Bag a -> Bag a -> Bag a `unionBags` forall a. [a] -> Bag a listToBag [Ct] xs andManyCts :: [Cts] -> Cts andManyCts :: [Cts] -> Cts andManyCts = forall a. [Bag a] -> Bag a unionManyBags emptyCts :: Cts emptyCts :: Cts emptyCts = forall a. Bag a emptyBag isEmptyCts :: Cts -> Bool isEmptyCts :: Cts -> Bool isEmptyCts = forall a. Bag a -> Bool isEmptyBag pprCts :: Cts -> SDoc pprCts :: Cts -> SDoc pprCts Cts cts = [SDoc] -> SDoc vcat (forall a b. (a -> b) -> [a] -> [b] map forall a. Outputable a => a -> SDoc ppr (forall a. Bag a -> [a] bagToList Cts cts)) {- ************************************************************************ * * Wanted constraints These are forced to be in GHC.Tc.Types because TcLclEnv mentions WantedConstraints WantedConstraint mentions CtLoc CtLoc mentions ErrCtxt ErrCtxt mentions TcM * * v%************************************************************************ -} data WantedConstraints = WC { WantedConstraints -> Cts wc_simple :: Cts -- Unsolved constraints, all wanted , WantedConstraints -> Bag Implication wc_impl :: Bag Implication , WantedConstraints -> Bag Hole wc_holes :: Bag Hole } emptyWC :: WantedConstraints emptyWC :: WantedConstraints emptyWC = WC { wc_simple :: Cts wc_simple = forall a. Bag a emptyBag , wc_impl :: Bag Implication wc_impl = forall a. Bag a emptyBag , wc_holes :: Bag Hole wc_holes = forall a. Bag a emptyBag } mkSimpleWC :: [CtEvidence] -> WantedConstraints mkSimpleWC :: [CtEvidence] -> WantedConstraints mkSimpleWC [CtEvidence] cts = WantedConstraints emptyWC { wc_simple :: Cts wc_simple = forall a. [a] -> Bag a listToBag (forall a b. (a -> b) -> [a] -> [b] map CtEvidence -> Ct mkNonCanonical [CtEvidence] cts) } mkImplicWC :: Bag Implication -> WantedConstraints mkImplicWC :: Bag Implication -> WantedConstraints mkImplicWC Bag Implication implic = WantedConstraints emptyWC { wc_impl :: Bag Implication wc_impl = Bag Implication implic } isEmptyWC :: WantedConstraints -> Bool isEmptyWC :: WantedConstraints -> Bool isEmptyWC (WC { wc_simple :: WantedConstraints -> Cts wc_simple = Cts f, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication i, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole holes }) = forall a. Bag a -> Bool isEmptyBag Cts f Bool -> Bool -> Bool && forall a. Bag a -> Bool isEmptyBag Bag Implication i Bool -> Bool -> Bool && forall a. Bag a -> Bool isEmptyBag Bag Hole holes -- | Checks whether a the given wanted constraints are solved, i.e. -- that there are no simple constraints left and all the implications -- are solved. isSolvedWC :: WantedConstraints -> Bool isSolvedWC :: WantedConstraints -> Bool isSolvedWC WC {wc_simple :: WantedConstraints -> Cts wc_simple = Cts wc_simple, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication wc_impl, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole holes} = forall a. Bag a -> Bool isEmptyBag Cts wc_simple Bool -> Bool -> Bool && forall a. (a -> Bool) -> Bag a -> Bool allBag (ImplicStatus -> Bool isSolvedStatus forall b c a. (b -> c) -> (a -> b) -> a -> c . Implication -> ImplicStatus ic_status) Bag Implication wc_impl Bool -> Bool -> Bool && forall a. Bag a -> Bool isEmptyBag Bag Hole holes andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints andWC (WC { wc_simple :: WantedConstraints -> Cts wc_simple = Cts f1, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication i1, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole h1 }) (WC { wc_simple :: WantedConstraints -> Cts wc_simple = Cts f2, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication i2, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole h2 }) = WC { wc_simple :: Cts wc_simple = Cts f1 forall a. Bag a -> Bag a -> Bag a `unionBags` Cts f2 , wc_impl :: Bag Implication wc_impl = Bag Implication i1 forall a. Bag a -> Bag a -> Bag a `unionBags` Bag Implication i2 , wc_holes :: Bag Hole wc_holes = Bag Hole h1 forall a. Bag a -> Bag a -> Bag a `unionBags` Bag Hole h2 } unionsWC :: [WantedConstraints] -> WantedConstraints unionsWC :: [WantedConstraints] -> WantedConstraints unionsWC = forall (t :: * -> *) a b. Foldable t => (a -> b -> b) -> b -> t a -> b foldr WantedConstraints -> WantedConstraints -> WantedConstraints andWC WantedConstraints emptyWC addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints addSimples :: WantedConstraints -> Cts -> WantedConstraints addSimples WantedConstraints wc Cts cts = WantedConstraints wc { wc_simple :: Cts wc_simple = WantedConstraints -> Cts wc_simple WantedConstraints wc forall a. Bag a -> Bag a -> Bag a `unionBags` Cts cts } -- Consider: Put the new constraints at the front, so they get solved first addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints addImplics WantedConstraints wc Bag Implication implic = WantedConstraints wc { wc_impl :: Bag Implication wc_impl = WantedConstraints -> Bag Implication wc_impl WantedConstraints wc forall a. Bag a -> Bag a -> Bag a `unionBags` Bag Implication implic } addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints addInsols :: WantedConstraints -> Cts -> WantedConstraints addInsols WantedConstraints wc Cts cts = WantedConstraints wc { wc_simple :: Cts wc_simple = WantedConstraints -> Cts wc_simple WantedConstraints wc forall a. Bag a -> Bag a -> Bag a `unionBags` Cts cts } addHoles :: WantedConstraints -> Bag Hole -> WantedConstraints addHoles :: WantedConstraints -> Bag Hole -> WantedConstraints addHoles WantedConstraints wc Bag Hole holes = WantedConstraints wc { wc_holes :: Bag Hole wc_holes = Bag Hole holes forall a. Bag a -> Bag a -> Bag a `unionBags` WantedConstraints -> Bag Hole wc_holes WantedConstraints wc } dropMisleading :: WantedConstraints -> WantedConstraints -- Drop misleading constraints; really just class constraints -- See Note [Constraints and errors] in GHC.Tc.Utils.Monad -- for why this function is so strange, treating the 'simples' -- and the implications differently. Sigh. dropMisleading :: WantedConstraints -> WantedConstraints dropMisleading (WC { wc_simple :: WantedConstraints -> Cts wc_simple = Cts simples, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication implics, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole holes }) = WC { wc_simple :: Cts wc_simple = forall a. (a -> Bool) -> Bag a -> Bag a filterBag Ct -> Bool insolubleCt Cts simples , wc_impl :: Bag Implication wc_impl = forall a b. (a -> b) -> Bag a -> Bag b mapBag Implication -> Implication drop_implic Bag Implication implics , wc_holes :: Bag Hole wc_holes = forall a. (a -> Bool) -> Bag a -> Bag a filterBag Hole -> Bool isOutOfScopeHole Bag Hole holes } where drop_implic :: Implication -> Implication drop_implic Implication implic = Implication implic { ic_wanted :: WantedConstraints ic_wanted = WantedConstraints -> WantedConstraints drop_wanted (Implication -> WantedConstraints ic_wanted Implication implic) } drop_wanted :: WantedConstraints -> WantedConstraints drop_wanted (WC { wc_simple :: WantedConstraints -> Cts wc_simple = Cts simples, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication implics, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole holes }) = WC { wc_simple :: Cts wc_simple = forall a. (a -> Bool) -> Bag a -> Bag a filterBag Ct -> Bool keep_ct Cts simples , wc_impl :: Bag Implication wc_impl = forall a b. (a -> b) -> Bag a -> Bag b mapBag Implication -> Implication drop_implic Bag Implication implics , wc_holes :: Bag Hole wc_holes = forall a. (a -> Bool) -> Bag a -> Bag a filterBag Hole -> Bool isOutOfScopeHole Bag Hole holes } keep_ct :: Ct -> Bool keep_ct Ct ct = case Xi -> Pred classifyPredType (Ct -> Xi ctPred Ct ct) of ClassPred {} -> Bool False Pred _ -> Bool True isSolvedStatus :: ImplicStatus -> Bool isSolvedStatus :: ImplicStatus -> Bool isSolvedStatus (IC_Solved {}) = Bool True isSolvedStatus ImplicStatus _ = Bool False isInsolubleStatus :: ImplicStatus -> Bool isInsolubleStatus :: ImplicStatus -> Bool isInsolubleStatus ImplicStatus IC_Insoluble = Bool True isInsolubleStatus ImplicStatus IC_BadTelescope = Bool True isInsolubleStatus ImplicStatus _ = Bool False insolubleImplic :: Implication -> Bool insolubleImplic :: Implication -> Bool insolubleImplic Implication ic = ImplicStatus -> Bool isInsolubleStatus (Implication -> ImplicStatus ic_status Implication ic) insolubleWC :: WantedConstraints -> Bool insolubleWC :: WantedConstraints -> Bool insolubleWC (WC { wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication implics, wc_simple :: WantedConstraints -> Cts wc_simple = Cts simples, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole holes }) = forall a. (a -> Bool) -> Bag a -> Bool anyBag Ct -> Bool insolubleCt Cts simples Bool -> Bool -> Bool || forall a. (a -> Bool) -> Bag a -> Bool anyBag Implication -> Bool insolubleImplic Bag Implication implics Bool -> Bool -> Bool || forall a. (a -> Bool) -> Bag a -> Bool anyBag Hole -> Bool isOutOfScopeHole Bag Hole holes -- See Note [Insoluble holes] insolubleCt :: Ct -> Bool -- Definitely insoluble, in particular /excluding/ type-hole constraints -- Namely: a) an equality constraint -- b) that is insoluble -- c) and does not arise from a Given insolubleCt :: Ct -> Bool insolubleCt Ct ct | Bool -> Bool not (Ct -> Bool insolubleEqCt Ct ct) = Bool False | Ct -> Bool arisesFromGivens Ct ct = Bool False -- See Note [Given insolubles] | Bool otherwise = Bool True insolubleEqCt :: Ct -> Bool -- Returns True of /equality/ constraints -- that are /definitely/ insoluble -- It won't detect some definite errors like -- F a ~ T (F a) -- where F is a type family, which actually has an occurs check -- -- The function is tuned for application /after/ constraint solving -- i.e. assuming canonicalisation has been done -- E.g. It'll reply True for a ~ [a] -- but False for [a] ~ a -- and -- True for Int ~ F a Int -- but False for Maybe Int ~ F a Int Int -- (where F is an arity-1 type function) insolubleEqCt :: Ct -> Bool insolubleEqCt (CIrredCan { cc_reason :: Ct -> CtIrredReason cc_reason = CtIrredReason reason }) = CtIrredReason -> Bool isInsolubleReason CtIrredReason reason insolubleEqCt Ct _ = Bool False -- | Does this hole represent an "out of scope" error? -- See Note [Insoluble holes] isOutOfScopeHole :: Hole -> Bool isOutOfScopeHole :: Hole -> Bool isOutOfScopeHole (Hole { hole_occ :: Hole -> OccName hole_occ = OccName occ }) = Bool -> Bool not (OccName -> Bool startsWithUnderscore OccName occ) instance Outputable WantedConstraints where ppr :: WantedConstraints -> SDoc ppr (WC {wc_simple :: WantedConstraints -> Cts wc_simple = Cts s, wc_impl :: WantedConstraints -> Bag Implication wc_impl = Bag Implication i, wc_holes :: WantedConstraints -> Bag Hole wc_holes = Bag Hole h}) = String -> SDoc text String "WC" SDoc -> SDoc -> SDoc <+> SDoc -> SDoc braces ([SDoc] -> SDoc vcat [ forall a. Outputable a => SDoc -> Bag a -> SDoc ppr_bag (String -> SDoc text String "wc_simple") Cts s , forall a. Outputable a => SDoc -> Bag a -> SDoc ppr_bag (String -> SDoc text String "wc_impl") Bag Implication i , forall a. Outputable a => SDoc -> Bag a -> SDoc ppr_bag (String -> SDoc text String "wc_holes") Bag Hole h ]) ppr_bag :: Outputable a => SDoc -> Bag a -> SDoc ppr_bag :: forall a. Outputable a => SDoc -> Bag a -> SDoc ppr_bag SDoc doc Bag a bag | forall a. Bag a -> Bool isEmptyBag Bag a bag = SDoc empty | Bool otherwise = SDoc -> Int -> SDoc -> SDoc hang (SDoc doc SDoc -> SDoc -> SDoc <+> SDoc equals) Int 2 (forall (t :: * -> *) a b. Foldable t => (a -> b -> b) -> b -> t a -> b foldr (SDoc -> SDoc -> SDoc ($$) forall b c a. (b -> c) -> (a -> b) -> a -> c . forall a. Outputable a => a -> SDoc ppr) SDoc empty Bag a bag) {- Note [Given insolubles] ~~~~~~~~~~~~~~~~~~~~~~~~~~ Consider (#14325, comment:) class (a~b) => C a b foo :: C a c => a -> c foo x = x hm3 :: C (f b) b => b -> f b hm3 x = foo x In the RHS of hm3, from the [G] C (f b) b we get the insoluble [G] f b ~# b. Then we also get an unsolved [W] C b (f b). Residual implication looks like forall b. C (f b) b => [G] f b ~# b [W] C f (f b) We do /not/ want to set the implication status to IC_Insoluble, because that'll suppress reports of [W] C b (f b). But we may not report the insoluble [G] f b ~# b either (see Note [Given errors] in GHC.Tc.Errors), so we may fail to report anything at all! Yikes. The same applies to Derived constraints that /arise from/ Givens. E.g. f :: (C Int [a]) => blah where a fundep means we get [D] Int ~ [a] By the same reasoning we must not suppress other errors (#15767) Bottom line: insolubleWC (called in GHC.Tc.Solver.setImplicationStatus) should ignore givens even if they are insoluble. Note [Insoluble holes] ~~~~~~~~~~~~~~~~~~~~~~ Hole constraints that ARE NOT treated as truly insoluble: a) type holes, arising from PartialTypeSignatures, b) "true" expression holes arising from TypedHoles An "expression hole" or "type hole" isn't really an error at all; it's a report saying "_ :: Int" here. But an out-of-scope variable masquerading as expression holes IS treated as truly insoluble, so that it trumps other errors during error reporting. Yuk! ************************************************************************ * * Implication constraints * * ************************************************************************ -} data Implication = Implic { -- Invariants for a tree of implications: -- see TcType Note [TcLevel invariants] Implication -> TcLevel ic_tclvl :: TcLevel, -- TcLevel of unification variables -- allocated /inside/ this implication Implication -> [EvVar] ic_skols :: [TcTyVar], -- Introduced skolems Implication -> SkolemInfo ic_info :: SkolemInfo, -- See Note [Skolems in an implication] -- See Note [Shadowing in a constraint] Implication -> [EvVar] ic_given :: [EvVar], -- Given evidence variables -- (order does not matter) -- See Invariant (GivenInv) in GHC.Tc.Utils.TcType Implication -> HasGivenEqs ic_given_eqs :: HasGivenEqs, -- Are there Given equalities here? Implication -> Bool ic_warn_inaccessible :: Bool, -- True <=> -Winaccessible-code is enabled -- at construction. See -- Note [Avoid -Winaccessible-code when deriving] -- in GHC.Tc.TyCl.Instance Implication -> TcLclEnv ic_env :: TcLclEnv, -- Records the TcLClEnv at the time of creation. -- -- The TcLclEnv gives the source location -- and error context for the implication, and -- hence for all the given evidence variables. Implication -> WantedConstraints ic_wanted :: WantedConstraints, -- The wanteds -- See Invariang (WantedInf) in GHC.Tc.Utils.TcType Implication -> EvBindsVar ic_binds :: EvBindsVar, -- Points to the place to fill in the -- abstraction and bindings. -- The ic_need fields keep track of which Given evidence -- is used by this implication or its children -- NB: including stuff used by nested implications that have since -- been discarded -- See Note [Needed evidence variables] Implication -> TcTyCoVarSet ic_need_inner :: VarSet, -- Includes all used Given evidence Implication -> TcTyCoVarSet ic_need_outer :: VarSet, -- Includes only the free Given evidence -- i.e. ic_need_inner after deleting -- (a) givens (b) binders of ic_binds Implication -> ImplicStatus ic_status :: ImplicStatus } implicationPrototype :: Implication implicationPrototype :: Implication implicationPrototype = Implic { -- These fields must be initialised ic_tclvl :: TcLevel ic_tclvl = forall a. String -> a panic String "newImplic:tclvl" , ic_binds :: EvBindsVar ic_binds = forall a. String -> a panic String "newImplic:binds" , ic_info :: SkolemInfo ic_info = forall a. String -> a panic String "newImplic:info" , ic_env :: TcLclEnv ic_env = forall a. String -> a panic String "newImplic:env" , ic_warn_inaccessible :: Bool ic_warn_inaccessible = forall a. String -> a panic String "newImplic:warn_inaccessible" -- The rest have sensible default values , ic_skols :: [EvVar] ic_skols = [] , ic_given :: [EvVar] ic_given = [] , ic_wanted :: WantedConstraints ic_wanted = WantedConstraints emptyWC , ic_given_eqs :: HasGivenEqs ic_given_eqs = HasGivenEqs MaybeGivenEqs , ic_status :: ImplicStatus ic_status = ImplicStatus IC_Unsolved , ic_need_inner :: TcTyCoVarSet ic_need_inner = TcTyCoVarSet emptyVarSet , ic_need_outer :: TcTyCoVarSet ic_need_outer = TcTyCoVarSet emptyVarSet } data ImplicStatus = IC_Solved -- All wanteds in the tree are solved, all the way down { ImplicStatus -> [EvVar] ics_dead :: [EvVar] } -- Subset of ic_given that are not needed -- See Note [Tracking redundant constraints] in GHC.Tc.Solver | IC_Insoluble -- At least one insoluble constraint in the tree | IC_BadTelescope -- Solved, but the skolems in the telescope are out of -- dependency order. See Note [Checking telescopes] | IC_Unsolved -- Neither of the above; might go either way data HasGivenEqs -- See Note [HasGivenEqs] = NoGivenEqs -- Definitely no given equalities, -- except by Note [Let-bound skolems] in GHC.Tc.Solver.Monad | LocalGivenEqs -- Might have Given equalities, but only ones that affect only -- local skolems e.g. forall a b. (a ~ F b) => ... | MaybeGivenEqs -- Might have any kind of Given equalities; no floating out -- is possible. deriving HasGivenEqs -> HasGivenEqs -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: HasGivenEqs -> HasGivenEqs -> Bool $c/= :: HasGivenEqs -> HasGivenEqs -> Bool == :: HasGivenEqs -> HasGivenEqs -> Bool $c== :: HasGivenEqs -> HasGivenEqs -> Bool Eq {- Note [HasGivenEqs] ~~~~~~~~~~~~~~~~~~~~~ The GivenEqs data type describes the Given constraints of an implication constraint: * NoGivenEqs: definitely no Given equalities, except perhaps let-bound skolems which don't count: see Note [Let-bound skolems] in GHC.Tc.Solver.Monad Examples: forall a. Eq a => ... forall a. (Show a, Num a) => ... forall a. a ~ Either Int Bool => ... -- Let-bound skolem * LocalGivenEqs: definitely no Given equalities that would affect principal types. But may have equalities that affect only skolems of this implication (and hence do not affect princial types) Examples: forall a. F a ~ Int => ... forall a b. F a ~ G b => ... * MaybeGivenEqs: may have Given equalities that would affect principal types Examples: forall. (a ~ b) => ... forall a. F a ~ b => ... forall a. c a => ... -- The 'c' might be instantiated to (b ~) forall a. C a b => .... where class x~y => C a b so there is an equality in the superclass of a Given The HasGivenEqs classifications affect two things: * Suppressing redundant givens during error reporting; see GHC.Tc.Errors Note [Suppress redundant givens during error reporting] * Floating in approximateWC. Specifically, here's how it goes: Stops floating | Suppresses Givens in errors in approximateWC | ----------------------------------------------- NoGivenEqs NO | YES LocalGivenEqs NO | NO MaybeGivenEqs YES | NO -} instance Outputable Implication where ppr :: Implication -> SDoc ppr (Implic { ic_tclvl :: Implication -> TcLevel ic_tclvl = TcLevel tclvl, ic_skols :: Implication -> [EvVar] ic_skols = [EvVar] skols , ic_given :: Implication -> [EvVar] ic_given = [EvVar] given, ic_given_eqs :: Implication -> HasGivenEqs ic_given_eqs = HasGivenEqs given_eqs , ic_wanted :: Implication -> WantedConstraints ic_wanted = WantedConstraints wanted, ic_status :: Implication -> ImplicStatus ic_status = ImplicStatus status , ic_binds :: Implication -> EvBindsVar ic_binds = EvBindsVar binds , ic_need_inner :: Implication -> TcTyCoVarSet ic_need_inner = TcTyCoVarSet need_in, ic_need_outer :: Implication -> TcTyCoVarSet ic_need_outer = TcTyCoVarSet need_out , ic_info :: Implication -> SkolemInfo ic_info = SkolemInfo info }) = SDoc -> Int -> SDoc -> SDoc hang (String -> SDoc text String "Implic" SDoc -> SDoc -> SDoc <+> SDoc lbrace) Int 2 ([SDoc] -> SDoc sep [ String -> SDoc text String "TcLevel =" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr TcLevel tclvl , String -> SDoc text String "Skolems =" SDoc -> SDoc -> SDoc <+> [EvVar] -> SDoc pprTyVars [EvVar] skols , String -> SDoc text String "Given-eqs =" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr HasGivenEqs given_eqs , String -> SDoc text String "Status =" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr ImplicStatus status , SDoc -> Int -> SDoc -> SDoc hang (String -> SDoc text String "Given =") Int 2 ([EvVar] -> SDoc pprEvVars [EvVar] given) , SDoc -> Int -> SDoc -> SDoc hang (String -> SDoc text String "Wanted =") Int 2 (forall a. Outputable a => a -> SDoc ppr WantedConstraints wanted) , String -> SDoc text String "Binds =" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr EvBindsVar binds , SDoc -> SDoc whenPprDebug (String -> SDoc text String "Needed inner =" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr TcTyCoVarSet need_in) , SDoc -> SDoc whenPprDebug (String -> SDoc text String "Needed outer =" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr TcTyCoVarSet need_out) , SkolemInfo -> SDoc pprSkolInfo SkolemInfo info ] SDoc -> SDoc -> SDoc <+> SDoc rbrace) instance Outputable ImplicStatus where ppr :: ImplicStatus -> SDoc ppr ImplicStatus IC_Insoluble = String -> SDoc text String "Insoluble" ppr ImplicStatus IC_BadTelescope = String -> SDoc text String "Bad telescope" ppr ImplicStatus IC_Unsolved = String -> SDoc text String "Unsolved" ppr (IC_Solved { ics_dead :: ImplicStatus -> [EvVar] ics_dead = [EvVar] dead }) = String -> SDoc text String "Solved" SDoc -> SDoc -> SDoc <+> (SDoc -> SDoc braces (String -> SDoc text String "Dead givens =" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr [EvVar] dead)) checkTelescopeSkol :: SkolemInfo -> Bool -- See Note [Checking telescopes] checkTelescopeSkol :: SkolemInfo -> Bool checkTelescopeSkol (ForAllSkol {}) = Bool True checkTelescopeSkol SkolemInfo _ = Bool False instance Outputable HasGivenEqs where ppr :: HasGivenEqs -> SDoc ppr HasGivenEqs NoGivenEqs = String -> SDoc text String "NoGivenEqs" ppr HasGivenEqs LocalGivenEqs = String -> SDoc text String "LocalGivenEqs" ppr HasGivenEqs MaybeGivenEqs = String -> SDoc text String "MaybeGivenEqs" -- Used in GHC.Tc.Solver.Monad.getHasGivenEqs instance Semigroup HasGivenEqs where HasGivenEqs NoGivenEqs <> :: HasGivenEqs -> HasGivenEqs -> HasGivenEqs <> HasGivenEqs other = HasGivenEqs other HasGivenEqs other <> HasGivenEqs NoGivenEqs = HasGivenEqs other HasGivenEqs MaybeGivenEqs <> HasGivenEqs _other = HasGivenEqs MaybeGivenEqs HasGivenEqs _other <> HasGivenEqs MaybeGivenEqs = HasGivenEqs MaybeGivenEqs HasGivenEqs LocalGivenEqs <> HasGivenEqs LocalGivenEqs = HasGivenEqs LocalGivenEqs -- Used in GHC.Tc.Solver.Monad.getHasGivenEqs instance Monoid HasGivenEqs where mempty :: HasGivenEqs mempty = HasGivenEqs NoGivenEqs {- Note [Checking telescopes] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ When kind-checking a /user-written/ type, we might have a "bad telescope" like this one: data SameKind :: forall k. k -> k -> Type type Foo :: forall a k (b :: k). SameKind a b -> Type The kind of 'a' mentions 'k' which is bound after 'a'. Oops. One approach to doing this would be to bring each of a, k, and b into scope, one at a time, creating a separate implication constraint for each one, and bumping the TcLevel. This would work, because the kind of, say, a would be untouchable when k is in scope (and the constraint couldn't float out because k blocks it). However, it leads to terrible error messages, complaining about skolem escape. While it is indeed a problem of skolem escape, we can do better. Instead, our approach is to bring the block of variables into scope all at once, creating one implication constraint for the lot: * We make a single implication constraint when kind-checking the 'forall' in Foo's kind, something like forall a k (b::k). { wanted constraints } * Having solved {wanted}, before discarding the now-solved implication, the constraint solver checks the dependency order of the skolem variables (ic_skols). This is done in setImplicationStatus. * This check is only necessary if the implication was born from a 'forall' in a user-written signature (the HsForAllTy case in GHC.Tc.Gen.HsType. If, say, it comes from checking a pattern match that binds existentials, where the type of the data constructor is known to be valid (it in tcConPat), no need for the check. So the check is done /if and only if/ ic_info is ForAllSkol. * If ic_info is (ForAllSkol dt dvs), the dvs::SDoc displays the original, user-written type variables. * Be careful /NOT/ to discard an implication with a ForAllSkol ic_info, even if ic_wanted is empty. We must give the constraint solver a chance to make that bad-telescope test! Hence the extra guard in emitResidualTvConstraint; see #16247 * Don't mix up inferred and explicit variables in the same implication constraint. E.g. foo :: forall a kx (b :: kx). SameKind a b We want an implication Implic { ic_skol = [(a::kx), kx, (b::kx)], ... } but GHC will attempt to quantify over kx, since it is free in (a::kx), and it's hopelessly confusing to report an error about quantified variables kx (a::kx) kx (b::kx). Instead, the outer quantification over kx should be in a separate implication. TL;DR: an explicit forall should generate an implication quantified only over those explicitly quantified variables. Note [Needed evidence variables] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Th ic_need_evs field holds the free vars of ic_binds, and all the ic_binds in nested implications. * Main purpose: if one of the ic_givens is not mentioned in here, it is redundant. * solveImplication may drop an implication altogether if it has no remaining 'wanteds'. But we still track the free vars of its evidence binds, even though it has now disappeared. Note [Shadowing in a constraint] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We assume NO SHADOWING in a constraint. Specifically * The unification variables are all implicitly quantified at top level, and are all unique * The skolem variables bound in ic_skols are all freah when the implication is created. So we can safely substitute. For example, if we have forall a. a~Int => ...(forall b. ...a...)... we can push the (a~Int) constraint inwards in the "givens" without worrying that 'b' might clash. Note [Skolems in an implication] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The skolems in an implication are used: * When considering floating a constraint outside the implication in GHC.Tc.Solver.floatEqualities or GHC.Tc.Solver.approximateImplications For this, we can treat ic_skols as a set. * When checking that a /user-specified/ forall (ic_info = ForAllSkol tvs) has its variables in the correct order; see Note [Checking telescopes]. Only for these implications does ic_skols need to be a list. Nota bene: Although ic_skols is a list, it is not necessarily in dependency order: - In the ic_info=ForAllSkol case, the user might have written them in the wrong order - In the case of a type signature like f :: [a] -> [b] the renamer gathers the implicit "outer" forall'd variables {a,b}, but does not know what order to put them in. The type checker can sort them into dependency order, but only after solving all the kind constraints; and to do that it's convenient to create the Implication! So we accept that ic_skols may be out of order. Think of it as a set or (in the case of ic_info=ForAllSkol, a list in user-specified, and possibly wrong, order. Note [Insoluble constraints] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Some of the errors that we get during canonicalization are best reported when all constraints have been simplified as much as possible. For instance, assume that during simplification the following constraints arise: [Wanted] F alpha ~ uf1 [Wanted] beta ~ uf1 beta When canonicalizing the wanted (beta ~ uf1 beta), if we eagerly fail we will simply see a message: 'Can't construct the infinite type beta ~ uf1 beta' and the user has no idea what the uf1 variable is. Instead our plan is that we will NOT fail immediately, but: (1) Record the "frozen" error in the ic_insols field (2) Isolate the offending constraint from the rest of the inerts (3) Keep on simplifying/canonicalizing At the end, we will hopefully have substituted uf1 := F alpha, and we will be able to report a more informative error: 'Can't construct the infinite type beta ~ F alpha beta' Insoluble constraints *do* include Derived constraints. For example, a functional dependency might give rise to [D] Int ~ Bool, and we must report that. If insolubles did not contain Deriveds, reportErrors would never see it. ************************************************************************ * * Pretty printing * * ************************************************************************ -} pprEvVars :: [EvVar] -> SDoc -- Print with their types pprEvVars :: [EvVar] -> SDoc pprEvVars [EvVar] ev_vars = [SDoc] -> SDoc vcat (forall a b. (a -> b) -> [a] -> [b] map EvVar -> SDoc pprEvVarWithType [EvVar] ev_vars) pprEvVarTheta :: [EvVar] -> SDoc pprEvVarTheta :: [EvVar] -> SDoc pprEvVarTheta [EvVar] ev_vars = [Xi] -> SDoc pprTheta (forall a b. (a -> b) -> [a] -> [b] map EvVar -> Xi evVarPred [EvVar] ev_vars) pprEvVarWithType :: EvVar -> SDoc pprEvVarWithType :: EvVar -> SDoc pprEvVarWithType EvVar v = forall a. Outputable a => a -> SDoc ppr EvVar v SDoc -> SDoc -> SDoc <+> SDoc dcolon SDoc -> SDoc -> SDoc <+> Xi -> SDoc pprType (EvVar -> Xi evVarPred EvVar v) wrapType :: Type -> [TyVar] -> [PredType] -> Type wrapType :: Xi -> [EvVar] -> [Xi] -> Xi wrapType Xi ty [EvVar] skols [Xi] givens = [EvVar] -> Xi -> Xi mkSpecForAllTys [EvVar] skols forall a b. (a -> b) -> a -> b $ [Xi] -> Xi -> Xi mkPhiTy [Xi] givens Xi ty {- ************************************************************************ * * CtEvidence * * ************************************************************************ Note [Evidence field of CtEvidence] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ During constraint solving we never look at the type of ctev_evar/ctev_dest; instead we look at the ctev_pred field. The evtm/evar field may be un-zonked. Note [Bind new Givens immediately] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ For Givens we make new EvVars and bind them immediately. Two main reasons: * Gain sharing. E.g. suppose we start with g :: C a b, where class D a => C a b class (E a, F a) => D a If we generate all g's superclasses as separate EvTerms we might get selD1 (selC1 g) :: E a selD2 (selC1 g) :: F a selC1 g :: D a which we could do more economically as: g1 :: D a = selC1 g g2 :: E a = selD1 g1 g3 :: F a = selD2 g1 * For *coercion* evidence we *must* bind each given: class (a~b) => C a b where .... f :: C a b => .... Then in f's Givens we have g:(C a b) and the superclass sc(g,0):a~b. But that superclass selector can't (yet) appear in a coercion (see evTermCoercion), so the easy thing is to bind it to an Id. So a Given has EvVar inside it rather than (as previously) an EvTerm. -} -- | A place for type-checking evidence to go after it is generated. -- Wanted equalities are always HoleDest; other wanteds are always -- EvVarDest. data TcEvDest = EvVarDest EvVar -- ^ bind this var to the evidence -- EvVarDest is always used for non-type-equalities -- e.g. class constraints | HoleDest CoercionHole -- ^ fill in this hole with the evidence -- HoleDest is always used for type-equalities -- See Note [Coercion holes] in GHC.Core.TyCo.Rep data CtEvidence = CtGiven -- Truly given, not depending on subgoals { CtEvidence -> Xi ctev_pred :: TcPredType -- See Note [Ct/evidence invariant] , CtEvidence -> EvVar ctev_evar :: EvVar -- See Note [Evidence field of CtEvidence] , CtEvidence -> CtLoc ctev_loc :: CtLoc } | CtWanted -- Wanted goal { ctev_pred :: TcPredType -- See Note [Ct/evidence invariant] , CtEvidence -> TcEvDest ctev_dest :: TcEvDest , CtEvidence -> ShadowInfo ctev_nosh :: ShadowInfo -- See Note [Constraint flavours] , ctev_loc :: CtLoc } | CtDerived -- A goal that we don't really have to solve and can't -- immediately rewrite anything other than a derived -- (there's no evidence!) but if we do manage to solve -- it may help in solving other goals. { ctev_pred :: TcPredType , ctev_loc :: CtLoc } ctEvPred :: CtEvidence -> TcPredType -- The predicate of a flavor ctEvPred :: CtEvidence -> Xi ctEvPred = CtEvidence -> Xi ctev_pred ctEvLoc :: CtEvidence -> CtLoc ctEvLoc :: CtEvidence -> CtLoc ctEvLoc = CtEvidence -> CtLoc ctev_loc ctEvOrigin :: CtEvidence -> CtOrigin ctEvOrigin :: CtEvidence -> CtOrigin ctEvOrigin = CtLoc -> CtOrigin ctLocOrigin forall b c a. (b -> c) -> (a -> b) -> a -> c . CtEvidence -> CtLoc ctEvLoc -- | Get the equality relation relevant for a 'CtEvidence' ctEvEqRel :: CtEvidence -> EqRel ctEvEqRel :: CtEvidence -> EqRel ctEvEqRel = Xi -> EqRel predTypeEqRel forall b c a. (b -> c) -> (a -> b) -> a -> c . CtEvidence -> Xi ctEvPred -- | Get the role relevant for a 'CtEvidence' ctEvRole :: CtEvidence -> Role ctEvRole :: CtEvidence -> Role ctEvRole = EqRel -> Role eqRelRole forall b c a. (b -> c) -> (a -> b) -> a -> c . CtEvidence -> EqRel ctEvEqRel ctEvTerm :: CtEvidence -> EvTerm ctEvTerm :: CtEvidence -> EvTerm ctEvTerm CtEvidence ev = EvExpr -> EvTerm EvExpr (CtEvidence -> EvExpr ctEvExpr CtEvidence ev) ctEvExpr :: CtEvidence -> EvExpr ctEvExpr :: CtEvidence -> EvExpr ctEvExpr ev :: CtEvidence ev@(CtWanted { ctev_dest :: CtEvidence -> TcEvDest ctev_dest = HoleDest CoercionHole _ }) = forall b. Coercion -> Expr b Coercion forall a b. (a -> b) -> a -> b $ HasDebugCallStack => CtEvidence -> Coercion ctEvCoercion CtEvidence ev ctEvExpr CtEvidence ev = EvVar -> EvExpr evId (CtEvidence -> EvVar ctEvEvId CtEvidence ev) ctEvCoercion :: HasDebugCallStack => CtEvidence -> TcCoercion ctEvCoercion :: HasDebugCallStack => CtEvidence -> Coercion ctEvCoercion (CtGiven { ctev_evar :: CtEvidence -> EvVar ctev_evar = EvVar ev_id }) = EvVar -> Coercion mkTcCoVarCo EvVar ev_id ctEvCoercion (CtWanted { ctev_dest :: CtEvidence -> TcEvDest ctev_dest = TcEvDest dest }) | HoleDest CoercionHole hole <- TcEvDest dest = -- ctEvCoercion is only called on type equalities -- and they always have HoleDests CoercionHole -> Coercion mkHoleCo CoercionHole hole ctEvCoercion CtEvidence ev = forall a. HasCallStack => String -> SDoc -> a pprPanic String "ctEvCoercion" (forall a. Outputable a => a -> SDoc ppr CtEvidence ev) ctEvEvId :: CtEvidence -> EvVar ctEvEvId :: CtEvidence -> EvVar ctEvEvId (CtWanted { ctev_dest :: CtEvidence -> TcEvDest ctev_dest = EvVarDest EvVar ev }) = EvVar ev ctEvEvId (CtWanted { ctev_dest :: CtEvidence -> TcEvDest ctev_dest = HoleDest CoercionHole h }) = CoercionHole -> EvVar coHoleCoVar CoercionHole h ctEvEvId (CtGiven { ctev_evar :: CtEvidence -> EvVar ctev_evar = EvVar ev }) = EvVar ev ctEvEvId ctev :: CtEvidence ctev@(CtDerived {}) = forall a. HasCallStack => String -> SDoc -> a pprPanic String "ctEvId:" (forall a. Outputable a => a -> SDoc ppr CtEvidence ctev) instance Outputable TcEvDest where ppr :: TcEvDest -> SDoc ppr (HoleDest CoercionHole h) = String -> SDoc text String "hole" SDoc -> SDoc -> SDoc <> forall a. Outputable a => a -> SDoc ppr CoercionHole h ppr (EvVarDest EvVar ev) = forall a. Outputable a => a -> SDoc ppr EvVar ev instance Outputable CtEvidence where ppr :: CtEvidence -> SDoc ppr CtEvidence ev = forall a. Outputable a => a -> SDoc ppr (CtEvidence -> CtFlavour ctEvFlavour CtEvidence ev) SDoc -> SDoc -> SDoc <+> SDoc pp_ev SDoc -> SDoc -> SDoc <+> SDoc -> SDoc braces (forall a. Outputable a => a -> SDoc ppr (CtLoc -> SubGoalDepth ctl_depth (CtEvidence -> CtLoc ctEvLoc CtEvidence ev))) -- Show the sub-goal depth too SDoc -> SDoc -> SDoc <> SDoc dcolon SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr (CtEvidence -> Xi ctEvPred CtEvidence ev) where pp_ev :: SDoc pp_ev = case CtEvidence ev of CtGiven { ctev_evar :: CtEvidence -> EvVar ctev_evar = EvVar v } -> forall a. Outputable a => a -> SDoc ppr EvVar v CtWanted {ctev_dest :: CtEvidence -> TcEvDest ctev_dest = TcEvDest d } -> forall a. Outputable a => a -> SDoc ppr TcEvDest d CtDerived {} -> String -> SDoc text String "_" isWanted :: CtEvidence -> Bool isWanted :: CtEvidence -> Bool isWanted (CtWanted {}) = Bool True isWanted CtEvidence _ = Bool False isGiven :: CtEvidence -> Bool isGiven :: CtEvidence -> Bool isGiven (CtGiven {}) = Bool True isGiven CtEvidence _ = Bool False isDerived :: CtEvidence -> Bool isDerived :: CtEvidence -> Bool isDerived (CtDerived {}) = Bool True isDerived CtEvidence _ = Bool False {- %************************************************************************ %* * CtFlavour %* * %************************************************************************ Note [Constraint flavours] ~~~~~~~~~~~~~~~~~~~~~~~~~~ Constraints come in four flavours: * [G] Given: we have evidence * [W] Wanted WOnly: we want evidence * [D] Derived: any solution must satisfy this constraint, but we don't need evidence for it. Examples include: - superclasses of [W] class constraints - equalities arising from functional dependencies or injectivity * [WD] Wanted WDeriv: a single constraint that represents both [W] and [D] We keep them paired as one both for efficiency The ctev_nosh field of a Wanted distinguishes between [W] and [WD] Wanted constraints are born as [WD], but are split into [W] and its "shadow" [D] in GHC.Tc.Solver.Monad.maybeEmitShadow. See Note [The improvement story and derived shadows] in GHC.Tc.Solver.Monad -} data CtFlavour -- See Note [Constraint flavours] = Given | Wanted ShadowInfo | Derived deriving CtFlavour -> CtFlavour -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: CtFlavour -> CtFlavour -> Bool $c/= :: CtFlavour -> CtFlavour -> Bool == :: CtFlavour -> CtFlavour -> Bool $c== :: CtFlavour -> CtFlavour -> Bool Eq data ShadowInfo = WDeriv -- [WD] This Wanted constraint has no Derived shadow, -- so it behaves like a pair of a Wanted and a Derived | WOnly -- [W] It has a separate derived shadow -- See Note [The improvement story and derived shadows] in GHC.Tc.Solver.Monad deriving( ShadowInfo -> ShadowInfo -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: ShadowInfo -> ShadowInfo -> Bool $c/= :: ShadowInfo -> ShadowInfo -> Bool == :: ShadowInfo -> ShadowInfo -> Bool $c== :: ShadowInfo -> ShadowInfo -> Bool Eq ) instance Outputable CtFlavour where ppr :: CtFlavour -> SDoc ppr CtFlavour Given = String -> SDoc text String "[G]" ppr (Wanted ShadowInfo WDeriv) = String -> SDoc text String "[WD]" ppr (Wanted ShadowInfo WOnly) = String -> SDoc text String "[W]" ppr CtFlavour Derived = String -> SDoc text String "[D]" -- | Does this 'CtFlavour' subsumed 'Derived'? True of @[WD]@ and @[D]@. ctFlavourContainsDerived :: CtFlavour -> Bool ctFlavourContainsDerived :: CtFlavour -> Bool ctFlavourContainsDerived (Wanted ShadowInfo WDeriv) = Bool True ctFlavourContainsDerived CtFlavour Derived = Bool True ctFlavourContainsDerived CtFlavour _ = Bool False ctEvFlavour :: CtEvidence -> CtFlavour ctEvFlavour :: CtEvidence -> CtFlavour ctEvFlavour (CtWanted { ctev_nosh :: CtEvidence -> ShadowInfo ctev_nosh = ShadowInfo nosh }) = ShadowInfo -> CtFlavour Wanted ShadowInfo nosh ctEvFlavour (CtGiven {}) = CtFlavour Given ctEvFlavour (CtDerived {}) = CtFlavour Derived -- | Whether or not one 'Ct' can rewrite another is determined by its -- flavour and its equality relation. See also -- Note [Flavours with roles] in "GHC.Tc.Solver.Monad" type CtFlavourRole = (CtFlavour, EqRel) -- | Extract the flavour, role, and boxity from a 'CtEvidence' ctEvFlavourRole :: CtEvidence -> CtFlavourRole ctEvFlavourRole :: CtEvidence -> CtFlavourRole ctEvFlavourRole CtEvidence ev = (CtEvidence -> CtFlavour ctEvFlavour CtEvidence ev, CtEvidence -> EqRel ctEvEqRel CtEvidence ev) -- | Extract the flavour and role from a 'Ct' ctFlavourRole :: Ct -> CtFlavourRole -- Uses short-cuts to role for special cases ctFlavourRole :: Ct -> CtFlavourRole ctFlavourRole (CDictCan { cc_ev :: Ct -> CtEvidence cc_ev = CtEvidence ev }) = (CtEvidence -> CtFlavour ctEvFlavour CtEvidence ev, EqRel NomEq) ctFlavourRole (CEqCan { cc_ev :: Ct -> CtEvidence cc_ev = CtEvidence ev, cc_eq_rel :: Ct -> EqRel cc_eq_rel = EqRel eq_rel }) = (CtEvidence -> CtFlavour ctEvFlavour CtEvidence ev, EqRel eq_rel) ctFlavourRole Ct ct = CtEvidence -> CtFlavourRole ctEvFlavourRole (Ct -> CtEvidence ctEvidence Ct ct) {- Note [eqCanRewrite] ~~~~~~~~~~~~~~~~~~~~~~ (eqCanRewrite ct1 ct2) holds if the constraint ct1 (a CEqCan of form lhs ~ ty) can be used to rewrite ct2. It must satisfy the properties of a can-rewrite relation, see Definition [Can-rewrite relation] in GHC.Tc.Solver.Monad. With the solver handling Coercible constraints like equality constraints, the rewrite conditions must take role into account, never allowing a representational equality to rewrite a nominal one. Note [Wanteds do not rewrite Wanteds] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We don't allow Wanteds to rewrite Wanteds, because that can give rise to very confusing type error messages. A good example is #8450. Here's another f :: a -> Bool f x = ( [x,'c'], [x,True] ) `seq` True Here we get [W] a ~ Char [W] a ~ Bool but we do not want to complain about Bool ~ Char! Note [Deriveds do rewrite Deriveds] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ However we DO allow Deriveds to rewrite Deriveds, because that's how improvement works; see Note [The improvement story] in GHC.Tc.Solver.Interact. However, for now at least I'm only letting (Derived,NomEq) rewrite (Derived,NomEq) and not doing anything for ReprEq. If we have eqCanRewriteFR (Derived, NomEq) (Derived, _) = True then we lose property R2 of Definition [Can-rewrite relation] in GHC.Tc.Solver.Monad R2. If f1 >= f, and f2 >= f, then either f1 >= f2 or f2 >= f1 Consider f1 = (Given, ReprEq) f2 = (Derived, NomEq) f = (Derived, ReprEq) I thought maybe we could never get Derived ReprEq constraints, but we can; straight from the Wanteds during improvement. And from a Derived ReprEq we could conceivably get a Derived NomEq improvement (by decomposing a type constructor with Nomninal role), and hence unify. This restriction that (Derived, NomEq) cannot rewrite (Derived, ReprEq) bites, in an obscure scenario: data T a type role T nominal type family F a g :: forall b a. (F a ~ T a, Coercible (F a) (T b)) => () g = () f :: forall a. (F a ~ T a) => () f = g @a The problem is in the body of f. We have [G] F a ~N T a [WD] F alpha ~N T alpha [WD] F alpha ~R T a The Wanteds aren't of use, so let's just look at Deriveds: [G] F a ~N T a [D] F alpha ~N T alpha [D] F alpha ~R T a As written, this makes no progress, and GHC errors. But, if we allowed D/N to rewrite D/R, the first D could rewrite the second: [G] F a ~N T a [D] F alpha ~N T alpha [D] T alpha ~R T a Now we decompose the second D to get [D] alpha ~N a noting the role annotation on T. This causes (alpha := a), and then everything else unlocks. What to do? We could "decompose" nominal equalities into nominal-only ("NO") equalities and representational ones, where a NO equality rewrites only nominals. That is, when considering whether [D] F alpha ~N T alpha should rewrite [D] F alpha ~R T a, we could require splitting the first D into [D] F alpha ~NO T alpha, [D] F alpha ~R T alpha. Then, we use the R half of the split to rewrite the second D, and off we go. This splitting would allow the split-off R equality to be rewritten by other equalities, thus avoiding the problem in Note [Why R2?] in GHC.Tc.Solver.Monad. This infelicity is #19665 and tested in typecheck/should_compile/T19665 (marked as expect_broken). -} eqCanRewrite :: EqRel -> EqRel -> Bool eqCanRewrite :: EqRel -> EqRel -> Bool eqCanRewrite EqRel NomEq EqRel _ = Bool True eqCanRewrite EqRel ReprEq EqRel ReprEq = Bool True eqCanRewrite EqRel ReprEq EqRel NomEq = Bool False eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool -- Can fr1 actually rewrite fr2? -- Very important function! -- See Note [eqCanRewrite] -- See Note [Wanteds do not rewrite Wanteds] -- See Note [Deriveds do rewrite Deriveds] eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool eqCanRewriteFR (CtFlavour Given, EqRel r1) (CtFlavour _, EqRel r2) = EqRel -> EqRel -> Bool eqCanRewrite EqRel r1 EqRel r2 eqCanRewriteFR (Wanted ShadowInfo WDeriv, EqRel NomEq) (CtFlavour Derived, EqRel NomEq) = Bool True eqCanRewriteFR (CtFlavour Derived, EqRel NomEq) (CtFlavour Derived, EqRel NomEq) = Bool True eqCanRewriteFR CtFlavourRole _ CtFlavourRole _ = Bool False eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool -- Is it /possible/ that fr1 can rewrite fr2? -- This is used when deciding which inerts to kick out, -- at which time a [WD] inert may be split into [W] and [D] eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool eqMayRewriteFR (Wanted ShadowInfo WDeriv, EqRel NomEq) (Wanted ShadowInfo WDeriv, EqRel NomEq) = Bool True eqMayRewriteFR (CtFlavour Derived, EqRel NomEq) (Wanted ShadowInfo WDeriv, EqRel NomEq) = Bool True eqMayRewriteFR CtFlavourRole fr1 CtFlavourRole fr2 = CtFlavourRole -> CtFlavourRole -> Bool eqCanRewriteFR CtFlavourRole fr1 CtFlavourRole fr2 {- Note [eqCanDischarge] ~~~~~~~~~~~~~~~~~~~~~~~~ Suppose we have two identical CEqCan equality constraints (i.e. both LHS and RHS are the same) (x1:lhs~t) `eqCanDischarge` (xs:lhs~t) Can we just drop x2 in favour of x1? Answer: yes if eqCanDischarge is true. Note that we do /not/ allow Wanted to discharge Derived. We must keep both. Why? Because the Derived may rewrite other Deriveds in the model whereas the Wanted cannot. However a Wanted can certainly discharge an identical Wanted. So eqCanDischarge does /not/ define a can-rewrite relation in the sense of Definition [Can-rewrite relation] in GHC.Tc.Solver.Monad. We /do/ say that a [W] can discharge a [WD]. In evidence terms it certainly can, and the /caller/ arranges that the otherwise-lost [D] is spat out as a new Derived. -} eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool -- See Note [eqCanDischarge] eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool eqCanDischargeFR (CtFlavour f1,EqRel r1) (CtFlavour f2, EqRel r2) = EqRel -> EqRel -> Bool eqCanRewrite EqRel r1 EqRel r2 Bool -> Bool -> Bool && CtFlavour -> CtFlavour -> Bool eqCanDischargeF CtFlavour f1 CtFlavour f2 eqCanDischargeF :: CtFlavour -> CtFlavour -> Bool eqCanDischargeF :: CtFlavour -> CtFlavour -> Bool eqCanDischargeF CtFlavour Given CtFlavour _ = Bool True eqCanDischargeF (Wanted ShadowInfo _) (Wanted ShadowInfo _) = Bool True eqCanDischargeF (Wanted ShadowInfo WDeriv) CtFlavour Derived = Bool True eqCanDischargeF CtFlavour Derived CtFlavour Derived = Bool True eqCanDischargeF CtFlavour _ CtFlavour _ = Bool False {- ************************************************************************ * * SubGoalDepth * * ************************************************************************ Note [SubGoalDepth] ~~~~~~~~~~~~~~~~~~~ The 'SubGoalDepth' takes care of stopping the constraint solver from looping. The counter starts at zero and increases. It includes dictionary constraints, equality simplification, and type family reduction. (Why combine these? Because it's actually quite easy to mistake one for another, in sufficiently involved scenarios, like ConstraintKinds.) The flag -freduction-depth=n fixes the maximium level. * The counter includes the depth of type class instance declarations. Example: [W] d{7} : Eq [Int] That is d's dictionary-constraint depth is 7. If we use the instance $dfEqList :: Eq a => Eq [a] to simplify it, we get d{7} = $dfEqList d'{8} where d'{8} : Eq Int, and d' has depth 8. For civilised (decidable) instance declarations, each increase of depth removes a type constructor from the type, so the depth never gets big; i.e. is bounded by the structural depth of the type. * The counter also increments when resolving equalities involving type functions. Example: Assume we have a wanted at depth 7: [W] d{7} : F () ~ a If there is a type function equation "F () = Int", this would be rewritten to [W] d{8} : Int ~ a and remembered as having depth 8. Again, without UndecidableInstances, this counter is bounded, but without it can resolve things ad infinitum. Hence there is a maximum level. * Lastly, every time an equality is rewritten, the counter increases. Again, rewriting an equality constraint normally makes progress, but it's possible the "progress" is just the reduction of an infinitely-reducing type family. Hence we need to track the rewrites. When compiling a program requires a greater depth, then GHC recommends turning off this check entirely by setting -freduction-depth=0. This is because the exact number that works is highly variable, and is likely to change even between minor releases. Because this check is solely to prevent infinite compilation times, it seems safe to disable it when a user has ascertained that their program doesn't loop at the type level. -} -- | See Note [SubGoalDepth] newtype SubGoalDepth = SubGoalDepth Int deriving (SubGoalDepth -> SubGoalDepth -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: SubGoalDepth -> SubGoalDepth -> Bool $c/= :: SubGoalDepth -> SubGoalDepth -> Bool == :: SubGoalDepth -> SubGoalDepth -> Bool $c== :: SubGoalDepth -> SubGoalDepth -> Bool Eq, Eq SubGoalDepth SubGoalDepth -> SubGoalDepth -> Bool SubGoalDepth -> SubGoalDepth -> Ordering SubGoalDepth -> SubGoalDepth -> SubGoalDepth forall a. Eq a -> (a -> a -> Ordering) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> a) -> (a -> a -> a) -> Ord a min :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth $cmin :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth max :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth $cmax :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth >= :: SubGoalDepth -> SubGoalDepth -> Bool $c>= :: SubGoalDepth -> SubGoalDepth -> Bool > :: SubGoalDepth -> SubGoalDepth -> Bool $c> :: SubGoalDepth -> SubGoalDepth -> Bool <= :: SubGoalDepth -> SubGoalDepth -> Bool $c<= :: SubGoalDepth -> SubGoalDepth -> Bool < :: SubGoalDepth -> SubGoalDepth -> Bool $c< :: SubGoalDepth -> SubGoalDepth -> Bool compare :: SubGoalDepth -> SubGoalDepth -> Ordering $ccompare :: SubGoalDepth -> SubGoalDepth -> Ordering Ord, SubGoalDepth -> SDoc forall a. (a -> SDoc) -> Outputable a ppr :: SubGoalDepth -> SDoc $cppr :: SubGoalDepth -> SDoc Outputable) initialSubGoalDepth :: SubGoalDepth initialSubGoalDepth :: SubGoalDepth initialSubGoalDepth = Int -> SubGoalDepth SubGoalDepth Int 0 bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth bumpSubGoalDepth (SubGoalDepth Int n) = Int -> SubGoalDepth SubGoalDepth (Int n forall a. Num a => a -> a -> a + Int 1) maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth maxSubGoalDepth (SubGoalDepth Int n) (SubGoalDepth Int m) = Int -> SubGoalDepth SubGoalDepth (Int n forall a. Ord a => a -> a -> a `max` Int m) subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool subGoalDepthExceeded DynFlags dflags (SubGoalDepth Int d) = Int -> IntWithInf mkIntWithInf Int d forall a. Ord a => a -> a -> Bool > DynFlags -> IntWithInf reductionDepth DynFlags dflags {- ************************************************************************ * * CtLoc * * ************************************************************************ The 'CtLoc' gives information about where a constraint came from. This is important for decent error message reporting because dictionaries don't appear in the original source code. type will evolve... -} data CtLoc = CtLoc { CtLoc -> CtOrigin ctl_origin :: CtOrigin , CtLoc -> TcLclEnv ctl_env :: TcLclEnv , CtLoc -> Maybe TypeOrKind ctl_t_or_k :: Maybe TypeOrKind -- OK if we're not sure , CtLoc -> SubGoalDepth ctl_depth :: !SubGoalDepth } -- The TcLclEnv includes particularly -- source location: tcl_loc :: RealSrcSpan -- context: tcl_ctxt :: [ErrCtxt] -- binder stack: tcl_bndrs :: TcBinderStack -- level: tcl_tclvl :: TcLevel mkKindLoc :: TcType -> TcType -- original *types* being compared -> CtLoc -> CtLoc mkKindLoc :: Xi -> Xi -> CtLoc -> CtLoc mkKindLoc Xi s1 Xi s2 CtLoc loc = CtLoc -> CtOrigin -> CtLoc setCtLocOrigin (CtLoc -> CtLoc toKindLoc CtLoc loc) (Xi -> Xi -> CtOrigin -> Maybe TypeOrKind -> CtOrigin KindEqOrigin Xi s1 Xi s2 (CtLoc -> CtOrigin ctLocOrigin CtLoc loc) (CtLoc -> Maybe TypeOrKind ctLocTypeOrKind_maybe CtLoc loc)) -- | Take a CtLoc and moves it to the kind level toKindLoc :: CtLoc -> CtLoc toKindLoc :: CtLoc -> CtLoc toKindLoc CtLoc loc = CtLoc loc { ctl_t_or_k :: Maybe TypeOrKind ctl_t_or_k = forall a. a -> Maybe a Just TypeOrKind KindLevel } mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc mkGivenLoc TcLevel tclvl SkolemInfo skol_info TcLclEnv env = CtLoc { ctl_origin :: CtOrigin ctl_origin = SkolemInfo -> CtOrigin GivenOrigin SkolemInfo skol_info , ctl_env :: TcLclEnv ctl_env = TcLclEnv -> TcLevel -> TcLclEnv setLclEnvTcLevel TcLclEnv env TcLevel tclvl , ctl_t_or_k :: Maybe TypeOrKind ctl_t_or_k = forall a. Maybe a Nothing -- this only matters for error msgs , ctl_depth :: SubGoalDepth ctl_depth = SubGoalDepth initialSubGoalDepth } ctLocEnv :: CtLoc -> TcLclEnv ctLocEnv :: CtLoc -> TcLclEnv ctLocEnv = CtLoc -> TcLclEnv ctl_env ctLocLevel :: CtLoc -> TcLevel ctLocLevel :: CtLoc -> TcLevel ctLocLevel CtLoc loc = TcLclEnv -> TcLevel getLclEnvTcLevel (CtLoc -> TcLclEnv ctLocEnv CtLoc loc) ctLocDepth :: CtLoc -> SubGoalDepth ctLocDepth :: CtLoc -> SubGoalDepth ctLocDepth = CtLoc -> SubGoalDepth ctl_depth ctLocOrigin :: CtLoc -> CtOrigin ctLocOrigin :: CtLoc -> CtOrigin ctLocOrigin = CtLoc -> CtOrigin ctl_origin ctLocSpan :: CtLoc -> RealSrcSpan ctLocSpan :: CtLoc -> RealSrcSpan ctLocSpan (CtLoc { ctl_env :: CtLoc -> TcLclEnv ctl_env = TcLclEnv lcl}) = TcLclEnv -> RealSrcSpan getLclEnvLoc TcLclEnv lcl ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind ctLocTypeOrKind_maybe = CtLoc -> Maybe TypeOrKind ctl_t_or_k setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc setCtLocSpan ctl :: CtLoc ctl@(CtLoc { ctl_env :: CtLoc -> TcLclEnv ctl_env = TcLclEnv lcl }) RealSrcSpan loc = CtLoc -> TcLclEnv -> CtLoc setCtLocEnv CtLoc ctl (TcLclEnv -> RealSrcSpan -> TcLclEnv setLclEnvLoc TcLclEnv lcl RealSrcSpan loc) bumpCtLocDepth :: CtLoc -> CtLoc bumpCtLocDepth :: CtLoc -> CtLoc bumpCtLocDepth loc :: CtLoc loc@(CtLoc { ctl_depth :: CtLoc -> SubGoalDepth ctl_depth = SubGoalDepth d }) = CtLoc loc { ctl_depth :: SubGoalDepth ctl_depth = SubGoalDepth -> SubGoalDepth bumpSubGoalDepth SubGoalDepth d } setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc setCtLocOrigin CtLoc ctl CtOrigin orig = CtLoc ctl { ctl_origin :: CtOrigin ctl_origin = CtOrigin orig } updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc updateCtLocOrigin ctl :: CtLoc ctl@(CtLoc { ctl_origin :: CtLoc -> CtOrigin ctl_origin = CtOrigin orig }) CtOrigin -> CtOrigin upd = CtLoc ctl { ctl_origin :: CtOrigin ctl_origin = CtOrigin -> CtOrigin upd CtOrigin orig } setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc setCtLocEnv CtLoc ctl TcLclEnv env = CtLoc ctl { ctl_env :: TcLclEnv ctl_env = TcLclEnv env } pprCtLoc :: CtLoc -> SDoc -- "arising from ... at ..." -- Not an instance of Outputable because of the "arising from" prefix pprCtLoc :: CtLoc -> SDoc pprCtLoc (CtLoc { ctl_origin :: CtLoc -> CtOrigin ctl_origin = CtOrigin o, ctl_env :: CtLoc -> TcLclEnv ctl_env = TcLclEnv lcl}) = [SDoc] -> SDoc sep [ CtOrigin -> SDoc pprCtOrigin CtOrigin o , String -> SDoc text String "at" SDoc -> SDoc -> SDoc <+> forall a. Outputable a => a -> SDoc ppr (TcLclEnv -> RealSrcSpan getLclEnvLoc TcLclEnv lcl)]