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

module Haskell.Debug.Adapter.State.Contaminated where

import Control.Monad.IO.Class
import qualified System.Log.Logger as L

import qualified Haskell.DAP as DAP
import Haskell.Debug.Adapter.Type
import qualified Haskell.Debug.Adapter.Utility as U
import Haskell.Debug.Adapter.Constant
import qualified Haskell.Debug.Adapter.State.Utility as SU


-- |
--
instance AppStateIF ContaminatedStateData where
  -- |
  --
  entryAction :: AppState ContaminatedStateData -> AppContext ()
entryAction AppState ContaminatedStateData
ContaminatedState = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP ErrMsg
"ContaminatedState entryAction called."
    () -> AppContext ()
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


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


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

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

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

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

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

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

    TerminateRequest -> AppContext ()
SU.terminateRequest TerminateRequest
req

    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
Contaminated_Shutdown

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.SetBreakpointsRequest where
  action :: AppState ContaminatedStateData
-> Request SetBreakpointsRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (SetBreakpointsRequest SetBreakpointsRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState SetBreakpointsRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ SetBreakpointsRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show SetBreakpointsRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: SetBreakpointsResponse
res = SetBreakpointsResponse
DAP.defaultSetBreakpointsResponse {
              DAP.seqSetBreakpointsResponse = resSeq
            , DAP.request_seqSetBreakpointsResponse = DAP.seqSetBreakpointsRequest req
            , DAP.successSetBreakpointsResponse = False
            , DAP.messageSetBreakpointsResponse = "Contaminated State. need restart."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ SetBreakpointsResponse -> Response
SetBreakpointsResponse SetBreakpointsResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.SetFunctionBreakpointsRequest where
  action :: AppState ContaminatedStateData
-> Request SetFunctionBreakpointsRequest
-> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (SetFunctionBreakpointsRequest SetFunctionBreakpointsRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState SetFunctionBreakpointsRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ SetFunctionBreakpointsRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show SetFunctionBreakpointsRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: SetFunctionBreakpointsResponse
res = SetFunctionBreakpointsResponse
DAP.defaultSetFunctionBreakpointsResponse {
              DAP.seqSetFunctionBreakpointsResponse = resSeq
            , DAP.request_seqSetFunctionBreakpointsResponse = DAP.seqSetFunctionBreakpointsRequest req
            , DAP.successSetFunctionBreakpointsResponse = False
            , DAP.messageSetFunctionBreakpointsResponse = "Contaminated State. need restart."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ SetFunctionBreakpointsResponse -> Response
SetFunctionBreakpointsResponse SetFunctionBreakpointsResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.SetExceptionBreakpointsRequest where
  action :: AppState ContaminatedStateData
-> Request SetExceptionBreakpointsRequest
-> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (SetExceptionBreakpointsRequest SetExceptionBreakpointsRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState SetExceptionBreakpointsRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ SetExceptionBreakpointsRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show SetExceptionBreakpointsRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: SetExceptionBreakpointsResponse
res = SetExceptionBreakpointsResponse
DAP.defaultSetExceptionBreakpointsResponse {
              DAP.seqSetExceptionBreakpointsResponse = resSeq
            , DAP.request_seqSetExceptionBreakpointsResponse = DAP.seqSetExceptionBreakpointsRequest req
            , DAP.successSetExceptionBreakpointsResponse = False
            , DAP.messageSetExceptionBreakpointsResponse = "Contaminated State. need restart."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ SetExceptionBreakpointsResponse -> Response
SetExceptionBreakpointsResponse SetExceptionBreakpointsResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

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

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.ThreadsRequest where
  action :: AppState ContaminatedStateData
-> Request ThreadsRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (ThreadsRequest ThreadsRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState ThreadsRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ ThreadsRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show ThreadsRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: ThreadsResponse
res = ThreadsResponse
DAP.defaultThreadsResponse {
              DAP.seqThreadsResponse = resSeq
            , DAP.request_seqThreadsResponse = DAP.seqThreadsRequest req
            , DAP.successThreadsResponse = True
            , DAP.messageThreadsResponse = "Contaminated State. need restart."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ThreadsResponse -> Response
ThreadsResponse ThreadsResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.StackTraceRequest where
  action :: AppState ContaminatedStateData
-> Request StackTraceRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (StackTraceRequest StackTraceRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState StackTraceRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ StackTraceRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show StackTraceRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: StackTraceResponse
res = StackTraceResponse
DAP.defaultStackTraceResponse {
              DAP.seqStackTraceResponse = resSeq
            , DAP.request_seqStackTraceResponse = DAP.seqStackTraceRequest req
            , DAP.successStackTraceResponse = False
            , DAP.messageStackTraceResponse = "Contaminated State. need restart."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ StackTraceResponse -> Response
StackTraceResponse StackTraceResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.ScopesRequest where
  action :: AppState ContaminatedStateData
-> Request ScopesRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (ScopesRequest ScopesRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState ScopesRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ ScopesRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show ScopesRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: ScopesResponse
res = ScopesResponse
DAP.defaultScopesResponse {
              DAP.seqScopesResponse = resSeq
            , DAP.request_seqScopesResponse = DAP.seqScopesRequest req
            , DAP.successScopesResponse = False
            , DAP.messageScopesResponse = "Contaminated State. need restart."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ScopesResponse -> Response
ScopesResponse ScopesResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.VariablesRequest where
  action :: AppState ContaminatedStateData
-> Request VariablesRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (VariablesRequest VariablesRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState VariablesRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ VariablesRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show VariablesRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: VariablesResponse
res = VariablesResponse
DAP.defaultVariablesResponse {
              DAP.seqVariablesResponse = resSeq
            , DAP.request_seqVariablesResponse = DAP.seqVariablesRequest req
            , DAP.successVariablesResponse = False
            , DAP.messageVariablesResponse = "Contaminated State. need restart."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ VariablesResponse -> Response
VariablesResponse VariablesResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.SourceRequest where
  action :: AppState ContaminatedStateData
-> Request SourceRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (SourceRequest SourceRequest
req) = do
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: SourceResponse
res = SourceResponse
DAP.defaultSourceResponse {
        DAP.seqSourceResponse = resSeq
      , DAP.request_seqSourceResponse = DAP.seqSourceRequest req
      , DAP.successSourceResponse = False
      , DAP.messageSourceResponse = "Contaminated State. need restart."
      }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ SourceResponse -> Response
SourceResponse SourceResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.ContinueRequest where
  action :: AppState ContaminatedStateData
-> Request ContinueRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (ContinueRequest ContinueRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState ContinueRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ ContinueRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show ContinueRequest
req
    AppContext ()
restartEvent
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
Contaminated_Shutdown

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.NextRequest where
  action :: AppState ContaminatedStateData
-> Request NextRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (NextRequest NextRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState NextRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ NextRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show NextRequest
req
    AppContext ()
restartEvent
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
Contaminated_Shutdown

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData DAP.StepInRequest where
  action :: AppState ContaminatedStateData
-> Request StepInRequest -> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (StepInRequest StepInRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState StepInRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ StepInRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show StepInRequest
req
    AppContext ()
restartEvent
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
Contaminated_Shutdown

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

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

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF ContaminatedStateData HdaInternalTerminateRequest where
  action :: AppState ContaminatedStateData
-> Request HdaInternalTerminateRequest
-> AppContext (Maybe StateTransit)
action AppState ContaminatedStateData
_ (InternalTerminateRequest HdaInternalTerminateRequest
req) = do
    IO () -> AppContext ()
forall a. IO a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ErrMsg -> ErrMsg -> IO ()
L.debugM ErrMsg
_LOG_APP (ErrMsg -> IO ()) -> ErrMsg -> IO ()
forall a b. (a -> b) -> a -> b
$ ErrMsg
"ContaminatedState InternalTerminateRequest called. " ErrMsg -> ErrMsg -> ErrMsg
forall a. [a] -> [a] -> [a]
++ HdaInternalTerminateRequest -> ErrMsg
forall a. Show a => a -> ErrMsg
show HdaInternalTerminateRequest
req
    AppContext ()
SU.internalTerminateRequest
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a. a -> StateT AppStores (ExceptT ErrMsg IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
Contaminated_Shutdown

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

-- |
--
restartEvent :: AppContext ()
restartEvent :: AppContext ()
restartEvent = do
  AppContext ()
SU.terminateGHCi

  ErrMsg -> AppContext ()
U.sendConsoleEventLF ErrMsg
""
  ErrMsg -> AppContext ()
U.sendConsoleEventLF ErrMsg
"restarting debug adapter."
  ErrMsg -> AppContext ()
U.sendConsoleEventLF ErrMsg
""

  AppContext ()
U.sendRestartEvent
  AppContext ()
U.sendExitedEvent