Implement Goto Type Definition (haskell/ghcide#533)

* Implement Goto Type Definition

ghcide/src/Development/IDE/Core/Rules.hs

@@ -21,6 +21,7 @@ module Development.IDE.Core.Rules(
     mainRule,
     getAtPoint,
     getDefinition,
+    getTypeDefinition,
     getDependencies,
     getParsedModule,
     generateCore,
@@ -123,6 +124,13 @@ getDefinition file pos = fmap join $ runMaybeT $ do
     spans <- useE GetSpanInfo file
     lift $ AtPoint.gotoDefinition (getHieFile file) opts (spansExprs spans) pos
 
+getTypeDefinition :: NormalizedFilePath -> Position -> Action (Maybe [Location])
+getTypeDefinition file pos = runMaybeT $ do
+    opts <- lift getIdeOptions
+    spans <- useE GetSpanInfo file
+    lift $ AtPoint.gotoTypeDefinition (getHieFile file) opts (spansExprs spans) pos
+
+
 getHieFile
   :: NormalizedFilePath -- ^ file we're editing
   -> Module -- ^ module dep we want info for

ghcide/src/Development/IDE/LSP/HoverDefinition.hs

@@ -6,9 +6,11 @@
 module Development.IDE.LSP.HoverDefinition
     ( setHandlersHover
     , setHandlersDefinition
+    , setHandlersTypeDefinition
     -- * For haskell-language-server
     , hover
     , gotoDefinition
+    , gotoTypeDefinition
     ) where
 
 import           Development.IDE.Core.Rules
@@ -26,16 +28,20 @@ import System.Time.Extra (showDuration, duration)
 
 gotoDefinition :: IdeState -> TextDocumentPositionParams -> IO (Either ResponseError LocationResponseParams)
 hover          :: IdeState -> TextDocumentPositionParams -> IO (Either ResponseError (Maybe Hover))
+gotoTypeDefinition :: IdeState -> TextDocumentPositionParams -> IO (Either ResponseError LocationResponseParams)
 gotoDefinition = request "Definition" getDefinition (MultiLoc []) SingleLoc
+gotoTypeDefinition = request "TypeDefinition" getTypeDefinition (MultiLoc []) MultiLoc
 hover          = request "Hover"      getAtPoint     Nothing      foundHover
 
 foundHover :: (Maybe Range, [T.Text]) -> Maybe Hover
 foundHover (mbRange, contents) =
   Just $ Hover (HoverContents $ MarkupContent MkMarkdown $ T.intercalate sectionSeparator contents) mbRange
 
-setHandlersDefinition, setHandlersHover :: PartialHandlers c
+setHandlersDefinition, setHandlersHover, setHandlersTypeDefinition :: PartialHandlers c
 setHandlersDefinition = PartialHandlers $ \WithMessage{..} x ->
   return x{LSP.definitionHandler = withResponse RspDefinition $ const gotoDefinition}
+setHandlersTypeDefinition = PartialHandlers $ \WithMessage{..} x ->
+  return x{LSP.typeDefinitionHandler = withResponse RspDefinition $ const gotoTypeDefinition}
 setHandlersHover      = PartialHandlers $ \WithMessage{..} x ->
   return x{LSP.hoverHandler      = withResponse RspHover      $ const hover}
 

ghcide/src/Development/IDE/LSP/LanguageServer.hs

@@ -101,7 +101,7 @@ runLanguageServer options userHandlers onInitialConfig onConfigChange getIdeStat
     let PartialHandlers parts =
             initializeRequestHandler <>
             setHandlersIgnore <> -- least important
-            setHandlersDefinition <> setHandlersHover <>
+            setHandlersDefinition <> setHandlersHover <> setHandlersTypeDefinition <>
             setHandlersOutline <>
             userHandlers <>
             setHandlersNotifications <> -- absolutely critical, join them with user notifications

ghcide/src/Development/IDE/Spans/AtPoint.hs

@@ -6,6 +6,7 @@
 module Development.IDE.Spans.AtPoint (
     atPoint
   , gotoDefinition
+  , gotoTypeDefinition
   ) where
 
 import           Development.IDE.GHC.Error
@@ -34,6 +35,16 @@ import           Data.Maybe
 import           Data.List
 import qualified Data.Text as T
 
+gotoTypeDefinition
+  :: MonadIO m
+  => (Module -> m (Maybe (HieFile, FilePath)))
+  -> IdeOptions
+  -> [SpanInfo]
+  -> Position
+  -> m [Location]
+gotoTypeDefinition getHieFile ideOpts srcSpans pos
+  = typeLocationsAtPoint getHieFile ideOpts pos srcSpans
+
 -- | Locate the definition of the name at a given position.
 gotoDefinition
   :: MonadIO m
@@ -115,6 +126,26 @@ atPoint IdeOptions{..} (SpansInfo srcSpans cntsSpans) pos = do
         Just name -> any (`isInfixOf` getOccString name) ["==", "showsPrec"]
         Nothing -> False
 
+
+
+
+typeLocationsAtPoint
+  :: forall m
+   . MonadIO m
+  => (Module -> m (Maybe (HieFile, FilePath)))
+  -> IdeOptions
+  -> Position
+  -> [SpanInfo]
+  -> m [Location]
+typeLocationsAtPoint getHieFile = querySpanInfoAt getTypeSpan
+  where getTypeSpan :: SpanInfo -> m (Maybe SrcSpan)
+        getTypeSpan SpanInfo { spaninfoType = Just t } =
+          case splitTyConApp_maybe t of
+            Nothing -> return Nothing
+            Just (getName -> name, _) ->
+              nameToLocation getHieFile name
+        getTypeSpan _ = return Nothing
+
 locationsAtPoint
   :: forall m
    . MonadIO m
@@ -123,32 +154,47 @@ locationsAtPoint
   -> Position
   -> [SpanInfo]
   -> m [Location]
-locationsAtPoint getHieFile _ideOptions pos =
-    fmap (map srcSpanToLocation) . mapMaybeM (getSpan . spaninfoSource) . spansAtPoint pos
+locationsAtPoint getHieFile = querySpanInfoAt (getSpan . spaninfoSource)
   where getSpan :: SpanSource -> m (Maybe SrcSpan)
         getSpan NoSource = pure Nothing
         getSpan (SpanS sp) = pure $ Just sp
         getSpan (Lit _) = pure Nothing
-        getSpan (Named name) = case nameSrcSpan name of
-            sp@(RealSrcSpan _) -> pure $ Just sp
-            sp@(UnhelpfulSpan _) -> runMaybeT $ do
-                guard (sp /= wiredInSrcSpan)
-                -- This case usually arises when the definition is in an external package (DAML only).
-                -- In this case the interface files contain garbage source spans
-                -- so we instead read the .hie files to get useful source spans.
-                mod <- MaybeT $ return $ nameModule_maybe name
-                (hieFile, srcPath) <- MaybeT $ getHieFile mod
-                avail <- MaybeT $ pure $ find (eqName name . snd) $ hieExportNames hieFile
-                -- The location will point to the source file used during compilation.
-                -- This file might no longer exists and even if it does the path will be relative
-                -- to the compilation directory which we don’t know.
-                let span = setFileName srcPath $ fst avail
-                pure span
-        -- We ignore uniques and source spans and only compare the name and the module.
-        eqName :: Name -> Name -> Bool
-        eqName n n' = nameOccName n == nameOccName n' && nameModule_maybe n == nameModule_maybe n'
-        setFileName f (RealSrcSpan span) = RealSrcSpan (span { srcSpanFile = mkFastString f })
-        setFileName _ span@(UnhelpfulSpan _) = span
+        getSpan (Named name) = nameToLocation getHieFile name
+
+querySpanInfoAt :: forall m
+   . MonadIO m
+  => (SpanInfo -> m (Maybe SrcSpan))
+  -> IdeOptions
+  -> Position
+  -> [SpanInfo]
+  -> m [Location]
+querySpanInfoAt getSpan _ideOptions pos =
+    fmap (map srcSpanToLocation) . mapMaybeM getSpan . spansAtPoint pos
+
+-- | Given a 'Name' attempt to find the location where it is defined.
+nameToLocation :: Monad f => (Module -> f (Maybe (HieFile, String))) -> Name -> f (Maybe SrcSpan)
+nameToLocation getHieFile name =
+  case nameSrcSpan name of
+    sp@(RealSrcSpan _) -> pure $ Just sp
+    sp@(UnhelpfulSpan _) -> runMaybeT $ do
+      guard (sp /= wiredInSrcSpan)
+      -- This case usually arises when the definition is in an external package (DAML only).
+      -- In this case the interface files contain garbage source spans
+      -- so we instead read the .hie files to get useful source spans.
+      mod <- MaybeT $ return $ nameModule_maybe name
+      (hieFile, srcPath) <- MaybeT $ getHieFile mod
+      avail <- MaybeT $ pure $ find (eqName name . snd) $ hieExportNames hieFile
+      -- The location will point to the source file used during compilation.
+      -- This file might no longer exists and even if it does the path will be relative
+      -- to the compilation directory which we don’t know.
+      let span = setFileName srcPath $ fst avail
+      pure span
+  where
+    -- We ignore uniques and source spans and only compare the name and the module.
+    eqName :: Name -> Name -> Bool
+    eqName n n' = nameOccName n == nameOccName n' && nameModule_maybe n == nameModule_maybe n'
+    setFileName f (RealSrcSpan span) = RealSrcSpan (span { srcSpanFile = mkFastString f })
+    setFileName _ span@(UnhelpfulSpan _) = span
 
 -- | Filter out spans which do not enclose a given point
 spansAtPoint :: Position -> [SpanInfo] -> [SpanInfo]

ghcide/test/data/hover/hie.yaml

@@ -0,0 +1 @@
+cradle: {direct: {arguments: ["Foo", "Bar", "GotoHover"]}}

ghcide/test/exe/Main.hs

@@ -98,8 +98,10 @@ initializeResponseTests = withResource acquire release tests where
     , chk "   completion"               _completionProvider (Just $ CompletionOptions (Just False) (Just ["."]) Nothing)
     , chk "NO signature help"        _signatureHelpProvider  Nothing
     , chk "   goto definition"          _definitionProvider (Just True)
-    , chk "NO goto type definition" _typeDefinitionProvider (Just $ GotoOptionsStatic False)
-    , chk "NO goto implementation"  _implementationProvider (Just $ GotoOptionsStatic False)
+    , chk "   goto type definition" _typeDefinitionProvider (Just $ GotoOptionsStatic True)
+    -- BUG in lsp-test, this test fails, just change the accepted response
+    -- for now
+    , chk "NO goto implementation"  _implementationProvider (Just $ GotoOptionsStatic True)
     , chk "NO find references"          _referencesProvider  Nothing
     , chk "NO doc highlight"     _documentHighlightProvider  Nothing
     , chk "   doc symbol"           _documentSymbolProvider  (Just True)
@@ -1375,7 +1377,11 @@ findDefinitionAndHoverTests = let
   mkFindTests tests = testGroup "get"
     [ testGroup "definition" $ mapMaybe fst tests
     , testGroup "hover"      $ mapMaybe snd tests
-    , checkFileCompiles sourceFilePath ]
+    , checkFileCompiles sourceFilePath
+    , testGroup "type-definition" typeDefinitionTests ]
+
+  typeDefinitionTests = [ tst (getTypeDefinitions, checkDefs) aaaL14 (pure tcData) "Saturated data con"
+                        , tst (getTypeDefinitions, checkDefs) opL16 (pure [ExpectNoDefinitions]) "Polymorphic variable"]
 
   test runDef runHover look expect = testM runDef runHover look (return expect)
 
@@ -1384,7 +1390,6 @@ findDefinitionAndHoverTests = let
     , runHover $ tst hover look expect title ) where
       def   = (getDefinitions, checkDefs)
       hover = (getHover      , checkHover)
-      --type_ = (getTypeDefinitions, checkTDefs) -- getTypeDefinitions always times out
 
   -- search locations            expectations on results
   fffL4  = _start fffR     ;  fffR = mkRange 8  4    8  7 ; fff  = [ExpectRange fffR]