InCastCoercion,

         OutId, OutBind, OutExpr, OutAlt, OutArg, OutType, OutKind,

                OutBndr, OutVar, OutCoercion, OutCoercionR, OutTyVar, OutCoVar,

         -- ** 'Expr' construction

         mkLet, mkLets, mkLetNonRec, mkLetRec, mkLams,

 type OutExpr      = CoreExpr

 type OutAlt       = CoreAlt

 type OutArg       = CoreArg

 type OutCastCoercion = CastCoercion

         mkFunResCastCo,

         mkFunCastCoNoFTF,

         applyForAllTy,

         -- ** Decomposition

         instNewTyCon_maybe,

     Pair s1t1 s2t2 = coercionKind co

     all_ok = isFunTy s1t1 && isFunTy s2t2

 {- Note [Pushing a coercion into a pi-type]

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

 Suppose we have this:

     Pair tyL tyR = coercionKind co

 pushCoercionIntoLambda

 -- This implements the Push rule from the paper on coercions

 --    (\x. e) |> co

 -- ===>

 --    (\x'. e |> co')

     | assert (not (isTyVar x) && not (isCoVar x)) True

     , Just (_, w1, t1,_t2) <- splitFunTy_maybe t1t2

     , typeHasFixedRuntimeRep t1

       -- We can't push the coercion into the lambda if it would create

       -- a representation-polymorphic binder.

           subst' =

             extendIdSubst (setInScope subst in_scope')

               x

             -- We substitute x' for x, except we need to preserve types.

             -- The types are as follows:

             --   x :: s1,  x' :: t1,  co1 :: s1 ~# t1,

             -- so we extend the substitution with x |-> (x' |> sym co1).

     | otherwise

     = Nothing

 simplCast env body co0 cont0

   = do  { (tyL, co1) <- {-#SCC "simplCast-simplCoercion" #-} simplCastCoercion env (exprType body) co0

         ; cont1 <- {-#SCC "simplCast-addCoerce" #-}

                         -- True <=> co1 is optimised

         ; {-#SCC "simplCast-simplExprF" #-} simplExprF env body cont1 }

   where

         -- Type tyL is the coercionLKind of the coercion

         addCoerce :: OutType -> OutCastCoercion -> Bool -> SimplCont -> SimplM SimplCont

         addCoerce tyL co1 _ (CastIt { sc_co = co2, sc_cont = cont })  -- See Note [Optimising reflexivity]

         addCoerce tyL co co_is_opt (ApplyToTy { sc_arg_ty = arg_ty, sc_cont = tail })

           | Just (arg_ty', res_ty, m_co') <- pushCastCoTyArg tyL co arg_ty

           = {-#SCC "addCoerce-pushCoTyArg" #-}

                ; return (ApplyToTy { sc_arg_ty  = arg_ty'

                                    , sc_cont    = tail'

                                    , sc_hole_ty = tyL }) }

                                                 , sc_dup = dup, sc_cont = tail

                                                 , sc_hole_ty = fun_ty })

           | not co_is_opt  -- pushCoValArg duplicates the coercion, so optimise first

           | Just (_, m_co1, res_ty, m_co2) <- pushCastCoValArg tyL co

           = {-#SCC "addCoerce-pushCoValArg" #-}

                ; if isReflCastCo m_co1

                    then return (cont { sc_cont = tail'

                                          , sc_hole_ty = tyL }) ;

                                     , sc_hole_ty = tyL }) } }

         addCoerce tyL co co_is_opt cont

 simplLazyArg :: SimplEnvIS              -- ^ Used only for its InScopeSet

              -> DupFlag

 ----------------------

 type SimpleClo = (SimpleOptEnv, InExpr)

 instance Outputable SimpleContItem where

   ppr (ApplyToArg (_, arg)) = text "ARG" <+> ppr arg

 data SimpleOptEnv

   = SOE { soe_opts :: {-# UNPACK #-} !SimpleOpts

       = wrapLet mb_pr $ do_beta env'' body as

       where (env', b') = subst_opt_bndr env b

       -- See Note [Desugaring unlifted newtypes]

       | isNonCoVarId b

       = do_beta (soeZapSubst env) (Lam b' body') rest

         -- soeZapSubst: pushCoercionIntoLambda applies the substitution

       | otherwise

   = as

   | otherwise

   = case as of

   where

 rebuild_app :: HasDebugCallStack

             => SimpleOptEnv -> OutExpr -> [SimpleContItem] -> OutExpr

     in_scope = soeInScope env

     mk_app out_fun = \case

       ApplyToArg arg -> App out_fun (simple_opt_clo in_scope arg)

 {- Note [Desugaring unlifted newtypes]

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

     -- this implies that x is not in scope in gamma (makes this code simpler)

     , not (isTyVar x) && not (isCoVar x)

     , assert (not $ x `elemVarSet` tyCoVarsOfCastCo co) True

     , let res = Just (x',e',ts)

     = --pprTrace "exprIsLambda_maybe:Cast" (vcat [ppr casted_e,ppr co,ppr res)])

       res

     go [] = init_renamings

     go (bind : binds)

        | NonRec b rhs <- bind

        , Just e <- lookupVarEnv renamings b

        | otherwise

        = renamings

        where

         keep_me rhs = isEmptyVarSet (exprSomeFreeVars bad_var rhs)

         bad_var v = is_local v && not (v `elemVarSet` known_bndrs)

 getCastedVar _                 = Nothing

 specFunInlinePrag :: Id -> InlinePragma