import GHC.Core.Unify     ( tcMatchTy )

 import GHC.Core.Rules

 import GHC.Core.Utils     ( exprIsTrivial, exprIsTopLevelBindable

                           , stripTicksTop, mkInScopeSetBndrs )

 import GHC.Core.FVs

 import GHC.Core.TyCo.FVs ( tyCoVarsOfTypeList )

 --      See Note [Inline specialisations] for why we do not

 --      switch off specialisation for inline functions

     foldlM spec_call ([], [], emptyUDs) calls_for_me

   | otherwise   -- No calls or RHS doesn't fit our preconceptions

              , rule_bndrs, rule_lhs_args

              , spec_bndrs1, dx_binds, spec_args) <- specHeader env rhs_bndrs all_call_args

                [ text "fun:       "  <+> ppr fn

                , text "call info: "  <+> ppr _ci

                , text "useful:    "  <+> ppr useful

 mkCallUDs' env f args

   | wantCallsFor env f    -- We want it, and...

   , not (null ci_key)     -- this call site has a useful specialisation

     singleCall env f ci_key

   | otherwise  -- See also Note [Specialisations already covered]

     emptyUDs

   where

     pis                = fst $ splitPiTys $ idType f

     constrained_tyvars = tyCoVarsOfTypes $ getTheta pis

 because the code for the specialised f is not improved at all, because

 d is lambda-bound.  We simply get junk specialisations.

 Note [Update unfolding after specialisation]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Now `f` turns into:

   f @a @b (dd :: D a) (ds :: Show b) a b

      = let dc :: D a = %p1 dd  -- Superclass selection

        in meth @a dc ....

           meth @a dc ....

 the Rec case.)

 -}

 interestingDict :: InScopeEnv -> CoreExpr -> Bool

   = interestingDict env arg

   | Just (_, _, data_con, _tys, args) <- exprIsConApp_maybe env arg

   , Just cls <- tyConClass_maybe (dataConTyCon data_con)

     then any (interestingDict env) args

     else True

   | otherwise

   = False

 thenUDs :: UsageDetails -> UsageDetails -> UsageDetails

 thenUDs (MkUD {ud_binds = db1, ud_calls = calls1})

         (MkUD {ud_binds = db2, ud_calls = calls2})

   classMethodTy, classMethodInstTy,

   -- Implicit parameters

   isCallStackTy, isCallStackPred, isCallStackPredTy,

   isExceptionContextPred, isExceptionContextTy,

   isIPPred_maybe,

 typeDeterminesValue :: Type -> Bool

 -- See Note [Type determines value]

 getClassPredTys :: HasDebugCallStack => PredType -> (Class, [Type])

 getClassPredTys ty = case getClassPredTys_maybe ty of

   | otherwise

   = False

 --                 See Note [Local implicit parameters]

 -- Is `pred`, or any of its superclasses, an implicit parameter?

 -- See Note [Local implicit parameters]

 --

 --    - @cls tys@ is of the form @IP str ty@, where @str_cond str@ and @ty_cond ty@

 --      are both @True@,

 --    - or any superclass of @cls tys@ has this property.

 --

 -- See Note [Local implicit parameters]

   | Just (str_ty, ty) <- isIPPred_maybe cls tys

   = str_cond str_ty && ty_cond ty

   | otherwise

        | sc_sel_id <- classSCSelIds cls ]

   | Just (cls, tys) <- getClassPredTys_maybe ty

   , let tc = classTyCon cls

   , Just rec_clss' <- if isTupleTyCon tc then Just rec_clss

                       else checkRecTc rec_clss tc

   | otherwise

   = False -- Includes things like (D []) where D is

           -- a Constraint-ranged family; #7785

 See also wrinkle (SIP1) in Note [Shadowing of implicit parameters] in

 GHC.Tc.Solver.Dict.

 superclasses, is an implicit parameter.

 Why are implicit parameters special?  Unlike normal classes, we can

    let ?x = True in ...

 So in various places we must be careful not to assume that any value

 of the right type will do; we must carefully look for the innermost binding.

 a superclass that is an implicit parameter.

 Several wrinkles

   think nothing does.

 * I'm a little concerned about type variables; such a variable might

   be instantiated to an implicit parameter.  I don't think this

   obscure anyway.

 * The superclass hunt stops when it encounters the same class again,

   but in principle we could have the same class, differently instantiated,

   and the second time it could have an implicit parameter

 I'm going to treat these as problems for another day. They are all exotic.

   (1) to check that a predicate does not contain any implicit parameters

       IP str ty, for a fixed literal str and any type ty,

   | otherwise  = transCloVarSet mk_next seed_tcvs

   where

     seed_tcvs = tcvs `unionVarSet` tyCoVarsOfTypes ips

                          -- See Note [Inheriting implicit parameters]

     mk_next :: VarSet -> VarSet -- Maps current set to newly-grown ones

     -- programs should typecheck regardless of whether we take this step or

     -- not. See Note [Shortcut solving]

   , not (xopt LangExt.IncoherentInstances dflags)

     -- If IncoherentInstances is on then we cannot rely on coherence of proofs

      is_wsc_orig_w = isWantedSuperclassOrigin orig_w

      different_level_strategy  -- Both Given

        -- See Note [Replacement vs keeping] part (1)

        --                               in GHC.Tc.Solver.Dict

      same_level_strategy -- Both Given

     -- an implicit parameter (?str :: ty) for the given 'str' and any type 'ty'?

     does_not_mention_ip_for :: Type -> DictCt -> Bool

     does_not_mention_ip_for str_ty (DictCt { di_cls = cls, di_tys = tys })

         -- in GHC.Core.Predicate

 updInertIrreds :: IrredCt -> TcS ()

   = do { is_callstack    <- is_tyConTy isCallStackTy        callStackTyConName

        ; is_exceptionCtx <- is_tyConTy isExceptionContextTy exceptionContextTyConName

        ; let contains_callstack_or_exceptionCtx =

                  (const True)

                     -- NB: the name of the call-stack IP is irrelevant

                     -- e.g (?foo :: CallStack) counts!

     -- Return a predicate that decides whether a type is CallStack

     -- or ExceptionContext, accounting for e.g. type family reduction, as

     --

     is_tyConTy :: (Type -> Bool) -> Name -> TcS (Type -> Bool)

     is_tyConTy is_eq tc_name

       = do { (mb_tc, _) <- wrapTcS $ TcM.tryTc $ TcM.tcLookupTyCon tc_name

 See also Note [Shadowing of implicit parameters], which deals with a similar

 problem with Given implicit parameter constraints.

 To implement Note [Don't add HasCallStack constraints to the solved set],

 we need to check whether a constraint contains a HasCallStack or HasExceptionContext

 constraint. We do this using the 'mentionsIP' function, but as per

     (const True) -- (ignore the implicit parameter string)

     (isCallStackTy <||> isExceptionContextTy)

   mkTyConTy, mkTyVarTy, mkTyVarTys,

   mkTyCoVarTy, mkTyCoVarTys,

   isEqualityClass, mkClassPred,

   tcSplitQuantPredTy, tcSplitDFunTy, tcSplitDFunHead, tcSplitMethodTy,

   isRuntimeRepVar, isFixedRuntimeRepKind,

 pickCapturedPreds qtvs theta

   = filter captured theta

   where

 -- Superclasses