#333 Update line numbers for loclist items when current sign_id values are set

autoload/ale/engine.vim

@@ -254,14 +254,15 @@ function! s:HandleExit(job) abort
 endfunction
 
 function! ale#engine#SetResults(buffer, loclist) abort
-    if g:ale_set_quickfix || g:ale_set_loclist
-        call ale#list#SetLists(a:buffer, a:loclist)
-    endif
-
+    " Set signs first. This could potentially fix some line numbers.
     if g:ale_set_signs
         call ale#sign#SetSigns(a:buffer, a:loclist)
     endif
 
+    if g:ale_set_quickfix || g:ale_set_loclist
+        call ale#list#SetLists(a:buffer, a:loclist)
+    endif
+
     if exists('*ale#statusline#Update')
         " Don't load/run if not already loaded.
         call ale#statusline#Update(a:buffer, a:loclist)

autoload/ale/sign.vim

@@ -37,14 +37,17 @@ function! ale#sign#ParseSigns(line_list) abort
     " línea=12 id=1000001 nombre=ALEWarningSign
     " riga=1 id=1000001, nome=ALEWarningSign
     let l:pattern = '^.*=\(\d\+\).*=\(\d\+\).*=ALE\(Error\|Warning\|Dummy\)Sign'
-
     let l:result = []
 
     for l:line in a:line_list
         let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) > 0
-            call add(l:result, [str2nr(l:match[1]), str2nr(l:match[2])])
+            call add(l:result, [
+            \   str2nr(l:match[1]),
+            \   str2nr(l:match[2]),
+            \   'ALE' . l:match[3] . 'Sign',
+            \])
         endif
     endfor
 
@@ -58,25 +61,25 @@ function! ale#sign#FindCurrentSigns(buffer) abort
 endfunction
 
 " Given a loclist, group the List into with one List per line.
-function! s:GroupSigns(loclist) abort
-    let l:signlist = []
+function! s:GroupLoclistItems(loclist) abort
+    let l:grouped_items = []
     let l:last_lnum = -1
 
     for l:obj in a:loclist
         " Create a new sub-List when we hit a new line.
         if l:obj.lnum != l:last_lnum
-            call add(l:signlist, [])
+            call add(l:grouped_items, [])
         endif
 
-        call add(l:signlist[-1], l:obj)
+        call add(l:grouped_items[-1], l:obj)
         let l:last_lnum = l:obj.lnum
     endfor
 
-    return l:signlist
+    return l:grouped_items
 endfunction
 
 function! s:IsDummySignSet(current_id_list) abort
-    for [l:line, l:id] in a:current_id_list
+    for [l:line, l:id, l:name] in a:current_id_list
         if l:id == g:ale_sign_offset
             return 1
         endif
@@ -89,37 +92,27 @@ function! s:IsDummySignSet(current_id_list) abort
     return 0
 endfunction
 
-" This function will set the signs which show up on the left.
-function! ale#sign#SetSigns(buffer, loclist) abort
-    let l:signlist = s:GroupSigns(a:loclist)
-
-    " Find the current markers
-    let l:current_id_list = ale#sign#FindCurrentSigns(a:buffer)
-    " Check if we set the dummy sign already.
-    let l:dummy_sign_set = s:IsDummySignSet(l:current_id_list)
+function! s:SetDummySignIfNeeded(buffer, current_sign_list, new_signs) abort
+    let l:is_dummy_sign_set = s:IsDummySignSet(a:current_sign_list)
 
     " If we haven't already set a dummy sign, and we have some previous signs
     " or always want a dummy sign, then set one, to keep the sign column open.
-    if !l:dummy_sign_set && (len(l:signlist) > 0 || g:ale_sign_column_always)
+    if !l:is_dummy_sign_set && (a:new_signs || g:ale_sign_column_always)
         execute 'sign place ' .  g:ale_sign_offset
         \   . ' line=1 name=ALEDummySign buffer='
         \   . a:buffer
 
-        let l:dummy_sign_set = 1
+        let l:is_dummy_sign_set = 1
     endif
 
-    " Now remove the previous signs. The dummy will hold the column open
-    " while we add the new signs, if we had signs before.
-    for [l:line, l:current_id] in l:current_id_list
-        if l:current_id != g:ale_sign_offset
-            exec 'sign unplace ' . l:current_id . ' buffer=' . a:buffer
-        endif
-    endfor
+    return l:is_dummy_sign_set
+endfunction
 
+function! s:PlaceNewSigns(buffer, grouped_items) abort
     " Add the new signs,
-    for l:index in range(0, len(l:signlist) - 1)
+    for l:index in range(0, len(a:grouped_items) - 1)
         let l:sign_id = l:index + g:ale_sign_offset + 1
-        let l:sublist = l:signlist[l:index]
+        let l:sublist = a:grouped_items[l:index]
         let l:type = !empty(filter(copy(l:sublist), 'v:val.type ==# ''E'''))
         \   ? 'ALEErrorSign'
         \   : 'ALEWarningSign'
@@ -130,18 +123,81 @@ function! ale#sign#SetSigns(buffer, loclist) abort
             let l:obj.sign_id = l:sign_id
         endfor
 
-        let l:sign_line = 'sign place ' . l:sign_id
-            \. ' line=' . l:sublist[0].lnum
-            \. ' name=' . l:type
-            \. ' buffer=' . a:buffer
-
-        exec l:sign_line
+        execute 'sign place ' . l:sign_id
+        \   . ' line=' . l:sublist[0].lnum
+        \   . ' name=' . l:type
+        \   . ' buffer=' . a:buffer
     endfor
+endfunction
+
+" Get items grouped by any current sign IDs they might have.
+function! s:GetItemsWithSignIDs(loclist) abort
+    let l:items_by_sign_id = {}
+
+    for l:item in a:loclist
+        if has_key(l:item, 'sign_id')
+            if !has_key(l:items_by_sign_id, l:item.sign_id)
+                let l:items_by_sign_id[l:item.sign_id] = []
+            endif
+
+            call add(l:items_by_sign_id[l:item.sign_id], l:item)
+        endif
+    endfor
+
+    return l:items_by_sign_id
+endfunction
+
+" Given some current signs and a loclist, look for items with sign IDs,
+" and change the line numbers for loclist items to match the signs.
+function! s:UpdateLineNumbers(current_sign_list, loclist) abort
+    let l:items_by_sign_id = s:GetItemsWithSignIDs(a:loclist)
+
+    " Do nothing if there's nothing to work with.
+    if empty(l:items_by_sign_id)
+        return
+    endif
+
+    for [l:line, l:sign_id, l:name] in a:current_sign_list
+        for l:obj in get(l:items_by_sign_id, l:sign_id, [])
+            let l:obj.lnum = l:line
+        endfor
+    endfor
+
+    " Sort items again.
+    call sort(a:loclist, 'ale#util#LocItemCompare')
+endfunction
+
+" This function will set the signs which show up on the left.
+function! ale#sign#SetSigns(buffer, loclist) abort
+    " Find the current markers
+    let l:current_sign_list = ale#sign#FindCurrentSigns(a:buffer)
+
+    call s:UpdateLineNumbers(l:current_sign_list, a:loclist)
+
+    let l:grouped_items = s:GroupLoclistItems(a:loclist)
+
+    " Set the dummy sign if we need to.
+    " This keeps the sign gutter open while we remove things, etc.
+    let l:is_dummy_sign_set = s:SetDummySignIfNeeded(
+    \   a:buffer,
+    \   l:current_sign_list,
+    \   !empty(l:grouped_items),
+    \)
+
+    " Now remove the previous signs. The dummy will hold the column open
+    " while we add the new signs, if we had signs before.
+    for [l:line, l:sign_id, l:name] in l:current_sign_list
+        if l:sign_id != g:ale_sign_offset
+            exec 'sign unplace ' . l:sign_id . ' buffer=' . a:buffer
+        endif
+    endfor
+
+    call s:PlaceNewSigns(a:buffer, l:grouped_items)
 
     " Remove the dummy sign now we've updated the signs, unless we want
     " to keep it, which will keep the sign column open even when there are
     " no warnings or errors.
-    if l:dummy_sign_set && !g:ale_sign_column_always
+    if l:is_dummy_sign_set && !g:ale_sign_column_always
         execute 'sign unplace ' . g:ale_sign_offset . ' buffer=' . a:buffer
     endif
 endfunction