From fb4b797dd22b2ec225542c97e5c0c4195edf037e Mon Sep 17 00:00:00 2001
From: Bjorn Neergaard <bjorn@neersighted.com>
Date: Mon, 10 Oct 2016 18:43:45 -0500
Subject: Use explicit scope in all ale_linters

vint -s is now clean
---
 ale_linters/coffee/coffeelint.vim | 30 ++++++++++++++--------------
 ale_linters/d/dmd.vim             | 42 +++++++++++++++++++--------------------
 ale_linters/fortran/gcc.vim       | 34 +++++++++++++++----------------
 ale_linters/haskell/ghc.vim       | 36 ++++++++++++++++-----------------
 ale_linters/html/htmlhint.vim     | 26 ++++++++++++------------
 ale_linters/html/tidy.vim         | 35 ++++++++++++++++----------------
 ale_linters/javascript/eslint.vim | 28 +++++++++++++-------------
 ale_linters/javascript/jscs.vim   | 22 ++++++++++----------
 ale_linters/javascript/jshint.vim | 36 ++++++++++++++++-----------------
 ale_linters/json/jsonlint.vim     | 18 ++++++++---------
 ale_linters/perl/perl.vim         | 28 +++++++++++++-------------
 ale_linters/perl/perlcritic.vim   | 28 +++++++++++++-------------
 ale_linters/php/php.vim           | 12 +++++------
 ale_linters/php/phpcs.vim         | 26 ++++++++++++------------
 ale_linters/pug/puglint.vim       | 12 +++++------
 ale_linters/pyrex/cython.vim      | 12 +++++------
 ale_linters/python/flake8.vim     | 32 ++++++++++++++---------------
 ale_linters/ruby/rubocop.vim      | 20 +++++++++----------
 ale_linters/scala/scalac.vim      | 36 ++++++++++++++++-----------------
 ale_linters/scss/scsslint.vim     | 12 +++++------
 ale_linters/sh/shell.vim          | 40 ++++++++++++++++++-------------------
 ale_linters/typescript/tslint.vim | 28 +++++++++++++-------------
 ale_linters/verilog/iverilog.vim  | 24 +++++++++++-----------
 ale_linters/verilog/verilator.vim | 24 +++++++++++-----------
 ale_linters/yaml/yamllint.vim     | 28 +++++++++++++-------------
 25 files changed, 334 insertions(+), 335 deletions(-)

diff --git a/ale_linters/coffee/coffeelint.vim b/ale_linters/coffee/coffeelint.vim
index 61f3dc81..83053be7 100644
--- a/ale_linters/coffee/coffeelint.vim
+++ b/ale_linters/coffee/coffeelint.vim
@@ -12,36 +12,36 @@ function! ale_linters#coffee#coffeelint#Handle(buffer, lines)
     "
     " path,lineNumber,lineNumberEnd,level,message
     " stdin,14,,error,Throwing strings is forbidden
-    " 
+    "
     " Note that we currently ignore lineNumberEnd for multiline errors
-    let pattern = 'stdin,\(\d\+\),\(\d*\),\(.\+\),\(.\+\)'
-    let output = []
+    let l:pattern = 'stdin,\(\d\+\),\(\d*\),\(.\+\),\(.\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = l:match[1] + 0
-        let column = 1
-        let type = l:match[3] ==# 'error' ? 'E' : 'W'
-        let text = l:match[4]
+        let l:line = l:match[1] + 0
+        let l:column = 1
+        let l:type = l:match[3] ==# 'error' ? 'E' : 'W'
+        let l:text = l:match[4]
 
         " vcol is needed to indicate that the column is a character
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': column,
-        \   'text': text,
-        \   'type': type,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('coffee', {
diff --git a/ale_linters/d/dmd.vim b/ale_linters/d/dmd.vim
index 0fdf0bac..c9e3a2c2 100644
--- a/ale_linters/d/dmd.vim
+++ b/ale_linters/d/dmd.vim
@@ -9,56 +9,56 @@ let g:loaded_ale_linters_d_dmd = 1
 
 " A function for finding the dmd-wrapper script in the Vim runtime paths
 function! s:FindWrapperScript()
-    for parent in split(&runtimepath, ',')
+    for l:parent in split(&runtimepath, ',')
         " Expand the path to deal with ~ issues.
-        let path = expand(parent . '/' . 'dmd-wrapper')
+        let l:path = expand(l:parent . '/' . 'dmd-wrapper')
 
-        if filereadable(path)
-            return path
+        if filereadable(l:path)
+            return l:path
         endif
     endfor
 endfunction
 
 function! ale_linters#d#dmd#GetCommand(buffer)
-    let wrapper_script = s:FindWrapperScript()
+    let l:wrapper_script = s:FindWrapperScript()
 
-    let command = wrapper_script . ' -o- -vcolumns -c'
+    let l:command = l:wrapper_script . ' -o- -vcolumns -c'
 
-    return command
+    return l:command
 endfunction
 
 function! ale_linters#d#dmd#Handle(buffer, lines)
     " Matches patterns lines like the following:
     "
     " /tmp/tmp.G1L5xIizvB.d(8,8): Error: module weak_reference is in file 'dstruct/weak_reference.d' which cannot be read
-    let pattern = '^[^(]\+(\([0-9]\+\),\([0-9]\+\)): \([^:]\+\): \(.\+\)'
-    let output = []
+    let l:pattern = '^[^(]\+(\([0-9]\+\),\([0-9]\+\)): \([^:]\+\): \(.\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             break
         endif
 
-        let line = l:match[1] + 0
-        let column = l:match[2] + 0
-        let type = l:match[3]
-        let text = l:match[4]
+        let l:line = l:match[1] + 0
+        let l:column = l:match[2] + 0
+        let l:type = l:match[3]
+        let l:text = l:match[4]
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': bufnr('%'),
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': column,
-        \   'text': text,
-        \   'type': type ==# 'Warning' ? 'W' : 'E',
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type ==# 'Warning' ? 'W' : 'E',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('d', {
diff --git a/ale_linters/fortran/gcc.vim b/ale_linters/fortran/gcc.vim
index fecaf39a..c0a8974a 100644
--- a/ale_linters/fortran/gcc.vim
+++ b/ale_linters/fortran/gcc.vim
@@ -18,33 +18,33 @@ function! ale_linters#fortran#gcc#Handle(buffer, lines)
     "
     " :21.34:
     " Error: Expected comma in I/O list at (1)
-    let line_marker_pattern = '^:\(\d\+\)\.\(\d\+\):$'
-    let message_pattern = '^\(Error\|Warning\): \(.\+\)$'
-    let looking_for_message = 0
-    let last_loclist_obj = {}
+    let l:line_marker_pattern = '^:\(\d\+\)\.\(\d\+\):$'
+    let l:message_pattern = '^\(Error\|Warning\): \(.\+\)$'
+    let l:looking_for_message = 0
+    let l:last_loclist_obj = {}
 
-    let output = []
+    let l:output = []
 
-    for line in a:lines
-        if looking_for_message
-            let l:match = matchlist(line, message_pattern)
+    for l:line in a:lines
+        if l:looking_for_message
+            let l:match = matchlist(l:line, l:message_pattern)
         else
-            let l:match = matchlist(line, line_marker_pattern)
+            let l:match = matchlist(l:line, l:line_marker_pattern)
         endif
 
         if len(l:match) == 0
             continue
         endif
 
-        if looking_for_message
-            let looking_for_message = 0
+        if l:looking_for_message
+            let l:looking_for_message = 0
 
             " Now we have the text, we can set it and add the error.
-            let last_loclist_obj.text = l:match[2]
-            let last_loclist_obj.type = l:match[1] ==# 'Warning' ? 'W' : 'E'
-            call add(output, last_loclist_obj)
+            let l:last_loclist_obj.text = l:match[2]
+            let l:last_loclist_obj.type = l:match[1] ==# 'Warning' ? 'W' : 'E'
+            call add(l:output, l:last_loclist_obj)
         else
-            let last_loclist_obj = {
+            let l:last_loclist_obj = {
             \   'bufnr': a:buffer,
             \   'lnum': l:match[1] + 0,
             \   'vcol': 0,
@@ -53,11 +53,11 @@ function! ale_linters#fortran#gcc#Handle(buffer, lines)
             \}
 
             " Start looking for the message and error type.
-            let looking_for_message = 1
+            let l:looking_for_message = 1
         endif
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('fortran', {
diff --git a/ale_linters/haskell/ghc.vim b/ale_linters/haskell/ghc.vim
index 5c5dba10..275cf32f 100644
--- a/ale_linters/haskell/ghc.vim
+++ b/ale_linters/haskell/ghc.vim
@@ -11,40 +11,40 @@ function! ale_linters#haskell#ghc#Handle(buffer, lines)
     " Look for lines like the following.
     "
     " /dev/stdin:28:26: Not in scope: `>>>>>'
-    let pattern = '^[^:]\+:\(\d\+\):\(\d\+\): \(.\+\)$'
-    let output = []
+    let l:pattern = '^[^:]\+:\(\d\+\):\(\d\+\): \(.\+\)$'
+    let l:output = []
 
     " For some reason the output coming out of the GHC through the wrapper
     " script breaks the lines up in strange ways. So we have to join some
     " lines back together again.
-    let corrected_lines = []
+    let l:corrected_lines = []
 
-    for line in a:lines
-        if len(matchlist(line, pattern)) > 0
-            call add(corrected_lines, line)
-            if line !~# ': error:$'
-                call add(corrected_lines, '')
+    for l:line in a:lines
+        if len(matchlist(l:line, l:pattern)) > 0
+            call add(l:corrected_lines, l:line)
+            if l:line !~# ': error:$'
+                call add(l:corrected_lines, '')
             endif
-        elseif line ==# ''
-            call add(corrected_lines, line)
+        elseif l:line ==# ''
+            call add(l:corrected_lines, l:line)
         else
-            if len(corrected_lines) > 0
-                if corrected_lines[-1] =~# ': error:$'
-                    let line = substitute(line, '\v^\s+', ' ', '')
+            if len(l:corrected_lines) > 0
+                if l:corrected_lines[-1] =~# ': error:$'
+                    let l:line = substitute(l:line, '\v^\s+', ' ', '')
                 endif
-                let corrected_lines[-1] .= line
+                let l:corrected_lines[-1] .= l:line
             endif
         endif
     endfor
 
-    for line in corrected_lines
-        let l:match = matchlist(line, pattern)
+    for l:line in l:corrected_lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
@@ -55,7 +55,7 @@ function! ale_linters#haskell#ghc#Handle(buffer, lines)
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('haskell', {
diff --git a/ale_linters/html/htmlhint.vim b/ale_linters/html/htmlhint.vim
index 57eff0ec..b46cb8f6 100644
--- a/ale_linters/html/htmlhint.vim
+++ b/ale_linters/html/htmlhint.vim
@@ -11,33 +11,33 @@ function! ale_linters#html#htmlhint#Handle(buffer, lines) abort
     " Matches patterns lines like the following:
     "stdin:7:10: <title></title> must not be empty. [error/title-require]
 
-    let pattern = '^stdin:\(\d\+\):\(\d\+\): \(.\+\)$'
-    let output = []
+    let l:pattern = '^stdin:\(\d\+\):\(\d\+\): \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
-        if len(match) == 0
+        if len(l:match) == 0
             continue
         endif
 
-        let line = match[1] + 0
-        let col = match[2] + 0
-        let text = match[3]
+        let l:line = l:match[1] + 0
+        let l:col = l:match[2] + 0
+        let l:text = l:match[3]
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': col,
-        \   'text': text,
+        \   'col': l:col,
+        \   'text': l:text,
         \   'type': 'E',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('html', {
diff --git a/ale_linters/html/tidy.vim b/ale_linters/html/tidy.vim
index c1aab8f3..a4e12aec 100644
--- a/ale_linters/html/tidy.vim
+++ b/ale_linters/html/tidy.vim
@@ -12,10 +12,9 @@ let g:ale_html_tidy_executable = get(g:, 'ale_html_tidy_executable', 'tidy')
 let g:ale_html_tidy_args = get(g:, 'ale_html_tidy_args', '-q -e -language en')
 
 function! ale_linters#html#tidy#GetCommand(buffer) abort
-
     " Specify file encoding in options
     " (Idea taken from https://github.com/scrooloose/syntastic/blob/master/syntax_checkers/html/tidy.vim)
-    let file_encoding = get({
+    let l:file_encoding = get({
     \   'ascii':        '-ascii',
     \   'big5':         '-big5',
     \   'cp1252':       '-win1252',
@@ -33,7 +32,7 @@ function! ale_linters#html#tidy#GetCommand(buffer) abort
     return printf('%s %s %s -',
     \   g:ale_html_tidy_executable,
     \   g:ale_html_tidy_args,
-    \   file_encoding
+    \   l:file_encoding
     \ )
 endfunction
 
@@ -41,34 +40,34 @@ function! ale_linters#html#tidy#Handle(buffer, lines) abort
     " Matches patterns lines like the following:
     " line 7 column 5 - Warning: missing </title> before </head>
 
-    let pattern = '^line \(\d\+\) column \(\d\+\) - \(Warning\|Error\): \(.\+\)$'
-    let output = []
+    let l:pattern = '^line \(\d\+\) column \(\d\+\) - \(Warning\|Error\): \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
-        if len(match) == 0
+        if len(l:match) == 0
             continue
         endif
 
-        let line = match[1] + 0
-        let col = match[2] + 0
-        let type = match[3] ==# 'Error' ? 'E' : 'W'
-        let text = match[4]
+        let l:line = l:match[1] + 0
+        let l:col = l:match[2] + 0
+        let l:type = l:match[3] ==# 'Error' ? 'E' : 'W'
+        let l:text = l:match[4]
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': col,
-        \   'text': text,
-        \   'type': type,
+        \   'col': l:col,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('html', {
diff --git a/ale_linters/javascript/eslint.vim b/ale_linters/javascript/eslint.vim
index d140a957..909c1128 100644
--- a/ale_linters/javascript/eslint.vim
+++ b/ale_linters/javascript/eslint.vim
@@ -15,38 +15,38 @@ function! ale_linters#javascript#eslint#Handle(buffer, lines)
     "
     " /path/to/some-filename.js:47:14: Missing trailing comma. [Warning/comma-dangle]
     " /path/to/some-filename.js:56:41: Missing semicolon. [Error/semi]
-    let pattern = '^.*:\(\d\+\):\(\d\+\): \(.\+\) \[\(.\+\)\]$'
-    let output = []
+    let l:pattern = '^.*:\(\d\+\):\(\d\+\): \(.\+\) \[\(.\+\)\]$'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let text = l:match[3]
-        let marker = l:match[4]
-        let marker_parts = split(marker, '/')
-        let type = marker_parts[0]
+        let l:text = l:match[3]
+        let l:marker = l:match[4]
+        let l:marker_parts = split(l:marker, '/')
+        let l:type = l:marker_parts[0]
 
-        if len(marker_parts) == 2
-            let text = text . ' (' . marker_parts[1] . ')'
+        if len(l:marker_parts) == 2
+            let l:text = l:text . ' (' . l:marker_parts[1] . ')'
         endif
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
         \   'col': l:match[2] + 0,
-        \   'text': text,
-        \   'type': type ==# 'Warning' ? 'W' : 'E',
+        \   'text': l:text,
+        \   'type': l:type ==# 'Warning' ? 'W' : 'E',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('javascript', {
diff --git a/ale_linters/javascript/jscs.vim b/ale_linters/javascript/jscs.vim
index 9252eef3..1853c894 100644
--- a/ale_linters/javascript/jscs.vim
+++ b/ale_linters/javascript/jscs.vim
@@ -11,36 +11,36 @@ function! ale_linters#javascript#jscs#Handle(buffer, lines)
     " Matches patterns line the following:
     "
     " input:57:8: Unexpected token (57:8)
-    let pattern = '^.\+:\(\d\+\):\(\d\+\): \(.\+\)'
-    let output = []
+    let l:pattern = '^.\+:\(\d\+\):\(\d\+\): \(.\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let text = l:match[3]
-        let marker_parts = l:match[4]
+        let l:text = l:match[3]
+        let l:marker_parts = l:match[4]
 
-        if len(marker_parts) == 2
-            let text = text . ' (' . marker_parts[1] . ')'
+        if len(l:marker_parts) == 2
+            let l:text = l:text . ' (' . l:marker_parts[1] . ')'
         endif
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
         \   'col': l:match[2] + 0,
-        \   'text': text,
+        \   'text': l:text,
         \   'type': 'E',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('javascript', {
diff --git a/ale_linters/javascript/jshint.vim b/ale_linters/javascript/jshint.vim
index 11c60409..6dbd4c2a 100644
--- a/ale_linters/javascript/jshint.vim
+++ b/ale_linters/javascript/jshint.vim
@@ -14,21 +14,21 @@ function! ale_linters#javascript#jshint#GetCommand(buffer)
     " Set this to the location of the jshint configuration file to
     " use a fixed location for .jshintrc
     if exists('g:ale_jshint_config_loc')
-        let jshint_config = g:ale_jshint_config_loc
+        let l:jshint_config = g:ale_jshint_config_loc
     else
         " Look for the JSHint config in parent directories.
-        let jshint_config = ale#util#FindNearestFile(a:buffer, '.jshintrc')
+        let l:jshint_config = ale#util#FindNearestFile(a:buffer, '.jshintrc')
     endif
 
-    let command = g:ale_javascript_jshint_executable . ' --reporter unix'
+    let l:command = g:ale_javascript_jshint_executable . ' --reporter unix'
 
-    if !empty(jshint_config)
-        let command .= ' --config ' . fnameescape(jshint_config)
+    if !empty(l:jshint_config)
+        let l:command .= ' --config ' . fnameescape(l:jshint_config)
     endif
 
-    let command .= ' -'
+    let l:command .= ' -'
 
-    return command
+    return l:command
 endfunction
 
 function! ale_linters#javascript#jshint#Handle(buffer, lines)
@@ -38,36 +38,36 @@ function! ale_linters#javascript#jshint#Handle(buffer, lines)
     " stdin:60:5: Attempting to override 'test2' which is a constant.
     " stdin:57:10: 'test' is defined but never used.
     " stdin:57:1: 'function' is defined but never used.
-    let pattern = '^.\+:\(\d\+\):\(\d\+\): \(.\+\)'
-    let output = []
+    let l:pattern = '^.\+:\(\d\+\):\(\d\+\): \(.\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let text = l:match[3]
-        let marker_parts = l:match[4]
+        let l:text = l:match[3]
+        let l:marker_parts = l:match[4]
 
-        if len(marker_parts) == 2
-            let text = text . ' (' . marker_parts[1] . ')'
+        if len(l:marker_parts) == 2
+            let l:text = l:text . ' (' . l:marker_parts[1] . ')'
         endif
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
         \   'col': l:match[2] + 0,
-        \   'text': text,
+        \   'text': l:text,
         \   'type': 'E',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('javascript', {
diff --git a/ale_linters/json/jsonlint.vim b/ale_linters/json/jsonlint.vim
index aaf56b6e..cfbe9c7d 100644
--- a/ale_linters/json/jsonlint.vim
+++ b/ale_linters/json/jsonlint.vim
@@ -10,29 +10,29 @@ function! ale_linters#json#jsonlint#Handle(buffer, lines)
     " Matches patterns like the following:
     " line 2, col 15, found: 'STRING' - expected: 'EOF', '}', ',', ']'.
 
-    let pattern = '^line \(\d\+\), col \(\d*\), \(.\+\)$'
-    let output = []
+    let l:pattern = '^line \(\d\+\), col \(\d*\), \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
         " vcol is needed to indicate that the column is a character
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': match[1] + 0,
+        \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
-        \   'col': match[2] + 0,
-        \   'text': match[3],
+        \   'col': l:match[2] + 0,
+        \   'text': l:match[3],
         \   'type': 'E',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('json', {
diff --git a/ale_linters/perl/perl.vim b/ale_linters/perl/perl.vim
index c5300ac8..5b35803c 100644
--- a/ale_linters/perl/perl.vim
+++ b/ale_linters/perl/perl.vim
@@ -7,34 +7,34 @@ endif
 
 let g:loaded_ale_linters_perl_perl = 1
 function! ale_linters#perl#perl#Handle(buffer, lines)
-    let pattern = '\(.\+\) at \(.\+\) line \(\d\+\)'
-    let output = []
+    let l:pattern = '\(.\+\) at \(.\+\) line \(\d\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = l:match[3]
-        let column = 1
-        let text = l:match[1]
-        let type = 'E'
+        let l:line = l:match[3]
+        let l:column = 1
+        let l:text = l:match[1]
+        let l:type = 'E'
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': column,
-        \   'text': text,
-        \   'type': type,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('perl', {
diff --git a/ale_linters/perl/perlcritic.vim b/ale_linters/perl/perlcritic.vim
index 64e1e3e4..8e29a574 100644
--- a/ale_linters/perl/perlcritic.vim
+++ b/ale_linters/perl/perlcritic.vim
@@ -7,34 +7,34 @@ endif
 
 let g:loaded_ale_linters_perl_perlcritic = 1
 function! ale_linters#perl#perlcritic#Handle(buffer, lines)
-    let pattern = '\(.\+\) at \(.\+\) line \(\d\+\)'
-    let output = []
+    let l:pattern = '\(.\+\) at \(.\+\) line \(\d\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = l:match[3]
-        let column = 1
-        let text = l:match[1]
-        let type = 'E'
+        let l:line = l:match[3]
+        let l:column = 1
+        let l:text = l:match[1]
+        let l:type = 'E'
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': column,
-        \   'text': text,
-        \   'type': type,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('perl', {
diff --git a/ale_linters/php/php.vim b/ale_linters/php/php.vim
index 57519a24..21288428 100644
--- a/ale_linters/php/php.vim
+++ b/ale_linters/php/php.vim
@@ -11,18 +11,18 @@ function! ale_linters#php#php#Handle(buffer, lines)
     " Matches patterns like the following:
     "
     " Parse error: parse error in - on line 7
-    let pattern = 'Parse error:\s\+\(.\+\) on line \(\d\+\)'
-    let output = []
+    let l:pattern = 'Parse error:\s\+\(.\+\) on line \(\d\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
         " vcol is needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[2] + 0,
         \   'vcol': 0,
@@ -33,7 +33,7 @@ function! ale_linters#php#php#Handle(buffer, lines)
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('php', {
diff --git a/ale_linters/php/phpcs.vim b/ale_linters/php/phpcs.vim
index ed74b443..67ac6b5a 100644
--- a/ale_linters/php/phpcs.vim
+++ b/ale_linters/php/phpcs.vim
@@ -8,46 +8,46 @@ endif
 let g:loaded_ale_linters_php_phpcs = 1
 
 function! ale_linters#php#phpcs#GetCommand(buffer)
-    let command = 'phpcs -s --report=emacs --stdin-path=%s'
+    let l:command = 'phpcs -s --report=emacs --stdin-path=%s'
 
     " This option can be set to change the standard used by phpcs
     if exists('g:ale_php_phpcs_standard')
-        let command .= ' --standard=' . g:ale_php_phpcs_standard
+        let l:command .= ' --standard=' . g:ale_php_phpcs_standard
     endif
 
-    return command
+    return l:command
 endfunction
 
 function! ale_linters#php#phpcs#Handle(buffer, lines)
     " Matches against lines like the following:
     "
     " /path/to/some-filename.php:18:3: error - Line indented incorrectly; expected 4 spaces, found 2 (Generic.WhiteSpace.ScopeIndent.IncorrectExact)
-    let pattern = '^.*:\(\d\+\):\(\d\+\): \(.\+\) - \(.\+\) \(\(.\+\)\)$'
-    let output = []
+    let l:pattern = '^.*:\(\d\+\):\(\d\+\): \(.\+\) - \(.\+\) \(\(.\+\)\)$'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let text = l:match[4]
-        let type = l:match[3]
+        let l:text = l:match[4]
+        let l:type = l:match[3]
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
         \   'col': l:match[2] + 0,
-        \   'text': text,
-        \   'type': type ==# 'warning' ? 'W' : 'E',
+        \   'text': l:text,
+        \   'type': l:type ==# 'warning' ? 'W' : 'E',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('php', {
diff --git a/ale_linters/pug/puglint.vim b/ale_linters/pug/puglint.vim
index 754c6bb4..e3eff72f 100644
--- a/ale_linters/pug/puglint.vim
+++ b/ale_linters/pug/puglint.vim
@@ -11,17 +11,17 @@ function! ale_linters#pug#puglint#Handle(buffer, lines)
     " Matches patterns like the following:
     "
     " temp.jade:6:1 The end of the string reached with no closing bracket ) found.
-    let pattern = '^.\+:\(\d\+\):\(\d\+\) \(.\+\)$'
-    let output = []
+    let l:pattern = '^.\+:\(\d\+\):\(\d\+\) \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
@@ -32,7 +32,7 @@ function! ale_linters#pug#puglint#Handle(buffer, lines)
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('pug', {
diff --git a/ale_linters/pyrex/cython.vim b/ale_linters/pyrex/cython.vim
index 0c393f95..a8c59b3e 100644
--- a/ale_linters/pyrex/cython.vim
+++ b/ale_linters/pyrex/cython.vim
@@ -5,11 +5,11 @@ function! ale_linters#pyrex#cython#Handle(buffer, lines)
     " Matches patterns line the following:
     "
     " test.pyx:13:25: Expected ':', found 'NEWLINE'
-    let pattern = '^.\+:\(\d\+\):\(\d\+\): \(.\+\)$'
-    let output = []
+    let l:pattern = '^.\+:\(\d\+\):\(\d\+\): \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
@@ -20,7 +20,7 @@ function! ale_linters#pyrex#cython#Handle(buffer, lines)
             continue
         endif
 
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
@@ -31,7 +31,7 @@ function! ale_linters#pyrex#cython#Handle(buffer, lines)
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('pyrex', {
diff --git a/ale_linters/python/flake8.vim b/ale_linters/python/flake8.vim
index aa114df6..549eaf7f 100644
--- a/ale_linters/python/flake8.vim
+++ b/ale_linters/python/flake8.vim
@@ -11,40 +11,40 @@ function! ale_linters#python#flake8#Handle(buffer, lines)
     " Matches patterns line the following:
     "
     " stdin:6:6: E111 indentation is not a multiple of four
-    let pattern = '^stdin:\(\d\+\):\(\d\+\): \([^ ]\+\) \(.\+\)$'
-    let output = []
+    let l:pattern = '^stdin:\(\d\+\):\(\d\+\): \([^ ]\+\) \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = l:match[1] + 0
-        let column = l:match[2] + 0
-        let code = l:match[3]
-        let text = code . ': ' . l:match[4]
-        let type = code[0] ==# 'E' ? 'E' : 'W'
+        let l:line = l:match[1] + 0
+        let l:column = l:match[2] + 0
+        let l:code = l:match[3]
+        let l:text = l:code . ': ' . l:match[4]
+        let l:type = l:code[0] ==# 'E' ? 'E' : 'W'
 
-        if code ==# 'W291' && !g:ale_warn_about_trailing_whitespace
+        if l:code ==# 'W291' && !g:ale_warn_about_trailing_whitespace
             " Skip warnings for trailing whitespace if the option is off.
             continue
         endif
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': column,
-        \   'text': text,
-        \   'type': type,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('python', {
diff --git a/ale_linters/ruby/rubocop.vim b/ale_linters/ruby/rubocop.vim
index 17326a7e..7c90cdf5 100644
--- a/ale_linters/ruby/rubocop.vim
+++ b/ale_linters/ruby/rubocop.vim
@@ -12,32 +12,32 @@ function! ale_linters#ruby#rubocop#Handle(buffer, lines)
     "
     " <path>/_:47:14: 83:29: C: Prefer single-quoted strings when you don't
     " need string interpolation or special symbols.
-    let pattern = '\v_:(\d+):(\d+): (.): (.+)'
-    let output = []
+    let l:pattern = '\v_:(\d+):(\d+): (.): (.+)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let text = l:match[4]
-        let type = l:match[3]
+        let l:text = l:match[4]
+        let l:type = l:match[3]
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
         \   'col': l:match[2] + 0,
-        \   'text': text,
-        \   'type': type ==# 'C' ? 'E' : 'W',
+        \   'text': l:text,
+        \   'type': l:type ==# 'C' ? 'E' : 'W',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('ruby', {
diff --git a/ale_linters/scala/scalac.vim b/ale_linters/scala/scalac.vim
index 06508107..648e3460 100644
--- a/ale_linters/scala/scalac.vim
+++ b/ale_linters/scala/scalac.vim
@@ -12,41 +12,41 @@ function! ale_linters#scala#scalac#Handle(buffer, lines)
     " Matches patterns line the following:
     "
     " /var/folders/5q/20rgxx3x1s34g3m14n5bq0x80000gn/T/vv6pSsy/0:26: error: expected class or object definition
-    let pattern = '^.\+:\(\d\+\): \(\w\+\): \(.\+\)'
-    let output = []
-    let ln = 0
+    let l:pattern = '^.\+:\(\d\+\): \(\w\+\): \(.\+\)'
+    let l:output = []
+    let l:ln = 0
 
-    for line in a:lines
-        let ln = ln + 1
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:ln = l:ln + 1
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let text = l:match[3]
-        let type = l:match[2] ==# 'error' ? 'E' : 'W'
-        let col = 0
-        if ln + 1 < len(a:lines)
-            let col = stridx(a:lines[ln + 1], '^')
-            if col == -1
-                let col = 0
+        let l:text = l:match[3]
+        let l:type = l:match[2] ==# 'error' ? 'E' : 'W'
+        let l:col = 0
+        if l:ln + 1 < len(a:lines)
+            let l:col = stridx(a:lines[l:ln + 1], '^')
+            if l:col == -1
+                let l:col = 0
             endif
         endif
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
-        \   'col': col + 1,
-        \   'text': text,
-        \   'type': type,
+        \   'col': l:col + 1,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('scala', {
diff --git a/ale_linters/scss/scsslint.vim b/ale_linters/scss/scsslint.vim
index ac1c3796..e7541bb2 100644
--- a/ale_linters/scss/scsslint.vim
+++ b/ale_linters/scss/scsslint.vim
@@ -11,11 +11,11 @@ function! ale_linters#scss#scsslint#Handle(buffer, lines)
     " Matches patterns like the following:
     "
     " test.scss:2:1 [W] Indentation: Line should be indented 2 spaces, but was indented 4 spaces
-    let pattern = '^.*:\(\d\+\):\(\d*\) \[\([^\]]\+\)\] \(.\+\)$'
-    let output = []
+    let l:pattern = '^.*:\(\d\+\):\(\d*\) \[\([^\]]\+\)\] \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
@@ -27,7 +27,7 @@ function! ale_linters#scss#scsslint#Handle(buffer, lines)
         endif
 
         " vcol is needed to indicate that the column is a character
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
         \   'vcol': 0,
@@ -38,7 +38,7 @@ function! ale_linters#scss#scsslint#Handle(buffer, lines)
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('scss', {
diff --git a/ale_linters/sh/shell.vim b/ale_linters/sh/shell.vim
index b17f331a..9866309e 100644
--- a/ale_linters/sh/shell.vim
+++ b/ale_linters/sh/shell.vim
@@ -18,16 +18,16 @@ if !exists('g:ale_linters_sh_shell_default_shell')
 endif
 
 function! ale_linters#sh#shell#GetExecutable(buffer)
-    let banglines = getbufline(a:buffer, 1)
+    let l:banglines = getbufline(a:buffer, 1)
 
     " Take the shell executable from the hashbang, if we can.
-    if len(banglines) == 1 && banglines[0] =~# '^#!'
+    if len(l:banglines) == 1 && l:banglines[0] =~# '^#!'
         " Remove options like -e, etc.
-        let line = substitute(banglines[0], '--\?[a-zA-Z0-9]\+', '', 'g')
+        let l:line = substitute(l:banglines[0], '--\?[a-zA-Z0-9]\+', '', 'g')
 
-        for possible_shell in ['bash', 'tcsh', 'csh', 'zsh', 'sh']
-            if line =~# possible_shell . '\s*$'
-                return possible_shell
+        for l:possible_shell in ['bash', 'tcsh', 'csh', 'zsh', 'sh']
+            if l:line =~# l:possible_shell . '\s*$'
+                return l:possible_shell
             endif
         endfor
     endif
@@ -44,34 +44,34 @@ function! ale_linters#sh#shell#Handle(buffer, lines)
     "
     " bash: line 13: syntax error near unexpected token `d'
     " sh: 11: Syntax error: "(" unexpected
-    let pattern = '^[^:]\+: \%(\w\+ \|\)\(\d\+\): \(.\+\)'
-    let output = []
+    let l:pattern = '^[^:]\+: \%(\w\+ \|\)\(\d\+\): \(.\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = l:match[1] + 0
-        let column = 1
-        let text = l:match[2]
-        let type = 'E'
+        let l:line = l:match[1] + 0
+        let l:column = 1
+        let l:text = l:match[2]
+        let l:type = 'E'
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': column,
-        \   'text': text,
-        \   'type': type,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('sh', {
diff --git a/ale_linters/typescript/tslint.vim b/ale_linters/typescript/tslint.vim
index ef147832..d0e5ee0b 100644
--- a/ale_linters/typescript/tslint.vim
+++ b/ale_linters/typescript/tslint.vim
@@ -13,34 +13,34 @@ function! ale_linters#typescript#tslint#Handle(buffer, lines)
     " hello.ts[7, 41]: trailing whitespace
     " hello.ts[5, 1]: Forbidden 'var' keyword, use 'let' or 'const' instead
     "
-    let pattern = '.\+.ts\[\(\d\+\), \(\d\+\)\]: \(.\+\)'
-    let output = []
+    let l:pattern = '.\+.ts\[\(\d\+\), \(\d\+\)\]: \(.\+\)'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = l:match[1] + 0
-        let column = l:match[2] + 0
-        let type = 'E'
-        let text = l:match[3]
+        let l:line = l:match[1] + 0
+        let l:column = l:match[2] + 0
+        let l:type = 'E'
+        let l:text = l:match[3]
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': column,
-        \   'text': text,
-        \   'type': type,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('typescript', {
diff --git a/ale_linters/verilog/iverilog.vim b/ale_linters/verilog/iverilog.vim
index 02df6f84..373c6731 100644
--- a/ale_linters/verilog/iverilog.vim
+++ b/ale_linters/verilog/iverilog.vim
@@ -14,32 +14,32 @@ function! ale_linters#verilog#iverilog#Handle(buffer, lines)
     " tb_me_top.v:17: syntax error
     " memory_single_port.v:2: syntax error
     " tb_me_top.v:17: error: Invalid module instantiation
-    let pattern = '^[^:]\+:\(\d\+\): \(warning\|error\|syntax error\)\(: \(.\+\)\)\?'
-    let output = []
+    let l:pattern = '^[^:]\+:\(\d\+\): \(warning\|error\|syntax error\)\(: \(.\+\)\)\?'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = l:match[1] + 0
-        let type = l:match[2] ==# 'warning' ? 'W' : 'E'
-        let text = l:match[2] ==# 'syntax error' ? 'syntax error' : l:match[4]
+        let l:line = l:match[1] + 0
+        let l:type = l:match[2] ==# 'warning' ? 'W' : 'E'
+        let l:text = l:match[2] ==# 'syntax error' ? 'syntax error' : l:match[4]
 
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
         \   'col': 1,
-        \   'text': text,
-        \   'type': type,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('verilog', {
diff --git a/ale_linters/verilog/verilator.vim b/ale_linters/verilog/verilator.vim
index 4878ad3e..4fd0a295 100644
--- a/ale_linters/verilog/verilator.vim
+++ b/ale_linters/verilog/verilator.vim
@@ -16,32 +16,32 @@ function! ale_linters#verilog#verilator#Handle(buffer, lines)
     " %Warning-UNDRIVEN: test.v:3: Signal is not driven: clk
     " %Warning-UNUSED: test.v:4: Signal is not used: dout
     " %Warning-BLKSEQ: test.v:10: Blocking assignments (=) in sequential (flop or latch) block; suggest delayed assignments (<=).
-    let pattern = '^%\(Warning\|Error\)[^:]*:[^:]\+:\(\d\+\): \(.\+\)$'
-    let output = []
+    let l:pattern = '^%\(Warning\|Error\)[^:]*:[^:]\+:\(\d\+\): \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = l:match[2] + 0
-        let type = l:match[1] ==# 'Error' ? 'E' : 'W'
-        let text = l:match[3]
+        let l:line = l:match[2] + 0
+        let l:type = l:match[1] ==# 'Error' ? 'E' : 'W'
+        let l:text = l:match[3]
 
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
         \   'col': 1,
-        \   'text': text,
-        \   'type': type,
+        \   'text': l:text,
+        \   'type': l:type,
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('verilog', {
diff --git a/ale_linters/yaml/yamllint.vim b/ale_linters/yaml/yamllint.vim
index db01ccc4..4b0c8def 100644
--- a/ale_linters/yaml/yamllint.vim
+++ b/ale_linters/yaml/yamllint.vim
@@ -10,34 +10,34 @@ function! ale_linters#yaml#yamllint#Handle(buffer, lines)
     " Matches patterns line the following:
     " something.yaml:1:1: [warning] missing document start "---" (document-start)
     " something.yml:2:1: [error] syntax error: expected the node content, but found '<stream end>'
-    let pattern = '^.*:\(\d\+\):\(\d\+\): \[\(error\|warning\)\] \(.\+\)$'
-    let output = []
+    let l:pattern = '^.*:\(\d\+\):\(\d\+\): \[\(error\|warning\)\] \(.\+\)$'
+    let l:output = []
 
-    for line in a:lines
-        let l:match = matchlist(line, pattern)
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
 
         if len(l:match) == 0
             continue
         endif
 
-        let line = match[1] + 0
-        let col = match[2] + 0
-        let type = match[3]
-        let text = match[4]
+        let l:line = l:match[1] + 0
+        let l:col = l:match[2] + 0
+        let l:type = l:match[3]
+        let l:text = l:match[4]
 
         " vcol is Needed to indicate that the column is a character.
-        call add(output, {
+        call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': line,
+        \   'lnum': l:line,
         \   'vcol': 0,
-        \   'col': col,
-        \   'text': text,
-        \   'type': type ==# 'warning' ? 'W' : 'E',
+        \   'col': l:col,
+        \   'text': l:text,
+        \   'type': l:type ==# 'warning' ? 'W' : 'E',
         \   'nr': -1,
         \})
     endfor
 
-    return output
+    return l:output
 endfunction
 
 call ale#linter#Define('yaml', {
-- 
cgit v1.2.3