Merge branch 'master' into wip/2.9.0.0

michaelpj · web-flow · commit ed6206ec0e57 · 2024-06-17T10:52:46.000+01:00
diff --git a/docs/support/ghc-version-support.md b/docs/support/ghc-version-support.md
@@ -76,26 +76,62 @@ Major versions of GHC which are not supported by HLS on master are extremely unl
 
 ## GHC version deprecation policy
 
-### Major versions
+### Base policy
 
-A major GHC version is a "legacy" version if it is 3 or more major versions behind the latest GHC version that is
+This is the static part of the policy that can be checked by a machine.
 
-1. Fully supported by HLS
-2. Used in the a Stackage LTS
+#### Major versions
 
-For example, if 9.2 is the latest major version fully supported by HLS and used in a Stackage LTS, then the 8.8 major version and older will be legacy.
+HLS will support major versions of GHC until they are older than _both_
 
-HLS will support all non-legacy major versions of GHC.
+1. The major version of GHC used in the current Stackage LTS; and
+2. The major version of GHC recommended by GHCup
 
-### Minor versions
+For example, if 
+
+1. Stackage LTS uses GHC 9.2; and
+2. GHCUp recommends GHC 9.4
+
+then HLS will support back to GHC 9.2.
+
+#### Minor versions
 
 For the latest supported major GHC version we will support at least 2 minor versions.
 
 For the rest of the supported major GHC versions, we will support at least the latest minor version in Stackage LTS (so 1 minor version).
 
-### Announcements
+### Extended policy
+
+This is the part of the policy that needs evaluation by a human and possibly followed
+by a discussion.
+
+#### Ecosystem factors
+
+To establish and apply the policy we take the following ecosystem factors into account:
+
+- Support status of HLS
+- The most recent [stackage](https://www.stackage.org/) LTS snapshot
+- The GHC version recommended by GHCup
+- The GHC versions used in the most popular [linux distributions](https://repology.org/project/ghc/versions)
+- The reliability of different ghc versions on the major operating systems (Linux, Windows, MacOS)
+- The [Haskell Survey results](https://taylor.fausak.me/2022/11/18/haskell-survey-results/#s2q4)
 
-We will warn users about the upcoming deprecation of a GHC version in the notes of the release *prior* to the deprecation itself.
+### Supporting a GHC version beyond normal deprecation time
+
+In cases where the base policy demands a deprecation, but ecosystem factors
+suggest that it's still widely used (e.g. last [Haskell Survey results](https://taylor.fausak.me/2022/11/18/haskell-survey-results/#s2q4)),
+the deprecation should be suspended for the next release and the situation be re-evaluated for the release after that.
+
+When we decide to keep on an old version, we should track it as follows:
+
+1. open a ticket on HLS issue tracker wrt discussing to deprecate said GHC version
+    - explain the reason the GHC version wasn't deprecated (context)
+    - explain the maintenance burden it causes (reason)
+    - evaluate whether it impacts the next HLS release (impact)
+2. discuss whether ecosystem factors changed
+    - e.g. if Haskell Survey results show that 25% or more of users are still on the GHC version in question, then dropping should be avoided
+3. if dropping is still undesired, but maintenance burden is also high, then set out a call-for-help and contact HF for additional funding to support this GHC version
+4. if no help or funding was received within 2 releases (say, e.g. 3-6 months), then drop the version regardless
 
 ### Why deprecate older versions of GHC?
 
@@ -108,12 +144,3 @@ We will warn users about the upcoming deprecation of a GHC version in the notes
 So we need to limit the GHC support to save maintainers and contributors time and reduce CI resources.
 
 At same time we aim to support the right balance of GHC versions to minimize the impact on users.
-
-### What factors do we take into account when deprecating a version?
-
-To establish and apply the policy we take into account:
-
-- Completeness: support includes all plugins and features
-- The most recent [stackage](https://www.stackage.org/) LTS snapshot
-- The GHC versions used in the most popular [linux distributions](https://repology.org/project/ghc/versions)
-- The reliability of different ghc versions on the major operating systems (Linux, Windows, MacOS)
diff --git a/haskell-language-server.cabal b/haskell-language-server.cabal
@@ -231,6 +231,7 @@ library hls-cabal-plugin
   exposed-modules:
     Ide.Plugin.Cabal
     Ide.Plugin.Cabal.Diagnostics
+    Ide.Plugin.Cabal.Completion.CabalFields
     Ide.Plugin.Cabal.Completion.Completer.FilePath
     Ide.Plugin.Cabal.Completion.Completer.Module
     Ide.Plugin.Cabal.Completion.Completer.Paths
diff --git a/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal.hs b/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal.hs
@@ -18,6 +18,7 @@ import           Data.Hashable
 import           Data.HashMap.Strict                         (HashMap)
 import qualified Data.HashMap.Strict                         as HashMap
 import qualified Data.List.NonEmpty                          as NE
+import qualified Data.Maybe                                  as Maybe
 import qualified Data.Text.Encoding                          as Encoding
 import           Data.Typeable
 import           Development.IDE                             as D
@@ -32,7 +33,8 @@ import qualified Distribution.Parsec.Position                as Syntax
 import           GHC.Generics
 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           (ParseCabalFields (..),
+import           Ide.Plugin.Cabal.Completion.Types           (ParseCabalCommonSections (ParseCabalCommonSections),
+                                                              ParseCabalFields (..),
                                                               ParseCabalFile (..))
 import qualified Ide.Plugin.Cabal.Completion.Types           as Types
 import qualified Ide.Plugin.Cabal.Diagnostics                as Diagnostics
@@ -170,6 +172,14 @@ cabalRules recorder plId = do
           Right fields ->
             pure ([], Just fields)
 
+  define (cmapWithPrio LogShake recorder) $ \ParseCabalCommonSections file -> do
+    fields <- use_ ParseCabalFields file
+    let commonSections = Maybe.mapMaybe (\case
+          commonSection@(Syntax.Section (Syntax.Name _ "common") _ _) -> Just commonSection
+          _ -> Nothing)
+          fields
+    pure ([], Just commonSections)
+
   define (cmapWithPrio LogShake recorder) $ \ParseCabalFile file -> do
     config <- getPluginConfigAction plId
     if not (plcGlobalOn config && plcDiagnosticsOn config)
@@ -342,6 +352,9 @@ completion recorder ide _ complParams = do
                 -- The `withStale` option is very important here, since we often call this rule with invalid cabal files.
                 mGPD <- runIdeAction "cabal-plugin.modulesCompleter.gpd" (shakeExtras ide) $ useWithStaleFast ParseCabalFile $ toNormalizedFilePath fp
                 pure $ fmap fst mGPD
+              , getCabalCommonSections = do
+                mSections <- runIdeAction "cabal-plugin.modulesCompleter.commonsections" (shakeExtras ide) $ useWithStaleFast ParseCabalCommonSections $ toNormalizedFilePath fp
+                pure $ fmap fst mSections
               , cabalPrefixInfo = prefInfo
               , stanzaName =
                 case fst ctx of
diff --git a/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/CabalFields.hs b/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/CabalFields.hs
@@ -0,0 +1,68 @@
+module Ide.Plugin.Cabal.Completion.CabalFields (findStanzaForColumn, findFieldSection, getOptionalSectionName, getAnnotation, getFieldName) where
+
+import           Data.List.NonEmpty                (NonEmpty)
+import qualified Data.List.NonEmpty                as NE
+import qualified Data.Text                         as T
+import qualified Data.Text.Encoding                as T
+import qualified Distribution.Fields               as Syntax
+import qualified Distribution.Parsec.Position      as Syntax
+import           Ide.Plugin.Cabal.Completion.Types
+
+-- ----------------------------------------------------------------
+-- Cabal-syntax utilities I don't really want to write myself
+-- ----------------------------------------------------------------
+
+-- | Determine the context of a cursor position within a stack of stanza contexts
+--
+-- If the cursor is indented more than one of the stanzas in the stack
+-- the respective stanza is returned if this is never the case, the toplevel stanza
+-- in the stack is returned.
+findStanzaForColumn :: Int -> NonEmpty (Int, StanzaContext) -> (StanzaContext, FieldContext)
+findStanzaForColumn col ctx = case NE.uncons ctx of
+    ((_, stanza), Nothing) -> (stanza, None)
+    ((indentation, stanza), Just res)
+        | col < indentation -> findStanzaForColumn col res
+        | otherwise -> (stanza, None)
+
+-- | Determine the field the cursor is currently a part of.
+--
+-- The result is said field and its starting position
+-- or Nothing if the passed list of fields is empty.
+
+-- This only looks at the row of the cursor and not at the cursor's
+-- position within the row.
+--
+-- TODO: we do not handle braces correctly. Add more tests!
+findFieldSection :: Syntax.Position -> [Syntax.Field Syntax.Position] -> Maybe (Syntax.Field Syntax.Position)
+findFieldSection _cursor [] = Nothing
+findFieldSection _cursor [x] =
+  -- Last field. We decide later, whether we are starting
+  -- a new section.
+  Just x
+findFieldSection cursor (x:y:ys)
+    | Syntax.positionRow (getAnnotation x) <= cursorLine && cursorLine < Syntax.positionRow (getAnnotation y)
+    = Just x
+    | otherwise = findFieldSection cursor (y:ys)
+  where
+    cursorLine = Syntax.positionRow cursor
+
+type FieldName = T.Text
+
+getAnnotation :: Syntax.Field ann -> ann
+getAnnotation (Syntax.Field (Syntax.Name ann _) _)     = ann
+getAnnotation (Syntax.Section (Syntax.Name ann _) _ _) = ann
+
+getFieldName :: Syntax.Field ann -> FieldName
+getFieldName (Syntax.Field (Syntax.Name _ fn) _)     = T.decodeUtf8 fn
+getFieldName (Syntax.Section (Syntax.Name _ fn) _ _) = T.decodeUtf8 fn
+
+-- | Returns the name of a section if it has a name.
+--
+-- This assumes that the given section args belong to named stanza
+-- in which case the stanza name is returned.
+getOptionalSectionName :: [Syntax.SectionArg ann] -> Maybe T.Text
+getOptionalSectionName [] = Nothing
+getOptionalSectionName (x:xs) = case x of
+    Syntax.SecArgName _ name -> Just (T.decodeUtf8 name)
+    _                        -> getOptionalSectionName xs
+
diff --git a/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Completer/Simple.hs b/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Completer/Simple.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE LambdaCase        #-}
 {-# LANGUAGE OverloadedStrings #-}
 
 module Ide.Plugin.Cabal.Completion.Completer.Simple where
@@ -7,11 +8,14 @@ import           Data.Function                               ((&))
 import qualified Data.List                                   as List
 import           Data.Map                                    (Map)
 import qualified Data.Map                                    as Map
-import           Data.Maybe                                  (fromMaybe)
+import           Data.Maybe                                  (fromMaybe,
+                                                              mapMaybe)
 import           Data.Ord                                    (Down (Down))
 import qualified Data.Text                                   as T
+import qualified Distribution.Fields                         as Syntax
 import           Ide.Logger                                  (Priority (..),
                                                               logWith)
+import           Ide.Plugin.Cabal.Completion.CabalFields
 import           Ide.Plugin.Cabal.Completion.Completer.Types
 import           Ide.Plugin.Cabal.Completion.Types           (CabalPrefixInfo (..),
                                                               Log)
@@ -41,6 +45,22 @@ constantCompleter completions _ cData = do
       range = completionRange prefInfo
   pure $ map (mkSimpleCompletionItem range . Fuzzy.original) scored
 
+-- | Completer to be used for import fields.
+--
+-- TODO: Does not exclude imports, defined after the current cursor position
+-- which are not allowed according to the cabal specification
+importCompleter :: Completer
+importCompleter l cData = do
+  cabalCommonsM <- getCabalCommonSections cData
+  case cabalCommonsM of
+    Just cabalCommons -> do
+        let commonNames = mapMaybe (\case
+              Syntax.Section (Syntax.Name _ "common") commonNames _ -> getOptionalSectionName commonNames
+              _ -> Nothing)
+              cabalCommons
+        constantCompleter commonNames l cData
+    Nothing -> noopCompleter l cData
+
 -- | Completer to be used for the field @name:@ value.
 --
 -- This is almost always the name of the cabal file. However,
diff --git a/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Completer/Types.hs b/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Completer/Types.hs
@@ -3,7 +3,9 @@
 module Ide.Plugin.Cabal.Completion.Completer.Types where
 
 import           Development.IDE                   as D
+import qualified Distribution.Fields               as Syntax
 import           Distribution.PackageDescription   (GenericPackageDescription)
+import qualified Distribution.Parsec.Position      as Syntax
 import           Ide.Plugin.Cabal.Completion.Types
 import           Language.LSP.Protocol.Types       (CompletionItem)
 
@@ -16,9 +18,11 @@ data CompleterData = CompleterData
   { -- | Access to the latest available generic package description for the handled cabal file,
     -- relevant for some completion actions which require the file's meta information
     -- such as the module completers which require access to source directories
-    getLatestGPD    :: IO (Maybe GenericPackageDescription),
+    getLatestGPD           :: IO (Maybe GenericPackageDescription),
+    -- | Access to the entries of the handled cabal file as parsed by ParseCabalFields
+    getCabalCommonSections :: IO (Maybe [Syntax.Field Syntax.Position]),
     -- | Prefix info to be used for constructing completion items
-    cabalPrefixInfo :: CabalPrefixInfo,
+    cabalPrefixInfo        :: CabalPrefixInfo,
     -- | The name of the stanza in which the completer is applied
-    stanzaName      :: Maybe StanzaName
+    stanzaName             :: Maybe StanzaName
   }
diff --git a/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Completions.hs b/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Completions.hs
@@ -8,11 +8,11 @@ import           Data.List.NonEmpty                            (NonEmpty)
 import qualified Data.List.NonEmpty                            as NE
 import qualified Data.Map                                      as Map
 import qualified Data.Text                                     as T
-import qualified Data.Text.Encoding                            as T
 import           Development.IDE                               as D
 import qualified Development.IDE.Plugin.Completions.Types      as Ghcide
 import qualified Distribution.Fields                           as Syntax
 import qualified Distribution.Parsec.Position                  as Syntax
+import           Ide.Plugin.Cabal.Completion.CabalFields
 import           Ide.Plugin.Cabal.Completion.Completer.Simple
 import           Ide.Plugin.Cabal.Completion.Completer.Snippet
 import           Ide.Plugin.Cabal.Completion.Completer.Types   (Completer)
@@ -177,57 +177,3 @@ classifyFieldContext ctx cursor field
 
     cursorColumn = Syntax.positionCol cursor
     fieldColumn = Syntax.positionCol (getAnnotation field)
-
--- ----------------------------------------------------------------
--- Cabal-syntax utilities I don't really want to write myself
--- ----------------------------------------------------------------
-
--- | Determine the context of a cursor position within a stack of stanza contexts
---
--- If the cursor is indented more than one of the stanzas in the stack
--- the respective stanza is returned if this is never the case, the toplevel stanza
--- in the stack is returned.
-findStanzaForColumn :: Int -> NonEmpty (Int, StanzaContext) -> (StanzaContext, FieldContext)
-findStanzaForColumn col ctx = case NE.uncons ctx of
-    ((_, stanza), Nothing) -> (stanza, None)
-    ((indentation, stanza), Just res)
-        | col < indentation -> findStanzaForColumn col res
-        | otherwise -> (stanza, None)
-
--- | Determine the field the cursor is currently a part of.
---
--- The result is said field and its starting position
--- or Nothing if the passed list of fields is empty.
-
--- This only looks at the row of the cursor and not at the cursor's
--- position within the row.
---
--- TODO: we do not handle braces correctly. Add more tests!
-findFieldSection :: Syntax.Position -> [Syntax.Field Syntax.Position] -> Maybe (Syntax.Field Syntax.Position)
-findFieldSection _cursor [] = Nothing
-findFieldSection _cursor [x] =
-  -- Last field. We decide later, whether we are starting
-  -- a new section.
-  Just x
-findFieldSection cursor (x:y:ys)
-    | Syntax.positionRow (getAnnotation x) <= cursorLine && cursorLine < Syntax.positionRow (getAnnotation y)
-    = Just x
-    | otherwise = findFieldSection cursor (y:ys)
-  where
-    cursorLine = Syntax.positionRow cursor
-
-type FieldName = T.Text
-
-getAnnotation :: Syntax.Field ann -> ann
-getAnnotation (Syntax.Field (Syntax.Name ann _) _)     = ann
-getAnnotation (Syntax.Section (Syntax.Name ann _) _ _) = ann
-
-getFieldName :: Syntax.Field ann -> FieldName
-getFieldName (Syntax.Field (Syntax.Name _ fn) _)     = T.decodeUtf8 fn
-getFieldName (Syntax.Section (Syntax.Name _ fn) _ _) = T.decodeUtf8 fn
-
-getOptionalSectionName :: [Syntax.SectionArg ann] -> Maybe T.Text
-getOptionalSectionName [] = Nothing
-getOptionalSectionName (x:xs) = case x of
-    Syntax.SecArgName _ name -> Just (T.decodeUtf8 name)
-    _                        -> getOptionalSectionName xs
diff --git a/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Data.hs b/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Data.hs
@@ -162,7 +162,8 @@ flagFields =
 libExecTestBenchCommons :: Map KeyWordName Completer
 libExecTestBenchCommons =
   Map.fromList
-    [ ("build-depends:", noopCompleter),
+    [ ("import:", importCompleter),
+      ("build-depends:", noopCompleter),
       ("hs-source-dirs:", directoryCompleter),
       ("default-extensions:", noopCompleter),
       ("other-extensions:", noopCompleter),
diff --git a/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Types.hs b/plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal/Completion/Types.hs
@@ -59,6 +59,15 @@ instance Hashable ParseCabalFields
 
 instance NFData ParseCabalFields
 
+type instance RuleResult ParseCabalCommonSections = [Syntax.Field Syntax.Position]
+
+data ParseCabalCommonSections = ParseCabalCommonSections
+  deriving (Eq, Show, Typeable, Generic)
+
+instance Hashable ParseCabalCommonSections
+
+instance NFData ParseCabalCommonSections
+
 -- | The context a cursor can be in within a cabal file.
 --
 --  We can be in stanzas or the top level,
diff --git a/plugins/hls-cabal-plugin/test/Completer.hs b/plugins/hls-cabal-plugin/test/Completer.hs
