Extend import suggestions don't work when there's more than one option

[pepeiborra]

Given the following code:

import Data.Map ()

foo = fromList []

ghcide will produce a code action "Add fromList to the import list of Data.Map".

However, the code below will not produce an "Add fromList to the importList" suggestions at all:

import Data.Map ()
import Data.HashMap.Strict()

foo = fromList []

[gdevanla]

I am using hls with emacs. I do see the following CodeLens:

foo = fromList []                                                                                                                                                                                                   
                                                                                                                                                        typecheck: • Variable not in scope: fromList :: [a0] -> t   
data TestSumType = TestSumType1 Int | TestSumType2 Bool                                                                                        • Perhaps you want to add ‘fromList’ to one of these import lists:   
                                                                                                                                           ‘Data.Map’ (/home/devanla/fsf/haskell-scratch/app/test-lsp.hs:21:1-18)   
                                                                                                                                           ‘Data.HashMap.Strict’ (/home/devanla/fsf/haskell-scratch/app/test-lsp.hs:22:1-29) 

And, when I do lsp-execute-code-actions, I see a lot of options listed in the menu I can choose from. I have pasted a few here:

import Data.List.NonEmpty.Extra (fromList)                                                                                                                                                                          
import Data.List.NonEmpty.Extra                                                                                                                                                                                     
import Data.IntMap.Strict (fromList)                                                                                                                                                                                
import Data.IntMap.Strict                                                                                                                                                                                           
import Data.Vector (fromList)                                                                                                                                                                                       
import Data.Vector                                                                                                                                                                                                  
import Data.List.NonEmpty.Compat (fromList)                                                                                                                                                                         
import Data.List.NonEmpty.Compat                                                                                                                                                                                    
import GHC.Exts (IsList(fromList))                                                                                                                                                                                  
import GHC.Exts                                                                                                                                                                                                     
import Data.Map.Lazy (fromList)                                                                                                                                                                                     
import Data.Map.Lazy                                                                                                                                                                                                
import Data.Map (fromList)                                                                                                                                                                                          
import Data.Map                                                                                                                                                                                                     
import Data.Set.Internal (fromList)                                                                                                                                                                                 
import Data.Set.Internal                                                                                                                                                                                            
import Data.Sequence.Internal (fromList)           

Am I checking this incorrectly?

[pepeiborra]

Yes. This ticket is for the "extend import" code action. You are missing the two import declarations in the original repro.

[gdka]

Do you have more context? Files to modify? and how I can test the changes?:)

[pepeiborra]

The relevant code is in Development.IDE.Plugin.CodeAction, function suggestExtendImport.
To test the changes, extend the unit tests.
Good luck!

[gdka]

Do you actually have unit test for this section? I can't find anything in /tst/src/development/ide

[gdevanla]

So, here is the cause of the issue.

When we have one suggestion for 'Add imports', the complier error looks like this:

haskell-scratch-2/learn-lsp/app/testlsp.hs:7:7: error:
    • Variable not in scope: fromList :: [a0] -> t
    • Perhaps you want to add ‘fromList’ to the import list
      in the import of ‘Data.Map’ (app/testlsp.hs:4:1-18).
  |
7 | foo = fromList []
  |       ^^^^^^^^

The diagnostics string Perhaps you want to add ‘fromList’ to the import list in the import of ‘Data.Map’ (app/testlsp.hs:4:1-18). is captured by the the RegEx here: https://github.com/haskell/ghcide/blob/a345e11aa3f811240a8961fe08806c3b7862d12e/src/Development/IDE/Plugin/CodeAction.hs#L649.

But, when you have multiple suggestions, for code like this:

import Data.Map ()
import Data.HashMap.Strict()

then the `diagnostics from the compiler is

    • Perhaps you want to add ‘fromList’ to one of these import lists:
        ‘Data.Map’ (app/testlsp.hs:7:1-18)
        ‘Data.HashMap.Strict’ (app/testlsp.hs:8:1-29)

which does not match the current regex.

I have a fix for this here: haskell/ghcide#913