exprs_fvs exprs = mapUnionFV expr_fvs exprs

 tickish_fvs :: CoreTickish -> FV

 tickish_fvs _ = emptyFV

 {- **********************************************************************

         , AnnTick tickish expr2 )

       where

         expr2 = go expr

     go (Type ty)     = (tyCoVarsOfTypeDSet ty, AnnType ty)

     go (Coercion co) = (tyCoVarsOfCoDSet co, AnnCoercion co)

 lintCoreExpr (Tick tickish expr)

   = do { case tickish of

        ; markAllJoinsBadIf block_joins $ lintCoreExpr expr }

   where

     block_joins = not (tickish `tickishScopesLike` SoftScope)

 eqDeBruijnTickish :: DeBruijn CoreTickish -> DeBruijn CoreTickish -> Bool

 eqDeBruijnTickish (D env1 t1) (D env2 t2) = go t1 t2 where

         =  lid == rid

         && D env1 lids == D env2 rids

         && lext == rext

     go l r = l == r

 -- Compares for equality, modulo alpha

       -- For a non-soft tick scope, we can inline lambdas only, so we

       -- abandon tail calls, and do markAllInsideLam too: usage_lam

       = -- Never substitute for any of the Ids in a Breakpoint

         addManyOccs usage_lam (mkVarSet ids)

   simplTickish env tickish

     | otherwise = tickish

   -- Push type application and coercion inside a tick

 import GHC.Core

 import GHC.Core.Stats (exprStats)

 import GHC.Types.Fixity (LexicalFixity(..))

 import GHC.Types.Literal( pprLiteral )

 import GHC.Types.Name( pprInfixName, pprPrefixName )

             ppr modl, comma,

             ppr ix,

             text ">"]

       hcat [text "break<",

             text ">",

             parens (hcat (punctuate comma (map ppr vars)))]

   ppr (ProfNote { profNoteCC = cc,

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

 -- | Drop free vars from the breakpoint if they have a non-variable substitution.

 substTickish :: Subst -> CoreTickish -> CoreTickish

  where

     do_one = getIdFromTrivialExpr_maybe . lookupIdSubst subst

 ------------  Tickish  --------------

 tidyTickish :: TidyEnv -> CoreTickish -> CoreTickish

 tidyTickish _   other_tickish       = other_tickish

 ------------  Rules  --------------

 -- Used by diffBinds, which is itself only used in GHC.Core.Lint.lintAnnots

 eqTickish :: RnEnv2 -> CoreTickish -> CoreTickish -> Bool

       = lid == rid &&

         map (rnOccL env) lids == map (rnOccR env) rids &&

 eqTickish _ l r = l == r

 -- | Finds differences between core bindings, see @diffExpr@.

 toIfaceTickish (HpcTick modl ix)       = IfaceHpcTick modl ix

 toIfaceTickish (SourceNote src (LexicalFastString names)) =

   IfaceSource src names

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

 toIfaceBind :: Bind Id -> IfaceBinding IfaceLetBndr

 coreToStgTick :: Type -- type of the ticked expression

               -> CoreTickish

               -> StgTickish

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

 -- The magic for lets:

   = do { body <- cpeBodyNF env expr

        ; return (emptyFloats, mkTick tickish' body) }

   where

              -- See also 'substTickish'

              | otherwise

              = tickish

 import GHC.Utils.Outputable as Outputable

 import GHC.Utils.Panic

 import GHC.Utils.Logger

 import GHC.Types.SrcLoc

 import GHC.Types.Basic

 import GHC.Types.Id

     Breakpoints -> do

       i <- addMixEntry me

     SourceNotes | RealSrcSpan pos' _ <- pos ->

       return $ SourceNote pos' $ LexicalFastString cc_name

 import GHC.Builtin.Names ( unrestrictedFunTyConKey, liftedTypeKindTyConKey,

                            constraintKindTyConKey )

 import GHC.Types.Unique ( hasKey )

 import GHC.Iface.Type

 import GHC.Iface.Recomp.Binary

   = IfaceHpcTick    Module Int               -- from HpcTick x

   | IfaceSCC        CostCentre Bool Bool     -- from ProfNote

   | IfaceSource  RealSrcSpan FastString      -- from SourceNote

 data IfaceAlt = IfaceAlt IfaceConAlt [IfLclName] IfaceExpr

         -- Note: IfLclName, not IfaceBndr (and same with the case binder)

   = braces (pprCostCentreCore cc <+> ppr tick <+> ppr scope)

 pprIfaceTickish (IfaceSource src _names)

   = braces (pprUserRealSpan True src)

   = braces (text "break" <+> ppr m <+> ppr ix <+> ppr fvs)

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

   = unitNameSet ax &&& freeNamesIfTc tc &&& freeNamesIfAppArgs tys

 freeNamesIfTickish :: IfaceTickish -> NameSet

   fnList freeNamesIfExpr fvs

 freeNamesIfTickish _ = emptyNameSet

         put_ bh (srcSpanEndLine src)

         put_ bh (srcSpanEndCol src)

         put_ bh name

         putByte bh 3

         put_ bh m

         put_ bh ix

             3 -> do m <- get bh

                     ix <- get bh

                     fvs <- get bh

             _ -> panic ("get IfaceTickish " ++ show h)

 instance Binary IfaceConAlt where

     IfaceHpcTick m i -> rnf m `seq` rnf i

     IfaceSCC cc b1 b2 -> rnf cc `seq` rnf b1 `seq` rnf b2

     IfaceSource src str -> rnf src `seq` rnf str

 instance NFData IfaceConAlt where

   rnf = \case

 dffvExpr (Var v)              = insert v

 dffvExpr (App e1 e2)          = dffvExpr e1 >> dffvExpr e2

 dffvExpr (Lam v e)            = extendScope v (dffvExpr e)

 dffvExpr (Tick _other e)    = dffvExpr e

 dffvExpr (Cast e _)           = dffvExpr e

 dffvExpr (Let (NonRec x r) e) = dffvBind (x,r) >> extendScope x (dffvExpr e)

 tcIfaceTickish (IfaceHpcTick modl ix)   = return (HpcTick modl ix)

 tcIfaceTickish (IfaceSCC  cc tick push) = return (ProfNote cc tick push)

 tcIfaceTickish (IfaceSource src name)   = return (SourceNote src (LexicalFastString name))

   fvs' <- mapM tcIfaceExpr fvs

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

 tcIfaceLit :: Literal -> IfL Literal

 bcPrepExpr :: StgExpr -> BcPrepM StgExpr

 -- explicitly match all constructors so we get a warning if we miss any

   | isLiftedTypeKind (typeKind tick_ty) = do

       id <- newId tick_ty

       rhs' <- bcPrepExpr rhs

       , let lcl_fvs' = unionDVarSet (tickish tick) lcl_fvs

       = (StgTick tick e', imp_fvs, top_fvs, lcl_fvs')

         where

     go_bind dc bind body = (dc bind' body', imp_fvs, top_fvs, lcl_fvs)

       where

 import GHC.Runtime.Interpreter

 import GHCi.FFI

 import GHC.Types.Basic

 import GHC.Utils.Outputable

 import GHC.Types.Name

 import GHC.Types.Id

 -- | Introduce break instructions for ticked expressions.

 -- If no breakpoint information is available, the instruction is omitted.

 schemeER_wrk :: StackDepth -> BCEnv -> CgStgExpr -> BcM BCInstrList

   code <- schemeE d 0 p rhs

   hsc_env <- getHscEnv

   current_mod <- getCurrentModule

      thunk_codes <- sequence compile_binds

      return (alloc_code `appOL` concatOL thunk_codes `appOL` body_code)

 -- ignore other kinds of tick

 schemeE d s p (StgTick _ rhs) = schemeE d s p rhs

 import GHC.Prelude

 import GHC.Unit.Module

 -- | Breakpoint identifier.

 --

   { bi_tick_mod   :: !Module  -- ^ Breakpoint tick module

   , bi_tick_index :: !Int     -- ^ Breakpoint tick index

   }

 -- | Internal breakpoint identifier

 --

 -- So every breakpoint occurrence gets assigned a module-unique *info index* and

 -- we store it alongside the occurrence module (*info module*) in the

 -- InternalBreakpointId datatype.

 import GHC.Unit.Module

 import GHC.Types.CostCentre

 import GHC.Types.SrcLoc ( RealSrcSpan, containsSpan )

 import GHC.Types.Var

   -- and (b) substituting (don't substitute for them)

   | Breakpoint

     { breakpointExt    :: XBreakpoint pass

     , breakpointFVs    :: [XTickishId pass]

                                 -- ^ the order of this list is important:

                                 -- it matches the order of the lists in the

                                 --

                                 -- Careful about substitution!  See

                                 -- Note [substTickish] in "GHC.Core.Subst".

     }

   -- | A source note.