WIP: Generate completions from local declarations

Author: fwcd

src/Curry/LanguageServer/Features/Completion.hs

@@ -22,7 +22,7 @@ import Curry.LanguageServer.Logging
 import Curry.LanguageServer.Utils.Conversions (ppToText)
 import Curry.LanguageServer.Utils.General (rmDupsOn, wordAtPos, guarded)
 import Curry.LanguageServer.Utils.Env (valueInfoType, typeInfoKind)
-import Curry.LanguageServer.Utils.Syntax (elementAt, elementContains, HasExpressions (..), HasDeclarations (..))
+import Curry.LanguageServer.Utils.Syntax (elementAt, elementsAt, elementContains, HasExpressions (..), HasDeclarations (..))
 import qualified Data.Map as M
 import Data.Maybe (maybeToList, isJust)
 import qualified Data.Text as T
@@ -48,7 +48,7 @@ fetchCompletions store entry content pos = do
                    $  (takeIfNonEmpty $ expressionCompletions ast' pos)
                   <|> (takeIfNonEmpty $ declarationCompletions ast' pos)
                   <|> (takeIfNonEmpty $ importCompletions store ast' pos)
-                  <|> (takeIfNonEmpty $ generalCompletions env query)
+                  <|> (takeIfNonEmpty $ generalCompletions env ast' pos query)
 
     logs INFO $ "fetchCompletions: Found " ++ show (length completions) ++ " completions with query '" ++ show query
     return completions
@@ -78,8 +78,14 @@ importCompletions store ast pos = do
 moduleCompletions :: IndexStore -> [J.CompletionItem]
 moduleCompletions store = moduleToCompletion <$> ((maybeToList . moduleAST) =<< snd <$> storedModules store)
 
-generalCompletions :: Maybe CE.CompilerEnv -> T.Text -> [J.CompletionItem]
-generalCompletions env query = rmDupsOn (^. J.label) $ filter (matchesQuery query) $ valueCompletions env ++ typeCompletions env ++ keywordCompletions
+generalCompletions :: Maybe CE.CompilerEnv -> Maybe (CS.Module a) -> J.Position -> T.Text -> [J.CompletionItem]
+generalCompletions env ast pos query = rmDupsOn (^. J.label) $ filter (matchesQuery query)
+                                                             $ valueCompletions env ++ localCompletions ast pos
+                                                                                    ++ typeCompletions env
+                                                                                    ++ keywordCompletions
+
+localCompletions :: Maybe (CS.Module a) -> J.Position -> [J.CompletionItem]
+localCompletions ast pos = declarationToCompletions =<< (elementsAt pos $ declarations =<< maybeToList ast)
 
 valueCompletions :: Maybe CE.CompilerEnv -> [J.CompletionItem]
 valueCompletions env = valueBindingToCompletion <$> ((CT.allBindings . CE.valueEnv) =<< maybeToList env)
@@ -108,6 +114,15 @@ moduleToCompletion (CS.Module _ _ _ mid _ _ _) = item
           doc = Nothing
           item = completionFrom name ciKind detail doc
 
+-- | Converts a declaration to a completion item.
+declarationToCompletions :: CS.Decl a -> [J.CompletionItem]
+declarationToCompletions decl = (\n -> completionFrom n J.CiVariable Nothing Nothing) <$> names
+    where names = T.pack <$> CI.idName <$> case decl of
+            CS.FunctionDecl _ _ ident _ -> [ident]
+            CS.ExternalDecl _ vars      -> (\(CS.Var _ ident) -> ident) <$> vars
+            CS.FreeDecl _ vars          -> (\(CS.Var _ ident) -> ident) <$> vars
+            _                           -> []
+
 -- TODO: Reimplement the following functions in terms of bindingToQualSymbols and a conversion from SymbolInformation to CompletionItem
 
 -- | Converts a Curry value binding to a completion item.

src/Curry/LanguageServer/Utils/Syntax.hs

@@ -8,6 +8,7 @@ module Curry.LanguageServer.Utils.Syntax (
     HasIdentifier (..),
     ModuleAST,
     elementAt,
+    elementsAt,
     elementContains,
     moduleIdentifier
 ) where
@@ -24,9 +25,13 @@ import qualified Language.Haskell.LSP.Types as J
 
 type ModuleAST = CS.Module CT.PredType
 
--- | Fetches the element at the given position.
+-- | Fetches the innermost element at the given position.
 elementAt :: CSPI.HasSpanInfo e => J.Position -> [e] -> Maybe e
-elementAt pos = lastSafe . filter (elementContains pos)
+elementAt pos = lastSafe . elementsAt pos
+
+-- | Fetches the elements at the given position.
+elementsAt :: CSPI.HasSpanInfo e => J.Position -> [e] -> [e]
+elementsAt pos = filter (elementContains pos)
 
 -- | Tests whether the given element in the AST contains the given position.
 elementContains :: CSPI.HasSpanInfo e => J.Position -> e -> Bool

test/resources/Test.curry

@@ -1,5 +1,5 @@
 module Test where
 
 f x = case x of
-    _ -> 3
+    _ -> let y = 4 in f y
     _ -> 4