{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TypeInType #-}

module Language.LSP.Protocol.Message.Parsing where

import Language.LSP.Protocol.Internal.Method
import Language.LSP.Protocol.Message.LspId
import Language.LSP.Protocol.Message.Meta
import Language.LSP.Protocol.Message.Method
import Language.LSP.Protocol.Message.Types

import Data.Aeson
import Data.Aeson.Types
import Data.Function (on)
import Data.GADT.Compare
import Data.Kind
import Data.Proxy
import Data.Type.Equality
import GHC.TypeLits (sameSymbol)

-- ---------------------------------------------------------------------
-- Working with arbitrary messages
-- ---------------------------------------------------------------------

data FromServerMessage' a where
  FromServerMess :: forall t (m :: Method ServerToClient t) a. SMethod m -> TMessage m -> FromServerMessage' a
  FromServerRsp :: forall (m :: Method ClientToServer Request) a. a m -> TResponseMessage m -> FromServerMessage' a

type FromServerMessage = FromServerMessage' SMethod

instance Eq FromServerMessage where
  == :: FromServerMessage -> FromServerMessage -> Bool
(==) = Value -> Value -> Bool
forall a. Eq a => a -> a -> Bool
(==) (Value -> Value -> Bool)
-> (FromServerMessage -> Value)
-> FromServerMessage
-> FromServerMessage
-> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` FromServerMessage -> Value
forall a. ToJSON a => a -> Value
toJSON
instance Show FromServerMessage where
  show :: FromServerMessage -> String
show = Value -> String
forall a. Show a => a -> String
show (Value -> String)
-> (FromServerMessage -> Value) -> FromServerMessage -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FromServerMessage -> Value
forall a. ToJSON a => a -> Value
toJSON

instance ToJSON FromServerMessage where
  toJSON :: FromServerMessage -> Value
toJSON (FromServerMess SMethod m
m TMessage m
p) = SMethod m -> (ToJSON (TMessage m) => Value) -> Value
forall {t :: MessageKind} (m :: Method 'ServerToClient t) x.
SServerMethod m -> (ToJSON (TServerMessage m) => x) -> x
serverMethodJSON SMethod m
m (TMessage m -> Value
forall a. ToJSON a => a -> Value
toJSON TMessage m
p)
  toJSON (FromServerRsp SMethod m
m TResponseMessage m
p) = SMethod m -> (HasJSON (TResponseMessage m) => Value) -> Value
forall (m :: Method 'ClientToServer 'Request) x.
SClientMethod m -> (HasJSON (TResponseMessage m) => x) -> x
clientResponseJSON SMethod m
m (TResponseMessage m -> Value
forall a. ToJSON a => a -> Value
toJSON TResponseMessage m
p)

fromServerNot ::
  forall (m :: Method ServerToClient Notification).
  TMessage m ~ TNotificationMessage m =>
  TNotificationMessage m ->
  FromServerMessage
fromServerNot :: forall (m :: Method 'ServerToClient 'Notification).
(TMessage m ~ TNotificationMessage m) =>
TNotificationMessage m -> FromServerMessage
fromServerNot m :: TNotificationMessage m
m@TNotificationMessage{$sel:_method:TNotificationMessage :: forall (f :: MessageDirection) (m :: Method f 'Notification).
TNotificationMessage m -> SMethod m
_method = SMethod m
meth} = SMethod m -> TMessage m -> FromServerMessage
forall (s :: MessageKind) (m :: Method 'ServerToClient s)
       (a :: Method 'ClientToServer 'Request -> *).
SMethod m -> TMessage m -> FromServerMessage' a
FromServerMess SMethod m
meth TMessage m
TNotificationMessage m
m

fromServerReq ::
  forall (m :: Method ServerToClient Request).
  TMessage m ~ TRequestMessage m =>
  TRequestMessage m ->
  FromServerMessage
fromServerReq :: forall (m :: Method 'ServerToClient 'Request).
(TMessage m ~ TRequestMessage m) =>
TRequestMessage m -> FromServerMessage
fromServerReq m :: TRequestMessage m
m@TRequestMessage{$sel:_method:TRequestMessage :: forall (f :: MessageDirection) (m :: Method f 'Request).
TRequestMessage m -> SMethod m
_method = SMethod m
meth} = SMethod m -> TMessage m -> FromServerMessage
forall (s :: MessageKind) (m :: Method 'ServerToClient s)
       (a :: Method 'ClientToServer 'Request -> *).
SMethod m -> TMessage m -> FromServerMessage' a
FromServerMess SMethod m
meth TMessage m
TRequestMessage m
m

data FromClientMessage' a where
  FromClientMess :: forall t (m :: Method ClientToServer t) a. SMethod m -> TMessage m -> FromClientMessage' a
  FromClientRsp :: forall (m :: Method ServerToClient Request) a. a m -> TResponseMessage m -> FromClientMessage' a

type FromClientMessage = FromClientMessage' SMethod

instance ToJSON FromClientMessage where
  toJSON :: FromClientMessage -> Value
toJSON (FromClientMess SMethod m
m TMessage m
p) = SMethod m -> (ToJSON (TMessage m) => Value) -> Value
forall {t :: MessageKind} (m :: Method 'ClientToServer t) x.
SClientMethod m -> (ToJSON (TClientMessage m) => x) -> x
clientMethodJSON SMethod m
m (TMessage m -> Value
forall a. ToJSON a => a -> Value
toJSON TMessage m
p)
  toJSON (FromClientRsp SMethod m
m TResponseMessage m
p) = SMethod m -> (HasJSON (TResponseMessage m) => Value) -> Value
forall (m :: Method 'ServerToClient 'Request) x.
SServerMethod m -> (HasJSON (TResponseMessage m) => x) -> x
serverResponseJSON SMethod m
m (TResponseMessage m -> Value
forall a. ToJSON a => a -> Value
toJSON TResponseMessage m
p)

fromClientNot ::
  forall (m :: Method ClientToServer Notification).
  TMessage m ~ TNotificationMessage m =>
  TNotificationMessage m ->
  FromClientMessage
fromClientNot :: forall (m :: Method 'ClientToServer 'Notification).
(TMessage m ~ TNotificationMessage m) =>
TNotificationMessage m -> FromClientMessage
fromClientNot m :: TNotificationMessage m
m@TNotificationMessage{$sel:_method:TNotificationMessage :: forall (f :: MessageDirection) (m :: Method f 'Notification).
TNotificationMessage m -> SMethod m
_method = SMethod m
meth} = SMethod m -> TMessage m -> FromClientMessage
forall (s :: MessageKind) (m :: Method 'ClientToServer s)
       (a :: Method 'ServerToClient 'Request -> *).
SMethod m -> TMessage m -> FromClientMessage' a
FromClientMess SMethod m
meth TMessage m
TNotificationMessage m
m

fromClientReq ::
  forall (m :: Method ClientToServer Request).
  TMessage m ~ TRequestMessage m =>
  TRequestMessage m ->
  FromClientMessage
fromClientReq :: forall (m :: Method 'ClientToServer 'Request).
(TMessage m ~ TRequestMessage m) =>
TRequestMessage m -> FromClientMessage
fromClientReq m :: TRequestMessage m
m@TRequestMessage{$sel:_method:TRequestMessage :: forall (f :: MessageDirection) (m :: Method f 'Request).
TRequestMessage m -> SMethod m
_method = SMethod m
meth} = SMethod m -> TMessage m -> FromClientMessage
forall (s :: MessageKind) (m :: Method 'ClientToServer s)
       (a :: Method 'ServerToClient 'Request -> *).
SMethod m -> TMessage m -> FromClientMessage' a
FromClientMess SMethod m
meth TMessage m
TRequestMessage m
m

-- ---------------------------------------------------------------------
-- Parsing
-- ---------------------------------------------------------------------

type LookupFunc f a = forall (m :: Method f Request). LspId m -> Maybe (SMethod m, a m)

{-
Message Types we must handle are the following

Request      | jsonrpc | id | method | params?
Response     | jsonrpc | id |        |         | response? | error?
Notification | jsonrpc |    | method | params?
-}

{-# INLINE parseServerMessage #-}
parseServerMessage :: LookupFunc ClientToServer a -> Value -> Parser (FromServerMessage' a)
parseServerMessage :: forall (a :: Method 'ClientToServer 'Request -> *).
LookupFunc 'ClientToServer a
-> Value -> Parser (FromServerMessage' a)
parseServerMessage LookupFunc 'ClientToServer a
lookupId v :: Value
v@(Object Object
o) = do
  Maybe SomeServerMethod
methMaybe <- Object
o Object -> Key -> Parser (Maybe SomeServerMethod)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:! Key
"method"
  Maybe (LspId Any)
idMaybe <- Object
o Object -> Key -> Parser (Maybe (LspId Any))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:! Key
"id"
  case Maybe SomeServerMethod
methMaybe of
    -- Request or Notification
    Just (SomeServerMethod SMethod m
m) ->
      case SMethod m -> ServerNotOrReq m
forall {t :: MessageKind} (m :: Method 'ServerToClient t).
SServerMethod m -> ServerNotOrReq m
splitServerMethod SMethod m
m of
        ServerNotOrReq m
IsServerNot -> SMethod m -> TMessage m -> FromServerMessage' a
forall (s :: MessageKind) (m :: Method 'ServerToClient s)
       (a :: Method 'ClientToServer 'Request -> *).
SMethod m -> TMessage m -> FromServerMessage' a
FromServerMess SMethod m
m (TNotificationMessage m -> FromServerMessage' a)
-> Parser (TNotificationMessage m) -> Parser (FromServerMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TNotificationMessage m)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
        ServerNotOrReq m
IsServerReq -> SMethod m -> TMessage m -> FromServerMessage' a
forall (s :: MessageKind) (m :: Method 'ServerToClient s)
       (a :: Method 'ClientToServer 'Request -> *).
SMethod m -> TMessage m -> FromServerMessage' a
FromServerMess SMethod m
m (TRequestMessage m -> FromServerMessage' a)
-> Parser (TRequestMessage m) -> Parser (FromServerMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TRequestMessage m)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
        ServerNotOrReq m
IsServerEither | SMethod_CustomMethod (Proxy s
p :: Proxy s') <- SMethod m
m -> do
          case Maybe (LspId Any)
idMaybe of
            -- Request
            Just LspId Any
_ ->
              let m' :: SMethod ('Method_CustomMethod s)
m' = (Proxy s -> SMethod ('Method_CustomMethod s)
forall {f :: MessageDirection} {t :: MessageKind} (s :: Symbol).
KnownSymbol s =>
Proxy s -> SMethod ('Method_CustomMethod s)
SMethod_CustomMethod Proxy s
p :: SMethod (Method_CustomMethod s' :: Method ServerToClient Request))
               in SMethod ('Method_CustomMethod s)
-> TMessage ('Method_CustomMethod s) -> FromServerMessage' a
forall (s :: MessageKind) (m :: Method 'ServerToClient s)
       (a :: Method 'ClientToServer 'Request -> *).
SMethod m -> TMessage m -> FromServerMessage' a
FromServerMess SMethod ('Method_CustomMethod s)
m' (TCustomMessage s 'ServerToClient 'Request -> FromServerMessage' a)
-> Parser (TCustomMessage s 'ServerToClient 'Request)
-> Parser (FromServerMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TCustomMessage s 'ServerToClient 'Request)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
            Maybe (LspId Any)
Nothing ->
              let m' :: SMethod ('Method_CustomMethod s)
m' = (Proxy s -> SMethod ('Method_CustomMethod s)
forall {f :: MessageDirection} {t :: MessageKind} (s :: Symbol).
KnownSymbol s =>
Proxy s -> SMethod ('Method_CustomMethod s)
SMethod_CustomMethod Proxy s
p :: SMethod (Method_CustomMethod s' :: Method ServerToClient Notification))
               in SMethod ('Method_CustomMethod s)
-> TMessage ('Method_CustomMethod s) -> FromServerMessage' a
forall (s :: MessageKind) (m :: Method 'ServerToClient s)
       (a :: Method 'ClientToServer 'Request -> *).
SMethod m -> TMessage m -> FromServerMessage' a
FromServerMess SMethod ('Method_CustomMethod s)
m' (TCustomMessage s 'ServerToClient 'Notification
 -> FromServerMessage' a)
-> Parser (TCustomMessage s 'ServerToClient 'Notification)
-> Parser (FromServerMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TCustomMessage s 'ServerToClient 'Notification)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
    Maybe SomeServerMethod
Nothing -> do
      case Maybe (LspId Any)
idMaybe of
        Just LspId Any
i -> do
          case LspId Any -> Maybe (SMethod Any, a Any)
LookupFunc 'ClientToServer a
lookupId LspId Any
i of
            Just (SMethod Any
m, a Any
res) -> SMethod Any
-> (HasJSON (TResponseMessage Any) =>
    Parser (FromServerMessage' a))
-> Parser (FromServerMessage' a)
forall (m :: Method 'ClientToServer 'Request) x.
SClientMethod m -> (HasJSON (TResponseMessage m) => x) -> x
clientResponseJSON SMethod Any
m ((HasJSON (TResponseMessage Any) => Parser (FromServerMessage' a))
 -> Parser (FromServerMessage' a))
-> (HasJSON (TResponseMessage Any) =>
    Parser (FromServerMessage' a))
-> Parser (FromServerMessage' a)
forall a b. (a -> b) -> a -> b
$ a Any -> TResponseMessage Any -> FromServerMessage' a
forall (s :: Method 'ClientToServer 'Request)
       (a :: Method 'ClientToServer 'Request -> *).
a s -> TResponseMessage s -> FromServerMessage' a
FromServerRsp a Any
res (TResponseMessage Any -> FromServerMessage' a)
-> Parser (TResponseMessage Any) -> Parser (FromServerMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TResponseMessage Any)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
            Maybe (SMethod Any, a Any)
Nothing -> String -> Parser (FromServerMessage' a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (FromServerMessage' a))
-> String -> Parser (FromServerMessage' a)
forall a b. (a -> b) -> a -> b
$ [String] -> String
unwords [String
"Failed in looking up response type of", Value -> String
forall a. Show a => a -> String
show Value
v]
        Maybe (LspId Any)
Nothing -> String -> Parser (FromServerMessage' a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (FromServerMessage' a))
-> String -> Parser (FromServerMessage' a)
forall a b. (a -> b) -> a -> b
$ [String] -> String
unwords [String
"Got unexpected message without method or id"]
parseServerMessage LookupFunc 'ClientToServer a
_ Value
v = String -> Parser (FromServerMessage' a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (FromServerMessage' a))
-> String -> Parser (FromServerMessage' a)
forall a b. (a -> b) -> a -> b
$ [String] -> String
unwords [String
"parseServerMessage expected object, got:", Value -> String
forall a. Show a => a -> String
show Value
v]

{-# INLINE parseClientMessage #-}
parseClientMessage :: LookupFunc ServerToClient a -> Value -> Parser (FromClientMessage' a)
parseClientMessage :: forall (a :: Method 'ServerToClient 'Request -> *).
LookupFunc 'ServerToClient a
-> Value -> Parser (FromClientMessage' a)
parseClientMessage LookupFunc 'ServerToClient a
lookupId v :: Value
v@(Object Object
o) = do
  Maybe SomeClientMethod
methMaybe <- Object
o Object -> Key -> Parser (Maybe SomeClientMethod)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:! Key
"method"
  Maybe (LspId Any)
idMaybe <- Object
o Object -> Key -> Parser (Maybe (LspId Any))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:! Key
"id"
  case Maybe SomeClientMethod
methMaybe of
    -- Request or Notification
    Just (SomeClientMethod SMethod m
m) ->
      case SMethod m -> ClientNotOrReq m
forall {t :: MessageKind} (m :: Method 'ClientToServer t).
SClientMethod m -> ClientNotOrReq m
splitClientMethod SMethod m
m of
        ClientNotOrReq m
IsClientNot -> SMethod m -> TMessage m -> FromClientMessage' a
forall (s :: MessageKind) (m :: Method 'ClientToServer s)
       (a :: Method 'ServerToClient 'Request -> *).
SMethod m -> TMessage m -> FromClientMessage' a
FromClientMess SMethod m
m (TNotificationMessage m -> FromClientMessage' a)
-> Parser (TNotificationMessage m) -> Parser (FromClientMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TNotificationMessage m)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
        ClientNotOrReq m
IsClientReq -> SMethod m -> TMessage m -> FromClientMessage' a
forall (s :: MessageKind) (m :: Method 'ClientToServer s)
       (a :: Method 'ServerToClient 'Request -> *).
SMethod m -> TMessage m -> FromClientMessage' a
FromClientMess SMethod m
m (TRequestMessage m -> FromClientMessage' a)
-> Parser (TRequestMessage m) -> Parser (FromClientMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TRequestMessage m)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
        ClientNotOrReq m
IsClientEither | SMethod_CustomMethod (Proxy s
p :: Proxy s') <- SMethod m
m -> do
          case Maybe (LspId Any)
idMaybe of
            -- Request
            Just LspId Any
_ ->
              let m' :: SMethod ('Method_CustomMethod s)
m' = (Proxy s -> SMethod ('Method_CustomMethod s)
forall {f :: MessageDirection} {t :: MessageKind} (s :: Symbol).
KnownSymbol s =>
Proxy s -> SMethod ('Method_CustomMethod s)
SMethod_CustomMethod Proxy s
p :: SMethod (Method_CustomMethod s' :: Method ClientToServer Request))
               in SMethod ('Method_CustomMethod s)
-> TMessage ('Method_CustomMethod s) -> FromClientMessage' a
forall (s :: MessageKind) (m :: Method 'ClientToServer s)
       (a :: Method 'ServerToClient 'Request -> *).
SMethod m -> TMessage m -> FromClientMessage' a
FromClientMess SMethod ('Method_CustomMethod s)
m' (TCustomMessage s 'ClientToServer 'Request -> FromClientMessage' a)
-> Parser (TCustomMessage s 'ClientToServer 'Request)
-> Parser (FromClientMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TCustomMessage s 'ClientToServer 'Request)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
            Maybe (LspId Any)
Nothing ->
              let m' :: SMethod ('Method_CustomMethod s)
m' = (Proxy s -> SMethod ('Method_CustomMethod s)
forall {f :: MessageDirection} {t :: MessageKind} (s :: Symbol).
KnownSymbol s =>
Proxy s -> SMethod ('Method_CustomMethod s)
SMethod_CustomMethod Proxy s
p :: SMethod (Method_CustomMethod s' :: Method ClientToServer Notification))
               in SMethod ('Method_CustomMethod s)
-> TMessage ('Method_CustomMethod s) -> FromClientMessage' a
forall (s :: MessageKind) (m :: Method 'ClientToServer s)
       (a :: Method 'ServerToClient 'Request -> *).
SMethod m -> TMessage m -> FromClientMessage' a
FromClientMess SMethod ('Method_CustomMethod s)
m' (TCustomMessage s 'ClientToServer 'Notification
 -> FromClientMessage' a)
-> Parser (TCustomMessage s 'ClientToServer 'Notification)
-> Parser (FromClientMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TCustomMessage s 'ClientToServer 'Notification)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
    Maybe SomeClientMethod
Nothing -> do
      case Maybe (LspId Any)
idMaybe of
        Just LspId Any
i -> do
          case LspId Any -> Maybe (SMethod Any, a Any)
LookupFunc 'ServerToClient a
lookupId LspId Any
i of
            Just (SMethod Any
m, a Any
res) -> SMethod Any
-> (HasJSON (TResponseMessage Any) =>
    Parser (FromClientMessage' a))
-> Parser (FromClientMessage' a)
forall (m :: Method 'ServerToClient 'Request) x.
SServerMethod m -> (HasJSON (TResponseMessage m) => x) -> x
serverResponseJSON SMethod Any
m ((HasJSON (TResponseMessage Any) => Parser (FromClientMessage' a))
 -> Parser (FromClientMessage' a))
-> (HasJSON (TResponseMessage Any) =>
    Parser (FromClientMessage' a))
-> Parser (FromClientMessage' a)
forall a b. (a -> b) -> a -> b
$ a Any -> TResponseMessage Any -> FromClientMessage' a
forall (s :: Method 'ServerToClient 'Request)
       (a :: Method 'ServerToClient 'Request -> *).
a s -> TResponseMessage s -> FromClientMessage' a
FromClientRsp a Any
res (TResponseMessage Any -> FromClientMessage' a)
-> Parser (TResponseMessage Any) -> Parser (FromClientMessage' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (TResponseMessage Any)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
            Maybe (SMethod Any, a Any)
Nothing -> String -> Parser (FromClientMessage' a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (FromClientMessage' a))
-> String -> Parser (FromClientMessage' a)
forall a b. (a -> b) -> a -> b
$ [String] -> String
unwords [String
"Failed in looking up response type of", Value -> String
forall a. Show a => a -> String
show Value
v]
        Maybe (LspId Any)
Nothing -> String -> Parser (FromClientMessage' a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (FromClientMessage' a))
-> String -> Parser (FromClientMessage' a)
forall a b. (a -> b) -> a -> b
$ [String] -> String
unwords [String
"Got unexpected message without method or id"]
parseClientMessage LookupFunc 'ServerToClient a
_ Value
v = String -> Parser (FromClientMessage' a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (FromClientMessage' a))
-> String -> Parser (FromClientMessage' a)
forall a b. (a -> b) -> a -> b
$ [String] -> String
unwords [String
"parseClientMessage expected object, got:", Value -> String
forall a. Show a => a -> String
show Value
v]

-- ---------------------------------------------------------------------
-- Helper Utilities
-- ---------------------------------------------------------------------

{-# INLINE clientResponseJSON #-}
clientResponseJSON :: SClientMethod m -> (HasJSON (TResponseMessage m) => x) -> x
clientResponseJSON :: forall (m :: Method 'ClientToServer 'Request) x.
SClientMethod m -> (HasJSON (TResponseMessage m) => x) -> x
clientResponseJSON SClientMethod m
m HasJSON (TResponseMessage m) => x
x = case SClientMethod m -> ClientNotOrReq m
forall {t :: MessageKind} (m :: Method 'ClientToServer t).
SClientMethod m -> ClientNotOrReq m
splitClientMethod SClientMethod m
m of
  ClientNotOrReq m
IsClientReq -> x
HasJSON (TResponseMessage m) => x
x
  ClientNotOrReq m
IsClientEither -> x
HasJSON (TResponseMessage m) => x
x

{-# INLINE serverResponseJSON #-}
serverResponseJSON :: SServerMethod m -> (HasJSON (TResponseMessage m) => x) -> x
serverResponseJSON :: forall (m :: Method 'ServerToClient 'Request) x.
SServerMethod m -> (HasJSON (TResponseMessage m) => x) -> x
serverResponseJSON SServerMethod m
m HasJSON (TResponseMessage m) => x
x = case SServerMethod m -> ServerNotOrReq m
forall {t :: MessageKind} (m :: Method 'ServerToClient t).
SServerMethod m -> ServerNotOrReq m
splitServerMethod SServerMethod m
m of
  ServerNotOrReq m
IsServerReq -> x
HasJSON (TResponseMessage m) => x
x
  ServerNotOrReq m
IsServerEither -> x
HasJSON (TResponseMessage m) => x
x

{-# INLINE clientMethodJSON #-}
clientMethodJSON :: SClientMethod m -> (ToJSON (TClientMessage m) => x) -> x
clientMethodJSON :: forall {t :: MessageKind} (m :: Method 'ClientToServer t) x.
SClientMethod m -> (ToJSON (TClientMessage m) => x) -> x
clientMethodJSON SClientMethod m
m ToJSON (TClientMessage m) => x
x =
  case SClientMethod m -> ClientNotOrReq m
forall {t :: MessageKind} (m :: Method 'ClientToServer t).
SClientMethod m -> ClientNotOrReq m
splitClientMethod SClientMethod m
m of
    ClientNotOrReq m
IsClientNot -> x
ToJSON (TClientMessage m) => x
x
    ClientNotOrReq m
IsClientReq -> x
ToJSON (TClientMessage m) => x
x
    ClientNotOrReq m
IsClientEither -> x
ToJSON (TClientMessage m) => x
x

{-# INLINE serverMethodJSON #-}
serverMethodJSON :: SServerMethod m -> (ToJSON (TServerMessage m) => x) -> x
serverMethodJSON :: forall {t :: MessageKind} (m :: Method 'ServerToClient t) x.
SServerMethod m -> (ToJSON (TServerMessage m) => x) -> x
serverMethodJSON SServerMethod m
m ToJSON (TServerMessage m) => x
x =
  case SServerMethod m -> ServerNotOrReq m
forall {t :: MessageKind} (m :: Method 'ServerToClient t).
SServerMethod m -> ServerNotOrReq m
splitServerMethod SServerMethod m
m of
    ServerNotOrReq m
IsServerNot -> x
ToJSON (TServerMessage m) => x
x
    ServerNotOrReq m
IsServerReq -> x
ToJSON (TServerMessage m) => x
x
    ServerNotOrReq m
IsServerEither -> x
ToJSON (TServerMessage m) => x
x

type HasJSON a = (ToJSON a, FromJSON a, Eq a)

-- Reify universal properties about Client/Server Messages

type ClientNotOrReq :: forall t. Method ClientToServer t -> Type
data ClientNotOrReq m where
  IsClientNot ::
    ( HasJSON (TClientMessage m)
    , TMessage m ~ TNotificationMessage m
    ) =>
    ClientNotOrReq (m :: Method ClientToServer Notification)
  IsClientReq ::
    forall (m :: Method ClientToServer Request).
    ( HasJSON (TClientMessage m)
    , HasJSON (TResponseMessage m)
    , TMessage m ~ TRequestMessage m
    ) =>
    ClientNotOrReq m
  IsClientEither ::
    ClientNotOrReq (Method_CustomMethod s)

type ServerNotOrReq :: forall t. Method ServerToClient t -> Type
data ServerNotOrReq m where
  IsServerNot ::
    ( HasJSON (TServerMessage m)
    , TMessage m ~ TNotificationMessage m
    ) =>
    ServerNotOrReq (m :: Method ServerToClient Notification)
  IsServerReq ::
    forall (m :: Method ServerToClient Request).
    ( HasJSON (TServerMessage m)
    , HasJSON (TResponseMessage m)
    , TMessage m ~ TRequestMessage m
    ) =>
    ServerNotOrReq m
  IsServerEither ::
    ServerNotOrReq (Method_CustomMethod s)

{-# INLINE splitClientMethod #-}
splitClientMethod :: SClientMethod m -> ClientNotOrReq m
splitClientMethod :: forall {t :: MessageKind} (m :: Method 'ClientToServer t).
SClientMethod m -> ClientNotOrReq m
splitClientMethod = \case
  SClientMethod m
SMethod_Initialize -> ClientNotOrReq m
ClientNotOrReq 'Method_Initialize
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_Initialized -> ClientNotOrReq m
ClientNotOrReq 'Method_Initialized
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_Shutdown -> ClientNotOrReq m
ClientNotOrReq 'Method_Shutdown
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_Exit -> ClientNotOrReq m
ClientNotOrReq 'Method_Exit
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_WorkspaceDidChangeWorkspaceFolders -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceDidChangeWorkspaceFolders
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_WorkspaceDidChangeConfiguration -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceDidChangeConfiguration
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_WorkspaceDidChangeWatchedFiles -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceDidChangeWatchedFiles
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_WorkspaceSymbol -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceSymbol
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_WorkspaceExecuteCommand -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceExecuteCommand
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_WindowWorkDoneProgressCancel -> ClientNotOrReq m
ClientNotOrReq 'Method_WindowWorkDoneProgressCancel
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_TextDocumentDidOpen -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDidOpen
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_TextDocumentDidChange -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDidChange
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_TextDocumentWillSave -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentWillSave
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_TextDocumentWillSaveWaitUntil -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentWillSaveWaitUntil
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentDidSave -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDidSave
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_TextDocumentDidClose -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDidClose
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_TextDocumentCompletion -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentCompletion
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentHover -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentHover
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentSignatureHelp -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentSignatureHelp
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentDeclaration -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDeclaration
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentDefinition -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDefinition
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentTypeDefinition -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentTypeDefinition
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentImplementation -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentImplementation
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentReferences -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentReferences
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentDocumentHighlight -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDocumentHighlight
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentDocumentSymbol -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDocumentSymbol
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentCodeAction -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentCodeAction
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentCodeLens -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentCodeLens
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentDocumentLink -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDocumentLink
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentDocumentColor -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDocumentColor
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentColorPresentation -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentColorPresentation
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentFormatting -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentFormatting
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentRangeFormatting -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentRangeFormatting
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentOnTypeFormatting -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentOnTypeFormatting
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentRename -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentRename
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentPrepareRename -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentPrepareRename
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentFoldingRange -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentFoldingRange
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentSelectionRange -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentSelectionRange
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentPrepareCallHierarchy -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentPrepareCallHierarchy
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentLinkedEditingRange -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentLinkedEditingRange
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_CallHierarchyIncomingCalls -> ClientNotOrReq m
ClientNotOrReq 'Method_CallHierarchyIncomingCalls
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_CallHierarchyOutgoingCalls -> ClientNotOrReq m
ClientNotOrReq 'Method_CallHierarchyOutgoingCalls
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentSemanticTokensFull -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentSemanticTokensFull
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentSemanticTokensFullDelta -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentSemanticTokensFullDelta
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentSemanticTokensRange -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentSemanticTokensRange
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_WorkspaceWillCreateFiles -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceWillCreateFiles
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_WorkspaceWillDeleteFiles -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceWillDeleteFiles
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_WorkspaceWillRenameFiles -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceWillRenameFiles
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_WorkspaceDidCreateFiles -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceDidCreateFiles
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_WorkspaceDidDeleteFiles -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceDidDeleteFiles
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_WorkspaceDidRenameFiles -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceDidRenameFiles
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_TextDocumentMoniker -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentMoniker
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentPrepareTypeHierarchy -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentPrepareTypeHierarchy
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TypeHierarchySubtypes -> ClientNotOrReq m
ClientNotOrReq 'Method_TypeHierarchySubtypes
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TypeHierarchySupertypes -> ClientNotOrReq m
ClientNotOrReq 'Method_TypeHierarchySupertypes
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentInlineValue -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentInlineValue
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentInlayHint -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentInlayHint
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_TextDocumentDiagnostic -> ClientNotOrReq m
ClientNotOrReq 'Method_TextDocumentDiagnostic
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_WorkspaceDiagnostic -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceDiagnostic
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_CodeLensResolve -> ClientNotOrReq m
ClientNotOrReq 'Method_CodeLensResolve
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_InlayHintResolve -> ClientNotOrReq m
ClientNotOrReq 'Method_InlayHintResolve
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_CodeActionResolve -> ClientNotOrReq m
ClientNotOrReq 'Method_CodeActionResolve
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_DocumentLinkResolve -> ClientNotOrReq m
ClientNotOrReq 'Method_DocumentLinkResolve
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_CompletionItemResolve -> ClientNotOrReq m
ClientNotOrReq 'Method_CompletionItemResolve
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_WorkspaceSymbolResolve -> ClientNotOrReq m
ClientNotOrReq 'Method_WorkspaceSymbolResolve
forall (s :: Method 'ClientToServer 'Request).
(HasJSON (TClientMessage s), HasJSON (TResponseMessage s),
 TClientMessage s ~ TRequestMessage s) =>
ClientNotOrReq s
IsClientReq
  SClientMethod m
SMethod_NotebookDocumentDidChange -> ClientNotOrReq m
ClientNotOrReq 'Method_NotebookDocumentDidChange
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_NotebookDocumentDidClose -> ClientNotOrReq m
ClientNotOrReq 'Method_NotebookDocumentDidClose
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_NotebookDocumentDidOpen -> ClientNotOrReq m
ClientNotOrReq 'Method_NotebookDocumentDidOpen
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_NotebookDocumentDidSave -> ClientNotOrReq m
ClientNotOrReq 'Method_NotebookDocumentDidSave
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_SetTrace -> ClientNotOrReq m
ClientNotOrReq 'Method_SetTrace
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_Progress -> ClientNotOrReq m
ClientNotOrReq 'Method_Progress
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  SClientMethod m
SMethod_CancelRequest -> ClientNotOrReq m
ClientNotOrReq 'Method_CancelRequest
forall (s :: Method 'ClientToServer 'Notification).
(HasJSON (TClientMessage s),
 TClientMessage s ~ TNotificationMessage s) =>
ClientNotOrReq s
IsClientNot
  (SMethod_CustomMethod Proxy s
_) -> ClientNotOrReq m
ClientNotOrReq ('Method_CustomMethod s)
forall {t :: MessageKind} (s :: Symbol).
ClientNotOrReq ('Method_CustomMethod s)
IsClientEither

{-# INLINE splitServerMethod #-}
splitServerMethod :: SServerMethod m -> ServerNotOrReq m
splitServerMethod :: forall {t :: MessageKind} (m :: Method 'ServerToClient t).
SServerMethod m -> ServerNotOrReq m
splitServerMethod = \case
  SServerMethod m
SMethod_WindowShowMessage -> ServerNotOrReq m
ServerNotOrReq 'Method_WindowShowMessage
forall (s :: Method 'ServerToClient 'Notification).
(HasJSON (TServerMessage s),
 TServerMessage s ~ TNotificationMessage s) =>
ServerNotOrReq s
IsServerNot
  SServerMethod m
SMethod_WindowShowMessageRequest -> ServerNotOrReq m
ServerNotOrReq 'Method_WindowShowMessageRequest
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WindowShowDocument -> ServerNotOrReq m
ServerNotOrReq 'Method_WindowShowDocument
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WindowLogMessage -> ServerNotOrReq m
ServerNotOrReq 'Method_WindowLogMessage
forall (s :: Method 'ServerToClient 'Notification).
(HasJSON (TServerMessage s),
 TServerMessage s ~ TNotificationMessage s) =>
ServerNotOrReq s
IsServerNot
  SServerMethod m
SMethod_WindowWorkDoneProgressCreate -> ServerNotOrReq m
ServerNotOrReq 'Method_WindowWorkDoneProgressCreate
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_Progress -> ServerNotOrReq m
ServerNotOrReq 'Method_Progress
forall (s :: Method 'ServerToClient 'Notification).
(HasJSON (TServerMessage s),
 TServerMessage s ~ TNotificationMessage s) =>
ServerNotOrReq s
IsServerNot
  SServerMethod m
SMethod_TelemetryEvent -> ServerNotOrReq m
ServerNotOrReq 'Method_TelemetryEvent
forall (s :: Method 'ServerToClient 'Notification).
(HasJSON (TServerMessage s),
 TServerMessage s ~ TNotificationMessage s) =>
ServerNotOrReq s
IsServerNot
  SServerMethod m
SMethod_ClientRegisterCapability -> ServerNotOrReq m
ServerNotOrReq 'Method_ClientRegisterCapability
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_ClientUnregisterCapability -> ServerNotOrReq m
ServerNotOrReq 'Method_ClientUnregisterCapability
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WorkspaceWorkspaceFolders -> ServerNotOrReq m
ServerNotOrReq 'Method_WorkspaceWorkspaceFolders
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WorkspaceConfiguration -> ServerNotOrReq m
ServerNotOrReq 'Method_WorkspaceConfiguration
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WorkspaceApplyEdit -> ServerNotOrReq m
ServerNotOrReq 'Method_WorkspaceApplyEdit
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_TextDocumentPublishDiagnostics -> ServerNotOrReq m
ServerNotOrReq 'Method_TextDocumentPublishDiagnostics
forall (s :: Method 'ServerToClient 'Notification).
(HasJSON (TServerMessage s),
 TServerMessage s ~ TNotificationMessage s) =>
ServerNotOrReq s
IsServerNot
  SServerMethod m
SMethod_LogTrace -> ServerNotOrReq m
ServerNotOrReq 'Method_LogTrace
forall (s :: Method 'ServerToClient 'Notification).
(HasJSON (TServerMessage s),
 TServerMessage s ~ TNotificationMessage s) =>
ServerNotOrReq s
IsServerNot
  SServerMethod m
SMethod_CancelRequest -> ServerNotOrReq m
ServerNotOrReq 'Method_CancelRequest
forall (s :: Method 'ServerToClient 'Notification).
(HasJSON (TServerMessage s),
 TServerMessage s ~ TNotificationMessage s) =>
ServerNotOrReq s
IsServerNot
  SServerMethod m
SMethod_WorkspaceCodeLensRefresh -> ServerNotOrReq m
ServerNotOrReq 'Method_WorkspaceCodeLensRefresh
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WorkspaceSemanticTokensRefresh -> ServerNotOrReq m
ServerNotOrReq 'Method_WorkspaceSemanticTokensRefresh
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WorkspaceInlineValueRefresh -> ServerNotOrReq m
ServerNotOrReq 'Method_WorkspaceInlineValueRefresh
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WorkspaceInlayHintRefresh -> ServerNotOrReq m
ServerNotOrReq 'Method_WorkspaceInlayHintRefresh
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  SServerMethod m
SMethod_WorkspaceDiagnosticRefresh -> ServerNotOrReq m
ServerNotOrReq 'Method_WorkspaceDiagnosticRefresh
forall (s :: Method 'ServerToClient 'Request).
(HasJSON (TServerMessage s), HasJSON (TResponseMessage s),
 TServerMessage s ~ TRequestMessage s) =>
ServerNotOrReq s
IsServerReq
  (SMethod_CustomMethod Proxy s
_) -> ServerNotOrReq m
ServerNotOrReq ('Method_CustomMethod s)
forall {t :: MessageKind} (s :: Symbol).
ServerNotOrReq ('Method_CustomMethod s)
IsServerEither

-- | Given a witness that two custom methods are of the same type, produce a witness that the methods are the same
data CustomEq m1 m2 where
  CustomEq ::
    (m1 ~ (Method_CustomMethod s :: Method f t1), m2 ~ (Method_CustomMethod s :: Method f t2)) =>
    {forall (f :: MessageDirection) (t1 :: MessageKind)
       (m1 :: Method f t1) (t2 :: MessageKind) (m2 :: Method f t2).
CustomEq m1 m2 -> (t1 ~ t2) => m1 :~~: m2
runCustomEq :: (t1 ~ t2 => m1 :~~: m2)} ->
    CustomEq m1 m2

runEq ::
  (t1 ~ t2) =>
  (SMethod m1 -> SMethod m2 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))) ->
  SMethod (m1 :: Method f t1) ->
  SMethod (m2 :: Method f t2) ->
  Maybe (m1 :~~: m2)
runEq :: forall (t1 :: MessageKind) (t2 :: MessageKind)
       (f :: MessageDirection) (m1 :: Method f t1) (m2 :: Method f t2).
(t1 ~ t2) =>
(SMethod m1
 -> SMethod m2 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2)))
-> SMethod m1 -> SMethod m2 -> Maybe (m1 :~~: m2)
runEq SMethod m1
-> SMethod m2 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
f SMethod m1
m1 SMethod m2
m2 = do
  Either (CustomEq m1 m2) (m1 :~~: m2)
res <- SMethod m1
-> SMethod m2 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
f SMethod m1
m1 SMethod m2
m2
  (m1 :~~: m2) -> Maybe (m1 :~~: m2)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((m1 :~~: m2) -> Maybe (m1 :~~: m2))
-> (m1 :~~: m2) -> Maybe (m1 :~~: m2)
forall a b. (a -> b) -> a -> b
$ case Either (CustomEq m1 m2) (m1 :~~: m2)
res of
    Right m1 :~~: m2
eq -> m1 :~~: m2
eq
    Left CustomEq m1 m2
ceq -> CustomEq m1 m2 -> (t1 ~ t2) => m1 :~~: m2
forall (f :: MessageDirection) (t1 :: MessageKind)
       (m1 :: Method f t1) (t2 :: MessageKind) (m2 :: Method f t2).
CustomEq m1 m2 -> (t1 ~ t2) => m1 :~~: m2
runCustomEq CustomEq m1 m2
ceq

-- | Heterogeneous equality on singleton server methods
mEqServer :: SServerMethod m1 -> SServerMethod m2 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
mEqServer :: forall {t1 :: MessageKind} {t2 :: MessageKind}
       (m1 :: Method 'ServerToClient t1)
       (m2 :: Method 'ServerToClient t2).
SServerMethod m1
-> SServerMethod m2 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
mEqServer SServerMethod m1
m1 SServerMethod m2
m2 = ServerNotOrReq m1
-> ServerNotOrReq m2
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
go (SServerMethod m1 -> ServerNotOrReq m1
forall {t :: MessageKind} (m :: Method 'ServerToClient t).
SServerMethod m -> ServerNotOrReq m
splitServerMethod SServerMethod m1
m1) (SServerMethod m2 -> ServerNotOrReq m2
forall {t :: MessageKind} (m :: Method 'ServerToClient t).
SServerMethod m -> ServerNotOrReq m
splitServerMethod SServerMethod m2
m2)
 where
  go :: ServerNotOrReq m1
-> ServerNotOrReq m2
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
go ServerNotOrReq m1
IsServerNot ServerNotOrReq m2
IsServerNot = do
    m1 :~: m2
Refl <- SServerMethod m1 -> SMethod m2 -> Maybe (m1 :~: m2)
forall k (f :: k -> *) (a :: k) (b :: k).
GEq f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: Method 'ServerToClient t1)
       (b :: Method 'ServerToClient t1).
SMethod a -> SMethod b -> Maybe (a :~: b)
geq SServerMethod m1
m1 SMethod m2
SServerMethod m2
m2
    Either (CustomEq m1 m2) (m1 :~~: m2)
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either (CustomEq m1 m2) (m1 :~~: m2)
 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2)))
-> Either (CustomEq m1 m2) (m1 :~~: m2)
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a b. (a -> b) -> a -> b
$ (m2 :~~: m2) -> Either (CustomEq m2 m2) (m2 :~~: m2)
forall a b. b -> Either a b
Right m2 :~~: m2
forall {k1} (a :: k1). a :~~: a
HRefl
  go ServerNotOrReq m1
IsServerReq ServerNotOrReq m2
IsServerReq = do
    m1 :~: m2
Refl <- SServerMethod m1 -> SMethod m2 -> Maybe (m1 :~: m2)
forall k (f :: k -> *) (a :: k) (b :: k).
GEq f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: Method 'ServerToClient t1)
       (b :: Method 'ServerToClient t1).
SMethod a -> SMethod b -> Maybe (a :~: b)
geq SServerMethod m1
m1 SMethod m2
SServerMethod m2
m2
    Either (CustomEq m1 m2) (m1 :~~: m2)
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either (CustomEq m1 m2) (m1 :~~: m2)
 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2)))
-> Either (CustomEq m1 m2) (m1 :~~: m2)
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a b. (a -> b) -> a -> b
$ (m2 :~~: m2) -> Either (CustomEq m2 m2) (m2 :~~: m2)
forall a b. b -> Either a b
Right m2 :~~: m2
forall {k1} (a :: k1). a :~~: a
HRefl
  go ServerNotOrReq m1
IsServerEither ServerNotOrReq m2
IsServerEither
    | SMethod_CustomMethod Proxy s
p1 <- SServerMethod m1
m1
    , SMethod_CustomMethod Proxy s
p2 <- SServerMethod m2
m2 =
        case Proxy s -> Proxy s -> Maybe (s :~: s)
forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *)
       (proxy2 :: Symbol -> *).
(KnownSymbol a, KnownSymbol b) =>
proxy1 a -> proxy2 b -> Maybe (a :~: b)
sameSymbol Proxy s
p1 Proxy s
p2 of
          Just s :~: s
Refl -> Either
  (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
  ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
-> Maybe
     (Either
        (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
        ('Method_CustomMethod s :~~: 'Method_CustomMethod s))
forall a. a -> Maybe a
Just (Either
   (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
   ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
 -> Maybe
      (Either
         (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
         ('Method_CustomMethod s :~~: 'Method_CustomMethod s)))
-> Either
     (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
     ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
-> Maybe
     (Either
        (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
        ('Method_CustomMethod s :~~: 'Method_CustomMethod s))
forall a b. (a -> b) -> a -> b
$ CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s)
-> Either
     (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
     ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
forall a b. a -> Either a b
Left (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s)
 -> Either
      (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
      ('Method_CustomMethod s :~~: 'Method_CustomMethod s))
-> CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s)
-> Either
     (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
     ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
forall a b. (a -> b) -> a -> b
$ ((t1 ~ t2) => 'Method_CustomMethod s :~~: 'Method_CustomMethod s)
-> CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s)
forall (f :: MessageDirection) (t1 :: MessageKind)
       (m1 :: Method f t1) (s :: Symbol) (t2 :: MessageKind)
       (m2 :: Method f t2).
(m1 ~ 'Method_CustomMethod s, m2 ~ 'Method_CustomMethod s) =>
((t1 ~ t2) => m1 :~~: m2) -> CustomEq m1 m2
CustomEq 'Method_CustomMethod s :~~: 'Method_CustomMethod s
'Method_CustomMethod s :~~: 'Method_CustomMethod s
(t1 ~ t2) => 'Method_CustomMethod s :~~: 'Method_CustomMethod s
forall {k1} (a :: k1). a :~~: a
HRefl
          Maybe (s :~: s)
_ -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
Maybe
  (Either
     (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
     ('Method_CustomMethod s :~~: 'Method_CustomMethod s))
forall a. Maybe a
Nothing
  go ServerNotOrReq m1
_ ServerNotOrReq m2
_ = Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a. Maybe a
Nothing

-- | Heterogeneous equality on singleton client methods
mEqClient :: SClientMethod m1 -> SClientMethod m2 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
mEqClient :: forall {t1 :: MessageKind} {t2 :: MessageKind}
       (m1 :: Method 'ClientToServer t1)
       (m2 :: Method 'ClientToServer t2).
SClientMethod m1
-> SClientMethod m2 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
mEqClient SClientMethod m1
m1 SClientMethod m2
m2 = ClientNotOrReq m1
-> ClientNotOrReq m2
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
go (SClientMethod m1 -> ClientNotOrReq m1
forall {t :: MessageKind} (m :: Method 'ClientToServer t).
SClientMethod m -> ClientNotOrReq m
splitClientMethod SClientMethod m1
m1) (SClientMethod m2 -> ClientNotOrReq m2
forall {t :: MessageKind} (m :: Method 'ClientToServer t).
SClientMethod m -> ClientNotOrReq m
splitClientMethod SClientMethod m2
m2)
 where
  go :: ClientNotOrReq m1
-> ClientNotOrReq m2
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
go ClientNotOrReq m1
IsClientNot ClientNotOrReq m2
IsClientNot = do
    m1 :~: m2
Refl <- SClientMethod m1 -> SMethod m2 -> Maybe (m1 :~: m2)
forall k (f :: k -> *) (a :: k) (b :: k).
GEq f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: Method 'ClientToServer t1)
       (b :: Method 'ClientToServer t1).
SMethod a -> SMethod b -> Maybe (a :~: b)
geq SClientMethod m1
m1 SMethod m2
SClientMethod m2
m2
    Either (CustomEq m1 m2) (m1 :~~: m2)
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either (CustomEq m1 m2) (m1 :~~: m2)
 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2)))
-> Either (CustomEq m1 m2) (m1 :~~: m2)
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a b. (a -> b) -> a -> b
$ (m2 :~~: m2) -> Either (CustomEq m2 m2) (m2 :~~: m2)
forall a b. b -> Either a b
Right m2 :~~: m2
forall {k1} (a :: k1). a :~~: a
HRefl
  go ClientNotOrReq m1
IsClientReq ClientNotOrReq m2
IsClientReq = do
    m1 :~: m2
Refl <- SClientMethod m1 -> SMethod m2 -> Maybe (m1 :~: m2)
forall k (f :: k -> *) (a :: k) (b :: k).
GEq f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: Method 'ClientToServer t1)
       (b :: Method 'ClientToServer t1).
SMethod a -> SMethod b -> Maybe (a :~: b)
geq SClientMethod m1
m1 SMethod m2
SClientMethod m2
m2
    Either (CustomEq m1 m2) (m1 :~~: m2)
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either (CustomEq m1 m2) (m1 :~~: m2)
 -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2)))
-> Either (CustomEq m1 m2) (m1 :~~: m2)
-> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a b. (a -> b) -> a -> b
$ (m2 :~~: m2) -> Either (CustomEq m2 m2) (m2 :~~: m2)
forall a b. b -> Either a b
Right m2 :~~: m2
forall {k1} (a :: k1). a :~~: a
HRefl
  go ClientNotOrReq m1
IsClientEither ClientNotOrReq m2
IsClientEither
    | SMethod_CustomMethod Proxy s
p1 <- SClientMethod m1
m1
    , SMethod_CustomMethod Proxy s
p2 <- SClientMethod m2
m2 =
        case Proxy s -> Proxy s -> Maybe (s :~: s)
forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *)
       (proxy2 :: Symbol -> *).
(KnownSymbol a, KnownSymbol b) =>
proxy1 a -> proxy2 b -> Maybe (a :~: b)
sameSymbol Proxy s
p1 Proxy s
p2 of
          Just s :~: s
Refl -> Either
  (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
  ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
-> Maybe
     (Either
        (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
        ('Method_CustomMethod s :~~: 'Method_CustomMethod s))
forall a. a -> Maybe a
Just (Either
   (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
   ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
 -> Maybe
      (Either
         (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
         ('Method_CustomMethod s :~~: 'Method_CustomMethod s)))
-> Either
     (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
     ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
-> Maybe
     (Either
        (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
        ('Method_CustomMethod s :~~: 'Method_CustomMethod s))
forall a b. (a -> b) -> a -> b
$ CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s)
-> Either
     (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
     ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
forall a b. a -> Either a b
Left (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s)
 -> Either
      (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
      ('Method_CustomMethod s :~~: 'Method_CustomMethod s))
-> CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s)
-> Either
     (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
     ('Method_CustomMethod s :~~: 'Method_CustomMethod s)
forall a b. (a -> b) -> a -> b
$ ((t1 ~ t2) => 'Method_CustomMethod s :~~: 'Method_CustomMethod s)
-> CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s)
forall (f :: MessageDirection) (t1 :: MessageKind)
       (m1 :: Method f t1) (s :: Symbol) (t2 :: MessageKind)
       (m2 :: Method f t2).
(m1 ~ 'Method_CustomMethod s, m2 ~ 'Method_CustomMethod s) =>
((t1 ~ t2) => m1 :~~: m2) -> CustomEq m1 m2
CustomEq 'Method_CustomMethod s :~~: 'Method_CustomMethod s
'Method_CustomMethod s :~~: 'Method_CustomMethod s
(t1 ~ t2) => 'Method_CustomMethod s :~~: 'Method_CustomMethod s
forall {k1} (a :: k1). a :~~: a
HRefl
          Maybe (s :~: s)
_ -> Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
Maybe
  (Either
     (CustomEq ('Method_CustomMethod s) ('Method_CustomMethod s))
     ('Method_CustomMethod s :~~: 'Method_CustomMethod s))
forall a. Maybe a
Nothing
  go ClientNotOrReq m1
_ ClientNotOrReq m2
_ = Maybe (Either (CustomEq m1 m2) (m1 :~~: m2))
forall a. Maybe a
Nothing