{-# LANGUAGE GADTs #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

module Haskell.Debug.Adapter.State.DebugRun where

import Control.Monad.IO.Class
import qualified System.Log.Logger as L
import Control.Monad.State.Lazy
import Control.Monad.Except
import Control.Lens
import qualified Text.Read as R

import qualified Haskell.DAP as DAP
import Haskell.Debug.Adapter.Constant
import qualified Haskell.Debug.Adapter.Utility as U
import Haskell.Debug.Adapter.Type
import qualified Haskell.Debug.Adapter.GHCi as P
import Haskell.Debug.Adapter.State.DebugRun.Threads()
import Haskell.Debug.Adapter.State.DebugRun.StackTrace()
import Haskell.Debug.Adapter.State.DebugRun.Scopes()
import Haskell.Debug.Adapter.State.DebugRun.Variables()
import Haskell.Debug.Adapter.State.DebugRun.Continue()
import Haskell.Debug.Adapter.State.DebugRun.Next()
import Haskell.Debug.Adapter.State.DebugRun.StepIn()
import Haskell.Debug.Adapter.State.DebugRun.Terminate()
import Haskell.Debug.Adapter.State.DebugRun.InternalTerminate()
import qualified Haskell.Debug.Adapter.State.Utility as SU


instance AppStateIF DebugRunStateData where
  -- |
  --
  entryAction :: AppState DebugRunStateData -> AppContext ()
entryAction AppState DebugRunStateData
DebugRunState = do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP ErrMsg
"DebugRunState entryAction called."
    AppContext ()
goEntry

  -- |
  --
  exitAction :: AppState DebugRunStateData -> AppContext ()
exitAction AppState DebugRunStateData
DebugRunState = do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP ErrMsg
"DebugRunState exitAction called."
    forall (m :: * -> *) a. Monad m => a -> m a
return ()


  -- |
  --
  doActivity :: AppState DebugRunStateData
-> WrapRequest -> AppContext (Maybe StateTransit)
doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@InitializeRequest{})              = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@LaunchRequest{})                  = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@DisconnectRequest{})              = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@PauseRequest{})                   = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@TerminateRequest{})               = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@SetBreakpointsRequest{})          = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@SetFunctionBreakpointsRequest{})  = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@SetExceptionBreakpointsRequest{}) = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@ConfigurationDoneRequest{})       = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@ThreadsRequest{})                 = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@StackTraceRequest{})              = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@ScopesRequest{})                  = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@VariablesRequest{})               = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@ContinueRequest{})                = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@NextRequest{})                    = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@StepInRequest{})                  = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@EvaluateRequest{})                = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@CompletionsRequest{})             = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@InternalTransitRequest{})         = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@InternalTerminateRequest{})       = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r
  doActivity AppState DebugRunStateData
s (WrapRequest r :: Request a
r@InternalLoadRequest{})            = forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
s Request a
r

-- |
--   default nop.
--
instance StateActivityIF DebugRunStateData DAP.InitializeRequest

-- |
--   default nop.
--
instance StateActivityIF DebugRunStateData DAP.LaunchRequest

-- |
--   default nop.
--
instance StateActivityIF DebugRunStateData DAP.DisconnectRequest

-- |
--   default nop.
--
instance StateActivityIF DebugRunStateData DAP.PauseRequest

-- |
--
goEntry :: AppContext ()
goEntry :: AppContext ()
goEntry = forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' AppStores Bool
stopOnEntryAppStores forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
  Bool
True  -> AppContext ()
stopOnEntry
  Bool
False -> AppContext ()
startDebug

-- |
--
stopOnEntry :: AppContext ()
stopOnEntry :: AppContext ()
stopOnEntry = do
  ErrMsg
startupFile <- forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' AppStores ErrMsg
startupAppStores forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *). MonadState s m => m s
get
  ErrMsg
startupFunc <- forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' AppStores ErrMsg
startupFuncAppStores forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *). MonadState s m => m s
get

  let funcName :: ErrMsg
funcName = if forall (t :: * -> *) a. Foldable t => t a -> Bool
null ErrMsg
startupFunc then ErrMsg
"main" else ErrMsg
startupFunc
      funcBp :: (ErrMsg, FunctionBreakpoint)
funcBp   = (ErrMsg
startupFile, ErrMsg -> Maybe ErrMsg -> Maybe ErrMsg -> FunctionBreakpoint
DAP.FunctionBreakpoint ErrMsg
funcName forall a. Maybe a
Nothing forall a. Maybe a
Nothing)
      cmd :: ErrMsg
cmd = ErrMsg
":dap-set-function-breakpoint " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
U.showDAP (ErrMsg, FunctionBreakpoint)
funcBp

  ErrMsg -> AppContext ()
P.command ErrMsg
cmd
  [ErrMsg]
res <- AppContext [ErrMsg]
P.expectPmpt

  [ErrMsg] -> AppContext ()
withAdhocAddDapHeader forall a b. (a -> b) -> a -> b
$ forall a. (a -> Bool) -> [a] -> [a]
filter (ErrMsg -> ErrMsg -> Bool
U.startswith ErrMsg
_DAP_HEADER) [ErrMsg]
res

  where
    -- |
    --
    withAdhocAddDapHeader :: [String] -> AppContext ()
    withAdhocAddDapHeader :: [ErrMsg] -> AppContext ()
withAdhocAddDapHeader [] = do
      ErrMsg -> ErrMsg -> AppContext ()
U.warnEV ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"can not set func breakpoint. no dap header found."
      AppContext ()
startDebug
    withAdhocAddDapHeader (ErrMsg
str:[]) = case forall a. Read a => ErrMsg -> Either ErrMsg a
R.readEither (forall a. Int -> [a] -> [a]
drop (forall (t :: * -> *) a. Foldable t => t a -> Int
length ErrMsg
_DAP_HEADER) ErrMsg
str) of
      Left ErrMsg
err -> do
        ErrMsg -> ErrMsg -> AppContext ()
U.warnEV ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"read response body failed. " forall a. [a] -> [a] -> [a]
++ ErrMsg
err forall a. [a] -> [a] -> [a]
++ ErrMsg
" : " forall a. [a] -> [a] -> [a]
++ ErrMsg
str
        AppContext ()
startDebug
      Right (Left ErrMsg
err) -> do
        ErrMsg -> ErrMsg -> AppContext ()
U.warnEV ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"set adhoc breakpoint failed. " forall a. [a] -> [a] -> [a]
++ ErrMsg
err forall a. [a] -> [a] -> [a]
++ ErrMsg
" : " forall a. [a] -> [a] -> [a]
++ ErrMsg
str
        AppContext ()
startDebug
      Right (Right Breakpoint
bp) -> do
        AppContext ()
startDebug
        Breakpoint -> AppContext ()
adhocDelBreakpoint Breakpoint
bp
    withAdhocAddDapHeader [ErrMsg]
_ = do
      ErrMsg -> ErrMsg -> AppContext ()
U.warnEV ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"can not set func breakpoint. ambiguous dap header found."
      AppContext ()
startDebug

    -- |
    --
    adhocDelBreakpoint :: DAP.Breakpoint -> AppContext ()
    adhocDelBreakpoint :: Breakpoint -> AppContext ()
adhocDelBreakpoint Breakpoint
bp = do
      let cmd :: ErrMsg
cmd = ErrMsg
":dap-delete-breakpoint " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
U.showDAP Breakpoint
bp

      ErrMsg -> AppContext ()
P.command ErrMsg
cmd
      [ErrMsg]
res <- AppContext [ErrMsg]
P.expectPmpt

      [ErrMsg] -> AppContext ()
withAdhocDelDapHeader forall a b. (a -> b) -> a -> b
$ forall a. (a -> Bool) -> [a] -> [a]
filter (ErrMsg -> ErrMsg -> Bool
U.startswith ErrMsg
_DAP_HEADER) [ErrMsg]
res

    -- |
    --
    withAdhocDelDapHeader :: [String] -> AppContext ()
    withAdhocDelDapHeader :: [ErrMsg] -> AppContext ()
withAdhocDelDapHeader [] = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ ErrMsg
"can not del func breakpoint. no dap header found."
    withAdhocDelDapHeader (ErrMsg
str:[]) = case forall a. Read a => ErrMsg -> Either ErrMsg a
R.readEither (forall a. Int -> [a] -> [a]
drop (forall (t :: * -> *) a. Foldable t => t a -> Int
length ErrMsg
_DAP_HEADER) ErrMsg
str) of
      Left ErrMsg
err -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ ErrMsg
"read response body failed. " forall a. [a] -> [a] -> [a]
++ ErrMsg
err forall a. [a] -> [a] -> [a]
++ ErrMsg
" : " forall a. [a] -> [a] -> [a]
++ ErrMsg
str
      Right (Left ErrMsg
err) -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ ErrMsg
"del adhoc breakpoint failed. " forall a. [a] -> [a] -> [a]
++ ErrMsg
err forall a. [a] -> [a] -> [a]
++ ErrMsg
" : " forall a. [a] -> [a] -> [a]
++ ErrMsg
str
      Right (Right ()
res) -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
res
    withAdhocDelDapHeader [ErrMsg]
_ = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ ErrMsg
"can not del func breakpoint. ambiguous dap header found."


-- |
--
startDebug :: AppContext ()
startDebug :: AppContext ()
startDebug = do
  ErrMsg
expr <- StateT AppStores (ExceptT ErrMsg IO) ErrMsg
getTraceExpr
  let args :: ContinueRequestArguments
args = ContinueRequestArguments
DAP.defaultContinueRequestArguments {
             exprContinueRequestArguments :: Maybe ErrMsg
DAP.exprContinueRequestArguments = forall a. a -> Maybe a
Just ErrMsg
expr
           }

  forall {a}. Show a => a -> AppContext ()
startDebugDAP ContinueRequestArguments
args

  where
    getTraceExpr :: StateT AppStores (ExceptT ErrMsg IO) ErrMsg
getTraceExpr = forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' AppStores ErrMsg
startupFuncAppStores forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      [] -> forall (m :: * -> *) a. Monad m => a -> m a
return ErrMsg
"main"
      ErrMsg
func -> do
        ErrMsg
funcArgs <- forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' AppStores ErrMsg
startupArgsAppStores forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *). MonadState s m => m s
get
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg
U.strip forall a b. (a -> b) -> a -> b
$ ErrMsg
func forall a. [a] -> [a] -> [a]
++ ErrMsg
" " forall a. [a] -> [a] -> [a]
++ ErrMsg
funcArgs

    startDebugDAP :: a -> AppContext ()
startDebugDAP a
args = do

      let dap :: ErrMsg
dap = ErrMsg
":dap-continue "
          cmd :: ErrMsg
cmd = ErrMsg
dap forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
U.showDAP a
args
          dbg :: ErrMsg
dbg = ErrMsg
dap forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
show a
args

      ErrMsg -> AppContext ()
P.command ErrMsg
cmd
      ErrMsg -> ErrMsg -> AppContext ()
U.debugEV ErrMsg
_LOG_APP ErrMsg
dbg
      AppContext [ErrMsg]
P.expectPmpt forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [ErrMsg] -> StateT AppStores (ExceptT ErrMsg IO) ErrMsg
SU.takeDapResult forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ErrMsg -> AppContext ()
dapHdl

      forall (m :: * -> *) a. Monad m => a -> m a
return ()

    -- |
    --
    dapHdl :: String -> AppContext ()
    dapHdl :: ErrMsg -> AppContext ()
dapHdl ErrMsg
str = case forall a. Read a => ErrMsg -> Either ErrMsg a
R.readEither ErrMsg
str of
      Left ErrMsg
err -> ErrMsg -> ErrMsg -> AppContext ()
errHdl ErrMsg
str ErrMsg
err
      Right (Left ErrMsg
err) -> ErrMsg -> ErrMsg -> AppContext ()
errHdl ErrMsg
str ErrMsg
err
      Right (Right StoppedEventBody
body) -> StoppedEventBody -> AppContext ()
U.handleStoppedEventBody StoppedEventBody
body

    -- |
    --
    errHdl :: String -> String -> AppContext()
    errHdl :: ErrMsg -> ErrMsg -> AppContext ()
errHdl ErrMsg
str ErrMsg
err = do
      let msg :: ErrMsg
msg = ErrMsg
"start debugging failed. " forall a. [a] -> [a] -> [a]
++ ErrMsg
err forall a. [a] -> [a] -> [a]
++ ErrMsg
" : " forall a. [a] -> [a] -> [a]
++ ErrMsg
str
      forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.errorM ErrMsg
_LOG_APP ErrMsg
msg
      ErrMsg -> AppContext ()
U.sendErrorEventLF ErrMsg
msg


-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF DebugRunStateData DAP.SetBreakpointsRequest where
  action :: AppState DebugRunStateData
-> Request SetBreakpointsRequest -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
_ (SetBreakpointsRequest SetBreakpointsRequest
req) = do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"DebugRunState SetBreakpointsRequest called. " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
show SetBreakpointsRequest
req
    SetBreakpointsRequest -> AppContext (Maybe StateTransit)
SU.setBreakpointsRequest SetBreakpointsRequest
req

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF DebugRunStateData DAP.SetExceptionBreakpointsRequest where
  action :: AppState DebugRunStateData
-> Request SetExceptionBreakpointsRequest
-> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
_ (SetExceptionBreakpointsRequest SetExceptionBreakpointsRequest
req) = do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"DebugRunState SetExceptionBreakpointsRequest called. " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
show SetExceptionBreakpointsRequest
req
    SetExceptionBreakpointsRequest -> AppContext (Maybe StateTransit)
SU.setExceptionBreakpointsRequest SetExceptionBreakpointsRequest
req

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF DebugRunStateData DAP.SetFunctionBreakpointsRequest where
  action :: AppState DebugRunStateData
-> Request SetFunctionBreakpointsRequest
-> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
_ (SetFunctionBreakpointsRequest SetFunctionBreakpointsRequest
req) = do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"DebugRunState SetFunctionBreakpointsRequest called. " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
show SetFunctionBreakpointsRequest
req
    SetFunctionBreakpointsRequest -> AppContext (Maybe StateTransit)
SU.setFunctionBreakpointsRequest SetFunctionBreakpointsRequest
req

-- |
--   default nop.
--
instance StateActivityIF DebugRunStateData DAP.ConfigurationDoneRequest

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF DebugRunStateData DAP.EvaluateRequest where
  action :: AppState DebugRunStateData
-> Request EvaluateRequest -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
_ (EvaluateRequest EvaluateRequest
req) = do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"DebugRunState EvaluateRequest called. " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
show EvaluateRequest
req
    EvaluateRequest -> AppContext (Maybe StateTransit)
SU.evaluateRequest EvaluateRequest
req

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF DebugRunStateData DAP.CompletionsRequest where
  action :: AppState DebugRunStateData
-> Request CompletionsRequest -> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
_ (CompletionsRequest CompletionsRequest
req) = do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"DebugRunState CompletionsRequest called. " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
show CompletionsRequest
req
    CompletionsRequest -> AppContext (Maybe StateTransit)
SU.completionsRequest CompletionsRequest
req

-- |
--   default nop.
--
instance StateActivityIF DebugRunStateData HdaInternalTransitRequest

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF DebugRunStateData HdaInternalLoadRequest where
  action :: AppState DebugRunStateData
-> Request HdaInternalLoadRequest
-> AppContext (Maybe StateTransit)
action AppState DebugRunStateData
_ (InternalLoadRequest HdaInternalLoadRequest
req) = do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP forall a b. (a -> b) -> a -> b
$ ErrMsg
"DebugRunState InternalLoadRequest called. " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> ErrMsg
show HdaInternalLoadRequest
req
    ErrMsg -> AppContext ()
SU.loadHsFile forall a b. (a -> b) -> a -> b
$ HdaInternalLoadRequest -> ErrMsg
pathHdaInternalLoadRequest HdaInternalLoadRequest
req
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just StateTransit
DebugRun_Contaminated