; return (literalType lit, zeroUE) }

 lintCoreExpr (Cast expr co)

             -- markAllJoinsBad: see Note [Join points and casts]

        ; lintCoercion co

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

 lintJoinBndrType :: OutType -- Type of the body

                  -> OutId   -- Possibly a join Id

 -- Checks that the return type of a join Id matches the body

 -- E.g. join j x = rhs in body

 --      The type of 'rhs' must be the same as the type of 'body'

 import GHC.Core.Type

 import GHC.Core.TyCo.FVs    ( tyCoVarsOfMCo )

 import GHC.Data.Graph.Directed ( SCC(..), Node(..)

                                , stronglyConnCompFromEdgedVerticesUniq

                                , stronglyConnCompFromEdgedVerticesUniqR )

 import GHC.Unit.Module( Module )

 import Data.List (mapAccumL)

 import qualified Data.Semigroup as Semi

 {-

                     _ -> usage1

          -- usage3: see Note [Quasi join points] in GHC.Core.Opt.Simplify.Iteration.

     in WUD usage3 (Cast expr' co)

   = let (WUD usage expr') = occAnal env expr

         usage1 = addManyOccs usage (coVarsOfCo co)

             -- usage1: see Note [Gather occurrences of coercion variables]

             -- usage2: see Note [Quasi join points]

     in WUD usage2 (Cast expr' co)

   where

     exact_join =

       case mb_join_arity of

                 -> CoreExpr    -- Rhs usage, AFTER occAnalLamTail

                 -> UsageDetails

                 -> UsageDetails

   = -- c.f. occAnal (Lam {})

     markAllInsideLamIf (not one_shot) $

     uds

   where

 adjustTailArity :: Maybe JoinArity -> TailUsageDetails -> UsageDetails

 adjustTailArity mb_rhs_ja (TUD ja usage) = markAllNonTailIf not_same_arity usage

 -- No-op on TyVars

 -- Precondition: OccInfo is not IAmDead

 tagNonRecBinder lvl occ bndr

   = (setBinderOcc occ bndr,        JoinPoint join_ty ar)

   | otherwise

   = (setBinderOcc zapped_occ bndr, NotJoinPoint)

        = assertPpr (rhs_ja == joinRhsArity rhs) (ppr rhs_ja $$ ppr uds $$ ppr rhs) $

          uds

      will_be_joins = decideRecJoinPointHood lvl unadj_uds bndrs

      -- 2. Adjust usage details of each RHS, taking into account the

 --

 -- See Note [Invariants on join points] in "GHC.Core".

 decideRecJoinPointHood :: TopLevelFlag -> UsageDetails

   where

     ok bndr = okForJoinPoint lvl bndr (lookupTailCallInfo usage bndr)

     -- See Note [Invariants on join points]; invariants cited by number below.

     -- Invariant 2 is always satisfiable by the simplifier by eta expansion.

 okForJoinPoint lvl bndr tail_call_info

   = warnPprTrace lost_join "Lost join point" lost_join_doc $

   | otherwise

   where

     lost_join | JoinPoint { joinPointArity = ja } <- idJoinPointHood bndr

                 (case tail_call_info of -- Valid join but arity differs

                    AlwaysTailCalled { tailCallArity = ja' } -> ja /= ja'

                    _ -> False)

 of a SpecConstr-generated RULE for a join point.

 -}

 simplNonRecJoinPoint :: SimplEnv -> InId -> InExpr

                      -> InExpr -> SimplCont

                      -> SimplM (SimplFloats, OutExpr)

      wrapJoinCont do_case_case env cont $ \ env cont ->

      do { -- We push join_cont into the join RHS and the body;

           -- and wrap wrap_cont around the whole thing

         ; (env1, bndr1)    <- simplNonRecJoinBndr env bndr mult res_ty

         ; (env2, bndr2)    <- addBndrRules env1 bndr bndr1 (BC_Join NonRecursive cont)

         ; (floats1, env3)  <- simplJoinBind NonRecursive cont (bndr,env) (bndr2,env2) (rhs,env)

 simplRecJoinPoint env pairs body cont

   = wrapJoinCont do_case_case env cont $ \ env cont ->

     do { let bndrs  = map fst pairs

        ; env1 <- simplRecJoinBndrs env bndrs mult res_ty

                -- NB: bndrs' don't have unfoldings or rules

                -- We add them as we go down

   = cont -- Not a jump

 trimJoinCont var (JoinPoint { joinPointType = join_ty, joinPointArity = arity }) cont

   | QuasiJoinPoint <- join_ty

   = cont

   | otherwise

   = trim arity cont

              -- arity: See Note [Invariants on join points] invariant 2b, in GHC.Core

              join_arity = length bndrs

              details    = JoinId

                             , joinIdArity    = join_arity

                             , joinIdCbvMarks = Nothing

                             }

    pp CoVarId                 = text "CoVarId"

    pp (JoinId ty arity marks) = quasi <> text "JoinId" <> parens (int arity) <> parens (ppr marks)

      where

 {-

 ************************************************************************