<+> text "with an InternalBreakpointId for module" <+> ppr ibi_mod)

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

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

 -- | Get the source span for this breakpoint

         minf_instances :: [ClsInst],

         minf_iface     :: Maybe ModIface,

         minf_safe      :: SafeHaskellMode,

   }

         -- We don't want HomeModInfo here, because a ModuleInfo applies

         -- to package modules too.

                          -- NB: already forced. See Note [Forcing GREInfo] in GHC.Types.GREInfo.

                         minf_instances = instEnvElts $ md_insts details,

                         minf_iface     = Just iface,

                         }))

 -- | The list of top-level entities defined in a module

 modInfoSafe :: ModuleInfo -> SafeHaskellMode

 modInfoSafe = minf_safe

 modInfoModBreaks = minf_modBreaks

    , extendLoadedEnv

    , deleteFromLoadedEnv

    -- * Internals

    , rmDupLinkables

    , modifyLoaderState

    , initLinkDepsOpts

             allocateBreakArrays

               interp

               (breakarray_env le)

           le2_ccs_env <-

             allocateCCS

               interp

               (ccs_env le)

           let le2 = le { itbl_env = le2_itbl_env

                        , addr_env = le2_addr_env

                        , breakarray_env = le2_breakarray_env

             le1 = linker_env pls

         ie2 <- linkITbls interp (itbl_env le1) (concatMap bc_itbls cbcs)

         ae2 <- foldlM (\env cbc -> allocateTopStrings interp (bc_strs cbc) env) (addr_env le1) cbcs

         let le2 = le1 { itbl_env = ie2, addr_env = ae2, breakarray_env = be2, ccs_env = ce2 }

         names_and_refs <- linkSomeBCOs interp (pkgs_loaded pls) le2 cbcs

 allocateBreakArrays ::

   Interp ->

   ModuleEnv (ForeignRef BreakArray) ->

   IO (ModuleEnv (ForeignRef BreakArray))

 allocateBreakArrays interp =

   foldlM

         let bi = imodBreaks_breakInfo imbs

     )

 -- | Given a list of 'InternalModBreaks' and 'ModBreaks' collected from a list

 allocateCCS ::

   Interp ->

   ModuleEnv (Array BreakTickIndex (RemotePtr CostCentre)) ->

   IO (ModuleEnv (Array BreakTickIndex (RemotePtr CostCentre)))

 allocateCCS interp ce mbss

   | interpreterProfiled interp = do

       -- First construct the CCSs for each module, using the 'ModBreaks'

       ccs_map <- foldlM

         ) emptyModuleEnv mbss

       -- Now, construct an array indexed by an 'InternalBreakpointId' index by first

       -- finding the matching 'BreakpointId' and then looking it up in the ccs_map

       foldlM

           let breakModl    = imodBreaks_module imbs

               breakInfoMap = imodBreaks_breakInfo imbs

               ccss         = expectJust $ lookupModuleEnv ccs_map breakModl

           ccs_im <- foldlM

             (\(bids :: IM.IntMap (RemotePtr CostCentre)) cgi -> do

               let tickBreakId = bi_tick_index $ cgb_tick_id cgi

               pure $ IM.insert tickBreakId (ccss ! tickBreakId) bids

             ) mempty breakInfoMap

         )

         ce

         mbss

 import qualified Data.Semigroup as S

 import GHC.HsToCore.Breakpoints

 import GHC.Driver.Env

 import GHC.Driver.Monad

 import GHC.Driver.Session.Inspect

 makeModuleLineMap :: GhcMonad m => Module -> m (Maybe TickArray)

 makeModuleLineMap m = do

   mi <- getModuleInfo m

   where

     mkTickArray :: [(BreakTickIndex, SrcSpan)] -> TickArray

     mkTickArray ticks

 getModBreak :: GhcMonad m => Module -> m (Maybe ModBreaks)

 getModBreak m = do

    mod_info <- fromMaybe (panic "getModBreak") <$> getModuleInfo m

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

 -- Getting current breakpoint information

   return $ case resumes of

     [] -> Nothing

     (r:_) -> case resumeHistoryIx r of

       ix -> Just $ getHistoryModule $ resumeHistory r !! (ix-1)

 import GHC.Tc.Utils.Monad

 import GHC.IfaceToCore

 import Control.Monad

 import Data.Dynamic

 import Data.IntMap (IntMap)

 import Data.List (find,intercalate)

 import Data.List.NonEmpty (NonEmpty)

 import Unsafe.Coerce ( unsafeCoerce )

 getResumeContext :: GhcMonad m => m [Resume]

 getResumeContext = withSession (return . ic_resume . hsc_IC)

 getHistoryModule :: History -> Module

 getHistorySpan :: HUG.HomeUnitGraph -> History -> IO SrcSpan

 getHistorySpan hug hist = do

 {- | Finds the enclosing top level function name -}

 -- ToDo: a better way to do this would be to keep hold of the decl_path computed

 -- by the coverage pass, which gives the list of lexically-enclosing bindings

 -- for each tick.

 -- | Update fixity environment in the current interactive context.

 updateFixityEnv :: GhcMonad m => FixityEnv -> m ()

       let hug = hsc_HUG hsc_env

       let ibi@InternalBreakpointId{ibi_info_index}

             = evalBreakpointToId eval_break

       let

       -- Was this breakpoint explicitly enabled (ie. in @BreakArray@)?

       bactive <- liftIO $ breakpointStatus interp breakArray ibi_info_index

             , resumeBindings = bindings

             , resumeFinalIds = final_ids

             , resumeApStack = apStack_fhv

             , resumeSpan = span

             , resumeHistory = toListBL history0

             , resumeDecl = decl

         let eval_opts = initEvalOpts dflags (enableGhcStepMode step)

         status <- liftIO $ GHCi.resumeStmt interp eval_opts resume_ctxt_fhv

         history <- if not tracing then pure history0 else do

           let !history' = history1 `consBL` history0

                 -- history is strict, otherwise our BoundedList is pointless.

           return history'

                 -- When the user specified a break ignore count, set it

                 -- in the interpreter

                 case (mb_brkpt, mbCnt) of

                     setupBreakpoint interp ibi cnt

                   _ -> return ()

                     hug = hsc_HUG hsc_env

                     hist' = case mb_brkpt of

                        Nothing -> pure prevHistoryLst

                          | breakHere False step span -> do

                             return $ hist1 `consBL` fromListBL 50 hist

                          | otherwise -> pure prevHistoryLst

                 handleRunStatus step expr bindings final_ids status =<< hist'

 setupBreakpoint :: GhcMonad m => Interp -> InternalBreakpointId -> Int -> m ()   -- #19157

 setupBreakpoint interp ibi cnt = do

   liftIO $ GHCi.storeBreakpoint interp breakArray (ibi_info_index ibi) cnt

 back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan)

 back n = moveHist (+n)

           update_ic apStack mb_info = do

             span <- case mb_info of

                       Nothing  -> return $ mkGeneralSrcSpan (fsLit "<unknown>")

             (hsc_env1, names) <-

             let ic = hsc_IC hsc_env1

                 r' = r { resumeHistoryIx = new_ix }

                 ic' = ic { ic_resume = r':rs }

                           update_ic apStack mb_brkpt

            else case history !! (new_ix - 1) of

                    History{..} ->

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

 -- of the breakpoint and the free variables of the expression.

 bindLocalsAtBreakpoint hsc_env apStack_fhv span (Just ibi) = do

    let hug = hsc_HUG hsc_env

        interp = hscInterp hsc_env

   -- Rehydrate to understand the breakpoint info relative to the current environment.

   -- This design is critical to preventing leaks (#22530)

        , resumeFinalIds  :: [Id]         -- [Id] to bind on completion

        , resumeApStack   :: ForeignHValue -- The object from which we can get

                                         -- value of the free variables.

                                         -- ^ the internal breakpoint we stopped at

                                         -- (Nothing <=> exception)

        , resumeSpan      :: SrcSpan     -- just a copy of the SrcSpan

                                         -- from the ModBreaks,

 data History = History

   { historyApStack        :: ForeignHValue

     -- ^ internal breakpoint identifier

   , historyEnclosingDecls :: [String]

     -- ^ declarations enclosing the breakpoint

 import GHC.Runtime.Eval.Utils

 -- The GHC interface

 import GHC.Runtime.Interpreter

 import GHCi.RemoteTypes

 import GHCi.BreakArray( breakOn, breakOff )

              -> GHC.ExecResult -> m GHC.ExecResult

 afterRunStmt step run_result = do

   resumes <- GHC.getResumeContext

   case run_result of

      GHC.ExecComplete{..} ->

        case execResult of

          <> text (GHC.resumeDecl res))

     <> char ',' <+> ppr (GHC.resumeSpan res)

  where

 showUnits :: GHC.GhcMonad m => m ()

 showUnits = mapNonInteractiveHomeUnitsM $ \dflags -> do

     Left sdoc -> printForUser sdoc

     Right (mod, mod_info, fun_str) -> do

       let modBreaks = expectJust (GHC.modInfoModBreaks mod_info)

 breakSyntax :: a

 breakSyntax = throwGhcException $ CmdLineError ("Syntax: :break [<mod>.]<func>[.<func>]\n"