Unify argument and parameter

Follow LSP specification, we use parameter.

Author: jian-lin

plugins/hls-signature-help-plugin/src/Ide/Plugin/SignatureHelp.hs

@@ -98,26 +98,26 @@ signatureHelpProvider ideState _pluginId (SignatureHelpParams (TextDocumentIdent
             ( \span hieAst -> do
                 let functionNode = getLeftMostNode hieAst
                 (functionName, functionTypes) <- getNodeNameAndTypes hieKind functionNode
-                argumentNumber <- getArgumentNumber span hieAst
-                Just (functionName, functionTypes, argumentNumber)
+                parameterIndex <- getParameterIndex span hieAst
+                Just (functionName, functionTypes, parameterIndex)
             )
   (docMap, argDocMap) <- runIdeActionE "signatureHelp.docMap" (shakeExtras ideState) $ do
     mResult <- ExceptT $ Right <$> useWithStaleFast GetDocMap nfp
     case mResult of
       Just (DKMap docMap _tyThingMap argDocMap, _positionMapping) -> pure (docMap, argDocMap)
       Nothing -> pure (mempty, mempty)
   case results of
-    [(_functionName, [], _argumentNumber)] -> pure $ InR Null
-    [(functionName, functionTypes, argumentNumber)] ->
-      pure $ InL $ mkSignatureHelp mSignatureHelpContext docMap argDocMap (fromIntegral argumentNumber - 1) functionName functionTypes
+    [(_functionName, [], _parameterIndex)] -> pure $ InR Null
+    [(functionName, functionTypes, parameterIndex)] ->
+      pure $ InL $ mkSignatureHelp mSignatureHelpContext docMap argDocMap (fromIntegral parameterIndex - 1) functionName functionTypes
     _ -> pure $ InR Null
 
 mkSignatureHelp :: Maybe SignatureHelpContext -> DocMap -> ArgDocMap -> UInt -> Name -> [Type] -> SignatureHelp
-mkSignatureHelp mSignatureHelpContext docMap argDocMap argumentNumber functionName functionTypes =
+mkSignatureHelp mSignatureHelpContext docMap argDocMap parameterIndex functionName functionTypes =
   SignatureHelp
-    (mkSignatureInformation docMap argDocMap argumentNumber functionName <$> functionTypes)
+    (mkSignatureInformation docMap argDocMap parameterIndex functionName <$> functionTypes)
     activeSignature
-    (Just $ InL argumentNumber)
+    (Just $ InL parameterIndex)
   where
     activeSignature = case mSignatureHelpContext of
       Just
@@ -130,7 +130,7 @@ mkSignatureHelp mSignatureHelpContext docMap argDocMap argumentNumber functionNa
       _ -> Just 0
 
 mkSignatureInformation :: DocMap -> ArgDocMap -> UInt -> Name -> Type -> SignatureInformation
-mkSignatureInformation docMap argDocMap argumentNumber functionName functionType =
+mkSignatureInformation docMap argDocMap parameterIndex functionName functionType =
   let functionNameLabelPrefix = printOutputableOneLine (ppr functionName) <> " :: "
       mFunctionDoc = case lookupNameEnv docMap functionName of
         Nothing      -> Nothing
@@ -141,19 +141,19 @@ mkSignatureInformation docMap argDocMap argumentNumber functionName functionType
    in SignatureInformation
         (functionNameLabelPrefix <> printOutputableOneLine functionType)
         mFunctionDoc
-        (Just $ mkArguments thisArgDocMap (fromIntegral $ T.length functionNameLabelPrefix) functionType)
-        (Just $ InL argumentNumber)
+        (Just $ mkParameterInformations thisArgDocMap (fromIntegral $ T.length functionNameLabelPrefix) functionType)
+        (Just $ InL parameterIndex)
 
-mkArguments :: IntMap SpanDoc -> UInt -> Type -> [ParameterInformation]
-mkArguments thisArgDocMap offset functionType =
-  [ ParameterInformation (InR range) mArgDoc
-    | (argIndex, range) <- zip [0 ..] (bimap (+ offset) (+ offset) <$> findArgumentRanges functionType),
-      let mArgDoc = case IntMap.lookup argIndex thisArgDocMap of
+mkParameterInformations :: IntMap SpanDoc -> UInt -> Type -> [ParameterInformation]
+mkParameterInformations thisArgDocMap offset functionType =
+  [ ParameterInformation (InR range) mParameterDoc
+    | (parameterIndex, range) <- zip [0 ..] (bimap (+ offset) (+ offset) <$> findParameterRanges functionType),
+      let mParameterDoc = case IntMap.lookup parameterIndex thisArgDocMap of
             Nothing      -> Nothing
             Just spanDoc -> Just $ InR $ mkMarkdownDoc $ removeUris spanDoc
   ]
   where
-    -- we already show uris in the function doc, no need to duplicate them in the arg doc
+    -- we already show uris in the function doc, no need to duplicate them in the parameter doc
     removeUris (SpanDocString docs _uris) = SpanDocString docs emptyUris
     removeUris (SpanDocText docs _uris)   = SpanDocText docs emptyUris
 
@@ -162,16 +162,16 @@ mkArguments thisArgDocMap offset functionType =
 mkMarkdownDoc :: SpanDoc -> MarkupContent
 mkMarkdownDoc = spanDocToMarkdown >>> T.unlines >>> MarkupContent MarkupKind_Markdown
 
-findArgumentRanges :: Type -> [(UInt, UInt)]
-findArgumentRanges functionType =
+findParameterRanges :: Type -> [(UInt, UInt)]
+findParameterRanges functionType =
   let functionTypeString = printOutputableOneLine functionType
       functionTypeStringLength = fromIntegral $ T.length functionTypeString
       splitFunctionTypes = filter notTypeConstraint $ splitFunTysIgnoringForAll functionType
       splitFunctionTypeStrings = printOutputableOneLine . fst <$> splitFunctionTypes
       -- reverse to avoid matching "a" of "forall a" in "forall a. a -> a"
       reversedRanges =
         drop 1 $ -- do not need the range of the result (last) type
-          findArgumentStringRanges
+          findParameterStringRanges
             0
             (T.reverse functionTypeString)
             (T.reverse <$> reverse splitFunctionTypeStrings)
@@ -193,34 +193,34 @@ Some tricky cases are as follows:
   f :: forall a. Maybe a -> forall b. (a, b) -> b
 - '=>' can appear anywhere in a type
   g :: forall a b. Eq a => a -> Num b => b -> b
-- ppr the first argument type of '(a -> b) -> a -> b' is 'a -> b' (no parentheses)
+- ppr the first parameter type of '(a -> b) -> a -> b' is 'a -> b' (no parentheses)
 - 'forall' is not always shown
 
 Alternative method 2: use only unstructured type string
 This method is hard to implement because we need to parse the type string.
 Some tricky cases are as follows:
 - h :: forall a (m :: Type -> Type). Monad m => a -> m a
 -}
-findArgumentStringRanges :: UInt -> Text -> [Text] -> [(UInt, UInt)]
-findArgumentStringRanges _totalPrefixLength _functionTypeString [] = []
-findArgumentStringRanges totalPrefixLength functionTypeString (argumentTypeString : restArgumentTypeStrings) =
-  let (prefix, match) = T.breakOn argumentTypeString functionTypeString
+findParameterStringRanges :: UInt -> Text -> [Text] -> [(UInt, UInt)]
+findParameterStringRanges _totalPrefixLength _functionTypeString [] = []
+findParameterStringRanges totalPrefixLength functionTypeString (parameterTypeString : restParameterTypeStrings) =
+  let (prefix, match) = T.breakOn parameterTypeString functionTypeString
       prefixLength = fromIntegral $ T.length prefix
-      argumentTypeStringLength = fromIntegral $ T.length argumentTypeString
+      parameterTypeStringLength = fromIntegral $ T.length parameterTypeString
       start = totalPrefixLength + prefixLength
-   in (start, start + argumentTypeStringLength)
-        : findArgumentStringRanges
-          (totalPrefixLength + prefixLength + argumentTypeStringLength)
-          (T.drop (fromIntegral argumentTypeStringLength) match)
-          restArgumentTypeStrings
+   in (start, start + parameterTypeStringLength)
+        : findParameterStringRanges
+          (totalPrefixLength + prefixLength + parameterTypeStringLength)
+          (T.drop (fromIntegral parameterTypeStringLength) match)
+          restParameterTypeStrings
 
 -- similar to 'splitFunTys' but
 --   1) the result (last) type is included and
 --   2) toplevel foralls are ignored
 splitFunTysIgnoringForAll :: Type -> [(Type, Maybe FunTyFlag)]
 splitFunTysIgnoringForAll ty = case ty & dropForAlls & splitFunTy_maybe of
-  Just (funTyFlag, _mult, argumentType, resultType) ->
-    (argumentType, Just funTyFlag) : splitFunTysIgnoringForAll resultType
+  Just (funTyFlag, _mult, parameterType, resultType) ->
+    (parameterType, Just funTyFlag) : splitFunTysIgnoringForAll resultType
   Nothing -> [(ty, Nothing)]
 
 notTypeConstraint :: (Type, Maybe FunTyFlag) -> Bool
@@ -287,22 +287,22 @@ getNodeNameAndTypes hieKind hieAst =
 isUse :: IdentifierDetails a -> Bool
 isUse = identInfo >>> S.member Use
 
--- Just 1 means the first argument
-getArgumentNumber :: RealSrcSpan -> HieAST a -> Maybe Integer
-getArgumentNumber span hieAst
+-- Just 1 means the first parameter
+getParameterIndex :: RealSrcSpan -> HieAST a -> Maybe Integer
+getParameterIndex span hieAst
   | nodeHasAnnotation ("HsApp", "HsExpr") hieAst =
       case nodeChildren hieAst of
         [leftChild, _] ->
           if span `isRealSubspanOf` nodeSpan leftChild
             then Nothing
-            else getArgumentNumber span leftChild >>= \argumentNumber -> Just (argumentNumber + 1)
+            else getParameterIndex span leftChild >>= \parameterIndex -> Just (parameterIndex + 1)
         _ -> Nothing -- impossible
   | nodeHasAnnotation ("HsAppType", "HsExpr") hieAst =
       case nodeChildren hieAst of
-        [leftChild, _] -> getArgumentNumber span leftChild
+        [leftChild, _] -> getParameterIndex span leftChild
         _              -> Nothing -- impossible
   | otherwise =
       case nodeChildren hieAst of
         []      -> Just 0 -- the function is found
-        [child] -> getArgumentNumber span child -- ignore irrelevant nodes
+        [child] -> getParameterIndex span child -- ignore irrelevant nodes
         _       -> Nothing

plugins/hls-signature-help-plugin/test/Main.hs

@@ -202,7 +202,7 @@ main =
           [ Nothing,
             Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall abcdefghijklmn. Num abcdefghijklmn => abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn" Nothing (Just [ParameterInformation (InR (50, 64)) Nothing, ParameterInformation (InR (68, 82)) Nothing, ParameterInformation (InR (86, 100)) Nothing, ParameterInformation (InR (104, 118)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> Integer -> Integer -> Integer -> Integer" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (16, 23)) Nothing, ParameterInformation (InR (27, 34)) Nothing, ParameterInformation (InR (38, 45)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
           ],
-        -- TODO fix bug of wrong arg range in the function type string
+        -- TODO fix bug of wrong parameter range in the function type string
         -- https://github.com/haskell/haskell-language-server/pull/4626#discussion_r2261133076
         mkTestExpectFail
           "middle =>"
@@ -233,7 +233,7 @@ main =
               ]
           ),
         mkTest
-          "=> in argument"
+          "=> in parameter"
           [__i|
             f :: Eq a => a -> (Num b => b -> b) -> a
             f = _
@@ -270,7 +270,7 @@ main =
             Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. Maybe a -> forall b. (a, b) -> b" Nothing (Just [ParameterInformation (InR (15, 22)) Nothing, ParameterInformation (InR (36, 42)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Maybe Bool -> forall b. (Bool, b) -> b" Nothing (Just [ParameterInformation (InR (5, 15)) Nothing, ParameterInformation (InR (29, 38)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
             Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. Maybe a -> forall b. (a, b) -> b" Nothing (Just [ParameterInformation (InR (15, 22)) Nothing, ParameterInformation (InR (36, 42)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Maybe Integer -> forall b. (Integer, b) -> b" Nothing (Just [ParameterInformation (InR (5, 18)) Nothing, ParameterInformation (InR (32, 44)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
           ],
-        -- TODO fix bug of wrong arg range in the function type string
+        -- TODO fix bug of wrong parameter range in the function type string
         -- https://github.com/haskell/haskell-language-server/pull/4626#discussion_r2261133076
         mkTestExpectFail
           "RankNTypes(forall in middle), another"
@@ -290,7 +290,7 @@ main =
                 Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall l. l -> forall a. a -> a" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (30, 31)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> forall a. a -> a" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (26, 27)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
               ]
           ),
-        -- TODO fix bug of wrong arg range in the function type string
+        -- TODO fix bug of wrong parameter range in the function type string
         -- https://github.com/haskell/haskell-language-server/pull/4626#discussion_r2261133076
         mkTestExpectFail
           "RankNTypes(forall in middle), again"
@@ -338,13 +338,13 @@ main =
             Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Bool -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "The  `f`  function does something to a bool value") (Just [ParameterInformation (InR (5, 9)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
           ],
         mkTest
-          "function and arguments documentation"
+          "function and parameters documentation"
           [__i|
             -- |Doc for function 'f'.
             f ::
-              -- | The first 'Bool' argument
+              -- | The first 'Bool' parameter
               Bool ->
-              -- | The second 'Int' argument
+              -- | The second 'Int' parameter
               Int ->
               -- | The return value
               Bool
@@ -353,7 +353,7 @@ main =
                 ^ ^
           |]
           [ Nothing,
-            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Bool -> Int -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "Doc for function  `f`") (Just [ParameterInformation (InR (5, 9)) (Just $ InR $ MarkupContent MarkupKind_Markdown "The first  `Bool`  argument"), ParameterInformation (InR (13, 16)) (Just $ InR $ MarkupContent MarkupKind_Markdown "The second  `Int`  argument")]) (Just (InL 0))] (Just 0) (Just (InL 0))
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Bool -> Int -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "Doc for function  `f`") (Just [ParameterInformation (InR (5, 9)) (Just $ InR $ MarkupContent MarkupKind_Markdown "The first  `Bool`  parameter"), ParameterInformation (InR (13, 16)) (Just $ InR $ MarkupContent MarkupKind_Markdown "The second  `Int`  parameter")]) (Just (InL 0))] (Just 0) (Just (InL 0))
           ],
         mkTest
           "imported function with no documentation"
@@ -365,7 +365,7 @@ main =
             Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "even :: forall a. Integral a => a -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "") (Just [ParameterInformation (InR (32, 33)) Nothing]) (Just (InL 0)), SignatureInformation "even :: Integer -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "") (Just [ParameterInformation (InR (8, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
           ],
         mkTest
-          "imported function with argument documentation"
+          "imported function with parameter documentation"
           [__i|
             import Language.Haskell.TH.Lib (mkBytes)
             x = mkBytes _