content: {-# LANGUAGE CPP, MagicHash, NondecreasingIndentation, UnboxedTuples,
      RecordWildCards, BangPatterns #-}
  
  -- -----------------------------------------------------------------------------
  --
  -- (c) The University of Glasgow, 2005-2007
  --
  -- Running statements interactively
  --
  -- -----------------------------------------------------------------------------
  
  module Eta.Main.InteractiveEval (
          Resume(..), History(..),
          execStmt, ExecOptions(..), execOptions, ExecResult(..), resumeExec,
          runDecls, runDeclsWithLocation,
          isStmt, hasImport, isImport, isDecl,
          parseImportDecl, SingleStep(..),
          abandon, abandonAll,
          getResumeContext,
          getHistorySpan,
          getModBreaks,
          getHistoryModule,
          back, forward,
          setContext, getContext,
          availsToGlobalRdrEnv,
          getNamesInScope,
          getRdrNamesInScope,
          moduleIsInterpreted,
          getInfo,
          exprType,
          typeKind,
          parseName,
          showModule,
          moduleIsBootOrNotObjectLinkable,
          parseExpr, compileParsedExpr,
          compileExpr, dynCompileExpr,
          compileExprRemote, compileParsedExprRemote,
          Term, obtainTermFromId, obtainTermFromVal, reconstructType
          ) where
  
  #include "HsVersions.h"
  
  import Eta.Main.InteractiveEvalTypes
  
  import Eta.REPL as GHCi
  import Eta.REPL.Message
  import Eta.REPL.RemoteTypes
  import Eta.Main.GhcMonad
  import Eta.Main.HscMain
  import Eta.HsSyn.HsSyn
  import Eta.Main.HscTypes
  import Eta.Types.InstEnv
  import Eta.Iface.IfaceEnv   ( newInteractiveBinder )
  import Eta.Types.FamInstEnv ( FamInst )
  import Eta.Core.CoreFVs    ( orphNamesOfFamInst )
  import Eta.Types.TyCon
  import Eta.Types.Type             hiding( typeKind )
  -- import RepType
  import Eta.Types.TypeRep (noFreeVarsOfType)
  import Eta.TypeCheck.TcType           hiding( typeKind )
  import Eta.BasicTypes.Var
  import Eta.BasicTypes.Id as Id
  import Eta.BasicTypes.Name             hiding ( varName )
  import Eta.BasicTypes.NameSet
  import Eta.BasicTypes.Avail
  import Eta.BasicTypes.RdrName
  import Eta.BasicTypes.VarEnv
  -- import ByteCodeTypes
  import Eta.REPL.Linker as Linker
  import Eta.Main.DynFlags
  import Eta.BasicTypes.Unique
  import Eta.BasicTypes.UniqSupply
  import Eta.Utils.MonadUtils
  import Eta.BasicTypes.Module
  import Eta.Prelude.PrelNames  ( pretendNameIsInScope, toDynName )
  import Eta.Utils.Panic
  import Eta.Utils.Maybes
  import Eta.Main.ErrUtils
  import Eta.BasicTypes.SrcLoc
  -- import RtClosureInspect
  import Eta.Utils.Outputable
  import Eta.Utils.FastString
  import Eta.Utils.Bag
  import Eta.Utils.Util
  import qualified Eta.Parser.Lexer as Lexer (P (..), ParseResult(..), unP, mkPState)
  import qualified Eta.Parser.Parser as Parser (parseStmt, parseModule, parseDeclaration, parseImport)
  
  import System.Directory
  import Data.Dynamic
  import Data.Either
  -- import qualified Data.IntMap as IntMap
  import Data.List (find,intercalate)
  import Eta.Utils.StringBuffer (stringToStringBuffer)
  import Control.Monad
  import GHC.Exts
  import Data.Array
  import Eta.Utils.Exception
  import Eta.BasicTypes.VarSet
  import Eta.Utils.OrdList
  
  -- -----------------------------------------------------------------------------
  -- running a statement interactively
  
  getResumeContext :: GhcMonad m => m [Resume]
  getResumeContext = withSession (return . ic_resume . hsc_IC)
  
  mkHistory :: HscEnv -> ForeignHValue -> BreakInfo -> History
  mkHistory hsc_env hval bi = History hval bi (findEnclosingDecls hsc_env bi)
  
  getHistoryModule :: History -> Module
  getHistoryModule = breakInfo_module . historyBreakInfo
  
  getHistorySpan :: HscEnv -> History -> SrcSpan
  getHistorySpan hsc_env History{..} =
    let BreakInfo{..} = historyBreakInfo in
    case lookupHpt (hsc_HPT hsc_env) (moduleName breakInfo_module) of
      Just hmi -> modBreaks_locs (getModBreaks hmi) ! breakInfo_number
      _ -> panic "getHistorySpan"
  
  getModBreaks :: HomeModInfo -> ModBreaks
  getModBreaks _hmi
    -- TODO: Implement breakpoints
    -- | Just linkable <- hm_linkable hmi,
    --   [BCOs _cbc _] <- linkableUnlinked linkable
    -- = emptyModBreaks
    -- -- = fromMaybe emptyModBreaks (bc_breaks cbc)
    -- | otherwise
    = emptyModBreaks -- probably object code
  
  {- | 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.
  findEnclosingDecls :: HscEnv -> BreakInfo -> [String]
  findEnclosingDecls hsc_env (BreakInfo modl ix) =
     let hmi = expectJust "findEnclosingDecls" $
               lookupHpt (hsc_HPT hsc_env) (moduleName modl)
         mb = getModBreaks hmi
     in modBreaks_decls mb ! ix
  
  -- | Update fixity environment in the current interactive context.
  updateFixityEnv :: GhcMonad m => FixityEnv -> m ()
  updateFixityEnv fix_env = do
    hsc_env <- getSession
    let ic = hsc_IC hsc_env
    setSession $ hsc_env { hsc_IC = ic { ic_fix_env = fix_env } }
  
  -- -----------------------------------------------------------------------------
  -- execStmt
  
  -- | default ExecOptions
  execOptions :: ExecOptions
  execOptions = ExecOptions
    { execSingleStep = RunToCompletion
    , execSourceFile = "<interactive>"
    , execLineNumber = 1
    , execWrap = EvalThis -- just run the statement, don't wrap it in anything
    }
  
  -- | Run a statement in the current interactive context.
  execStmt
    :: GhcMonad m
    => String             -- ^ a statement (bind or expression)
    -> ExecOptions
    -> m (Either Reinterpret ExecResult)
  execStmt stmt ExecOptions{..} = do
      hsc_env <- getSession
  
      -- Turn off -fwarn-unused-local-binds when running a statement, to hide
      -- warnings about the implicit bindings we introduce.
      let ic       = hsc_IC hsc_env -- use the interactive dflags
          idflags' = ic_dflags ic `wopt_unset` Opt_WarnUnusedBinds
          hsc_env' = hsc_env{ hsc_IC = ic{ ic_dflags = idflags' } }
  
      -- compile to value (IO [HValue]), don't run
      r <- liftIO $ hscStmtWithLocation hsc_env' stmt
                      execSourceFile execLineNumber
  
      case r of
        -- empty statement / comment
        Nothing -> return $ Right $ ExecComplete (Right []) 0
  
        Just res -> case res of
            Right (ids, hval, fix_env) -> do
              updateFixityEnv fix_env
  
              status <-
                  withVirtualCWD $
                      liftIO $
                      evalStmt hsc_env' (isStep execSingleStep) (execWrap hval)
  
              let ic = hsc_IC hsc_env
                  bindings = (ic_tythings ic, ic_rn_gbl_env ic)
  
                  size = ghciHistSize idflags'
  
              fmap Right $ handleRunStatus execSingleStep stmt bindings ids
                             status (emptyHistory size)
            Left reinterpret -> return $ Left reinterpret
  
  
  runDecls :: GhcMonad m => String -> m [Name]
  runDecls = runDeclsWithLocation "<interactive>" 1
  
  -- | Run some declarations and return any user-visible names that were brought
  -- into scope.
  runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name]
  runDeclsWithLocation source linenumber expr =
    do
      hsc_env <- getSession
      (tyThings, ic) <- liftIO $ hscDeclsWithLocation hsc_env expr source linenumber
  
      setSession $ hsc_env { hsc_IC = ic }
      -- TODO: Handle rttiEnvironment
      -- hsc_env <- getSession
      -- hsc_env' <- liftIO $ rttiEnvironment hsc_env
      -- setSession hsc_env'
      return $ filter (not . isDerivedOccName . nameOccName)
               -- For this filter, see Note [What to show to users]
             $ map getName tyThings
  
  {- Note [What to show to users]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  We don't want to display internally-generated bindings to users.
  Things like the coercion axiom for newtypes. These bindings all get
  OccNames that users can't write, to avoid the possiblity of name
  clashes (in linker symbols).  That gives a convenient way to suppress
  them. The relevant predicate is OccName.isDerivedOccName.
  See Trac #11051 for more background and examples.
  -}
  
  withVirtualCWD :: GhcMonad m => m a -> m a
  withVirtualCWD m = do
    hsc_env <- getSession
  
      -- a virtual CWD is only necessary when we're running interpreted code in
      -- the same process as the compiler.
    if gopt Opt_ExternalInterpreter (hsc_dflags hsc_env) then m else do
  
    let ic = hsc_IC hsc_env
    let set_cwd = do
          dir <- liftIO $ getCurrentDirectory
          case ic_cwd ic of
             Just dir -> liftIO $ setCurrentDirectory dir
             Nothing  -> return ()
          return dir
  
        reset_cwd orig_dir = do
          virt_dir <- liftIO $ getCurrentDirectory
          hsc_env <- getSession
          let old_IC = hsc_IC hsc_env
          setSession hsc_env{  hsc_IC = old_IC{ ic_cwd = Just virt_dir } }
          liftIO $ setCurrentDirectory orig_dir
  
    gbracket set_cwd reset_cwd $ \_ -> m
  
  parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
  parseImportDecl expr = withSession $ \hsc_env -> liftIO $ hscImport hsc_env expr
  
  emptyHistory :: Int -> BoundedList History
  emptyHistory size = nilBL size
  
  handleRunStatus :: GhcMonad m
                  => SingleStep -> String-> ([TyThing],GlobalRdrEnv) -> [Id]
                  -> EvalStatus_ [ForeignHValue] [HValueRef]
                  -> BoundedList History
                  -> m ExecResult
  
  handleRunStatus step expr bindings final_ids status history
    | RunAndLogSteps <- step = tracing
    | otherwise              = not_tracing
   where
    tracing
      | EvalBreak is_exception apStack_ref ix mod_uniq resume_ctxt <- status
      , not is_exception
      = do
         hsc_env <- getSession
         let hmi = expectJust "handleRunStatus" $
                     lookupHptDirectly (hsc_HPT hsc_env)
                                       (mkUniqueGrimily mod_uniq)
             modl = mi_module (hm_iface hmi)
             _breaks = getModBreaks hmi
  
         b <- liftIO $ panic "breakpointStatus: breakpoints not implemented yet"
                -- breakpointStatus hsc_env (modBreaks_flags breaks) ix
         if b
           then not_tracing
             -- This breakpoint is explicitly enabled; we want to stop
             -- instead of just logging it.
           else do
             apStack_fhv <- liftIO $ mkFinalizedHValue hsc_env apStack_ref
             let bi = BreakInfo modl ix
                 !history' = mkHistory hsc_env apStack_fhv bi `consBL` history
                   -- history is strict, otherwise our BoundedList is pointless.
             _fhv <- liftIO $ mkFinalizedHValue hsc_env resume_ctxt
             status <- liftIO $ panic "resumeStmt: breakpoints not implemented yet"
               -- GHCi.resumeStmt hsc_env True fhv
             handleRunStatus RunAndLogSteps expr bindings final_ids
                             status history'
      | otherwise
      = not_tracing
  
    not_tracing
      -- Hit a breakpoint
      | EvalBreak is_exception apStack_ref ix mod_uniq resume_ctxt <- status
      = do
           hsc_env <- getSession
           resume_ctxt_fhv <- liftIO $ mkFinalizedHValue hsc_env resume_ctxt
           apStack_fhv <- liftIO $ mkFinalizedHValue hsc_env apStack_ref
           let hmi = expectJust "handleRunStatus" $
                       lookupHptDirectly (hsc_HPT hsc_env)
                                         (mkUniqueGrimily mod_uniq)
               modl = mi_module (hm_iface hmi)
               bp | is_exception = Nothing
                  | otherwise = Just (BreakInfo modl ix)
           (hsc_env1, names, span, decl) <- liftIO $
             bindLocalsAtBreakpoint hsc_env apStack_fhv bp
           let
             resume = Resume
               { resumeStmt = expr, resumeContext = resume_ctxt_fhv
               , resumeBindings = bindings, resumeFinalIds = final_ids
               , resumeApStack = apStack_fhv
               , resumeBreakInfo = bp
               , resumeSpan = span, resumeHistory = toListBL history
               , resumeDecl = decl
               , resumeCCS = panic "resumeCCS not handled!"
               , resumeHistoryIx = 0 }
             hsc_env2 = pushResume hsc_env1 resume
  
           setSession hsc_env2
           return (ExecBreak names bp)
  
      -- Completed successfully
      | EvalComplete allocs (EvalSuccess _ hvals) <- status
      = do hsc_env <- getSession
           let final_ic = extendInteractiveContextWithIds (hsc_IC hsc_env) final_ids
               final_names = map getName final_ids
           liftIO $ Linker.extendLinkEnv (zip final_names hvals)
           -- TODO: Handle rttiEnvironment
           -- hsc_env' <- liftIO $ rttiEnvironment hsc_env{hsc_IC=final_ic}
           setSession $ hsc_env { hsc_IC = final_ic }
           return (ExecComplete (Right final_names) allocs)
  
      -- Completed with an exception
      | EvalComplete alloc (EvalException _ e) <- status
      = return (ExecComplete (Left (fromSerializableException e)) alloc)
  
      | otherwise
      = panic "not_tracing" -- actually exhaustive, but GHC can't tell
  
  
  resumeExec :: GhcMonad m => (SrcSpan->Bool) -> SingleStep -> m ExecResult
  resumeExec canLogSpan step
   = do
     hsc_env <- getSession
     let ic = hsc_IC hsc_env
         resume = ic_resume ic
  
     case resume of
       [] -> liftIO $
             throwGhcExceptionIO (ProgramError "not stopped at a breakpoint")
       (r:rs) -> do
          -- unbind the temporary locals by restoring the TypeEnv from
          -- before the breakpoint, and drop this Resume from the
          -- InteractiveContext.
          let (resume_tmp_te,resume_rdr_env) = resumeBindings r
              ic' = ic { ic_tythings = resume_tmp_te,
                         ic_rn_gbl_env = resume_rdr_env,
                         ic_resume   = rs }
          setSession hsc_env{ hsc_IC = ic' }
  
          -- remove any bindings created since the breakpoint from the
          -- linker's environment
          let _old_names = map getName resume_tmp_te
              _new_names = [ n | thing <- ic_tythings ic
                              , let n = getName thing
                              , not (n `elem` []) ]
          -- liftIO $ Linker.deleteFromLinkEnv new_names
          _ <- panic "Linker.deleteFromLinkEnv not handled"
  
          case r of
            Resume { resumeStmt = expr, resumeContext = _fhv
                   , resumeBindings = bindings, resumeFinalIds = final_ids
                   , resumeApStack = apStack, resumeBreakInfo = mb_brkpt
                   , resumeSpan = span
                   , resumeHistory = hist } -> do
                 withVirtualCWD $ do
                  status <- liftIO $
                    panic "resumeExec: resumeStmt: breakpoints not implemented yet"
                  -- GHCi.resumeStmt hsc_env (isStep step) fhv
                  let prevHistoryLst = fromListBL 50 hist
                      hist' = case mb_brkpt of
                         Nothing -> prevHistoryLst
                         Just bi
                           | not $canLogSpan span -> prevHistoryLst
                           | otherwise -> mkHistory hsc_env apStack bi `consBL`
                                                          fromListBL 50 hist
                  handleRunStatus step expr bindings final_ids status hist'
  
  back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String)
  back n = moveHist (+n)
  
  forward :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String)
  forward n = moveHist (subtract n)
  
  moveHist :: GhcMonad m => (Int -> Int) -> m ([Name], Int, SrcSpan, String)
  moveHist fn = do
    hsc_env <- getSession
    case ic_resume (hsc_IC hsc_env) of
       [] -> liftIO $
             throwGhcExceptionIO (ProgramError "not stopped at a breakpoint")
       (r:rs) -> do
          let ix = resumeHistoryIx r
              history = resumeHistory r
              new_ix = fn ix
          --
          when (history `lengthLessThan` new_ix) $ liftIO $
             throwGhcExceptionIO (ProgramError "no more logged breakpoints")
          when (new_ix < 0) $ liftIO $
             throwGhcExceptionIO (ProgramError "already at the beginning of the history")
  
          let
            update_ic apStack mb_info = do
              (hsc_env1, names, span, decl) <-
                liftIO $ bindLocalsAtBreakpoint hsc_env apStack mb_info
              let ic = hsc_IC hsc_env1
                  r' = r { resumeHistoryIx = new_ix }
                  ic' = ic { ic_resume = r':rs }
  
              setSession hsc_env1{ hsc_IC = ic' }
  
              return (names, new_ix, span, decl)
  
          -- careful: we want apStack to be the AP_STACK itself, not a thunk
          -- around it, hence the cases are carefully constructed below to
          -- make this the case.  ToDo: this is v. fragile, do something better.
          if new_ix == 0
             then case r of
                     Resume { resumeApStack = apStack,
                              resumeBreakInfo = mb_brkpt } ->
                            update_ic apStack mb_brkpt
             else case history !! (new_ix - 1) of
                     History{..} ->
                       update_ic historyApStack (Just historyBreakInfo)
  
  
  -- -----------------------------------------------------------------------------
  -- After stopping at a breakpoint, add free variables to the environment
  
  result_fs :: FastString
  result_fs = fsLit "_result"
  
  bindLocalsAtBreakpoint
          :: HscEnv
          -> ForeignHValue
          -> Maybe BreakInfo
          -> IO (HscEnv, [Name], SrcSpan, String)
  
  -- Nothing case: we stopped when an exception was raised, not at a
  -- breakpoint.  We have no location information or local variables to
  -- bind, all we can do is bind a local variable to the exception
  -- value.
  bindLocalsAtBreakpoint hsc_env _apStack Nothing = do
     let exn_occ = mkVarOccFS (fsLit "_exception")
         span    = mkGeneralSrcSpan (fsLit "<unknown>")
     exn_name <- newInteractiveBinder hsc_env exn_occ span
  
     let e_fs    = fsLit "e"
         e_name  = mkInternalName (getUnique e_fs) (mkTyVarOccFS e_fs) span
         e_tyvar = mkRuntimeUnkTyVar e_name liftedTypeKind
         exn_id  = Id.mkVanillaGlobal exn_name (mkTyVarTy e_tyvar)
  
         ictxt0 = hsc_IC hsc_env
         ictxt1 = extendInteractiveContextWithIds ictxt0 [exn_id]
     --
     -- Linker.extendLinkEnv [(exn_name, apStack)]
     _ <- panic "Linker.extendLinkEnv exn_name not handled!"
     return (hsc_env{ hsc_IC = ictxt1 }, [exn_name], span, "<exception thrown>")
  
  -- Just case: we stopped at a breakpoint, we have information about the location
  -- of the breakpoint and the free variables of the expression.
  bindLocalsAtBreakpoint hsc_env _apStack_fhv (Just BreakInfo{..}) = do
     let
         hmi       = expectJust "bindLocalsAtBreakpoint" $
                       lookupHpt (hsc_HPT hsc_env) (moduleName breakInfo_module)
         breaks    = getModBreaks hmi
         _info      = expectJust "bindLocalsAtBreakpoint2" $
                       -- IntMap.lookup breakInfo_number (modBreaks_breakInfo breaks)
                       panic "modBreaks_breakInfo not handled!"
         vars      = panic "cgb_vars not handled!"
         result_ty = panic "cgb_resty not handled!"
         occs      = modBreaks_vars breaks ! breakInfo_number
         span      = modBreaks_locs breaks ! breakInfo_number
         decl      = intercalate "." $ modBreaks_decls breaks ! breakInfo_number
  
             -- Filter out any unboxed ids;
             -- we can't bind these at the prompt
         pointers = filter (\(id,_) -> isPointer id) vars
         isPointer id | [rep] <- typePrimRepMany (idType id)
                      , isGcPtrRep rep                   = True
                      | otherwise                        = False
  
         (ids, _offsets) = unzip pointers
  
         free_tvs = varSetElems $ tyVarsOfTypes (result_ty:map idType ids)
  
     -- It might be that getIdValFromApStack fails, because the AP_STACK
     -- has been accidentally evaluated, or something else has gone wrong.
     -- So that we don't fall over in a heap when this happens, just don't
     -- bind any free variables instead, and we emit a warning.
     mb_hValues <- panic "mb_hValues not handled!"
        -- mapM (getBreakpointVar hsc_env apStack_fhv . fromIntegral) offsets
     when (any isNothing mb_hValues) $
        debugTraceMsg (hsc_dflags hsc_env) 1 $
            text "Warning: _result has been evaluated, some bindings have been lost"
  
     us <- mkSplitUniqSupply 'I'   -- Dodgy; will give the same uniques every time
     let tv_subst     = newTyVars us free_tvs
         filtered_ids = [ id | (id, Just _hv) <- zip ids mb_hValues ]
         (_,tidy_tys) = tidyOpenTypes emptyTidyEnv $
                        map (substTy tv_subst . idType) filtered_ids
  
     new_ids     <- zipWith3M mkNewId occs tidy_tys filtered_ids
     result_name <- newInteractiveBinder hsc_env (mkVarOccFS result_fs) span
  
     let result_id = Id.mkVanillaGlobal result_name
                       (substTy tv_subst result_ty)
         result_ok = isPointer result_id
  
         final_ids | result_ok = result_id : new_ids
                   | otherwise = new_ids
         ictxt0 = hsc_IC hsc_env
         ictxt1 = extendInteractiveContextWithIds ictxt0 final_ids
         names  = map idName new_ids
  
     let _fhvs = catMaybes mb_hValues
    --  Linker.extendLinkEnv (zip names fhvs)
    --  when result_ok $ Linker.extendLinkEnv [(result_name, apStack_fhv)]
     _ <- panic "Linker.extendLinkEnv result_name not handled!"
     hsc_env1 <- rttiEnvironment hsc_env{ hsc_IC = ictxt1 }
     return (hsc_env1, if result_ok then result_name:names else names, span, decl)
    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
          -- whenever we stop at a breakpoint.  The InteractveContext is properly
          -- saved/restored, but not the linker state.  See #1743, test break026.
     mkNewId :: OccName -> Type -> Id -> IO Id
     mkNewId occ ty old_id
       = do { name <- newInteractiveBinder hsc_env occ (getSrcSpan old_id)
            ; return (Id.mkVanillaGlobalWithInfo name ty (idInfo old_id)) }
  
     newTyVars :: UniqSupply -> [TcTyVar] -> TvSubst
       -- Similarly, clone the type variables mentioned in the types
       -- we have here, *and* make them all RuntimeUnk tyvars
     newTyVars _us _tvs
      --  = mkTvSubstPrs [ (tv, mkTyVarTy (mkRuntimeUnkTyVar name (tyVarKind tv)))
      --                 | (tv, uniq) <- tvs `zip` uniqsFromSupply us
      --                 , let name = setNameUnique (tyVarName tv) uniq ]
         = panic "mkTyVars not handled!"
  
  rttiEnvironment :: HscEnv -> IO HscEnv
  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]
     hsc_env' <- foldM improveTypes hsc_env (map idName incompletelyTypedIds)
     return hsc_env'
      where
       noSkolems = noFreeVarsOfType . idType
       improveTypes hsc_env@HscEnv{hsc_IC=ic} name = do
        let tmp_ids = [id | AnId id <- ic_tythings ic]
            Just id = find (\i -> idName i == name) tmp_ids
        if noSkolems id
           then return hsc_env
           else do
             mb_new_ty <- reconstructType hsc_env 10 id
             let _old_ty = idType id
             case mb_new_ty of
               Nothing -> return hsc_env
               Just _new_ty -> do
                case panic "improveRTTIType not handled!" of --improveRTTIType hsc_env old_ty new_ty of
                 Nothing -> return $
                          WARN(True, text (":print failed to calculate the "
                                             ++ "improvement for a type")) hsc_env
                 Just subst -> do
                   let dflags = hsc_dflags hsc_env
                   when (dopt Opt_D_dump_rtti dflags) $
                        printInfoForUser dflags alwaysQualify $
                        fsep [text "RTTI Improvement for", ppr id, equals, ppr subst]
  
                   let ic' = substInteractiveContext ic subst
                   return hsc_env{hsc_IC=ic'}
  
  pushResume :: HscEnv -> Resume -> HscEnv
  pushResume hsc_env resume = hsc_env { hsc_IC = ictxt1 }
    where
          ictxt0 = hsc_IC hsc_env
          ictxt1 = ictxt0 { ic_resume = resume : ic_resume ictxt0 }
  
  -- -----------------------------------------------------------------------------
  -- Abandoning a resume context
  
  abandon :: GhcMonad m => m Bool
  abandon = do
     hsc_env <- getSession
     let ic = hsc_IC hsc_env
         resume = ic_resume ic
     case resume of
        []    -> return False
        _r:rs  -> do
           setSession hsc_env{ hsc_IC = ic { ic_resume = rs } }
           _ <- liftIO $ panic "abandonStmt: breakpoints not implemented yet"
             -- abandonStmt hsc_env (resumeContext r)
           return True
  
  abandonAll :: GhcMonad m => m Bool
  abandonAll = do
     hsc_env <- getSession
     let ic = hsc_IC hsc_env
         resume = ic_resume ic
     case resume of
        []  -> return False
        _rs  -> do
           setSession hsc_env{ hsc_IC = ic { ic_resume = [] } }
           _ <- liftIO $ panic "abandonStmt: breakpoints not implemented yet"
           -- liftIO $ mapM_ (abandonStmt hsc_env. resumeContext) rs
           return True
  
  -- -----------------------------------------------------------------------------
  -- Bounded list, optimised for repeated cons
  
  data BoundedList a = BL
                          {-# UNPACK #-} !Int  -- length
                          {-# UNPACK #-} !Int  -- bound
                          [a] -- left
                          [a] -- right,  list is (left ++ reverse right)
  
  nilBL :: Int -> BoundedList a
  nilBL bound = BL 0 bound [] []
  
  consBL :: a -> BoundedList a -> BoundedList a
  consBL a (BL len bound left right)
    | len < bound = BL (len+1) bound (a:left) right
    | null right  = BL len     bound [a]      $! tail (reverse left)
    | otherwise   = BL len     bound (a:left) $! tail right
  
  toListBL :: BoundedList a -> [a]
  toListBL (BL _ _ left right) = left ++ reverse right
  
  fromListBL :: Int -> [a] -> BoundedList a
  fromListBL bound l = BL (length l) bound l []
  
  -- lenBL (BL len _ _ _) = len
  
  -- -----------------------------------------------------------------------------
  -- | Set the interactive evaluation context.
  --
  -- (setContext imports) sets the ic_imports field (which in turn
  -- determines what is in scope at the prompt) to 'imports', and
  -- constructs the ic_rn_glb_env environment to reflect it.
  --
  -- We retain in scope all the things defined at the prompt, and kept
  -- in ic_tythings.  (Indeed, they shadow stuff from ic_imports.)
  
  setContext :: GhcMonad m => [InteractiveImport] -> m ()
  setContext imports
    = do { hsc_env <- getSession
         ; let dflags = hsc_dflags hsc_env
         ; all_env_err <- liftIO $ findGlobalRdrEnv hsc_env imports
         ; case all_env_err of
             Left (mod, err) ->
                 liftIO $ throwGhcExceptionIO (formatError dflags mod err)
             Right all_env -> do {
         ; let old_ic         = hsc_IC hsc_env
               !final_rdr_env = all_env `icExtendGblRdrEnv` ic_tythings old_ic
         ; setSession
           hsc_env{ hsc_IC = old_ic { ic_imports    = imports
                                    , ic_rn_gbl_env = final_rdr_env }}}}
    where
      formatError dflags mod err = ProgramError . showSDoc dflags $
        text "Cannot add module" <+> ppr mod <+>
        text "to context:" <+> text err
  
  findGlobalRdrEnv :: HscEnv -> [InteractiveImport]
                   -> IO (Either (ModuleName, String) GlobalRdrEnv)
  -- Compute the GlobalRdrEnv for the interactive context
  findGlobalRdrEnv hsc_env imports
    = do { idecls_env <- hscRnImportDecls hsc_env idecls
                      -- This call also loads any orphan modules
         ; return $ case partitionEithers (map mkEnv imods) of
             ([], imods_env) -> Right (foldr plusGlobalRdrEnv idecls_env imods_env)
             (err : _, _)    -> Left err }
    where
      idecls :: [LImportDecl RdrName]
      idecls = [noLoc d | IIDecl d <- imports]
  
      imods :: [ModuleName]
      imods = [m | IIModule m <- imports]
  
      mkEnv mod = case mkTopLevEnv (hsc_HPT hsc_env) mod of
        Left err -> Left (mod, err)
        Right env -> Right env
  
  availsToGlobalRdrEnv :: ModuleName -> [AvailInfo] -> GlobalRdrEnv
  availsToGlobalRdrEnv mod_name avails
    = mkGlobalRdrEnv (gresFromAvails (Imported [imp_spec]) avails)
    where
        -- We're building a GlobalRdrEnv as if the user imported
        -- all the specified modules into the global interactive module
      imp_spec = ImpSpec { is_decl = decl, is_item = ImpAll}
      decl = ImpDeclSpec { is_mod = mod_name, is_as = mod_name,
                           is_qual = False,
                           is_dloc = srcLocSpan interactiveSrcLoc,
                           is_java = False }
  
  mkTopLevEnv :: HomePackageTable -> ModuleName -> Either String GlobalRdrEnv
  mkTopLevEnv hpt modl
    = case lookupHpt hpt modl of
        Nothing -> Left "not a home module"
        Just details ->
           case mi_globals (hm_iface details) of
                  Nothing  -> Left "not interpreted"
                  Just env -> Right env
  
  -- | Get the interactive evaluation context, consisting of a pair of the
  -- set of modules from which we take the full top-level scope, and the set
  -- of modules from which we take just the exports respectively.
  getContext :: GhcMonad m => m [InteractiveImport]
  getContext = withSession $ \HscEnv{ hsc_IC=ic } ->
               return (ic_imports ic)
  
  -- | Returns @True@ if the specified module is interpreted, and hence has
  -- its full top-level scope available.
  moduleIsInterpreted :: GhcMonad m => Module -> m Bool
  moduleIsInterpreted modl = withSession $ \h ->
   if moduleUnitId modl /= thisPackage (hsc_dflags h)
          then return False
          else case lookupHpt (hsc_HPT h) (moduleName modl) of
                  Just details       -> return (isJust (mi_globals (hm_iface details)))
                  _not_a_home_module -> return False
  
  -- | Looks up an identifier in the current interactive context (for :info)
  -- Filter the instances by the ones whose tycons (or clases resp)
  -- are in scope (qualified or otherwise).  Otherwise we list a whole lot too many!
  -- The exact choice of which ones to show, and which to hide, is a judgement call.
  --      (see Trac #1581)
  getInfo :: GhcMonad m => Bool -> Name
          -> m (Maybe (TyThing,Fixity,[ClsInst],[FamInst], SDoc))
  getInfo allInfo name
    = withSession $ \hsc_env ->
      do mb_stuff <- liftIO $ hscTcRnGetInfo hsc_env name
         case mb_stuff of
           Nothing -> return Nothing
           Just (thing, fixity, cls_insts, fam_insts, docs) -> do
             let rdr_env = ic_rn_gbl_env (hsc_IC hsc_env)
  
             -- Filter the instances based on whether the constituent names of their
             -- instance heads are all in scope.
             let cls_insts' = filter (plausible rdr_env . orphNamesOfClsInst) cls_insts
                 fam_insts' = filter (plausible rdr_env . orphNamesOfFamInst) fam_insts
             return (Just (thing, fixity, cls_insts', fam_insts', docs))
    where
      plausible rdr_env names
            -- Dfun involving only names that are in ic_rn_glb_env
          = allInfo
         || nameSetAll ok names
          where   -- A name is ok if it's in the rdr_env,
                  -- whether qualified or not
            ok n | n == name              = True
                         -- The one we looked for in the first place!
                 | pretendNameIsInScope n = True
                 | isBuiltInSyntax n      = True
                 | isExternalName n       = not (null (lookupGRE_Name rdr_env n))
                 | otherwise              = True
  
  -- | Returns all names in scope in the current interactive context
  getNamesInScope :: GhcMonad m => m [Name]
  getNamesInScope = withSession $ \hsc_env -> do
    return (map gre_name (globalRdrEnvElts (ic_rn_gbl_env (hsc_IC hsc_env))))
  
  -- | Returns all 'RdrName's in scope in the current interactive
  -- context, excluding any that are internally-generated.
  getRdrNamesInScope :: GhcMonad m => m [RdrName]
  getRdrNamesInScope = withSession $ \hsc_env -> do
    let
        ic = hsc_IC hsc_env
        gbl_rdrenv = ic_rn_gbl_env ic
        gbl_names = concatMap greRdrNames $ globalRdrEnvElts gbl_rdrenv
    -- Exclude internally generated names; see e.g. Trac #11328
    return (filter (not . isDerivedOccName . rdrNameOcc) gbl_names)
  
  
  -- | Parses a string as an identifier, and returns the list of 'Name's that
  -- the identifier can refer to in the current interactive context.
  parseName :: GhcMonad m => String -> m [Name]
  parseName str = withSession $ \hsc_env -> liftIO $
     do { lrdr_name <- hscParseIdentifier hsc_env str
        ; hscTcRnLookupRdrName hsc_env lrdr_name }
  
  -- | Returns @True@ if passed string is a statement.
  isStmt :: DynFlags -> String -> Bool
  isStmt dflags stmt =
    case parseThing Parser.parseStmt dflags stmt of
      Lexer.POk _ _ -> True
      Lexer.PFailed _ _ -> False
  
  -- | Returns @True@ if passed string has an import declaration.
  hasImport :: DynFlags -> String -> Bool
  hasImport dflags stmt =
    case parseThing Parser.parseModule dflags stmt of
      Lexer.POk _ thing -> hasImports thing
      Lexer.PFailed _ _ -> False
    where
      hasImports = not . null . hsmodImports . unLoc
  
  -- | Returns @True@ if passed string is an import declaration.
  isImport :: DynFlags -> String -> Bool
  isImport dflags stmt =
    case parseThing Parser.parseImport dflags stmt of
      Lexer.POk _ _ -> True
      Lexer.PFailed _ _ -> False
  
  -- | Returns @True@ if passed string is a declaration but __/not a splice/__.
  isDecl :: DynFlags -> String -> Bool
  isDecl dflags stmt = do
    case parseThing Parser.parseDeclaration dflags stmt of
      Lexer.POk _ thing ->
        case map unLoc (fromOL thing) of
          [SpliceD _] -> False
          _ -> True
      Lexer.PFailed _ _ -> False
  
  parseThing :: Lexer.P thing -> DynFlags -> String -> Lexer.ParseResult thing
  parseThing parser dflags stmt = do
    let buf = stringToStringBuffer stmt
        loc = mkRealSrcLoc (fsLit "<interactive>") 1 1
  
    Lexer.unP parser (Lexer.mkPState dflags buf loc)
  
  -- -----------------------------------------------------------------------------
  -- Getting the type of an expression
  
  -- | Get the type of an expression
  -- Returns the type as described by 'TcRnExprMode'
  exprType :: GhcMonad m => String -> m Type
  exprType expr = withSession $ \hsc_env -> do
     ty <- liftIO $ hscTcExpr hsc_env expr
     return $ tidyType emptyTidyEnv ty
  
  -- -----------------------------------------------------------------------------
  -- Getting the kind of a type
  
  -- | Get the kind of a  type
  typeKind  :: GhcMonad m => Bool -> String -> m (Type, Kind)
  typeKind normalise str = withSession $ \hsc_env -> do
     liftIO $ hscKcType hsc_env normalise str
  
  -----------------------------------------------------------------------------
  -- Compile an expression, run it, and deliver the result
  
  -- | Parse an expression, the parsed expression can be further processed and
  -- passed to compileParsedExpr.
  parseExpr :: GhcMonad m => String -> m (HsExpr RdrName)
  parseExpr expr = withSession $ \hsc_env -> do
    liftIO $ runInteractiveHsc hsc_env $ hscParseExpr expr
  
  -- | Compile an expression, run it, and deliver the resulting HValue.
  compileExpr :: GhcMonad m => String -> m HValue
  compileExpr expr = do
    parsed_expr <- parseExpr expr
    compileParsedExpr parsed_expr
  
  -- | Compile an expression, run it, and deliver the resulting HValue.
  compileExprRemote :: GhcMonad m => String -> m ForeignHValue
  compileExprRemote expr = do
    parsed_expr <- parseExpr expr
    compileParsedExprRemote parsed_expr
  
  -- | Compile a parsed expression (before renaming), run it, and deliver
  -- the resulting HValue.
  compileParsedExprRemote :: GhcMonad m => HsExpr RdrName -> m ForeignHValue
  compileParsedExprRemote expr = withSession $ \hsc_env -> do
    -- > let _compileParsedExpr = expr
    -- Create let stmt from expr to make hscParsedStmt happy.
    -- We will ignore the returned [Id], namely [expr_id], and not really
    -- create a new binding.
    let expr_fs = fsLit "_compileParsedExpr"
        expr_name = mkInternalName (getUnique expr_fs) (mkTyVarOccFS expr_fs) noSrcSpan
        let_stmt = L noSrcSpan . LetStmt . HsValBinds $
          ValBindsIn (unitBag $ mkHsVarBind noSrcSpan (getRdrName expr_name) (noLoc expr)) []
    Just (Right ([_id], hvals_io, fix_env)) <- liftIO $ hscParsedStmt hsc_env let_stmt
    updateFixityEnv fix_env
    status <- liftIO $ evalStmt hsc_env False (EvalThis hvals_io)
    case status of
      EvalComplete _ (EvalSuccess _ [hval]) -> return hval
      EvalComplete _ (EvalException _ e) ->
        liftIO $ throwIO (fromSerializableException e)
      _ -> panic "compileParsedExpr"
  
  compileParsedExpr :: GhcMonad m => HsExpr RdrName -> m HValue
  compileParsedExpr expr = do
     fhv <- compileParsedExprRemote expr
     dflags <- getDynFlags
     liftIO $ wormhole dflags fhv
  
  -- | Compile an expression, run it and return the result as a Dynamic.
  dynCompileExpr :: GhcMonad m => String -> m Dynamic
  dynCompileExpr expr = do
    parsed_expr <- parseExpr expr
    -- > Data.Dynamic.toDyn expr
    let -- loc = getLoc parsed_expr
        to_dyn_expr = mkHsApp (noLoc . HsVar $ getRdrName toDynName)
                              (noLoc parsed_expr)
    hval <- compileParsedExpr (unLoc to_dyn_expr)
    return (unsafeCoerce# hval :: Dynamic)
  
  -----------------------------------------------------------------------------
  -- show a module and it's source/object filenames
  
  showModule :: GhcMonad m => ModSummary -> m String
  showModule mod_summary =
      withSession $ \hsc_env -> do
          interpreted <- moduleIsBootOrNotObjectLinkable mod_summary
          let dflags = hsc_dflags hsc_env
          return (showModMsg dflags (hscTarget dflags) interpreted mod_summary)
  
  moduleIsBootOrNotObjectLinkable :: GhcMonad m => ModSummary -> m Bool
  moduleIsBootOrNotObjectLinkable mod_summary = withSession $ \hsc_env ->
    case lookupHpt (hsc_HPT hsc_env) (ms_mod_name mod_summary) of
          Nothing       -> panic "missing linkable"
          Just mod_info -> return $ case hm_linkable mod_info of
            Nothing       -> True
            Just linkable -> not (isObjectLinkable linkable)
  
  ----------------------------------------------------------------------------
  -- RTTI primitives
  
  type Term = ()
  
  obtainTermFromVal :: HscEnv -> Int -> Bool -> Type -> a -> IO Term
  obtainTermFromVal _hsc_env _bound _force _ty _x =
    panic "obtainTermFromVal not handled"
                -- cvObtainTerm hsc_env bound force ty (unsafeCoerce# x)
  
  obtainTermFromId :: HscEnv -> Int -> Bool -> Id -> IO Term
  obtainTermFromId _hsc_env _bound _force _id = panic "obtainTermFromId not handled!"
    -- do
    -- let dflags = hsc_dflags hsc_env
    -- hv <- Linker.getHValue hsc_env (varName id) >>= wormhole dflags
    -- panic "Linker.getHValue not handled!"
    -- cvObtainTerm hsc_env bound force (idType id) hv
  
  -- Uses RTTI to reconstruct the type of an Id, making it less polymorphic
  reconstructType :: HscEnv -> Int -> Id -> IO (Maybe Type)
  reconstructType _hsc_env _bound _id = panic "reconstructType not handled!"
    -- do
    -- let dflags = hsc_dflags hsc_env
    -- hv <- Linker.getHValue hsc_env (varName id) >>= wormhole dflags
    -- panic "Linker.getHValue not handled!"
    -- cvReconstructType hsc_env bound (idType id) hv
  
  mkRuntimeUnkTyVar :: Name -> Kind -> TyVar
  mkRuntimeUnkTyVar _name _kind = panic "mkRuntimeUnkTyVar not handled!"
    -- mkTcTyVar name kind RuntimeUnk
  