Switch to v:t_ variables for type checks

17 files changed, 84 insertions, 62 deletions

diff --git a/ale_linters/elm/make.vim b/ale_linters/elm/make.vim
index d5bc19eb..8231ad47 100644
--- a/ale_linters/elm/make.vim
+++ b/ale_linters/elm/make.vim
@@ -136,7 +136,7 @@ function! ale_linters#elm#make#ParseMessage(message) abort
 endfunction
 
 function! ale_linters#elm#make#ParseMessageItem(item) abort
-    if type(a:item) == type('')
+    if type(a:item) is v:t_string
         return a:item
     else
         return a:item.string
diff --git a/autoload/ale.vim b/autoload/ale.vim
index 6d1e8521..ee32a9a6 100644
--- a/autoload/ale.vim
+++ b/autoload/ale.vim
@@ -95,7 +95,7 @@ function! ale#Queue(delay, ...) abort
         throw "linting_flag must be either '' or 'lint_file'"
     endif
 
-    if type(l:buffer) != type(0)
+    if type(l:buffer) isnot v:t_number
         throw 'buffer_number must be a Number'
     endif
 
diff --git a/autoload/ale/assert.vim b/autoload/ale/assert.vim
index 55c39ee3..a6753a1a 100644
--- a/autoload/ale/assert.vim
+++ b/autoload/ale/assert.vim
@@ -30,7 +30,7 @@ function! ale#assert#Linter(expected_executable, expected_command) abort
         let l:callbacks = map(copy(l:linter.command_chain), 'v:val.callback')
 
         " If the expected command is a string, just check the last one.
-        if type(a:expected_command) is type('')
+        if type(a:expected_command) is v:t_string
             if len(l:callbacks) is 1
                 let l:command = call(l:callbacks[0], [l:buffer])
             else
diff --git a/autoload/ale/completion.vim b/autoload/ale/completion.vim
index 7440f8cd..0423e395 100644
--- a/autoload/ale/completion.vim
+++ b/autoload/ale/completion.vim
@@ -113,7 +113,7 @@ function! ale#completion#Filter(buffer, suggestions, prefix) abort
         for l:item in a:suggestions
             " A List of String values or a List of completion item Dictionaries
             " is accepted here.
-            let l:word = type(l:item) == type('') ? l:item : l:item.word
+            let l:word = type(l:item) is v:t_string ? l:item : l:item.word
 
             " Add suggestions if the suggestion starts with a case-insensitive
             " match for the prefix.
@@ -133,7 +133,7 @@ function! ale#completion#Filter(buffer, suggestions, prefix) abort
         " Remove suggestions with words in the exclusion List.
         call filter(
         \   l:filtered_suggestions,
-        \   'index(l:excluded_words, type(v:val) is type('''') ? v:val : v:val.word) < 0',
+        \   'index(l:excluded_words, type(v:val) is v:t_string ? v:val : v:val.word) < 0',
         \)
     endif
 
@@ -315,10 +315,10 @@ function! ale#completion#ParseLSPCompletions(response) abort
 
     let l:item_list = []
 
-    if type(get(a:response, 'result')) is type([])
+    if type(get(a:response, 'result')) is v:t_list
         let l:item_list = a:response.result
-    elseif type(get(a:response, 'result')) is type({})
-    \&& type(get(a:response.result, 'items')) is type([])
+    elseif type(get(a:response, 'result')) is v:t_dict
+    \&& type(get(a:response.result, 'items')) is v:t_list
         let l:item_list = a:response.result.items
     endif
 
diff --git a/autoload/ale/definition.vim b/autoload/ale/definition.vim
index 6c7d7d32..3ef24e28 100644
--- a/autoload/ale/definition.vim
+++ b/autoload/ale/definition.vim
@@ -40,9 +40,9 @@ function! ale#definition#HandleLSPResponse(conn_id, response) abort
         " The result can be a Dictionary item, a List of the same, or null.
         let l:result = get(a:response, 'result', v:null)
 
-        if type(l:result) is type({})
+        if type(l:result) is v:t_dict
             let l:result = [l:result]
-        elseif type(l:result) isnot type([])
+        elseif type(l:result) isnot v:t_list
             let l:result = []
         endif
 
diff --git a/autoload/ale/engine.vim b/autoload/ale/engine.vim
index ec5ccb6d..fdf883f5 100644
--- a/autoload/ale/engine.vim
+++ b/autoload/ale/engine.vim
@@ -557,7 +557,7 @@ function! s:RunJob(options) abort
     if get(g:, 'ale_run_synchronously') == 1
         " Run a command synchronously if this test option is set.
         let s:job_info_map[l:job_id].output = systemlist(
-        \   type(l:command) == type([])
+        \   type(l:command) is v:t_list
         \   ?  join(l:command[0:1]) . ' ' . ale#Escape(l:command[2])
         \   : l:command
         \)
diff --git a/autoload/ale/engine/ignore.vim b/autoload/ale/engine/ignore.vim
index 65347e21..2db2c6c1 100644
--- a/autoload/ale/engine/ignore.vim
+++ b/autoload/ale/engine/ignore.vim
@@ -4,11 +4,11 @@
 " Given a filetype and a configuration for ignoring linters, return a List of
 " Strings for linter names to ignore.
 function! ale#engine#ignore#GetList(filetype, config) abort
-    if type(a:config) is type([])
+    if type(a:config) is v:t_list
         return a:config
     endif
 
-    if type(a:config) is type({})
+    if type(a:config) is v:t_dict
         let l:names_to_remove = []
 
         for l:part in split(a:filetype , '\.')
diff --git a/autoload/ale/fix.vim b/autoload/ale/fix.vim
index 8dfdeca8..4d82b367 100644
--- a/autoload/ale/fix.vim
+++ b/autoload/ale/fix.vim
@@ -275,7 +275,7 @@ function! s:RunJob(options) abort
     if get(g:, 'ale_run_synchronously') == 1
         " Run a command synchronously if this test option is set.
         let l:output = systemlist(
-        \   type(l:command) == type([])
+        \   type(l:command) is v:t_list
         \   ?  join(l:command[0:1]) . ' ' . ale#Escape(l:command[2])
         \   : l:command
         \)
@@ -313,10 +313,10 @@ function! s:RunFixer(options) abort
             \   : call(l:Function, [l:buffer, copy(l:input)])
         endif
 
-        if type(l:result) == type(0) && l:result == 0
+        if type(l:result) is v:t_number && l:result == 0
             " When `0` is returned, skip this item.
             let l:index += 1
-        elseif type(l:result) == type([])
+        elseif type(l:result) is v:t_list
             let l:input = l:result
             let l:index += 1
         else
@@ -351,9 +351,9 @@ function! s:RunFixer(options) abort
 endfunction
 
 function! s:AddSubCallbacks(full_list, callbacks) abort
-    if type(a:callbacks) == type('')
+    if type(a:callbacks) is v:t_string
         call add(a:full_list, a:callbacks)
-    elseif type(a:callbacks) == type([])
+    elseif type(a:callbacks) is v:t_list
         call extend(a:full_list, a:callbacks)
     else
         return 0
@@ -365,7 +365,7 @@ endfunction
 function! s:GetCallbacks(buffer, fixers) abort
     if len(a:fixers)
         let l:callback_list = a:fixers
-    elseif type(get(b:, 'ale_fixers')) is type([])
+    elseif type(get(b:, 'ale_fixers')) is v:t_list
         " Lists can be used for buffer-local variables only
         let l:callback_list = b:ale_fixers
     else
@@ -396,7 +396,7 @@ function! s:GetCallbacks(buffer, fixers) abort
     " Variables with capital characters are needed, or Vim will complain about
     " funcref variables.
     for l:Item in l:callback_list
-        if type(l:Item) == type('')
+        if type(l:Item) is v:t_string
             let l:Func = ale#fix#registry#GetFunc(l:Item)
 
             if !empty(l:Func)
diff --git a/autoload/ale/fix/registry.vim b/autoload/ale/fix/registry.vim
index e148ecd6..dc34e4c5 100644
--- a/autoload/ale/fix/registry.vim
+++ b/autoload/ale/fix/registry.vim
@@ -245,32 +245,32 @@ function! ale#fix#registry#Add(name, func, filetypes, desc, ...) abort
     " This command will throw from the sandbox.
     let &equalprg=&equalprg
 
-    if type(a:name) != type('')
+    if type(a:name) isnot v:t_string
         throw '''name'' must be a String'
     endif
 
-    if type(a:func) != type('')
+    if type(a:func) isnot v:t_string
         throw '''func'' must be a String'
     endif
 
-    if type(a:filetypes) != type([])
+    if type(a:filetypes) isnot v:t_list
         throw '''filetypes'' must be a List'
     endif
 
     for l:type in a:filetypes
-        if type(l:type) != type('')
+        if type(l:type) isnot v:t_string
             throw 'Each entry of ''filetypes'' must be a String'
         endif
     endfor
 
-    if type(a:desc) != type('')
+    if type(a:desc) isnot v:t_string
         throw '''desc'' must be a String'
     endif
 
     let l:aliases = get(a:000, 0, [])
 
-    if type(l:aliases) != type([])
-    \|| !empty(filter(copy(l:aliases), 'type(v:val) != type('''')'))
+    if type(l:aliases) isnot v:t_list
+    \|| !empty(filter(copy(l:aliases), 'type(v:val) isnot v:t_string'))
         throw '''aliases'' must be a List of String values'
     endif
 
diff --git a/autoload/ale/handlers/rust.vim b/autoload/ale/handlers/rust.vim
index 537bc731..f12c53be 100644
--- a/autoload/ale/handlers/rust.vim
+++ b/autoload/ale/handlers/rust.vim
@@ -32,7 +32,7 @@ function! ale#handlers#rust#HandleRustErrors(buffer, lines) abort
 
         let l:error = json_decode(l:errorline)
 
-        if has_key(l:error, 'message') && type(l:error.message) == type({})
+        if has_key(l:error, 'message') && type(l:error.message) is v:t_dict
             let l:error = l:error.message
         endif
 
diff --git a/autoload/ale/hover.vim b/autoload/ale/hover.vim
index 5e97e16e..dc97ff41 100644
--- a/autoload/ale/hover.vim
+++ b/autoload/ale/hover.vim
@@ -63,19 +63,19 @@ function! ale#hover#HandleLSPResponse(conn_id, response) abort
 
         let l:result = l:result.contents
 
-        if type(l:result) is type('')
+        if type(l:result) is v:t_string
              " The result can be just a string.
              let l:result = [l:result]
         endif
 
-        if type(l:result) is type({})
+        if type(l:result) is v:t_dict
             " If the result is an object, then it's markup content.
             let l:result = [l:result.value]
         endif
 
-        if type(l:result) is type([])
+        if type(l:result) is v:t_list
             " Replace objects with text values.
-            call map(l:result, 'type(v:val) is type('''') ? v:val : v:val.value')
+            call map(l:result, 'type(v:val) is v:t_string ? v:val : v:val.value')
             let l:str = join(l:result, "\n")
             let l:str = substitute(l:str, '^\s*\(.\{-}\)\s*$', '\1', '')
 
diff --git a/autoload/ale/linter.vim b/autoload/ale/linter.vim
index aa602f7e..683d506a 100644
--- a/autoload/ale/linter.vim
+++ b/autoload/ale/linter.vim
@@ -57,11 +57,11 @@ function! ale#linter#GetLintersLoaded() abort
 endfunction
 
 function! s:IsCallback(value) abort
-    return type(a:value) == type('') || type(a:value) == type(function('type'))
+    return type(a:value) is v:t_string || type(a:value) is v:t_func
 endfunction
 
 function! s:IsBoolean(value) abort
-    return type(a:value) == type(0) && (a:value == 0 || a:value == 1)
+    return type(a:value) is v:t_number && (a:value == 0 || a:value == 1)
 endfunction
 
 function! s:LanguageGetter(buffer) dict abort
@@ -69,7 +69,7 @@ function! s:LanguageGetter(buffer) dict abort
 endfunction
 
 function! ale#linter#PreProcess(filetype, linter) abort
-    if type(a:linter) != type({})
+    if type(a:linter) isnot v:t_dict
         throw 'The linter object must be a Dictionary'
     endif
 
@@ -79,7 +79,7 @@ function! ale#linter#PreProcess(filetype, linter) abort
     \   'lsp': get(a:linter, 'lsp', ''),
     \}
 
-    if type(l:obj.name) != type('')
+    if type(l:obj.name) isnot v:t_string
         throw '`name` must be defined to name the linter'
     endif
 
@@ -114,7 +114,7 @@ function! ale#linter#PreProcess(filetype, linter) abort
     elseif has_key(a:linter, 'executable')
         let l:obj.executable = a:linter.executable
 
-        if type(l:obj.executable) != type('')
+        if type(l:obj.executable) isnot v:t_string
             throw '`executable` must be a string if defined'
         endif
     else
@@ -130,7 +130,7 @@ function! ale#linter#PreProcess(filetype, linter) abort
     elseif has_key(a:linter, 'command_chain')
         let l:obj.command_chain = a:linter.command_chain
 
-        if type(l:obj.command_chain) != type([])
+        if type(l:obj.command_chain) isnot v:t_list
             throw '`command_chain` must be a List'
         endif
 
@@ -148,7 +148,7 @@ function! ale#linter#PreProcess(filetype, linter) abort
             endif
 
             if has_key(l:link, 'output_stream')
-                if type(l:link.output_stream) != type('')
+                if type(l:link.output_stream) isnot v:t_string
                 \|| index(['stdout', 'stderr', 'both'], l:link.output_stream) < 0
                     throw l:err_prefix . '`output_stream` flag must be '
                     \   . "'stdout', 'stderr', or 'both'"
@@ -170,7 +170,7 @@ function! ale#linter#PreProcess(filetype, linter) abort
     elseif has_key(a:linter, 'command')
         let l:obj.command = a:linter.command
 
-        if type(l:obj.command) != type('')
+        if type(l:obj.command) isnot v:t_string
             throw '`command` must be a string if defined'
         endif
     else
@@ -217,7 +217,7 @@ function! ale#linter#PreProcess(filetype, linter) abort
             " Default to using the filetype as the language.
             let l:obj.language = get(a:linter, 'language', a:filetype)
 
-            if type(l:obj.language) != type('')
+            if type(l:obj.language) isnot v:t_string
                 throw '`language` must be a string'
             endif
 
@@ -257,7 +257,7 @@ function! ale#linter#PreProcess(filetype, linter) abort
 
     let l:obj.output_stream = get(a:linter, 'output_stream', 'stdout')
 
-    if type(l:obj.output_stream) != type('')
+    if type(l:obj.output_stream) isnot v:t_string
     \|| index(['stdout', 'stderr', 'both'], l:obj.output_stream) < 0
         throw "`output_stream` must be 'stdout', 'stderr', or 'both'"
     endif
@@ -283,8 +283,8 @@ function! ale#linter#PreProcess(filetype, linter) abort
 
     let l:obj.aliases = get(a:linter, 'aliases', [])
 
-    if type(l:obj.aliases) != type([])
-    \|| len(filter(copy(l:obj.aliases), 'type(v:val) != type('''')')) > 0
+    if type(l:obj.aliases) isnot v:t_list
+    \|| len(filter(copy(l:obj.aliases), 'type(v:val) isnot v:t_string')) > 0
         throw '`aliases` must be a List of String values'
     endif
 
@@ -336,7 +336,7 @@ function! s:GetAliasedFiletype(original_filetype) abort
     let l:buffer_aliases = get(b:, 'ale_linter_aliases', {})
 
     " b:ale_linter_aliases can be set to a List.
-    if type(l:buffer_aliases) is type([])
+    if type(l:buffer_aliases) is v:t_list
         return l:buffer_aliases
     endif
 
@@ -360,7 +360,7 @@ endfunction
 function! ale#linter#ResolveFiletype(original_filetype) abort
     let l:filetype = s:GetAliasedFiletype(a:original_filetype)
 
-    if type(l:filetype) != type([])
+    if type(l:filetype) isnot v:t_list
         return [l:filetype]
     endif
 
@@ -376,7 +376,7 @@ function! s:GetLinterNames(original_filetype) abort
     endif
 
     " b:ale_linters can be set to a List.
-    if type(l:buffer_ale_linters) is type([])
+    if type(l:buffer_ale_linters) is v:t_list
         return l:buffer_ale_linters
     endif
 
@@ -414,9 +414,9 @@ function! ale#linter#Get(original_filetypes) abort
         let l:all_linters = ale#linter#GetAll(l:filetype)
         let l:filetype_linters = []
 
-        if type(l:linter_names) == type('') && l:linter_names is# 'all'
+        if type(l:linter_names) is v:t_string && l:linter_names is# 'all'
             let l:filetype_linters = l:all_linters
-        elseif type(l:linter_names) == type([])
+        elseif type(l:linter_names) is v:t_list
             " Select only the linters we or the user has specified.
             for l:linter in l:all_linters
                 let l:name_list = [l:linter.name] + l:linter.aliases
diff --git a/autoload/ale/lsp.vim b/autoload/ale/lsp.vim
index 312319ab..5d900138 100644
--- a/autoload/ale/lsp.vim
+++ b/autoload/ale/lsp.vim
@@ -213,7 +213,7 @@ endfunction
 " Update capabilities from the server, so we know which features the server
 " supports.
 function! s:UpdateCapabilities(conn, capabilities) abort
-    if type(a:capabilities) != type({})
+    if type(a:capabilities) isnot v:t_dict
         return
     endif
 
@@ -229,10 +229,10 @@ function! s:UpdateCapabilities(conn, capabilities) abort
         let a:conn.capabilities.completion = 1
     endif
 
-    if type(get(a:capabilities, 'completionProvider')) is type({})
+    if type(get(a:capabilities, 'completionProvider')) is v:t_dict
         let l:chars = get(a:capabilities.completionProvider, 'triggerCharacters')
 
-        if type(l:chars) is type([])
+        if type(l:chars) is v:t_list
             let a:conn.capabilities.completion_trigger_characters = l:chars
         endif
     endif
@@ -275,7 +275,7 @@ function! ale#lsp#HandleOtherInitializeResponses(conn, response) abort
 endfunction
 
 function! ale#lsp#HandleMessage(conn, message) abort
-    if type(a:message) != type('')
+    if type(a:message) isnot v:t_string
         " Ignore messages that aren't strings.
         return
     endif
@@ -548,7 +548,7 @@ function! ale#lsp#WaitForCapability(conn_id, project_root, capability, callback)
         return 0
     endif
 
-    if type(get(l:conn.capabilities, a:capability, v:null)) isnot type(0)
+    if type(get(l:conn.capabilities, a:capability, v:null)) isnot v:t_number
         throw 'Invalid capability ' . a:capability
     endif
 
diff --git a/autoload/ale/lsp/response.vim b/autoload/ale/lsp/response.vim
index 3ac65388..48740ad1 100644
--- a/autoload/ale/lsp/response.vim
+++ b/autoload/ale/lsp/response.vim
@@ -88,7 +88,7 @@ function! ale#lsp#response#ReadTSServerDiagnostics(response) abort
 endfunction
 
 function! ale#lsp#response#GetErrorMessage(response) abort
-    if type(get(a:response, 'error', 0)) isnot type({})
+    if type(get(a:response, 'error', 0)) isnot v:t_dict
         return ''
     endif
 
@@ -108,12 +108,12 @@ function! ale#lsp#response#GetErrorMessage(response) abort
     " Include the traceback or error data as details, if present.
     let l:error_data = get(a:response.error, 'data', {})
 
-    if type(l:error_data) is type('')
+    if type(l:error_data) is v:t_string
         let l:message .= "\n" . l:error_data
     else
         let l:traceback = get(l:error_data, 'traceback', [])
 
-        if type(l:traceback) is type([]) && !empty(l:traceback)
+        if type(l:traceback) is v:t_list && !empty(l:traceback)
             let l:message .= "\n" . join(l:traceback, "\n")
         endif
     endif
diff --git a/autoload/ale/sign.vim b/autoload/ale/sign.vim
index a0dde359..af863682 100644
--- a/autoload/ale/sign.vim
+++ b/autoload/ale/sign.vim
@@ -211,7 +211,7 @@ function! s:BuildSignMap(buffer, current_sign_list, grouped_items) abort
 
     if l:max_signs is 0
         let l:selected_grouped_items = []
-    elseif type(l:max_signs) is type(0) && l:max_signs > 0
+    elseif type(l:max_signs) is v:t_number && l:max_signs > 0
         let l:selected_grouped_items = a:grouped_items[:l:max_signs - 1]
     else
         let l:selected_grouped_items = a:grouped_items
diff --git a/autoload/ale/util.vim b/autoload/ale/util.vim
index fb6dc085..879c983a 100644
--- a/autoload/ale/util.vim
+++ b/autoload/ale/util.vim
@@ -79,7 +79,7 @@ function! ale#util#GetLineCount(buffer) abort
 endfunction
 
 function! ale#util#GetFunction(string_or_ref) abort
-    if type(a:string_or_ref) == type('')
+    if type(a:string_or_ref) is v:t_string
         return function(a:string_or_ref)
     endif
 
@@ -303,8 +303,8 @@ endfunction
 " Only the first pattern which matches a line will be returned.
 function! ale#util#GetMatches(lines, patterns) abort
     let l:matches = []
-    let l:lines = type(a:lines) == type([]) ? a:lines : [a:lines]
-    let l:patterns = type(a:patterns) == type([]) ? a:patterns : [a:patterns]
+    let l:lines = type(a:lines) is v:t_list ? a:lines : [a:lines]
+    let l:patterns = type(a:patterns) is v:t_list ? a:patterns : [a:patterns]
 
     for l:line in l:lines
         for l:pattern in l:patterns
@@ -382,7 +382,7 @@ function! ale#util#FuzzyJSONDecode(data, default) abort
         return a:default
     endif
 
-    let l:str = type(a:data) == type('') ? a:data : join(a:data, '')
+    let l:str = type(a:data) is v:t_string ? a:data : join(a:data, '')
 
     try
         let l:result = json_decode(l:str)
diff --git a/test/script/custom-linting-rules b/test/script/custom-linting-rules
index e1b07624..7aafe995 100755
--- a/test/script/custom-linting-rules
+++ b/test/script/custom-linting-rules
@@ -78,6 +78,17 @@ if (( FIX_ERRORS )); then
         sed -i 's/==?/is?/g' "$directory"/**/*.vim
         sed -i 's/!=#/isnot#/g' "$directory"/**/*.vim
         sed -i 's/!=?/isnot?/g' "$directory"/**/*.vim
+        # Improving type checks.
+        sed -i $'s/\\(==.\\?\\|is\\) type([\'"]\+)/is v:t_string/g' "$directory"/**/*.vim
+        sed -i 's/\(==.\?\|is\) type([0-9]\+)/is v:t_number/g' "$directory"/**/*.vim
+        sed -i 's/\(==.\?\|is\) type(\[\])/is v:t_list/g' "$directory"/**/*.vim
+        sed -i 's/\(==.\?\|is\) type({})/is v:t_dict/g' "$directory"/**/*.vim
+        sed -i 's/\(==.\?\|is\) type(function([^)]\+))/is v:t_func/g' "$directory"/**/*.vim
+        sed -i $'s/\\(!=.\\?\\|isnot\\) type([\'"]\+)/isnot v:t_string/g' "$directory"/**/*.vim
+        sed -i 's/\(!=.\?\|isnot\) type([0-9]\+)/isnot v:t_number/g' "$directory"/**/*.vim
+        sed -i 's/\(!=.\?\|isnot\) type(\[\])/isnot v:t_list/g' "$directory"/**/*.vim
+        sed -i 's/\(!=.\?\|isnot\) type({})/isnot v:t_dict/g' "$directory"/**/*.vim
+        sed -i 's/\(!=.\?\|isnot\) type(function([^)]\+))/isnot v:t_func/g' "$directory"/**/*.vim
     done
 fi
 
@@ -103,5 +114,16 @@ check_errors '!=#' "Use 'isnot#' instead of '!=#'. 0 !=# 'foobar' is false"
 check_errors '!=?' "Use 'isnot?' instead of '!=?'. 0 !=? 'foobar' is false"
 check_errors '^ *:\?echo' "Stray echo line. Use \`execute echo\` if you want to echo something"
 check_errors $'name.:.*\'[a-z_]*[^a-z_0-9][a-z_0-9]*\',$' 'Use snake_case names for linters' '*/ale_linters/*'
+# Checks for improving type checks.
+check_errors $'\\(==.\\?\\|is\\) type([\'"]\+)' "Use 'is v:t_string' instead"
+check_errors '\(==.\?\|is\) type([0-9]\+)' "Use 'is v:t_number' instead"
+check_errors '\(==.\?\|is\) type(\[\])' "Use 'is v:t_list' instead"
+check_errors '\(==.\?\|is\) type({})' "Use 'is v:t_dict' instead"
+check_errors '\(==.\?\|is\) type(function([^)]\+))' "Use 'is v:t_func' instead"
+check_errors $'\\(!=.\\?\\|isnot\\) type([\'"]\+)' "Use 'isnot v:t_string' instead"
+check_errors '\(!=.\?\|isnot\) type([0-9]\+)' "Use 'isnot v:t_number' instead"
+check_errors '\(!=.\?\|isnot\) type(\[\])' "Use 'isnot v:t_list' instead"
+check_errors '\(!=.\?\|isnot\) type({})' "Use 'isnot v:t_dict' instead"
+check_errors '\(!=.\?\|isnot\) type(function([^)]\+))' "Use 'isnot v:t_func' instead"
 
 exit $RETURN_CODE