section: compiler

 issues: #25924

 mrs: !16219

 -- Fail (returning Nothing) if

 --    * the RuntimeRep of the Type is not monomorphic;

 --    * the type is (a ~# b), the type of coercion

 -- in GHC.Types.Literal

 mkLitRubbish ty

   | not (noFreeVarsOfType rep)

   = Nothing   -- Satisfy INVARIANT 1

   | isCoVarType ty

   = Nothing   -- Satisfy INVARIANT 2

   | otherwise

   = Just (Lit (LitRubbish torc rep) `mkTyApps` [ty])

   where

 import GHC.Core.SimpleOpt( defaultSimpleOpts, simpleOptExprWith )

 import GHC.Core.Predicate

 import GHC.Core.Coercion( Coercion )

 import GHC.Core.Opt.Monad

 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.Utils     ( exprIsTrivial, exprIsTopLevelBindable

            ; ( useful, rhs_env2, leftover_bndrs

              , rule_bndrs, rule_lhs_args

 --           ; pprTrace "spec_call" (vcat

 --                [ text "fun:       "  <+> ppr fn

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

 --    )

 specHeader

      -> [InBndr]    -- The binders from the original function 'f'

      -> [SpecArg]   -- From the CallInfo

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

 -- 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 qvars, the type variables to add to the binders for the rule

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

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

              ty'            = substTy env1 ty

              env2           = extendTvSubst env1 bndr ty'

        ; (useful, env3, leftover_bndrs, rule_bs, rule_es, bs', dx, spec_args)

        ; pure ( useful

               , env3

               , leftover_bndrs

 -- 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 (env', bndr') = substBndr env bndr

        ; (useful, env'', leftover_bndrs, rule_bs, rule_es, bs', dx, spec_args)

        ; pure ( useful

               , env''

               , leftover_bndrs

               , varToCoreExpr bndr' : spec_args

               )

        }

 -- 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.

   | not (isDeadBinder bndr)

   , allVarSet (`elemInScopeSet` in_scope) (exprFreeVars d)

     -- See Note [Weird special case for SpecDict]

   = do { (env1, bndr') <- newDictBndr env bndr -- See Note [Zap occ info in rule binders]

        ; let (env2, dx_bind, spec_dict) = bindAuxiliaryDict env1 bndr bndr' d

        ; (_, env3, leftover_bndrs, rule_bs, rule_es, bs', dx, spec_args)

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

               , env3

               , leftover_bndrs

 -- 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.

     -- The "_" can be UnSpecArg, or SpecDict where the bndr is dead

   = do { -- see Note [Zap occ info in rule binders]

          let (env', bndr') = substBndr env (zapIdOccInfo bndr)

        ; (useful, env'', leftover_bndrs, rule_bs, rule_es, bs', dx, spec_args)

              -- C.f. GHC.Core.Opt.WorkWrap.Utils.mk_absent_let

              (mb_spec_bndr, spec_arg)

                 | isDeadBinder bndr

                 | otherwise

                 = (Just bndr', varToCoreExpr bndr')

 -- If we run out of binders, stop immediately

 -- See Note [Specialisation Must Preserve Sharing]

 -- Return all remaining binders from the original function. These have the

 -- invariant that they should all correspond to unspecialised arguments, so

 -- it's safe to stop processing at this point.

   = pure (False, env', bndrs', [], [], [], [], [])

   where

     (env', bndrs') = substBndrs env bndrs

   -- 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.TyCon

     _ | 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

 where marking recursive DFuns (of undecidable *instances*) strict in dictionary

 *parameters* leads to quite the same change in termination as above.

 Note [BindInfo and FloatInfo]

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

           -- (where it is actually bound lazily).

           --

           -- Don't speculate an absent binding. See #25924 and

       | is_unlifted || is_strict = (CaseBound, StrictContextFloatable)

           -- These will never be floated out of a lazy RHS context

    This is sad, though: see #18983.

 3. STG: The type app in `RUBBISH[IntRep] @Int# :: Int#` is erased and we get

    the (untyped) 'StgLit' `RUBBISH[IntRep] :: Int#` in STG.

 ==================== Tidy Core ====================

 -- RHS size: {terms: 8, types: 9, coercions: 1, joins: 0/0}

 T18982.$WExGADT :: forall e. (e ~ Int) => e %1 -> Int %1 -> ExGADT Int

 T18982.$tc'ExGADT :: GHC.Types.TyCon

 T18982.$tc'ExGADT = GHC.Types.TyCon 8468257409157161049#Word64 5503123603717080600#Word64 T18982.$trModule T18982.$tc'ExGADT2 1# T18982.$tc'ExGADT1

 i :: forall a. ExGADT a -> Int

 -- RHS size: {terms: 6, types: 7, coercions: 0, joins: 0/0}

 T18982.$wh :: forall a. (a GHC.Prim.~# Int) => GHC.Prim.Int# -> GHC.Prim.Int#