Change tracking of file types to language kinds

The plugin descriptor now tracks the language kinds it is responsible
for instead of the file endings.

We get the language kinds of any file from the VFS.

Currently we are using a source repository to be able to use the lsp
changes needed, but once lsp is released this can be removed.

Author: VeryMilkyJoe

cabal.project

@@ -7,6 +7,17 @@ packages:
          ./hls-plugin-api
          ./hls-test-utils
 
+source-repository-package
+    type: git
+    location: https://github.com/VeryMilkyJoe/lsp.git
+    subdir: lsp
+    tag: 39d780bbe9ebb4a21bd6d132a3c1abe4edf2b5a4
+
+source-repository-package
+    type: git
+    location: https://github.com/VeryMilkyJoe/lsp.git
+    subdir: lsp-test
+    tag: 39d780bbe9ebb4a21bd6d132a3c1abe4edf2b5a4
 
 index-state: 2025-05-12T13:26:29Z
 

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

@@ -226,8 +226,8 @@ getVersionedTextDoc doc = do
     maybe (pure Nothing) getVirtualFile $
         uriToNormalizedFilePath $ toNormalizedUri uri
   let ver = case mvf of
-        Just (VirtualFile lspver _ _) -> lspver
-        Nothing                       -> 0
+        Just (VirtualFile lspver _ _ _) -> lspver
+        Nothing                         -> 0
   return (VersionedTextDocumentIdentifier uri ver)
 
 fileStoreRules :: Recorder (WithPriority Log) -> (NormalizedFilePath -> Action Bool) -> Rules ()

ghcide/src/Development/IDE/Plugin/Completions/Logic.hs

@@ -854,7 +854,7 @@ mergeListsBy cmp all_lists = merge_lists all_lists
 
 -- |From the given cursor position, gets the prefix module or record for autocompletion
 getCompletionPrefix :: Position -> VFS.VirtualFile -> PosPrefixInfo
-getCompletionPrefix pos (VFS.VirtualFile _ _ ropetext) = getCompletionPrefixFromRope pos ropetext
+getCompletionPrefix pos (VFS.VirtualFile _ _ ropetext _) = getCompletionPrefixFromRope pos ropetext
 
 getCompletionPrefixFromRope :: Position -> Rope.Rope -> PosPrefixInfo
 getCompletionPrefixFromRope pos@(Position l c) ropetext =

ghcide/src/Development/IDE/Plugin/HLS.hs

@@ -251,11 +251,12 @@ extensiblePlugins recorder plugins = mempty { P.pluginHandlers = handlers }
     handlers = mconcat $ do
       (IdeMethod m :=> IdeHandler fs') <- DMap.assocs handlers'
       pure $ requestHandler m $ \ide params -> do
+        vfs <- LSP.getVirtualFiles
         config <- Ide.PluginUtils.getClientConfig
         -- Only run plugins that are allowed to run on this request, save the
         -- list of disabled plugins incase that's all we have
-        let (fs, dfs) = List.partition (\(_, desc, _) -> handlesRequest m params desc config == HandlesRequest) fs'
-        let disabledPluginsReason = (\(x, desc, _) -> (x, handlesRequest m params desc config)) <$> dfs
+        let (fs, dfs) = List.partition (\(_, desc, _) -> handlesRequest vfs m params desc config == HandlesRequest) fs'
+        let disabledPluginsReason = (\(x, desc, _) -> (x, handlesRequest vfs m params desc config)) <$> dfs
         -- Clients generally don't display ResponseErrors so instead we log any that we come across
         -- However, some clients do display ResponseErrors! See for example the issues:
         -- https://github.com/haskell/haskell-language-server/issues/4467
@@ -370,7 +371,7 @@ extensibleNotificationPlugins recorder xs = mempty { P.pluginHandlers = handlers
       pure $ notificationHandler m $ \ide vfs params -> do
         config <- Ide.PluginUtils.getClientConfig
         -- Only run plugins that are enabled for this request
-        let fs = filter (\(_, desc, _) -> handlesRequest m params desc config == HandlesRequest) fs'
+        let fs = filter (\(_, desc, _) -> handlesRequest vfs m params desc config == HandlesRequest) fs'
         case nonEmpty fs of
           Nothing -> do
             logWith recorder Warning (LogNoPluginForMethod $ Some m)

hls-plugin-api/src/Ide/Types.hs

@@ -94,13 +94,13 @@ import           Ide.Plugin.Properties
 import qualified Language.LSP.Protocol.Lens    as L
 import           Language.LSP.Protocol.Message
 import           Language.LSP.Protocol.Types
+import qualified Language.LSP.Protocol.Types   as J
 import           Language.LSP.Server
 import           Language.LSP.VFS
 import           Numeric.Natural
 import           OpenTelemetry.Eventlog
 import           Options.Applicative           (ParserInfo)
 import           Prettyprinter                 as PP
-import           System.FilePath
 import           System.IO.Unsafe
 import           Text.Regex.TDFA.Text          ()
 import           UnliftIO                      (MonadUnliftIO)
@@ -323,7 +323,7 @@ data PluginDescriptor (ideState :: Type) =
                    , pluginNotificationHandlers :: PluginNotificationHandlers ideState
                    , pluginModifyDynflags :: DynFlagsModifications
                    , pluginCli            :: Maybe (ParserInfo (IdeCommand ideState))
-                   , pluginFileType       :: [T.Text]
+                   , pluginLanguageIds    :: [J.LanguageKind]
                    -- ^ File extension of the files the plugin is responsible for.
                    --   The plugin is only allowed to handle files with these extensions.
                    --   When writing handlers, etc. for this plugin it can be assumed that all handled files are of this type.
@@ -416,14 +416,14 @@ pluginResolverResponsible _ _ = DoesNotHandleRequest $ NotResolveOwner "(unable
 -- We are passing the msgParams here even though we only need the URI URI here.
 -- If in the future we need to be able to provide only an URI it can be
 -- separated again.
-pluginSupportsFileType :: (L.HasTextDocument m doc, L.HasUri doc Uri) => m -> PluginDescriptor c -> HandleRequestResult
-pluginSupportsFileType msgParams pluginDesc =
-  case mfp of
-    Just fp | T.pack (takeExtension fp) `elem` pluginFileType pluginDesc -> HandlesRequest
-    _ -> DoesNotHandleRequest $ DoesNotSupportFileType (maybe "(unable to determine file type)" (T.pack . takeExtension) mfp)
+pluginSupportsFileType :: (L.HasTextDocument m doc, L.HasUri doc Uri) => VFS -> m -> PluginDescriptor c -> HandleRequestResult
+pluginSupportsFileType (VFS vfs) msgParams pluginDesc =
+  case _language_id =<< mVFS of
+    Just languageKind | languageKind `elem` pluginLanguageIds pluginDesc -> HandlesRequest
+    _ -> DoesNotHandleRequest $ DoesNotSupportFileType (maybe "(unable to determine file type)" (T.pack . show) $ _language_id =<< mVFS)
     where
-      mfp = uriToFilePath uri
-      uri = msgParams ^. L.textDocument . L.uri
+      mVFS = Map.lookup uri vfs
+      uri = toNormalizedUri $ msgParams ^. L.textDocument . L.uri
 
 -- | Methods that can be handled by plugins.
 -- 'ExtraParams' captures any extra data the IDE passes to the handlers for this method
@@ -452,7 +452,9 @@ class HasTracing (MessageParams m) => PluginMethod (k :: MessageKind) (m :: Meth
   --
   -- But there is no use to split it up into two different methods for now.
   handlesRequest
-    :: SMethod m
+    :: VFS
+    -- ^ The virtual file system, contains the language kind of the file.
+    -> SMethod m
     -- ^ Method type.
     -> MessageParams m
     -- ^ Whether a plugin is enabled might depend on the message parameters
@@ -468,24 +470,24 @@ class HasTracing (MessageParams m) => PluginMethod (k :: MessageKind) (m :: Meth
     -- with the given parameters?
 
   default handlesRequest :: (L.HasTextDocument (MessageParams m) doc, L.HasUri doc Uri)
-                              => SMethod m -> MessageParams m -> PluginDescriptor c -> Config -> HandleRequestResult
-  handlesRequest _ params desc conf =
-    pluginEnabledGlobally desc conf <> pluginSupportsFileType params desc
+                              => VFS -> SMethod m -> MessageParams m -> PluginDescriptor c -> Config -> HandleRequestResult
+  handlesRequest vfs _ params desc conf =
+    pluginEnabledGlobally desc conf <> pluginSupportsFileType vfs params desc
 
 -- | Check if a plugin is enabled, if one of it's specific config's is enabled,
 -- and if it supports the file
 pluginEnabledWithFeature :: (L.HasTextDocument (MessageParams m) doc, L.HasUri doc Uri)
-                              => (PluginConfig -> Bool) -> SMethod m -> MessageParams m
+                              => (PluginConfig -> Bool) -> VFS -> SMethod m -> MessageParams m
                               -> PluginDescriptor c -> Config -> HandleRequestResult
-pluginEnabledWithFeature feature _ msgParams pluginDesc config =
+pluginEnabledWithFeature feature vfs _ msgParams pluginDesc config =
   pluginEnabledGlobally pluginDesc config
   <> pluginFeatureEnabled feature pluginDesc config
-  <> pluginSupportsFileType msgParams pluginDesc
+  <> pluginSupportsFileType vfs msgParams pluginDesc
 
 -- | Check if a plugin is enabled, if one of it's specific configs is enabled,
 -- and if it's the plugin responsible for a resolve request.
-pluginEnabledResolve :: L.HasData_ s (Maybe Value) => (PluginConfig -> Bool) -> p -> s -> PluginDescriptor c -> Config -> HandleRequestResult
-pluginEnabledResolve feature _ msgParams pluginDesc config =
+pluginEnabledResolve :: L.HasData_ s (Maybe Value) => (PluginConfig -> Bool) -> VFS -> p -> s -> PluginDescriptor c -> Config -> HandleRequestResult
+pluginEnabledResolve feature _ _ msgParams pluginDesc config =
     pluginEnabledGlobally pluginDesc config
     <> pluginFeatureEnabled feature pluginDesc config
     <> pluginResolverResponsible msgParams pluginDesc
@@ -498,23 +500,23 @@ instance PluginMethod Request Method_CodeActionResolve where
   handlesRequest = pluginEnabledResolve plcCodeActionsOn
 
 instance PluginMethod Request Method_TextDocumentDefinition where
-  handlesRequest _ msgParams pluginDesc _ = pluginSupportsFileType msgParams pluginDesc
+  handlesRequest vfs _ msgParams pluginDesc _ = pluginSupportsFileType vfs msgParams pluginDesc
 
 instance PluginMethod Request Method_TextDocumentTypeDefinition where
-  handlesRequest _ msgParams pluginDesc _ = pluginSupportsFileType msgParams pluginDesc
+  handlesRequest vfs _ msgParams pluginDesc _ = pluginSupportsFileType vfs msgParams pluginDesc
 
 instance PluginMethod Request Method_TextDocumentImplementation where
-  handlesRequest _ msgParams pluginDesc _ = pluginSupportsFileType msgParams pluginDesc
+  handlesRequest vfs _ msgParams pluginDesc _ = pluginSupportsFileType vfs msgParams pluginDesc
 
 instance PluginMethod Request Method_TextDocumentDocumentHighlight where
-  handlesRequest _ msgParams pluginDesc _ = pluginSupportsFileType msgParams pluginDesc
+  handlesRequest vfs _ msgParams pluginDesc _ = pluginSupportsFileType vfs msgParams pluginDesc
 
 instance PluginMethod Request Method_TextDocumentReferences where
-  handlesRequest _ msgParams pluginDesc _ = pluginSupportsFileType msgParams pluginDesc
+  handlesRequest vfs _ msgParams pluginDesc _ = pluginSupportsFileType vfs msgParams pluginDesc
 
 instance PluginMethod Request Method_WorkspaceSymbol where
   -- Unconditionally enabled, but should it really be?
-  handlesRequest _ _ _ _ = HandlesRequest
+  handlesRequest _ _ _ _ _ = HandlesRequest
 
 instance PluginMethod Request Method_TextDocumentInlayHint where
   handlesRequest = pluginEnabledWithFeature plcInlayHintsOn
@@ -549,22 +551,22 @@ instance PluginMethod Request Method_TextDocumentCompletion where
   handlesRequest = pluginEnabledWithFeature plcCompletionOn
 
 instance PluginMethod Request Method_TextDocumentFormatting where
-  handlesRequest _ msgParams pluginDesc conf =
+  handlesRequest vfs _ msgParams pluginDesc conf =
     (if PluginId (formattingProvider conf) == pid
           || PluginId (cabalFormattingProvider conf) == pid
         then HandlesRequest
         else DoesNotHandleRequest (NotFormattingProvider (formattingProvider conf)) )
-    <> pluginSupportsFileType msgParams pluginDesc
+    <> pluginSupportsFileType vfs msgParams pluginDesc
     where
       pid = pluginId pluginDesc
 
 instance PluginMethod Request Method_TextDocumentRangeFormatting where
-  handlesRequest _ msgParams pluginDesc conf =
+  handlesRequest vfs _ msgParams pluginDesc conf =
     (if PluginId (formattingProvider conf) == pid
           || PluginId (cabalFormattingProvider conf) == pid
         then HandlesRequest
         else DoesNotHandleRequest (NotFormattingProvider (formattingProvider conf)))
-    <> pluginSupportsFileType msgParams pluginDesc
+    <> pluginSupportsFileType vfs msgParams pluginDesc
     where
       pid = pluginId pluginDesc
 
@@ -585,21 +587,21 @@ instance PluginMethod Request Method_TextDocumentFoldingRange where
 
 instance PluginMethod Request Method_CallHierarchyIncomingCalls where
   -- This method has no URI parameter, thus no call to 'pluginResponsible'
-  handlesRequest _ _ pluginDesc conf =
+  handlesRequest _ _ _ pluginDesc conf =
       pluginEnabledGlobally pluginDesc conf
     <> pluginFeatureEnabled plcCallHierarchyOn pluginDesc conf
 
 instance PluginMethod Request Method_CallHierarchyOutgoingCalls where
   -- This method has no URI parameter, thus no call to 'pluginResponsible'
-  handlesRequest _ _ pluginDesc conf =
+  handlesRequest _ _ _ pluginDesc conf =
       pluginEnabledGlobally pluginDesc conf
     <> pluginFeatureEnabled plcCallHierarchyOn pluginDesc conf
 
 instance PluginMethod Request Method_WorkspaceExecuteCommand where
-  handlesRequest _ _ _ _= HandlesRequest
+  handlesRequest _ _ _ _ _ = HandlesRequest
 
 instance PluginMethod Request (Method_CustomMethod m) where
-  handlesRequest _ _ _ _ = HandlesRequest
+  handlesRequest _ _ _ _ _ = HandlesRequest
 
 -- Plugin Notifications
 
@@ -613,19 +615,19 @@ instance PluginMethod Notification Method_TextDocumentDidClose where
 
 instance PluginMethod Notification Method_WorkspaceDidChangeWatchedFiles where
   -- This method has no URI parameter, thus no call to 'pluginResponsible'.
-  handlesRequest _ _ desc conf = pluginEnabledGlobally desc conf
+  handlesRequest _ _ _ desc conf = pluginEnabledGlobally desc conf
 
 instance PluginMethod Notification Method_WorkspaceDidChangeWorkspaceFolders where
   -- This method has no URI parameter, thus no call to 'pluginResponsible'.
-  handlesRequest _ _ desc conf = pluginEnabledGlobally desc conf
+  handlesRequest _ _ _ desc conf = pluginEnabledGlobally desc conf
 
 instance PluginMethod Notification Method_WorkspaceDidChangeConfiguration where
   -- This method has no URI parameter, thus no call to 'pluginResponsible'.
-  handlesRequest _ _ desc conf = pluginEnabledGlobally desc conf
+  handlesRequest _ _ _ desc conf = pluginEnabledGlobally desc conf
 
 instance PluginMethod Notification Method_Initialized where
   -- This method has no URI parameter, thus no call to 'pluginResponsible'.
-  handlesRequest _ _ desc conf = pluginEnabledGlobally desc conf
+  handlesRequest _ _ _ desc conf = pluginEnabledGlobally desc conf
 
 
 -- ---------------------------------------------------------------------
@@ -1054,7 +1056,7 @@ defaultPluginDescriptor plId desc =
     mempty
     mempty
     Nothing
-    [".hs", ".lhs", ".hs-boot"]
+    [J.LanguageKind_Haskell, J.LanguageKind_Custom "literate haskell"]
 
 -- | Set up a plugin descriptor, initialized with default values.
 -- This plugin descriptor is prepared for @.cabal@ files and as such,
@@ -1075,7 +1077,7 @@ defaultCabalPluginDescriptor plId desc =
     mempty
     mempty
     Nothing
-    [".cabal"]
+    [J.LanguageKind_Custom "cabal"]
 
 newtype CommandId = CommandId T.Text
   deriving (Show, Read, Eq, Ord)

plugins/hls-semantic-tokens-plugin/test/SemanticTokensTest.hs

@@ -29,6 +29,7 @@ import           System.Info                        (compilerVersion)
 import           Test.Hls
 import qualified Test.Hls.FileSystem                as FS
 import           Test.Hls.FileSystem                (file, text)
+import qualified Language.LSP.Protocol.Types as J
 
 testDataDir :: FilePath
 testDataDir = "plugins" </> "hls-semantic-tokens-plugin" </> "test" </> "testdata" </> testVersionDir
@@ -90,7 +91,7 @@ docLspSemanticTokensString :: (HasCallStack) => TextDocumentIdentifier -> Sessio
 docLspSemanticTokensString doc = do
   res <- Test.getSemanticTokens doc
   textContent <- documentContents doc
-  let vfs = VirtualFile 0 0 (Rope.fromText textContent)
+  let vfs = VirtualFile 0 0 (Rope.fromText textContent) $ Just J.LanguageKind_Haskell
   case res ^? Language.LSP.Protocol.Types._L of
     Just tokens -> do
       either (error . show) pure $ recoverLspSemanticTokens vfs tokens