Use parsed context for import completions

- use Context based on ParsedModule
- add regression test for fixed multiline import

Author: xsebek

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

@@ -65,7 +65,6 @@ import           Language.LSP.Types.Capabilities
 import qualified Language.LSP.VFS                         as VFS
 import           Text.Fuzzy.Parallel                      (Scored (score),
                                                            original)
-import Safe (fromJustNote)
 
 -- Chunk size used for parallelizing fuzzy matching
 chunkSize :: Int
@@ -588,10 +587,7 @@ getCompletions plId ideOpts CC {allModNamesAsNS, anyQualCompls, unqualCompls, qu
           $ (if T.null enteredQual then id else mapMaybe (T.stripPrefix enteredQual))
             allModNamesAsNS
 
-      filtCompls = Fuzzy.filter chunkSize maxC prefixText ctxCompls (label . snd)
-        where
-
-          mcc = case maybe_parsed of
+      maybeContext = case maybe_parsed of
             Nothing -> Nothing
             Just (pm, pmapping) ->
               let PositionMapping pDelta = pmapping
@@ -600,8 +596,10 @@ getCompletions plId ideOpts CC {allModNamesAsNS, anyQualCompls, unqualCompls, qu
                   hpos = upperRange position'
               in getCContext lpos pm <|> getCContext hpos pm
 
+      filtCompls = Fuzzy.filter chunkSize maxC prefixText ctxCompls (label . snd)
+        where
           -- completions specific to the current context
-          ctxCompls' = case mcc of
+          ctxCompls' = case maybeContext of
                         Nothing           -> compls
                         Just TypeContext  -> filter ( isTypeCompl . snd) compls
                         Just ValueContext -> filter (not . isTypeCompl . snd) compls
@@ -637,8 +635,15 @@ getCompletions plId ideOpts CC {allModNamesAsNS, anyQualCompls, unqualCompls, qu
         , enteredQual `T.isPrefixOf` original label
         ]
 
-      getModuleName line = let ws = filter (/= "qualified") (T.words line)
-                            in if List.length ws >= 2 then Just (ws !! 1) else Nothing
+      moduleImportListCompletions :: String -> [Scored CompletionItem]
+      moduleImportListCompletions moduleNameS =
+        let moduleName = T.pack moduleNameS
+            funcs = HM.lookupDefault HashSet.empty moduleName moduleExportsMap
+            funs = map (show . name) $ HashSet.toList funcs
+        in filterModuleExports moduleName $ map T.pack funs
+
+      -- manually parse in case we don't have completion context ("import [qualified ]ModuleName")
+      getModuleName line = filter (/= "qualified") (T.words line) !? 1
       filtImportCompls = filtListWith (mkImportCompl enteredQual) importableModules
       filterModuleExports moduleName = filtListWith $ mkModuleFunctionImport moduleName
       filtKeywordCompls
@@ -647,20 +652,32 @@ getCompletions plId ideOpts CC {allModNamesAsNS, anyQualCompls, unqualCompls, qu
 
   if
     -- TODO: handle multiline imports
+    | Just (ImportListContext moduleName) <- maybeContext
+    -> pure $ moduleImportListCompletions moduleName
+
+    | Just (ImportHidingContext moduleName) <- maybeContext
+    -> pure $ moduleImportListCompletions moduleName
+
+    -- TODO: Is manual parsing ever needed or is context always present for module?
+    -- If possible only keep the above.
     | "import " `T.isPrefixOf` fullLine
-      && isJust (getModuleName fullLine)
-      && "(" `T.isInfixOf` fullLine
-    -> do
-      let moduleName = fromJustNote "NEVER FAILS: module name checked above" $ getModuleName fullLine
-          funcs = HM.lookupDefault HashSet.empty moduleName moduleExportsMap
-          funs = map (show . name) $ HashSet.toList funcs
-      return $ filterModuleExports moduleName $ map T.pack funs
+    , Just moduleName <- getModuleName fullLine
+    , "(" `T.isInfixOf` fullLine
+    -> pure $ moduleImportListCompletions $ T.unpack moduleName
+
+    | Just (ImportContext _moduleName) <- maybeContext
+    -> return filtImportCompls
+
+    -- TODO: Can we avoid this manual parsing?
+    -- If possible only keep the above.
     | "import " `T.isPrefixOf` fullLine
     -> return filtImportCompls
+
     -- we leave this condition here to avoid duplications and return empty list
     -- since HLS implements these completions (#haskell-language-server/pull/662)
     | "{-# " `T.isPrefixOf` fullLine
     -> return []
+
     | otherwise -> do
         -- assumes that nubOrdBy is stable
         let uniqueFiltCompls = nubOrdBy (uniqueCompl `on` snd . Fuzzy.original) filtCompls

ghcide/test/exe/Main.hs

@@ -5206,7 +5206,17 @@ otherCompletionTests = [
             ]
         _ <- waitForDiagnostics
         compls <- getCompletions  doc (Position 3 13)
-        liftIO $ length compls @?= maxCompletions def
+        liftIO $ length compls @?= maxCompletions def,
+
+    completionNoCommandTest
+        "multiline import"
+        [ "{-# LANGUAGE NoImplicitPrelude #-}"
+        , "module A where"
+        , "import Control.Monad"
+        , "    (fore)"
+        ]
+        (Position 3 9)
+        "forever"
   ]
 
 packageCompletionTests :: [TestTree]