section: compiler

 issues: #25924

 mrs: !16219

 import GHC.Core.Predicate

 import GHC.Core.Class( classMethods )

 import GHC.Core.Coercion( Coercion )

 import qualified GHC.Core.Subst as Core

 import GHC.Core.Unfold.Make

 import GHC.Core

 import GHC.Core.Unify     ( tcMatchTy )

 import GHC.Core.Rules

 import GHC.Core.Subst (substTickish)

                                         | otherwise    = UnspecArg

            ; (useful, subst', rule_bndrs, rule_lhs_args, spec_bndrs, dx_binds, spec_args)

            ; let env' = env { se_subst = subst' }

            -- Check for (a) usefulness and (b) not already covered

 --    , [T1, T2, c, i, dEqT1, dShow1]

 --    )

 specHeader

      -> [InBndr]    -- Binders from the original function `f`

      -> [SpecArg]   -- From the CallInfo

      -> SpecM ( Bool     -- True <=> some useful specialisation happened

 -- If we run out of binders, stop immediately

 -- See Note [Specialisation Must Preserve Sharing]

 -- We want to specialise on type 'T1', and so we must construct a substitution

 -- 'a->T1', as well as a LHS argument for the resulting RULE and unfolding

 -- details.

   = do { -- Find free_tvs, the type variables to add to the binders for the rule

          -- Namely those deeply free in `ty` that aren't in scope

          -- See (MP2) in Note [Specialising polymorphic dictionaries]

        ; let subst2 = Core.extendTvSubst subst1 bndr ty

        ; (useful, subst3, rule_bs, rule_args, spec_bs, dx, spec_args)

        ; pure ( useful, subst3

               , free_tvs ++ rule_bs,     Type ty : rule_args

               , free_tvs ++ spec_bs, dx, Type ty : spec_args ) }

 -- a substitution on it (in case the type refers to 'a'). Additionally, we need

 -- to produce a binder, LHS argument and RHS argument for the resulting rule,

 -- /and/ a binder for the specialised body.

   = do { let (subst1, bndr') = Core.substBndr subst bndr

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

        ; let ty_e' = Type (mkTyVarTy bndr')

        ; pure ( useful, subst2

               , bndr' : rule_bs,     ty_e' : rule_es

               , bndr' : spec_bs, dx, ty_e' : spec_args ) }

   | isDeadBinder bndr

   , let (subst1, bndr') = Core.substBndr subst (zapIdOccInfo bndr)

   = -- See Note [Drop dead args from specialisations]

        ; pure ( useful, subst2

               , bndr' : rule_bs, Var bndr'   : rule_es

 -- Next we want to specialise the 'Eq a' dict away. We need to construct

 -- a wildcard binder to match the dictionary (See Note [Specialising Calls] for

 -- the nitty-gritty), as a LHS rule and unfolding details.

   = do { -- Make up a fresh binder to use in the RULE

          -- It might turn into a dict binding (via bindAuxiliaryDict) which we

          -- then float, so we use cloneIdBndr to get a completely fresh binder

          -- Extend the substitution to map bndr :-> dict_arg, for use in the RHS

        ; let (subst2, dx_bind, spec_dict) = bindAuxiliaryDict subst1 bndr bndr' dict_arg

        ; let dx' = case dx_bind of { Nothing -> dx; Just d -> d : dx }

        ; pure ( True, subst3      -- Ha!  A useful specialisation!

 -- why 'i' doesn't appear in our RULE above. But we have no guarantee that

 -- there aren't 'UnspecArg's which come /before/ all of the dictionaries, so

 -- this case must be here.

   = do { let (subst1, bndr') = Core.substBndr subst (zapIdOccInfo bndr)

                  -- zapIdOccInfo: see Note [Zap occ info in rule binders]

        ; let dummy_arg = varToCoreExpr bndr'

                -- dummy_arg is usually just (Var bndr),

   -- See Note [Drop absent bindings]

   | isAbsDmd (demandInfo fn_info)

   , not (isJoinId fn_id)

   = return [(new_fn_id, filler)]

   -- See Note [Don't w/w INLINE things]

 import GHC.Core.Type

 import GHC.Core.Multiplicity

 import GHC.Core.Coercion

 import GHC.Core.Reduction

 import GHC.Core.FamInstEnv

 import GHC.Core.Predicate( isEqualityClass )

     _ | isTyVar arg -> do_nothing

     DropAbsent

          -- Absent case.  Drop the argument from the worker.

          -- We can't always handle absence for arbitrary

          -- unlifted types, so we need to choose just the cases we can

 --

 -- If @mkAbsentFiller _ id == Just e@, then @e@ is an absent filler with the

 -- same type as @id@. Otherwise, no suitable filler could be found.

   -- The lifted case: bind 'absentError'. See (AF1) in Note [Absent fillers]

   -- We want to use this case if possible, because we get a nice runtime panic message

   -- if we are wrong (like we were in #11126).  Otherwise we fall through to the

   -- less-desirable mkLitRubbish case.

   | mightBeLiftedType arg_ty

   , not (isStrictDmd (idDemandInfo arg))  -- See (AF2)

   , not (isMarkedStrict str)              --    in Note [Absent fillers]

   = Just (mkAbsentErrorApp arg_ty msg)

               -- will have different lengths and hence different costs for

               -- the inliner leading to different inlining.

               -- See also Note [Unique Determinism] in GHC.Types.Unique

 {- Note [Worker/wrapper for Strictness and Absence]

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

      have to be representation monomorphic. But in the future, we might allow

      levity polymorphism, e.g. a polymorphic levity variable in 'BoxedRep'.

 While (AF1) and (AF2) are simply an optimisation in terms of compiler debugging

 experience, (AF3) should be irrelevant in most programs, if not all.

    because `MkT` is strict in its Int# argument, so we get an absentError

    exception when we shouldn't.  Very annoying!

 Note [Unboxing through unboxed tuples]

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

 We should not to a worker/wrapper split just for unboxing the components of