Qualify lens classes as L instead of J

Author: joyfulmantis

lsp-test/func-test/FuncTest.hs

@@ -5,7 +5,7 @@ module Main where
 import Language.LSP.Server
 import qualified Language.LSP.Test as Test
 import Language.LSP.Protocol.Types
-import qualified Language.LSP.Protocol.Lens as J
+import qualified Language.LSP.Protocol.Lens as L
 import Language.LSP.Protocol.Message 
 import Control.Monad.IO.Class
 import System.IO
@@ -57,15 +57,15 @@ main = hspec $ do
         -- First make sure that we get a $/progress begin notification
         skipManyTill Test.anyMessage $ do
           x <- Test.message SMethod_Progress
-          guard $ has (J.params . J.value . _workDoneProgressBegin) x
+          guard $ has (L.params . L.value . _workDoneProgressBegin) x
 
         -- Then kill the thread
         liftIO $ putMVar killVar ()
 
         -- Then make sure we still get a $/progress end notification
         skipManyTill Test.anyMessage $ do
           x <- Test.message SMethod_Progress
-          guard $ has (J.params . J.value . _workDoneProgressEnd) x
+          guard $ has (L.params . L.value . _workDoneProgressEnd) x
 
   describe "workspace folders" $
     it "keeps track of open workspace folders" $ do

lsp-test/src/Language/LSP/Test.hs

@@ -119,7 +119,7 @@ import Data.List
 import Data.Maybe
 import Language.LSP.Protocol.Types
 import Language.LSP.Protocol.Message
-import qualified Language.LSP.Protocol.Lens as J
+import qualified Language.LSP.Protocol.Lens as L
 import qualified Language.LSP.Protocol.Capabilities as C
 import Language.LSP.VFS
 import Language.LSP.Test.Compat
@@ -227,7 +227,7 @@ runSessionWithHandles' serverProc serverIn serverOut config' caps rootDir sessio
     -- collect them and then...
     (inBetween, initRspMsg) <- manyTill_ anyMessage (responseForId SMethod_Initialize initReqId)
 
-    case initRspMsg ^. J.result of
+    case initRspMsg ^. L.result of
       Left error -> liftIO $ putStrLn ("Error while initializing: " ++ show error)
       Right _ -> pure ()
 
@@ -291,7 +291,7 @@ envOverrideConfig cfg = do
 documentContents :: TextDocumentIdentifier -> Session T.Text
 documentContents doc = do
   vfs <- vfs <$> get
-  let Just file = vfs ^. vfsMap . at (toNormalizedUri (doc ^. J.uri))
+  let Just file = vfs ^. vfsMap . at (toNormalizedUri (doc ^. L.uri))
   return (virtualFileText file)
 
 -- | Parses an ApplyEditRequest, checks that it is for the passed document
@@ -306,14 +306,14 @@ getDocumentEdit doc = do
   documentContents doc
   where
     checkDocumentChanges req =
-      let changes = req ^. J.params . J.edit . J.documentChanges
+      let changes = req ^. L.params . L.edit . L.documentChanges
           maybeDocs = fmap (fmap documentChangeUri) changes
       in case maybeDocs of
-        Just docs -> (doc ^. J.uri) `elem` docs
+        Just docs -> (doc ^. L.uri) `elem` docs
         Nothing -> False
     checkChanges req =
-      let mMap = req ^. J.params . J.edit . J.changes
-        in maybe False (Map.member (doc ^. J.uri)) mMap
+      let mMap = req ^. L.params . L.edit . L.changes
+        in maybe False (Map.member (doc ^. L.uri)) mMap
 
 -- | Sends a request to the server and waits for its response.
 -- Will skip any messages in between the request and the response
@@ -432,10 +432,10 @@ createDoc file languageId contents = do
       createHits _ = False
 
       regHits :: TRegistration Method_WorkspaceDidChangeWatchedFiles -> Bool
-      regHits reg = foldl' (\acc w -> acc || watchHits w) False (reg ^. J.registerOptions . _Just . J.watchers)
+      regHits reg = foldl' (\acc w -> acc || watchHits w) False (reg ^. L.registerOptions . _Just . L.watchers)
 
       clientCapsSupports =
-          caps ^? J.workspace . _Just . J.didChangeWatchedFiles . _Just . J.dynamicRegistration . _Just
+          caps ^? L.workspace . _Just . L.didChangeWatchedFiles . _Just . L.dynamicRegistration . _Just
             == Just True
       shouldSend = clientCapsSupports && foldl' (\acc r -> acc || regHits r) False regs
 
@@ -467,14 +467,14 @@ openDoc' file languageId contents = do
 -- | Closes a text document and sends a textDocument/didOpen notification to the server.
 closeDoc :: TextDocumentIdentifier -> Session ()
 closeDoc docId = do
-  let params = DidCloseTextDocumentParams (TextDocumentIdentifier (docId ^. J.uri))
+  let params = DidCloseTextDocumentParams (TextDocumentIdentifier (docId ^. L.uri))
   sendNotification SMethod_TextDocumentDidClose params
 
 -- | Changes a text document and sends a textDocument/didOpen notification to the server.
 changeDoc :: TextDocumentIdentifier -> [TextDocumentContentChangeEvent] -> Session ()
 changeDoc docId changes = do
   verDoc <- getVersionedDoc docId
-  let params = DidChangeTextDocumentParams (verDoc & J.version +~ 1) changes
+  let params = DidChangeTextDocumentParams (verDoc & L.version +~ 1) changes
   sendNotification SMethod_TextDocumentDidChange params
 
 -- | Gets the Uri for the file corrected to the session directory.
@@ -488,7 +488,7 @@ getDocUri file = do
 waitForDiagnostics :: Session [Diagnostic]
 waitForDiagnostics = do
   diagsNot <- skipManyTill anyMessage (message SMethod_TextDocumentPublishDiagnostics)
-  let diags = diagsNot ^. J.params . J.diagnostics
+  let diags = diagsNot ^. L.params . L.diagnostics
   return diags
 
 -- | The same as 'waitForDiagnostics', but will only match a specific
@@ -502,15 +502,15 @@ waitForDiagnosticsSource src = do
     else return res
   where
     matches :: Diagnostic -> Bool
-    matches d = d ^. J.source == Just (T.pack src)
+    matches d = d ^. L.source == Just (T.pack src)
 
 -- | Expects a 'PublishDiagnosticsNotification' and throws an
 -- 'UnexpectedDiagnostics' exception if there are any diagnostics
 -- returned.
 noDiagnostics :: Session ()
 noDiagnostics = do
   diagsNot <- message SMethod_TextDocumentPublishDiagnostics
-  when (diagsNot ^. J.params . J.diagnostics /= []) $ liftIO $ throw UnexpectedDiagnostics
+  when (diagsNot ^. L.params . L.diagnostics /= []) $ liftIO $ throw UnexpectedDiagnostics
 
 -- | Returns the symbols in a document.
 getDocumentSymbols :: TextDocumentIdentifier -> Session (Either [SymbolInformation] [DocumentSymbol])
@@ -528,10 +528,10 @@ getCodeActions doc range = do
   ctx <- getCodeActionContextInRange doc range
   rsp <- request SMethod_TextDocumentCodeAction (CodeActionParams Nothing Nothing doc range ctx)
 
-  case rsp ^. J.result of
+  case rsp ^. L.result of
     Right (InL xs) -> return xs
     Right (InR _) -> return []
-    Left error -> throw (UnexpectedResponseError (SomeLspId $ fromJust $ rsp ^. J.id) error)
+    Left error -> throw (UnexpectedResponseError (SomeLspId $ fromJust $ rsp ^. L.id) error)
 
 -- | Returns all the code actions in a document by
 -- querying the code actions at each of the current
@@ -545,7 +545,7 @@ getAllCodeActions doc = do
   where
     go :: CodeActionContext -> [Command |? CodeAction] -> Diagnostic -> Session [Command |? CodeAction]
     go ctx acc diag = do
-      TResponseMessage _ rspLid res <- request SMethod_TextDocumentCodeAction (CodeActionParams Nothing Nothing doc (diag ^. J.range) ctx)
+      TResponseMessage _ rspLid res <- request SMethod_TextDocumentCodeAction (CodeActionParams Nothing Nothing doc (diag ^. L.range) ctx)
 
       case res of
         Left e -> throw (UnexpectedResponseError (SomeLspId $ fromJust rspLid) e)
@@ -580,7 +580,7 @@ getCodeActionContext doc = do
 -- | Returns the current diagnostics that have been sent to the client.
 -- Note that this does not wait for more to come in.
 getCurrentDiagnostics :: TextDocumentIdentifier -> Session [Diagnostic]
-getCurrentDiagnostics doc = fromMaybe [] . Map.lookup (toNormalizedUri $ doc ^. J.uri) . curDiagnostics <$> get
+getCurrentDiagnostics doc = fromMaybe [] . Map.lookup (toNormalizedUri $ doc ^. L.uri) . curDiagnostics <$> get
 
 -- | Returns the tokens of all progress sessions that have started but not yet ended.
 getIncompleteProgressSessions :: Session (Set.Set ProgressToken)
@@ -589,8 +589,8 @@ getIncompleteProgressSessions = curProgressSessions <$> get
 -- | Executes a command.
 executeCommand :: Command -> Session ()
 executeCommand cmd = do
-  let args = decode $ encode $ fromJust $ cmd ^. J.arguments
-      execParams = ExecuteCommandParams Nothing (cmd ^. J.command) args
+  let args = decode $ encode $ fromJust $ cmd ^. L.arguments
+      execParams = ExecuteCommandParams Nothing (cmd ^. L.command) args
   void $ sendRequest SMethod_WorkspaceExecuteCommand execParams
 
 -- | Executes a code action.
@@ -599,8 +599,8 @@ executeCommand cmd = do
 -- be applied first.
 executeCodeAction :: CodeAction -> Session ()
 executeCodeAction action = do
-  maybe (return ()) handleEdit $ action ^. J.edit
-  maybe (return ()) executeCommand $ action ^. J.command
+  maybe (return ()) handleEdit $ action ^. L.edit
+  maybe (return ()) executeCommand $ action ^. L.command
 
   where handleEdit :: WorkspaceEdit -> Session ()
         handleEdit e =
@@ -625,14 +625,14 @@ applyEdit doc edit = do
 
   caps <- asks sessionCapabilities
 
-  let supportsDocChanges = fromMaybe False $ caps ^? J.workspace . _Just . J.workspaceEdit . _Just . J.documentChanges . _Just
+  let supportsDocChanges = fromMaybe False $ caps ^? L.workspace . _Just . L.workspaceEdit . _Just . L.documentChanges . _Just
 
   let wEdit = if supportsDocChanges
       then
         let docEdit = TextDocumentEdit (review _versionedTextDocumentIdentifier verDoc) [InL edit]
         in WorkspaceEdit Nothing (Just [InL docEdit]) Nothing
       else
-        let changes = Map.singleton (doc ^. J.uri) [edit]
+        let changes = Map.singleton (doc ^. L.uri) [edit]
         in WorkspaceEdit (Just changes) Nothing Nothing
 
   let req = TRequestMessage "" (IdInt 0) SMethod_WorkspaceApplyEdit (ApplyWorkspaceEditParams Nothing wEdit)
@@ -648,7 +648,7 @@ getCompletions doc pos = do
 
   case getResponseResult rsp of
     InL items -> return items
-    InR (InL c) -> return $ c ^. J.items
+    InR (InL c) -> return $ c ^. L.items
     InR (InR _) -> return []
 
 -- | Returns the references for the position in the document.
@@ -721,9 +721,9 @@ getHighlights doc pos =
 -- Returns the result if successful.
 getResponseResult :: (ToJSON (ErrorData m)) => TResponseMessage m -> MessageResult m
 getResponseResult rsp =
-  case rsp ^. J.result of
+  case rsp ^. L.result of
     Right x -> x
-    Left err -> throw $ UnexpectedResponseError (SomeLspId $ fromJust $ rsp ^. J.id) err
+    Left err -> throw $ UnexpectedResponseError (SomeLspId $ fromJust $ rsp ^. L.id) err
 
 -- | Applies formatting to the specified document.
 formatDoc :: TextDocumentIdentifier -> FormattingOptions -> Session ()
@@ -741,7 +741,7 @@ formatRange doc opts range = do
 
 applyTextEdits :: TextDocumentIdentifier -> [TextEdit] -> Session ()
 applyTextEdits doc edits =
-  let wEdit = WorkspaceEdit (Just (Map.singleton (doc ^. J.uri) edits)) Nothing Nothing
+  let wEdit = WorkspaceEdit (Just (Map.singleton (doc ^. L.uri) edits)) Nothing Nothing
       -- Send a dummy message to updateState so it can do bookkeeping
       req = TRequestMessage "" (IdInt 0) SMethod_WorkspaceApplyEdit (ApplyWorkspaceEditParams Nothing wEdit)
   in updateState (FromServerMess SMethod_WorkspaceApplyEdit req)

lsp-test/src/Language/LSP/Test/Decoding.hs

@@ -16,7 +16,7 @@ import           Data.Maybe
 import           System.IO
 import           System.IO.Error
 import           Language.LSP.Protocol.Message
-import qualified Language.LSP.Protocol.Lens as J
+import qualified Language.LSP.Protocol.Lens as L
 import           Language.LSP.Test.Exceptions
 
 import Data.IxMap
@@ -64,10 +64,10 @@ getRequestMap = foldl' helper emptyIxMap
   helper acc msg = case msg of
     FromClientMess m mess -> case splitClientMethod m of
       IsClientNot -> acc
-      IsClientReq -> fromJust $ updateRequestMap acc (mess ^. J.id) m
+      IsClientReq -> fromJust $ updateRequestMap acc (mess ^. L.id) m
       IsClientEither -> case mess of
         NotMess _ -> acc
-        ReqMess msg -> fromJust $ updateRequestMap acc (msg ^. J.id) m
+        ReqMess msg -> fromJust $ updateRequestMap acc (msg ^. L.id) m
     _ -> acc
 
 decodeFromServerMsg :: RequestMap -> B.ByteString -> (RequestMap, FromServerMessage)

lsp-test/src/Language/LSP/Test/Files.hs

@@ -12,7 +12,7 @@ where
 
 import           Language.LSP.Protocol.Message
 import           Language.LSP.Protocol.Types
-import qualified Language.LSP.Protocol.Lens    as J
+import qualified Language.LSP.Protocol.Lens    as L
 import           Control.Lens
 import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
@@ -41,7 +41,7 @@ swapFiles relCurBaseDir msgs = do
 rootDir :: [Event] -> FilePath
 rootDir (ClientEv _ (FromClientMess SMethod_Initialize req):_) =
   fromMaybe (error "Couldn't find root dir") $ do
-    rootUri <- case req ^. J.params . J.rootUri of
+    rootUri <- case req ^. L.params . L.rootUri of
         InL r -> Just r
         InR _ -> error "Couldn't find root dir"
     uriToFilePath rootUri
@@ -55,46 +55,46 @@ mapUris f event =
 
   where
     --TODO: Handle all other URIs that might need swapped
-    fromClientMsg (FromClientMess m@SMethod_Initialize                 r) = FromClientMess m $ J.params .~ transformInit (r ^. J.params) $ r
-    fromClientMsg (FromClientMess m@SMethod_TextDocumentDidOpen        n) = FromClientMess m $ swapUri (J.params . J.textDocument) n
-    fromClientMsg (FromClientMess m@SMethod_TextDocumentDidChange      n) = FromClientMess m $ swapUri (J.params . J.textDocument) n
-    fromClientMsg (FromClientMess m@SMethod_TextDocumentWillSave       n) = FromClientMess m $ swapUri (J.params . J.textDocument) n
-    fromClientMsg (FromClientMess m@SMethod_TextDocumentDidSave        n) = FromClientMess m $ swapUri (J.params . J.textDocument) n
-    fromClientMsg (FromClientMess m@SMethod_TextDocumentDidClose       n) = FromClientMess m $ swapUri (J.params . J.textDocument) n
-    fromClientMsg (FromClientMess m@SMethod_TextDocumentDocumentSymbol n) = FromClientMess m $ swapUri (J.params . J.textDocument) n
-    fromClientMsg (FromClientMess m@SMethod_TextDocumentRename         n) = FromClientMess m $ swapUri (J.params . J.textDocument) n
+    fromClientMsg (FromClientMess m@SMethod_Initialize                 r) = FromClientMess m $ L.params .~ transformInit (r ^. L.params) $ r
+    fromClientMsg (FromClientMess m@SMethod_TextDocumentDidOpen        n) = FromClientMess m $ swapUri (L.params . L.textDocument) n
+    fromClientMsg (FromClientMess m@SMethod_TextDocumentDidChange      n) = FromClientMess m $ swapUri (L.params . L.textDocument) n
+    fromClientMsg (FromClientMess m@SMethod_TextDocumentWillSave       n) = FromClientMess m $ swapUri (L.params . L.textDocument) n
+    fromClientMsg (FromClientMess m@SMethod_TextDocumentDidSave        n) = FromClientMess m $ swapUri (L.params . L.textDocument) n
+    fromClientMsg (FromClientMess m@SMethod_TextDocumentDidClose       n) = FromClientMess m $ swapUri (L.params . L.textDocument) n
+    fromClientMsg (FromClientMess m@SMethod_TextDocumentDocumentSymbol n) = FromClientMess m $ swapUri (L.params . L.textDocument) n
+    fromClientMsg (FromClientMess m@SMethod_TextDocumentRename         n) = FromClientMess m $ swapUri (L.params . L.textDocument) n
     fromClientMsg x = x
 
     fromServerMsg :: FromServerMessage -> FromServerMessage
-    fromServerMsg (FromServerMess m@SMethod_WorkspaceApplyEdit r) = FromServerMess m $ J.params . J.edit .~ swapWorkspaceEdit (r ^. J.params . J.edit) $ r
-    fromServerMsg (FromServerMess m@SMethod_TextDocumentPublishDiagnostics n) = FromServerMess m $ swapUri J.params n
+    fromServerMsg (FromServerMess m@SMethod_WorkspaceApplyEdit r) = FromServerMess m $ L.params . L.edit .~ swapWorkspaceEdit (r ^. L.params . L.edit) $ r
+    fromServerMsg (FromServerMess m@SMethod_TextDocumentPublishDiagnostics n) = FromServerMess m $ swapUri L.params n
     fromServerMsg (FromServerRsp m@SMethod_TextDocumentDocumentSymbol r) =
       let swapUri' :: ([SymbolInformation] |? [DocumentSymbol] |? Null) -> [SymbolInformation] |? [DocumentSymbol] |? Null
           swapUri' (InR (InL dss)) = InR $ InL dss -- no file locations here
           swapUri' (InR (InR n)) = InR $ InR n
-          swapUri' (InL si) = InL (swapUri J.location <$> si)
-      in FromServerRsp m $ r & J.result . _Right %~ swapUri'
-    fromServerMsg (FromServerRsp m@SMethod_TextDocumentRename r) = FromServerRsp m $ r & J.result . _Right . _L %~ swapWorkspaceEdit
+          swapUri' (InL si) = InL (swapUri L.location <$> si)
+      in FromServerRsp m $ r & L.result . _Right %~ swapUri'
+    fromServerMsg (FromServerRsp m@SMethod_TextDocumentRename r) = FromServerRsp m $ r & L.result . _Right . _L %~ swapWorkspaceEdit
     fromServerMsg x = x
 
     swapWorkspaceEdit :: WorkspaceEdit -> WorkspaceEdit
     swapWorkspaceEdit e =
       let swapDocumentChangeUri :: DocumentChange -> DocumentChange
-          swapDocumentChangeUri (InL textDocEdit) = InL $ swapUri J.textDocument textDocEdit
+          swapDocumentChangeUri (InL textDocEdit) = InL $ swapUri L.textDocument textDocEdit
           swapDocumentChangeUri (InR (InL createFile)) = InR $ InL $ swapUri id createFile
           -- for RenameFile, we swap `newUri`
-          swapDocumentChangeUri (InR (InR (InL renameFile))) = InR $ InR $ InL $ J.newUri .~ f (renameFile ^. J.newUri) $ renameFile
+          swapDocumentChangeUri (InR (InR (InL renameFile))) = InR $ InR $ InL $ L.newUri .~ f (renameFile ^. L.newUri) $ renameFile
           swapDocumentChangeUri (InR (InR (InR deleteFile))) = InR $ InR $ InR $ swapUri id deleteFile
-       in e & J.changes . _Just %~ swapKeys f
-            & J.documentChanges . _Just . traversed%~ swapDocumentChangeUri
+       in e & L.changes . _Just %~ swapKeys f
+            & L.documentChanges . _Just . traversed%~ swapDocumentChangeUri
 
     swapKeys :: (Uri -> Uri) -> M.Map Uri b -> M.Map Uri b
     swapKeys f = M.foldlWithKey' (\acc k v -> M.insert (f k) v acc) M.empty
 
-    swapUri :: J.HasUri b Uri => Lens' a b -> a -> a
+    swapUri :: L.HasUri b Uri => Lens' a b -> a -> a
     swapUri lens x =
-      let newUri = f (x ^. lens . J.uri)
-        in (lens . J.uri) .~ newUri $ x
+      let newUri = f (x ^. lens . L.uri)
+        in (lens . L.uri) .~ newUri $ x
 
     -- | Transforms rootUri/rootPath.
     transformInit :: InitializeParams -> InitializeParams
@@ -105,5 +105,5 @@ mapUris f event =
             in case uriToFilePath (f uri) of
               Just fp -> T.pack fp
               Nothing -> p
-      in x & J.rootUri . _L %~ f
-           & J.rootPath . _Just . _L %~ modifyRootPath
+      in x & L.rootUri . _L %~ f
+           & L.rootPath . _Just . _L %~ modifyRootPath