fix merge issues

plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal.hs

@@ -17,14 +17,12 @@ import qualified Data.ByteString                             as BS
 import           Data.Hashable
 import           Data.HashMap.Strict                         (HashMap)
 import qualified Data.HashMap.Strict                         as HashMap
-import           Data.List                                   (find)
 import qualified Data.List.NonEmpty                          as NE
 import qualified Data.Maybe                                  as Maybe
 import qualified Data.Text                                   as T
 import qualified Data.Text.Encoding                          as Encoding
 import           Data.Typeable
 import           Development.IDE                             as D
-import           Development.IDE.Core.PluginUtils
 import           Development.IDE.Core.Shake                  (restartShakeSession)
 import qualified Development.IDE.Core.Shake                  as Shake
 import           Development.IDE.Graph                       (Key, alwaysRerun)
@@ -33,21 +31,19 @@ import           Development.IDE.Types.Shake                 (toKey)
 import qualified Distribution.Fields                         as Syntax
 import qualified Distribution.Parsec.Position                as Syntax
 import           GHC.Generics
-import           Ide.Plugin.Cabal.Completion.CabalFields     as CabalFields
 import qualified Ide.Plugin.Cabal.Completion.Completer.Types as CompleterTypes
 import qualified Ide.Plugin.Cabal.Completion.Completions     as Completions
 import           Ide.Plugin.Cabal.Completion.Types           (ParseCabalCommonSections (ParseCabalCommonSections),
                                                               ParseCabalFields (..),
                                                               ParseCabalFile (..))
 import qualified Ide.Plugin.Cabal.Completion.Types           as Types
-import           Ide.Plugin.Cabal.Definition                 (gotoDefinitionAction)
+import           Ide.Plugin.Cabal.Definition                 (gotoDefinition)
 import qualified Ide.Plugin.Cabal.Diagnostics                as Diagnostics
 import qualified Ide.Plugin.Cabal.FieldSuggest               as FieldSuggest
 import qualified Ide.Plugin.Cabal.LicenseSuggest             as LicenseSuggest
 import           Ide.Plugin.Cabal.Orphans                    ()
 import           Ide.Plugin.Cabal.Outline
 import qualified Ide.Plugin.Cabal.Parse                      as Parse
-import           Ide.Plugin.Error
 import           Ide.Types
 import qualified Language.LSP.Protocol.Lens                  as JL
 import qualified Language.LSP.Protocol.Message               as LSP
@@ -98,7 +94,7 @@ descriptor recorder plId =
           , mkPluginHandler LSP.SMethod_TextDocumentCompletion $ completion recorder
           , mkPluginHandler LSP.SMethod_TextDocumentDocumentSymbol moduleOutline
           , mkPluginHandler LSP.SMethod_TextDocumentCodeAction $ fieldSuggestCodeAction recorder
-          , mkPluginHandler LSP.SMethod_TextDocumentDefinition gotoDefinitionAction
+          , mkPluginHandler LSP.SMethod_TextDocumentDefinition gotoDefinition
           ]
     , pluginNotificationHandlers =
         mconcat
@@ -283,32 +279,6 @@ fieldSuggestCodeAction recorder ide _ (CodeActionParams _ _ (TextDocumentIdentif
       let completionTexts = fmap (^. JL.label) completions
       pure $ FieldSuggest.fieldErrorAction uri fieldName completionTexts _range
 
--- | CodeActions for going to definitions.
---
--- Provides a CodeAction for going to a definition when clicking on an identifier.
--- The definition is found by traversing the sections and comparing their name to
--- the clicked identifier.
---
--- TODO: Support more definitions than sections.
-gotoDefinition :: PluginMethodHandler IdeState LSP.Method_TextDocumentDefinition
-gotoDefinition ideState _ msgParam = do
-    nfp <- getNormalizedFilePathE uri
-    cabalFields <- runActionE "cabal-plugin.commonSections" ideState $ useE ParseCabalFields nfp
-    case CabalFields.findTextWord cursor cabalFields of
-      Nothing ->
-        pure $ InR $ InR Null
-      Just cursorText -> do
-        commonSections <- runActionE "cabal-plugin.commonSections" ideState $ useE ParseCabalCommonSections nfp
-        case find (isSectionArgName cursorText) commonSections of
-          Nothing ->
-            pure $ InR $ InR Null
-          Just commonSection -> do
-            pure $ InL $ Definition $ InL $ Location uri $ CabalFields.getFieldLSPRange commonSection
-    where
-      cursor = Types.lspPositionToCabalPosition (msgParam ^. JL.position)
-      uri = msgParam ^. JL.textDocument . JL.uri
-      isSectionArgName name (Syntax.Section _ sectionArgName _) = name == CabalFields.onelineSectionArgs sectionArgName
-      isSectionArgName _ _ = False
 
 -- ----------------------------------------------------------------
 -- Cabal file of Interest rules and global variable

plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Definition.hs

@@ -52,8 +52,8 @@ import           System.FilePath                               (joinPath,
 -- gathering all possible definitions by calling subfunctions.
 
 -- TODO: Resolve more cases for go-to definition.
-gotoDefinitionAction :: PluginMethodHandler IdeState LSP.Method_TextDocumentDefinition
-gotoDefinitionAction ide _ msgParam = do
+gotoDefinition :: PluginMethodHandler IdeState LSP.Method_TextDocumentDefinition
+gotoDefinition ide _ msgParam = do
     nfp <- getNormalizedFilePathE uri
     cabalFields <- runActionE "cabal-plugin.commonSections" ide $ useE ParseCabalFields nfp
     -- Trim the AST tree, so multiple passes in subfunctions won't hurt the performance.

plugins/hls-cabal-plugin/test/Main.hs

@@ -21,7 +21,6 @@ import           Definition                      (gotoDefinitionTests)
 import           Ide.Plugin.Cabal.LicenseSuggest (licenseErrorSuggestion)
 import qualified Ide.Plugin.Cabal.Parse          as Lib
 import qualified Language.LSP.Protocol.Lens      as L
-import qualified Language.LSP.Protocol.Types     as LSP
 import           Outline                         (outlineTests)
 import           System.FilePath
 import           Test.Hls
@@ -230,56 +229,3 @@ codeActionTests = testGroup "Code Actions"
         InR action@CodeAction{_title} <- codeActions
         guard (_title == "Replace with " <> license)
         pure action
-
--- ----------------------------------------------------------------------------
--- Goto Definition Tests
--- ----------------------------------------------------------------------------
-
-gotoDefinitionTests :: TestTree
-gotoDefinitionTests = testGroup "Goto Definition"
-    [ positiveTest "middle of identifier"            (mkP 27 16) (mkR  6 0  7 22)
-    , positiveTest "left of identifier"              (mkP 30 12) (mkR 10 0 17 40)
-    , positiveTest "right of identifier"             (mkP 33 22) (mkR 20 0 23 34)
-    , positiveTest "left of '-' in identifier"       (mkP 36 20) (mkR  6 0  7 22)
-    , positiveTest "right of '-' in identifier"      (mkP 39 19) (mkR 10 0 17 40)
-    , positiveTest "identifier in identifier list"   (mkP 42 16) (mkR 20 0 23 34)
-    , positiveTest "left of ',' right of identifier" (mkP 45 33) (mkR 10 0 17 40)
-    , positiveTest "right of ',' left of identifier" (mkP 48 34) (mkR  6 0  7 22)
-
-    , negativeTest "right of ',' left of space"      (mkP 51 23)
-    , negativeTest "right of ':' left of space"      (mkP 54 11)
-    , negativeTest "not a definition"                (mkP 57 8)
-    , negativeTest "empty space"                     (mkP 59 7)
-    ]
-    where
-        mkP :: UInt -> UInt -> Position
-        mkP x1 y1 = Position x1 y1
-
-        mkR :: UInt -> UInt -> UInt -> UInt -> Range
-        mkR x1 y1 x2 y2 = Range (mkP x1 y1) (mkP x2 y2)
-
-        getDefinition :: Show b => (Definition |? b) -> Range
-        getDefinition (InL (Definition (InL loc))) = loc^.L.range
-        getDefinition unk = error $ "Unexpected pattern '" ++ show unk ++ "' , expected '(InL (Definition (InL loc))'"
-
-        -- A positive test checks if the provided range is equal
-        -- to the expected range from the definition in the test file.
-        -- The test emulates a goto-definition request of an actual definition.
-        positiveTest :: TestName -> Position -> Range -> TestTree
-        positiveTest testName cursorPos expectedRange =
-            runCabalTestCaseSession testName "goto-definition" $ do
-                doc <- openDoc "simple-with-common.cabal" "cabal"
-                definitions <- getDefinitions doc cursorPos
-                let locationRange = getDefinition definitions
-                liftIO $ locationRange @?= expectedRange
-
-        -- A negative test checks if the request failed and
-        -- the provided result is empty, i.e. `InR $ InR Null`.
-        -- The test emulates a goto-definition request of anything but an
-        -- actual definition.
-        negativeTest :: TestName -> Position -> TestTree
-        negativeTest testName cursorPos =
-            runCabalTestCaseSession testName "goto-definition" $ do
-                doc <- openDoc "simple-with-common.cabal" "cabal"
-                empty <- getDefinitions doc cursorPos
-                liftIO $ empty @?= (InR $ InR LSP.Null)