, extendInteractiveContextWithIds

    , setInteractivePrintName

    , substInteractiveContext

    , replaceImportEnv

    , icReaderEnv

    , icExtendGblRdrEnv

 substInteractiveContext :: InteractiveContext -> Subst -> InteractiveContext

 substInteractiveContext ictxt@InteractiveContext{ ic_tythings = tts } subst

   | isEmptyTCvSubst subst = ictxt

 instance Outputable InteractiveImport where

   ppr (IIModule m) = char '*' <> ppr m

      --  Then, we extract a substitution,

      --  mapping the old tyvars to the reconstructed types.

        let reconstructed_type = termType term

          Nothing     -> return (subst, term')

          Just subst' -> do { logger <- getLogger

                            ; liftIO $

 import Control.Monad

 import Data.Dynamic

 import Data.IntMap (IntMap)

 import Data.List.NonEmpty (NonEmpty)

 import Unsafe.Coerce ( unsafeCoerce )

 import qualified GHC.Unit.Home.Graph as HUG

         handleRunStatus execSingleStep stmt_text bindings ids

                         status (emptyHistory size)

 runDecls = runDeclsWithLocation "<interactive>" 1

 -- | Run some declarations and return any user-visible names that were brought

 -- into scope.

 runDeclsWithLocation source line_num input = do

     hsc_env <- getSession

     decls <- liftIO (hscParseDeclsWithLocation hsc_env source line_num input)

 -- | Like `runDeclsWithLocation`, but takes parsed declarations as argument.

 -- Useful when doing preprocessing on the AST before execution, e.g. in GHCi

 -- (see GHCi.UI.runStmt).

 runParsedDecls decls = do

     setSession $ hsc_env { hsc_IC = ic }

     hsc_env <- getSession

     setSession hsc_env'

              -- For this filter, see Note [What to show to users]

 {- Note [What to show to users]

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

         final_ic = extendInteractiveContextWithIds (hsc_IC hsc_env) final_ids

         final_names = map getName final_ids

       liftIO $ Loader.extendLoadedEnv interp modifyHomePackageBytecodeState (zip final_names hvals)

       setSession hsc_env'

     -- Completed with an exception

     EvalComplete alloc (EvalException e) ->

       resume_ctxt_fhv <- liftIO $ mkFinalizedHValue interp resume_ctxt

       apStack_fhv     <- liftIO $ mkFinalizedHValue interp apStack_ref

       let span = mkGeneralSrcSpan (fsLit "<unknown>")

         bindLocalsAtBreakpoint hsc_env apStack_fhv span Nothing

       let

         resume = Resume

         hsc_env2 = pushResume hsc_env1 resume

       setSession hsc_env2

     -- EvalBreak (Just ...) case: the interpreter stopped at a breakpoint

     --

         -- This function only returns control to ghci with 'ExecBreak' when it is really meant to break.

         -- Specifically, for :steplocal or :stepmodule, don't return control

         -- and simply resume execution from here until we hit a breakpoint we do want to stop at.

           bindLocalsAtBreakpoint hsc_env apStack_fhv span (Just ibi)

         let

           resume = Resume

             }

           hsc_env2 = pushResume hsc_env1 resume

         setSession hsc_env2

       else do

         -- resume with the same step type

         let eval_opts = initEvalOpts dflags (enableGhcStepMode step)

           ( ld_st'

           , ba

           )

 back n = moveHist (+n)

 forward n = moveHist (subtract n)

 moveHist fn = do

   hsc_env <- getSession

   case ic_resume (hsc_IC hsc_env) of

                         let hug = hsc_HUG hsc_env

                         brks <- readIModBreaks hug ibi

                         getBreakLoc (readIModModBreaks hug) ibi brks

               liftIO $ bindLocalsAtBreakpoint hsc_env apStack span mb_info

             let ic = hsc_IC hsc_env1

                 r' = r { resumeHistoryIx = new_ix }

             setSession hsc_env1{ hsc_IC = ic' }

         -- careful: we want apStack to be the AP_STACK itself, not a thunk

         -- around it, hence the cases are carefully constructed below to

         -> ForeignHValue

         -> SrcSpan

         -> Maybe InternalBreakpointId

 -- Nothing case: we stopped when an exception was raised, not at a

 -- breakpoint.  We have no location information or local variables to

        interp = hscInterp hsc_env

    --

    Loader.extendLoadedEnv interp modifyHomePackageBytecodeState [(exn_name, apStack)]

 -- Just case: we stopped at a breakpoint, we have information about the location

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

    let fhvs = catMaybes mb_hValues

    Loader.extendLoadedEnv interp modifyHomePackageBytecodeState (zip names fhvs)

    when result_ok $ Loader.extendLoadedEnv interp modifyHomePackageBytecodeState [(result_name, apStack_fhv)]

   where

         -- We need a fresh Unique for each Id we bind, because the linker

         -- state is single-threaded and otherwise we'd spam old bindings

        joinOccs = zipWithEqual joinOcc

        joinOcc mbV oc = (\(a,b) c -> (a,b,c)) <$> mbV <*> pure oc

 rttiEnvironment hsc_env@HscEnv{hsc_IC=ic} = do

    let tmp_ids = [id | AnId id <- ic_tythings ic]

        incompletelyTypedIds =

            [id | id <- tmp_ids

                , not $ noSkolems id

                , (occNameFS.nameOccName.idName) id /= result_fs]

     where

      noSkolems = noFreeVarsOfType . idType

       if noSkolems id

          else do

            mb_new_ty <- reconstructType hsc_env 10 id

            let old_ty = idType id

            case mb_new_ty of

              Just new_ty -> do

                Nothing -> warnPprTrace True (":print failed to calculate the "

                                              ++ "improvement for a type")

                               (vcat [ text "id" <+> ppr id

                                     , text "old_ty" <+> debugPprType old_ty

                                     , text "new_ty" <+> debugPprType new_ty ]) $

                Just subst -> do

                  let logger = hsc_logger hsc_env

                  putDumpFileMaybe logger Opt_D_dump_rtti "RTTI"

                           ppr subst])

                  let ic' = substInteractiveContext ic subst

 pushResume :: HscEnv -> Resume -> HscEnv

 pushResume hsc_env resume = hsc_env { hsc_IC = ictxt1 }

 import GHCi.Message (EvalExpr, ResumeContext)

 import GHC.ByteCode.Types (InternalBreakpointId(..))

 import GHC.Types.Id

 import GHC.Types.TyThing

 import GHC.Types.Name.Reader

 import GHC.Types.SrcLoc

   -- | Execution is complete with either an exception or the list of

   -- user-visible names that were brought into scope.

   = ExecComplete

        , execAllocation :: Word64

        }

     -- subsequently deciding whether to really stop here.

     -- `ExecBreak` always means GHCi breaks.

     | ExecBreak

        , breakPointId :: Maybe InternalBreakpointId

        }

 -- improveType <base_type> <rtti_type>

 -- The types can contain skolem type variables, which need to be treated as normal vars.

 -- In particular, we want them to unify with things.

 getDataConArgTys :: DataCon -> Type -> TR [Type]

 -- Given the result type ty of a constructor application (D a b c :: ty)

     -- runStmt wrapper for temporarily overridden line-number

     runStmtWithLineNum :: Int -> String -> SingleStep

     runStmtWithLineNum lnum stmt step = do

         st0 <- getGHCiState

         setGHCiState st0 { line_number = lnum }

 -- | Entry point to execute some haskell code from user.

 -- The return value True indicates success, as in `runOneCommand`.

 runStmt input step = do

   dflags <- GHC.getInteractiveDynFlags

   let pflags = initParserOpts dflags

          case mb_stmt of

            Nothing ->

              -- empty statement / comment

            Just stmt ->

              run_stmt stmt

              run_imports imports

              run_decls decls

   where

     run_imports imports = mapM_ (addImportToContext . unLoc) imports

     set_pragmas pflags sec supported =

           opts = unLoc <$> loc_opts

       in setOptions opts

     run_stmt stmt = do

            m_result <- GhciMonad.runStmt stmt input step

            case m_result of

                Nothing     -> return Nothing

     -- `x = y` (a declaration) should be treated as `let x = y` (a statement).

     -- The reason is because GHCi wasn't designed to support `x = y`, but then

     --

     -- Instead of dealing with all these problems individually here we fix this

     -- mess by just treating `x = y` as `let x = y`.

     -- Only turn `FunBind` and `VarBind` into statements, other bindings

     -- (e.g. `PatBind`) need to stay as decls.

     run_decls [L l (ValD _ bind@FunBind{})] = run_stmt (mk_stmt (locA l) bind)

       -- a file, otherwise the read buffer can't be flushed).

       _ <- liftIO $ tryIO $ hFlushAll stdin

       m_result <- GhciMonad.runDecls' decls

     mk_stmt :: SrcSpan -> HsBind GhcPs -> GhciLStmt GhcPs

     mk_stmt loc bind =

       where

         modStr = moduleNameString $ moduleName $ icInteractiveModule $ ic

 -- | Clean up the GHCi environment after a statement has run

 afterRunStmt :: GhciMonad m => SingleStep {-^ Type of step we took just before -}

 afterRunStmt step run_result = do

   resumes <- GHC.getResumeContext

   case run_result of

   flushInterpBuffers

   withSignalHandlers $ do

   return run_result

 runSuccess run_result

   | otherwise = False

 runAllocs m = do

   res <- m

   case res of

     _ -> Nothing

 toBreakIdAndLocation :: GhciMonad m

   return $ listToMaybe [ id_loc | id_loc@(_,loc) <- IntMap.assocs (breaks st),

                                   breakId loc == bi ]

   printForUser =<< pprStopped res

   printForUserPartWay $ vcat docs

 compareNames :: Name -> Name -> Ordering

 compareNames = on compare getOccString S.<> on SrcLoc.leftmost_smallest getSrcSpan

 data MaybeCommand = GotCommand Command | BadCommand | NoLastCommand

 -- | Entry point for execution a ':<command>' input from user

 doContinue' :: GhciMonad m => SingleStep -> Maybe Int -> m ()

 doContinue' step mbCnt= do

   runResult <- resume step mbCnt

   return ()

 abandonCmd :: GhciMonad m => String -> m ()

   | otherwise       = liftIO $ putStrLn "Syntax:  :back [num]"

   where

   back num = withSandboxOnly ":back" $ do

       printForUser $ text "Logged breakpoint at" <+> ppr pan

        -- run the command set with ":set stop <cmd>"

       st <- getGHCiState

       enqueueCommands [stop st]

   | otherwise       = liftIO $ putStrLn "Syntax:  :forward [num]"

   where

   forward num = withSandboxOnly ":forward" $ do

       printForUser $ (if (ix == 0)

                         then text "Stopped at"

                         else text "Logged breakpoint at") <+> ppr pan

        -- run the command set with ":set stop <cmd>"

       st <- getGHCiState

       enqueueCommands [stop st]

                                                    (EvalThis fhv) }

     Just <$> GHC.execStmt' stmt stmt_text opts

 runDecls decls = do

   st <- getGHCiState

   reifyGHCi $ \x ->

           r <- GHC.runDeclsWithLocation (progname st) (line_number st) decls

           return (Just r)

 runDecls' decls = do

   st <- getGHCiState

   reifyGHCi $ \x ->

 test('T26042g', extra_files(['T26042g.hs']), ghci_script, ['T26042g.script'])

 test('T27633c', extra_files(['T27633c_obj.hs']), ghci_script, ['T27633c.script'])