+    -- Binders of the stable unfolding template, if there is one.

+    -- See Note [Dead args and stable unfoldings]

+    unf_bndrs | isStableUnfolding fn_unf

+              , Just tmpl <- maybeUnfoldingTemplate fn_unf

+              = Just (fst (collectBinders tmpl))

+              | otherwise

+              = Nothing

+

+                 <- specHeader this_mod subst rhs_bndrs unf_bndrs all_call_args

+  big result tuple. We pass an absent filler, but only once we have checked

+  that the unfolding does not use the argument either.

+  See Note [Dead args and stable unfoldings]

+

+Note [Dead args and stable unfoldings]

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+specHeader decides an argument is dead with isDeadBinder on a binder of the

+optimised RHS, then applies the filler to the stable unfolding template instead.

+The two may differ, so the argument can be dead in the RHS and not in the

+template. See #27703 for an instance of this. The specialised function's

+unfolding then contains the filler, and any call site that inlines it evaluates

+the error thunk.

+It is not enough to ask whether the RHS binder occurs free in the template: the

+template has its own binders, so it never does. We must walk the arguments in

+lockstep. If the template runs out of binders, the RHS was eta-expanded past

+it, and we assume the argument is used.

+

+DmdAnal does the same job in addUnfoldingDemands. See Wrinkle (W3) of

+Note [Absence analysis for stable unfoldings and RULES].

+     -> Maybe [InBndr]

+                    -- Binders of f's stable unfolding template, if it has one

+                    -- See Note [Dead args and stable unfoldings]

+specHeader _ subst [] _ _  = pure (False, subst, [], [], [], [], [])

+specHeader _ subst _  _ [] = pure (False, subst, [], [], [], [], [])

+specHeader mod subst (bndr:bndrs) unf_bndrs (SpecType ty : args)

+             <- specHeader mod subst2 bndrs (fmap (drop 1) unf_bndrs) args

+specHeader mod subst (bndr:bndrs) unf_bndrs (UnspecType : args)

+             <- specHeader mod subst1 bndrs (fmap (drop 1) unf_bndrs) args

+specHeader mod subst (bndr:bndrs) unf_bndrs (_ : args)

+  , dead_in_unfolding unf_bndrs

+      -- See Note [Dead args and stable unfoldings]

+    do { (useful, subst2, rule_bs, rule_es, spec_bs, dx, spec_args)

+             <- specHeader mod subst1 bndrs (fmap (drop 1) unf_bndrs) args

+specHeader mod subst (bndr:bndrs) unf_bndrs (SpecDict dict_arg : args)

+       ; (_, subst3, rule_bs, rule_es, spec_bs, dx, spec_args)

+             <- specHeader mod subst2 bndrs (fmap (drop 1) unf_bndrs) args

+specHeader mod subst (bndr:bndrs) unf_bndrs (UnspecArg : args)

+       ; (useful, subst2, rule_bs, rule_es, spec_bs, dx, spec_args)

+             <- specHeader mod subst1 bndrs (fmap (drop 1) unf_bndrs) args

+dead_in_unfolding :: Maybe [InBndr] -> Bool

+-- ^ Is the argument at this position dead in the stable unfolding template?

+-- Nothing means there is no stable unfolding, so no filler can escape into one.

+-- If the template runs out of binders we cannot tell, so we say No.

+dead_in_unfolding Nothing                 = True

+dead_in_unfolding (Just (unf_bndr : _))   = isDeadBinder unf_bndr

+dead_in_unfolding (Just [])               = False

+

+import GHC.Core.Predicate( isEqualityClass )

+  | ConstraintLike <- typeTypeOrConstraint arg_ty

+cpe_rec_ids is module-local, so it does not catch a recursion that goes through

+an hs-boot import. Suppose Mid and Callee form a module loop, and Mid sees

+Callee through its hs-boot file:

+

+  -- Mid.hs

+  $fCAT = \ @a $dCB -> C:CA ($fxCBT $dCB) ...

+  -- Callee.hs

+  $fCBT = \ @a $dCB -> C:CB ($fCAT  $dCB) ...

+

+Neither module can see that these two call each other, so each looks

+non-recursive, and we speculate the inner call in both:

+

+  $fCAT = \ @a $dCB -> case $fxCBT $dCB of s { __DEFAULT -> C:CA s ... }

+  $fCBT = \ @a $dCB -> case $fCAT  $dCB of s { __DEFAULT -> C:CB s ... }

+

+Now each forces the other and the program loops. Such a cycle must cross an

+hs-boot edge, so we do not speculate a call whose callee has a BootUnfolding.

+Note [Inlining and hs-boot files] in GHC.CoreToIface does the same for

+infinite inlining.

+

+      | is_boot_call x                          = False

+    is_rec_call  = (`elemUnVarSet` cpe_rec_ids env)

+    is_boot_call = isBootUnfolding . realIdUnfolding

+      -- See Note [Speculative evaluation], Very Nasty Wrinkle

+{-# LANGUAGE GADTs, ConstraintKinds, ScopedTypeVariables #-}

+{-# OPTIONS_GHC -fno-worker-wrapper #-}

+module Callee where

+

+-- Not unary: a superclass field and a method field, so (Eq a) can be

+-- speculatively selected out of a (TC a) dictionary.

+class Eq a => TC a where

+  tcDummy :: a -> Int

+

+data W = W

+instance Eq W where _ == _ = True

+

+data Dict c where

+  Dict :: c => Dict c

+

+{-# NOINLINE discard #-}

+discard :: Dict c -> Int

+discard _ = 42

+

+-- Never forces its dictionary, so demand analysis marks it absent, and

+-- Caller's `a` inherits that absence.

+{-# NOINLINE b #-}

+b :: forall a. TC a => a -> Int

+b _ = discard (Dict :: Dict (Eq a))

+{-# LANGUAGE TypeFamilies, ConstraintKinds, FlexibleContexts #-}

+{-# LANGUAGE UndecidableInstances #-}

+module Caller where

+

+import Callee

+import Data.Kind (Constraint)

+

+-- A Constraint-kinded type family.  It reduces to (TC W), so the dictionary

+-- `a` receives really is a (TC W) dictionary; but (F W) is not class-headed,

+-- so isDictTy says False.  Worker/wrapper must still not replace it with a

+-- filler: Callee speculates a superclass selection out of it.

+type family F a :: Constraint

+type instance F W = TC W

+

+-- Note there is no `instance TC W` in scope here: `b W` must take its

+-- dictionary from this Given, rather than from an instance.

+{-# NOINLINE a #-}

+a :: F W => Int -> Int

+a x = b W + x

+module Inst where

+

+import Callee

+

+-- Deliberately not in Callee or Caller: see the comment in Caller.hs

+instance TC W where tcDummy _ = 7

+module Main where

+

+import Caller

+import Inst ()

+

+main :: IO ()

+main = print (a 1)

+43

+test('T27627f',

+     [extra_files(['Main.hs', 'Inst.hs', 'Caller.hs', 'Callee.hs'])],

+     multimod_compile_and_run,

+     ['Main', '-O'])

+{-# LANGUAGE UndecidableInstances, FlexibleInstances, FlexibleContexts #-}

+module Callee where

+

+import Ty

+import Mid

+

+instance CB a => CB (T a) where

+  opB _ = 2

+

+instance CB Int where

+  opB _ = 8

+{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}

+module Callee where

+

+import Ty

+

+instance CB a => CB (T a)

+instance CB Int

+module Main where

+import Mid

+import Callee ()

+

+main :: IO ()

+main = print (g (1 :: Int))

+{-# LANGUAGE UndecidableInstances, FlexibleInstances, FlexibleContexts #-}

+{-# LANGUAGE GADTs, ConstraintKinds, ScopedTypeVariables #-}

+module Mid where

+

+import Ty

+import {-# SOURCE #-} Callee

+

+-- $fCATa calls Callee's $fxCBT, and that calls this one back.  The cycle runs

+-- through the hs-boot import, so both dfuns are NonRec in their own module and

+-- cpe_rec_ids cannot see it.  Speculating either one loops.

+instance CB a => CA (T a) where

+  opA _ = 1

+

+instance CA Int where

+  opA _ = 9

+

+data Dict c where

+  Dict :: c => Dict c

+

+{-# NOINLINE keep #-}

+keep :: [Dict c] -> Int

+keep xs = length xs + 41

+

+{-# NOINLINE g #-}

+g :: forall a. CB a => a -> Int

+g _ = keep [Dict :: Dict (CA (T a))]

+42

+{-# LANGUAGE UndecidableSuperClasses #-}

+module Ty where

+

+data T a = MkT a

+

+class CB a => CA a where

+  opA :: a -> Int

+

+class CA a => CB a where

+  opB :: a -> Int

+test('T27717',

+     [extra_files(['Main.hs', 'Mid.hs', 'Ty.hs', 'Callee.hs', 'Callee.hs-boot'])],

+     multimod_compile_and_run,

+     ['Main', '-O -fspec-eval-dictfun'])

+{-# LANGUAGE RankNTypes #-}

+module Lib (g) where

+

+{-# NOINLINE consume #-}

+consume :: Int -> Int

+consume n = n `seq` 0

+

+{-# RULES "consume/drop" [~1] forall n. consume n = 0 #-}

+

+-- A dead value argument (n) that comes *before* the dictionary we

+-- specialise on.  No implicit parameters involved.

+{-# INLINE [1] f #-}

+f :: forall a. Int -> Show a => a -> String

+f n y = show y ++ replicate (consume n) '!'

+

+{-# NOINLINE g #-}

+g :: Bool -> String

+g b = f 7 b ++ "."

+module Main where

+import Lib

+

+main :: IO ()

+main = putStrLn (g True)

+True.

+test('T27703',

+     [extra_files(['Main.hs', 'Lib.hs'])],

+     multimod_compile_and_run,

+     ['Main', '-O'])