Update

* Make the number of packages in the project easier to find.
* Replace `ed` with `awk` in `update_readme()`, the latter being (_arguably_!) more readable/less fragile.

README.md

@@ -1,4 +1,4 @@
-# vim-polyglot [![Build Status][travis-img-url]][travis-url] [![Maintenance](https://img.shields.io/maintenance/yes/2017.svg?maxAge=2592000)]()
+# vim-polyglot [![Build Status][travis-img-url]][travis-url] [![Maintenance](https://img.shields.io/maintenance/yes/2018.svg?maxAge=2592000)]()
 
 [travis-img-url]: https://travis-ci.org/sheerun/vim-polyglot.svg
 [travis-url]: https://travis-ci.org/sheerun/vim-polyglot
@@ -8,7 +8,7 @@ A collection of language packs for Vim.
 > One to rule them all, one to find them, one to bring them all and in the darkness bind them.
 
 - It **won't affect your startup time**, as scripts are loaded only on demand\*.
-- It **installs and updates 100+ times faster** than 100+ packages it consists of.
+- It **installs and updates 100+ times faster** than the <!--Package Count-->114<!--/Package Count--> packages it consists of.
 - Solid syntax and indentation support (other features skipped). Only the best language packs.
 - All unnecessary files are ignored (like enormous documentation from php support).
 - No support for esoteric languages, only most popular ones (modern too, like `slim`).
@@ -21,6 +21,12 @@ A collection of language packs for Vim.
 1. Install [Pathogen](https://github.com/tpope/vim-pathogen), [Vundle](https://github.com/VundleVim/Vundle.vim), [NeoBundle](https://github.com/Shougo/neobundle.vim), or [Plug](https://github.com/junegunn/vim-plug) package manager for Vim.
 2. Use this repository as submodule or package.
 
+For example when using [Plug](https://github.com/junegunn/vim-plug):
+
+```
+Plug 'sheerun/vim-polyglot'
+```
+
 Optionally download one of the [releases](https://github.com/sheerun/vim-polyglot/releases) and unpack it directly under `~/.vim` directory.
 
 You can also use Vim 8 built-in package manager:
@@ -36,9 +42,10 @@ If you need full functionality of any plugin, please use it directly with your p
 
 ## Language packs
 
+<!--Language Packs-->
 - [ansible](https://github.com/pearofducks/ansible-vim) (syntax, indent, ftplugin)
 - [apiblueprint](https://github.com/sheerun/apiblueprint.vim) (syntax)
-- [applescript](https://github.com/vim-scripts/applescript.vim) (syntax)
+- [applescript](https://github.com/mityu/vim-applescript) (syntax, indent)
 - [arduino](https://github.com/sudar/vim-arduino-syntax) (syntax, indent)
 - [asciidoc](https://github.com/asciidoc/vim-asciidoc) (syntax)
 - [autohotkey](https://github.com/hnamikaw/vim-autohotkey) (indent)
@@ -46,6 +53,7 @@ If you need full functionality of any plugin, please use it directly with your p
 - [c++11](https://github.com/octol/vim-cpp-enhanced-highlight) (syntax)
 - [c/c++](https://github.com/vim-jp/vim-cpp) (syntax)
 - [caddyfile](https://github.com/isobit/vim-caddyfile) (syntax, indent, ftplugin)
+- [carp](https://github.com/hellerve/carp-vim) (syntax)
 - [cjsx](https://github.com/mtscout6/vim-cjsx) (syntax, ftplugin)
 - [clojure](https://github.com/guns/vim-clojure-static) (syntax, indent, autoload, ftplugin)
 - [cmake](https://github.com/pboettch/vim-cmake-syntax) (syntax, indent)
@@ -61,6 +69,7 @@ If you need full functionality of any plugin, please use it directly with your p
 - [emberscript](https://github.com/yalesov/vim-ember-script) (syntax, indent, ftplugin)
 - [emblem](https://github.com/yalesov/vim-emblem) (syntax, indent, ftplugin)
 - [erlang](https://github.com/vim-erlang/vim-erlang-runtime) (syntax, indent)
+- [ferm](https://github.com/vim-scripts/ferm.vim) (syntax)
 - [fish](https://github.com/dag/vim-fish) (syntax, indent, compiler, autoload, ftplugin)
 - [fsharp](https://github.com/fsharp/vim-fsharp) (syntax, indent)
 - [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin)
@@ -68,9 +77,11 @@ If you need full functionality of any plugin, please use it directly with your p
 - [gmpl](https://github.com/maelvalais/gmpl.vim) (syntax)
 - [gnuplot](https://github.com/vim-scripts/gnuplot-syntax-highlighting) (syntax)
 - [go](https://github.com/fatih/vim-go) (syntax, compiler, indent)
+- [graphql](https://github.com/jparise/vim-graphql) (syntax, indent, ftplugin)
 - [groovy](https://github.com/vim-scripts/groovy.vim) (syntax)
 - [haml](https://github.com/sheerun/vim-haml) (syntax, indent, compiler, ftplugin)
 - [handlebars](https://github.com/mustache/vim-mustache-handlebars) (syntax, indent, ftplugin)
+- [haproxy](https://github.com/CH-DanReif/haproxy.vim) (syntax)
 - [haskell](https://github.com/neovimhaskell/haskell-vim) (syntax, indent, ftplugin)
 - [haxe](https://github.com/yaymukund/vim-haxe) (syntax)
 - [html5](https://github.com/othree/html5.vim) (syntax, indent, autoload, ftplugin)
@@ -78,10 +89,11 @@ If you need full functionality of any plugin, please use it directly with your p
 - [jasmine](https://github.com/glanotte/vim-jasmine) (syntax)
 - [javascript](https://github.com/pangloss/vim-javascript) (syntax, indent, compiler, ftplugin, extras)
 - [jenkins](https://github.com/martinda/Jenkinsfile-vim-syntax) (syntax, indent)
+- [json5](https://github.com/GutenYe/json5.vim) (syntax)
 - [json](https://github.com/elzr/vim-json) (syntax, indent, ftplugin)
 - [jst](https://github.com/briancollins/vim-jst) (syntax, indent)
 - [jsx](https://github.com/mxw/vim-jsx) (after)
-- [julia](https://github.com/dcjones/julia-minimalist-vim) (syntax, indent)
+- [julia](https://github.com/JuliaEditorSupport/julia-vim) (syntax, indent, autoload, ftplugin)
 - [kotlin](https://github.com/udalov/kotlin-vim) (syntax, indent)
 - [latex](https://github.com/LaTeX-Box-Team/LaTeX-Box) (syntax, indent, ftplugin)
 - [less](https://github.com/groenewege/vim-less) (syntax, indent, ftplugin)
@@ -89,11 +101,11 @@ If you need full functionality of any plugin, please use it directly with your p
 - [livescript](https://github.com/gkz/vim-ls) (syntax, indent, compiler, ftplugin)
 - [lua](https://github.com/tbastos/vim-lua) (syntax, indent)
 - [mako](https://github.com/sophacles/vim-bundle-mako) (syntax, indent, ftplugin)
-- [markdown](https://github.com/plasticboy/vim-markdown) (syntax)
+- [markdown](https://github.com/plasticboy/vim-markdown) (syntax, indent)
 - [mathematica](https://github.com/rsmenon/vim-mathematica) (syntax, ftplugin)
 - [nginx](https://github.com/chr4/nginx.vim) (syntax, indent, ftplugin)
 - [nim](https://github.com/zah/nim.vim) (syntax, compiler, indent)
-- [nix](https://github.com/LnL7/vim-nix) (syntax, indent, ftplugin)
+- [nix](https://github.com/LnL7/vim-nix) (syntax, indent, compiler, ftplugin)
 - [objc](https://github.com/b4winckler/vim-objc) (ftplugin, syntax, indent)
 - [ocaml](https://github.com/jrk/vim-ocaml) (syntax, indent, ftplugin)
 - [octave](https://github.com/vim-scripts/octave.vim--) (syntax)
@@ -108,7 +120,8 @@ If you need full functionality of any plugin, please use it directly with your p
 - [puppet](https://github.com/voxpupuli/vim-puppet) (syntax, indent, ftplugin)
 - [purescript](https://github.com/purescript-contrib/purescript-vim) (syntax, indent, ftplugin)
 - [python-compiler](https://github.com/aliev/vim-compiler-python) (compiler, autoload)
-- [python](https://github.com/mitsuhiko/vim-python-combined) (syntax, indent)
+- [python-ident](https://github.com/Vimjas/vim-python-pep8-indent) (indent)
+- [python](https://github.com/vim-python/python-syntax) (syntax)
 - [qml](https://github.com/peterhoeg/vim-qml) (syntax, indent, ftplugin)
 - [r-lang](https://github.com/vim-scripts/R.vim) (syntax, ftplugin)
 - [racket](https://github.com/wlangstroth/vim-racket) (syntax, indent, autoload, ftplugin)
@@ -121,11 +134,12 @@ If you need full functionality of any plugin, please use it directly with your p
 - [scala](https://github.com/derekwyatt/vim-scala) (syntax, indent, compiler, ftplugin)
 - [scss](https://github.com/cakebaker/scss-syntax.vim) (syntax, autoload, ftplugin)
 - [slim](https://github.com/slim-template/vim-slim) (syntax, indent, ftplugin)
+- [slime](https://github.com/slime-lang/vim-slime-syntax) (syntax, indent)
 - [solidity](https://github.com/tomlion/vim-solidity) (syntax, indent, ftplugin)
 - [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin)
 - [swift](https://github.com/keith/swift.vim) (syntax, indent, ftplugin)
 - [sxhkd](https://github.com/baskerville/vim-sxhkdrc) (syntax)
-- [systemd](https://github.com/kurayama/systemd-vim-syntax) (syntax)
+- [systemd](https://github.com/wgwoods/vim-systemd-syntax) (syntax)
 - [terraform](https://github.com/hashivim/vim-terraform) (syntax, indent, ftplugin)
 - [textile](https://github.com/timcharper/textile.vim) (syntax, ftplugin)
 - [thrift](https://github.com/solarnz/thrift.vim) (syntax)
@@ -143,6 +157,7 @@ If you need full functionality of any plugin, please use it directly with your p
 - [xls](https://github.com/vim-scripts/XSLT-syntax) (syntax)
 - [yaml](https://github.com/stephpy/vim-yaml) (syntax, ftplugin)
 - [yard](https://github.com/sheerun/vim-yardoc) (syntax)
+<!--/Language Packs-->
 
 ## Updating
 
@@ -159,13 +174,18 @@ Individual language packs can be disabled by setting `g:polyglot_disabled` as fo
 let g:polyglot_disabled = ['css']
 ```
 
-Note that disabiling languages won't make in general your vim startup any faster / slower (only for specific file type). Vim-polyglot is selection of language plugins that are loaded only on demand.
+Note that disabling languages won't make in general your vim startup any faster / slower (only for specific file type). Vim-polyglot is selection of language plugins that are loaded only on demand.
 
 ## Contributing
 
 Language packs are periodically updated using automated `build` script.
 
-Feel free to add your language, and send pull-request.
+Feel free to add your language, and send pull-request.  In your pull request, please include:
+1. How you chose the particular repo from which to pull support for this language.
+2. An updated https://github.com/sheerun/vim-polyglot/blob/master/build .
+3. If at all possible, absolutely nothing else (in particular, please don't run `build` and include that in your PR).
+
+The easier it is to validate that the new language won't do anything wacky, the faster it'll be merged.  In particular, languages that utilize global plugins (loaded for every filetype), or plugins with dangerous features (like `call` based on the contents of a file being edited), will never be merged, as they will be slow or dangerous, respectively.
 
 ## License
 

after/ftplugin/jsx.vim

@@ -11,8 +11,11 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'jsx') == -1
 " modified from html.vim
 if exists("loaded_matchit")
   let b:match_ignorecase = 0
-  let b:match_words = '(:),\[:\],{:},<:>,' .
+  let s:jsx_match_words = '(:),\[:\],{:},<:>,' .
         \ '<\@<=\([^/][^ \t>]*\)[^>]*\%(/\@<!>\|$\):<\@<=/\1>'
+  let b:match_words = exists('b:match_words')
+    \ ? b:match_words . ',' . s:jsx_match_words
+    \ : s:jsx_match_words
 endif
 
 setlocal suffixesadd+=.jsx

after/ftplugin/terraform.vim

@@ -8,6 +8,10 @@ if !exists('g:terraform_remap_spacebar')
   let g:terraform_remap_spacebar = 0
 endif
 
+if !exists('g:terraform_fold_sections')
+  let g:terraform_fold_sections = 0
+endif
+
 if g:terraform_align && exists(':Tabularize')
   inoremap <buffer> <silent> = =<Esc>:call <SID>terraformalign()<CR>a
   function! s:terraformalign()
@@ -22,38 +26,39 @@ if g:terraform_align && exists(':Tabularize')
   endfunction
 endif
 
+if g:terraform_fold_sections
+  function! TerraformFolds()
+    let thisline = getline(v:lnum)
+    if match(thisline, '^resource') >= 0
+      return ">1"
+    elseif match(thisline, '^provider') >= 0
+      return ">1"
+    elseif match(thisline, '^module') >= 0
+      return ">1"
+    elseif match(thisline, '^variable') >= 0
+      return ">1"
+    elseif match(thisline, '^output') >= 0
+      return ">1"
+    elseif match(thisline, '^data') >= 0
+      return ">1"
+    elseif match(thisline, '^terraform') >= 0
+      return ">1"
+    elseif match(thisline, '^locals') >= 0
+      return ">1"
+    else
+      return "="
+    endif
+  endfunction
+  setlocal foldmethod=expr
+  setlocal foldexpr=TerraformFolds()
+  setlocal foldlevel=1
 
-function! TerraformFolds()
-  let thisline = getline(v:lnum)
-  if match(thisline, '^resource') >= 0
-    return ">1"
-  elseif match(thisline, '^provider') >= 0
-    return ">1"
-  elseif match(thisline, '^module') >= 0
-    return ">1"
-  elseif match(thisline, '^variable') >= 0
-    return ">1"
-  elseif match(thisline, '^output') >= 0
-    return ">1"
-  elseif match(thisline, '^data') >= 0
-    return ">1"
-  elseif match(thisline, '^terraform') >= 0
-    return ">1"
-  elseif match(thisline, '^locals') >= 0
-    return ">1"
-  else
-    return "="
-  endif
-endfunction
-setlocal foldmethod=expr
-setlocal foldexpr=TerraformFolds()
-setlocal foldlevel=1
-
-function! TerraformFoldText()
-  let foldsize = (v:foldend-v:foldstart)
-  return getline(v:foldstart).' ('.foldsize.' lines)'
-endfunction
-setlocal foldtext=TerraformFoldText()
+  function! TerraformFoldText()
+    let foldsize = (v:foldend-v:foldstart)
+    return getline(v:foldstart).' ('.foldsize.' lines)'
+  endfunction
+  setlocal foldtext=TerraformFoldText()
+endif
 
 " Re-map the space bar to fold and unfold
 if get(g:, "terraform_remap_spacebar", 1)
@@ -70,5 +75,11 @@ if get(g:, "terraform_align", 1)
   setlocal shiftwidth=2
 endif
 
+" Set the commentstring
+if exists('g:terraform_commentstring')
+    let &l:commentstring=g:terraform_commentstring
+else
+    setlocal commentstring=#%s
+endif
 
 endif

after/syntax/c.vim

@@ -21,7 +21,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'c++11') == -1
 "  Highlight function names.
 " -----------------------------------------------------------------------------
 if !exists('g:cpp_no_function_highlight')
-    syn match    cCustomParen    "(" contains=cParen contains=cCppParen
+    syn match    cCustomParen    transparent "(" contains=cParen contains=cCppParen
     syn match    cCustomFunc     "\w\+\s*(\@=" contains=cCustomParen
     hi def link cCustomFunc  Function
 endif
@@ -32,7 +32,7 @@ endif
 if exists('g:cpp_member_variable_highlight') && g:cpp_member_variable_highlight
     syn match   cCustomDot    "\." contained
     syn match   cCustomPtr    "->" contained
-    syn match   cCustomMemVar "\(\.\|->\)\w\+" contains=cCustomDot,cCustomPtr
+    syn match   cCustomMemVar "\(\.\|->\)\h\w*" contains=cCustomDot,cCustomPtr
     hi def link cCustomMemVar Function
 endif
 

after/syntax/cpp.vim

@@ -4,7 +4,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'c++11') == -1
 " Language: C++ Additions
 " Maintainer: Jon Haggblad <jon@haeggblad.com>
 " URL: http://www.haeggblad.com
-" Last Change: 12 Oct 2016
+" Last Change: 1 Feb 2018
 " Version: 0.6
 " Changelog:
 "   0.1 - initial version.
@@ -37,7 +37,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'c++11') == -1
 
 " Functions
 if !exists('g:cpp_no_function_highlight')
-    syn match   cCustomParen    "(" contains=cParen contains=cCppParen
+    syn match   cCustomParen    transparent "(" contains=cParen contains=cCppParen
     syn match   cCustomFunc     "\w\+\s*(\@="
     hi def link cCustomFunc  Function
 endif
@@ -855,6 +855,37 @@ syntax keyword cppSTLconstant WEOF
 syntax keyword cppSTLconstant WCHAR_MIN
 syntax keyword cppSTLconstant WCHAR_MAX
 
+" locale
+syntax keyword cppSTLtype locale
+syntax keyword cppSTLtype ctype_base
+syntax keyword cppSTLtype codecvt_base
+syntax keyword cppSTLtype messages_base
+syntax keyword cppSTLtype time_base
+syntax keyword cppSTLtype money_base
+syntax keyword cppSTLtype ctype
+syntax keyword cppSTLtype codecvt
+syntax keyword cppSTLtype collate
+syntax keyword cppSTLtype messages
+syntax keyword cppSTLtype time_get
+syntax keyword cppSTLtype time_put
+syntax keyword cppSTLtype num_get
+syntax keyword cppSTLtype num_put
+syntax keyword cppSTLtype numpunct
+syntax keyword cppSTLtype money_get
+syntax keyword cppSTLtype money_put
+syntax keyword cppSTLtype moneypunct
+syntax keyword cppSTLtype ctype_byname
+syntax keyword cppSTLtype codecvt_byname
+syntax keyword cppSTLtype messages_byname
+syntax keyword cppSTLtype collate_byname
+syntax keyword cppSTLtype time_get_byname
+syntax keyword cppSTLtype time_put_byname
+syntax keyword cppSTLtype numpunct_byname
+syntax keyword cppSTLtype moneypunct_byname
+syntax keyword cppSTLfunction use_facet
+syntax keyword cppSTLfunction has_facet
+syntax keyword cppSTLfunction isspace isblank iscntrl isupper islower isalpha
+syntax keyword cppSTLfunction isdigit ispunct isxdigit isalnum isprint isgraph
 
 if !exists("cpp_no_cpp11")
     syntax keyword cppSTLconstant nullptr
@@ -1766,6 +1797,9 @@ if !exists("cpp_no_cpp17")
     syntax keyword cppSTLfunction do_deallocate
     syntax keyword cppSTLfunction do_is_equal
 
+    " mutex
+    syntax keyword cppSTLtype scoped_lock
+
     " new
     syntax keyword cppSTLconstant hardware_destructive_interference_size
     syntax keyword cppSTLconstant hardware_constructive_interference_size
@@ -1804,7 +1838,7 @@ if !exists("cpp_no_cpp17")
     syntax keyword cppSTLbool is_error_code_enum_v
     syntax keyword cppSTLbool is_error_condition_enum_v
 
-    " thread
+    " shared_mutex
     syntax keyword cppSTLtype shared_mutex
 
     " tuple
@@ -1879,6 +1913,16 @@ if !exists("cpp_no_cpp17")
     syntax keyword cppSTLbool conjunction_v
     syntax keyword cppSTLbool disjunction_v
     syntax keyword cppSTLbool negation_v
+    syntax keyword cppSTLbool has_unique_object_representations_v
+    syntax keyword cppSTLbool is_swappable_v
+    syntax keyword cppSTLbool is_swappable_with_v
+    syntax keyword cppSTLbool is_nothrow_swappable_v
+    syntax keyword cppSTLbool is_nothrow_swappable_with_v
+    syntax keyword cppSTLbool is_invocable_v
+    syntax keyword cppSTLbool is_invocable_r_v
+    syntax keyword cppSTLbool is_nothrow_invocable_v
+    syntax keyword cppSTLbool is_nothrow_invocable_r_v
+    syntax keyword cppSTLbool is_aggregate_v
     syntax keyword cppSTLconstant alignment_of_v
     syntax keyword cppSTLconstant rank_v
     syntax keyword cppSTLconstant extent_v
@@ -1888,6 +1932,19 @@ if !exists("cpp_no_cpp17")
     syntax keyword cppSTLtype conjunction
     syntax keyword cppSTLtype disjunction
     syntax keyword cppSTLtype negation
+    syntax keyword cppSTLtype void_t
+    syntax keyword cppSTLtype has_unique_object_representations
+    syntax keyword cppSTLtype is_swappable
+    syntax keyword cppSTLtype is_swappable_with
+    syntax keyword cppSTLtype is_nothrow_swappable
+    syntax keyword cppSTLtype is_nothrow_swappable_with
+    syntax keyword cppSTLtype is_invocable
+    syntax keyword cppSTLtype is_invocable_r
+    syntax keyword cppSTLtype is_nothrow_invocable
+    syntax keyword cppSTLtype is_nothrow_invocable_r
+    syntax keyword cppSTLtype invoke_result
+    syntax keyword cppSTLtype invoke_result_t
+    syntax keyword cppSTLtype is_aggregate
 
     " unordered_map, unordered_set, unordered_multimap, unordered_multiset
     syntax keyword cppSTLtype node_type
@@ -1921,6 +1978,12 @@ if !exists("cpp_no_cpp17")
 endif " C++17
 
 
+if !exists("cpp_no_cpp20")
+    " type_traits
+    syntax keyword cppSTLtype remove_cvref remove_cvref_t
+endif
+
+
 if exists('g:cpp_concepts_highlight') && g:cpp_concepts_highlight
     syntax keyword cppStatement concept
     syntax keyword cppStorageClass requires

after/syntax/javascript/graphql.vim

@@ -0,0 +1,27 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+  
+if exists('b:current_syntax')
+  let s:current_syntax = b:current_syntax
+  unlet b:current_syntax
+endif
+syn include @GraphQLSyntax syntax/graphql.vim
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+let s:tags = '\%(' . join(g:graphql_javascript_tags, '\|') . '\)'
+
+exec 'syntax region graphqlTemplateString start=+' . s:tags . '\@20<=`+ skip=+\\`+ end=+`+ contains=@GraphQLSyntax,jsTemplateExpression,jsSpecial extend'
+exec 'syntax match graphqlTaggedTemplate +' . s:tags . '\ze`+ nextgroup=graphqlTemplateString'
+
+" Support expression interpolation ((${...})) inside template strings.
+syntax region graphqlTemplateExpression start=+${+ end=+}+ contained contains=jsTemplateExpression containedin=graphqlFold keepend
+
+hi def link graphqlTemplateString jsTemplateString
+hi def link graphqlTaggedTemplate jsTaggedTemplate
+hi def link graphqlTemplateExpression jsTemplateExpression
+
+syn cluster jsExpression add=graphqlTaggedTemplate
+syn cluster graphqlTaggedTemplate add=graphqlTemplateString
+
+endif

after/syntax/jsx.vim

@@ -36,6 +36,10 @@ endif
 " jsBlock take care of ending the region.
 syn region xmlString contained start=+{+ end=++ contains=jsBlock,javascriptBlock
 
+" JSX comments inside XML tag should color as comment.  Note the trivial end pattern; we let
+" jsComment take care of ending the region.
+syn region xmlString contained start=+//+ end=++ contains=jsComment
+
 " JSX child blocks behave just like JSX attributes, except that (a) they are
 " syntactically distinct, and (b) they need the syn-extend argument, or else
 " nested XML end-tag patterns may end the outer jsxRegion.
@@ -49,7 +53,7 @@ syn region jsxChild contained start=+{+ end=++ contains=jsBlock,javascriptBlock
 " and generic Flow type annotations (http://flowtype.org/).
 syn region jsxRegion
   \ contains=@Spell,@XMLSyntax,jsxRegion,jsxChild,jsBlock,javascriptBlock
-  \ start=+\%(<\|\w\)\@<!<\z([a-zA-Z][a-zA-Z0-9:\-.]*\>[:,]\@!\)\([^>]*>(\)\@!+
+  \ start=+\%(<\|\w\)\@<!<\z([a-zA-Z_][a-zA-Z0-9:\-.]*\>[:,]\@!\)\([^>]*>(\)\@!+
   \ skip=+<!--\_.\{-}-->+
   \ end=+</\z1\_\s\{-}>+
   \ end=+/>+

after/syntax/rust.vim

@@ -1,12 +1,14 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
   
-if !exists('g:rust_conceal') || g:rust_conceal == 0 || !has('conceal') || &enc != 'utf-8'
-	finish
+scriptencoding utf-8
+
+if !get(g:, 'rust_conceal', 0) || !has('conceal') || &encoding !=# 'utf-8'
+    finish
 endif
 
 " For those who don't want to see `::`...
-if exists('g:rust_conceal_mod_path') && g:rust_conceal_mod_path != 0
-	syn match rustNiceOperator "::" conceal cchar=ㆍ
+if get(g:, 'rust_conceal_mod_path', 0)
+    syn match rustNiceOperator "::" conceal cchar=ㆍ
 endif
 
 syn match rustRightArrowHead contained ">" conceal cchar= 
@@ -20,7 +22,7 @@ syn match rustNiceOperator "=>" contains=rustFatRightArrowHead,rustFatRightArrow
 syn match rustNiceOperator /\<\@!_\(_*\>\)\@=/ conceal cchar=′
 
 " For those who don't want to see `pub`...
-if exists('g:rust_conceal_pub') && g:rust_conceal_pub != 0
+if get(g:, 'rust_conceal_pub', 0)
     syn match rustPublicSigil contained "pu" conceal cchar=＊
     syn match rustPublicRest contained "b" conceal cchar= 
     syn match rustNiceOperator "pub " contains=rustPublicSigil,rustPublicRest
@@ -28,11 +30,16 @@ endif
 
 hi link rustNiceOperator Operator
 
-if !(exists('g:rust_conceal_mod_path') && g:rust_conceal_mod_path != 0)
+if !get(g:, 'rust_conceal_mod_path', 0)
     hi! link Conceal Operator
 
-    " And keep it after a colorscheme change
-    au ColorScheme <buffer> hi! link Conceal Operator
+    augroup rust.vim.after
+        autocmd!
+        " And keep it after a colorscheme change
+        autocmd ColorScheme <buffer> hi! link Conceal Operator
+    augroup END
 endif
 
+" vim: set et sw=4 sts=4 ts=8:
+
 endif

after/syntax/typescript/graphql.vim

@@ -0,0 +1,26 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+  
+if exists('b:current_syntax')
+  let s:current_syntax = b:current_syntax
+  unlet b:current_syntax
+endif
+syn include @GraphQLSyntax syntax/graphql.vim
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+let s:tags = '\%(' . join(g:graphql_javascript_tags, '\|') . '\)'
+
+exec 'syntax region graphqlTemplateString start=+' . s:tags . '\@20<=`+ skip=+\\`+ end=+`+ contains=@GraphQLSyntax,typescriptTemplateSubstitution extend'
+exec 'syntax match graphqlTaggedTemplate +' . s:tags . '\ze`+ nextgroup=graphqlTemplateString'
+
+" Support expression interpolation ((${...})) inside template strings.
+syntax region graphqlTemplateExpression start=+${+ end=+}+ contained contains=typescriptTemplateSubstitution containedin=graphqlFold keepend
+
+hi def link graphqlTemplateString typescriptTemplate
+hi def link graphqlTemplateExpression typescriptTemplateSubstitution
+
+syn cluster typescriptExpression add=graphqlTaggedTemplate
+syn cluster graphqlTaggedTemplate add=graphqlTemplateString
+
+endif

after/syntax/yaml.vim

@@ -21,13 +21,17 @@ if version < 600
 endif
 syntax clear
 
-syn match yamlBlock "[\[\]\{\}\|\>]"
+syn match yamlInline "[\[\]\{\}]"
+syn match yamlBlock "[>|]\d\?[+-]"
 
 syn region yamlComment	start="\#" end="$"
 syn match yamlIndicator	"#YAML:\S\+"
 
-syn region yamlString	start="'" end="'" skip="\\'"
+syn region yamlString	start="\(^\|\s\|\[\|\,\|\-\)'" end="'" skip="\\'"
 syn region yamlString	start='"' end='"' skip='\\"' contains=yamlEscape
+syn region yamlString	matchgroup=yamlBlock start=/[>|]\s*\n\+\z(\s\+\)\S/rs=s+1 skip=/^\%(\z1\S\|^$\)/ end=/^\z1\@!.*/me=s-1
+syn region yamlString	matchgroup=yamlBlock start=/[>|]\(\d\|[+-]\)\s*\n\+\z(\s\+\)\S/rs=s+2 skip=/^\%(\z1\S\|^$\)/ end=/^\z1\@!.*/me=s-1
+syn region yamlString	matchgroup=yamlBlock start=/[>|]\d\(\d\|[+-]\)\s*\n\+\z(\s\+\)\S/rs=s+3 skip=/^\%(\z1\S\|^$\)/ end=/^\z1\@!.*/me=s-1
 syn match  yamlEscape	+\\[abfnrtv'"\\]+ contained
 syn match  yamlEscape	"\\\o\o\=\o\=" contained
 syn match  yamlEscape	"\\x\x\+" contained
@@ -53,6 +57,7 @@ hi link yamlKey		Identifier
 hi link yamlType	Type
 
 hi link yamlComment	Comment
+hi link yamlInline	Operator
 hi link yamlBlock	Operator
 hi link yamlString	String
 hi link yamlEscape	Special

autoload/LaTeXtoUnicode.vim

@@ -0,0 +1,625 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+  
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Support for LaTex-to-Unicode conversion as in the Julia REPL "
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+function! s:L2U_Setup()
+
+  call s:L2U_SetupGlobal()
+
+  " Keep track of whether LaTeX-to-Unicode is activated
+  " (used when filetype changes)
+  if !has_key(b:, "l2u_enabled")
+    let b:l2u_enabled = 0
+  endif
+
+  " Did we install the L2U tab mappings?
+  if !has_key(b:, "l2u_tab_set")
+    let b:l2u_tab_set = 0
+  endif
+  if !has_key(b:, "l2u_cmdtab_set")
+    let b:l2u_cmdtab_set = 0
+  endif
+
+  " Did we activate the L2U as-you-type substitutions?
+  if !has_key(b:, "l2u_autosub_set")
+    let b:l2u_autosub_set = 0
+  endif
+
+  " Following are some flags used to pass information between the function which
+  " attempts the LaTeX-to-Unicode completion and the fallback function
+
+  " Was a (possibly partial) completion found?
+  let b:l2u_found_completion = 0
+  " Is the cursor just after a single backslash
+  let b:l2u_singlebslash = 0
+  " Backup value of the completeopt settings
+  " (since we temporarily add the 'longest' setting while
+  "  attempting LaTeX-to-Unicode)
+  let b:l2u_backup_commpleteopt = &completeopt
+  " Are we in the middle of a L2U tab completion?
+  let b:l2u_tab_completing = 0
+  " Are we calling the tab fallback?
+  let b:l2u_in_fallback = 0
+
+endfunction
+
+function! s:L2U_SetupGlobal()
+
+  " Initialization of global and script-local variables
+  " is only performed once
+  if get(g:, "l2u_did_global_setup", 0)
+    return
+  endif
+
+  let g:l2u_did_global_setup = 1
+
+  let g:l2u_symbols_dict = julia_latex_symbols#get_dict()
+
+  call s:L2U_deprecated_options()
+
+  if v:version < 704
+      let g:latex_to_unicode_tab = 0
+      let g:latex_to_unicode_auto = 0
+  endif
+
+  " YouCompleteMe and neocomplcache/neocomplete/deoplete plug-ins do not work well
+  " with LaTeX symbols suggestions
+  if exists("g:loaded_youcompleteme") ||
+        \ exists("g:loaded_neocomplcache") ||
+        \ exists("g:loaded_neocomplete") ||
+        \ exists("g:loaded_deoplete")
+    let g:latex_to_unicode_suggestions = 0
+  endif
+
+  " A hack to forcibly get out of completion mode: feed
+  " this string with feedkeys()
+  if has("win32") || has("win64")
+    if has("gui_running")
+      let s:l2u_esc_sequence = "\u0006"
+    else
+      let s:l2u_esc_sequence = "\u0006\b"
+    endif
+  else
+    let s:l2u_esc_sequence = "\u0091\b"
+  end
+
+  " Trigger for the previous mapping of <Tab>
+  let s:l2u_fallback_trigger = "\u0091L2UFallbackTab"
+
+endfunction
+
+" Each time the filetype changes, we may need to enable or
+" disable the LaTeX-to-Unicode functionality
+function! LaTeXtoUnicode#Refresh()
+
+  call s:L2U_Setup()
+
+  " by default, LaTeX-to-Unicode is only active on julia files
+  let file_types = s:L2U_file_type_regex(get(g:, "latex_to_unicode_file_types", "julia"))
+  let file_types_blacklist = s:L2U_file_type_regex(get(g:, "latex_to_unicode_file_types_blacklist", "$^"))
+
+  if match(&filetype, file_types) < 0 || match(&filetype, file_types_blacklist) >= 0
+    if b:l2u_enabled
+      call LaTeXtoUnicode#Disable()
+    else
+      return
+    endif
+  elseif !b:l2u_enabled
+    call LaTeXtoUnicode#Enable()
+  endif
+
+endfunction
+
+function! LaTeXtoUnicode#Enable()
+
+  if b:l2u_enabled
+    return
+  end
+
+  call s:L2U_ResetLastCompletionInfo()
+
+  let b:l2u_enabled = 1
+
+  " If we're editing the first file upon opening vim, this will only init the
+  " command line mode mapping, and the full initialization will be performed by
+  " the autocmd triggered by InsertEnter, defined in /ftdetect.vim.
+  " Otherwise, if we're opening a file from within a running vim session, this
+  " will actually initialize all the LaTeX-to-Unicode substitutions.
+  call LaTeXtoUnicode#Init()
+
+  return
+
+endfunction
+
+function! LaTeXtoUnicode#Disable()
+  if !b:l2u_enabled
+    return
+  endif
+  let b:l2u_enabled = 0
+  call LaTeXtoUnicode#Init()
+  return
+endfunction
+
+" Translate old options to their new equivalents
+function! s:L2U_deprecated_options()
+  for [new, old] in [["latex_to_unicode_tab",         "julia_latex_to_unicode"],
+                 \   ["latex_to_unicode_auto",        "julia_auto_latex_to_unicode"],
+                 \   ["latex_to_unicode_suggestions", "julia_latex_suggestions_enabled"],
+                 \   ["latex_to_unicode_eager",       "julia_latex_to_unicode_eager"]]
+    if !has_key(g:, new) && has_key(g:, old)
+      exec "let g:" . new . " = g:" . old
+    endif
+  endfor
+endfunction
+
+function! s:L2U_file_type_regex(ft)
+  if type(a:ft) == 3
+    let file_types = "\\%(" . join(a:ft, "\\|") . "\\)"
+  elseif type(a:ft) == 1
+    let file_types = a:ft
+  else
+    echoerr "invalid file_type specification"
+  endif
+  return "^" . file_types . "$"
+endfunction
+
+" Some data used to keep track of the previous completion attempt.
+" Used to detect
+" 1) if we just attempted the same completion, or
+" 2) if backspace was just pressed while completing
+" This function initializes and resets the required info
+
+function! s:L2U_ResetLastCompletionInfo()
+  let b:l2u_completed_once = 0
+  let b:l2u_bs_while_completing = 0
+  let b:l2u_last_compl = {
+        \ 'line': '',
+        \ 'col0': -1,
+        \ 'col1': -1,
+        \ }
+endfunction
+
+" This function only detects whether an exact match is found for a LaTeX
+" symbol in front of the cursor
+function! s:L2U_ismatch()
+  let col1 = col('.')
+  let l = getline('.')
+  let col0 = match(l[0:col1-2], '\\[^[:space:]\\]\+$')
+  if col0 == -1
+    return 0
+  endif
+  let base = l[col0 : col1-1]
+  return has_key(g:l2u_symbols_dict, base)
+endfunction
+
+" Helper function to sort suggestion entries
+function! s:L2U_partmatches_sort(p1, p2)
+  return a:p1.word > a:p2.word ? 1 : a:p1.word < a:p2.word ? -1 : 0
+endfunction
+
+" Helper function to fix display of Unicode compose characters
+" in the suggestions menu (they are displayed on top of '◌')
+function! s:L2U_fix_compose_chars(uni)
+  let u = matchstr(a:uni, '^.')
+  let isc = ("\u0300" <= u && u <= "\u036F") ||
+          \ ("\u1DC0" <= u && u <= "\u1DFF") ||
+          \ ("\u20D0" <= u && u <= "\u20FF") ||
+          \ ("\uFE20" <= u && u <= "\uFE2F")
+  return isc ? "\u25CC" . a:uni : a:uni
+endfunction
+
+" Helper function to find the longest common prefix among
+" partial completion matches (used when suggestions are disabled
+" and in command line mode)
+function! s:L2U_longest_common_prefix(partmatches)
+  let common = a:partmatches[0]
+  for i in range(1, len(a:partmatches)-1)
+    let p = a:partmatches[i]
+    if len(p) < len(common)
+      let common = common[0 : len(p)-1]
+    endif
+    for j in range(1, len(common)-1)
+      if p[j] != common[j]
+        let common = common[0 : j-1]
+        break
+      endif
+    endfor
+  endfor
+  return common
+endfunction
+
+" Omnicompletion function. Besides the usual two-stage omnifunc behaviour,
+" it has the following peculiar features:
+"  *) keeps track of the previous completion attempt
+"  *) sets some info to be used by the fallback function
+"  *) either returns a list of completions if a partial match is found, or a
+"     Unicode char if an exact match is found
+"  *) forces its way out of completion mode through a hack in some cases
+function! LaTeXtoUnicode#omnifunc(findstart, base)
+  if a:findstart
+    " first stage
+    " avoid infinite loop if the fallback happens to call omnicompletion
+    if b:l2u_in_fallback
+      let b:l2u_in_fallback = 0
+      return -3
+    endif
+    let b:l2u_in_fallback = 0
+    " set info for the callback
+    let b:l2u_tab_completing = 1
+    let b:l2u_found_completion = 1
+    " analyse current line
+    let col1 = col('.')
+    let l = getline('.')
+    let col0 = match(l[0:col1-2], '\\[^[:space:]\\]\+$')
+    " compare with previous completion attempt
+    let b:l2u_bs_while_completing = 0
+    let b:l2u_completed_once = 0
+    if col0 == b:l2u_last_compl['col0']
+      let prevl = b:l2u_last_compl['line']
+      if col1 == b:l2u_last_compl['col1'] && l ==# prevl
+        let b:l2u_completed_once = 1
+      elseif col1 == b:l2u_last_compl['col1'] - 1 && l ==# prevl[0 : col1-2] . prevl[col1 : -1]
+        let b:l2u_bs_while_completing = 1
+      endif
+    endif
+    " store completion info for next attempt
+    let b:l2u_last_compl['col0'] = col0
+    let b:l2u_last_compl['col1'] = col1
+    let b:l2u_last_compl['line'] = l
+    " is the cursor right after a backslash?
+    let b:l2u_singlebslash = (match(l[0:col1-2], '\\$') >= 0)
+    " completion not found
+    if col0 == -1
+      let b:l2u_found_completion = 0
+      call feedkeys(s:l2u_esc_sequence, 'n')
+      let col0 = -2
+    endif
+    return col0
+  else
+    " read settings (eager mode is implicit when suggestions are disabled)
+    let suggestions = get(g:, "latex_to_unicode_suggestions", 1)
+    let eager = get(g:, "latex_to_unicode_eager", 1) || !suggestions
+    " search for matches
+    let partmatches = []
+    let exact_match = 0
+    for k in keys(g:l2u_symbols_dict)
+      if k ==# a:base
+        let exact_match = 1
+      endif
+      if len(k) >= len(a:base) && k[0 : len(a:base)-1] ==# a:base
+        let menu = s:L2U_fix_compose_chars(g:l2u_symbols_dict[k])
+        if suggestions
+          call add(partmatches, {'word': k, 'menu': menu})
+        else
+          call add(partmatches, k)
+        endif
+      endif
+    endfor
+    " exact matches are replaced with Unicode
+    " exceptions:
+    "  *) we reached an exact match by pressing backspace while completing
+    "  *) the exact match is one among many, and the eager setting is
+    "     disabled, and it's the first time this completion is attempted
+    if exact_match && !b:l2u_bs_while_completing && (len(partmatches) == 1 || eager || b:l2u_completed_once)
+      " the completion is successful: reset the last completion info...
+      call s:L2U_ResetLastCompletionInfo()
+      " ...force our way out of completion mode...
+      call feedkeys(s:l2u_esc_sequence, 'n')
+      " ...return the Unicode symbol
+      return [g:l2u_symbols_dict[a:base]]
+    endif
+    if !empty(partmatches)
+      " here, only partial matches were found; either keep just the longest
+      " common prefix, or pass them on
+      if !suggestions
+        let partmatches = [s:L2U_longest_common_prefix(partmatches)]
+      else
+        call sort(partmatches, "s:L2U_partmatches_sort")
+      endif
+    endif
+    if empty(partmatches)
+      call feedkeys(s:l2u_esc_sequence, 'n')
+      let b:l2u_found_completion = 0
+    endif
+    return partmatches
+  endif
+endfunction
+
+function! LaTeXtoUnicode#PutLiteral(k)
+  call feedkeys(a:k, 'ni')
+  return ''
+endfunction
+
+" Function which saves the current insert-mode mapping of a key sequence `s`
+" and associates it with another key sequence `k` (e.g. stores the current
+" <Tab> mapping into the Fallback trigger)
+function! s:L2U_SetFallbackMapping(s, k)
+  let mmdict = maparg(a:s, 'i', 0, 1)
+  if empty(mmdict)
+    exe 'inoremap <buffer> ' . a:k . ' ' . a:s
+    return
+  endif
+  let rhs = mmdict["rhs"]
+  if rhs =~# '^<Plug>L2U'
+    return
+  endif
+  let pre = '<buffer>'
+  if mmdict["silent"]
+    let pre = pre . '<silent>'
+  endif
+  if mmdict["expr"]
+    let pre = pre . '<expr>'
+  endif
+  if mmdict["noremap"]
+    let cmd = 'inoremap '
+  else
+    let cmd = 'imap '
+    " This is a nasty hack used to prevent infinite recursion. It's not a
+    " general solution.
+    if mmdict["expr"]
+      let rhs = substitute(rhs, '\c' . a:s, "\<C-R>=LaTeXtoUnicode#PutLiteral('" . a:s . "')\<CR>", 'g')
+    endif
+  endif
+  exe cmd . pre . ' ' . a:k . ' ' . rhs
+endfunction
+
+" This is the function which is mapped to <Tab>
+function! LaTeXtoUnicode#Tab()
+  " the <Tab> is passed through to the fallback mapping if the completion
+  " menu is present, and it hasn't been raised by the L2U tab, and there
+  " isn't an exact match before the cursor when suggestions are disabled
+  if pumvisible() && !b:l2u_tab_completing && (get(g:, "latex_to_unicode_suggestions", 1) || !s:L2U_ismatch())
+    call feedkeys(s:l2u_fallback_trigger)
+    return ''
+  endif
+  " reset the in_fallback info
+  let b:l2u_in_fallback = 0
+  " temporary change to completeopt to use the `longest` setting, which is
+  " probably the only one which makes sense given that the goal of the
+  " completion is to substitute the final string
+  let b:l2u_backup_commpleteopt = &completeopt
+  set completeopt+=longest
+  set completeopt-=noinsert
+  " invoke omnicompletion; failure to perform LaTeX-to-Unicode completion is
+  " handled by the CompleteDone autocommand.
+  return "\<C-X>\<C-O>"
+endfunction
+
+" This function is called at every CompleteDone event, and is meant to handle
+" the failures of LaTeX-to-Unicode completion by calling a fallback
+function! LaTeXtoUnicode#FallbackCallback()
+  if !b:l2u_tab_completing
+    " completion was not initiated by L2U, nothing to do
+    return
+  else
+    " completion was initiated by L2U, restore completeopt
+    let &completeopt = b:l2u_backup_commpleteopt
+  endif
+  " at this point L2U tab completion is over
+  let b:l2u_tab_completing = 0
+  " if the completion was successful do nothing
+  if b:l2u_found_completion == 1 || b:l2u_singlebslash == 1
+    return
+  endif
+  " fallback
+  let b:l2u_in_fallback = 1
+  call feedkeys(s:l2u_fallback_trigger)
+  return
+endfunction
+
+" This is the function which is mapped to <S-Tab> in command-line mode
+function! LaTeXtoUnicode#CmdTab()
+  " first stage
+  " analyse command line
+  let col1 = getcmdpos() - 1
+  let l = getcmdline()
+  let col0 = match(l[0:col1-1], '\\[^[:space:]\\]\+$')
+  let b:l2u_singlebslash = (match(l[0:col1-1], '\\$') >= 0)
+  " completion not found
+  if col0 == -1
+    return l
+  endif
+  let base = l[col0 : col1-1]
+  " search for matches
+  let partmatches = []
+  let exact_match = 0
+  for k in keys(g:l2u_symbols_dict)
+    if k ==# base
+      let exact_match = 1
+    endif
+    if len(k) >= len(base) && k[0 : len(base)-1] ==# base
+      call add(partmatches, k)
+    endif
+  endfor
+  if len(partmatches) == 0
+    return l
+  endif
+  " exact matches are replaced with Unicode
+  if exact_match
+    let unicode = g:l2u_symbols_dict[base]
+    if col0 > 0
+      let pre = l[0 : col0 - 1]
+    else
+      let pre = ''
+    endif
+    let posdiff = col1-col0 - len(unicode)
+    call setcmdpos(col1 - posdiff + 1)
+    return pre . unicode . l[col1 : -1]
+  endif
+  " no exact match: complete with the longest common prefix
+  let common = s:L2U_longest_common_prefix(partmatches)
+  if col0 > 0
+    let pre = l[0 : col0 - 1]
+  else
+    let pre = ''
+  endif
+  let posdiff = col1-col0 - len(common)
+  call setcmdpos(col1 - posdiff + 1)
+  return pre . common . l[col1 : -1]
+endfunction
+
+" Setup the L2U tab mapping
+function! s:L2U_SetTab(wait_insert_enter)
+  if !b:l2u_cmdtab_set && get(g:, "latex_to_unicode_tab", 1) && b:l2u_enabled
+    cmap <buffer> <S-Tab> <Plug>L2UCmdTab
+    cnoremap <buffer> <Plug>L2UCmdTab <C-\>eLaTeXtoUnicode#CmdTab()<CR>
+    let b:l2u_cmdtab_set = 1
+  endif
+  if b:l2u_tab_set
+    return
+  endif
+  " g:did_insert_enter is set from an autocommand in ftdetect
+  if a:wait_insert_enter && !get(g:, "did_insert_enter", 0)
+    return
+  endif
+  if !get(g:, "latex_to_unicode_tab", 1) || !b:l2u_enabled
+    return
+  endif
+
+  " Backup the previous omnifunc (the check is probably not really needed)
+  if get(b:, "prev_omnifunc", "") != "LaTeXtoUnicode#omnifunc"
+    let b:prev_omnifunc = &omnifunc
+  endif
+  setlocal omnifunc=LaTeXtoUnicode#omnifunc
+
+  call s:L2U_SetFallbackMapping('<Tab>', s:l2u_fallback_trigger)
+  imap <buffer> <Tab> <Plug>L2UTab
+  inoremap <buffer><expr> <Plug>L2UTab LaTeXtoUnicode#Tab()
+
+  augroup L2UTab
+    autocmd! * <buffer>
+    " Every time a completion finishes, the fallback may be invoked
+    autocmd CompleteDone <buffer> call LaTeXtoUnicode#FallbackCallback()
+  augroup END
+
+  let b:l2u_tab_set = 1
+endfunction
+
+" Revert the LaTeX-to-Unicode tab mapping settings
+function! s:L2U_UnsetTab()
+  if b:l2u_cmdtab_set
+    cunmap <buffer> <S-Tab>
+    let b:l2u_cmdtab_set = 0
+  endif
+  if !b:l2u_tab_set
+    return
+  endif
+  exec "setlocal omnifunc=" . get(b:, "prev_omnifunc", "")
+  iunmap <buffer> <Tab>
+  if empty(maparg("<Tab>", "i"))
+    call s:L2U_SetFallbackMapping(s:l2u_fallback_trigger, '<Tab>')
+  endif
+  iunmap <buffer> <Plug>L2UTab
+  exe 'iunmap <buffer> ' . s:l2u_fallback_trigger
+  augroup L2UTab
+    autocmd! * <buffer>
+  augroup END
+  let b:l2u_tab_set = 0
+endfunction
+
+" Function which looks for viable LaTeX-to-Unicode supstitutions as you type
+function! LaTeXtoUnicode#AutoSub(...)
+  let vc = a:0 == 0 ? v:char : a:1
+  let col1 = col('.')
+  let lnum = line('.')
+  if col1 == 1
+    if a:0 > 1
+      call feedkeys(a:2, 'n')
+    endif
+    return ''
+  endif
+  let bs = (vc != "\n")
+  let l = getline(lnum)[0 : col1-1-bs] . v:char
+  let col0 = match(l, '\\\%([_^]\?[A-Za-z]\+\%' . col1 . 'c\%([^A-Za-z]\|$\)\|[_^]\%([0-9()=+-]\)\%' . col1 .'c\%(.\|$\)\)')
+  if col0 == -1
+    if a:0 > 1
+      call feedkeys(a:2, 'n')
+    endif
+    return ''
+  endif
+  let base = l[col0 : -1-bs]
+  let unicode = get(g:l2u_symbols_dict, base, '')
+  if empty(unicode)
+    if a:0 > 1
+      call feedkeys(a:2, 'n')
+    endif
+    return ''
+  endif
+  call feedkeys("\<C-G>u", 'n')
+  call feedkeys(repeat("\b", len(base) + bs) . unicode . vc . s:l2u_esc_sequence, 'nt')
+  call feedkeys("\<C-G>u", 'n')
+  return ''
+endfunction
+
+" Setup the auto as-you-type LaTeX-to-Unicode substitution
+function! s:L2U_SetAutoSub(wait_insert_enter)
+  if b:l2u_autosub_set
+    return
+  endif
+  " g:did_insert_enter is set from an autocommand in ftdetect
+  if a:wait_insert_enter && !get(g:, "did_insert_enter", 0)
+    return
+  endif
+  if !get(g:, "latex_to_unicode_auto", 0) || !b:l2u_enabled
+    return
+  endif
+  " Viable substitutions are searched at every character insertion via the
+  " autocmd InsertCharPre. The <Enter> key does not seem to be catched in
+  " this way though, so we use a mapping for that case.
+  imap <buffer> <CR> <Plug>L2UAutoSub
+  inoremap <buffer><expr> <Plug>L2UAutoSub LaTeXtoUnicode#AutoSub("\n", "\<CR>")
+
+  augroup L2UAutoSub
+    autocmd! * <buffer>
+    autocmd InsertCharPre <buffer> call LaTeXtoUnicode#AutoSub()
+  augroup END
+
+  let b:l2u_autosub_set = 1
+endfunction
+
+" Revert the auto LaTeX-to-Unicode settings
+function! s:L2U_UnsetAutoSub()
+  if !b:l2u_autosub_set
+    return
+  endif
+
+  iunmap <buffer> <CR>
+  iunmap <buffer> <Plug>L2UAutoSub
+  augroup L2UAutoSub
+    autocmd! * <buffer>
+  augroup END
+  let b:l2u_autosub_set = 0
+endfunction
+
+" Initialization. Can be used to re-init when global settings have changed.
+function! LaTeXtoUnicode#Init(...)
+  let wait_insert_enter = a:0 > 0 ? a:1 : 1
+
+  if !wait_insert_enter
+    augroup L2UInit
+      autocmd!
+    augroup END
+  endif
+
+  call s:L2U_UnsetTab()
+  call s:L2U_UnsetAutoSub()
+
+  call s:L2U_SetTab(wait_insert_enter)
+  call s:L2U_SetAutoSub(wait_insert_enter)
+endfunction
+
+function! LaTeXtoUnicode#Toggle()
+  call s:L2U_Setup()
+  if b:l2u_enabled
+    call LaTeXtoUnicode#Disable()
+    echo "LaTeX-to-Unicode disabled"
+  else
+    call LaTeXtoUnicode#Enable()
+    echo "LaTeX-to-Unicode enabled"
+  endif
+  return
+endfunction
+
+endif

autoload/cargo.vim

@@ -0,0 +1,91 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+  
+function! cargo#Load() 
+    " Utility call to get this script loaded, for debugging
+endfunction
+
+function! cargo#cmd(args)
+    execute "! cargo" a:args
+endfunction
+
+function! s:nearest_cargo(...) abort
+    " If the second argument is not specified, the first argument determines
+    " whether we will start from the current directory or the directory of the
+    " current buffer, otherwise, we start with the provided path on the 
+    " second argument.
+
+    let l:is_getcwd = get(a:, 1, 0)
+    if l:is_getcwd 
+        let l:starting_path = get(a:, 2, getcwd())
+    else
+        let l:starting_path = get(a:, 2, expand('%:p:h'))
+    endif
+
+    return findfile('Cargo.toml', l:starting_path . ';')
+endfunction
+
+function! cargo#nearestCargo(is_getcwd) abort
+    return s:nearest_cargo(a:is_getcwd)
+endfunction
+
+function! cargo#nearestWorkspaceCargo(is_getcwd) abort
+    let l:nearest = s:nearest_cargo(a:is_getcwd)
+    while l:nearest !=# ''
+        for l:line in readfile(l:nearest, '', 0x100)
+            if l:line =~# '\V[workspace]'
+                return l:nearest
+            endif
+        endfor
+        let l:next = fnamemodify(l:nearest, ':p:h:h')
+        let l:nearest = s:nearest_cargo(0, l:next)
+    endwhile
+    return ''
+endfunction
+
+function! cargo#nearestRootCargo(is_getcwd) abort
+    " Try to find a workspace Cargo.toml, and if not found, take the nearest
+    " regular Cargo.toml
+    let l:workspace_cargo = cargo#nearestWorkspaceCargo(a:is_getcwd)
+    if l:workspace_cargo !=# ''
+        return l:workspace_cargo
+    endif
+    return s:nearest_cargo(a:is_getcwd)
+endfunction
+
+
+function! cargo#build(args)
+    call cargo#cmd("build " . a:args)
+endfunction
+
+function! cargo#clean(args)
+    call cargo#cmd("clean " . a:args)
+endfunction
+
+function! cargo#doc(args)
+    call cargo#cmd("doc " . a:args)
+endfunction
+
+function! cargo#new(args)
+    call cargo#cmd("new " . a:args)
+    cd `=a:args`
+endfunction
+
+function! cargo#init(args)
+    call cargo#cmd("init " . a:args)
+endfunction
+
+function! cargo#run(args)
+    call cargo#cmd("run " . a:args)
+endfunction
+
+function! cargo#test(args)
+    call cargo#cmd("test " . a:args)
+endfunction
+
+function! cargo#bench(args)
+    call cargo#cmd("bench " . a:args)
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+endif

autoload/cargo/quickfix.vim

@@ -0,0 +1,30 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+  
+function! cargo#quickfix#CmdPre() abort
+    if &filetype ==# 'rust' && get(b:, 'current_compiler', '') ==# 'cargo'
+        " Preserve the current directory, and 'lcd' to the nearest Cargo file.
+        let b:rust_compiler_cargo_qf_has_lcd = haslocaldir()
+        let b:rust_compiler_cargo_qf_prev_cd = getcwd()
+        let b:rust_compiler_cargo_qf_prev_cd_saved = 1
+        let l:nearest = fnamemodify(cargo#nearestRootCargo(0), ':h')
+        execute 'lchdir! '.l:nearest
+    else
+        let b:rust_compiler_cargo_qf_prev_cd_saved = 0
+    endif
+endfunction
+
+function! cargo#quickfix#CmdPost() abort
+    if b:rust_compiler_cargo_qf_prev_cd_saved
+        " Restore the current directory.
+        if b:rust_compiler_cargo_qf_has_lcd
+            execute 'lchdir! '.b:rust_compiler_cargo_qf_prev_cd
+        else
+            execute 'chdir! '.b:rust_compiler_cargo_qf_prev_cd
+        endif
+        let b:rust_compiler_cargo_qf_prev_cd_saved = 0
+    endif
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+endif

autoload/crystal_lang.vim

@@ -3,11 +3,21 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
 let s:save_cpo = &cpo
 set cpo&vim
 
-let s:V = vital#of('crystal')
+let s:V = vital#crystal#new()
 let s:P = s:V.import('Process')
-let s:J = s:V.import('Web.JSON')
 let s:C = s:V.import('ColorEcho')
 
+if exists('*json_decode')
+    function! s:decode_json(text) abort
+        return json_decode(a:text)
+    endfunction
+else
+    let s:J = s:V.import('Web.JSON')
+    function! s:decode_json(text) abort
+        return s:J.decode(a:text)
+    endfunction
+endif
+
 function! s:echo_error(msg, ...) abort
     echohl ErrorMsg
     if a:0 == 0
@@ -102,7 +112,7 @@ function! crystal_lang#jump_to_definition(file, pos) abort
         return s:echo_error(cmd_result.output)
     endif
 
-    let impl = s:J.decode(cmd_result.output)
+    let impl = s:decode_json(cmd_result.output)
     if impl.status !=# 'ok'
         return s:echo_error(impl.message)
     endif
@@ -149,7 +159,6 @@ endfunction
 
 function! crystal_lang#complete(findstart, base) abort
     if a:findstart
-        echom 'find start'
         return s:find_completion_start()
     endif
 
@@ -158,7 +167,7 @@ function! crystal_lang#complete(findstart, base) abort
         return
     endif
 
-    let contexts = s:J.decode(cmd_result.output)
+    let contexts = s:decode_json(cmd_result.output)
     if contexts.status !=# 'ok'
         return
     endif
@@ -271,59 +280,38 @@ function! crystal_lang#format_string(code, ...) abort
     return output
 endfunction
 
-function! s:get_saved_states() abort
-    let result = {}
-    let fname = bufname('%')
-    let current_winnr = winnr()
-    for i in range(1, winnr('$'))
-        let bufnr = winbufnr(i)
-        if bufnr == -1
-            continue
-        endif
-        if bufname(bufnr) ==# fname
-            execute i 'wincmd w'
-            let result[i] = {
-                \     'pos': getpos('.'),
-                \     'screen': winsaveview()
-                \ }
-        endif
-    endfor
-    execute current_winnr 'wincmd w'
-    return result
-endfunction
-
-function! crystal_lang#format(option_str) abort
+" crystal_lang#format(option_str [, on_save])
+function! crystal_lang#format(option_str, ...) abort
     if !executable(g:crystal_compiler_command)
         " Finish command silently
         return
     endif
 
-    let formatted = crystal_lang#format_string(join(getline(1, '$'), "\n"), a:option_str)
-    let formatted = substitute(formatted, '\n$', '', '')
+    let on_save = a:0 > 0 ? a:1 : 0
 
-    let sel_save = &l:selection
-    let ve_save = &virtualedit
-    let &l:selection = 'inclusive'
-    let &virtualedit = ''
-    let [save_g_reg, save_g_regtype] = [getreg('g'), getregtype('g')]
-    let windows_save = s:get_saved_states()
+    let before = join(getline(1, '$'), "\n")
+    let formatted = crystal_lang#format_string(before, a:option_str)
+    if !on_save
+        let after = substitute(formatted, '\n$', '', '')
+        if before ==# after
+            return
+        endif
+    endif
 
-    try
-        call setreg('g', formatted, 'v')
-        silent normal! gg0vG$"gp
-    finally
-        call setreg('g', save_g_reg, save_g_regtype)
-        let &l:selection = sel_save
-        let &virtualedit = ve_save
-        let winnr = winnr()
-        for winnr in keys(windows_save)
-            let w = windows_save[winnr]
-            execute winnr 'wincmd w'
-            call setpos('.', w.pos)
-            call winrestview(w.screen)
-        endfor
-        execute winnr 'wincmd w'
-    endtry
+    let view_save = winsaveview()
+    let pos_save = getpos('.')
+    let lines = split(formatted, '\n')
+    silent! undojoin
+    if line('$') > len(lines)
+        execute len(lines) . ',$delete' '_'
+    endif
+    call setline(1, lines)
+    call winrestview(view_save)
+    call setpos('.', pos_save)
+endfunction
+
+function! crystal_lang#expand(file, pos, ...) abort
+    return crystal_lang#tool('expand', a:file, a:pos, get(a:, 1, ''))
 endfunction
 
 let &cpo = s:save_cpo

autoload/dart.vim

@@ -22,6 +22,7 @@ function! dart#fmt(q_args) abort
   if executable('dartfmt')
     let buffer_content = join(getline(1, '$'), "\n")
     let joined_lines = system(printf('dartfmt %s', a:q_args), buffer_content)
+    if buffer_content ==# joined_lines[:-2] | return | endif
     if 0 == v:shell_error
       let win_view = winsaveview()
       let lines = split(joined_lines, "\n")
@@ -129,6 +130,15 @@ function! s:PackageMap() abort
   return [v:true, map]
 endfunction
 
+" Toggle whether dartfmt is run on save or not.
+function! dart#ToggleFormatOnSave() abort
+  if get(g:, "dart_format_on_save", 0)
+    let g:dart_format_on_save = 0
+    return
+  endif
+  let g:dart_format_on_save = 1
+endfunction
+
 " Finds a file name '.packages' in the cwd, or in any directory above the open
 " file.
 "
@@ -152,4 +162,13 @@ function! s:DotPackagesFile() abort
   return [v:false, '']
 endfunction
 
+" Prevent writes to files in the pub cache.
+function! dart#setModifiable() abort
+  let full_path = expand('%:p')
+  if full_path =~# '.pub-cache' ||
+      \ full_path =~# 'Pub\Cache'
+    setlocal nomodifiable
+  endif
+endfunction
+
 endif

autoload/elixir/indent.vim

@@ -18,30 +18,32 @@ function! elixir#indent#indent(lnum)
   call s:debug("==> Indenting line " . lnum)
   call s:debug("text = '" . text . "'")
 
+  let [_, curs_lnum, curs_col, _] = getpos('.')
+  call cursor(lnum, 0)
+
   let handlers = [
         \'top_of_file',
-        \'starts_with_end',
-        \'starts_with_mid_or_end_block_keyword',
-        \'following_trailing_do',
         \'following_trailing_binary_operator',
         \'starts_with_pipe',
-        \'starts_with_close_bracket',
         \'starts_with_binary_operator',
-        \'inside_nested_construct',
-        \'starts_with_comment',
+        \'inside_block',
+        \'starts_with_end',
         \'inside_generic_block',
         \'follow_prev_nb'
         \]
   for handler in handlers
     call s:debug('testing handler elixir#indent#handle_'.handler)
-    let indent = function('elixir#indent#handle_'.handler)(lnum, text, prev_nb_lnum, prev_nb_text)
+    let context = {'lnum': lnum, 'text': text, 'prev_nb_lnum': prev_nb_lnum, 'prev_nb_text': prev_nb_text}
+    let indent = function('elixir#indent#handle_'.handler)(context)
     if indent != -1
       call s:debug('line '.lnum.': elixir#indent#handle_'.handler.' returned '.indent)
+      call cursor(curs_lnum, curs_col)
       return indent
     endif
   endfor
 
   call s:debug("defaulting")
+  call cursor(curs_lnum, curs_col)
   return 0
 endfunction
 
@@ -51,9 +53,17 @@ function! s:debug(str)
   endif
 endfunction
 
+function! s:starts_with(context, expr)
+  return s:_starts_with(a:context.text, a:expr, a:context.lnum)
+endfunction
+
+function! s:prev_starts_with(context, expr)
+  return s:_starts_with(a:context.prev_nb_text, a:expr, a:context.prev_nb_lnum)
+endfunction
+
 " Returns 0 or 1 based on whether or not the text starts with the given
 " expression and is not a string or comment
-function! s:starts_with(text, expr, lnum)
+function! s:_starts_with(text, expr, lnum)
   let pos = match(a:text, '^\s*'.a:expr)
   if pos == -1
     return 0
@@ -68,9 +78,13 @@ function! s:starts_with(text, expr, lnum)
   end
 endfunction
 
+function! s:prev_ends_with(context, expr)
+  return s:_ends_with(a:context.prev_nb_text, a:expr, a:context.prev_nb_lnum)
+endfunction
+
 " Returns 0 or 1 based on whether or not the text ends with the given
 " expression and is not a string or comment
-function! s:ends_with(text, expr, lnum)
+function! s:_ends_with(text, expr, lnum)
   let pos = match(a:text, a:expr.'\s*$')
   if pos == -1
     return 0
@@ -134,16 +148,16 @@ function! s:find_last_pos(lnum, text, match)
   return -1
 endfunction
 
-function! elixir#indent#handle_top_of_file(_lnum, _text, prev_nb_lnum, _prev_nb_text)
-  if a:prev_nb_lnum == 0
+function! elixir#indent#handle_top_of_file(context)
+  if a:context.prev_nb_lnum == 0
     return 0
   else
     return -1
   end
 endfunction
 
-function! elixir#indent#handle_follow_prev_nb(_lnum, _text, prev_nb_lnum, prev_nb_text)
-  return s:get_base_indent(a:prev_nb_lnum, a:prev_nb_text)
+function! elixir#indent#handle_follow_prev_nb(context)
+  return s:get_base_indent(a:context.prev_nb_lnum, a:context.prev_nb_text)
 endfunction
 
 " Given the line at `lnum`, returns the indent of the line that acts as the 'base indent'
@@ -157,16 +171,16 @@ function! s:get_base_indent(lnum, text)
   let data_structure_close = '\%(\]\|}\|)\)'
   let pipe = '|>'
 
-  if s:starts_with(a:text, binary_operator, a:lnum)
+  if s:_starts_with(a:text, binary_operator, a:lnum)
     return s:get_base_indent(prev_nb_lnum, prev_nb_text)
-  elseif s:starts_with(a:text, pipe, a:lnum)
+  elseif s:_starts_with(a:text, pipe, a:lnum)
     return s:get_base_indent(prev_nb_lnum, prev_nb_text)
-  elseif s:ends_with(prev_nb_text, binary_operator, prev_nb_lnum)
+  elseif s:_ends_with(prev_nb_text, binary_operator, prev_nb_lnum)
     return s:get_base_indent(prev_nb_lnum, prev_nb_text)
-  elseif s:ends_with(a:text, data_structure_close, a:lnum)
+  elseif s:_ends_with(a:text, data_structure_close, a:lnum)
     let data_structure_open = '\%(\[\|{\|(\)'
     let close_match_idx = match(a:text, data_structure_close . '\s*$')
-    let _move = cursor(a:lnum, close_match_idx + 1)
+    call cursor(a:lnum, close_match_idx + 1)
     let [open_match_lnum, open_match_col] = searchpairpos(data_structure_open, '', data_structure_close, 'bnW')
     let open_match_text = getline(open_match_lnum)
     return s:get_base_indent(open_match_lnum, open_match_text)
@@ -175,47 +189,26 @@ function! s:get_base_indent(lnum, text)
   endif
 endfunction
 
-" TODO: @jbodah 2017-03-31: remove
-function! elixir#indent#handle_following_trailing_do(lnum, text, prev_nb_lnum, prev_nb_text)
-  if s:ends_with(a:prev_nb_text, s:keyword('do'), a:prev_nb_lnum)
-    if s:starts_with(a:text, s:keyword('end'), a:lnum)
-      return indent(a:prev_nb_lnum)
-    else
-      return indent(a:prev_nb_lnum) + s:sw()
-    end
-  else
-    return -1
-  endif
-endfunction
-
-function! elixir#indent#handle_following_trailing_binary_operator(lnum, text, prev_nb_lnum, prev_nb_text)
+function! elixir#indent#handle_following_trailing_binary_operator(context)
   let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
 
-  if s:ends_with(a:prev_nb_text, binary_operator, a:prev_nb_lnum)
-    return indent(a:prev_nb_lnum) + s:sw()
+  if s:prev_ends_with(a:context, binary_operator)
+    return indent(a:context.prev_nb_lnum) + s:sw()
   else
     return -1
   endif
 endfunction
 
-function! elixir#indent#handle_following_prev_end(_lnum, _text, prev_nb_lnum, prev_nb_text)
-  if s:ends_with(a:prev_nb_text, s:keyword('end'), a:prev_nb_lnum)
-    return indent(a:prev_nb_lnum)
-  else
-    return -1
-  endif
-endfunction
-
-function! elixir#indent#handle_starts_with_pipe(lnum, text, prev_nb_lnum, prev_nb_text)
-  if s:starts_with(a:text, '|>', a:lnum)
+function! elixir#indent#handle_starts_with_pipe(context)
+  if s:starts_with(a:context, '|>')
     let match_operator = '\%(!\|=\|<\|>\)\@<!=\%(=\|>\|\~\)\@!'
-    let pos = s:find_last_pos(a:prev_nb_lnum, a:prev_nb_text, match_operator)
+    let pos = s:find_last_pos(a:context.prev_nb_lnum, a:context.prev_nb_text, match_operator)
     if pos == -1
-      return indent(a:prev_nb_lnum)
+      return indent(a:context.prev_nb_lnum)
     else
-      let next_word_pos = match(strpart(a:prev_nb_text, pos+1, len(a:prev_nb_text)-1), '\S')
+      let next_word_pos = match(strpart(a:context.prev_nb_text, pos+1, len(a:context.prev_nb_text)-1), '\S')
       if next_word_pos == -1
-        return indent(a:prev_nb_lnum) + s:sw()
+        return indent(a:context.prev_nb_lnum) + s:sw()
       else
         return pos + 1 + next_word_pos
       end
@@ -225,16 +218,8 @@ function! elixir#indent#handle_starts_with_pipe(lnum, text, prev_nb_lnum, prev_n
   endif
 endfunction
 
-function! elixir#indent#handle_starts_with_comment(_lnum, text, prev_nb_lnum, _prev_nb_text)
-  if match(a:text, '^\s*#') != -1
-    return indent(a:prev_nb_lnum)
-  else
-    return -1
-  endif
-endfunction
-
-function! elixir#indent#handle_starts_with_end(lnum, text, _prev_nb_lnum, _prev_nb_text)
-  if s:starts_with(a:text, s:keyword('end'), a:lnum)
+function! elixir#indent#handle_starts_with_end(context)
+  if s:starts_with(a:context, s:keyword('end'))
     let pair_lnum = searchpair(s:keyword('do\|fn'), '', s:keyword('end').'\zs', 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
     return indent(pair_lnum)
   else
@@ -242,36 +227,18 @@ function! elixir#indent#handle_starts_with_end(lnum, text, _prev_nb_lnum, _prev_
   endif
 endfunction
 
-function! elixir#indent#handle_starts_with_mid_or_end_block_keyword(lnum, text, _prev_nb_lnum, _prev_nb_text)
-  if s:starts_with(a:text, s:keyword('catch\|rescue\|after\|else'), a:lnum)
-    let pair_lnum = searchpair(s:keyword('with\|receive\|try\|if\|fn'), s:keyword('catch\|rescue\|after\|else').'\zs', s:keyword('end'), 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
-    return indent(pair_lnum)
-  else
-    return -1
-  endif
-endfunction
-
-function! elixir#indent#handle_starts_with_close_bracket(lnum, text, _prev_nb_lnum, _prev_nb_text)
-  if s:starts_with(a:text, '\%(\]\|}\|)\)', a:lnum)
-    let pair_lnum = searchpair('\%(\[\|{\|(\)', '', '\%(\]\|}\|)\)', 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
-    return indent(pair_lnum)
-  else
-    return -1
-  endif
-endfunction
-
-function! elixir#indent#handle_starts_with_binary_operator(lnum, text, prev_nb_lnum, prev_nb_text)
+function! elixir#indent#handle_starts_with_binary_operator(context)
   let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
 
-  if s:starts_with(a:text, binary_operator, a:lnum)
+  if s:starts_with(a:context, binary_operator)
     let match_operator = '\%(!\|=\|<\|>\)\@<!=\%(=\|>\|\~\)\@!'
-    let pos = s:find_last_pos(a:prev_nb_lnum, a:prev_nb_text, match_operator)
+    let pos = s:find_last_pos(a:context.prev_nb_lnum, a:context.prev_nb_text, match_operator)
     if pos == -1
-      return indent(a:prev_nb_lnum)
+      return indent(a:context.prev_nb_lnum)
     else
-      let next_word_pos = match(strpart(a:prev_nb_text, pos+1, len(a:prev_nb_text)-1), '\S')
+      let next_word_pos = match(strpart(a:context.prev_nb_text, pos+1, len(a:context.prev_nb_text)-1), '\S')
       if next_word_pos == -1
-        return indent(a:prev_nb_lnum) + s:sw()
+        return indent(a:context.prev_nb_lnum) + s:sw()
       else
         return pos + 1 + next_word_pos
       end
@@ -285,162 +252,89 @@ endfunction
 " nested structure. For example, we might be in a function in a map in a
 " function, etc... so we need to first figure out what the innermost structure
 " is then forward execution to the proper handler
-function! elixir#indent#handle_inside_nested_construct(lnum, text, prev_nb_lnum, prev_nb_text)
+function! elixir#indent#handle_inside_block(context)
   let start_pattern = '\C\%(\<with\>\|\<if\>\|\<case\>\|\<cond\>\|\<try\>\|\<receive\>\|\<fn\>\|{\|\[\|(\)'
   let end_pattern = '\C\%(\<end\>\|\]\|}\|)\)'
-  let pair_info = searchpairpos(start_pattern, '', end_pattern, 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()", max([0, a:lnum - g:elixir_indent_max_lookbehind]))
-  let pair_lnum = pair_info[0]
-  let pair_col = pair_info[1]
-  if pair_lnum != 0 || pair_col != 0
-    let pair_text = getline(pair_lnum)
-    let pair_char = pair_text[pair_col - 1]
-    if pair_char == 'f'
-      call s:debug("testing s:do_handle_inside_fn")
-      return s:do_handle_inside_fn(pair_lnum, pair_col, a:lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
-    elseif pair_char == '['
-      call s:debug("testing s:do_handle_inside_square_brace")
-      return s:do_handle_inside_square_brace(pair_lnum, pair_col, a:lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
-    elseif pair_char == '{'
-      call s:debug("testing s:do_handle_inside_curly_brace")
-      return s:do_handle_inside_curly_brace(pair_lnum, pair_col, a:lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
-    elseif pair_char == '('
-      call s:debug("testing s:do_handle_inside_parens")
-      return s:do_handle_inside_parens(pair_lnum, pair_col, a:lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
-    elseif pair_char == 'w'
-      call s:debug("testing s:do_handle_inside_with")
-      return s:do_handle_inside_with(pair_lnum, pair_col, a:lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
+  " hack - handle do: better
+  let block_info = searchpairpos(start_pattern, '', end_pattern, 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip() || getline(line('.')) =~ 'do:'", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
+  let block_start_lnum = block_info[0]
+  let block_start_col = block_info[1]
+  if block_start_lnum != 0 || block_start_col != 0
+    let block_text = getline(block_start_lnum)
+    let block_start_char = block_text[block_start_col - 1]
+
+    let never_match = '\(a\)\@=b'
+    let config = {
+          \'f': {'aligned_clauses': s:keyword('end'), 'pattern_match_clauses': never_match},
+          \'c': {'aligned_clauses': s:keyword('end'), 'pattern_match_clauses': never_match},
+          \'t': {'aligned_clauses': s:keyword('end\|catch\|rescue\|after'), 'pattern_match_clauses': s:keyword('catch\|rescue')},
+          \'r': {'aligned_clauses': s:keyword('end\|after'), 'pattern_match_clauses': s:keyword('after')},
+          \'i': {'aligned_clauses': s:keyword('end\|else'), 'pattern_match_clauses': never_match},
+          \'[': {'aligned_clauses': ']', 'pattern_match_clauses': never_match},
+          \'{': {'aligned_clauses': '}', 'pattern_match_clauses': never_match},
+          \'(': {'aligned_clauses': ')', 'pattern_match_clauses': never_match}
+          \}
+
+    if block_start_char == 'w'
+      call s:debug("testing s:handle_with")
+      return s:handle_with(block_start_lnum, block_start_col, a:context)
     else
-      call s:debug("testing s:do_handle_inside_keyword_block")
-      return s:do_handle_inside_keyword_block(pair_lnum, pair_col, a:lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
-    end
-  else
-    return -1
-  end
-endfunction
-
-function! s:do_handle_inside_with(pair_lnum, pair_col, lnum, text, prev_nb_lnum, prev_nb_text)
-  if a:pair_lnum == a:lnum
-    " This is the `with` line or an inline `with`/`do`
-    call s:debug("current line is `with`")
-    return -1
-  else
-    " Determine if in with/do, do/else|end, or else/end
-    let start_pattern = '\C\%(\<with\>\|\<else\>\|\<do\>\)'
-    let end_pattern = '\C\%(\<end\>\)'
-    let pair_info = searchpairpos(start_pattern, '', end_pattern, 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
-    let pair_lnum = pair_info[0]
-    let pair_col = pair_info[1]
-
-    let pair_text = getline(pair_lnum)
-    let pair_char = pair_text[pair_col - 1]
-
-    if s:starts_with(a:text, '\Cdo:', a:lnum)
-      call s:debug("current line is do:")
-      return pair_col - 1 + s:sw()
-    elseif s:starts_with(a:text, '\Celse:', a:lnum)
-      call s:debug("current line is else:")
-      return pair_col - 1
-    elseif s:starts_with(a:text, '\C\(\<do\>\|\<else\>\)', a:lnum)
-      call s:debug("current line is do/else")
-      return pair_col - 1
-    elseif s:starts_with(pair_text, '\C\(do\|else\):', pair_lnum)
-      call s:debug("inside do:/else:")
-      return pair_col - 1 + s:sw()
-    elseif pair_char == 'w'
-      call s:debug("inside with/do")
-      return pair_col + 4
-    elseif pair_char == 'd'
-      call s:debug("inside do/else|end")
-      return pair_col - 1 + s:sw()
-    else
-      call s:debug("inside else/end")
-      return s:do_handle_inside_pattern_match_block(pair_lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
-    end
-  end
-endfunction
-
-function! s:do_handle_inside_keyword_block(pair_lnum, _pair_col, _lnum, text, prev_nb_lnum, prev_nb_text)
-  let keyword_pattern = '\C\%(\<case\>\|\<cond\>\|\<try\>\|\<receive\>\|\<after\>\|\<catch\>\|\<rescue\>\|\<else\>\)'
-  if a:pair_lnum
-    " last line is a "receive" or something
-    if s:starts_with(a:prev_nb_text, keyword_pattern, a:prev_nb_lnum)
-      call s:debug("prev nb line is keyword")
-      return indent(a:prev_nb_lnum) + s:sw()
-    else
-      return s:do_handle_inside_pattern_match_block(a:pair_lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
-    end
-  else
-    return -1
-  endif
-endfunction
-
-" Implements indent for pattern-matching blocks (e.g. case, fn, with/else)
-function! s:do_handle_inside_pattern_match_block(block_start_lnum, text, prev_nb_lnum, prev_nb_text)
-  if a:text =~ '->'
-    call s:debug("current line contains ->")
-    return indent(a:block_start_lnum) + s:sw()
-  elseif a:prev_nb_text =~ '->'
-    call s:debug("prev nb line contains ->")
-    return indent(a:prev_nb_lnum) + s:sw()
-  else
-    return indent(a:prev_nb_lnum)
-  end
-endfunction
-
-function! s:do_handle_inside_fn(pair_lnum, _pair_col, lnum, text, prev_nb_lnum, prev_nb_text)
-  if a:pair_lnum && a:pair_lnum != a:lnum
-    return s:do_handle_inside_pattern_match_block(a:pair_lnum, a:text, a:prev_nb_lnum, a:prev_nb_text)
-  else
-    return -1
-  endif
-endfunction
-
-function! s:do_handle_inside_square_brace(pair_lnum, pair_col, _lnum, _text, _prev_nb_lnum, _prev_nb_text)
-  " If in list...
-  if a:pair_lnum != 0 || a:pair_col != 0
-    let pair_text = getline(a:pair_lnum)
-    let substr = strpart(pair_text, a:pair_col, len(pair_text)-1)
-    let indent_pos = match(substr, '\S')
-    if indent_pos != -1
-      return indent_pos + a:pair_col
-    else
-      return indent(a:pair_lnum) + s:sw()
-    endif
-  else
-    return -1
-  end
-endfunction
-
-function! s:do_handle_inside_curly_brace(pair_lnum, _pair_col, _lnum, _text, _prev_nb_lnum, _prev_nb_text)
-  return indent(a:pair_lnum) + s:sw()
-endfunction
-
-function! s:do_handle_inside_parens(pair_lnum, pair_col, _lnum, _text, prev_nb_lnum, prev_nb_text)
-  if a:pair_lnum
-    if s:ends_with(a:prev_nb_text, '(', a:prev_nb_lnum)
-      return indent(a:prev_nb_lnum) + s:sw()
-    elseif a:pair_lnum == a:prev_nb_lnum
-      " Align indent (e.g. "def add(a,")
-      let pos = s:find_last_pos(a:prev_nb_lnum, a:prev_nb_text, '[^(]\+,')
-      if pos == -1
-        return 0
+      let block_config = config[block_start_char]
+      if s:starts_with(a:context, block_config.aligned_clauses)
+        call s:debug("clause")
+        return indent(block_start_lnum)
       else
-        return pos
-      end
-    else
-      return indent(a:prev_nb_lnum)
+        let clause_lnum = searchpair(block_config.pattern_match_clauses, '', '*', 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()", block_start_lnum)
+        let relative_lnum = max([clause_lnum, block_start_lnum])
+        call s:debug("pattern matching relative to lnum " . relative_lnum)
+        return s:do_handle_pattern_match_block(relative_lnum, a:context)
+      endif
     end
   else
     return -1
-  endif
+  end
 endfunction
 
-function! elixir#indent#handle_inside_generic_block(lnum, _text, prev_nb_lnum, prev_nb_text)
-  let pair_lnum = searchpair(s:keyword('do\|fn'), '', s:keyword('end'), 'bW', "line('.') == ".a:lnum." || s:is_string_or_comment(line('.'), col('.'))", max([0, a:lnum - g:elixir_indent_max_lookbehind]))
+function! s:handle_with(start_lnum, start_col, context)
+  let block_info = searchpairpos('\C\%(\<with\>\|\<do\>\|\<else\>\)', '', s:keyword('end'), 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
+  let block_start_lnum = block_info[0]
+  let block_start_col = block_info[1]
+
+  let block_start_text = getline(block_start_lnum)
+  let block_start_char = block_start_text[block_start_col - 1]
+
+  if s:starts_with(a:context, s:keyword('do\|else\|end'))
+    return indent(a:start_lnum)
+  elseif block_start_char == 'w' || s:starts_with(a:context, '\C\(do\|else\):')
+    return indent(a:start_lnum) + 5
+  elseif s:_starts_with(block_start_text, '\C\(do\|else\):', a:start_lnum)
+    return indent(block_start_lnum) + s:sw()
+  else
+    return s:do_handle_pattern_match_block(a:start_lnum, a:context)
+  end
+endfunction
+
+function! s:do_handle_pattern_match_block(relative_line, context)
+  let relative_indent = indent(a:relative_line)
+  " hack!
+  if a:context.text =~ '\(fn.*\)\@<!->'
+    call s:debug("current line contains ->; assuming match definition")
+    return relative_indent + s:sw()
+  elseif search('\(fn.*\)\@<!->', 'bnW', a:relative_line) != 0
+    call s:debug("a previous line contains ->; assuming match handler")
+    return relative_indent + 2 * s:sw()
+  else
+    call s:debug("couldn't find any previous ->; assuming body text")
+    return relative_indent + s:sw()
+  end
+endfunction
+
+function! elixir#indent#handle_inside_generic_block(context)
+  let pair_lnum = searchpair(s:keyword('do\|fn'), '', s:keyword('end'), 'bW', "line('.') == ".a:context.lnum." || s:is_string_or_comment(line('.'), col('.'))", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
   if pair_lnum
     " TODO: @jbodah 2017-03-29: this should probably be the case in *all*
     " blocks
-    if s:ends_with(a:prev_nb_text, ',', a:prev_nb_lnum)
+    if s:prev_ends_with(a:context, ',')
       return indent(pair_lnum) + 2 * s:sw()
     else
       return indent(pair_lnum) + s:sw()

autoload/fish.vim

@@ -1,6 +1,7 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'fish') == -1
   
 function! fish#Indent()
+    let l:shiftwidth = shiftwidth()
     let l:prevlnum = prevnonblank(v:lnum - 1)
     if l:prevlnum ==# 0
         return 0
@@ -8,15 +9,15 @@ function! fish#Indent()
     let l:indent = 0
     let l:prevline = getline(l:prevlnum)
     if l:prevline =~# '\v^\s*switch>'
-        let l:indent = &shiftwidth * 2
+        let l:indent = l:shiftwidth * 2
     elseif l:prevline =~# '\v^\s*%(begin|if|else|while|for|function|case)>'
-        let l:indent = &shiftwidth
+        let l:indent = l:shiftwidth
     endif
     let l:line = getline(v:lnum)
     if l:line =~# '\v^\s*end>'
-        return indent(v:lnum) - (l:indent ==# 0 ? &shiftwidth : l:indent)
+        return indent(v:lnum) - (l:indent ==# 0 ? l:shiftwidth : l:indent)
     elseif l:line =~# '\v^\s*%(case|else)>'
-        return indent(v:lnum) - &shiftwidth
+        return indent(v:lnum) - l:shiftwidth
     endif
     return indent(l:prevlnum) + l:indent
 endfunction

autoload/go/config.vim

@@ -0,0 +1,440 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'go') == -1
+  
+function! go#config#AutodetectGopath() abort
+	return get(g:, 'go_autodetect_gopath', 0)
+endfunction
+
+function! go#config#ListTypeCommands() abort
+  return get(g:, 'go_list_type_commands', {})
+endfunction
+
+function! go#config#VersionWarning() abort
+  return get(g:, 'go_version_warning', 1)
+endfunction
+
+function! go#config#BuildTags() abort
+  return get(g:, 'go_build_tags', '')
+endfunction
+
+function! go#config#SetBuildTags(value) abort
+  if a:value is ''
+    silent! unlet g:go_build_tags
+    return
+  endif
+
+  let g:go_build_tags = a:value
+endfunction
+
+function! go#config#TestTimeout() abort
+ return get(g:, 'go_test_timeout', '10s')
+endfunction
+
+function! go#config#TestShowName() abort
+  return get(g:, 'go_test_show_name', 0)
+endfunction
+
+function! go#config#TermHeight() abort
+  return get(g:, 'go_term_height', winheight(0))
+endfunction
+
+function! go#config#TermWidth() abort
+  return get(g:, 'go_term_width', winwidth(0))
+endfunction
+
+function! go#config#TermMode() abort
+  return get(g:, 'go_term_mode', 'vsplit')
+endfunction
+
+function! go#config#TermEnabled() abort
+  return get(g:, 'go_term_enabled', 0)
+endfunction
+
+function! go#config#SetTermEnabled(value) abort
+  let g:go_term_enabled = a:value
+endfunction
+
+function! go#config#TemplateUsePkg() abort
+  return get(g:, 'go_template_use_pkg', 0)
+endfunction
+
+function! go#config#TemplateTestFile() abort
+  return get(g:, 'go_template_test_file', "hello_world_test.go")
+endfunction
+
+function! go#config#TemplateFile() abort
+  return get(g:, 'go_template_file', "hello_world.go")
+endfunction
+
+function! go#config#StatuslineDuration() abort
+  return get(g:, 'go_statusline_duration', 60000)
+endfunction
+
+function! go#config#SnippetEngine() abort
+  return get(g:, 'go_snippet_engine', 'automatic')
+endfunction
+
+function! go#config#PlayBrowserCommand() abort
+    if go#util#IsWin()
+        let go_play_browser_command = '!start rundll32 url.dll,FileProtocolHandler %URL%'
+    elseif go#util#IsMac()
+        let go_play_browser_command = 'open %URL%'
+    elseif executable('xdg-open')
+        let go_play_browser_command = 'xdg-open %URL%'
+    elseif executable('firefox')
+        let go_play_browser_command = 'firefox %URL% &'
+    elseif executable('chromium')
+        let go_play_browser_command = 'chromium %URL% &'
+    else
+        let go_play_browser_command = ''
+    endif
+
+    return get(g:, 'go_play_browser_command', go_play_browser_command)
+endfunction
+
+function! go#config#MetalinterDeadline() abort
+  " gometalinter has a default deadline of 5 seconds only when asynchronous
+  " jobs are not supported.
+
+  let deadline = '5s'
+  if go#util#has_job() && has('lambda')
+    let deadline = ''
+  endif
+
+  return get(g:, 'go_metalinter_deadline', deadline)
+endfunction
+
+function! go#config#ListType() abort
+  return get(g:, 'go_list_type', '')
+endfunction
+
+function! go#config#ListAutoclose() abort
+  return get(g:, 'go_list_autoclose', 1)
+endfunction
+
+function! go#config#InfoMode() abort
+  return get(g:, 'go_info_mode', 'gocode')
+endfunction
+
+function! go#config#GuruScope() abort
+  let scope = get(g:, 'go_guru_scope', [])
+
+  if !empty(scope)
+    " strip trailing slashes for each path in scope. bug:
+    " https://github.com/golang/go/issues/14584
+    let scopes = go#util#StripTrailingSlash(scope)
+  endif
+
+  return scope
+endfunction
+
+function! go#config#SetGuruScope(scope) abort
+  if empty(a:scope)
+    if exists('g:go_guru_scope')
+      unlet g:go_guru_scope
+    endif
+  else
+    let g:go_guru_scope = a:scope
+  endif
+endfunction
+
+let s:sock_type = (has('win32') || has('win64')) ? 'tcp' : 'unix'
+function! go#config#GocodeSocketType() abort
+  return get(g:, 'go_gocode_socket_type', s:sock_type)
+endfunction
+
+function! go#config#GocodeProposeBuiltins() abort
+  return get(g:, 'go_gocode_propose_builtins', 1)
+endfunction
+
+function! go#config#GocodeProposeSource() abort
+  return get(g:, 'go_gocode_propose_source', 1)
+endfunction
+
+function! go#config#EchoCommandInfo() abort
+  return get(g:, 'go_echo_command_info', 1)
+endfunction
+
+function! go#config#DocUrl() abort
+  let godoc_url = get(g:, 'go_doc_url', 'https://godoc.org')
+  if godoc_url isnot 'https://godoc.org'
+    " strip last '/' character if available
+    let last_char = strlen(godoc_url) - 1
+    if godoc_url[last_char] == '/'
+      let godoc_url = strpart(godoc_url, 0, last_char)
+    endif
+    " custom godoc installations expect /pkg before package names
+    let godoc_url .= "/pkg"
+  endif
+  return godoc_url
+endfunction
+
+function! go#config#DefReuseBuffer() abort
+  return get(g:, 'go_def_reuse_buffer', 0)
+endfunction
+
+function! go#config#DefMode() abort
+  return get(g:, 'go_def_mode', 'guru')
+endfunction
+
+function! go#config#DeclsIncludes() abort
+  return get(g:, 'go_decls_includes', 'func,type')
+endfunction
+
+function! go#config#Debug() abort
+  return get(g:, 'go_debug', [])
+endfunction
+
+function! go#config#DebugWindows() abort
+  return get(g:, 'go_debug_windows', {
+            \ 'stack': 'leftabove 20vnew',
+            \ 'out':   'botright 10new',
+            \ 'vars':  'leftabove 30vnew',
+            \ }
+         \ )
+
+endfunction
+
+function! go#config#DebugAddress() abort
+  return get(g:, 'go_debug_address', '127.0.0.1:8181')
+endfunction
+
+function! go#config#DebugCommands() abort
+  " make sure g:go_debug_commands is set so that it can be added to easily.
+  let g:go_debug_commands = get(g:, 'go_debug_commands', {})
+  return g:go_debug_commands
+endfunction
+
+function! go#config#SetDebugDiag(value) abort
+  let g:go_debug_diag = a:value
+endfunction
+
+function! go#config#AutoSameids() abort
+    return get(g:, 'go_auto_sameids', 0)
+endfunction
+
+function! go#config#SetAutoSameids(value) abort
+  let g:go_auto_sameids = a:value
+endfunction
+
+function! go#config#AddtagsTransform() abort
+  return get(g:, 'go_addtags_transform', "snakecase")
+endfunction
+
+function! go#config#TemplateAutocreate() abort
+  return get(g:, "go_template_autocreate", 1)
+endfunction
+
+function! go#config#SetTemplateAutocreate(value) abort
+  let g:go_template_autocreate = a:value
+endfunction
+
+function! go#config#MetalinterCommand() abort
+  return get(g:, "go_metalinter_command", "")
+endfunction
+
+function! go#config#MetalinterAutosaveEnabled() abort
+  return get(g:, 'go_metalinter_autosave_enabled', ['vet', 'golint'])
+endfunction
+
+function! go#config#MetalinterEnabled() abort
+  return get(g:, "go_metalinter_enabled", ['vet', 'golint', 'errcheck'])
+endfunction
+
+function! go#config#MetalinterDisabled() abort
+  return get(g:, "go_metalinter_disabled", [])
+endfunction
+
+function! go#config#GolintBin() abort
+  return get(g:, "go_golint_bin", "golint")
+endfunction
+
+function! go#config#ErrcheckBin() abort
+  return get(g:, "go_errcheck_bin", "errcheck")
+endfunction
+
+function! go#config#MetalinterAutosave() abort
+  return get(g:, "go_metalinter_autosave", 0)
+endfunction
+
+function! go#config#SetMetalinterAutosave(value) abort
+  let g:go_metalinter_autosave = a:value
+endfunction
+
+function! go#config#ListHeight() abort
+  return get(g:, "go_list_height", 0)
+endfunction
+
+function! go#config#FmtAutosave() abort
+	return get(g:, "go_fmt_autosave", 1)
+endfunction
+
+function! go#config#SetFmtAutosave(value) abort
+  let g:go_fmt_autosave = a:value
+endfunction
+
+function! go#config#AsmfmtAutosave() abort
+  return get(g:, "go_asmfmt_autosave", 0)
+endfunction
+
+function! go#config#SetAsmfmtAutosave(value) abort
+  let g:go_asmfmt_autosave = a:value
+endfunction
+
+function! go#config#ModFmtAutosave() abort
+	return get(g:, "go_mod_fmt_autosave", 1)
+endfunction
+
+function! go#config#SetModFmtAutosave(value) abort
+  let g:go_mod_fmt_autosave = a:value
+endfunction
+
+function! go#config#DocMaxHeight() abort
+  return get(g:, "go_doc_max_height", 20)
+endfunction
+
+function! go#config#AutoTypeInfo() abort
+  return get(g:, "go_auto_type_info", 0)
+endfunction
+
+function! go#config#SetAutoTypeInfo(value) abort
+  let g:go_auto_type_info = a:value
+endfunction
+
+function! go#config#AlternateMode() abort
+  return get(g:, "go_alternate_mode", "edit")
+endfunction
+
+function! go#config#DeclsMode() abort
+  return get(g:, "go_decls_mode", "")
+endfunction
+
+function! go#config#DocCommand() abort
+  return get(g:, "go_doc_command", ["godoc"])
+endfunction
+
+function! go#config#FmtCommand() abort
+  return get(g:, "go_fmt_command", "gofmt")
+endfunction
+
+function! go#config#FmtOptions() abort
+  return get(g:, "go_fmt_options", {})
+endfunction
+
+function! go#config#FmtFailSilently() abort
+  return get(g:, "go_fmt_fail_silently", 0)
+endfunction
+
+function! go#config#FmtExperimental() abort
+  return get(g:, "go_fmt_experimental", 0 )
+endfunction
+
+function! go#config#PlayOpenBrowser() abort
+  return get(g:, "go_play_open_browser", 1)
+endfunction
+
+function! go#config#GorenameBin() abort
+  return get(g:, "go_gorename_bin", "gorename")
+endfunction
+
+function! go#config#GorenamePrefill() abort
+  return get(g:, "go_gorename_prefill", 'expand("<cword>") =~# "^[A-Z]"' .
+          \ '? go#util#pascalcase(expand("<cword>"))' .
+          \ ': go#util#camelcase(expand("<cword>"))')
+endfunction
+
+function! go#config#TextobjIncludeFunctionDoc() abort
+  return get(g:, "go_textobj_include_function_doc", 1)
+endfunction
+
+function! go#config#TextobjIncludeVariable() abort
+  return get(g:, "go_textobj_include_variable", 1)
+endfunction
+
+function! go#config#BinPath() abort
+  return get(g:, "go_bin_path", "")
+endfunction
+
+function! go#config#HighlightArrayWhitespaceError() abort
+  return get(g:, 'go_highlight_array_whitespace_error', 0)
+endfunction
+
+function! go#config#HighlightChanWhitespaceError() abort
+  return get(g:, 'go_highlight_chan_whitespace_error', 0)
+endfunction
+
+function! go#config#HighlightExtraTypes() abort
+  return get(g:, 'go_highlight_extra_types', 0)
+endfunction
+
+function! go#config#HighlightSpaceTabError() abort
+  return get(g:, 'go_highlight_space_tab_error', 0)
+endfunction
+
+function! go#config#HighlightTrailingWhitespaceError() abort
+  return get(g:, 'go_highlight_trailing_whitespace_error', 0)
+endfunction
+
+function! go#config#HighlightOperators() abort
+  return get(g:, 'go_highlight_operators', 0)
+endfunction
+
+function! go#config#HighlightFunctions() abort
+  return get(g:, 'go_highlight_functions', 0)
+endfunction
+
+function! go#config#HighlightFunctionArguments() abort
+  return get(g:, 'go_highlight_function_arguments', 0)
+endfunction
+
+function! go#config#HighlightFunctionCalls() abort
+  return get(g:, 'go_highlight_function_calls', 0)
+endfunction
+
+function! go#config#HighlightFields() abort
+  return get(g:, 'go_highlight_fields', 0)
+endfunction
+
+function! go#config#HighlightTypes() abort
+  return get(g:, 'go_highlight_types', 0)
+endfunction
+
+function! go#config#HighlightBuildConstraints() abort
+  return get(g:, 'go_highlight_build_constraints', 0)
+endfunction
+
+function! go#config#HighlightStringSpellcheck() abort
+  return get(g:, 'go_highlight_string_spellcheck', 1)
+endfunction
+
+function! go#config#HighlightFormatStrings() abort
+  return get(g:, 'go_highlight_format_strings', 1)
+endfunction
+
+function! go#config#HighlightGenerateTags() abort
+  return get(g:, 'go_highlight_generate_tags', 0)
+endfunction
+
+function! go#config#HighlightVariableAssignments() abort
+  return get(g:, 'go_highlight_variable_assignments', 0)
+endfunction
+
+function! go#config#HighlightVariableDeclarations() abort
+  return get(g:, 'go_highlight_variable_declarations', 0)
+endfunction
+
+function! go#config#FoldEnable(...) abort
+  if a:0 > 0
+    return index(go#config#FoldEnable(), a:1) > -1
+  endif
+  return get(g:, 'go_fold_enable', ['block', 'import', 'varconst', 'package_comment'])
+endfunction
+
+" Set the default value. A value of "1" is a shortcut for this, for
+" compatibility reasons.
+if exists("g:go_gorename_prefill") && g:go_gorename_prefill == 1
+  unlet g:go_gorename_prefill
+endif
+
+" vim: sw=2 ts=2 et
+
+endif

autoload/julia.vim

@@ -0,0 +1,188 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+  
+function! julia#set_syntax_version(jvers)
+  if &filetype != "julia"
+    echo "Not a Julia file"
+    return
+  endif
+  syntax clear
+  let b:julia_syntax_version = a:jvers
+  set filetype=julia
+endfunction
+
+function! julia#toggle_deprecated_syntax()
+  if &filetype != "julia"
+    echo "Not a Julia file"
+    return
+  endif
+  syntax clear
+  let hd = get(b:, "julia_syntax_highlight_deprecated",
+      \    get(g:, "julia_syntax_highlight_deprecated", 0))
+  let b:julia_syntax_highlight_deprecated = hd ? 0 : 1
+  set filetype=julia
+  if b:julia_syntax_highlight_deprecated
+    echo "Highlighting of deprecated syntax enabled"
+  else
+    echo "Highlighting of deprecated syntax disabled"
+  endif
+endfunction
+
+if exists("loaded_matchit")
+
+function! julia#toggle_function_blockassign()
+    let sav_pos = getcurpos()
+    let l = getline('.')
+    let c = match(l, '\C\m\<function\s\+.\+(')
+    if c != -1
+        return julia#function_block2assign()
+    endif
+    let c = match(l, '\C\m)\%(::\S\+\)\?\%(\s\+where\s\+.*\)\?\s*=\s*')
+    if c == -1
+        echohl WarningMsg | echo "Not on a function definition or assignment line" | echohl None
+        return
+    endif
+    return julia#function_assign2block()
+endfunction
+
+function! julia#function_block2assign()
+    let sav_pos = getcurpos()
+    let l = getline('.')
+    let c = match(l, '\C\m\<function\s\+.\+(')
+    if c == -1
+        echohl WarningMsg | echo "Not on a function definition line" | echohl None
+        return
+    endif
+    let fpos = copy(sav_pos)
+    let fpos[2] = c+1
+    call setpos('.', fpos)
+    normal %
+    if line('.') != fpos[1]+2 || match(getline('.'), '\C\m^\s*end\s*$') == -1
+        echohl WarningMsg | echo "Only works with 3-lines functions" | echohl None
+        call setpos('.', sav_pos)
+        return
+    endif
+    call setpos('.', fpos)
+    normal! f(
+    normal %
+    while line('.') == fpos[1] && match(l[col('.')-1:], '\C\m)(') == 0
+        normal! l
+        normal %
+    endwhile
+    if line('.') != fpos[1] || match(l[(col('.')-1):], '\C\m)\%(::\S\+\)\?\%(\s\+where\s\+.*\)\?\s*$') != 0
+        echohl WarningMsg | echo "Unrecognized function definition format" | echohl None
+        call setpos('.', sav_pos)
+        return
+    endif
+
+    call setpos('.', fpos)
+    normal! dwA = J
+    if match(getline('.')[(col('.')-1):], '\C\mreturn\>') == 0
+        normal! dw
+    endif
+    if match(getline('.')[(col('.')-1):], '\C\m\s*$') == 0
+        normal! F=C= nothing
+    endif
+    normal! jddk^
+    return
+endfunction
+
+function! julia#function_assign2block()
+    let sav_pos = getcurpos()
+    let l = getline('.')
+    let c = match(l, '\C\m)\%(::\S\+\)\?\%(\s\+where\s\+.*\)\?\s*=\s*')
+    if c == -1
+        echohl WarningMsg | echo "Not on a function assignment-definition line" | echohl None
+        return
+    endif
+    normal ^
+    while match(l[(col('.')-1):], '\%(\S\+\.\)*@') == 0
+        normal! W
+    endwhile
+    normal! ifunction 
+    let l = getline('.')
+    let c = match(l, '\C\m)\%(::\S\+\)\?\%(\s\+where\s\+.*\)\?\s*\zs=\s*')
+    let eqpos = copy(sav_pos)
+    let eqpos[2] = c+1
+    call setpos('.', eqpos)
+    normal! cw
+oend
+    normal %
+    s/\s*$// | noh
+    return
+endfunction
+
+
+let s:nonid_chars = "\U01-\U07" . "\U0E-\U1F" .
+      \             "\"#$'(,.:;=?@`\\U5B{" .
+      \             "\U80-\UA1" . "\UA7\UA8\UAB\UAD\UAF\UB4" . "\UB6-\UB8" . "\UBB\UBF"
+
+let s:nonidS_chars = "[:space:])\\U5D}" . s:nonid_chars
+
+" the following excludes '!' since it can be used as an identifier,
+" and '$' since it can be used in interpolations
+" note that \U2D is '-'
+let s:uniop_chars = "+\\U2D~¬√∛∜"
+
+let s:binop_chars = "=+\\U2D*/\\%÷^&|⊻<>≤≥≡≠≢∈∉⋅×∪∩⊆⊈⊂⊄⊊←→∋∌⊕⊖⊞⊟∘∧⊗⊘↑↓∨⊠±"
+
+" the following is a list of all remainig valid operator chars,
+" but it's more efficient when expressed with ranges (see below)
+" let s:binop_chars_extra = "↔↚↛↠↣↦↮⇎⇏⇒⇔⇴⇶⇷⇸⇹⇺⇻⇼⇽⇾⇿⟵⟶⟷⟷⟹⟺⟻⟼⟽⟾⟿⤀⤁⤂⤃⤄⤅⤆⤇⤌⤍⤎⤏⤐⤑⤔⤕⤖⤗⤘⤝⤞⤟⤠⥄⥅⥆⥇⥈⥊⥋⥎⥐⥒⥓⥖⥗⥚⥛⥞⥟⥢⥤⥦⥧⥨⥩⥪⥫⥬⥭⥰⧴⬱⬰⬲⬳⬴⬵⬶⬷⬸⬹⬺⬻⬼⬽⬾⬿⭀⭁⭂⭃⭄⭇⭈⭉⭊⭋⭌￩￫" .
+"       \                   "∝∊∍∥∦∷∺∻∽∾≁≃≄≅≆≇≈≉≊≋≌≍≎≐≑≒≓≔≕≖≗≘≙≚≛≜≝≞≟≣≦≧≨≩≪≫≬≭≮≯≰≱≲≳≴≵≶≷≸≹≺≻≼≽≾≿⊀⊁⊃⊅⊇⊉⊋⊏⊐⊑⊒⊜⊩⊬⊮⊰⊱⊲⊳⊴⊵⊶⊷⋍⋐⋑⋕⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩⋪⋫⋬⋭⋲⋳⋴⋵⋶⋷⋸⋹⋺⋻⋼⋽⋾⋿⟈⟉⟒⦷⧀⧁⧡⧣⧤⧥⩦⩧⩪⩫⩬⩭⩮⩯⩰⩱⩲⩳⩴⩵⩶⩷⩸⩹⩺⩻⩼⩽⩾⩿⪀⪁⪂⪃⪄⪅⪆⪇⪈⪉⪊⪋⪌⪍⪎⪏⪐⪑⪒⪓⪔⪕⪖⪗⪘⪙⪚⪛⪜⪝⪞⪟⪠⪡⪢⪣⪤⪥⪦⪧⪨⪩⪪⪫⪬⪭⪮⪯⪰⪱⪲⪳⪴⪵⪶⪷⪸⪹⪺⪻⪼⪽⪾⪿⫀⫁⫂⫃⫄⫅⫆⫇⫈⫉⫊⫋⫌⫍⫎⫏⫐⫑⫒⫓⫔⫕⫖⫗⫘⫙⫷⫸⫹⫺⊢⊣" .
+"       \                   "⊔∓∔∸≂≏⊎⊽⋎⋓⧺⧻⨈⨢⨣⨤⨥⨦⨧⨨⨩⨪⨫⨬⨭⨮⨹⨺⩁⩂⩅⩊⩌⩏⩐⩒⩔⩖⩗⩛⩝⩡⩢⩣" .
+"       \                   "⊙⊚⊛⊡⊓∗∙∤⅋≀⊼⋄⋆⋇⋉⋊⋋⋌⋏⋒⟑⦸⦼⦾⦿⧶⧷⨇⨰⨱⨲⨳⨴⨵⨶⨷⨸⨻⨼⨽⩀⩃⩄⩋⩍⩎⩑⩓⩕⩘⩚⩜⩞⩟⩠⫛⊍▷⨝⟕⟖⟗" .
+"       \                   "⇵⟰⟱⤈⤉⤊⤋⤒⤓⥉⥌⥍⥏⥑⥔⥕⥘⥙⥜⥝⥠⥡⥣⥥⥮⥯￪￬"
+
+" same as above, but with character ranges, for performance
+let s:binop_chars_extra = "\\U214B\\U2190-\\U2194\\U219A\\U219B\\U21A0\\U21A3\\U21A6\\U21AE\\U21CE\\U21CF\\U21D2\\U21D4\\U21F4-\\U21FF\\U2208-\\U220D\\U2213\\U2214\\U2217-\\U2219\\U221D\\U2224-\\U222A\\U2237\\U2238\\U223A\\U223B\\U223D\\U223E\\U2240-\\U228B\\U228D-\\U229C\\U229E-\\U22A3\\U22A9\\U22AC\\U22AE\\U22B0-\\U22B7\\U22BB-\\U22BD\\U22C4-\\U22C7\\U22C9-\\U22D3\\U22D5-\\U22ED\\U22F2-\\U22FF\\U25B7\\U27C8\\U27C9\\U27D1\\U27D2\\U27D5-\\U27D7\\U27F0\\U27F1\\U27F5-\\U27F7\\U27F7\\U27F9-\\U27FF\\U2900-\\U2918\\U291D-\\U2920\\U2944-\\U2970\\U29B7\\U29B8\\U29BC\\U29BE-\\U29C1\\U29E1\\U29E3-\\U29E5\\U29F4\\U29F6\\U29F7\\U29FA\\U29FB\\U2A07\\U2A08\\U2A1D\\U2A22-\\U2A2E\\U2A30-\\U2A3D\\U2A40-\\U2A45\\U2A4A-\\U2A58\\U2A5A-\\U2A63\\U2A66\\U2A67\\U2A6A-\\U2AD9\\U2ADB\\U2AF7-\\U2AFA\\U2B30-\\U2B44\\U2B47-\\U2B4C\\UFFE9-\\UFFEC"
+
+" a Julia identifier, sort of
+let s:idregex = '[^' . s:nonidS_chars . '0-9!' . s:uniop_chars . s:binop_chars . '][^' . s:nonidS_chars . s:uniop_chars . s:binop_chars . s:binop_chars_extra . ']*'
+
+let s:operators = '\%(' . '\.\%([-+*/^÷%|&!]\|//\|\\\|<<\|>>>\?\)\?=' .
+      \           '\|'  . '[:$<>]=\|||\|&&\||>\|<|\|<:\|:>\|::\|<<\|>>>\?\|//\|[-=]>\|\.\{3\}' .
+      \           '\|'  . '[' . s:uniop_chars . '!$]' .
+      \           '\|'  . '\.\?[' . s:binop_chars . s:binop_chars_extra . ']' .
+      \           '\)'
+
+function! julia#idundercursor()
+    " TODO...
+    let w = expand('<cword>')
+    " let [l,c] = [line('.'),col('.')]
+    " let ll = getline(l)
+    return w
+endfunction
+
+function! julia#gotodefinition()
+    let w = julia#idundercursor()
+    if empty(w)
+        return ''
+    endif
+    let [l,c] = [line('.'),col('.')]
+    let st = map(synstack(l,c), 'synIDattr(v:val, "name")')
+    let n = len(st)
+    if n > 0 && st[-1] =~# '^julia\%(\%(Range\|Ternary\|CTrans\)\?Operator\|\%(Possible\)\?SymbolS\?\|\%(Bl\|Rep\)\?Keyword\|Conditional\|ParDelim\|Char\|Colon\|Typedef\|Number\|Float\|Const\%(Generic\|Bool\)\|ComplexUnit\|\%(Special\|\%(Octal\|Hex\)Escape\)Char\|UniChar\%(Small\|Large\)\|Comment[LM]\|Todo\|Semicolon\)$'
+        return ''
+    endif
+
+    let comprehension = 0
+    let indollar = 0
+    for i in range(n-1, 0, -1)
+        if st[i] =~# '^juliaDollar\%(Var\|Par\|SqBra\)$'
+            let indollar = 1
+        endif
+        if !indollar && st[i] =~# '^julia\%(\a*String\|QuotedParBlockS\?\)$'
+            return ''
+        endif
+        if st[i] =~# '^julia\%(ParBlock\%(InRange\)\?\|SqBraBlock\|\%(Dollar\|StringVars\)\%(Par\|SqBra\)\)$'
+            let comprehension = 1
+        endif
+    endfor
+
+    let s1 = search('\C\<' . w . '\s*=[^=]', 'bcWzs')
+
+    return
+endfunction
+
+endif
+

autoload/julia/doc.vim

@@ -0,0 +1,246 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+  
+" path to the julia binary to communicate with
+if has('win32') || has('win64')
+  if exists('g:julia#doc#juliapath')
+    " use assigned g:julia#doc#juliapath
+  elseif executable('julia')
+    " use julia command in PATH
+    let g:julia#doc#juliapath = 'julia'
+  else
+    " search julia binary in the default installation paths
+    let pathlist = sort(glob($LOCALAPPDATA . '\Julia-*\bin\julia.exe', 1, 1))
+    let g:julia#doc#juliapath = get(pathlist, -1, 'julia')
+  endif
+else
+  let g:julia#doc#juliapath = get(g:, 'julia#doc#juliapath', 'julia')
+endif
+
+function! s:version() abort
+  let VERSION = {'major': 0, 'minor': 0}
+  if !executable(g:julia#doc#juliapath)
+    return VERSION
+  endif
+
+  let cmd = printf('%s -v', g:julia#doc#juliapath)
+  let output = system(cmd)
+  let versionstr = matchstr(output, '\C^julia version \zs\d\+\.\d\+\ze')
+  let [major, minor] = map(split(versionstr, '\.'), 'str2nr(v:val)')
+  let VERSION.major = major
+  let VERSION.minor = minor
+  return VERSION
+endfunction
+
+let s:VERSION = s:version()
+let s:NODOCPATTERN = '\C\VNo documentation found.'
+
+function! julia#doc#lookup(keyword, ...) abort
+  let juliapath = get(a:000, 0, g:julia#doc#juliapath)
+  let keyword = escape(a:keyword, '"\')
+  let cmd = printf('%s -E "@doc %s"', juliapath, keyword)
+  return systemlist(cmd)
+endfunction
+
+function! julia#doc#open(keyword) abort
+  if empty(a:keyword)
+    call s:warn('Not an appropriate keyword.')
+    return
+  endif
+
+  if !executable(g:julia#doc#juliapath)
+    call s:warn('%s command is not executable', g:julia#doc#juliapath)
+    return
+  endif
+
+  let doc = julia#doc#lookup(a:keyword, g:julia#doc#juliapath)
+  if empty(doc) || match(doc[0], s:NODOCPATTERN) > -1
+    call s:warn('No documentation found for "%s".', a:keyword)
+    return
+  endif
+
+  " workaround for * and ? since a buffername cannot include them
+  let keyword = a:keyword
+  let keyword = substitute(keyword, '\*', ':asterisk:', 'g')
+  let keyword = substitute(keyword, '?', ':question:', 'g')
+  let buffername = printf('juliadoc: %s', keyword)
+
+  call s:write_to_preview_window(doc, "juliadoc", buffername)
+
+  call filter(s:HELPHISTORY, 'v:val isnot# a:keyword')
+  call add(s:HELPHISTORY, a:keyword)
+endfunction
+
+function! s:write_to_preview_window(content, ftype, buffername)
+  " Are we in the preview window from the outset? If not, best to close any
+  " preview windows that might exist.
+  let pvw = &previewwindow
+  if !pvw
+    silent! pclose!
+  endif
+  execute "silent! pedit +setlocal\\ nobuflisted\\ noswapfile\\"
+        \ "buftype=nofile\\ bufhidden=wipe" a:buffername
+  silent! wincmd P
+  if &previewwindow
+    setlocal modifiable noreadonly
+    silent! %delete _
+    call append(0, a:content)
+    silent! $delete _
+    normal! ggj
+    setlocal nomodified readonly nomodifiable
+    execute "setfiletype" a:ftype
+    " Only return to a normal window if we didn't start in a preview window.
+    if !pvw
+      silent! wincmd p
+    endif
+  else
+    " We couldn't make it to the preview window, so as a fallback we dump the
+    " contents in the status area.
+    execute printf("echo '%s'", join(a:content, "\n"))
+  endif
+endfunction
+
+function! s:warn(...) abort
+  if a:0 == 0
+    return
+  endif
+
+  echohl WarningMsg
+  try
+    if a:0 == 1
+      echo a:1
+    else
+      echo call('printf', a:000)
+    endif
+  finally
+    echohl None
+  endtry
+endfunction
+
+
+
+let s:KEYWORDPATTERN = '\m@\?\h\k*!\?'
+
+" This function is called in normal mode or visual mode.
+function! julia#doc#keywordprg(word) abort
+  if a:word is# ''
+    return
+  endif
+
+  let word = s:unfnameescape(a:word)
+  if word is# expand('<cword>')
+    " 'K' in normal mode
+    " NOTE: Because ! and @ is not in 'iskeyword' option, this func ignore
+    "       the argument to recognize keywords like "@time" and "push!"
+    let view = winsaveview()
+    let lnum = line('.')
+    let tail = searchpos(s:KEYWORDPATTERN, 'ce', lnum)
+    let head = searchpos(s:KEYWORDPATTERN, 'bc', lnum)
+    call winrestview(view)
+    if head == [0, 0] || tail == [0, 0]
+      return
+    else
+      let start = head[1] - 1
+      let end = tail[1] - 1
+      let word = getline(lnum)[start : end]
+    endif
+  endif
+  call julia#doc#open(word)
+endfunction
+
+if exists('+shellslash')
+  let s:ESCAPEDCHARS = " \t\n\"#%'*<?`|"
+else
+  let s:ESCAPEDCHARS = " \t\n*?[{`$\\%#'\"|!<"
+endif
+let s:FNAMEESCAPEPATTERN = '\\\ze[' . escape(s:ESCAPEDCHARS, ']^-\') . ']'
+
+" this function reproduces an original string escaped by fnameescape()
+function! s:unfnameescape(str) abort
+  if a:str is# ''
+    return ''
+  endif
+
+  " NOTE: We cannot determine the original string if a:str starts from '\-',
+  "       '\+' or '\>' because fnameescape('-') ==# fnameescape('\-').
+  if a:str is# '\-'
+    " Remove escape anyway.
+    return '-'
+  endif
+
+  if a:str =~# '^\\[+>]'
+    let str = a:str[1:]
+  else
+    let str = a:str
+  endif
+  return substitute(str, s:FNAMEESCAPEPATTERN, '', 'g')
+endfunction
+
+
+
+let s:HELPPROMPT = 'help?> '
+let s:HELPHISTORY = []
+
+function! julia#doc#prompt() abort
+  let inputhist = s:savehistory('input')
+  echohl MoreMsg
+  try
+    call s:restorehistory('input', s:HELPHISTORY)
+    let keyword = input(s:HELPPROMPT, '', 'customlist,julia#doc#complete')
+
+    " Clear the last prompt
+    normal! :
+  finally
+    echohl None
+    call s:restorehistory('input', inputhist)
+  endtry
+
+  if empty(keyword)
+    return
+  endif
+
+  call julia#doc#open(keyword)
+endfunction
+
+function! s:savehistory(name) abort
+  if histnr(a:name) == -1
+    return []
+  endif
+
+  let history = []
+  for i in range(1, histnr(a:name))
+    let item = histget(a:name, i)
+    if !empty(item)
+      call add(history, item)
+    endif
+  endfor
+  return history
+endfunction
+
+function! s:restorehistory(name, history) abort
+  call histdel(a:name)
+  for item in a:history
+    call histadd(a:name, item)
+  endfor
+endfunction
+
+
+
+if s:VERSION.major == 0 && s:VERSION.minor <= 6
+  let s:REPL_SEARCH = 'Base.Docs.repl_search'
+else
+  let s:REPL_SEARCH = 'import REPL.repl_search; repl_search'
+endif
+
+function! julia#doc#complete(ArgLead, CmdLine, CursorPos) abort
+  return s:likely(a:ArgLead)
+endfunction
+
+function! s:likely(str) abort
+  " escape twice
+  let str = escape(escape(a:str, '"\'), '"\')
+  let cmd = printf('%s -E "%s(\"%s\")"', g:julia#doc#juliapath, s:REPL_SEARCH, str)
+  let output = systemlist(cmd)
+  return split(matchstr(output[0], '\C^search: \zs.*'))
+endfunction
+
+endif

autoload/julia_blocks.vim

@@ -0,0 +1,798 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+  
+" Facilities for moving around Julia blocks (e.g. if/end, function/end etc.)
+" (AKA a collection of horrible hacks)
+
+let s:default_mappings = {
+  \  "moveblock_n" : "]]",
+  \  "moveblock_N" : "][",
+  \  "moveblock_p" : "[[",
+  \  "moveblock_P" : "[]",
+  \
+  \  "move_n" : "]j",
+  \  "move_N" : "]J",
+  \  "move_p" : "[j",
+  \  "move_P" : "[J",
+  \
+  \  "select_a" : "aj",
+  \  "select_i" : "ij",
+  \
+  \  "whereami" : "",
+  \  }
+
+function! s:getmapchars(function)
+  if exists("g:julia_blocks_mappings") && has_key(g:julia_blocks_mappings, a:function)
+    return s:escape(g:julia_blocks_mappings[a:function])
+  else
+    return s:escape(s:default_mappings[a:function])
+  endif
+endfunction
+
+function! s:map_move(function, toend, backwards)
+  let chars = s:getmapchars(a:function)
+  if empty(chars)
+    return
+  endif
+  let fn = "julia_blocks#" . a:function
+  let lhs = "<buffer> <nowait> <silent> " . chars . " "
+  let cnt = ":<C-U>let b:jlblk_count=v:count1"
+  exe "nnoremap " . lhs . cnt
+    \ . " <Bar> call " . fn . "()<CR>"
+  exe "onoremap " . lhs . cnt
+    \ . "<CR><Esc>:call julia_blocks#owrapper_move(v:operator, \"" . fn . "\", " . a:toend . ", " . a:backwards . ")<CR>"
+  exe "xnoremap " . lhs . cnt
+    \ . "<CR>gv<Esc>:call julia_blocks#vwrapper_move(\"" . fn . "\")<CR>"
+  let b:jlblk_mapped[a:function] = 1
+endfunction
+
+function! julia_blocks#owrapper_move(oper, function, toend, backwards)
+  let F = function(a:function)
+
+  let save_redraw = &lazyredraw
+  let save_select = &selection
+
+  let restore_cmds = "\<Esc>"
+    \ . ":let &l:selection = \"" . save_select . "\"\<CR>"
+    \ . ":let &l:lazyredraw = " . save_redraw . "\<CR>"
+    \ . ":\<BS>"
+
+  setlocal lazyredraw
+
+  let start_pos = getpos('.')
+  let b:jlblk_abort_calls_esc = 0
+  call F()
+  let b:jlblk_abort_calls_esc = 1
+  let end_pos = getpos('.')
+  if start_pos == end_pos
+    call feedkeys(restore_cmds, 'n')
+  endif
+
+  let &l:selection = "inclusive"
+  if a:backwards || !a:toend
+    let &l:selection = "exclusive"
+  endif
+  if a:toend && a:backwards
+    let end_pos[2] += 1
+  endif
+
+  if s:compare_pos(start_pos, end_pos) > 0
+    let [start_pos, end_pos] = [end_pos, start_pos]
+  endif
+
+  call setpos("'<", start_pos)
+  call setpos("'>", end_pos)
+
+  " NOTE: the 'c' operator behaves differently, for mysterious reasons. We
+  "       simulate it with 'd' followed by 'i' instead
+  call feedkeys("gv" . (a:oper == "c" ? "d" : a:oper) . restore_cmds . (a:oper == "c" ? "i" : ""), 'n')
+endfunction
+
+function! julia_blocks#vwrapper_move(function)
+  let F = function(a:function)
+
+  let s = getpos('.')
+  let b1 = getpos("'<")
+  let b2 = getpos("'>")
+
+  let b = b1 == s ? b2 : b1
+  call setpos('.', s)
+  let b:jlblk_abort_calls_esc = 0
+  call F()
+  let b:jlblk_abort_calls_esc = 1
+  let e = getpos('.')
+  call setpos('.', b)
+  exe "normal " . visualmode()
+  call setpos('.', e)
+endfunction
+
+function! s:unmap(function)
+  if !get(b:jlblk_mapped, a:function, 0)
+    return
+  endif
+  let chars = s:getmapchars(a:function)
+  if empty(chars)
+    " shouldn't happen
+    return
+  endif
+  let mapids = a:function =~# "^move" ? ["n", "x", "o"] :
+	\      a:function =~# "^select" ? ["x", "o"] :
+	\      ["n"]
+  let fn = "julia_blocks#" . a:function
+  let cmd = "<buffer> " . chars
+  for m in mapids
+    exe m . "unmap " . cmd
+  endfor
+  let b:jlblk_mapped[a:function] = 0
+endfunction
+
+function! s:escape(chars)
+  let c = a:chars
+  let c = substitute(c, '|', '<Bar>', 'g')
+  return c
+endfunction
+
+function! s:map_select(function)
+  let chars = s:getmapchars(a:function)
+  if empty(chars)
+    return
+  endif
+  let fn = "julia_blocks#" . a:function
+  let lhs = "<buffer> <nowait> <silent> " . chars . " "
+  let cnt = ":<C-U>let b:jlblk_inwrapper=1<CR>:let b:jlblk_count=max([v:prevcount,1])<CR>"
+  exe "onoremap " . lhs . "<Esc>" . cnt
+    \ . ":call julia_blocks#owrapper_select(v:operator, \"" . fn . "\")<CR>"
+  exe "xnoremap " . lhs . cnt
+    \ . ":call julia_blocks#vwrapper_select(\"" . fn . "\")<CR>"
+  let b:jlblk_mapped[a:function] = 1
+endfunction
+
+function! julia_blocks#owrapper_select(oper, function) ", toend, backwards)
+  let F = function(a:function)
+
+  let save_redraw = &lazyredraw
+  let save_select = &selection
+
+  let restore_cmds = "\<Esc>"
+    \ . ":let &l:selection = \"" . save_select . "\"\<CR>"
+    \ . ":let &l:lazyredraw = " . save_redraw . "\<CR>"
+    \ . ":\<BS>"
+
+  setlocal lazyredraw
+
+  let b:jlblk_abort_calls_esc = 0
+  let retF = F()
+  let b:jlblk_abort_calls_esc = 1
+  if empty(retF)
+    let b:jlblk_inwrapper = 0
+    call feedkeys(restore_cmds, 'n')
+    return
+  end
+  let [start_pos, end_pos] = retF
+
+  if start_pos == end_pos
+    call feedkeys(restore_cmds, 'n')
+  endif
+
+  let &l:selection = "inclusive"
+
+  call setpos("'<", start_pos)
+  call setpos("'>", end_pos)
+
+  let b:jlblk_inwrapper = 0
+  " NOTE: the 'c' operator behaves differently, for mysterious reasons. We
+  "       simulate it with 'd' followed by 'i' instead
+  call feedkeys("gv" . (a:oper == "c" ? "d" : a:oper) . restore_cmds . (a:oper == "c" ? "i" : ""), 'n')
+endfunction
+
+function! julia_blocks#vwrapper_select(function)
+  let F = function(a:function)
+
+  let b:jlblk_abort_calls_esc = 0
+  let retF = F()
+  let b:jlblk_abort_calls_esc = 1
+  if empty(retF)
+    let b:jlblk_inwrapper = 0
+    return
+  end
+  let [start_pos, end_pos] = retF
+  call setpos("'<", start_pos)
+  call setpos("'>", end_pos)
+  normal! gv
+  let b:jlblk_inwrapper = 0
+endfunction
+
+function! s:map_aux(function)
+  let chars = s:getmapchars(a:function)
+  if empty(chars)
+    return
+  endif
+  let fn = "julia_blocks#" . a:function
+  let lhs = "<buffer> <nowait> <silent> " . chars . " "
+  exe "nnoremap " . lhs . ":<C-U>echo " . fn . "()<CR>"
+  let b:jlblk_mapped[a:function] = 1
+endfunction
+
+let s:julia_blocks_functions = {
+      \  "moveblock_N": [1, 0],
+      \  "moveblock_n": [0, 0],
+      \  "moveblock_p": [0, 1],
+      \  "moveblock_P": [1, 1],
+      \
+      \  "move_N": [1, 0],
+      \  "move_n": [0, 0],
+      \  "move_p": [0, 1],
+      \  "move_P": [1, 1],
+      \
+      \  "select_a": [],
+      \  "select_i": [],
+      \
+      \  "whereami": [],
+      \  }
+
+function! julia_blocks#init_mappings()
+  let b:jlblk_mapped = {}
+  for f in keys(s:julia_blocks_functions)
+    if f =~# "^move"
+      let [te, bw] = s:julia_blocks_functions[f]
+      call s:map_move(f, te, bw)
+    elseif f =~# "^select"
+      call s:map_select(f)
+    else
+      call s:map_aux(f)
+    endif
+  endfor
+  call julia_blocks#select_reset()
+  augroup JuliaBlocks
+    au!
+    au InsertEnter <buffer> call julia_blocks#select_reset()
+    au CursorMoved <buffer> call s:cursor_moved()
+  augroup END
+
+  " we would need some autocmd event associated with exiting from
+  " visual mode, but there isn't any, so we resort to this crude
+  " hack
+  " ACTUALLY this creates more problems than it solves, so the crude hack
+  " is just disabled
+  "vnoremap <buffer><silent><unique> <Esc> <Esc>:call julia_blocks#select_reset()<CR>
+endfunction
+
+function! julia_blocks#remove_mappings()
+  if exists("b:jlblk_mapped")
+    for f in keys(s:julia_blocks_functions)
+      call s:unmap(f)
+    endfor
+  endif
+  unlet! b:jlblk_save_pos b:jlblk_view b:jlblk_count b:jlblk_abort_calls_esc
+  unlet! b:jlblk_inwrapper b:jlblk_did_select b:jlblk_doing_select
+  unlet! b:jlblk_last_start_pos b:jlblk_last_end_pos b:jlblk_last_mode
+  augroup JuliaBlocks
+    au!
+  augroup END
+  augroup! JuliaBlocks
+  let md = maparg("<Esc>", "x", 0, 1)
+  if !empty(md) && md["buffer"]
+    vunmap <buffer> <Esc>
+  endif
+endfunction
+
+function! s:restore_view()
+  "redraw! " would ensure correct behaviour, but is annoying
+  let pos = getpos('.')
+  if pos == b:jlblk_save_pos
+    call winrestview(b:jlblk_view)
+    return
+  endif
+  let oldtopline = b:jlblk_view["topline"]
+  let newtopline = winsaveview()["topline"]
+  let l = pos[1]
+  if l >= oldtopline + &l:scrolloff && l <= oldtopline + winheight(0) - 1 - &l:scrolloff
+    if newtopline > oldtopline
+      exe ":normal! " . (newtopline - oldtopline) . "\<C-Y>"
+    elseif newtopline < oldtopline
+      exe ":normal! " . (oldtopline - newtopline) . "\<C-E>"
+    endif
+  " these reduce the scrolling to the minimum (which is maybe not
+  " standard ViM behaviour?)
+  elseif newtopline < oldtopline && (l - newtopline - &l:scrolloff) > 0
+    exe ":normal! " . (l - newtopline - &l:scrolloff) . "\<C-E>"
+  elseif newtopline > oldtopline && (newtopline + &l:scrolloff - l) > 0
+    exe ":normal! " . (l - newtopline - &l:scrolloff) . "\<C-E>"
+  endif
+  call setpos('.', pos) " make sure we didn't screw up
+                        " (since winsaveview may not be up to date)
+endfunction
+
+function! s:abort()
+  call setpos('.', b:jlblk_save_pos)
+  call s:restore_view()
+  if get(b:, "jlblk_abort_calls_esc", 1)
+    call feedkeys("\<Esc>", 'n')
+  endif
+  return 0
+endfunction
+
+function! s:set_mark_tick(...)
+  " This could be a one-liner:
+  "   call setpos("''", b:jlblk_save_pos)
+  " but we want to append to the jumplist,
+  " which setpos doesn't do
+  let p = getpos('.')
+  call setpos('.', b:jlblk_save_pos)
+  normal! m'
+  call setpos('.', p)
+endfunction
+
+function! s:get_save_pos(...)
+  if !exists("b:jlblk_save_pos") || (a:0 == 0) || (a:0 > 0 && a:1)
+    let b:jlblk_save_pos = getpos('.')
+  endif
+  let b:jlblk_view = winsaveview()
+endfunction
+
+function! s:on_end()
+  return getline('.')[col('.')-1] =~# '\k' && expand("<cword>") =~# b:julia_end_keywords
+endfunction
+
+function! s:on_begin()
+  let [l,c] = [line('.'), col('.')]
+  normal! ^
+  let patt = '\%<'.(c+1).'c\(' . b:julia_begin_keywordsm . '\)\%>'.(c-1).'c'
+  let n = search(patt, 'Wnc', l)
+  call cursor(l, c)
+  return n > 0
+endfunction
+
+function! s:matchit()
+  let lkj = exists(":lockjumps") == 2 ? "lockjumps " : ""
+  exe lkj . "normal %"
+endfunction
+
+function! s:move_before_begin()
+  call search(b:julia_begin_keywordsm, 'Wbc')
+  normal! h
+endfunction
+
+function! s:cycle_until_end()
+  let pos = getpos('.')
+  while !s:on_end()
+    call s:matchit()
+    let c = 0
+    if getpos('.') == pos || c > 1000
+      " shouldn't happen, but let's avoid infinite loops anyway
+      return 0
+    endif
+    let c += 1
+  endwhile
+  return 1
+endfunction
+
+function! s:moveto_block_delim(toend, backwards, ...)
+  let pattern = a:toend ? b:julia_end_keywords : b:julia_begin_keywordsm
+  let flags = a:backwards ? 'Wb' : 'W'
+  let cnt = a:0 > 0 ? a:1 : b:jlblk_count
+  if !a:toend && a:backwards && s:on_begin()
+    call s:move_before_begin()
+  endif
+  let ret = 0
+  for c in range(cnt)
+    if a:toend && a:backwards && s:on_end()
+      normal! l
+      normal! bh
+    endif
+    while 1
+      let searchret = search(pattern, flags)
+      if !searchret
+	return ret
+      endif
+      exe "let skip = " . b:match_skip
+      if !skip
+	let ret = 1
+	break
+      endif
+    endwhile
+  endfor
+  return ret
+endfunction
+
+function! s:compare_pos(pos1, pos2)
+  if a:pos1[1] < a:pos2[1]
+    return -1
+  elseif a:pos1[1] > a:pos2[1]
+    return 1
+  elseif a:pos1[2] < a:pos2[2]
+    return -1
+  elseif a:pos1[2] > a:pos2[2]
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! julia_blocks#move_N()
+  call s:get_save_pos()
+
+  let ret = s:moveto_block_delim(1, 0)
+  if !ret
+    return s:abort()
+  endif
+
+  normal! e
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#move_n()
+  call s:get_save_pos()
+
+  let ret = s:moveto_block_delim(0, 0)
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#move_p()
+  call s:get_save_pos()
+
+  let ret = s:moveto_block_delim(0, 1)
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#move_P()
+  call s:get_save_pos()
+
+  let ret = s:moveto_block_delim(1, 1)
+  if !ret
+    return s:abort()
+  endif
+
+  normal! e
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! s:moveto_currentblock_end()
+  let flags = 'W'
+  if s:on_end()
+    let flags .= 'c'
+    " NOTE: using "normal! lb" fails at the end of the file (?!)
+    normal! l
+    normal! b
+  endif
+
+  let ret = searchpair(b:julia_begin_keywordsm, '', b:julia_end_keywords, flags, b:match_skip)
+  if ret <= 0
+    return s:abort()
+  endif
+
+  normal! e
+  return 1
+endfunction
+
+function! julia_blocks#moveblock_N()
+  call s:get_save_pos()
+
+  let ret = 0
+  for c in range(b:jlblk_count)
+    let last_seen_pos = getpos('.')
+    if s:on_end()
+      normal! hel
+      let save_pos = getpos('.')
+      let ret_start = s:moveto_block_delim(0, 0, 1)
+      let start1_pos = ret_start ? getpos('.') : [0,0,0,0]
+      call setpos('.', save_pos)
+      if s:on_end()
+	normal! h
+      endif
+      let ret_end = s:moveto_block_delim(1, 0, 1)
+      let end1_pos = ret_end ? getpos('.')  : [0,0,0,0]
+
+      if ret_start && (!ret_end || s:compare_pos(start1_pos, end1_pos) < 0)
+	call setpos('.', start1_pos)
+      else
+	call setpos('.', save_pos)
+      endif
+    endif
+
+    let moveret = s:moveto_currentblock_end()
+    if !moveret && c == 0
+      let moveret = s:moveto_block_delim(0, 0, 1) && s:cycle_until_end()
+      if moveret
+        normal! e
+      endif
+    endif
+    if !moveret
+      call setpos('.', last_seen_pos)
+      break
+    endif
+
+    let ret = 1
+  endfor
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#moveblock_n()
+  call s:get_save_pos()
+
+  let ret = 0
+  for c in range(b:jlblk_count)
+    let last_seen_pos = getpos('.')
+
+    call s:moveto_currentblock_end()
+    if s:moveto_block_delim(0, 0, 1)
+      let ret = 1
+    else
+      call setpos('.', last_seen_pos)
+      break
+    endif
+  endfor
+
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#moveblock_p()
+  call s:get_save_pos()
+
+  let ret = 0
+  for c in range(b:jlblk_count)
+    let last_seen_pos = getpos('.')
+    if s:on_begin()
+      call s:move_before_begin()
+      if s:on_end()
+	normal! l
+      endif
+      let save_pos = getpos('.')
+      let ret_start = s:moveto_block_delim(0, 1, 1)
+      let start1_pos = ret_start ? getpos('.') : [0,0,0,0]
+      call setpos('.', save_pos)
+      let ret_end = s:moveto_block_delim(1, 1, 1)
+      let end1_pos = ret_end ? getpos('.') : [0,0,0,0]
+
+      if ret_end && (!ret_start || s:compare_pos(start1_pos, end1_pos) < 0)
+	call setpos('.', end1_pos)
+      else
+	call setpos('.', save_pos)
+      endif
+    endif
+
+    let moveret = s:moveto_currentblock_end()
+    if !moveret && c == 0
+      let moveret = s:moveto_block_delim(1, 1, 1)
+    endif
+    if !moveret
+      call setpos('.', last_seen_pos)
+      break
+    endif
+
+    call s:matchit()
+    let ret = 1
+  endfor
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+  call s:restore_view()
+
+  return 1
+endfunction
+
+function! julia_blocks#moveblock_P()
+  call s:get_save_pos()
+
+  let ret = 0
+  for c in range(b:jlblk_count)
+    let last_seen_pos = getpos('.')
+
+    call s:moveto_currentblock_end()
+    if s:on_end()
+      call s:matchit()
+    endif
+
+    if s:moveto_block_delim(1, 1, 1)
+      " NOTE: normal! he does not work unless &whichwrap inlcudes h
+      normal! h
+      normal! e
+      let ret = 1
+    else
+      call setpos('.', last_seen_pos)
+    endif
+  endfor
+
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+  call s:restore_view()
+
+  return 1
+endfunction
+
+function! julia_blocks#whereami()
+  let b:jlblk_count = v:count1
+  let save_redraw = &lazyredraw
+  setlocal lazyredraw
+  let pos = getpos('.')
+  let ret = julia_blocks#select_a('w')
+  if empty(ret)
+    call setpos('.', pos)
+    let &l:lazyredraw = save_redraw
+    return ""
+  end
+  let [start_pos, end_pos] = ret
+  let m = getline(start_pos[1])[start_pos[2]-1:]
+
+  " If cursor_moved was not forced from select_a, we force it now
+  " (TODO: this is *really* ugly)
+  if end_pos != pos
+    call s:cursor_moved(1)
+  endif
+  call setpos('.', pos)
+  call s:restore_view()
+  let &l:lazyredraw = save_redraw
+  return m
+endfunction
+
+" Block text objects
+
+function! s:find_block(current_mode)
+
+  let flags = 'W'
+
+  if b:jlblk_did_select
+    call setpos('.', b:jlblk_last_start_pos)
+    if !s:cycle_until_end()
+      return s:abort()
+    endif
+    if !(a:current_mode[0] == 'a' && a:current_mode == b:jlblk_last_mode)
+      let flags .= 'c'
+    endif
+  elseif s:on_end()
+    let flags .= 'c'
+    " NOTE: using "normal! lb" fails at the end of the file (?!)
+    normal! l
+    normal! b
+  endif
+  let searchret = searchpair(b:julia_begin_keywordsm, '', b:julia_end_keywords, flags, b:match_skip)
+  if searchret <= 0
+    if !b:jlblk_did_select
+      return s:abort()
+    else
+     call setpos('.', b:jlblk_last_end_pos)
+    endif
+  endif
+
+  let end_pos = getpos('.')
+  " Jump to match
+  call s:matchit()
+  let start_pos = getpos('.')
+
+  let b:jlblk_last_start_pos = copy(start_pos)
+  let b:jlblk_last_end_pos = copy(end_pos)
+
+  return [start_pos, end_pos]
+endfunction
+
+function! s:repeated_find(ai_mode)
+  let repeat = b:jlblk_count + (a:ai_mode == 'i' && v:count1 > 1 ? 1 : 0)
+  for c in range(repeat)
+    let current_mode = (c < repeat - 1 ? 'a' : a:ai_mode)
+    let ret_find_block = s:find_block(current_mode)
+    if empty(ret_find_block)
+      return 0
+    endif
+    let [start_pos, end_pos] = ret_find_block
+    call setpos('.', end_pos)
+    let b:jlblk_last_mode = current_mode
+    if c < repeat - 1
+      let b:jlblk_doing_select = 0
+      let b:jlblk_did_select = 1
+    endif
+  endfor
+  return [start_pos, end_pos]
+endfunction
+
+function! julia_blocks#select_a(...)
+  let mode_flag = a:0 > 0 ? a:1 : ''
+  call s:get_save_pos(!b:jlblk_did_select)
+  let current_pos = getpos('.')
+  let ret_find_block = s:repeated_find('a' . mode_flag)
+  if empty(ret_find_block)
+    return 0
+  endif
+  let [start_pos, end_pos] = ret_find_block
+
+  call setpos('.', end_pos)
+  normal! e
+  let end_pos = getpos('.')
+
+  let b:jlblk_doing_select = 1
+
+  " CursorMove is only triggered if end_pos
+  " end_pos is different than the staring position;
+  " so when starting from the 'd' in 'end' we need to
+  " force it
+  if current_pos == end_pos
+    call s:cursor_moved(1)
+  endif
+
+  call s:set_mark_tick()
+  return [start_pos, end_pos]
+endfunction
+
+function! julia_blocks#select_i()
+  call s:get_save_pos(!b:jlblk_did_select)
+  let current_pos = getpos('.')
+  let ret_find_block = s:repeated_find('i')
+  if empty(ret_find_block)
+    return 0
+  endif
+  let [start_pos, end_pos] = ret_find_block
+
+  if end_pos[1] <= start_pos[1]+1
+    return s:abort()
+  endif
+
+  call setpos('.', end_pos)
+
+  let b:jlblk_doing_select = 1
+
+  let start_pos[1] += 1
+  call setpos('.', start_pos)
+  normal! ^
+  let start_pos = getpos('.')
+  let end_pos[1] -= 1
+  let end_pos[2] = len(getline(end_pos[1]))
+
+  " CursorMove is only triggered if end_pos
+  " end_pos is different than the staring position;
+  " so when starting from the 'd' in 'end' we need to
+  " force it
+  if current_pos == end_pos
+    call s:cursor_moved(1)
+  endif
+
+  call s:set_mark_tick()
+  return [start_pos, end_pos]
+endfunction
+
+function julia_blocks#select_reset()
+  let b:jlblk_did_select = 0
+  let b:jlblk_doing_select = 0
+  let b:jlblk_inwrapper = 0
+  let b:jlblk_last_mode = ""
+endfunction
+
+function! s:cursor_moved(...)
+  if b:jlblk_inwrapper && !(a:0 > 0 && a:1)
+    return
+  endif
+  let b:jlblk_did_select = b:jlblk_doing_select
+  let b:jlblk_doing_select = 0
+endfunction
+
+endif

autoload/rubycomplete.vim

@@ -105,7 +105,7 @@ function! s:GetBufferRubyEntity( name, type, ... )
     endif
 
     let curpos = getpos(".")
-    let [enum,ecol] = searchpairpos( crex, '', '\(end\|}\)', 'wr' )
+    let [enum,ecol] = searchpairpos( crex, '', '\(end\|}\)', 'W' )
     call cursor(lastpos[1], lastpos[2])
 
     if lnum > enum
@@ -255,15 +255,27 @@ class VimRubyCompletion
 
 # {{{ buffer analysis magic
   def load_requires
+
+    custom_paths = VIM::evaluate("get(g:, 'rubycomplete_load_paths', [])")
+
+    if !custom_paths.empty?
+      $LOAD_PATH.concat(custom_paths).uniq!
+    end
+
     buf = VIM::Buffer.current
     enum = buf.line_number
     nums = Range.new( 1, enum )
     nums.each do |x|
+
       ln = buf[x]
       begin
-        eval( "require %s" % $1 ) if /.*require\s*(.*)$/.match( ln )
-      rescue Exception
-        #ignore?
+        if /.*require_relative\s*(.*)$/.match( ln )
+          eval( "require %s" % File.expand_path($1) )
+        elsif /.*require\s*(["'].*?["'])/.match( ln )
+          eval( "require %s" % $1 )
+        end
+      rescue Exception => e
+        dprint e.inspect
       end
     end
   end
@@ -346,8 +358,13 @@ class VimRubyCompletion
         if x != cur_line
           next if x == 0
           ln = buf[x]
-          if /^\s*(module|class|def|include)\s+/.match(ln)
-            clscnt += 1 if $1 == "class"
+          is_const = false
+          if /^\s*(module|class|def|include)\s+/.match(ln) || is_const = /^\s*?[A-Z]([A-z]|[1-9])*\s*?[|]{0,2}=\s*?.+\s*?/.match(ln)
+            clscnt += 1 if /class|module/.match($1)
+            # We must make sure to load each constant only once to avoid errors
+            if is_const
+                ln.gsub!(/\s*?[|]{0,2}=\s*?/, '||=')
+            end
             #dprint "\$1$1
             classdef += "%s\n" % ln
             classdef += "end\n" if /def\s+/.match(ln)
@@ -425,7 +442,6 @@ class VimRubyCompletion
     return get_buffer_entity_list( "class" )
   end
 
-
   def load_rails
     allow_rails = VIM::evaluate("exists('g:rubycomplete_rails') && g:rubycomplete_rails")
     return if allow_rails.to_i.zero?
@@ -531,7 +547,6 @@ class VimRubyCompletion
         ret += ActiveRecord::ConnectionAdapters::SchemaStatements.methods
     end
 
-
     return ret
   end
 
@@ -616,7 +631,6 @@ class VimRubyCompletion
 
     want_gems = VIM::evaluate("get(g:, 'rubycomplete_load_gemfile')")
     load_gems unless want_gems.to_i.zero?
-    
 
     input = VIM::Buffer.current.line
     cpos = VIM::Window.current.cursor[1] - 1
@@ -670,6 +684,7 @@ class VimRubyCompletion
         message = Regexp.quote($4)
         dprint "const or cls 2 [recv: \'%s\', msg: \'%s\']" % [ receiver, message ]
         load_buffer_class( receiver )
+        load_buffer_module( receiver )
         begin
           classes = eval("#{receiver}.constants")
           #methods = eval("#{receiver}.methods")
@@ -790,7 +805,6 @@ class VimRubyCompletion
       methods += Kernel.public_methods
     end
 
-
     include_object = VIM::evaluate("exists('g:rubycomplete_include_object') && g:rubycomplete_include_object")
     methods = clean_sel( methods, message )
     methods = (methods-Object.instance_methods) if include_object == "0"
@@ -833,7 +847,6 @@ let s:rubycomplete_rails_loaded = 0
 call s:DefRuby()
 "}}} ruby-side code
 
-
 " vim:tw=78:sw=4:ts=8:et:fdm=marker:ft=vim:norl:
 
 endif

autoload/rust.vim

@@ -7,203 +7,219 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 
 " Jump {{{1
 
+function! rust#Load() 
+    " Utility call to get this script loaded, for debugging
+endfunction
+
+function! rust#GetConfigVar(name, default)
+    " Local buffer variable with same name takes predeence over global
+    if has_key(b:, a:name) 
+        return get(b:, a:name)
+    endif
+    if has_key(g:, a:name) 
+        return get(g:, a:name)
+    endif
+    return a:default
+endfunction
+
+
 function! rust#Jump(mode, function) range
-	let cnt = v:count1
-	normal! m'
-	if a:mode ==# 'v'
-		norm! gv
-	endif
-	let foldenable = &foldenable
-	set nofoldenable
-	while cnt > 0
-		execute "call <SID>Jump_" . a:function . "()"
-		let cnt = cnt - 1
-	endwhile
-	let &foldenable = foldenable
+    let cnt = v:count1
+    normal! m'
+    if a:mode ==# 'v'
+        norm! gv
+    endif
+    let foldenable = &foldenable
+    set nofoldenable
+    while cnt > 0
+        execute "call <SID>Jump_" . a:function . "()"
+        let cnt = cnt - 1
+    endwhile
+    let &foldenable = foldenable
 endfunction
 
 function! s:Jump_Back()
-	call search('{', 'b')
-	keepjumps normal! w99[{
+    call search('{', 'b')
+    keepjumps normal! w99[{
 endfunction
 
 function! s:Jump_Forward()
-	normal! j0
-	call search('{', 'b')
-	keepjumps normal! w99[{%
-	call search('{')
+    normal! j0
+    call search('{', 'b')
+    keepjumps normal! w99[{%
+    call search('{')
 endfunction
 
 " Run {{{1
 
 function! rust#Run(bang, args)
-	let args = s:ShellTokenize(a:args)
-	if a:bang
-		let idx = index(l:args, '--')
-		if idx != -1
-			let rustc_args = idx == 0 ? [] : l:args[:idx-1]
-			let args = l:args[idx+1:]
-		else
-			let rustc_args = l:args
-			let args = []
-		endif
-	else
-		let rustc_args = []
-	endif
+    let args = s:ShellTokenize(a:args)
+    if a:bang
+        let idx = index(l:args, '--')
+        if idx != -1
+            let rustc_args = idx == 0 ? [] : l:args[:idx-1]
+            let args = l:args[idx+1:]
+        else
+            let rustc_args = l:args
+            let args = []
+        endif
+    else
+        let rustc_args = []
+    endif
 
-	let b:rust_last_rustc_args = l:rustc_args
-	let b:rust_last_args = l:args
+    let b:rust_last_rustc_args = l:rustc_args
+    let b:rust_last_args = l:args
 
-	call s:WithPath(function("s:Run"), rustc_args, args)
+    call s:WithPath(function("s:Run"), rustc_args, args)
 endfunction
 
 function! s:Run(dict, rustc_args, args)
-	let exepath = a:dict.tmpdir.'/'.fnamemodify(a:dict.path, ':t:r')
-	if has('win32')
-		let exepath .= '.exe'
-	endif
+    let exepath = a:dict.tmpdir.'/'.fnamemodify(a:dict.path, ':t:r')
+    if has('win32')
+        let exepath .= '.exe'
+    endif
 
-	let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
-	let rustc_args = [relpath, '-o', exepath] + a:rustc_args
+    let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
+    let rustc_args = [relpath, '-o', exepath] + a:rustc_args
 
-	let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
+    let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
 
-	let pwd = a:dict.istemp ? a:dict.tmpdir : ''
-	let output = s:system(pwd, shellescape(rustc) . " " . join(map(rustc_args, 'shellescape(v:val)')))
-	if output != ''
-		echohl WarningMsg
-		echo output
-		echohl None
-	endif
-	if !v:shell_error
-		exe '!' . shellescape(exepath) . " " . join(map(a:args, 'shellescape(v:val)'))
-	endif
+    let pwd = a:dict.istemp ? a:dict.tmpdir : ''
+    let output = s:system(pwd, shellescape(rustc) . " " . join(map(rustc_args, 'shellescape(v:val)')))
+    if output !=# ''
+        echohl WarningMsg
+        echo output
+        echohl None
+    endif
+    if !v:shell_error
+        exe '!' . shellescape(exepath) . " " . join(map(a:args, 'shellescape(v:val)'))
+    endif
 endfunction
 
 " Expand {{{1
 
 function! rust#Expand(bang, args)
-	let args = s:ShellTokenize(a:args)
-	if a:bang && !empty(l:args)
-		let pretty = remove(l:args, 0)
-	else
-		let pretty = "expanded"
-	endif
-	call s:WithPath(function("s:Expand"), pretty, args)
+    let args = s:ShellTokenize(a:args)
+    if a:bang && !empty(l:args)
+        let pretty = remove(l:args, 0)
+    else
+        let pretty = "expanded"
+    endif
+    call s:WithPath(function("s:Expand"), pretty, args)
 endfunction
 
 function! s:Expand(dict, pretty, args)
-	try
-		let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
+    try
+        let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
 
-		if a:pretty =~? '^\%(everybody_loops$\|flowgraph=\)'
-			let flag = '--xpretty'
-		else
-			let flag = '--pretty'
-		endif
-		let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
-		let args = [relpath, '-Z', 'unstable-options', l:flag, a:pretty] + a:args
-		let pwd = a:dict.istemp ? a:dict.tmpdir : ''
-		let output = s:system(pwd, shellescape(rustc) . " " . join(map(args, 'shellescape(v:val)')))
-		if v:shell_error
-			echohl WarningMsg
-			echo output
-			echohl None
-		else
-			new
-			silent put =output
-			1
-			d
-			setl filetype=rust
-			setl buftype=nofile
-			setl bufhidden=hide
-			setl noswapfile
-			" give the buffer a nice name
-			let suffix = 1
-			let basename = fnamemodify(a:dict.path, ':t:r')
-			while 1
-				let bufname = basename
-				if suffix > 1 | let bufname .= ' ('.suffix.')' | endif
-				let bufname .= '.pretty.rs'
-				if bufexists(bufname)
-					let suffix += 1
-					continue
-				endif
-				exe 'silent noautocmd keepalt file' fnameescape(bufname)
-				break
-			endwhile
-		endif
-	endtry
+        if a:pretty =~? '^\%(everybody_loops$\|flowgraph=\)'
+            let flag = '--xpretty'
+        else
+            let flag = '--pretty'
+        endif
+        let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
+        let args = [relpath, '-Z', 'unstable-options', l:flag, a:pretty] + a:args
+        let pwd = a:dict.istemp ? a:dict.tmpdir : ''
+        let output = s:system(pwd, shellescape(rustc) . " " . join(map(args, 'shellescape(v:val)')))
+        if v:shell_error
+            echohl WarningMsg
+            echo output
+            echohl None
+        else
+            new
+            silent put =output
+            1
+            d
+            setl filetype=rust
+            setl buftype=nofile
+            setl bufhidden=hide
+            setl noswapfile
+            " give the buffer a nice name
+            let suffix = 1
+            let basename = fnamemodify(a:dict.path, ':t:r')
+            while 1
+                let bufname = basename
+                if suffix > 1 | let bufname .= ' ('.suffix.')' | endif
+                let bufname .= '.pretty.rs'
+                if bufexists(bufname)
+                    let suffix += 1
+                    continue
+                endif
+                exe 'silent noautocmd keepalt file' fnameescape(bufname)
+                break
+            endwhile
+        endif
+    endtry
 endfunction
 
 function! rust#CompleteExpand(lead, line, pos)
-	if a:line[: a:pos-1] =~ '^RustExpand!\s*\S*$'
-		" first argument and it has a !
-		let list = ["normal", "expanded", "typed", "expanded,identified", "flowgraph=", "everybody_loops"]
-		if !empty(a:lead)
-			call filter(list, "v:val[:len(a:lead)-1] == a:lead")
-		endif
-		return list
-	endif
+    if a:line[: a:pos-1] =~# '^RustExpand!\s*\S*$'
+        " first argument and it has a !
+        let list = ["normal", "expanded", "typed", "expanded,identified", "flowgraph=", "everybody_loops"]
+        if !empty(a:lead)
+            call filter(list, "v:val[:len(a:lead)-1] == a:lead")
+        endif
+        return list
+    endif
 
-	return glob(escape(a:lead, "*?[") . '*', 0, 1)
+    return glob(escape(a:lead, "*?[") . '*', 0, 1)
 endfunction
 
 " Emit {{{1
 
 function! rust#Emit(type, args)
-	let args = s:ShellTokenize(a:args)
-	call s:WithPath(function("s:Emit"), a:type, args)
+    let args = s:ShellTokenize(a:args)
+    call s:WithPath(function("s:Emit"), a:type, args)
 endfunction
 
 function! s:Emit(dict, type, args)
-	try
-		let output_path = a:dict.tmpdir.'/output'
+    try
+        let output_path = a:dict.tmpdir.'/output'
 
-		let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
+        let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
 
-		let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
-		let args = [relpath, '--emit', a:type, '-o', output_path] + a:args
-		let pwd = a:dict.istemp ? a:dict.tmpdir : ''
-		let output = s:system(pwd, shellescape(rustc) . " " . join(map(args, 'shellescape(v:val)')))
-		if output != ''
-			echohl WarningMsg
-			echo output
-			echohl None
-		endif
-		if !v:shell_error
-			new
-			exe 'silent keepalt read' fnameescape(output_path)
-			1
-			d
-			if a:type == "llvm-ir"
-				setl filetype=llvm
-				let extension = 'll'
-			elseif a:type == "asm"
-				setl filetype=asm
-				let extension = 's'
-			endif
-			setl buftype=nofile
-			setl bufhidden=hide
-			setl noswapfile
-			if exists('l:extension')
-				" give the buffer a nice name
-				let suffix = 1
-				let basename = fnamemodify(a:dict.path, ':t:r')
-				while 1
-					let bufname = basename
-					if suffix > 1 | let bufname .= ' ('.suffix.')' | endif
-					let bufname .= '.'.extension
-					if bufexists(bufname)
-						let suffix += 1
-						continue
-					endif
-					exe 'silent noautocmd keepalt file' fnameescape(bufname)
-					break
-				endwhile
-			endif
-		endif
-	endtry
+        let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
+        let args = [relpath, '--emit', a:type, '-o', output_path] + a:args
+        let pwd = a:dict.istemp ? a:dict.tmpdir : ''
+        let output = s:system(pwd, shellescape(rustc) . " " . join(map(args, 'shellescape(v:val)')))
+        if output !=# ''
+            echohl WarningMsg
+            echo output
+            echohl None
+        endif
+        if !v:shell_error
+            new
+            exe 'silent keepalt read' fnameescape(output_path)
+            1
+            d
+            if a:type ==# "llvm-ir"
+                setl filetype=llvm
+                let extension = 'll'
+            elseif a:type ==# "asm"
+                setl filetype=asm
+                let extension = 's'
+            endif
+            setl buftype=nofile
+            setl bufhidden=hide
+            setl noswapfile
+            if exists('l:extension')
+                " give the buffer a nice name
+                let suffix = 1
+                let basename = fnamemodify(a:dict.path, ':t:r')
+                while 1
+                    let bufname = basename
+                    if suffix > 1 | let bufname .= ' ('.suffix.')' | endif
+                    let bufname .= '.'.extension
+                    if bufexists(bufname)
+                        let suffix += 1
+                        continue
+                    endif
+                    exe 'silent noautocmd keepalt file' fnameescape(bufname)
+                    break
+                endwhile
+            endif
+        endif
+    endtry
 endfunction
 
 " Utility functions {{{1
@@ -221,145 +237,145 @@ endfunction
 " existing path of the current buffer. If the path is inside of {dict.tmpdir}
 " then it is guaranteed to have a '.rs' extension.
 function! s:WithPath(func, ...)
-	let buf = bufnr('')
-	let saved = {}
-	let dict = {}
-	try
-		let saved.write = &write
-		set write
-		let dict.path = expand('%')
-		let pathisempty = empty(dict.path)
+    let buf = bufnr('')
+    let saved = {}
+    let dict = {}
+    try
+        let saved.write = &write
+        set write
+        let dict.path = expand('%')
+        let pathisempty = empty(dict.path)
 
-		" Always create a tmpdir in case the wrapped command wants it
-		let dict.tmpdir = tempname()
-		call mkdir(dict.tmpdir)
+        " Always create a tmpdir in case the wrapped command wants it
+        let dict.tmpdir = tempname()
+        call mkdir(dict.tmpdir)
 
-		if pathisempty || !saved.write
-			let dict.istemp = 1
-			" if we're doing this because of nowrite, preserve the filename
-			if !pathisempty
-				let filename = expand('%:t:r').".rs"
-			else
-				let filename = 'unnamed.rs'
-			endif
-			let dict.tmpdir_relpath = filename
-			let dict.path = dict.tmpdir.'/'.filename
+        if pathisempty || !saved.write
+            let dict.istemp = 1
+            " if we're doing this because of nowrite, preserve the filename
+            if !pathisempty
+                let filename = expand('%:t:r').".rs"
+            else
+                let filename = 'unnamed.rs'
+            endif
+            let dict.tmpdir_relpath = filename
+            let dict.path = dict.tmpdir.'/'.filename
 
-			let saved.mod = &mod
-			set nomod
+            let saved.mod = &modified
+            set nomodified
 
-			silent exe 'keepalt write! ' . fnameescape(dict.path)
-			if pathisempty
-				silent keepalt 0file
-			endif
-		else
-			let dict.istemp = 0
-			update
-		endif
+            silent exe 'keepalt write! ' . fnameescape(dict.path)
+            if pathisempty
+                silent keepalt 0file
+            endif
+        else
+            let dict.istemp = 0
+            update
+        endif
 
-		call call(a:func, [dict] + a:000)
-	finally
-		if bufexists(buf)
-			for [opt, value] in items(saved)
-				silent call setbufvar(buf, '&'.opt, value)
-				unlet value " avoid variable type mismatches
-			endfor
-		endif
-		if has_key(dict, 'tmpdir') | silent call s:RmDir(dict.tmpdir) | endif
-	endtry
+        call call(a:func, [dict] + a:000)
+    finally
+        if bufexists(buf)
+            for [opt, value] in items(saved)
+                silent call setbufvar(buf, '&'.opt, value)
+                unlet value " avoid variable type mismatches
+            endfor
+        endif
+        if has_key(dict, 'tmpdir') | silent call s:RmDir(dict.tmpdir) | endif
+    endtry
 endfunction
 
 function! rust#AppendCmdLine(text)
-	call setcmdpos(getcmdpos())
-	let cmd = getcmdline() . a:text
-	return cmd
+    call setcmdpos(getcmdpos())
+    let cmd = getcmdline() . a:text
+    return cmd
 endfunction
 
 " Tokenize the string according to sh parsing rules
 function! s:ShellTokenize(text)
-	" states:
-	" 0: start of word
-	" 1: unquoted
-	" 2: unquoted backslash
-	" 3: double-quote
-	" 4: double-quoted backslash
-	" 5: single-quote
-	let l:state = 0
-	let l:current = ''
-	let l:args = []
-	for c in split(a:text, '\zs')
-		if l:state == 0 || l:state == 1 " unquoted
-			if l:c ==# ' '
-				if l:state == 0 | continue | endif
-				call add(l:args, l:current)
-				let l:current = ''
-				let l:state = 0
-			elseif l:c ==# '\'
-				let l:state = 2
-			elseif l:c ==# '"'
-				let l:state = 3
-			elseif l:c ==# "'"
-				let l:state = 5
-			else
-				let l:current .= l:c
-				let l:state = 1
-			endif
-		elseif l:state == 2 " unquoted backslash
-			if l:c !=# "\n" " can it even be \n?
-				let l:current .= l:c
-			endif
-			let l:state = 1
-		elseif l:state == 3 " double-quote
-			if l:c ==# '\'
-				let l:state = 4
-			elseif l:c ==# '"'
-				let l:state = 1
-			else
-				let l:current .= l:c
-			endif
-		elseif l:state == 4 " double-quoted backslash
-			if stridx('$`"\', l:c) >= 0
-				let l:current .= l:c
-			elseif l:c ==# "\n" " is this even possible?
-				" skip it
-			else
-				let l:current .= '\'.l:c
-			endif
-			let l:state = 3
-		elseif l:state == 5 " single-quoted
-			if l:c == "'"
-				let l:state = 1
-			else
-				let l:current .= l:c
-			endif
-		endif
-	endfor
-	if l:state != 0
-		call add(l:args, l:current)
-	endif
-	return l:args
+    " states:
+    " 0: start of word
+    " 1: unquoted
+    " 2: unquoted backslash
+    " 3: double-quote
+    " 4: double-quoted backslash
+    " 5: single-quote
+    let l:state = 0
+    let l:current = ''
+    let l:args = []
+    for c in split(a:text, '\zs')
+        if l:state == 0 || l:state == 1 " unquoted
+            if l:c ==# ' '
+                if l:state == 0 | continue | endif
+                call add(l:args, l:current)
+                let l:current = ''
+                let l:state = 0
+            elseif l:c ==# '\'
+                let l:state = 2
+            elseif l:c ==# '"'
+                let l:state = 3
+            elseif l:c ==# "'"
+                let l:state = 5
+            else
+                let l:current .= l:c
+                let l:state = 1
+            endif
+        elseif l:state == 2 " unquoted backslash
+            if l:c !=# "\n" " can it even be \n?
+                let l:current .= l:c
+            endif
+            let l:state = 1
+        elseif l:state == 3 " double-quote
+            if l:c ==# '\'
+                let l:state = 4
+            elseif l:c ==# '"'
+                let l:state = 1
+            else
+                let l:current .= l:c
+            endif
+        elseif l:state == 4 " double-quoted backslash
+            if stridx('$`"\', l:c) >= 0
+                let l:current .= l:c
+            elseif l:c ==# "\n" " is this even possible?
+                " skip it
+            else
+                let l:current .= '\'.l:c
+            endif
+            let l:state = 3
+        elseif l:state == 5 " single-quoted
+            if l:c ==# "'"
+                let l:state = 1
+            else
+                let l:current .= l:c
+            endif
+        endif
+    endfor
+    if l:state != 0
+        call add(l:args, l:current)
+    endif
+    return l:args
 endfunction
 
 function! s:RmDir(path)
-	" sanity check; make sure it's not empty, /, or $HOME
-	if empty(a:path)
-		echoerr 'Attempted to delete empty path'
-		return 0
-	elseif a:path == '/' || a:path == $HOME
-		echoerr 'Attempted to delete protected path: ' . a:path
-		return 0
-	endif
-	return system("rm -rf " . shellescape(a:path))
+    " sanity check; make sure it's not empty, /, or $HOME
+    if empty(a:path)
+        echoerr 'Attempted to delete empty path'
+        return 0
+    elseif a:path ==# '/' || a:path ==# $HOME
+        echoerr 'Attempted to delete protected path: ' . a:path
+        return 0
+    endif
+    return system("rm -rf " . shellescape(a:path))
 endfunction
 
 " Executes {cmd} with the cwd set to {pwd}, without changing Vim's cwd.
 " If {pwd} is the empty string then it doesn't change the cwd.
 function! s:system(pwd, cmd)
-	let cmd = a:cmd
-	if !empty(a:pwd)
-		let cmd = 'cd ' . shellescape(a:pwd) . ' && ' . cmd
-	endif
-	return system(cmd)
+    let cmd = a:cmd
+    if !empty(a:pwd)
+        let cmd = 'cd ' . shellescape(a:pwd) . ' && ' . cmd
+    endif
+    return system(cmd)
 endfunction
 
 " Playpen Support {{{1
@@ -368,10 +384,10 @@ endfunction
 " http://github.com/mattn/gist-vim
 function! s:has_webapi()
     if !exists("*webapi#http#post")
-	try
-	    call webapi#http#post()
-	catch
-	endtry
+        try
+            call webapi#http#post()
+        catch
+        endtry
     endif
     return exists("*webapi#http#post")
 endfunction
@@ -383,41 +399,102 @@ function! rust#Play(count, line1, line2, ...) abort
     let l:rust_shortener_url = get(g:, 'rust_shortener_url', 'https://is.gd/')
 
     if !s:has_webapi()
-	echohl ErrorMsg | echomsg ':RustPlay depends on webapi.vim (https://github.com/mattn/webapi-vim)' | echohl None
-	return
+        echohl ErrorMsg | echomsg ':RustPlay depends on webapi.vim (https://github.com/mattn/webapi-vim)' | echohl None
+        return
     endif
 
     let bufname = bufname('%')
     if a:count < 1
-	let content = join(getline(a:line1, a:line2), "\n")
+        let content = join(getline(a:line1, a:line2), "\n")
     else
-	let save_regcont = @"
-	let save_regtype = getregtype('"')
-	silent! normal! gvy
-	let content = @"
-	call setreg('"', save_regcont, save_regtype)
+        let save_regcont = @"
+        let save_regtype = getregtype('"')
+        silent! normal! gvy
+        let content = @"
+        call setreg('"', save_regcont, save_regtype)
     endif
 
-    let body = l:rust_playpen_url."?code=".webapi#http#encodeURI(content)
+    let url = l:rust_playpen_url."?code=".webapi#http#encodeURI(content)
 
-    if strlen(body) > 5000
-	echohl ErrorMsg | echomsg 'Buffer too large, max 5000 encoded characters ('.strlen(body).')' | echohl None
-	return
+    if strlen(url) > 5000
+        echohl ErrorMsg | echomsg 'Buffer too large, max 5000 encoded characters ('.strlen(url).')' | echohl None
+        return
     endif
 
-    let payload = "format=simple&url=".webapi#http#encodeURI(body)
+    let payload = "format=simple&url=".webapi#http#encodeURI(url)
     let res = webapi#http#post(l:rust_shortener_url.'create.php', payload, {})
-    let url = res.content
-
-    if exists('g:rust_clip_command')
-	call system(g:rust_clip_command, url)
+    if res.status[0] ==# '2'
+        let url = res.content
     endif
 
-    redraw | echomsg 'Done: '.url
+    let footer = ''
+    if exists('g:rust_clip_command')
+        call system(g:rust_clip_command, url)
+        if !v:shell_error
+            let footer = ' (copied to clipboard)'
+        endif
+    endif
+    redraw | echomsg 'Done: '.url.footer
+endfunction
+
+" Run a test under the cursor or all tests {{{1
+
+" Finds a test function name under the cursor. Returns empty string when a
+" test function is not found.
+function! s:SearchTestFunctionNameUnderCursor() abort
+    let cursor_line = line('.')
+
+    " Find #[test] attribute
+    if search('#\[test]', 'bcW') is 0
+        return ''
+    endif
+
+    " Move to an opening brace of the test function
+    let test_func_line = search('^\s*fn\s\+\h\w*\s*(.\+{$', 'eW')
+    if test_func_line is 0
+        return ''
+    endif
+
+    " Search the end of test function (closing brace) to ensure that the
+    " cursor position is within function definition
+    normal! %
+    if line('.') < cursor_line
+        return ''
+    endif
+
+    return matchstr(getline(test_func_line), '^\s*fn\s\+\zs\h\w*')
+endfunction
+
+function! rust#Test(all, options) abort
+    let pwd = expand('%:p:h')
+    if findfile('Cargo.toml', pwd . ';') ==# ''
+        return rust#Run(1, '--test ' . a:options)
+    endif
+
+    let pwd = shellescape(pwd)
+
+    if a:all
+        execute '!cd ' . pwd . ' && cargo test ' . a:options
+        return
+    endif
+
+    let saved = getpos('.')
+    try
+        let func_name = s:SearchTestFunctionNameUnderCursor()
+        if func_name ==# ''
+            echohl ErrorMsg
+            echo 'No test function was found under the cursor. Please add ! to command if you want to run all tests'
+            echohl None
+            return
+        endif
+        execute '!cd ' . pwd . ' && cargo test ' . func_name . ' ' . a:options
+    finally
+        call setpos('.', saved)
+    endtry
 endfunction
 
 " }}}1
 
-" vim: set noet sw=8 ts=8:
+" vim: set et sw=4 sts=4 ts=8:
 
 endif

autoload/rust/debugging.vim

@@ -0,0 +1,99 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+  
+" For debugging, inspired by https://github.com/w0rp/rust/blob/master/autoload/rust/debugging.vim
+
+let s:global_variable_list = [
+            \ 'ftplugin_rust_source_path',
+            \ 'loaded_syntastic_rust_cargo_checker',
+            \ 'loaded_syntastic_rust_filetype',
+            \ 'loaded_syntastic_rust_rustc_checker',
+            \ 'rust_bang_comment_leader',
+            \ 'rust_cargo_avoid_whole_workspace',
+            \ 'rust_clip_command',
+            \ 'rust_conceal',
+            \ 'rust_conceal_mod_path',
+            \ 'rust_conceal_pub',
+            \ 'rust_fold',
+            \ 'rust_last_args',
+            \ 'rust_last_rustc_args',
+            \ 'rust_original_delimitMate_excluded_regions',
+            \ 'rust_playpen_url',
+            \ 'rust_prev_delimitMate_quotes',
+            \ 'rust_recent_nearest_cargo_tol',
+            \ 'rust_recent_root_cargo_toml',
+            \ 'rust_recommended_style',
+            \ 'rust_set_conceallevel',
+            \ 'rust_set_conceallevel=1',
+            \ 'rust_set_foldmethod',
+            \ 'rust_set_foldmethod=1',
+            \ 'rust_shortener_url',
+            \ 'rustc_makeprg_no_percent',
+            \ 'rustc_path',
+            \ 'rustfmt_autosave',
+            \ 'rustfmt_autosave_because_of_config',
+            \ 'rustfmt_autosave_if_config_present',
+            \ 'rustfmt_command',
+            \ 'rustfmt_emit_files',
+            \ 'rustfmt_fail_silently',
+            \ 'rustfmt_options',
+            \ 'syntastic_extra_filetypes',
+            \ 'syntastic_rust_cargo_fname',
+            \]
+
+function! s:Echo(message) abort
+    execute 'echo a:message'
+endfunction
+
+function! s:EchoGlobalVariables() abort
+    for l:key in s:global_variable_list
+        call s:Echo('let g:' . l:key . ' = ' . string(get(g:, l:key, v:null)))
+
+        if has_key(b:, l:key)
+            call s:Echo('let b:' . l:key . ' = ' . string(b:[l:key]))
+        endif
+    endfor
+endfunction
+
+function! rust#debugging#Info() abort
+    call cargo#Load()
+    call rust#Load()
+    call rustfmt#Load()
+    call s:Echo('rust.vim Global Variables:')
+    call s:Echo('')
+    call s:EchoGlobalVariables()
+
+    silent let l:output = system(g:rustfmt_command . ' --version')
+    echo l:output
+
+    let l:rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
+    silent let l:output = system(l:rustc . ' --version')
+    echo l:output
+
+    silent let l:output = system('cargo --version')
+    echo l:output
+
+    version
+endfunction
+
+function! rust#debugging#InfoToClipboard() abort
+    redir @"
+    silent call rust#debugging#Info()
+    redir END
+
+    call s:Echo('RustInfo copied to your clipboard')
+endfunction
+
+function! rust#debugging#InfoToFile(filename) abort
+    let l:expanded_filename = expand(a:filename)
+
+    redir => l:output
+    silent call rust#debugging#Info()
+    redir END
+
+    call writefile(split(l:output, "\n"), l:expanded_filename)
+    call s:Echo('RustInfo written to ' . l:expanded_filename)
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+endif

autoload/rust/delimitmate.vim

@@ -0,0 +1,48 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+  
+let s:delimitMate_extra_excluded_regions = ',rustLifetimeCandidate,rustGenericLifetimeCandidate'
+
+" For this buffer, when delimitMate issues the `User delimitMate_map`
+" event in the autocommand system, add the above-defined extra excluded
+" regions to delimitMate's state, if they have not already been added.
+function! rust#delimitmate#onMap() abort
+    if &filetype !=# 'rust'
+        return
+    endif
+
+    if get(b:, "delimitMate_quotes")
+        let b:rust_prev_delimitMate_quotes = b:delimitMate_quotes
+    endif
+    let b:delimitMate_quotes = "\" `"
+
+    if match(delimitMate#Get("excluded_regions"),
+                \ s:delimitMate_extra_excluded_regions) == -1
+        call delimitMate#Set("excluded_regions",
+                    \delimitMate#Get("excluded_regions").s:delimitMate_extra_excluded_regions)
+    endif
+endfunction
+
+" For this buffer, when delimitMate issues the `User delimitMate_unmap`
+" event in the autocommand system, delete the above-defined extra excluded
+" regions from delimitMate's state (the deletion being idempotent and
+" having no effect if the extra excluded regions are not present in the
+" targeted part of delimitMate's state).
+function! rust#delimitmate#onUnmap() abort
+    if &filetype !=# 'rust'
+        return
+    endif
+
+    if get(b:, "rust_prev_delimitMate_quotes")
+        let b:delimitMate_quotes = b:rust_prev_delimitMate_quotes
+    endif
+
+    call delimitMate#Set("excluded_regions", substitute(
+               \ delimitMate#Get("excluded_regions"),
+               \ '\C\V' . s:delimitMate_extra_excluded_regions,
+               \ '', 'g'))
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+
+endif

autoload/rustfmt.vim

@@ -6,106 +6,247 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 " For bugs, patches and license go to https://github.com/rust-lang/rust.vim
 
 if !exists("g:rustfmt_autosave")
-	let g:rustfmt_autosave = 0
+    let g:rustfmt_autosave = 0
 endif
 
 if !exists("g:rustfmt_command")
-	let g:rustfmt_command = "rustfmt"
+    let g:rustfmt_command = "rustfmt"
 endif
 
 if !exists("g:rustfmt_options")
-	let g:rustfmt_options = ""
+    let g:rustfmt_options = ""
 endif
 
 if !exists("g:rustfmt_fail_silently")
-	let g:rustfmt_fail_silently = 0
+    let g:rustfmt_fail_silently = 0
+endif
+
+function! rustfmt#DetectVersion()
+    " Save rustfmt '--help' for feature inspection
+    silent let s:rustfmt_help = system(g:rustfmt_command . " --help")
+    let s:rustfmt_unstable_features = 1 - (s:rustfmt_help !~# "--unstable-features")
+
+    " Build a comparable rustfmt version varible out of its `--version` output:
+    silent let s:rustfmt_version = system(g:rustfmt_command . " --version")
+    let s:rustfmt_version = matchlist(s:rustfmt_version, '\vrustfmt ([0-9]+[.][0-9]+[.][0-9]+)')
+
+    if len(s:rustfmt_version) < 3 
+        let s:rustfmt_version = "0"
+    else
+        let s:rustfmt_version = s:rustfmt_version[1]
+    endif
+
+    return s:rustfmt_version
+endfunction
+
+call rustfmt#DetectVersion()
+
+if !exists("g:rustfmt_emit_files")
+    let g:rustfmt_emit_files = s:rustfmt_version >= "0.8.2"
+endif
+
+if !exists("g:rustfmt_file_lines")
+    let g:rustfmt_file_lines = 1 - (s:rustfmt_help !~# "--file-lines JSON")
 endif
 
 let s:got_fmt_error = 0
 
+function! rustfmt#Load()
+    " Utility call to get this script loaded, for debugging
+endfunction
+
+function! s:RustfmtWriteMode()
+    if g:rustfmt_emit_files
+        return "--emit=files"
+    else
+        return "--write-mode=overwrite"
+    endif
+endfunction
+
+function! s:RustfmtConfig()
+    let l:rustfmt_toml = findfile('rustfmt.toml', expand('%:p:h') . ';')
+    if l:rustfmt_toml !=# ''
+        return '--config-path '.l:rustfmt_toml
+    endif
+
+    let l:_rustfmt_toml = findfile('.rustfmt.toml', expand('%:p:h') . ';')
+    if l:_rustfmt_toml !=# ''
+        return '--config-path '.l:_rustfmt_toml
+    endif
+
+    return ''
+endfunction
+
 function! s:RustfmtCommandRange(filename, line1, line2)
-	let l:arg = {"file": shellescape(a:filename), "range": [a:line1, a:line2]}
-	return printf("%s %s --write-mode=overwrite --file-lines '[%s]'", g:rustfmt_command, g:rustfmt_options, json_encode(l:arg))
+    if g:rustfmt_file_lines == 0
+        echo "--file-lines is not supported in the installed `rustfmt` executable"
+        return
+    endif
+
+    let l:arg = {"file": shellescape(a:filename), "range": [a:line1, a:line2]}
+    let l:write_mode = s:RustfmtWriteMode()
+    let l:rustfmt_config = s:RustfmtConfig()
+
+    " FIXME: When --file-lines gets to be stable, enhance this version range checking
+    " accordingly.
+    let l:unstable_features = 
+                \ (s:rustfmt_unstable_features && (s:rustfmt_version < '1.'))
+                \ ? '--unstable-features' : ''
+
+    let l:cmd = printf("%s %s %s %s %s --file-lines '[%s]' %s", g:rustfmt_command,
+                \ l:write_mode, g:rustfmt_options,
+                \ l:unstable_features, l:rustfmt_config,
+                \ json_encode(l:arg), shellescape(a:filename))
+    return l:cmd
 endfunction
 
-function! s:RustfmtCommand(filename)
-	return g:rustfmt_command . " --write-mode=overwrite " . g:rustfmt_options . " " . shellescape(a:filename)
+function! s:RustfmtCommand()
+    if g:rustfmt_emit_files
+        let l:write_mode = "--emit=stdout"
+    else
+        let l:write_mode = "--write-mode=display"
+    endif
+    " rustfmt will pick on the right config on its own due to the
+    " current directory change.
+    return g:rustfmt_command . " ". l:write_mode . " " . g:rustfmt_options
 endfunction
 
-function! s:RunRustfmt(command, curw, tmpname)
-	if exists("*systemlist")
-		let out = systemlist(a:command)
-	else
-		let out = split(system(a:command), '\r\?\n')
-	endif
+function! s:DeleteLines(start, end) abort
+    silent! execute a:start . ',' . a:end . 'delete _'
+endfunction
 
-	if v:shell_error == 0 || v:shell_error == 3
-		" remove undo point caused via BufWritePre
-		try | silent undojoin | catch | endtry
+function! s:RunRustfmt(command, tmpname, fail_silently)
+    mkview!
 
-		" Replace current file with temp file, then reload buffer
-		call rename(a:tmpname, expand('%'))
-		silent edit!
-		let &syntax = &syntax
+    let l:stderr_tmpname = tempname()
+    let l:command = a:command . ' 2> ' . l:stderr_tmpname
 
-		" only clear location list if it was previously filled to prevent
-		" clobbering other additions
-		if s:got_fmt_error
-			let s:got_fmt_error = 0
-			call setloclist(0, [])
-			lwindow
-		endif
-	elseif g:rustfmt_fail_silently == 0
-		" otherwise get the errors and put them in the location list
-		let errors = []
+    if a:tmpname ==# ''
+        " Rustfmt in stdin/stdout mode
 
-		for line in out
-			" src/lib.rs:13:5: 13:10 error: expected `,`, or `}`, found `value`
-			let tokens = matchlist(line, '^\(.\{-}\):\(\d\+\):\(\d\+\):\s*\(\d\+:\d\+\s*\)\?\s*error: \(.*\)')
-			if !empty(tokens)
-				call add(errors, {"filename": @%,
-						 \"lnum":     tokens[2],
-						 \"col":      tokens[3],
-						 \"text":     tokens[5]})
-			endif
-		endfor
+        " chdir to the directory of the file
+        let l:has_lcd = haslocaldir()
+        let l:prev_cd = getcwd()
+        execute 'lchdir! '.expand('%:h')
 
-		if empty(errors)
-			% | " Couldn't detect rustfmt error format, output errors
-		endif
+        let l:buffer = getline(1, '$')
+        if exists("*systemlist")
+            silent let out = systemlist(l:command, l:buffer)
+        else
+            silent let out = split(system(l:command, l:buffer), '\r\?\n')
+        endif
+    else
+        if exists("*systemlist")
+            silent let out = systemlist(l:command)
+        else
+            silent let out = split(system(l:command), '\r\?\n')
+        endif
+    endif
 
-		if !empty(errors)
-			call setloclist(0, errors, 'r')
-			echohl Error | echomsg "rustfmt returned error" | echohl None
-		endif
+    let l:stderr = readfile(l:stderr_tmpname)
 
-		let s:got_fmt_error = 1
-		lwindow
-		" We didn't use the temp file, so clean up
-		call delete(a:tmpname)
-	endif
+    call delete(l:stderr_tmpname)
 
-	call winrestview(a:curw)
+    if v:shell_error == 0
+        " remove undo point caused via BufWritePre
+        try | silent undojoin | catch | endtry
+
+        if a:tmpname ==# ''
+            let l:content = l:out
+        else
+            " take the tmpfile's content, this is better than rename
+            " because it preserves file modes.
+            let l:content = readfile(a:tmpname)
+        endif
+
+        call s:DeleteLines(len(l:content), line('$'))
+        call setline(1, l:content)
+
+        " only clear location list if it was previously filled to prevent
+        " clobbering other additions
+        if s:got_fmt_error
+            let s:got_fmt_error = 0
+            call setloclist(0, [])
+            lwindow
+        endif
+    elseif g:rustfmt_fail_silently == 0 && a:fail_silently == 0
+        " otherwise get the errors and put them in the location list
+        let l:errors = []
+
+        let l:prev_line = ""
+        for l:line in l:stderr
+            " error: expected one of `;` or `as`, found `extern`
+            "  --> src/main.rs:2:1
+            let tokens = matchlist(l:line, '^\s\+-->\s\(.\{-}\):\(\d\+\):\(\d\+\)$')
+            if !empty(tokens)
+                call add(l:errors, {"filename": @%,
+                            \"lnum":	tokens[2],
+                            \"col":	tokens[3],
+                            \"text":	l:prev_line})
+            endif
+            let l:prev_line = l:line
+        endfor
+
+        if !empty(l:errors)
+            call setloclist(0, l:errors, 'r')
+            echohl Error | echomsg "rustfmt returned error" | echohl None
+        else
+            echo "rust.vim: was not able to parse rustfmt messages. Here is the raw output:"
+            echo "\n"
+            for l:line in l:stderr
+                echo l:line
+            endfor
+        endif
+
+        let s:got_fmt_error = 1
+        lwindow
+    endif
+
+    " Restore the current directory if needed
+    if a:tmpname ==# ''
+        if l:has_lcd
+            execute 'lchdir! '.l:prev_cd
+        else
+            execute 'chdir! '.l:prev_cd
+        endif
+    endif
+
+    silent! loadview
 endfunction
 
 function! rustfmt#FormatRange(line1, line2)
-	let l:curw = winsaveview()
-	let l:tmpname = expand("%:p:h") . "/." . expand("%:p:t") . ".rustfmt"
-	call writefile(getline(1, '$'), l:tmpname)
-
-	let command = s:RustfmtCommandRange(l:tmpname, a:line1, a:line2)
-
-	call s:RunRustfmt(command, l:curw, l:tmpname)
+    let l:tmpname = tempname()
+    call writefile(getline(1, '$'), l:tmpname)
+    let command = s:RustfmtCommandRange(l:tmpname, a:line1, a:line2)
+    call s:RunRustfmt(command, l:tmpname, 0)
+    call delete(l:tmpname)
 endfunction
 
 function! rustfmt#Format()
-	let l:curw = winsaveview()
-	let l:tmpname = expand("%:p:h") . "/." . expand("%:p:t") . ".rustfmt"
-	call writefile(getline(1, '$'), l:tmpname)
-
-	let command = s:RustfmtCommand(l:tmpname)
-
-	call s:RunRustfmt(command, l:curw, l:tmpname)
+    call s:RunRustfmt(s:RustfmtCommand(), '', 0)
 endfunction
 
+function! rustfmt#Cmd()
+    " Mainly for debugging
+    return s:RustfmtCommand()
+endfunction
+
+function! rustfmt#PreWrite()
+    if rust#GetConfigVar('rustfmt_autosave_if_config_present', 0)
+        if findfile('rustfmt.toml', '.;') !=# '' || findfile('.rustfmt.toml', '.;') !=# ''
+            let b:rustfmt_autosave = 1
+            let b:rustfmt_autosave_because_of_config = 1
+        endif
+    endif
+
+    if !rust#GetConfigVar("rustfmt_autosave", 0)
+        return
+    endif
+
+    call s:RunRustfmt(s:RustfmtCommand(), '', 1)
+endfunction
+
+
+" vim: set et sw=4 sts=4 ts=8:
+
 endif

autoload/vifm/globals.vim

@@ -0,0 +1,31 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vifm') == -1
+  
+" common functions for vifm plugin related to globals
+" Maintainer:  xaizek <xaizek@posteo.net>
+" Last Change: January 02, 2018
+
+" Initializes global variables to defaults unless they are already set
+function! vifm#globals#Init()
+    if !exists('g:vifm_exec')
+        let g:vifm_exec = 'vifm'
+    endif
+
+    if !exists('g:vifm_exec_args')
+        let g:vifm_exec_args = ''
+    endif
+
+    if !exists('g:vifm_term')
+        if has('win32')
+            if filereadable('C:\Windows\system32\cmd.exe')
+                let g:vifm_term = 'C:\Windows\system32\cmd.exe /C'
+            else
+                " If don't find use the integrate shell it work too
+                let g:vifm_term = ''
+            endif
+        else
+            let g:vifm_term = 'xterm -e'
+        endif
+    endif
+endfunction
+
+endif

autoload/vital.vim

@@ -1,16 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
-  
-function! vital#of(name) abort
-  let files = globpath(&runtimepath, 'autoload/vital/' . a:name . '.vital')
-  let file = split(files, "\n")
-  if empty(file)
-    throw 'vital: version file not found: ' . a:name
-  endif
-  let ver = readfile(file[0], 'b')
-  if empty(ver)
-    throw 'vital: invalid version file: ' . a:name
-  endif
-  return vital#_{substitute(ver[0], '\W', '', 'g')}#new()
-endfunction
-
-endif

autoload/vital/_crystal.vim

@@ -1,313 +1,13 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
   
-let s:self_version = expand('<sfile>:t:r')
-let s:self_file = expand('<sfile>')
+let s:_plugin_name = expand('<sfile>:t:r')
 
-" Note: The extra argument to globpath() was added in Patch 7.2.051.
-let s:globpath_third_arg = v:version > 702 || v:version == 702 && has('patch51')
-
-let s:loaded = {}
-let s:cache_module_path = {}
-let s:cache_sid = {}
-
-let s:_vital_files_cache_runtimepath = ''
-let s:_vital_files_cache = []
-let s:_unify_path_cache = {}
-
-function! s:import(name, ...) abort
-  let target = {}
-  let functions = []
-  for a in a:000
-    if type(a) == type({})
-      let target = a
-    elseif type(a) == type([])
-      let functions = a
-    endif
-    unlet a
-  endfor
-  let module = s:_import(a:name)
-  if empty(functions)
-    call extend(target, module, 'keep')
-  else
-    for f in functions
-      if has_key(module, f) && !has_key(target, f)
-        let target[f] = module[f]
-      endif
-    endfor
-  endif
-  return target
+function! vital#{s:_plugin_name}#new() abort
+  return vital#{s:_plugin_name[1:]}#new()
 endfunction
 
-function! s:load(...) dict abort
-  for arg in a:000
-    let [name; as] = type(arg) == type([]) ? arg[: 1] : [arg, arg]
-    let target = split(join(as, ''), '\W\+')
-    let dict = self
-    let dict_type = type({})
-    while !empty(target)
-      let ns = remove(target, 0)
-      if !has_key(dict, ns)
-        let dict[ns] = {}
-      endif
-      if type(dict[ns]) == dict_type
-        let dict = dict[ns]
-      else
-        unlet dict
-        break
-      endif
-    endwhile
-
-    if exists('dict')
-      call extend(dict, s:_import(name))
-    endif
-    unlet arg
-  endfor
-  return self
-endfunction
-
-function! s:unload() abort
-  let s:loaded = {}
-  let s:cache_sid = {}
-  let s:cache_module_path = {}
-endfunction
-
-function! s:exists(name) abort
-  return s:_get_module_path(a:name) !=# ''
-endfunction
-
-function! s:search(pattern) abort
-  let paths = s:_vital_files(a:pattern)
-  let modules = sort(map(paths, 's:_file2module(v:val)'))
-  return s:_uniq(modules)
-endfunction
-
-function! s:expand_modules(entry, all) abort
-  if type(a:entry) == type([])
-    let candidates = s:_concat(map(copy(a:entry), 's:search(v:val)'))
-    if empty(candidates)
-      throw printf('vital: Any of module %s is not found', string(a:entry))
-    endif
-    if eval(join(map(copy(candidates), 'has_key(a:all, v:val)'), '+'))
-      let modules = []
-    else
-      let modules = [candidates[0]]
-    endif
-  else
-    let modules = s:search(a:entry)
-    if empty(modules)
-      throw printf('vital: Module %s is not found', a:entry)
-    endif
-  endif
-  call filter(modules, '!has_key(a:all, v:val)')
-  for module in modules
-    let a:all[module] = 1
-  endfor
-  return modules
-endfunction
-
-function! s:_import(name) abort
-  if type(a:name) == type(0)
-    return s:_build_module(a:name)
-  endif
-  let path = s:_get_module_path(a:name)
-  if path ==# ''
-    throw 'vital: module not found: ' . a:name
-  endif
-  let sid = s:_get_sid_by_script(path)
-  if !sid
-    try
-      execute 'source' fnameescape(path)
-    catch /^Vim\%((\a\+)\)\?:E484/
-      throw 'vital: module not found: ' . a:name
-    catch /^Vim\%((\a\+)\)\?:E127/
-      " Ignore.
-    endtry
-
-    let sid = s:_get_sid_by_script(path)
-  endif
-  return s:_build_module(sid)
-endfunction
-
-function! s:_get_module_path(name) abort
-  let key = a:name . '_'
-  if has_key(s:cache_module_path, key)
-    return s:cache_module_path[key]
-  endif
-  if s:_is_absolute_path(a:name) && filereadable(a:name)
-    return a:name
-  endif
-  if a:name ==# ''
-    let paths = [s:self_file]
-  elseif a:name =~# '\v^\u\w*%(\.\u\w*)*$'
-    let paths = s:_vital_files(a:name)
-  else
-    throw 'vital: Invalid module name: ' . a:name
-  endif
-
-  call filter(paths, 'filereadable(expand(v:val, 1))')
-  let path = get(paths, 0, '')
-  let s:cache_module_path[key] = path
-  return path
-endfunction
-
-function! s:_get_sid_by_script(path) abort
-  if has_key(s:cache_sid, a:path)
-    return s:cache_sid[a:path]
-  endif
-
-  let path = s:_unify_path(a:path)
-  for line in filter(split(s:_redir('scriptnames'), "\n"),
-  \                  'stridx(v:val, s:self_version) > 0')
-    let list = matchlist(line, '^\s*\(\d\+\):\s\+\(.\+\)\s*$')
-    if !empty(list) && s:_unify_path(list[2]) ==# path
-      let s:cache_sid[a:path] = list[1] - 0
-      return s:cache_sid[a:path]
-    endif
-  endfor
-  return 0
-endfunction
-
-function! s:_file2module(file) abort
-  let filename = fnamemodify(a:file, ':p:gs?[\\/]?/?')
-  let tail = matchstr(filename, 'autoload/vital/_\w\+/\zs.*\ze\.vim$')
-  return join(split(tail, '[\\/]\+'), '.')
-endfunction
-
-if filereadable(expand('<sfile>:r') . '.VIM')
-  " resolve() is slow, so we cache results.
-  " Note: On windows, vim can't expand path names from 8.3 formats.
-  " So if getting full path via <sfile> and $HOME was set as 8.3 format,
-  " vital load duplicated scripts. Below's :~ avoid this issue.
-  function! s:_unify_path(path) abort
-    if has_key(s:_unify_path_cache, a:path)
-      return s:_unify_path_cache[a:path]
-    endif
-    let value = tolower(fnamemodify(resolve(fnamemodify(
-    \                   a:path, ':p')), ':~:gs?[\\/]?/?'))
-    let s:_unify_path_cache[a:path] = value
-    return value
-  endfunction
-else
-  function! s:_unify_path(path) abort
-    return resolve(fnamemodify(a:path, ':p:gs?[\\/]?/?'))
-  endfunction
-endif
-
-if s:globpath_third_arg
-  function! s:_runtime_files(path) abort
-    return split(globpath(&runtimepath, a:path, 1), "\n")
-  endfunction
-else
-  function! s:_runtime_files(path) abort
-    return split(globpath(&runtimepath, a:path), "\n")
-  endfunction
-endif
-
-function! s:_vital_files(pattern) abort
-  if s:_vital_files_cache_runtimepath !=# &runtimepath
-    let path = printf('autoload/vital/%s/**/*.vim', s:self_version)
-    let s:_vital_files_cache = s:_runtime_files(path)
-    let mod = ':p:gs?[\\/]\+?/?'
-    call map(s:_vital_files_cache, 'fnamemodify(v:val, mod)')
-    let s:_vital_files_cache_runtimepath = &runtimepath
-  endif
-  let target = substitute(a:pattern, '\.', '/', 'g')
-  let target = substitute(target, '\*', '[^/]*', 'g')
-  let regexp = printf('autoload/vital/%s/%s.vim', s:self_version, target)
-  return filter(copy(s:_vital_files_cache), 'v:val =~# regexp')
-endfunction
-
-" Copy from System.Filepath
-if has('win16') || has('win32') || has('win64')
-  function! s:_is_absolute_path(path) abort
-    return a:path =~? '^[a-z]:[/\\]'
-  endfunction
-else
-  function! s:_is_absolute_path(path) abort
-    return a:path[0] ==# '/'
-  endfunction
-endif
-
-function! s:_build_module(sid) abort
-  if has_key(s:loaded, a:sid)
-    return copy(s:loaded[a:sid])
-  endif
-  let functions = s:_get_functions(a:sid)
-
-  let prefix = '<SNR>' . a:sid . '_'
-  let module = {}
-  for func in functions
-    let module[func] = function(prefix . func)
-  endfor
-  if has_key(module, '_vital_created')
-    call module._vital_created(module)
-  endif
-  let export_module = filter(copy(module), 'v:key =~# "^\\a"')
-  let s:loaded[a:sid] = get(g:, 'vital_debug', 0) ? module : export_module
-  if has_key(module, '_vital_loaded')
-    let V = vital#{s:self_version}#new()
-    call module._vital_loaded(V)
-  endif
-  return copy(s:loaded[a:sid])
-endfunction
-
-if exists('+regexpengine')
-  function! s:_get_functions(sid) abort
-    let funcs = s:_redir(printf("function /\\%%#=2^\<SNR>%d_", a:sid))
-    let map_pat = '<SNR>' . a:sid . '_\zs\w\+'
-    return map(split(funcs, "\n"), 'matchstr(v:val, map_pat)')
-  endfunction
-else
-  function! s:_get_functions(sid) abort
-    let prefix = '<SNR>' . a:sid . '_'
-    let funcs = s:_redir('function')
-    let filter_pat = '^\s*function ' . prefix
-    let map_pat = prefix . '\zs\w\+'
-    return map(filter(split(funcs, "\n"),
-    \          'stridx(v:val, prefix) > 0 && v:val =~# filter_pat'),
-    \          'matchstr(v:val, map_pat)')
-  endfunction
-endif
-
-if exists('*uniq')
-  function! s:_uniq(list) abort
-    return uniq(a:list)
-  endfunction
-else
-  function! s:_uniq(list) abort
-    let i = len(a:list) - 1
-    while 0 < i
-      if a:list[i] ==# a:list[i - 1]
-        call remove(a:list, i)
-        let i -= 2
-      else
-        let i -= 1
-      endif
-    endwhile
-    return a:list
-  endfunction
-endif
-
-function! s:_concat(lists) abort
-  let result_list = []
-  for list in a:lists
-    let result_list += list
-  endfor
-  return result_list
-endfunction
-
-function! s:_redir(cmd) abort
-  let [save_verbose, save_verbosefile] = [&verbose, &verbosefile]
-  set verbose=0 verbosefile=
-  redir => res
-    silent! execute a:cmd
-  redir END
-  let [&verbose, &verbosefile] = [save_verbose, save_verbosefile]
-  return res
-endfunction
-
-function! vital#{s:self_version}#new() abort
-  return s:_import('')
+function! vital#{s:_plugin_name}#function(funcname) abort
+  silent! return function(a:funcname)
 endfunction
 
 endif

autoload/vital/_crystal/ColorEcho.vim

@@ -1,5 +1,14 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
   
+" ___vital___
+" NOTE: lines between '" ___vital___' is generated by :Vitalize.
+" Do not mofidify the code nor insert new lines before '" ___vital___'
+function! s:_SID() abort
+  return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
+endfunction
+execute join(['function! vital#_crystal#ColorEcho#import() abort', printf("return map({'get_echorizer': '', 'echo': '', 'is_available': ''}, \"vital#_crystal#function('<SNR>%s_' . v:key)\")", s:_SID()), 'endfunction'], "\n")
+delfunction s:_SID
+" ___vital___
 scriptencoding utf-8
 let s:save_cpo = &cpo
 set cpo&vim

autoload/vital/_crystal/Data/List.vim

@@ -1,5 +1,14 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
   
+" ___vital___
+" NOTE: lines between '" ___vital___' is generated by :Vitalize.
+" Do not mofidify the code nor insert new lines before '" ___vital___'
+function! s:_SID() abort
+  return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
+endfunction
+execute join(['function! vital#_crystal#Data#List#import() abort', printf("return map({'combinations': '', 'and': '', 'sort_by': '', 'foldr1': '', 'sort': '', 'flatten': '', 'has_index': '', 'find_indices': '', 'any': '', 'unshift': '', 'span': '', 'pop': '', 'binary_search': '', 'uniq_by': '', 'or': '', 'all': '', 'zip': '', 'find_last_index': '', 'find': '', 'partition': '', 'shift': '', 'permutations': '', 'break': '', 'max_by': '', 'foldl': '', 'foldr': '', 'find_index': '', 'drop_while': '', 'group_by': '', 'take_while': '', 'conj': '', 'push': '', 'char_range': '', 'cons': '', 'foldl1': '', 'intersect': '', 'concat': '', 'map_accum': '', 'clear': '', 'has_common_items': '', 'product': '', 'zip_fill': '', 'uniq': '', 'has': '', 'min_by': '', 'with_index': ''}, \"vital#_crystal#function('<SNR>%s_' . v:key)\")", s:_SID()), 'endfunction'], "\n")
+delfunction s:_SID
+" ___vital___
 " Utilities for list.
 
 let s:save_cpo = &cpo
@@ -175,6 +184,11 @@ function! s:take_while(f, xs) abort
   return s:span(a:f, a:xs)[0]
 endfunction
 
+" similar to Haskell's Data.List.dropWhile
+function! s:drop_while(f, xs) abort
+  return s:span(a:f, a:xs)[1]
+endfunction
+
 " similar to Haskell's Data.List.partition
 function! s:partition(f, xs) abort
   return [filter(copy(a:xs), a:f), filter(copy(a:xs), '!(' . a:f . ')')]
@@ -271,14 +285,22 @@ endfunction
 
 " similar to Ruby's detect or Haskell's find.
 function! s:find(list, default, f) abort
+  let l:Call = type(a:f) is type(function('function'))
+  \          ? function('call')
+  \          : function('s:_call_string_expr')
+
   for x in a:list
-    if eval(substitute(a:f, 'v:val', string(x), 'g'))
+    if l:Call(a:f, [x])
       return x
     endif
   endfor
   return a:default
 endfunction
 
+function! s:_call_string_expr(expr, args) abort
+  return map([a:args[0]], a:expr)[0]
+endfunction
+
 " Returns the index of the first element which satisfies the given expr.
 function! s:find_index(xs, f, ...) abort
   let len = len(a:xs)
@@ -426,7 +448,7 @@ function! s:combinations(list, r) abort
   if a:r > len(a:list)
     return []
   elseif a:r < 0
-    throw 'vital: Data:List: {r} must be non-negative integer'
+    throw 'vital: Data.List: {r} must be non-negative integer'
   endif
   let n = len(a:list)
   let result = []

autoload/vital/_crystal/Data/String.vim

@@ -1,5 +1,14 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
   
+" ___vital___
+" NOTE: lines between '" ___vital___' is generated by :Vitalize.
+" Do not mofidify the code nor insert new lines before '" ___vital___'
+function! s:_SID() abort
+  return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
+endfunction
+execute join(['function! vital#_crystal#Data#String#import() abort', printf("return map({'starts_with': '', 'split3': '', 'replace_first': '', 'chop': '', 'unescape': '', 'split_posix_text': '', 'replace': '', 'scan': '', 'strwidthpart': '', 'common_head': '', 'reverse': '', 'escape_pattern': '', 'trim_end': '', '_vital_depends': '', 'wrap': '', 'join_posix_lines': '', 'contains_multibyte': '', 'truncate_skipping': '', 'split_leftright': '', 'ends_with': '', 'nsplit': '', 'strwidthpart_reverse': '', 'unescape_pattern': '', 'levenshtein_distance': '', 'trim_start': '', 'justify_equal_spacing': '', 'nr2hex': '', 'iconv': '', 'pad_left': '', 'nr2enc_char': '', 'lines': '', 'repair_posix_text': '', 'nr2byte': '', 'trim': '', 'diffidx': '', 'truncate': '', 'split_by_displaywidth': '', '_vital_created': '', 'padding_by_displaywidth': '', 'hash': '', 'chomp': '', 'pad_between_letters': '', 'dstring': '', 'pad_both_sides': '', 'substitute_last': '', 'pad_right': '', 'remove_ansi_sequences': '', '_vital_loaded': ''}, \"vital#_crystal#function('<SNR>%s_' . v:key)\")", s:_SID()), 'endfunction'], "\n")
+delfunction s:_SID
+" ___vital___
 " Utilities for string.
 
 let s:save_cpo = &cpo
@@ -7,12 +16,21 @@ set cpo&vim
 
 function! s:_vital_loaded(V) abort
   let s:V = a:V
-  let s:P = s:V.import('Prelude')
   let s:L = s:V.import('Data.List')
 endfunction
 
 function! s:_vital_depends() abort
-  return ['Prelude', 'Data.List']
+  return ['Data.List']
+endfunction
+
+function! s:_vital_created(module) abort
+  " Expose script-local funcref
+  if exists('s:strchars')
+    let a:module.strchars = s:strchars
+  endif
+  if exists('s:wcswidth')
+    let a:module.wcswidth = s:wcswidth
+  endif
 endfunction
 
 " Substitute a:from => a:to by string.
@@ -61,7 +79,7 @@ function! s:common_head(strs) abort
   endif
   let strs = len == 2 ? a:strs : sort(copy(a:strs))
   let pat = substitute(strs[0], '.', '\="[" . escape(submatch(0), "^\\") . "]"', 'g')
-  return pat == '' ? '' : matchstr(strs[-1], '\C^\%[' . pat . ']')
+  return pat ==# '' ? '' : matchstr(strs[-1], '\C^\%[' . pat . ']')
 endfunction
 
 " Split to two elements of List. ([left, right])
@@ -130,9 +148,7 @@ endfunction
 " even if a:str contains multibyte character(s).
 " s:strchars(str) {{{
 if exists('*strchars')
-  function! s:strchars(str) abort
-    return strchars(a:str)
-  endfunction
+  let s:strchars = function('strchars')
 else
   function! s:strchars(str) abort
     return strlen(substitute(copy(a:str), '.', 'x', 'g'))
@@ -210,7 +226,7 @@ function! s:nr2byte(nr) abort
 endfunction
 
 function! s:nr2enc_char(charcode) abort
-  if &encoding == 'utf-8'
+  if &encoding ==# 'utf-8'
     return nr2char(a:charcode)
   endif
   let char = s:nr2byte(a:charcode)
@@ -222,7 +238,7 @@ endfunction
 
 function! s:nr2hex(nr) abort
   let n = a:nr
-  let r = ""
+  let r = ''
   while n
     let r = '0123456789ABCDEF'[n % 16] . r
     let n = n / 16
@@ -318,7 +334,7 @@ function! s:levenshtein_distance(str1, str2) abort
   let letters2 = split(a:str2, '\zs')
   let length1 = len(letters1)
   let length2 = len(letters2)
-  let distances = map(range(1, length1 + 1), 'map(range(1, length2 + 1), "0")')
+  let distances = map(range(1, length1 + 1), 'map(range(1, length2 + 1), ''0'')')
 
   for i1 in range(0, length1)
     let distances[i1][0] = i1
@@ -373,7 +389,7 @@ function! s:split_by_displaywidth(expr, width, float, is_wrap) abort
 
   let text = ''
   while cs_index < len(cs)
-    if cs[cs_index] is "\n"
+    if cs[cs_index] is# "\n"
       let text = s:padding_by_displaywidth(text, a:width, a:float)
       let lines += [text]
       let text = ''
@@ -394,7 +410,7 @@ function! s:split_by_displaywidth(expr, width, float, is_wrap) abort
         if a:is_wrap
           if a:width < w
             if a:width < strdisplaywidth(cs[cs_index])
-              while get(cs, cs_index, "\n") isnot "\n"
+              while get(cs, cs_index, "\n") isnot# "\n"
                 let cs_index += 1
               endwhile
               continue
@@ -403,7 +419,7 @@ function! s:split_by_displaywidth(expr, width, float, is_wrap) abort
             endif
           endif
         else
-          while get(cs, cs_index, "\n") isnot "\n"
+          while get(cs, cs_index, "\n") isnot# "\n"
             let cs_index += 1
           endwhile
           continue
@@ -440,8 +456,9 @@ function! s:truncate(str, width) abort
   " http://github.com/mattn/googlereader-vim/tree/master
 
   if a:str =~# '^[\x00-\x7f]*$'
-    return len(a:str) < a:width ?
-          \ printf('%-'.a:width.'s', a:str) : strpart(a:str, 0, a:width)
+    return len(a:str) < a:width
+          \ ? printf('%-' . a:width . 's', a:str)
+          \ : strpart(a:str, 0, a:width)
   endif
 
   let ret = a:str
@@ -471,57 +488,20 @@ function! s:truncate_skipping(str, max, footer_width, separator) abort
 endfunction
 
 function! s:strwidthpart(str, width) abort
-  if a:width <= 0
-    return ''
-  endif
-  let strarr = split(a:str, '\zs')
-  let width = s:wcswidth(a:str)
-  let index = len(strarr)
-  let diff = (index + 1) / 2
-  let rightindex = index - 1
-  while width > a:width
-    let index = max([rightindex - diff + 1, 0])
-    let partwidth = s:wcswidth(join(strarr[(index):(rightindex)], ''))
-    if width - partwidth >= a:width || diff <= 1
-      let width -= partwidth
-      let rightindex = index - 1
-    endif
-    if diff > 1
-      let diff = diff / 2
-    endif
-  endwhile
-  return index ? join(strarr[:index - 1], '') : ''
+  let str = tr(a:str, "\t", ' ')
+  let vcol = a:width + 2
+  return matchstr(str, '.*\%<' . (vcol < 0 ? 0 : vcol) . 'v')
 endfunction
 
 function! s:strwidthpart_reverse(str, width) abort
-  if a:width <= 0
-    return ''
-  endif
-  let strarr = split(a:str, '\zs')
-  let width = s:wcswidth(a:str)
-  let strlen = len(strarr)
-  let diff = (strlen + 1) / 2
-  let leftindex = 0
-  let index = -1
-  while width > a:width
-    let index = min([leftindex + diff, strlen]) - 1
-    let partwidth = s:wcswidth(join(strarr[(leftindex):(index)], ''))
-    if width - partwidth >= a:width || diff <= 1
-      let width -= partwidth
-      let leftindex = index + 1
-    endif
-    if diff > 1
-      let diff = diff / 2
-    endif
-  endwhile
-  return index < strlen ? join(strarr[(index + 1):], '') : ''
+  let str = tr(a:str, "\t", ' ')
+  let vcol = s:wcswidth(str) - a:width
+  return matchstr(str, '\%>' . (vcol < 0 ? 0 : vcol) . 'v.*')
 endfunction
 
 if v:version >= 703
   " Use builtin function.
-  function! s:wcswidth(str) abort
-    return strwidth(a:str)
-  endfunction
+  let s:wcswidth = function('strwidth')
 else
   function! s:wcswidth(str) abort
     if a:str =~# '^[\x00-\x7f]*$'
@@ -564,9 +544,88 @@ else
   endfunction
 endif
 
+function! s:remove_ansi_sequences(text) abort
+  return substitute(a:text, '\e\[\%(\%(\d\+;\)*\d\+\)\?[mK]', '', 'g')
+endfunction
+
+function! s:escape_pattern(str) abort
+  " escape characters for no-magic
+  return escape(a:str, '^$~.*[]\')
+endfunction
+
+function! s:unescape_pattern(str) abort
+  " unescape characters for no-magic
+  return s:unescape(a:str, '^$~.*[]\')
+endfunction
+
+function! s:unescape(str, chars) abort
+  let chars = map(split(a:chars, '\zs'), 'escape(v:val, ''^$~.*[]\'')')
+  return substitute(a:str, '\\\(' . join(chars, '\|') . '\)', '\1', 'g')
+endfunction
+
+function! s:iconv(expr, from, to) abort
+  if a:from ==# '' || a:to ==# '' || a:from ==? a:to
+    return a:expr
+  endif
+  let result = iconv(a:expr, a:from, a:to)
+  return empty(result) ? a:expr : result
+endfunction
+
+" NOTE:
+" A definition of a TEXT file is "A file that contains characters organized
+" into one or more lines."
+" A definition of a LINE is "A sequence of zero or more non- <newline>s
+" plus a terminating <newline>"
+" That's why {stdin} always ends with <newline> ideally. However, there are
+" some programs which does not follow the POSIX rule and a Vim's way to join
+" List into TEXT; join({text}, "\n"); does not add <newline> to the end of
+" the last line.
+" That's why add a trailing <newline> if it does not exist.
+" REF:
+" http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap03.html#tag_03_392
+" http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap03.html#tag_03_205
+" :help split()
+" NOTE:
+" it does nothing if the text is a correct POSIX text
+function! s:repair_posix_text(text, ...) abort
+  let newline = get(a:000, 0, "\n")
+  return a:text =~# '\n$' ? a:text : a:text . newline
+endfunction
+
+" NOTE:
+" A definition of a TEXT file is "A file that contains characters organized
+" into one or more lines."
+" A definition of a LINE is "A sequence of zero or more non- <newline>s
+" plus a terminating <newline>"
+" REF:
+" http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap03.html#tag_03_392
+" http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap03.html#tag_03_205
+function! s:join_posix_lines(lines, ...) abort
+  let newline = get(a:000, 0, "\n")
+  return join(a:lines, newline) . newline
+endfunction
+
+" NOTE:
+" A definition of a TEXT file is "A file that contains characters organized
+" into one or more lines."
+" A definition of a LINE is "A sequence of zero or more non- <newline>s
+" plus a terminating <newline>"
+" TEXT into List; split({text}, '\r\?\n', 1); add an extra empty line at the
+" end of List because the end of TEXT ends with <newline> and keepempty=1 is
+" specified. (btw. keepempty=0 cannot be used because it will remove
+" emptylines in the head and the tail).
+" That's why removing a trailing <newline> before proceeding to 'split' is required
+" REF:
+" http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap03.html#tag_03_392
+" http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap03.html#tag_03_205
+function! s:split_posix_text(text, ...) abort
+  let newline = get(a:000, 0, '\r\?\n')
+  let text = substitute(a:text, newline . '$', '', '')
+  return split(text, newline, 1)
+endfunction
+
 let &cpo = s:save_cpo
 unlet s:save_cpo
-
 " vim:set et ts=2 sts=2 sw=2 tw=0:
 
 endif

autoload/vital/_crystal/Prelude.vim

@@ -1,389 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
-  
-let s:save_cpo = &cpo
-set cpo&vim
-
-if v:version ># 703 ||
-\  (v:version is 703 && has('patch465'))
-  function! s:glob(expr) abort
-    return glob(a:expr, 1, 1)
-  endfunction
-else
-  function! s:glob(expr) abort
-    let R = glob(a:expr, 1)
-    return split(R, '\n')
-  endfunction
-endif
-
-function! s:globpath(path, expr) abort
-  let R = globpath(a:path, a:expr, 1)
-  return split(R, '\n')
-endfunction
-
-" Wrapper functions for type().
-let [
-\   s:__TYPE_NUMBER,
-\   s:__TYPE_STRING,
-\   s:__TYPE_FUNCREF,
-\   s:__TYPE_LIST,
-\   s:__TYPE_DICT,
-\   s:__TYPE_FLOAT] = [
-      \   type(3),
-      \   type(""),
-      \   type(function('tr')),
-      \   type([]),
-      \   type({}),
-      \   has('float') ? type(str2float('0')) : -1]
-" __TYPE_FLOAT = -1 when -float
-" This doesn't match to anything.
-
-" Number or Float
-function! s:is_numeric(Value) abort
-  let _ = type(a:Value)
-  return _ ==# s:__TYPE_NUMBER
-  \   || _ ==# s:__TYPE_FLOAT
-endfunction
-
-" Number
-function! s:is_number(Value) abort
-  return type(a:Value) ==# s:__TYPE_NUMBER
-endfunction
-
-" Float
-function! s:is_float(Value) abort
-  return type(a:Value) ==# s:__TYPE_FLOAT
-endfunction
-" String
-function! s:is_string(Value) abort
-  return type(a:Value) ==# s:__TYPE_STRING
-endfunction
-" Funcref
-function! s:is_funcref(Value) abort
-  return type(a:Value) ==# s:__TYPE_FUNCREF
-endfunction
-" List
-function! s:is_list(Value) abort
-  return type(a:Value) ==# s:__TYPE_LIST
-endfunction
-" Dictionary
-function! s:is_dict(Value) abort
-  return type(a:Value) ==# s:__TYPE_DICT
-endfunction
-
-function! s:truncate_skipping(str, max, footer_width, separator) abort
-  call s:_warn_deprecated("truncate_skipping", "Data.String.truncate_skipping")
-
-  let width = s:wcswidth(a:str)
-  if width <= a:max
-    let ret = a:str
-  else
-    let header_width = a:max - s:wcswidth(a:separator) - a:footer_width
-    let ret = s:strwidthpart(a:str, header_width) . a:separator
-          \ . s:strwidthpart_reverse(a:str, a:footer_width)
-  endif
-
-  return s:truncate(ret, a:max)
-endfunction
-
-function! s:truncate(str, width) abort
-  " Original function is from mattn.
-  " http://github.com/mattn/googlereader-vim/tree/master
-
-  call s:_warn_deprecated("truncate", "Data.String.truncate")
-
-  if a:str =~# '^[\x00-\x7f]*$'
-    return len(a:str) < a:width ?
-          \ printf('%-'.a:width.'s', a:str) : strpart(a:str, 0, a:width)
-  endif
-
-  let ret = a:str
-  let width = s:wcswidth(a:str)
-  if width > a:width
-    let ret = s:strwidthpart(ret, a:width)
-    let width = s:wcswidth(ret)
-  endif
-
-  if width < a:width
-    let ret .= repeat(' ', a:width - width)
-  endif
-
-  return ret
-endfunction
-
-function! s:strwidthpart(str, width) abort
-  call s:_warn_deprecated("strwidthpart", "Data.String.strwidthpart")
-
-  if a:width <= 0
-    return ''
-  endif
-  let ret = a:str
-  let width = s:wcswidth(a:str)
-  while width > a:width
-    let char = matchstr(ret, '.$')
-    let ret = ret[: -1 - len(char)]
-    let width -= s:wcswidth(char)
-  endwhile
-
-  return ret
-endfunction
-function! s:strwidthpart_reverse(str, width) abort
-  call s:_warn_deprecated("strwidthpart_reverse", "Data.String.strwidthpart_reverse")
-
-  if a:width <= 0
-    return ''
-  endif
-  let ret = a:str
-  let width = s:wcswidth(a:str)
-  while width > a:width
-    let char = matchstr(ret, '^.')
-    let ret = ret[len(char) :]
-    let width -= s:wcswidth(char)
-  endwhile
-
-  return ret
-endfunction
-
-if v:version >= 703
-  " Use builtin function.
-  function! s:wcswidth(str) abort
-    call s:_warn_deprecated("wcswidth", "Data.String.wcswidth")
-    return strwidth(a:str)
-  endfunction
-else
-  function! s:wcswidth(str) abort
-    call s:_warn_deprecated("wcswidth", "Data.String.wcswidth")
-
-    if a:str =~# '^[\x00-\x7f]*$'
-      return strlen(a:str)
-    end
-
-    let mx_first = '^\(.\)'
-    let str = a:str
-    let width = 0
-    while 1
-      let ucs = char2nr(substitute(str, mx_first, '\1', ''))
-      if ucs == 0
-        break
-      endif
-      let width += s:_wcwidth(ucs)
-      let str = substitute(str, mx_first, '', '')
-    endwhile
-    return width
-  endfunction
-
-  " UTF-8 only.
-  function! s:_wcwidth(ucs) abort
-    let ucs = a:ucs
-    if (ucs >= 0x1100
-          \  && (ucs <= 0x115f
-          \  || ucs == 0x2329
-          \  || ucs == 0x232a
-          \  || (ucs >= 0x2e80 && ucs <= 0xa4cf
-          \      && ucs != 0x303f)
-          \  || (ucs >= 0xac00 && ucs <= 0xd7a3)
-          \  || (ucs >= 0xf900 && ucs <= 0xfaff)
-          \  || (ucs >= 0xfe30 && ucs <= 0xfe6f)
-          \  || (ucs >= 0xff00 && ucs <= 0xff60)
-          \  || (ucs >= 0xffe0 && ucs <= 0xffe6)
-          \  || (ucs >= 0x20000 && ucs <= 0x2fffd)
-          \  || (ucs >= 0x30000 && ucs <= 0x3fffd)
-          \  ))
-      return 2
-    endif
-    return 1
-  endfunction
-endif
-
-let s:is_windows = has('win16') || has('win32') || has('win64') || has('win95')
-let s:is_cygwin = has('win32unix')
-let s:is_mac = !s:is_windows && !s:is_cygwin
-      \ && (has('mac') || has('macunix') || has('gui_macvim') ||
-      \   (!isdirectory('/proc') && executable('sw_vers')))
-let s:is_unix = has('unix')
-
-function! s:is_windows() abort
-  return s:is_windows
-endfunction
-
-function! s:is_cygwin() abort
-  return s:is_cygwin
-endfunction
-
-function! s:is_mac() abort
-  return s:is_mac
-endfunction
-
-function! s:is_unix() abort
-  return s:is_unix
-endfunction
-
-function! s:_warn_deprecated(name, alternative) abort
-  try
-    echohl Error
-    echomsg "Prelude." . a:name . " is deprecated!  Please use " . a:alternative . " instead."
-  finally
-    echohl None
-  endtry
-endfunction
-
-function! s:smart_execute_command(action, word) abort
-  execute a:action . ' ' . (a:word == '' ? '' : '`=a:word`')
-endfunction
-
-function! s:escape_file_searching(buffer_name) abort
-  return escape(a:buffer_name, '*[]?{}, ')
-endfunction
-
-function! s:escape_pattern(str) abort
-  return escape(a:str, '~"\.^$[]*')
-endfunction
-
-function! s:getchar(...) abort
-  let c = call('getchar', a:000)
-  return type(c) == type(0) ? nr2char(c) : c
-endfunction
-
-function! s:getchar_safe(...) abort
-  let c = s:input_helper('getchar', a:000)
-  return type(c) == type("") ? c : nr2char(c)
-endfunction
-
-function! s:input_safe(...) abort
-  return s:input_helper('input', a:000)
-endfunction
-
-function! s:input_helper(funcname, args) abort
-  let success = 0
-  if inputsave() !=# success
-    throw 'vital: Prelude: inputsave() failed'
-  endif
-  try
-    return call(a:funcname, a:args)
-  finally
-    if inputrestore() !=# success
-      throw 'vital: Prelude: inputrestore() failed'
-    endif
-  endtry
-endfunction
-
-function! s:set_default(var, val) abort
-  if !exists(a:var) || type({a:var}) != type(a:val)
-    let {a:var} = a:val
-  endif
-endfunction
-
-function! s:substitute_path_separator(path) abort
-  return s:is_windows ? substitute(a:path, '\\', '/', 'g') : a:path
-endfunction
-
-function! s:path2directory(path) abort
-  return s:substitute_path_separator(isdirectory(a:path) ? a:path : fnamemodify(a:path, ':p:h'))
-endfunction
-
-function! s:_path2project_directory_git(path) abort
-  let parent = a:path
-
-  while 1
-    let path = parent . '/.git'
-    if isdirectory(path) || filereadable(path)
-      return parent
-    endif
-    let next = fnamemodify(parent, ':h')
-    if next == parent
-      return ''
-    endif
-    let parent = next
-  endwhile
-endfunction
-
-function! s:_path2project_directory_svn(path) abort
-  let search_directory = a:path
-  let directory = ''
-
-  let find_directory = s:escape_file_searching(search_directory)
-  let d = finddir('.svn', find_directory . ';')
-  if d == ''
-    return ''
-  endif
-
-  let directory = fnamemodify(d, ':p:h:h')
-
-  " Search parent directories.
-  let parent_directory = s:path2directory(
-        \ fnamemodify(directory, ':h'))
-
-  if parent_directory != ''
-    let d = finddir('.svn', parent_directory . ';')
-    if d != ''
-      let directory = s:_path2project_directory_svn(parent_directory)
-    endif
-  endif
-  return directory
-endfunction
-
-function! s:_path2project_directory_others(vcs, path) abort
-  let vcs = a:vcs
-  let search_directory = a:path
-
-  let find_directory = s:escape_file_searching(search_directory)
-  let d = finddir(vcs, find_directory . ';')
-  if d == ''
-    return ''
-  endif
-  return fnamemodify(d, ':p:h:h')
-endfunction
-
-function! s:path2project_directory(path, ...) abort
-  let is_allow_empty = get(a:000, 0, 0)
-  let search_directory = s:path2directory(a:path)
-  let directory = ''
-
-  " Search VCS directory.
-  for vcs in ['.git', '.bzr', '.hg', '.svn']
-    if vcs ==# '.git'
-      let directory = s:_path2project_directory_git(search_directory)
-    elseif vcs ==# '.svn'
-      let directory = s:_path2project_directory_svn(search_directory)
-    else
-      let directory = s:_path2project_directory_others(vcs, search_directory)
-    endif
-    if directory != ''
-      break
-    endif
-  endfor
-
-  " Search project file.
-  if directory == ''
-    for d in ['build.xml', 'prj.el', '.project', 'pom.xml', 'package.json',
-          \ 'Makefile', 'configure', 'Rakefile', 'NAnt.build',
-          \ 'P4CONFIG', 'tags', 'gtags']
-      let d = findfile(d, s:escape_file_searching(search_directory) . ';')
-      if d != ''
-        let directory = fnamemodify(d, ':p:h')
-        break
-      endif
-    endfor
-  endif
-
-  if directory == ''
-    " Search /src/ directory.
-    let base = s:substitute_path_separator(search_directory)
-    if base =~# '/src/'
-      let directory = base[: strridx(base, '/src/') + 3]
-    endif
-  endif
-
-  if directory == '' && !is_allow_empty
-    " Use original path.
-    let directory = search_directory
-  endif
-
-  return s:substitute_path_separator(directory)
-endfunction
-
-let &cpo = s:save_cpo
-unlet s:save_cpo
-
-" vim:set et ts=2 sts=2 sw=2 tw=0:
-
-endif

autoload/vital/_crystal/Process.vim

@@ -1,5 +1,14 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
   
+" ___vital___
+" NOTE: lines between '" ___vital___' is generated by :Vitalize.
+" Do not mofidify the code nor insert new lines before '" ___vital___'
+function! s:_SID() abort
+  return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
+endfunction
+execute join(['function! vital#_crystal#Process#import() abort', printf("return map({'shellescape': '', 'has_vimproc': '', 'system': '', 'iconv': '', 'spawn': '', 'get_last_status': ''}, \"vital#_crystal#function('<SNR>%s_' . v:key)\")", s:_SID()), 'endfunction'], "\n")
+delfunction s:_SID
+" ___vital___
 " TODO: move all comments to doc file.
 "
 "
@@ -21,62 +30,36 @@ let s:need_trans = v:version < 704 || (v:version == 704 && !has('patch122'))
 
 let s:TYPE_DICT = type({})
 let s:TYPE_LIST = type([])
-let s:TYPE_STRING = type("")
+let s:TYPE_STRING = type('')
 
-
-" Execute program in the background from Vim.
-" Return an empty string always.
-"
-" If a:expr is a List, shellescape() each argument.
-" If a:expr is a String, the arguments are passed as-is.
-"
-" Windows:
-" Using :!start , execute program without via cmd.exe.
-" Spawning 'expr' with 'noshellslash'
-" keep special characters from unwanted expansion.
-" (see :help shellescape())
-"
-" Unix:
-" using :! , execute program in the background by shell.
 function! s:spawn(expr, ...) abort
-  let shellslash = 0
-  if s:is_windows
-    let shellslash = &l:shellslash
-    setlocal noshellslash
+  if type(a:expr) is s:TYPE_LIST
+    let special = 1
+    let cmdline = join(map(a:expr, 's:shellescape(v:val, special)'), ' ')
+  elseif type(a:expr) is s:TYPE_STRING
+    let cmdline = a:expr
+    if a:0 && a:1
+      " for :! command
+      let cmdline = substitute(cmdline, '\([!%#]\|<[^<>]\+>\)', '\\\1', 'g')
+    endif
+  else
+    throw 'vital: Process: invalid argument (value type:' . type(a:expr) . ')'
+  endif
+  if s:is_windows
+    silent execute '!start' cmdline
+  else
+    silent execute '!' cmdline '&'
   endif
-  try
-    if type(a:expr) is s:TYPE_LIST
-      let special = 1
-      let cmdline = join(map(a:expr, 'shellescape(v:val, special)'), ' ')
-    elseif type(a:expr) is s:TYPE_STRING
-      let cmdline = a:expr
-      if a:0 && a:1
-        " for :! command
-        let cmdline = substitute(cmdline, '\([!%#]\|<[^<>]\+>\)', '\\\1', 'g')
-      endif
-    else
-      throw 'Process.spawn(): invalid argument (value type:'.type(a:expr).')'
-    endif
-    if s:is_windows
-      silent execute '!start' cmdline
-    else
-      silent execute '!' cmdline '&'
-    endif
-  finally
-    if s:is_windows
-      let &l:shellslash = shellslash
-    endif
-  endtry
   return ''
 endfunction
 
 " iconv() wrapper for safety.
 function! s:iconv(expr, from, to) abort
-  if a:from == '' || a:to == '' || a:from ==? a:to
+  if a:from ==# '' || a:to ==# '' || a:from ==? a:to
     return a:expr
   endif
   let result = iconv(a:expr, a:from, a:to)
-  return result != '' ? result : a:expr
+  return result !=# '' ? result : a:expr
 endfunction
 
 " Check vimproc.
@@ -128,7 +111,7 @@ function! s:system(str, ...) abort
     elseif type(a:1) is s:TYPE_STRING
       let args += [s:iconv(a:1, &encoding, 'char')]
     else
-      throw 'Process.system(): invalid argument (value type:'.type(a:1).')'
+      throw 'vital: Process: invalid argument (value type:' . type(a:1) . ')'
     endif
   elseif a:0 >= 2
     " {command} [, {input} [, {timeout}]]
@@ -145,13 +128,16 @@ function! s:system(str, ...) abort
   elseif type(a:str) is s:TYPE_STRING
     let command = a:str
   else
-    throw 'Process.system(): invalid argument (value type:'.type(a:str).')'
+    throw 'vital: Process: invalid argument (value type:' . type(a:str) . ')'
   endif
   if s:need_trans
     let command = s:iconv(command, &encoding, 'char')
   endif
   let args = [command] + args
   if background && (use_vimproc || !s:is_windows)
+    if has('nvim')
+      throw "vital: Process: neovim's system() doesn't support background(&) process (cmdline:" . string(a:str) . ')'
+    endif
     let args[0] = args[0] . ' &'
   endif
 
@@ -167,8 +153,14 @@ function! s:get_last_status() abort
 endfunction
 
 if s:is_windows
-  function! s:shellescape(command) abort
-    return substitute(a:command, '[&()[\]{}^=;!''+,`~]', '^\0', 'g')
+  function! s:shellescape(...) abort
+    try
+      let shellslash = &shellslash
+      set noshellslash
+      return call('shellescape', a:000)
+    finally
+      let &shellslash = shellslash
+    endtry
   endfunction
 else
   function! s:shellescape(...) abort

autoload/vital/_crystal/Web/JSON.vim

@@ -1,5 +1,14 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
   
+" ___vital___
+" NOTE: lines between '" ___vital___' is generated by :Vitalize.
+" Do not mofidify the code nor insert new lines before '" ___vital___'
+function! s:_SID() abort
+  return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
+endfunction
+execute join(['function! vital#_crystal#Web#JSON#import() abort', printf("return map({'decode': '', '_vital_depends': '', '_vital_created': '', 'encode': '', '_vital_loaded': ''}, \"vital#_crystal#function('<SNR>%s_' . v:key)\")", s:_SID()), 'endfunction'], "\n")
+delfunction s:_SID
+" ___vital___
 let s:save_cpo = &cpo
 set cpo&vim
 
@@ -15,11 +24,6 @@ function! s:_null() abort
   return 0
 endfunction
 
-let s:const = {}
-let s:const.true = function('s:_true')
-let s:const.false = function('s:_false')
-let s:const.null = function('s:_null')
-
 function! s:_resolve(val, prefix) abort
   let t = type(a:val)
   if t == type('')
@@ -36,6 +40,13 @@ endfunction
 
 function! s:_vital_created(module) abort
   " define constant variables
+  if !exists('s:const')
+    let s:const = {}
+    let s:const.true = function('s:_true')
+    let s:const.false = function('s:_false')
+    let s:const.null = function('s:_null')
+    lockvar s:const
+  endif
   call extend(a:module, s:const)
 endfunction
 
@@ -55,7 +66,7 @@ function! s:decode(json, ...) abort
   let settings = extend({
         \ 'use_token': 0,
         \}, get(a:000, 0, {}))
-  let json = iconv(a:json, "utf-8", &encoding)
+  let json = iconv(a:json, 'utf-8', &encoding)
   let json = join(split(json, "\n"), '')
   let json = substitute(json, '\\u34;', '\\"', 'g')
   let json = substitute(json, '\\u\(\x\x\x\x\)', '\=s:string.nr2enc_char("0x".submatch(1))', 'g')
@@ -75,7 +86,11 @@ endfunction
 " @vimlint(EVL102, 0, l:true)
 " @vimlint(EVL102, 0, l:false)
 
-function! s:encode(val) abort
+function! s:encode(val, ...) abort
+  let settings = extend({
+        \ 'indent': 0,
+        \}, get(a:000, 0, {})
+        \)
   if type(a:val) == 0
     return a:val
   elseif type(a:val) == 1
@@ -83,7 +98,7 @@ function! s:encode(val) abort
     let json = substitute(json, "\r", '\\r', 'g')
     let json = substitute(json, "\n", '\\n', 'g')
     let json = substitute(json, "\t", '\\t', 'g')
-    return iconv(json, &encoding, "utf-8")
+    return iconv(json, &encoding, 'utf-8')
   elseif type(a:val) == 2
     if s:const.true == a:val
       return 'true'
@@ -96,14 +111,69 @@ function! s:encode(val) abort
       return string(a:val)
     endif
   elseif type(a:val) == 3
-    return '[' . join(map(copy(a:val), 's:encode(v:val)'), ',') . ']'
+    return s:_encode_list(a:val, settings)
   elseif type(a:val) == 4
-    return '{' . join(map(keys(a:val), 's:encode(v:val).":".s:encode(a:val[v:val])'), ',') . '}'
+    return s:_encode_dict(a:val, settings)
   else
     return string(a:val)
   endif
 endfunction
 
+" @vimlint(EVL102, 1, l:ns)
+function! s:_encode_list(val, settings) abort
+  if empty(a:val)
+    return '[]'
+  elseif !a:settings.indent
+    let encoded_candidates = map(copy(a:val), 's:encode(v:val, a:settings)')
+    return printf('[%s]', join(encoded_candidates, ','))
+  else
+    let previous_indent = get(a:settings, '_previous_indent')
+    let indent = previous_indent + a:settings.indent
+    let ns = extend(copy(a:settings), {
+          \ '_previous_indent': indent,
+          \})
+    let encoded_candidates = map(
+          \ copy(a:val),
+          \ printf('''%s'' . s:encode(v:val, ns)', repeat(' ', indent)),
+          \)
+    return printf(
+          \ "[\n%s\n%s]",
+          \ join(encoded_candidates, ",\n"),
+          \ repeat(' ', previous_indent)
+          \)
+  endif
+endfunction
+" @vimlint(EVL102, 0, l:ns)
+
+" @vimlint(EVL102, 1, l:ns)
+function! s:_encode_dict(val, settings) abort
+  if empty(a:val)
+    return '{}'
+  elseif !a:settings.indent
+    let encoded_candidates = map(keys(a:val),
+          \ 's:encode(v:val, a:settings) . '':'' . s:encode(a:val[v:val], a:settings)'
+          \)
+    return printf('{%s}', join(encoded_candidates, ','))
+  else
+    let previous_indent = get(a:settings, '_previous_indent')
+    let indent = previous_indent + a:settings.indent
+    let ns = extend(copy(a:settings), {
+          \ '_previous_indent': indent,
+          \})
+    let encoded_candidates = map(keys(a:val),
+          \ printf(
+          \   '''%s'' . s:encode(v:val, ns) . '': '' . s:encode(a:val[v:val], ns)',
+          \   repeat(' ', indent),
+          \ ),
+          \)
+    return printf("{\n%s\n%s}",
+          \ join(encoded_candidates, ",\n"),
+          \ repeat(' ', previous_indent),
+          \)
+  endif
+endfunction
+" @vimlint(EVL102, 0, l:ns)
+
 let &cpo = s:save_cpo
 unlet s:save_cpo
 

autoload/vital/crystal.vim

@@ -0,0 +1,332 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
+  
+let s:plugin_name = expand('<sfile>:t:r')
+let s:vital_base_dir = expand('<sfile>:h')
+let s:project_root = expand('<sfile>:h:h:h')
+let s:is_vital_vim = s:plugin_name is# 'vital'
+
+let s:loaded = {}
+let s:cache_sid = {}
+
+" function() wrapper
+if v:version > 703 || v:version == 703 && has('patch1170')
+  function! s:_function(fstr) abort
+    return function(a:fstr)
+  endfunction
+else
+  function! s:_SID() abort
+    return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
+  endfunction
+  let s:_s = '<SNR>' . s:_SID() . '_'
+  function! s:_function(fstr) abort
+    return function(substitute(a:fstr, 's:', s:_s, 'g'))
+  endfunction
+endif
+
+function! vital#{s:plugin_name}#new() abort
+  return s:new(s:plugin_name)
+endfunction
+
+function! vital#{s:plugin_name}#import(...) abort
+  if !exists('s:V')
+    let s:V = s:new(s:plugin_name)
+  endif
+  return call(s:V.import, a:000, s:V)
+endfunction
+
+let s:Vital = {}
+
+function! s:new(plugin_name) abort
+  let base = deepcopy(s:Vital)
+  let base._plugin_name = a:plugin_name
+  return base
+endfunction
+
+function! s:vital_files() abort
+  if !exists('s:vital_files')
+    let s:vital_files = map(
+    \   s:is_vital_vim ? s:_global_vital_files() : s:_self_vital_files(),
+    \   'fnamemodify(v:val, ":p:gs?[\\\\/]?/?")')
+  endif
+  return copy(s:vital_files)
+endfunction
+let s:Vital.vital_files = s:_function('s:vital_files')
+
+function! s:import(name, ...) abort dict
+  let target = {}
+  let functions = []
+  for a in a:000
+    if type(a) == type({})
+      let target = a
+    elseif type(a) == type([])
+      let functions = a
+    endif
+    unlet a
+  endfor
+  let module = self._import(a:name)
+  if empty(functions)
+    call extend(target, module, 'keep')
+  else
+    for f in functions
+      if has_key(module, f) && !has_key(target, f)
+        let target[f] = module[f]
+      endif
+    endfor
+  endif
+  return target
+endfunction
+let s:Vital.import = s:_function('s:import')
+
+function! s:load(...) abort dict
+  for arg in a:000
+    let [name; as] = type(arg) == type([]) ? arg[: 1] : [arg, arg]
+    let target = split(join(as, ''), '\W\+')
+    let dict = self
+    let dict_type = type({})
+    while !empty(target)
+      let ns = remove(target, 0)
+      if !has_key(dict, ns)
+        let dict[ns] = {}
+      endif
+      if type(dict[ns]) == dict_type
+        let dict = dict[ns]
+      else
+        unlet dict
+        break
+      endif
+    endwhile
+    if exists('dict')
+      call extend(dict, self._import(name))
+    endif
+    unlet arg
+  endfor
+  return self
+endfunction
+let s:Vital.load = s:_function('s:load')
+
+function! s:unload() abort dict
+  let s:loaded = {}
+  let s:cache_sid = {}
+  unlet! s:vital_files
+endfunction
+let s:Vital.unload = s:_function('s:unload')
+
+function! s:exists(name) abort dict
+  if a:name !~# '\v^\u\w*%(\.\u\w*)*$'
+    throw 'vital: Invalid module name: ' . a:name
+  endif
+  return s:_module_path(a:name) isnot# ''
+endfunction
+let s:Vital.exists = s:_function('s:exists')
+
+function! s:search(pattern) abort dict
+  let paths = s:_extract_files(a:pattern, self.vital_files())
+  let modules = sort(map(paths, 's:_file2module(v:val)'))
+  return s:_uniq(modules)
+endfunction
+let s:Vital.search = s:_function('s:search')
+
+function! s:plugin_name() abort dict
+  return self._plugin_name
+endfunction
+let s:Vital.plugin_name = s:_function('s:plugin_name')
+
+function! s:_self_vital_files() abort
+  let builtin = printf('%s/__%s__/', s:vital_base_dir, s:plugin_name)
+  let installed = printf('%s/_%s/', s:vital_base_dir, s:plugin_name)
+  let base = builtin . ',' . installed
+  return split(globpath(base, '**/*.vim', 1), "\n")
+endfunction
+
+function! s:_global_vital_files() abort
+  let pattern = 'autoload/vital/__*__/**/*.vim'
+  return split(globpath(&runtimepath, pattern, 1), "\n")
+endfunction
+
+function! s:_extract_files(pattern, files) abort
+  let tr = {'.': '/', '*': '[^/]*', '**': '.*'}
+  let target = substitute(a:pattern, '\.\|\*\*\?', '\=tr[submatch(0)]', 'g')
+  let regexp = printf('autoload/vital/[^/]\+/%s.vim$', target)
+  return filter(a:files, 'v:val =~# regexp')
+endfunction
+
+function! s:_file2module(file) abort
+  let filename = fnamemodify(a:file, ':p:gs?[\\/]?/?')
+  let tail = matchstr(filename, 'autoload/vital/_\w\+/\zs.*\ze\.vim$')
+  return join(split(tail, '[\\/]\+'), '.')
+endfunction
+
+" @param {string} name e.g. Data.List
+function! s:_import(name) abort dict
+  if has_key(s:loaded, a:name)
+    return copy(s:loaded[a:name])
+  endif
+  let module = self._get_module(a:name)
+  if has_key(module, '_vital_created')
+    call module._vital_created(module)
+  endif
+  let export_module = filter(copy(module), 'v:key =~# "^\\a"')
+  " Cache module before calling module.vital_loaded() to avoid cyclic
+  " dependences but remove the cache if module._vital_loaded() fails.
+  " let s:loaded[a:name] = export_module
+  let s:loaded[a:name] = export_module
+  if has_key(module, '_vital_loaded')
+    try
+      call module._vital_loaded(vital#{s:plugin_name}#new())
+    catch
+      unlet s:loaded[a:name]
+      throw 'vital: fail to call ._vital_loaded(): ' . v:exception
+    endtry
+  endif
+  return copy(s:loaded[a:name])
+endfunction
+let s:Vital._import = s:_function('s:_import')
+
+" s:_get_module() returns module object wihch has all script local functions.
+function! s:_get_module(name) abort dict
+  let funcname = s:_import_func_name(self.plugin_name(), a:name)
+  try
+    return call(funcname, [])
+  catch /^Vim\%((\a\+)\)\?:E117/
+    return s:_get_builtin_module(a:name)
+  endtry
+endfunction
+
+function! s:_get_builtin_module(name) abort
+ return s:sid2sfuncs(s:_module_sid(a:name))
+endfunction
+
+if s:is_vital_vim
+  " For vital.vim, we can use s:_get_builtin_module directly
+  let s:Vital._get_module = s:_function('s:_get_builtin_module')
+else
+  let s:Vital._get_module = s:_function('s:_get_module')
+endif
+
+function! s:_import_func_name(plugin_name, module_name) abort
+  return printf('vital#_%s#%s#import', a:plugin_name, s:_dot_to_sharp(a:module_name))
+endfunction
+
+function! s:_module_sid(name) abort
+  let path = s:_module_path(a:name)
+  if !filereadable(path)
+    throw 'vital: module not found: ' . a:name
+  endif
+  let vital_dir = s:is_vital_vim ? '__\w\+__' : printf('_\{1,2}%s\%%(__\)\?', s:plugin_name)
+  let base = join([vital_dir, ''], '[/\\]\+')
+  let p = base . substitute('' . a:name, '\.', '[/\\\\]\\+', 'g')
+  let sid = s:_sid(path, p)
+  if !sid
+    call s:_source(path)
+    let sid = s:_sid(path, p)
+    if !sid
+      throw printf('vital: cannot get <SID> from path: %s', path)
+    endif
+  endif
+  return sid
+endfunction
+
+function! s:_module_path(name) abort
+  return get(s:_extract_files(a:name, s:vital_files()), 0, '')
+endfunction
+
+function! s:_module_sid_base_dir() abort
+  return s:is_vital_vim ? &rtp : s:project_root
+endfunction
+
+function! s:_dot_to_sharp(name) abort
+  return substitute(a:name, '\.', '#', 'g')
+endfunction
+
+function! s:_source(path) abort
+  execute 'source' fnameescape(a:path)
+endfunction
+
+" @vimlint(EVL102, 1, l:_)
+" @vimlint(EVL102, 1, l:__)
+function! s:_sid(path, filter_pattern) abort
+  let unified_path = s:_unify_path(a:path)
+  if has_key(s:cache_sid, unified_path)
+    return s:cache_sid[unified_path]
+  endif
+  for line in filter(split(s:_execute(':scriptnames'), "\n"), 'v:val =~# a:filter_pattern')
+    let [_, sid, path; __] = matchlist(line, '^\s*\(\d\+\):\s\+\(.\+\)\s*$')
+    if s:_unify_path(path) is# unified_path
+      let s:cache_sid[unified_path] = sid
+      return s:cache_sid[unified_path]
+    endif
+  endfor
+  return 0
+endfunction
+
+" We want to use a execute() builtin function instead of s:_execute(),
+" however there is a bug in execute().
+" execute() returns empty string when it is called in
+" completion function of user defined ex command.
+" https://github.com/vim-jp/issues/issues/1129
+function! s:_execute(cmd) abort
+  let [save_verbose, save_verbosefile] = [&verbose, &verbosefile]
+  set verbose=0 verbosefile=
+  redir => res
+    silent! execute a:cmd
+  redir END
+  let [&verbose, &verbosefile] = [save_verbose, save_verbosefile]
+  return res
+endfunction
+
+if filereadable(expand('<sfile>:r') . '.VIM') " is case-insensitive or not
+  let s:_unify_path_cache = {}
+  " resolve() is slow, so we cache results.
+  " Note: On windows, vim can't expand path names from 8.3 formats.
+  " So if getting full path via <sfile> and $HOME was set as 8.3 format,
+  " vital load duplicated scripts. Below's :~ avoid this issue.
+  function! s:_unify_path(path) abort
+    if has_key(s:_unify_path_cache, a:path)
+      return s:_unify_path_cache[a:path]
+    endif
+    let value = tolower(fnamemodify(resolve(fnamemodify(
+    \                   a:path, ':p')), ':~:gs?[\\/]?/?'))
+    let s:_unify_path_cache[a:path] = value
+    return value
+  endfunction
+else
+  function! s:_unify_path(path) abort
+    return resolve(fnamemodify(a:path, ':p:gs?[\\/]?/?'))
+  endfunction
+endif
+
+" copied and modified from Vim.ScriptLocal
+let s:SNR = join(map(range(len("\<SNR>")), '"[\\x" . printf("%0x", char2nr("\<SNR>"[v:val])) . "]"'), '')
+function! s:sid2sfuncs(sid) abort
+  let fs = split(s:_execute(printf(':function /^%s%s_', s:SNR, a:sid)), "\n")
+  let r = {}
+  let pattern = printf('\m^function\s<SNR>%d_\zs\w\{-}\ze(', a:sid)
+  for fname in map(fs, 'matchstr(v:val, pattern)')
+    let r[fname] = function(s:_sfuncname(a:sid, fname))
+  endfor
+  return r
+endfunction
+
+"" Return funcname of script local functions with SID
+function! s:_sfuncname(sid, funcname) abort
+  return printf('<SNR>%s_%s', a:sid, a:funcname)
+endfunction
+
+if exists('*uniq')
+  function! s:_uniq(list) abort
+    return uniq(a:list)
+  endfunction
+else
+  function! s:_uniq(list) abort
+    let i = len(a:list) - 1
+    while 0 < i
+      if a:list[i] ==# a:list[i - 1]
+        call remove(a:list, i)
+      endif
+      let i -= 1
+    endwhile
+    return a:list
+  endfunction
+endif
+
+endif

autoload/vital/crystal.vital

@@ -0,0 +1,10 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
+  
+crystal
+bee84ae23effb0510137ad177e98c94d8b3657a6
+
+Process
+Web.JSON
+ColorEcho
+
+endif

autoload/xml/aria.vim

@@ -94,44 +94,61 @@ let landmark_role = [
 \ ]
 
 " Ref: https://www.w3.org/TR/dpub-aria-1.0/
-" Version: W3C Candidate Recommendation 15 December 2016
+" Version: W3C Recommendation 14 December 2017
 let dpub_role = [
-    \ 'dpub-abstract',
-    \ 'dpub-afterword',
-    \ 'dpub-appendix',
-    \ 'dpub-biblioentry',
-    \ 'dpub-bibliography',
-    \ 'dpub-biblioref',
-    \ 'dpub-chapter',
-    \ 'dpub-cover',
-    \ 'dpub-epilogue',
-    \ 'dpub-footnote',
-    \ 'dpub-footnotes',
-    \ 'dpub-foreword',
-    \ 'dpub-glossary',
-    \ 'dpub-glossdef',
-    \ 'dpub-glossref',
-    \ 'dpub-glossterm',
-    \ 'dpub-index',
-    \ 'dpub-locator',
-    \ 'dpub-noteref',
-    \ 'dpub-notice',
-    \ 'dpub-pagebreak',
-    \ 'dpub-pagelist',
-    \ 'dpub-part',
-    \ 'dpub-preface',
-    \ 'dpub-prologue',
-    \ 'dpub-pullquote',
-    \ 'dpub-qna',
-    \ 'dpub-subtitle',
-    \ 'dpub-tip',
-    \ 'dpub-title',
-    \ 'dpub-toc'
+    \ 'doc-abstract',
+    \ 'doc-acknowledgments',
+    \ 'doc-afterword',
+    \ 'doc-appendix',
+    \ 'doc-backlink',
+    \ 'doc-biblioentry',
+    \ 'doc-bibliography',
+    \ 'doc-biblioref',
+    \ 'doc-chapter',
+    \ 'doc-colophon',
+    \ 'doc-conclusion',
+    \ 'doc-cover',
+    \ 'doc-credit',
+    \ 'doc-credits',
+    \ 'doc-dedication',
+    \ 'doc-endnote',
+    \ 'doc-endnotes',
+    \ 'doc-epigraph',
+    \ 'doc-epilogue',
+    \ 'doc-errata',
+    \ 'doc-example',
+    \ 'doc-footnote',
+    \ 'doc-foreword',
+    \ 'doc-glossary',
+    \ 'doc-glossref',
+    \ 'doc-index',
+    \ 'doc-introduction',
+    \ 'doc-noteref',
+    \ 'doc-notice',
+    \ 'doc-pagebreak',
+    \ 'doc-pagelist',
+    \ 'doc-part',
+    \ 'doc-preface',
+    \ 'doc-prologue',
+    \ 'doc-pullquote',
+    \ 'doc-qna',
+    \ 'doc-subtitle',
+    \ 'doc-tip',
+    \ 'doc-toc'
+\ ]
+
+" Ref: https://www.w3.org/TR/graphics-aria-1.0/
+" Version: W3C Candidate Recommendation 29 March 2018
+let graphic_role = [
+    \ 'graphics-document',
+    \ 'graphics-object',
+    \ 'graphics-symbol'
 \ ]
 
 let role = extend(widget_role, document_structure)
 let role = extend(role, landmark_role)
 let role = extend(role, dpub_role)
+let role = extend(role, graphic_role)
 
 " https://www.w3.org/TR/wai-aria-1.1/#states_and_properties
 let global_states_and_properties = {

autoload/xml/html5.vim

@@ -62,7 +62,7 @@ let charset = [
     \ 'windows-1256', 'windows-1257', 'windows-1258', 'TIS-620', ]
 " }}}
 
-let autofill_tokens = ['on', 'off', 'name', 'honorific-prefix', 'given-name', 'additional-name', 'family-name', 'honorific-suffix', 'nickname', 'username', 'new-password', 'current-password', 'organization-title', 'organization', 'street-address', 'address-line1', 'address-line2', 'address-line3', 'address-level4', 'address-level3', 'address-level2', 'address-level1', 'country', 'country-name', 'postal-code', 'cc-name', 'cc-given-name', 'cc-additional-name', 'cc-family-name', 'cc-number', 'cc-exp', 'cc-exp-month', 'cc-exp-year', 'cc-csc', 'cc-type', 'transaction-currency', 'transaction-amount', 'language', 'bday', 'bday-day', 'bday-month', 'bday-year', 'sex', 'url', 'photo']
+let autofill_tokens = ['on', 'off', 'name', 'honorific-prefix', 'given-name', 'additional-name', 'family-name', 'honorific-suffix', 'nickname', 'organization-title', 'username', 'new-password', 'current-password', 'organization', 'street-address', 'address-line1', 'address-line2', 'address-line3', 'address-level4', 'address-level3', 'address-level2', 'address-level1', 'country', 'country-name', 'postal-code', 'cc-name', 'cc-given-name', 'cc-additional-name', 'cc-family-name', 'cc-number', 'cc-exp', 'cc-exp-month', 'cc-exp-year', 'cc-csc', 'cc-type', 'transaction-currency', 'transaction-amount', 'language', 'bday', 'bday-day', 'bday-month', 'bday-year', 'sex', 'url', 'photo', 'tel', 'tel-country-code', 'tel-national', 'tel-area-code', 'tel-local', 'tel-local-prefix', 'tel-local-suffix', 'tel-extension', 'email', 'impp']
 
 " Attributes_and_Settings: {{{
 let core_attributes = {'accesskey': [], 'class': [], 'contenteditable': ['true', 'false', ''], 'contextmenu': [], 'dir': ['ltr', 'rtl'], 'draggable': ['true', 'false'], 'hidden': ['hidden', ''], 'id': [], 'is': [], 'lang': lang_tag, 'spellcheck': ['true', 'false', ''], 'style': [], 'tabindex': [], 'title': []}
@@ -82,6 +82,7 @@ let attributes_value = {
     \ 'action': ['URL', ''],
     \ 'allowfullscreen': ['Bool', ''],
     \ 'allowpaymentrequest': ['Bool', ''],
+    \ 'allowpresentation': ['Bool', ''],
     \ 'allowusermedia': ['Bool', ''],
     \ 'alt': ['Text', ''],
     \ 'async': ['Bool', ''],
@@ -190,7 +191,7 @@ let attributes_value = {
 \ }
 
 if g:html5_event_handler_attributes_complete == 1
-    let event_handler_attributes = {'onabort': [], 'onblur': [], 'oncanplay': [], 'oncanplaythrough': [], 'onchange': [], 'onclick': [], 'oncontextmenu': [], 'ondblclick': [], 'ondrag': [], 'ondragend': [], 'ondragenter': [], 'ondragleave': [], 'ondragover': [], 'ondragstart': [], 'ondrop': [], 'ondurationchange': [], 'onemptied': [], 'onended': [], 'onerror': [], 'onfocus': [], 'onformchange': [], 'onforminput': [], 'oninput': [], 'oninvalid': [], 'onkeydown': [], 'onkeypress': [], 'onkeyup': [], 'onload': [], 'onloadeddata': [], 'onloadedmetadata': [], 'onloadstart': [], 'onmousedown': [], 'onmousemove': [], 'onmouseout': [], 'onmouseover': [], 'onmouseup': [], 'onmousewheel': [], 'onpause': [], 'onplay': [], 'onplaying': [], 'onprogress': [], 'onratechange': [], 'onreadystatechange': [], 'onscroll': [], 'onseeked': [], 'onseeking': [], 'onselect': [], 'onshow': [], 'onstalled': [], 'onsubmit': [], 'onsuspend': [], 'ontimeupdate': [], 'onvolumechange': [], 'onwaiting': []}
+    let event_handler_attributes = {'onabort': [], 'onblur': [], 'oncanplay': [], 'oncanplaythrough': [], 'onchange': [], 'onclick': [], 'oncontextmenu': [], 'ondblclick': [], 'ondrag': [], 'ondragend': [], 'ondragenter': [], 'ondragleave': [], 'ondragover': [], 'ondragstart': [], 'ondrop': [], 'ondurationchange': [], 'onemptied': [], 'onended': [], 'onerror': [], 'onfocus': [], 'onformchange': [], 'onforminput': [], 'oninput': [], 'oninvalid': [], 'onkeydown': [], 'onkeypress': [], 'onkeyup': [], 'onload': [], 'onloadeddata': [], 'onloadedmetadata': [], 'onloadstart': [], 'onmousedown': [], 'onmousemove': [], 'onmouseout': [], 'onmouseover': [], 'onmouseup': [], 'onmousewheel': [], 'onpause': [], 'onplay': [], 'onplaying': [], 'onprogress': [], 'onratechange': [], 'onreadystatechange': [], 'onscroll': [], 'onseeked': [], 'onseeking': [], 'onselect': [], 'onshow': [], 'onstalled': [], 'onsubmit': [], 'onsuspend': [], 'ontimeupdate': [], 'onvolumechange': [], 'onwaiting': [], 'onselectstart': [], 'onselectchange': []}
     let global_attributes = extend(global_attributes, event_handler_attributes)
     
     let body_attributes = {'onafterprint': [], 'onbeforeprint': [], 'onbeforeunload': [], 'onblur': [], 'onerror': [], 'onfocus': [], 'onhashchange': [], 'onload': [], 'onmessage': [], 'onoffline': [], 'ononline': [], 'onpopstate': [], 'onredo': [], 'onresize': [], 'onstorage': [], 'onundo': [], 'onunload': []}
@@ -213,6 +214,8 @@ if g:html5_event_handler_attributes_complete == 1
         \ 'ondragleave': ['Script', ''],
         \ 'ondragover': ['Script', ''],
         \ 'ondragstart': ['Script', ''],
+        \ 'onselectstart': ['Script', ''],
+        \ 'onselectchange': ['Script', ''],
         \ 'ondrop': ['Script', ''],
         \ 'ondurationchange': ['Script', ''],
         \ 'onemptied': ['Script', ''],
@@ -373,6 +376,8 @@ let abutton_dec = 'details\\|embed\\|iframe\\|keygen\\|label\\|menu\\|select\\|t
 
 let crossorigin = ['anonymous', 'use-credentials']
 
+let referrerpolicy = ['no-referrer', 'no-referrer-when-downgrade', 'same-origin', 'origin', 'strict-origin', 'origin-when-cross-origin', 'strict-origin-when-cross-origin', 'unsafe-url']
+
 
 let g:xmldata_html5 = {
 \ 'vimxmlentities': ['AElig', 'Aacute', 'Acirc', 'Agrave', 'Alpha', 'Aring', 'Atilde', 'Auml', 'Beta', 'Ccedil', 'Chi', 'Dagger', 'Delta', 'ETH', 'Eacute', 'Ecirc', 'Egrave', 'Epsilon', 'Eta', 'Euml', 'Gamma', 'Iacute', 'Icirc', 'Igrave', 'Iota', 'Iuml', 'Kappa', 'Lambda', 'Mu', 'Ntilde', 'Nu', 'OElig', 'Oacute', 'Ocirc', 'Ograve', 'Omega', 'Omicron', 'Oslash', 'Otilde', 'Ouml', 'Phi', 'Pi', 'Prime', 'Psi', 'Rho', 'Scaron', 'Sigma', 'THORN', 'Tau', 'Theta', 'Uacute', 'Ucirc', 'Ugrave', 'Upsilon', 'Uuml', 'Xi', 'Yacute', 'Yuml', 'Zeta', 'aacute', 'acirc', 'acute', 'aelig', 'agrave', 'alefsym', 'alpha', 'amp', 'and', 'ang', 'apos', 'aring', 'asymp', 'atilde', 'auml', 'bdquo', 'beta', 'brvbar', 'bull', 'cap', 'ccedil', 'cedil', 'cent', 'chi', 'circ', 'clubs', 'cong', 'copy', 'crarr', 'cup', 'curren', 'dArr', 'dagger', 'darr', 'deg', 'delta', 'diams', 'divide', 'eacute', 'ecirc', 'egrave', 'empty', 'emsp', 'ensp', 'epsilon', 'equiv', 'eta', 'eth', 'euml', 'euro', 'exist', 'fnof', 'forall', 'frac12', 'frac14', 'frac34', 'frasl', 'gamma', 'ge', 'gt', 'hArr', 'harr', 'hearts', 'hellip', 'iacute', 'icirc', 'iexcl', 'igrave', 'image', 'infin', 'int', 'iota', 'iquest', 'isin', 'iuml', 'kappa', 'lArr', 'lambda', 'lang', 'laquo', 'larr', 'lceil', 'ldquo', 'le', 'lfloor', 'lowast', 'loz', 'lrm', 'lsaquo', 'lsquo', 'lt', 'macr', 'mdash', 'micro', 'middot', 'minus', 'mu', 'nabla', 'nbsp', 'ndash', 'ne', 'ni', 'not', 'notin', 'nsub', 'ntilde', 'nu', 'oacute', 'ocirc', 'oelig', 'ograve', 'oline', 'omega', 'omicron', 'oplus', 'or', 'ordf', 'ordm', 'oslash', 'otilde', 'otimes', 'ouml', 'para', 'part', 'permil', 'perp', 'phi', 'pi', 'piv', 'plusmn', 'pound', 'prime', 'prod', 'prop', 'psi', 'quot', 'rArr', 'radic', 'rang', 'raquo', 'rarr', 'rceil', 'rdquo', 'real', 'reg', 'rfloor', 'rho', 'rlm', 'rsaquo', 'rsquo', 'sbquo', 'scaron', 'sdot', 'sect', 'shy', 'sigma', 'sigmaf', 'sim', 'spades', 'sub', 'sube', 'sum', 'sup', 'sup1', 'sup2', 'sup3', 'supe', 'szlig', 'tau', 'there4', 'theta', 'thetasym', 'thinsp', 'thorn', 'tilde', 'times', 'trade', 'uArr', 'uacute', 'uarr', 'ucirc', 'ugrave', 'uml', 'upsih', 'upsilon', 'uuml', 'weierp', 'xi', 'yacute', 'yen', 'yuml', 'zeta', 'zwj', 'zwnj'],
@@ -391,7 +396,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'area': [
     \ [],
-    \ extend(copy(global_attributes), {'alt': [], 'href': [], 'target': [], 'rel': linktypes, 'media': [], 'hreflang': lang_tag, 'type': [], 'shape': ['rect', 'circle', 'poly', 'default'], 'coords': [], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url']})
+    \ extend(copy(global_attributes), {'alt': [], 'href': [], 'target': [], 'rel': linktypes, 'media': [], 'hreflang': lang_tag, 'type': [], 'shape': ['rect', 'circle', 'poly', 'default'], 'coords': [], 'referrerpolicy': referrerpolicy})
 \ ],
 \ 'article': [
     \ flow_elements + ['style'],
@@ -489,6 +494,10 @@ let g:xmldata_html5 = {
     \ filter(copy(phrasing_elements), "!(v:val =~ 'dfn')"),
     \ global_attributes
 \ ],
+\ 'dialog': [
+    \ flow_elements,
+    \ extend(copy(global_attributes), {'open': []})
+\ ],
 \ 'div': [
     \ flow_elements + ['style'],
     \ global_attributes
@@ -579,11 +588,11 @@ let g:xmldata_html5 = {
 \ ],
 \ 'iframe': [
     \ [],
-    \ extend(copy(global_attributes), {'src': [], 'srcdoc': [], 'name': [], 'width': [], 'height': [], 'sandbox': ['allow-same-origin', 'allow-forms', 'allow-scripts'], 'seamless': ['seamless', ''], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url'], 'allowfullscreen': [], 'allowpaymentrequest': [], 'allowusermedia': []})
+    \ extend(copy(global_attributes), {'src': [], 'srcdoc': [], 'name': [], 'width': [], 'height': [], 'sandbox': ['allow-same-origin', 'allow-forms', 'allow-scripts'], 'seamless': ['seamless', ''], 'referrerpolicy': referrerpolicy, 'allowfullscreen': [], 'allowpaymentrequest': [], 'allowpresentation': [], 'allowusermedia': []})
 \ ],
 \ 'img': [
     \ [],
-    \ extend(copy(global_attributes), {'src': [], 'alt': [], 'height': [], 'width': [], 'usemap': [], 'ismap': ['ismap', ''], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url'], 'crossorigin': ['anonymous', 'use-credentials']})
+    \ extend(copy(global_attributes), {'src': [], 'alt': [], 'height': [], 'width': [], 'decoding': ['async', 'sync', 'auto'], 'usemap': [], 'ismap': ['ismap', ''], 'referrerpolicy': referrerpolicy, 'crossorigin': ['anonymous', 'use-credentials']})
 \ ],
 \ 'input': [
     \ [],
@@ -615,7 +624,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'link': [
     \ [],
-    \ extend(copy(global_attributes), {'href': [], 'rel': linkreltypes, 'hreflang': lang_tag, 'media': [], 'type': [], 'sizes': ['any'], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url'], 'crossorigin': crossorigin, 'preload': ['preload', ''], 'prefetch': ['prefetch', '']})
+    \ extend(copy(global_attributes), {'href': [], 'rel': linkreltypes, 'hreflang': lang_tag, 'media': [], 'type': [], 'sizes': ['any'], 'referrerpolicy': referrerpolicy, 'crossorigin': crossorigin, 'preload': ['preload', ''], 'prefetch': ['prefetch', ''], 'as': ['report', 'document', 'document', 'object', 'embed', 'audio', 'font', 'image', 'audioworklet', 'paintworklet', 'script', 'serviceworker', 'sharedworker', 'worker', 'style', 'track', 'video', 'image', 'manifest', 'xslt', 'fetch', '']})
 \ ],
 \ 'main': [
     \ flow_elements + ['style'],

build

@@ -3,41 +3,44 @@
 set -E
 
 DIRS="syntax indent compiler autoload ftplugin after/syntax after/indent after/ftplugin"
+# shellcheck disable=SC2034
 DIRS_BASIC="syntax compiler indent after/syntax after/indent"
+# shellcheck disable=SC2034
 DIRS_ALL="syntax indent compiler autoload ftplugin after"
-DIRS_SYNTAX="syntax after/syntax"
+# shellcheck disable=SC2034
+DIRS_SYNTAX="syntax indent after/syntax after/indent"
 DIRS_JAVASCRIPT="${DIRS} extras"
-DIRS_RM="$DIRS_JAVASCRIPT"
+read -r -a DIRS_RM <<<"$DIRS_JAVASCRIPT"
 
 OUTPUT=""
 
 output() {
   OUTPUT="$OUTPUT$1"
-  printf -- "$1"
+  echo -n "$1"
 }
 
 download() {
   for pack in $1; do
-    path="$(printf "$pack" | cut -d ':' -f 2)"
-    dir="tmp/$(printf "$path" | cut -d '/' -f 2)"
+    path="$(cut -d ':' -f 2 <<<"$pack")"
+    dir="tmp/$(cut -d '/' -f 2 <<<"$path")"
     rm -rf "$dir"
-    (mkdir -p "$dir" && curl --silent -L https://codeload.github.com/$path/tar.gz/master | tar -zx -C "$dir" --strip 1 && printf '.') &
+    (mkdir -p "$dir" && curl --silent -L "https://codeload.github.com/$path/tar.gz/master" | tar -zx -C "$dir" --strip 1 && printf '.') &
   done
 
   wait
 }
 
 extract() {
-  printf "\n"
+  echo
 
   cat config.vim >> tmp/polyglot.vim
 
   for pack in $1; do
-    name="$(printf "$pack" | cut -d ':' -f 1)"
-    path="$(printf "$pack" | cut -d ':' -f 2)"
-    dir="tmp/$(printf "$path" | cut -d '/' -f 2)"
-    directories="DIRS$(printf "$pack" | cut -d ':' -f 3)"
-    subtree="$(printf "$pack" | cut -d ':' -f 4)"
+    name="$(cut -d ':' -f 1 <<<"$pack")"
+    path="$(cut -d ':' -f 2 <<<"$pack")"
+    dir="tmp/$(cut -d '/' -f 2 <<<"$path")"
+    directories="DIRS$(cut -d ':' -f 3 <<<"$pack")"
+    subtree="$(cut -d ':' -f 4 <<<"$pack")"
     output "- [$name](https://github.com/$path) ("
 
     subdirs=""
@@ -52,63 +55,104 @@ extract() {
       fi
     done
 
-    for f in ${dir}/ftdetect/*; do
-      (
-        echo "augroup filetypedetect";
-        echo '" '"$pack";
-        cat "${f}";
-        echo "augroup END";
-        echo
-      ) >> tmp/polyglot.vim;
+    # syntax for go.vim depends on autoload for go.vim, but we exclude the
+    # autoload always and the ftplugin because it's too complex.  FML.
+    if [ "${pack%%:*}" = "go" ]; then
+      copy_file "${dir}${subtree}" "${dir}${subtree}/autoload/go/config.vim" "${name}"
+    fi
+
+    output "${subdirs##, })"$'\n'
+
+    if (echo "julia coffee-script elixir fish git plantuml scala swift" | grep -qF "$name"); then
+      echo "Skipping ftdetect installation of $name" >&2
+      continue
+    fi
+
+    [ -d "${dir}/ftdetect" ] && for f in "${dir}/ftdetect/"*; do
+      cat <<EOF >> tmp/polyglot.vim
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, '${pack%%:*}') == -1
+  augroup filetypedetect
+  " ${pack%%:*}, from ${f##*/ftdetect/} in ${pack#*:}
+$(cat "${f}")
+  augroup end
+endif
+
+EOF
     done
 
-    output "${subdirs##, })\n"
   done
 
   mv tmp/polyglot.vim ftdetect/
 
   for pack in $1; do
-    name="$(printf "$pack" | cut -d ':' -f 1)"
-    path="$(printf "$pack" | cut -d ':' -f 2)"
-    dir="tmp/$(printf "$path" | cut -d '/' -f 2)"
-    subtree="$(printf "$pack" | cut -d ':' -f 4)"
+    name="$(cut -d ':' -f 1 <<<"$pack")"
+    path="$(cut -d ':' -f 2 <<<"$pack")"
+    dir="tmp/$(cut -d '/' -f 2 <<<"$path")"
+    subtree="$(cut -d ':' -f 4 <<<"$pack")"
 
     if [ -d "$dir${subtree:-/}plugin" ]; then
-      printf "Possible error (plugin directory exists): $path\n"
+      echo "Possible error (plugin directory exists): $path" >&2
     fi
   done
 }
 
 copy_dir() {
-  for file in $(find "$1/$2" -name '*.vim'); do
-    file_path="$(dirname "${file##$1/}")"
-    mkdir -p "$file_path"
-    touch "$file_path/$(basename "$file")"
-
-    # Use comma instead of / to handle cases like c/c++
-    sed -e "s,%%PACK%%,$3," -e "/%%CONTENT%%/{r $file" -e "d;}" plugin_guard.vim.template >> $file_path/$(basename "$file")
+  find "$1/$2" \( -name '*.vim' -o -name '*.vital' \) -print0 | while read -r -d $'\0' file; do
+    copy_file "$1" "$file" "$3"
   done
 }
 
+copy_file() {
+  ## $1 is the build dir (e.g. tmp/vim-go)
+  ## $2 is the full file path, as returned by `find` (e.g. tmp/vim-go/indent/go.vim)
+  ## $3 is the name of the package (so that we can detect if it's disabled at runtime)
+  local tmp_dir="$1"
+  local file_in_tmp="$2"
+  local file_basename="${2##*/}"
+  local file_path="${file_in_tmp##$tmp_dir/}" # Just this file's (full) path
+  file_path="${file_path%/*}"                # Minus the actual name of the file
+  local file_in_dst="${file_path}/${file_basename}" # Could also be ${file_in_tmp##$tmp_dir/}
+  local package_name="$3"
+
+  if [ "${file_in_tmp##$tmp_dir/}" != "${file_in_dst}" ]; then
+    echo "Failure in logic in build script; '${file_in_tmp##$tmp_dir/}' != '${file_in_dst}'.  Bailing." >&2
+    exit 1
+  fi
+
+  mkdir -p "${file_path}"
+  touch "$file_in_dst"
+
+  # Use comma instead of / to handle cases like c/c++
+  sed -e "s,%%PACK%%,${package_name}," -e "/%%CONTENT%%/{r ${file_in_tmp}" -e "d;}" plugin_guard.vim.template >> "$file_in_dst"
+}
+
 update_readme() {
-  OLD_README="$(cat README.md)"
-
-  ed README.md <<- EOF
-/Language packs
-+2kb
-/##
-'b,-2c
-$(printf -- "$OUTPUT" | sort)
-.
-w
-q
-EOF
+  local tf of
+  tf="$(mktemp)"
+  of="$(mktemp)"
+  sort <<<"$OUTPUT" | grep -vxE '[[:space:]]*' > "$of"
 
+  awk 'suppress == 0 {
+      gsub(/<!--Package Count-->[^<]*<!--\/Package Count-->/,
+           "<!--Package Count-->'"$(awk 'END {print NR}' "$of")"'<!--/Package Count-->");
+      print;
+    }
+    /<!--Language Packs-->/ {
+      suppress = 1;
+      while ( ( getline line < "'"$of"'" ) > 0 ) {
+        print line;
+      }
+    }
+    /<!--\/Language Packs-->/ {
+      suppress = 0;
+      print;
+    }' "README.md" >"$tf"
+  mv "$tf" "README.md"
 }
 
 PACKS="
   apiblueprint:sheerun/apiblueprint.vim
-  applescript:vim-scripts/applescript.vim
+  applescript:mityu/vim-applescript:_SYNTAX
   asciidoc:asciidoc/vim-asciidoc
   yaml:stephpy/vim-yaml
   ansible:pearofducks/ansible-vim
@@ -118,6 +162,7 @@ PACKS="
   c++11:octol/vim-cpp-enhanced-highlight
   c/c++:vim-jp/vim-cpp
   caddyfile:isobit/vim-caddyfile
+  carp:hellerve/carp-vim
   cjsx:mtscout6/vim-cjsx
   clojure:guns/vim-clojure-static
   cmake:pboettch/vim-cmake-syntax
@@ -133,6 +178,7 @@ PACKS="
   emberscript:yalesov/vim-ember-script
   emblem:yalesov/vim-emblem
   erlang:vim-erlang/vim-erlang-runtime
+  ferm:vim-scripts/ferm.vim
   fish:dag/vim-fish
   fsharp:fsharp/vim-fsharp:_BASIC
   git:tpope/vim-git
@@ -140,9 +186,11 @@ PACKS="
   glsl:tikhomirov/vim-glsl
   gnuplot:vim-scripts/gnuplot-syntax-highlighting
   go:fatih/vim-go:_BASIC
+  graphql:jparise/vim-graphql
   groovy:vim-scripts/groovy.vim
   haml:sheerun/vim-haml
   handlebars:mustache/vim-mustache-handlebars
+  haproxy:CH-DanReif/haproxy.vim
   haskell:neovimhaskell/haskell-vim
   haxe:yaymukund/vim-haxe
   html5:othree/html5.vim
@@ -151,9 +199,10 @@ PACKS="
   javascript:pangloss/vim-javascript:_JAVASCRIPT
   jenkins:martinda/Jenkinsfile-vim-syntax
   json:elzr/vim-json
+  json5:GutenYe/json5.vim
   jst:briancollins/vim-jst
   jsx:mxw/vim-jsx:_ALL
-  julia:dcjones/julia-minimalist-vim
+  julia:JuliaEditorSupport/julia-vim
   kotlin:udalov/kotlin-vim
   latex:LaTeX-Box-Team/LaTeX-Box
   less:groenewege/vim-less
@@ -179,8 +228,9 @@ PACKS="
   pug:digitaltoad/vim-pug
   puppet:voxpupuli/vim-puppet
   purescript:purescript-contrib/purescript-vim
-  python:mitsuhiko/vim-python-combined
+  python:vim-python/python-syntax
   python-compiler:aliev/vim-compiler-python
+  python-ident:Vimjas/vim-python-pep8-indent
   qml:peterhoeg/vim-qml
   r-lang:vim-scripts/R.vim
   racket:wlangstroth/vim-racket
@@ -193,11 +243,12 @@ PACKS="
   scala:derekwyatt/vim-scala
   scss:cakebaker/scss-syntax.vim
   slim:slim-template/vim-slim
+  slime:slime-lang/vim-slime-syntax
   solidity:tomlion/vim-solidity
   stylus:wavded/vim-stylus
   swift:keith/swift.vim
   sxhkd:baskerville/vim-sxhkdrc
-  systemd:kurayama/systemd-vim-syntax
+  systemd:wgwoods/vim-systemd-syntax
   terraform:hashivim/vim-terraform
   textile:timcharper/textile.vim
   thrift:solarnz/thrift.vim
@@ -217,12 +268,12 @@ PACKS="
 "
 
 rm -rf tmp
-rm -rf $DIRS_RM
+rm -rf "${DIRS_RM[@]}"
 mkdir tmp
 
 printf "Downloading packs..."
-download "$PACKS"
-extract "$PACKS"
+download "$(sed '/^#/d' <<<"$PACKS")"
+extract "$(sed '/^#/d' <<<"$PACKS")"
 update_readme
 
 rm -rf tmp

compiler/cargo.vim

@@ -7,35 +7,47 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 " For bugs, patches and license go to https://github.com/rust-lang/rust.vim
 
 if exists('current_compiler')
-	finish
+    finish
 endif
 runtime compiler/rustc.vim
 let current_compiler = "cargo"
 
+" vint: -ProhibitAbbreviationOption
 let s:save_cpo = &cpo
 set cpo&vim
+" vint: +ProhibitAbbreviationOption
 
 if exists(':CompilerSet') != 2
-	command -nargs=* CompilerSet setlocal <args>
+    command -nargs=* CompilerSet setlocal <args>
 endif
 
 if exists('g:cargo_makeprg_params')
-	execute 'CompilerSet makeprg=cargo\ '.escape(g:cargo_makeprg_params, ' \|"').'\ $*'
+    execute 'CompilerSet makeprg=cargo\ '.escape(g:cargo_makeprg_params, ' \|"').'\ $*'
 else
-	CompilerSet makeprg=cargo\ $*
+    CompilerSet makeprg=cargo\ $*
 endif
 
+augroup RustCargoQuickFixHooks
+    autocmd!
+    autocmd QuickFixCmdPre make call cargo#quickfix#CmdPre()
+    autocmd QuickFixCmdPost make call cargo#quickfix#CmdPost()
+augroup END
+
 " Ignore general cargo progress messages
 CompilerSet errorformat+=
-			\%-G%\\s%#Downloading%.%#,
-			\%-G%\\s%#Compiling%.%#,
-			\%-G%\\s%#Finished%.%#,
-			\%-G%\\s%#error:\ Could\ not\ compile\ %.%#,
-			\%-G%\\s%#To\ learn\ more\\,%.%#,
-			\%-Gnote:\ Run\ with\ \`RUST_BACKTRACE=%.%#,
-			\%.%#panicked\ at\ \\'%m\\'\\,\ %f:%l
+            \%-G%\\s%#Downloading%.%#,
+            \%-G%\\s%#Compiling%.%#,
+            \%-G%\\s%#Finished%.%#,
+            \%-G%\\s%#error:\ Could\ not\ compile\ %.%#,
+            \%-G%\\s%#To\ learn\ more\\,%.%#,
+            \%-Gnote:\ Run\ with\ \`RUST_BACKTRACE=%.%#,
+            \%.%#panicked\ at\ \\'%m\\'\\,\ %f:%l:%c
 
+" vint: -ProhibitAbbreviationOption
 let &cpo = s:save_cpo
 unlet s:save_cpo
+" vint: +ProhibitAbbreviationOption
+
+" vim: set et sw=4 sts=4 ts=8:
 
 endif

compiler/credo.vim

@@ -0,0 +1,15 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
+  
+if exists('current_compiler')
+    finish
+endif
+let current_compiler = 'credo'
+
+if exists(":CompilerSet") != 2
+    command -nargs=* CompilerSet setlocal <args>
+endif
+
+CompilerSet errorformat=%f:%l:\ %t:\ %m
+CompilerSet makeprg=mix\ credo\ suggest\ --format=flycheck
+
+endif

compiler/eruby.vim

@@ -30,8 +30,8 @@ CompilerSet errorformat=
     \%W%f:%l:\ warning:\ %m,
     \%E%f:%l:in\ %*[^:]:\ %m,
     \%E%f:%l:\ %m,
-    \%-C%\tfrom\ %f:%l:in\ %.%#,
-    \%-Z%\tfrom\ %f:%l,
+    \%-C%\t%\\d%#:%#\ %#from\ %f:%l:in\ %.%#,
+    \%-Z%\t%\\d%#:%#\ %#from\ %f:%l,
     \%-Z%p^,
     \%-G%.%#
 

compiler/mix.vim

@@ -0,0 +1,15 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
+  
+if exists('current_compiler')
+    finish
+endif
+let current_compiler = 'mix'
+
+if exists(":CompilerSet") != 2
+    command -nargs=* CompilerSet setlocal <args>
+endif
+
+CompilerSet errorformat=%A%t%*[^:]:\ %m,%C%f:%l:\ %m,%C%f:%l,%Z
+CompilerSet makeprg=mix
+
+endif

compiler/nim.vim

@@ -13,7 +13,7 @@ endif
 let s:cpo_save = &cpo
 set cpo-=C
 
-CompilerSet makeprg=nim\ c\ --verbosity:0\ $*\ %:p
+CompilerSet makeprg=nim\ c\ --verbosity:0\ --listfullpaths\ $*\ %:p
 
 CompilerSet errorformat=
   \%-GHint:\ %m,

compiler/nix-build.vim

@@ -0,0 +1,15 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'nix') == -1
+  
+if exists('current_compiler')
+    finish
+endif
+let current_compiler = 'nix-build'
+
+if exists(":CompilerSet") != 2
+    command -nargs=* CompilerSet setlocal <args>
+endif
+
+CompilerSet errorformat=error:\ %m\ at\ %f:%l:%c,builder\ for\ \'%m\'\ failed\ with\ exit\ code\ %n,fixed-output\ derivation\ produced\ path\ \'%s\'\ with\ %m
+CompilerSet makeprg=nix-build
+
+endif

compiler/rake.vim

@@ -22,12 +22,12 @@ CompilerSet makeprg=rake
 
 CompilerSet errorformat=
       \%D(in\ %f),
-      \%\\s%#from\ %f:%l:%m,
-      \%\\s%#from\ %f:%l:,
-      \%\\s%##\ %f:%l:%m%\\&%.%#%\\D:%\\d%#:%.%#,
-      \%\\s%##\ %f:%l%\\&%.%#%\\D:%\\d%#,
-      \%\\s%#[%f:%l:\ %#%m%\\&%.%#%\\D:%\\d%#:%.%#,
-      \%\\s%#%f:%l:\ %#%m%\\&%.%#%\\D:%\\d%#:%.%#,
+      \%\\s%#%\\d%#:%#\ %#from\ %f:%l:%m,
+      \%\\s%#%\\d%#:%#\ %#from\ %f:%l:,
+      \%\\s%##\ %f:%l:%m%\\&%.%#%\\D:%\\d%\\+:%.%#,
+      \%\\s%##\ %f:%l%\\&%.%#%\\D:%\\d%\\+,
+      \%\\s%#[%f:%l:\ %#%m%\\&%.%#%\\D:%\\d%\\+:%.%#,
+      \%\\s%#%f:%l:\ %#%m%\\&%.%#%\\D:%\\d%\\+:%.%#,
       \%\\s%#%f:%l:,
       \%m\ [%f:%l]:,
       \%+Erake\ aborted!,

compiler/rspec.vim

@@ -25,7 +25,8 @@ CompilerSet errorformat=
     \%E%.%#:in\ `load':\ %f:%l:%m,
     \%E%f:%l:in\ `%*[^']':\ %m,
     \%-Z\ \ \ \ \ %\\+\#\ %f:%l:%.%#,
-    \%E\ \ %\\d%\\+)%.%#,
+    \%E\ \ \ \ \ Failure/Error:\ %m,
+    \%E\ \ \ \ \ Failure/Error:,
     \%C\ \ \ \ \ %m,
     \%C%\\s%#,
     \%-G%.%#

compiler/ruby.vim

@@ -23,21 +23,21 @@ set cpo-=C
 " default settings runs script normally
 " add '-c' switch to run syntax check only:
 "
-"   CompilerSet makeprg=ruby\ -wc\ $*
+"   CompilerSet makeprg=ruby\ -c
 "
 " or add '-c' at :make command line:
 "
 "   :make -c %<CR>
 "
-CompilerSet makeprg=ruby\ -w\ $*
+CompilerSet makeprg=ruby
 
 CompilerSet errorformat=
     \%+E%f:%l:\ parse\ error,
     \%W%f:%l:\ warning:\ %m,
     \%E%f:%l:in\ %*[^:]:\ %m,
     \%E%f:%l:\ %m,
-    \%-C%\tfrom\ %f:%l:in\ %.%#,
-    \%-Z%\tfrom\ %f:%l,
+    \%-C%\t%\\d%#:%#\ %#from\ %f:%l:in\ %.%#,
+    \%-Z%\t%\\d%#:%#\ %#from\ %f:%l,
     \%-Z%p^,
     \%-G%.%#
 

compiler/rustc.vim

@@ -7,44 +7,51 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 " For bugs, patches and license go to https://github.com/rust-lang/rust.vim
 
 if exists("current_compiler")
-	finish
+    finish
 endif
 let current_compiler = "rustc"
 
-let s:cpo_save = &cpo
+" vint: -ProhibitAbbreviationOption
+let s:save_cpo = &cpo
 set cpo&vim
+" vint: +ProhibitAbbreviationOption
 
 if exists(":CompilerSet") != 2
-	command -nargs=* CompilerSet setlocal <args>
+    command -nargs=* CompilerSet setlocal <args>
 endif
 
-if exists("g:rustc_makeprg_no_percent") && g:rustc_makeprg_no_percent != 0
-	CompilerSet makeprg=rustc
+if get(g:, 'rustc_makeprg_no_percent', 0)
+    CompilerSet makeprg=rustc
 else
-	CompilerSet makeprg=rustc\ \%
+    CompilerSet makeprg=rustc\ \%
 endif
 
-" Old errorformat (before nightly 2016/08/10)
-CompilerSet errorformat=
-			\%f:%l:%c:\ %t%*[^:]:\ %m,
-			\%f:%l:%c:\ %*\\d:%*\\d\ %t%*[^:]:\ %m,
-			\%-G%f:%l\ %s,
-			\%-G%*[\ ]^,
-			\%-G%*[\ ]^%*[~],
-			\%-G%*[\ ]...
-
 " New errorformat (after nightly 2016/08/10)
-CompilerSet errorformat+=
-			\%-G,
-			\%-Gerror:\ aborting\ %.%#,
-			\%-Gerror:\ Could\ not\ compile\ %.%#,
-			\%Eerror:\ %m,
-			\%Eerror[E%n]:\ %m,
-			\%Wwarning:\ %m,
-			\%Inote:\ %m,
-			\%C\ %#-->\ %f:%l:%c
+CompilerSet errorformat=
+            \%-G,
+            \%-Gerror:\ aborting\ %.%#,
+            \%-Gerror:\ Could\ not\ compile\ %.%#,
+            \%Eerror:\ %m,
+            \%Eerror[E%n]:\ %m,
+            \%Wwarning:\ %m,
+            \%Inote:\ %m,
+            \%C\ %#-->\ %f:%l:%c,
+            \%E\ \ left:%m,%C\ right:%m\ %f:%l:%c,%Z
 
-let &cpo = s:cpo_save
-unlet s:cpo_save
+" Old errorformat (before nightly 2016/08/10)
+CompilerSet errorformat+=
+            \%f:%l:%c:\ %t%*[^:]:\ %m,
+            \%f:%l:%c:\ %*\\d:%*\\d\ %t%*[^:]:\ %m,
+            \%-G%f:%l\ %s,
+            \%-G%*[\ ]^,
+            \%-G%*[\ ]^%*[~],
+            \%-G%*[\ ]...
+
+" vint: -ProhibitAbbreviationOption
+let &cpo = s:save_cpo
+unlet s:save_cpo
+" vint: +ProhibitAbbreviationOption
+
+" vim: set et sw=4 sts=4 ts=8:
 
 endif

config.vim

@@ -13,3 +13,63 @@ let g:filetype_euphoria = 'elixir'
 augroup filetypedetect
   autocmd BufNewFile,BufReadPost *.vb setlocal filetype=vbnet
 augroup END
+
+let g:python_highlight_all = 1
+
+augroup filetypedetect
+  if v:version < 704
+    " NOTE: this line fixes an issue with the default system-wide lisp ftplugin
+    "       which didn't define b:undo_ftplugin on older Vim versions
+    "       (*.jl files are recognized as lisp)
+    autocmd BufRead,BufNewFile *.jl    let b:undo_ftplugin = "setlocal comments< define< formatoptions< iskeyword< lisp<"
+  endif
+  
+  autocmd BufRead,BufNewFile *.jl      set filetype=julia
+
+  " coffeescript
+  autocmd BufNewFile,BufRead *.coffee set filetype=coffee
+  autocmd BufNewFile,BufRead *Cakefile set filetype=coffee
+  autocmd BufNewFile,BufRead *.coffeekup,*.ck set filetype=coffee
+  autocmd BufNewFile,BufRead *._coffee set filetype=coffee
+  autocmd BufNewFile,BufRead *.litcoffee set filetype=litcoffee
+  autocmd BufNewFile,BufRead *.coffee.md set filetype=litcoffee
+
+
+  " elixir
+  au BufRead,BufNewFile *.ex,*.exs call s:setf('elixir')
+  au BufRead,BufNewFile *.eex call s:setf('eelixir')
+
+  " fish
+  autocmd BufRead,BufNewFile *.fish setfiletype fish
+  autocmd BufRead fish_funced_*_*.fish call search('^$')
+  autocmd BufRead,BufNewFile ~/.config/fish/fish_{read_,}history setfiletype yaml
+  autocmd BufRead,BufNewFile ~/.config/fish/fishd.* setlocal readonly
+  autocmd BufNewFile ~/.config/fish/functions/*.fish
+              \ call append(0, ['function '.expand('%:t:r'),
+                               \'',
+                               \'end']) |
+              \ 2
+  
+  " git
+  autocmd BufNewFile,BufRead *.git/{,modules/**/,worktrees/*/}{COMMIT_EDIT,TAG_EDIT,MERGE_,}MSG set ft=gitcommit
+  autocmd BufNewFile,BufRead *.git/config,.gitconfig,gitconfig,.gitmodules set ft=gitconfig
+  autocmd BufNewFile,BufRead */.config/git/config                          set ft=gitconfig
+  autocmd BufNewFile,BufRead *.git/modules/**/config                       set ft=gitconfig
+  autocmd BufNewFile,BufRead git-rebase-todo                               set ft=gitrebase
+  autocmd BufNewFile,BufRead .gitsendemail.*                               set ft=gitsendemail
+
+  " plantuml
+  autocmd BufRead,BufNewFile *.pu,*.uml,*.plantuml setfiletype plantuml | set filetype=plantuml
+
+  " scala
+  au BufRead,BufNewFile *.scala,*.sc set filetype=scala
+  au BufRead,BufNewFile *.sbt setfiletype sbt.scala
+
+  " swift
+  autocmd BufNewFile,BufRead *.swift set filetype=swift
+augroup END
+
+" Fix for https://github.com/sheerun/vim-polyglot/issues/236#issuecomment-387984954
+if (!exists('g:graphql_javascript_tags'))
+  let g:graphql_javascript_tags = ['gql', 'graphql', 'Relay.QL']
+endif

extras/flow.vim

@@ -15,7 +15,7 @@ syntax region  jsFlowArrowArguments contained matchgroup=jsFlowNoise start=/(/
 syntax match   jsFlowArrow          contained /=>/ skipwhite skipempty nextgroup=jsFlowType,jsFlowTypeCustom,jsFlowParens
 syntax match   jsFlowObjectKey      contained /[0-9a-zA-Z_$?]*\(\s*:\)\@=/ contains=jsFunctionKey,jsFlowMaybe skipwhite skipempty nextgroup=jsObjectValue containedin=jsObject
 syntax match   jsFlowOrOperator     contained /|/ skipwhite skipempty nextgroup=@jsFlowCluster
-syntax keyword jsFlowImportType     contained type skipwhite skipempty nextgroup=jsModuleAsterisk,jsModuleKeyword,jsModuleGroup
+syntax keyword jsFlowImportType     contained type typeof skipwhite skipempty nextgroup=jsModuleAsterisk,jsModuleKeyword,jsModuleGroup
 syntax match   jsFlowWildcard       contained /*/
 
 syntax match   jsFlowReturn         contained /:\s*/ contains=jsFlowNoise skipwhite skipempty nextgroup=@jsFlowReturnCluster,jsFlowArrow,jsFlowReturnParens
@@ -23,16 +23,17 @@ syntax region  jsFlowReturnObject   contained matchgroup=jsFlowNoise start=/{/
 syntax region  jsFlowReturnArray    contained matchgroup=jsFlowNoise start=/\[/   end=/\]/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncBlock,jsFlowReturnOrOp fold
 syntax region  jsFlowReturnParens   contained matchgroup=jsFlowNoise start=/(/    end=/)/  contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncBlock,jsFlowReturnOrOp,jsFlowReturnArrow fold
 syntax match   jsFlowReturnArrow    contained /=>/ skipwhite skipempty nextgroup=@jsFlowReturnCluster
-syntax match   jsFlowReturnKeyword  contained /\k\+/ contains=jsFlowType,jsFlowTypeCustom skipwhite skipempty nextgroup=jsFlowReturnGroup,jsFuncBlock,jsFlowReturnOrOp
+syntax match   jsFlowReturnKeyword  contained /\k\+/ contains=jsFlowType,jsFlowTypeCustom skipwhite skipempty nextgroup=jsFlowReturnGroup,jsFuncBlock,jsFlowReturnOrOp,jsFlowReturnArray
 syntax match   jsFlowReturnMaybe    contained /?/ skipwhite skipempty nextgroup=jsFlowReturnKeyword,jsFlowReturnObject
 syntax region  jsFlowReturnGroup    contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncBlock,jsFlowReturnOrOp
 syntax match   jsFlowReturnOrOp     contained /\s*|\s*/ skipwhite skipempty nextgroup=@jsFlowReturnCluster
 syntax match   jsFlowWildcardReturn contained /*/ skipwhite skipempty nextgroup=jsFuncBlock
 
-syntax region  jsFlowFunctionGroup  contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncArgs
-syntax region  jsFlowClassGroup     contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsClassBlock
+syntax region  jsFlowFunctionGroup      contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncArgs
+syntax region  jsFlowClassGroup         contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsClassBlock
+syntax region  jsFlowClassFunctionGroup contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncArgs
 
-syntax region  jsFlowTypeStatement                                   start=/type\%(\s\+\k\)\@=/    end=/=\@=/ contains=jsFlowTypeOperator oneline skipwhite skipempty nextgroup=jsFlowTypeValue keepend
+syntax region  jsFlowTypeStatement                                   start=/\(opaque\s\+\)\?type\%(\s\+\k\)\@=/    end=/=\@=/ contains=jsFlowTypeOperator oneline skipwhite skipempty nextgroup=jsFlowTypeValue keepend
 syntax region  jsFlowTypeValue      contained     matchgroup=jsFlowNoise start=/=/       end=/[\n;]/ contains=@jsFlowCluster,jsFlowGroup,jsFlowMaybe
 syntax match   jsFlowTypeOperator   contained /=/ containedin=jsFlowTypeValue
 syntax match   jsFlowTypeOperator   contained /=/
@@ -83,6 +84,7 @@ if version >= 508 || !exists("did_javascript_syn_inits")
   HiLink jsFlowReturnGroup        jsFlowGroup
   HiLink jsFlowFunctionGroup      PreProc
   HiLink jsFlowClassGroup         PreProc
+  HiLink jsFlowClassFunctionGroup PreProc
   HiLink jsFlowArrowArguments     PreProc
   HiLink jsFlowArrow              PreProc
   HiLink jsFlowReturnArrow        PreProc

extras/jsdoc.vim

@@ -12,7 +12,7 @@ syntax match  jsDocTags         contained "@\(callback\|define\|enum\|external\|
 " tags containing references
 syntax match  jsDocTags         contained "@\(lends\|see\|tutorial\)\>" skipwhite nextgroup=jsDocSeeTag
 " other tags (no extra syntax)
-syntax match  jsDocTags         contained "@\(abstract\|access\|accessor\|async\|author\|classdesc\|constant\|const\|constructor\|copyright\|deprecated\|desc\|description\|dict\|event\|example\|file\|file[oO]verview\|final\|function\|global\|ignore\|inheritDoc\|inner\|instance\|interface\|license\|localdoc\|method\|mixin\|nosideeffects\|override\|overview\|preserve\|private\|protected\|public\|readonly\|since\|static\|struct\|todo\|summary\|undocumented\|virtual\)\>"
+syntax match  jsDocTags         contained "@\(abstract\|access\|accessor\|async\|author\|classdesc\|constant\|const\|constructor\|copyright\|deprecated\|desc\|description\|dict\|event\|example\|file\|file[oO]verview\|final\|function\|global\|ignore\|inherit[dD]oc\|inner\|instance\|interface\|license\|localdoc\|method\|mixin\|nosideeffects\|override\|overview\|preserve\|private\|protected\|public\|readonly\|since\|static\|struct\|todo\|summary\|undocumented\|virtual\)\>"
 
 syntax region jsDocType         contained matchgroup=jsDocTypeBrackets start="{" end="}" contains=jsDocTypeRecord oneline skipwhite nextgroup=jsDocParam
 syntax match  jsDocType         contained "\%(#\|\"\|\w\|\.\|:\|\/\)\+" skipwhite nextgroup=jsDocParam

ftplugin/ansible.vim

@@ -4,6 +4,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'ansible') == -1
 if exists('+regexpengine') && ('&regexpengine' == 0)
   setlocal regexpengine=1
 endif
-set path+=./../templates,./../files
+set isfname+=@-@
+set path+=./../templates,./../files,templates,files
 
 endif

ftplugin/cabal.vim

@@ -1,9 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haskell') == -1
-  
-if exists("g:loaded_haskellvim_cabal")
-  finish
-endif
-
-let g:loaded_haskellvim_cabal = 1
-
-endif

ftplugin/crystal.vim

@@ -50,18 +50,18 @@ command! -buffer -nargs=* CrystalHierarchy echo crystal_lang#type_hierarchy(expa
 command! -buffer -nargs=? CrystalSpecSwitch call crystal_lang#switch_spec_file(<f-args>)
 command! -buffer -nargs=? CrystalSpecRunAll call crystal_lang#run_all_spec(<f-args>)
 command! -buffer -nargs=? CrystalSpecRunCurrent call crystal_lang#run_current_spec(<f-args>)
-command! -buffer -nargs=* -bar CrystalFormat call crystal_lang#format(<q-args>)
+command! -buffer -nargs=* -bar CrystalFormat call crystal_lang#format(<q-args>, 0)
+command! -buffer -nargs=* CrystalExpand echo crystal_lang#expand(expand('%'), getpos('.'), <q-args>).output
 
-nnoremap <Plug>(crystal-jump-to-definition) :<C-u>CrystalDef<CR>
-nnoremap <Plug>(crystal-show-context) :<C-u>CrystalContext<CR>
-nnoremap <Plug>(crystal-spec-switch) :<C-u>CrystalSpecSwitch<CR>
-nnoremap <Plug>(crystal-spec-run-all) :<C-u>CrystalSpecRunAll<CR>
-nnoremap <Plug>(crystal-spec-run-current) :<C-u>CrystalSpecRunCurrent<CR>
-nnoremap <Plug>(crystal-format) :<C-u>CrystalFormat<CR>
+nnoremap <buffer><Plug>(crystal-jump-to-definition) :<C-u>CrystalDef<CR>
+nnoremap <buffer><Plug>(crystal-show-context) :<C-u>CrystalContext<CR>
+nnoremap <buffer><Plug>(crystal-spec-switch) :<C-u>CrystalSpecSwitch<CR>
+nnoremap <buffer><Plug>(crystal-spec-run-all) :<C-u>CrystalSpecRunAll<CR>
+nnoremap <buffer><Plug>(crystal-spec-run-current) :<C-u>CrystalSpecRunCurrent<CR>
+nnoremap <buffer><Plug>(crystal-format) :<C-u>CrystalFormat<CR>
 
 augroup plugin-ft-crystal
-    autocmd!
-    autocmd BufWritePre <buffer> if g:crystal_auto_format | CrystalFormat | endif
+    autocmd BufWritePre <buffer> if g:crystal_auto_format | call crystal_lang#format('', 1) | endif
 augroup END
 
 if get(g:, 'crystal_define_mappings', 1)

ftplugin/elixir.vim

@@ -1,12 +1,12 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
   
-if (exists("b:did_ftplugin"))
+if exists('b:did_ftplugin')
   finish
 endif
 let b:did_ftplugin = 1
 
 " Matchit support
-if exists("loaded_matchit") && !exists("b:match_words")
+if exists('loaded_matchit') && !exists('b:match_words')
   let b:match_ignorecase = 0
 
   let b:match_words = '\:\@<!\<\%(do\|fn\)\:\@!\>' .
@@ -32,9 +32,26 @@ let &l:path =
 setlocal includeexpr=elixir#util#get_filename(v:fname)
 setlocal suffixesadd=.ex,.exs,.eex,.erl,.yrl,.hrl
 
+let &l:define = 'def\(macro\|guard\|delegate\)\=p\='
+
 silent! setlocal formatoptions-=t formatoptions+=croqlj
 
-let b:undo_ftplugin = 'setlocal sw< sts< et< isk< com< cms< path< inex< sua< '.
-      \ '| unlet! b:match_ignorecase b:match_words'
+let b:block_begin = '\<\(do$\|fn\>\)'
+let b:block_end = '\<end\>'
+
+nnoremap <buffer> <silent> <expr> ]] ':silent keeppatterns /'.b:block_begin.'<CR>'
+nnoremap <buffer> <silent> <expr> [[ ':silent keeppatterns ?'.b:block_begin.'<CR>'
+nnoremap <buffer> <silent> <expr> ][ ':silent keeppatterns /'.b:block_end  .'<CR>'
+nnoremap <buffer> <silent> <expr> [] ':silent keeppatterns ?'.b:block_end  .'<CR>'
+
+onoremap <buffer> <silent> <expr> ]] ':silent keeppatterns /'.b:block_begin.'<CR>'
+onoremap <buffer> <silent> <expr> [[ ':silent keeppatterns ?'.b:block_begin.'<CR>'
+onoremap <buffer> <silent> <expr> ][ ':silent keeppatterns /'.b:block_end  .'<CR>'
+onoremap <buffer> <silent> <expr> [] ':silent keeppatterns ?'.b:block_end  .'<CR>'
+
+silent! setlocal formatoptions-=t formatoptions+=croqlj
+
+let b:undo_ftplugin = 'setlocal sw< sts< et< isk< com< cms< path< inex< sua< def<'.
+      \ '| unlet! b:match_ignorecase b:match_words b:block_begin b:block_end'
 
 endif

ftplugin/elm.vim

@@ -52,6 +52,18 @@ command -buffer ElmShowDocs call elm#ShowDocs()
 command -buffer ElmBrowseDocs call elm#BrowseDocs()
 command -buffer ElmFormat call elm#Format()
 
+" Commands cleanup
+let b:undo_ftplugin = "
+      \ delcommand ElmMake
+      \|delcommand ElmMakeMain
+      \|delcommand ElmTest
+      \|delcommand ElmRepl
+      \|delcommand ElmErrorDetail
+      \|delcommand ElmShowDocs
+      \|delcommand ElmBrowseDocs
+      \|delcommand ElmFormat
+      \"
+
 if get(g:, 'elm_setup_keybindings', 1)
   nmap <buffer> <LocalLeader>m <Plug>(elm-make)
   nmap <buffer> <LocalLeader>b <Plug>(elm-make-main)

ftplugin/eruby.vim

@@ -7,7 +7,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'ruby') == -1
 " Release Coordinator:	Doug Kearns <dougkearns@gmail.com>
 
 " Only do this when not done yet for this buffer
-if exists("b:did_ftplugin")
+if get(b:, 'did_ftplugin') =~# '\<eruby\>'
   finish
 endif
 
@@ -25,6 +25,8 @@ endif
 
 if &filetype =~ '^eruby\.'
   let b:eruby_subtype = matchstr(&filetype,'^eruby\.\zs\w\+')
+elseif &filetype =~ '^.*\.eruby\>'
+  let b:eruby_subtype = matchstr(&filetype,'^.\{-\}\ze\.eruby\>')
 elseif !exists("b:eruby_subtype")
   let s:lines = getline(1)."\n".getline(2)."\n".getline(3)."\n".getline(4)."\n".getline(5)."\n".getline("$")
   let b:eruby_subtype = matchstr(s:lines,'eruby_subtype=\zs\w\+')
@@ -47,11 +49,14 @@ elseif !exists("b:eruby_subtype")
   endif
 endif
 
-if exists("b:eruby_subtype") && b:eruby_subtype != '' && b:eruby_subtype !=? 'eruby'
-  exe "runtime! ftplugin/".b:eruby_subtype.".vim ftplugin/".b:eruby_subtype."_*.vim ftplugin/".b:eruby_subtype."/*.vim"
-else
-  runtime! ftplugin/html.vim ftplugin/html_*.vim ftplugin/html/*.vim
+if &filetype =~# '^eruby\>'
+  if exists("b:eruby_subtype") && b:eruby_subtype != '' && b:eruby_subtype !=? 'eruby'
+    exe "runtime! ftplugin/".b:eruby_subtype.".vim ftplugin/".b:eruby_subtype."_*.vim ftplugin/".b:eruby_subtype."/*.vim"
+  else
+    runtime! ftplugin/html.vim ftplugin/html_*.vim ftplugin/html/*.vim
+  endif
 endif
+let s:did_ftplugin = get(b:, 'did_ftplugin', 1)
 unlet! b:did_ftplugin
 
 " Override our defaults if these were set by an included ftplugin.
@@ -68,8 +73,23 @@ if exists("b:match_words")
   unlet b:match_words
 endif
 
+let s:cfilemap = v:version >= 704 ? maparg('<Plug><cfile>', 'c', 0, 1) : {}
+if !get(s:cfilemap, 'buffer') || !s:cfilemap.expr || s:cfilemap.rhs =~# 'ErubyAtCursor()'
+  let s:cfilemap = {}
+endif
+if !has_key(s:cfilemap, 'rhs')
+  let s:cfilemap.rhs = "substitute(&l:inex =~# '\\<v:fname\\>' && len(expand('<cfile>')) ? eval(substitute(&l:inex, '\\<v:fname\\>', '\\=string(expand(\"<cfile>\"))', 'g')) : '', '^$', \"\\022\\006\",'')"
+endif
+let s:ctagmap = v:version >= 704 ? maparg('<Plug><ctag>', 'c', 0, 1) : {}
+if !get(s:ctagmap, 'buffer') || !s:ctagmap.expr || s:ctagmap.rhs =~# 'ErubyAtCursor()'
+  let s:ctagmap = {}
+endif
+let s:include = &l:include
+let s:path = &l:path
+let s:suffixesadd = &l:suffixesadd
+
 runtime! ftplugin/ruby.vim ftplugin/ruby_*.vim ftplugin/ruby/*.vim
-let b:did_ftplugin = 1
+let b:did_ftplugin = s:did_ftplugin . '.eruby'
 
 " Combine the new set of values with those previously included.
 if exists("b:undo_ftplugin")
@@ -82,6 +102,15 @@ if exists("b:match_words")
   let s:match_words = b:match_words . ',' . s:match_words
 endif
 
+if len(s:include)
+  let &l:include = s:include
+endif
+let &l:path = s:path . (s:path =~# ',$\|^$' ? '' : ',') . &l:path
+let &l:suffixesadd = s:suffixesadd . (s:suffixesadd =~# ',$\|^$' ? '' : ',') . &l:suffixesadd
+exe 'cmap <buffer><script><expr> <Plug><cfile> ErubyAtCursor() ? ' . maparg('<Plug><cfile>', 'c') . ' : ' . s:cfilemap.rhs
+exe 'cmap <buffer><script><expr> <Plug><ctag> ErubyAtCursor() ? ' . maparg('<Plug><ctag>', 'c') . ' : ' . get(s:ctagmap, 'rhs', '"\022\027"')
+unlet s:cfilemap s:ctagmap s:include s:path s:suffixesadd
+
 " Change the browse dialog on Win32 to show mainly eRuby-related files
 if has("gui_win32")
   let b:browsefilter="eRuby Files (*.erb, *.rhtml)\t*.erb;*.rhtml\n" . s:browsefilter
@@ -101,6 +130,11 @@ let b:undo_ftplugin = "setl cms< "
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
+function! ErubyAtCursor() abort
+  let groups = map(['erubyBlock', 'erubyComment', 'erubyExpression', 'erubyOneLiner'], 'hlID(v:val)')
+  return !empty(filter(synstack(line('.'), col('.')), 'index(groups, v:val) >= 0'))
+endfunction
+
 " vim: nowrap sw=2 sts=2 ts=8:
 
 endif

ftplugin/fish.vim

@@ -31,7 +31,7 @@ endif
 " Use the 'man' wrapper function in fish to include fish's man pages.
 " Have to use a script for this; 'fish -c man' would make the the man page an
 " argument to fish instead of man.
-execute 'setlocal keywordprg=fish\ '.expand('<sfile>:p:h:h').'/bin/man.fish'
+execute 'setlocal keywordprg=fish\ '.fnameescape(expand('<sfile>:p:h:h').'/bin/man.fish')
 
 let b:match_words =
             \ escape('<%(begin|function|if|switch|while|for)>:<end>', '<>%|)')

ftplugin/git.vim

@@ -12,7 +12,7 @@ endif
 let b:did_ftplugin = 1
 
 if !exists('b:git_dir')
-  if expand('%:p') =~# '[\/]\.git[\/]modules[\/]'
+  if expand('%:p') =~# '[\/]\.git[\/]modules[\/]\|:[\/][\/]\|^\a\a\+:'
     " Stay out of the way
   elseif expand('%:p') =~# '[\/]\.git[\/]worktrees'
     let b:git_dir = matchstr(expand('%:p'),'.*\.git[\/]worktrees[\/][^\/]\+\>')

ftplugin/graphql.vim

@@ -0,0 +1,20 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+  
+" Vim filetype plugin
+" Language: GraphQL
+" Maintainer: Jon Parise <jon@indelible.org>
+
+if (exists('b:did_ftplugin'))
+  finish
+endif
+let b:did_ftplugin = 1
+
+setlocal comments=:#
+setlocal commentstring=#\ %s
+setlocal formatoptions-=t
+setlocal iskeyword+=$,@-@
+setlocal softtabstop=2
+setlocal shiftwidth=2
+setlocal expandtab
+
+endif

ftplugin/haskell.vim

@@ -1,20 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haskell') == -1
-  
-if exists("g:loaded_haskellvim_haskell")
-  finish
-endif
-
-let g:loaded_haskellvim_haskell = 1
-
-function! haskell#sortImports(line1, line2)
-  exe a:line1 . "," . a:line2 . "sort /import\\s\\+\\(qualified\\s\\+\\)\\?/"
-endfunction
-
-function! haskell#formatImport(line1, line2)
-  exec a:line1 . ",". a:line2 . "s/import\\s\\+\\([A-Z].*\\)/import           \\1"
-endfunction
-
-command! -buffer -range HaskellSortImports call haskell#sortImports(<line1>, <line2>)
-command! -buffer -range HaskellFormatImport call haskell#formatImport(<line1>, <line2>)
-
-endif

ftplugin/julia.vim

@@ -0,0 +1,108 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+  
+" Vim filetype plugin file
+" Language:	Julia
+" Maintainer:	Carlo Baldassi <carlobaldassi@gmail.com>
+" Last Change:	2014 may 29
+
+if exists("b:did_ftplugin")
+  finish
+endif
+let b:did_ftplugin = 1
+
+let s:save_cpo = &cpo
+set cpo-=C
+
+setlocal include=^\\s*\\%(reload\\\|include\\)\\>
+setlocal suffixesadd=.jl
+setlocal comments=:#
+setlocal commentstring=#=%s=#
+setlocal cinoptions+=#1
+setlocal define=^\\s*macro\\>
+setlocal fo-=t fo+=croql
+
+let b:julia_vim_loaded = 1
+
+let b:undo_ftplugin = "setlocal include< suffixesadd< comments< commentstring<"
+      \ . " define< fo< shiftwidth< expandtab< indentexpr< indentkeys< cinoptions< omnifunc<"
+      \ . " | unlet! b:julia_vim_loaded"
+
+" MatchIt plugin support
+if exists("loaded_matchit")
+  let b:match_ignorecase = 0
+
+  " note: begin_keywords must contain all blocks in order
+  " for nested-structures-skipping to work properly
+  let b:julia_begin_keywords = '\%(\%(\.\s*\)\@<!\|\%(@\s*.\s*\)\@<=\)\<\%(\%(staged\)\?function\|macro\|begin\|mutable\s\+struct\|\%(mutable\s\+\)\@<!struct\|\%(abstract\|primitive\)\s\+type\|\%(\(abstract\|primitive\)\s\+\)\@<!type\|immutable\|let\|do\|\%(bare\)\?module\|quote\|if\|for\|while\|try\)\>'
+  let s:macro_regex = '@\%(#\@!\S\)\+\s\+'
+  let s:nomacro = '\%(' . s:macro_regex . '\)\@<!'
+  let s:yesmacro = s:nomacro . '\%('. s:macro_regex . '\)\+'
+  let b:julia_begin_keywordsm = '\%(' . s:yesmacro . b:julia_begin_keywords . '\)\|'
+        \ . '\%(' . s:nomacro . b:julia_begin_keywords . '\)'
+  let b:julia_end_keywords = '\<end\>'
+
+  " note: this function relies heavily on the syntax file
+  function! JuliaGetMatchWords()
+    let [l,c] = [line('.'),col('.')]
+    let attr = synIDattr(synID(l, c, 1),"name")
+    let c1 = c
+    while attr == 'juliaMacro'
+      normal! W
+      if line('.') > l || col('.') == c1
+        call cursor(l, c)
+        return ''
+      endif
+      let attr = synIDattr(synID(l, col('.'), 1),"name")
+      let c1 = col('.')
+    endwhile
+    call cursor(l, c)
+    if attr == 'juliaConditional'
+      return b:julia_begin_keywordsm . ':\<\%(elseif\|else\)\>:' . b:julia_end_keywords
+    elseif attr =~ '\<\%(juliaRepeat\|juliaRepKeyword\)\>'
+      return b:julia_begin_keywordsm . ':\<\%(break\|continue\)\>:' . b:julia_end_keywords
+    elseif attr == 'juliaBlKeyword'
+      return b:julia_begin_keywordsm . ':' . b:julia_end_keywords
+    elseif attr == 'juliaException'
+      return b:julia_begin_keywordsm . ':\<\%(catch\|finally\)\>:' . b:julia_end_keywords
+    endif
+    return '\<\>:\<\>'
+  endfunction
+
+  let b:match_words = 'JuliaGetMatchWords()'
+
+  " we need to skip everything within comments, strings and
+  " the 'end' keyword when it is used as a range rather than as
+  " the end of a block
+  let b:match_skip = 'synIDattr(synID(line("."),col("."),1),"name") =~ '
+        \ . '"\\<julia\\%(Comprehension\\%(For\\|If\\)\\|RangeEnd\\|SymbolS\\?\\|Comment[LM]\\|\\%([bv]\\|ip\\|MIME\\|Shell\\|Doc\\)\\?String\\|RegEx\\)\\>"'
+
+  let b:undo_ftplugin = b:undo_ftplugin
+        \ . " | unlet! b:match_words b:match_skip b:match_ignorecase"
+        \ . " | unlet! b:julia_begin_keywords b:julia_end_keywords"
+        \ . " | delfunction JuliaGetMatchWords"
+        \ . " | call julia_blocks#remove_mappings()"
+
+  if get(g:, "julia_blocks", 1)
+    call julia_blocks#init_mappings()
+    let b:undo_ftplugin .= " | call julia_blocks#remove_mappings()"
+  endif
+
+endif
+
+if has("gui_win32")
+  let b:browsefilter = "Julia Source Files (*.jl)\t*.jl\n"
+  let b:undo_ftplugin = b:undo_ftplugin . " | unlet! b:browsefilter"
+endif
+
+" Lookup documents
+nnoremap <silent><buffer> <Plug>(JuliaDocPrompt) :<C-u>call julia#doc#prompt()<CR>
+command! -nargs=1 -buffer -complete=customlist,julia#doc#complete JuliaDoc call julia#doc#open(<q-args>)
+command! -nargs=1 -buffer JuliaDocKeywordprg call julia#doc#keywordprg(<q-args>)
+setlocal keywordprg=:JuliaDocKeywordprg
+let b:undo_ftplugin .= " | setlocal keywordprg<"
+let b:undo_ftplugin .= " | delcommand JuliaDoc | delcommand JuliaDocKeywordprg"
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+endif

ftplugin/juliadoc.vim

@@ -0,0 +1,34 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+  
+" Vim filetype plugin file
+" Language: Julia document
+
+if exists("b:did_ftplugin")
+  finish
+endif
+let b:did_ftplugin = 1
+
+let s:save_cpo = &cpo
+set cpo-=C
+
+setlocal conceallevel=2
+setlocal concealcursor=nc
+setlocal wrap
+
+if !exists('b:undo_ftplugin')
+  let b:undo_ftplugin = ''
+endif
+let b:undo_ftplugin .= 'setlocal conceallevel< concealcursor< wrap<'
+
+" Lookup documents
+nnoremap <silent><buffer> <Plug>(JuliaDocPrompt) :<C-u>call julia#doc#prompt()<CR>
+command! -nargs=1 -buffer -complete=customlist,julia#doc#complete JuliaDoc call julia#doc#open(<q-args>)
+command! -nargs=1 -buffer JuliaDocKeywordprg call julia#doc#keywordprg(<q-args>)
+setlocal keywordprg=:JuliaDocKeywordprg
+let b:undo_ftplugin .= " | setlocal keywordprg<"
+let b:undo_ftplugin .= " | delcommand JuliaDoc | delcommand JuliaDocKeywordprg"
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+endif

ftplugin/mail_vifm.vim

@@ -2,11 +2,13 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vifm') == -1
   
 " Mail file type extension to pick files for attachments via vifm
 " Maintainer:  xaizek <xaizek@posteo.net>
-" Last Change: January 23, 2016
+" Last Change: January 02, 2018
 
 " Insert attachment picked via vifm after 'Subject' header
-function! s:AddMailAttacments()
-	" TODO: reduce duplication between this file and plugins/vifm.vim
+function! s:AddMailAttachments()
+	call vifm#globals#Init()
+
+	" XXX: similar code is in plugins/vifm.vim, but it's different in details
 	let l:listf = tempname()
 
 	if !has('nvim')
@@ -26,7 +28,7 @@ function! s:AddMailAttacments()
 	else
 		" Work around handicapped neovim...
 		let callback = { 'listf': l:listf }
-		function! callback.on_exit(id, code)
+		function! callback.on_exit(id, code, event)
 			buffer #
 			silent! bdelete! #
 			call s:HandleRunResults(a:code, self.listf)
@@ -59,7 +61,7 @@ function! s:HandleRunResults(exitcode, listf)
 	call delete(a:listf)
 endfunction
 
-nnoremap <buffer> <silent> <localleader>a :call <sid>AddMailAttacments()<cr>
+nnoremap <buffer> <silent> <localleader>a :call <sid>AddMailAttachments()<cr>
 
 " vim: set tabstop=2 softtabstop=2 shiftwidth=2 noexpandtab cinoptions-=(0 :
 

ftplugin/nix.vim

@@ -11,7 +11,12 @@ endif
 let b:did_ftplugin = 1
 
 
-setlocal comments=:#
-setlocal commentstring=#\ %s
+setlocal
+    \ comments=:#
+    \ commentstring=#\ %s
+    \ shiftwidth=2
+    \ softtabstop=2
+    \ expandtab
+    \ iskeyword+=-
 
 endif

ftplugin/purescript.vim

@@ -1,6 +1,6 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'purescript') == -1
   
-setlocal comments=s1fl:{-,mb:\ \ ,ex:-},:--
+setlocal comments=s1fl:{-,mb:\ \ ,ex:-},:--\ \|,:--
 setlocal include=^import
 setlocal includeexpr=printf('%s.purs',substitute(v:fname,'\\.','/','g'))
 

ftplugin/ruby.vim

@@ -46,19 +46,12 @@ endif
 setlocal formatoptions-=t formatoptions+=croql
 
 setlocal include=^\\s*\\<\\(load\\>\\\|require\\>\\\|autoload\\s*:\\=[\"']\\=\\h\\w*[\"']\\=,\\)
-setlocal includeexpr=substitute(substitute(v:fname,'::','/','g'),'\%(\.rb\)\=$','.rb','')
 setlocal suffixesadd=.rb
 
 if exists("&ofu") && has("ruby")
   setlocal omnifunc=rubycomplete#Complete
 endif
 
-" To activate, :set ballooneval
-if has('balloon_eval') && exists('+balloonexpr')
-  setlocal balloonexpr=RubyBalloonexpr()
-endif
-
-
 " TODO:
 "setlocal define=^\\s*def
 
@@ -143,22 +136,32 @@ if (has("gui_win32") || has("gui_gtk")) && !exists("b:browsefilter")
                      \ "All Files (*.*)\t*.*\n"
 endif
 
-let b:undo_ftplugin = "setl fo< inc< inex< sua< def< com< cms< path< tags< kp<"
+let b:undo_ftplugin = "setl inc= sua= path= tags= fo< com< cms< kp="
       \."| unlet! b:browsefilter b:match_ignorecase b:match_words b:match_skip"
       \."| if exists('&ofu') && has('ruby') | setl ofu< | endif"
-      \."| if has('balloon_eval') && exists('+bexpr') | setl bexpr< | endif"
+
+if get(g:, 'ruby_recommended_style', 1)
+  setlocal shiftwidth=2 softtabstop=2 expandtab
+  let b:undo_ftplugin .= ' | setl sw< sts< et<'
+endif
+
+" To activate, :set ballooneval
+if exists('+balloonexpr') && get(g:, 'ruby_balloonexpr')
+  setlocal balloonexpr=RubyBalloonexpr()
+  let b:undo_ftplugin .= "| setl bexpr="
+endif
 
 function! s:map(mode, flags, map) abort
   let from = matchstr(a:map, '\S\+')
   if empty(mapcheck(from, a:mode))
-    exe a:mode.'map' '<buffer>'.(a:0 ? a:1 : '') a:map
+    exe a:mode.'map' '<buffer>' a:map
     let b:undo_ftplugin .= '|sil! '.a:mode.'unmap <buffer> '.from
   endif
 endfunction
 
-cmap <buffer><script><expr> <Plug><cword> substitute(RubyCursorIdentifier(),'^$',"\022\027",'')
+cmap <buffer><script><expr> <Plug><ctag> substitute(RubyCursorTag(),'^$',"\022\027",'')
 cmap <buffer><script><expr> <Plug><cfile> substitute(RubyCursorFile(),'^$',"\022\006",'')
-let b:undo_ftplugin .= "| sil! cunmap <buffer> <Plug><cword>| sil! cunmap <buffer> <Plug><cfile>"
+let b:undo_ftplugin .= "| sil! cunmap <buffer> <Plug><ctag>| sil! cunmap <buffer> <Plug><cfile>"
 
 if !exists("g:no_plugin_maps") && !exists("g:no_ruby_maps")
   nmap <buffer><script> <SID>:  :<C-U>
@@ -206,19 +209,18 @@ if !exists("g:no_plugin_maps") && !exists("g:no_ruby_maps")
           \."| sil! exe 'xunmap <buffer> iM' | sil! exe 'xunmap <buffer> aM'"
   endif
 
-  call s:map('c', '', '<C-R><C-W> <Plug><cword>')
   call s:map('c', '', '<C-R><C-F> <Plug><cfile>')
 
   cmap <buffer><script><expr> <SID>tagzv &foldopen =~# 'tag' ? '<Bar>norm! zv' : ''
-  call s:map('n', '<silent>', '<C-]>       <SID>:exe  v:count1."tag <Plug><cword>"<SID>tagzv<CR>')
-  call s:map('n', '<silent>', 'g<C-]>      <SID>:exe         "tjump <Plug><cword>"<SID>tagzv<CR>')
-  call s:map('n', '<silent>', 'g]          <SID>:exe       "tselect <Plug><cword>"<SID>tagzv<CR>')
-  call s:map('n', '<silent>', '<C-W>]      <SID>:exe v:count1."stag <Plug><cword>"<SID>tagzv<CR>')
-  call s:map('n', '<silent>', '<C-W><C-]>  <SID>:exe v:count1."stag <Plug><cword>"<SID>tagzv<CR>')
-  call s:map('n', '<silent>', '<C-W>g<C-]> <SID>:exe        "stjump <Plug><cword>"<SID>tagzv<CR>')
-  call s:map('n', '<silent>', '<C-W>g]     <SID>:exe      "stselect <Plug><cword>"<SID>tagzv<CR>')
-  call s:map('n', '<silent>', '<C-W>}      <SID>:exe v:count1."ptag <Plug><cword>"<CR>')
-  call s:map('n', '<silent>', '<C-W>g}     <SID>:exe        "ptjump <Plug><cword>"<CR>')
+  call s:map('n', '<silent>', '<C-]>       <SID>:exe  v:count1."tag <Plug><ctag>"<SID>tagzv<CR>')
+  call s:map('n', '<silent>', 'g<C-]>      <SID>:exe         "tjump <Plug><ctag>"<SID>tagzv<CR>')
+  call s:map('n', '<silent>', 'g]          <SID>:exe       "tselect <Plug><ctag>"<SID>tagzv<CR>')
+  call s:map('n', '<silent>', '<C-W>]      <SID>:exe v:count1."stag <Plug><ctag>"<SID>tagzv<CR>')
+  call s:map('n', '<silent>', '<C-W><C-]>  <SID>:exe v:count1."stag <Plug><ctag>"<SID>tagzv<CR>')
+  call s:map('n', '<silent>', '<C-W>g<C-]> <SID>:exe        "stjump <Plug><ctag>"<SID>tagzv<CR>')
+  call s:map('n', '<silent>', '<C-W>g]     <SID>:exe      "stselect <Plug><ctag>"<SID>tagzv<CR>')
+  call s:map('n', '<silent>', '<C-W>}      <SID>:exe v:count1."ptag <Plug><ctag>"<CR>')
+  call s:map('n', '<silent>', '<C-W>g}     <SID>:exe        "ptjump <Plug><ctag>"<CR>')
 
   call s:map('n', '<silent>', 'gf           <SID>c:find <Plug><cfile><CR>')
   call s:map('n', '<silent>', '<C-W>f      <SID>c:sfind <Plug><cfile><CR>')
@@ -352,6 +354,10 @@ function! RubyCursorIdentifier() abort
   return stripped == '' ? expand("<cword>") : stripped
 endfunction
 
+function! RubyCursorTag() abort
+  return substitute(RubyCursorIdentifier(), '^[$@]*', '', '')
+endfunction
+
 function! RubyCursorFile() abort
   let isfname = &isfname
   try

ftplugin/rust.vim

@@ -8,199 +8,196 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 " For bugs, patches and license go to https://github.com/rust-lang/rust.vim 
 
 if exists("b:did_ftplugin")
-	finish
+    finish
 endif
 let b:did_ftplugin = 1
 
+" vint: -ProhibitAbbreviationOption
 let s:save_cpo = &cpo
 set cpo&vim
+" vint: +ProhibitAbbreviationOption
 
 augroup rust.vim
-autocmd!
+    autocmd!
 
-" Variables {{{1
+    if get(b:, 'current_compiler', '') ==# ''
+        if strlen(findfile('Cargo.toml', '.;')) > 0
+            compiler cargo
+        else
+            compiler rustc
+        endif
+    endif
 
-" The rust source code at present seems to typically omit a leader on /*!
-" comments, so we'll use that as our default, but make it easy to switch.
-" This does not affect indentation at all (I tested it with and without
-" leader), merely whether a leader is inserted by default or not.
-if exists("g:rust_bang_comment_leader") && g:rust_bang_comment_leader != 0
-	" Why is the `,s0:/*,mb:\ ,ex:*/` there, you ask? I don't understand why,
-	" but without it, */ gets indented one space even if there were no
-	" leaders. I'm fairly sure that's a Vim bug.
-	setlocal comments=s1:/*,mb:*,ex:*/,s0:/*,mb:\ ,ex:*/,:///,://!,://
-else
-	setlocal comments=s0:/*!,m:\ ,ex:*/,s1:/*,mb:*,ex:*/,:///,://!,://
-endif
-setlocal commentstring=//%s
-setlocal formatoptions-=t formatoptions+=croqnl
-" j was only added in 7.3.541, so stop complaints about its nonexistence
-silent! setlocal formatoptions+=j
+    " Variables {{{1
 
-" smartindent will be overridden by indentexpr if filetype indent is on, but
-" otherwise it's better than nothing.
-setlocal smartindent nocindent
+    " The rust source code at present seems to typically omit a leader on /*!
+    " comments, so we'll use that as our default, but make it easy to switch.
+    " This does not affect indentation at all (I tested it with and without
+    " leader), merely whether a leader is inserted by default or not.
+    if get(g:, 'rust_bang_comment_leader', 0)
+        " Why is the `,s0:/*,mb:\ ,ex:*/` there, you ask? I don't understand why,
+        " but without it, */ gets indented one space even if there were no
+        " leaders. I'm fairly sure that's a Vim bug.
+        setlocal comments=s1:/*,mb:*,ex:*/,s0:/*,mb:\ ,ex:*/,:///,://!,://
+    else
+        setlocal comments=s0:/*!,m:\ ,ex:*/,s1:/*,mb:*,ex:*/,:///,://!,://
+    endif
+    setlocal commentstring=//%s
+    setlocal formatoptions-=t formatoptions+=croqnl
+    " j was only added in 7.3.541, so stop complaints about its nonexistence
+    silent! setlocal formatoptions+=j
 
-if !exists("g:rust_recommended_style") || g:rust_recommended_style != 0
-	setlocal tabstop=4 shiftwidth=4 softtabstop=4 expandtab
-	setlocal textwidth=99
-endif
+    " smartindent will be overridden by indentexpr if filetype indent is on, but
+    " otherwise it's better than nothing.
+    setlocal smartindent nocindent
 
-" This includeexpr isn't perfect, but it's a good start
-setlocal includeexpr=substitute(v:fname,'::','/','g')
+    if get(g:, 'rust_recommended_style', 1)
+        let b:rust_set_style = 1
+        setlocal tabstop=8 shiftwidth=4 softtabstop=4 expandtab
+        setlocal textwidth=99
+    endif
 
-setlocal suffixesadd=.rs
+    " This includeexpr isn't perfect, but it's a good start
+    setlocal includeexpr=substitute(v:fname,'::','/','g')
 
-if exists("g:ftplugin_rust_source_path")
-    let &l:path=g:ftplugin_rust_source_path . ',' . &l:path
-endif
+    setlocal suffixesadd=.rs
 
-if exists("g:loaded_delimitMate")
-	if exists("b:delimitMate_excluded_regions")
-		let b:rust_original_delimitMate_excluded_regions = b:delimitMate_excluded_regions
-	endif
+    if exists("g:ftplugin_rust_source_path")
+        let &l:path=g:ftplugin_rust_source_path . ',' . &l:path
+    endif
 
-	let s:delimitMate_extra_excluded_regions = ',rustLifetimeCandidate,rustGenericLifetimeCandidate'
+    if exists("g:loaded_delimitMate")
+        if exists("b:delimitMate_excluded_regions")
+            let b:rust_original_delimitMate_excluded_regions = b:delimitMate_excluded_regions
+        endif
 
-	" For this buffer, when delimitMate issues the `User delimitMate_map`
-	" event in the autocommand system, add the above-defined extra excluded
-	" regions to delimitMate's state, if they have not already been added.
-	autocmd User <buffer>
-		\ if expand('<afile>') ==# 'delimitMate_map' && match(
-		\     delimitMate#Get("excluded_regions"),
-		\     s:delimitMate_extra_excluded_regions) == -1
-		\|  let b:delimitMate_excluded_regions =
-		\       delimitMate#Get("excluded_regions")
-		\       . s:delimitMate_extra_excluded_regions
-		\|endif
+        autocmd User delimitMate_map   :call rust#delimitmate#onMap()
+        autocmd User delimitMate_unmap :call rust#delimitmate#onUnmap()
+    endif
 
-	" For this buffer, when delimitMate issues the `User delimitMate_unmap`
-	" event in the autocommand system, delete the above-defined extra excluded
-	" regions from delimitMate's state (the deletion being idempotent and
-	" having no effect if the extra excluded regions are not present in the
-	" targeted part of delimitMate's state).
-	autocmd User <buffer>
-		\ if expand('<afile>') ==# 'delimitMate_unmap'
-		\|  let b:delimitMate_excluded_regions = substitute(
-		\       delimitMate#Get("excluded_regions"),
-		\       '\C\V' . s:delimitMate_extra_excluded_regions,
-		\       '', 'g')
-		\|endif
-endif
+    " Integration with auto-pairs (https://github.com/jiangmiao/auto-pairs)
+    if exists("g:AutoPairsLoaded") && !get(g:, 'rust_keep_autopairs_default', 0)
+        let b:AutoPairs = {'(':')', '[':']', '{':'}','"':'"', '`':'`'}
+    endif
 
-if has("folding") && exists('g:rust_fold') && g:rust_fold != 0
-	let b:rust_set_foldmethod=1
-	setlocal foldmethod=syntax
-	if g:rust_fold == 2
-		setlocal foldlevel<
-	else
-		setlocal foldlevel=99
-	endif
-endif
+    if has("folding") && get(g:, 'rust_fold', 0)
+        let b:rust_set_foldmethod=1
+        setlocal foldmethod=syntax
+        if g:rust_fold == 2
+            setlocal foldlevel<
+        else
+            setlocal foldlevel=99
+        endif
+    endif
 
-if has('conceal') && exists('g:rust_conceal') && g:rust_conceal != 0
-	let b:rust_set_conceallevel=1
-	setlocal conceallevel=2
-endif
+    if has('conceal') && get(g:, 'rust_conceal', 0)
+        let b:rust_set_conceallevel=1
+        setlocal conceallevel=2
+    endif
 
-" Motion Commands {{{1
+    " Motion Commands {{{1
 
-" Bind motion commands to support hanging indents
-nnoremap <silent> <buffer> [[ :call rust#Jump('n', 'Back')<CR>
-nnoremap <silent> <buffer> ]] :call rust#Jump('n', 'Forward')<CR>
-xnoremap <silent> <buffer> [[ :call rust#Jump('v', 'Back')<CR>
-xnoremap <silent> <buffer> ]] :call rust#Jump('v', 'Forward')<CR>
-onoremap <silent> <buffer> [[ :call rust#Jump('o', 'Back')<CR>
-onoremap <silent> <buffer> ]] :call rust#Jump('o', 'Forward')<CR>
+    " Bind motion commands to support hanging indents
+    nnoremap <silent> <buffer> [[ :call rust#Jump('n', 'Back')<CR>
+    nnoremap <silent> <buffer> ]] :call rust#Jump('n', 'Forward')<CR>
+    xnoremap <silent> <buffer> [[ :call rust#Jump('v', 'Back')<CR>
+    xnoremap <silent> <buffer> ]] :call rust#Jump('v', 'Forward')<CR>
+    onoremap <silent> <buffer> [[ :call rust#Jump('o', 'Back')<CR>
+    onoremap <silent> <buffer> ]] :call rust#Jump('o', 'Forward')<CR>
 
-" Commands {{{1
+    " Commands {{{1
 
-" See |:RustRun| for docs
-command! -nargs=* -complete=file -bang -buffer RustRun call rust#Run(<bang>0, <q-args>)
+    " See |:RustRun| for docs
+    command! -nargs=* -complete=file -bang -buffer RustRun call rust#Run(<bang>0, <q-args>)
 
-" See |:RustExpand| for docs
-command! -nargs=* -complete=customlist,rust#CompleteExpand -bang -buffer RustExpand call rust#Expand(<bang>0, <q-args>)
+    " See |:RustExpand| for docs
+    command! -nargs=* -complete=customlist,rust#CompleteExpand -bang -buffer RustExpand call rust#Expand(<bang>0, <q-args>)
 
-" See |:RustEmitIr| for docs
-command! -nargs=* -buffer RustEmitIr call rust#Emit("llvm-ir", <q-args>)
+    " See |:RustEmitIr| for docs
+    command! -nargs=* -buffer RustEmitIr call rust#Emit("llvm-ir", <q-args>)
 
-" See |:RustEmitAsm| for docs
-command! -nargs=* -buffer RustEmitAsm call rust#Emit("asm", <q-args>)
+    " See |:RustEmitAsm| for docs
+    command! -nargs=* -buffer RustEmitAsm call rust#Emit("asm", <q-args>)
 
-" See |:RustPlay| for docs
-command! -range=% RustPlay :call rust#Play(<count>, <line1>, <line2>, <f-args>)
+    " See |:RustPlay| for docs
+    command! -range=% RustPlay :call rust#Play(<count>, <line1>, <line2>, <f-args>)
 
-" See |:RustFmt| for docs
-command! -buffer RustFmt call rustfmt#Format()
+    " See |:RustFmt| for docs
+    command! -buffer RustFmt call rustfmt#Format()
 
-" See |:RustFmtRange| for docs
-command! -range -buffer RustFmtRange call rustfmt#FormatRange(<line1>, <line2>)
+    " See |:RustFmtRange| for docs
+    command! -range -buffer RustFmtRange call rustfmt#FormatRange(<line1>, <line2>)
 
-" Mappings {{{1
+    " See |:RustInfo| for docs
+    command! -bar RustInfo call rust#debugging#Info()
 
-" Bind ⌘R in MacVim to :RustRun
-nnoremap <silent> <buffer> <D-r> :RustRun<CR>
-" Bind ⌘⇧R in MacVim to :RustRun! pre-filled with the last args
-nnoremap <buffer> <D-R> :RustRun! <C-r>=join(b:rust_last_rustc_args)<CR><C-\>erust#AppendCmdLine(' -- ' . join(b:rust_last_args))<CR>
+    " See |:RustInfoToClipboard| for docs
+    command! -bar RustInfoToClipboard call rust#debugging#InfoToClipboard()
 
-if !exists("b:rust_last_rustc_args") || !exists("b:rust_last_args")
-	let b:rust_last_rustc_args = []
-	let b:rust_last_args = []
-endif
+    " See |:RustInfoToFile| for docs
+    command! -bar -nargs=1 RustInfoToFile call rust#debugging#InfoToFile(<f-args>)
 
-" Cleanup {{{1
+    " See |:RustTest| for docs
+    command! -buffer -nargs=* -bang RustTest call rust#Test(<bang>0, <q-args>)
 
-let b:undo_ftplugin = "
-		\ setlocal formatoptions< comments< commentstring< includeexpr< suffixesadd<
-		\|setlocal tabstop< shiftwidth< softtabstop< expandtab< textwidth<
-		\|if exists('b:rust_original_delimitMate_excluded_regions')
-		  \|let b:delimitMate_excluded_regions = b:rust_original_delimitMate_excluded_regions
-		  \|unlet b:rust_original_delimitMate_excluded_regions
-		\|else
-		  \|unlet! b:delimitMate_excluded_regions
-		\|endif
-		\|if exists('b:rust_set_foldmethod')
-		  \|setlocal foldmethod< foldlevel<
-		  \|unlet b:rust_set_foldmethod
-		\|endif
-		\|if exists('b:rust_set_conceallevel')
-		  \|setlocal conceallevel<
-		  \|unlet b:rust_set_conceallevel
-		\|endif
-		\|unlet! b:rust_last_rustc_args b:rust_last_args
-		\|delcommand RustRun
-		\|delcommand RustExpand
-		\|delcommand RustEmitIr
-		\|delcommand RustEmitAsm
-		\|delcommand RustPlay
-		\|nunmap <buffer> <D-r>
-		\|nunmap <buffer> <D-R>
-		\|nunmap <buffer> [[
-		\|nunmap <buffer> ]]
-		\|xunmap <buffer> [[
-		\|xunmap <buffer> ]]
-		\|ounmap <buffer> [[
-		\|ounmap <buffer> ]]
-		\|set matchpairs-=<:>
-		\|unlet b:match_skip
-		\"
+    if !exists("b:rust_last_rustc_args") || !exists("b:rust_last_args")
+        let b:rust_last_rustc_args = []
+        let b:rust_last_args = []
+    endif
 
-" }}}1
+    " Cleanup {{{1
 
-" Code formatting on save
-if get(g:, "rustfmt_autosave", 0)
-	autocmd BufWritePre *.rs silent! call rustfmt#Format()
-endif
+    let b:undo_ftplugin = "
+                \ setlocal formatoptions< comments< commentstring< includeexpr< suffixesadd<
+                \|if exists('b:rust_set_style')
+                    \|setlocal tabstop< shiftwidth< softtabstop< expandtab< textwidth<
+                    \|endif
+                    \|if exists('b:rust_original_delimitMate_excluded_regions')
+                        \|let b:delimitMate_excluded_regions = b:rust_original_delimitMate_excluded_regions
+                        \|unlet b:rust_original_delimitMate_excluded_regions
+                        \|else
+                            \|unlet! b:delimitMate_excluded_regions
+                            \|endif
+                            \|if exists('b:rust_set_foldmethod')
+                                \|setlocal foldmethod< foldlevel<
+                                \|unlet b:rust_set_foldmethod
+                                \|endif
+                                \|if exists('b:rust_set_conceallevel')
+                                    \|setlocal conceallevel<
+                                    \|unlet b:rust_set_conceallevel
+                                    \|endif
+                                    \|unlet! b:rust_last_rustc_args b:rust_last_args
+                                    \|delcommand RustRun
+                                    \|delcommand RustExpand
+                                    \|delcommand RustEmitIr
+                                    \|delcommand RustEmitAsm
+                                    \|delcommand RustPlay
+                                    \|nunmap <buffer> [[
+                                    \|nunmap <buffer> ]]
+                                    \|xunmap <buffer> [[
+                                    \|xunmap <buffer> ]]
+                                    \|ounmap <buffer> [[
+                                    \|ounmap <buffer> ]]
+                                    \|setlocal matchpairs-=<:>
+                                    \|unlet b:match_skip
+                                    \"
+
+    " }}}1
+
+    " Code formatting on save
+    autocmd BufWritePre <buffer> silent! call rustfmt#PreWrite()
 
 augroup END
 
-set matchpairs+=<:>
+setlocal matchpairs+=<:>
 " For matchit.vim (rustArrow stops `Fn() -> X` messing things up)
 let b:match_skip = 's:comment\|string\|rustArrow'
 
+" vint: -ProhibitAbbreviationOption
 let &cpo = s:save_cpo
 unlet s:save_cpo
+" vint: +ProhibitAbbreviationOption
 
-" vim: set noet sw=8 ts=8:
+" vim: set et sw=4 sts=4 ts=8:
 
 endif

ftplugin/rust/tagbar.vim

@@ -0,0 +1,44 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+  
+"
+" Support for Tagbar -- https://github.com/majutsushi/tagbar
+"
+if !exists(':Tagbar')
+    finish
+endif
+
+" vint: -ProhibitAbbreviationOption
+let s:save_cpo = &cpo
+set cpo&vim
+" vint: +ProhibitAbbreviationOption
+
+if !exists('g:tagbar_type_rust')
+    let g:tagbar_type_rust = {
+                \ 'ctagstype' : 'rust',
+                \ 'kinds' : [
+                \'T:types',
+                \'f:functions',
+                \'g:enumerations',
+                \'s:structures',
+                \'m:modules',
+                \'c:constants',
+                \'t:traits',
+                \'i:trait implementations',
+                \ ]
+                \ }
+endif
+
+" In case you've updated/customized your ~/.ctags and prefer to use it.
+if !get(g:, 'rust_use_custom_ctags_defs', 0)
+    let g:tagbar_type_rust.deffile = expand('<sfile>:p:h:h:h') . '/ctags/rust.ctags'
+endif
+
+" vint: -ProhibitAbbreviationOption
+let &cpo = s:save_cpo
+unlet s:save_cpo
+" vint: +ProhibitAbbreviationOption
+
+
+" vim: set et sw=4 sts=4 ts=8:
+
+endif

ftplugin/slim.vim

@@ -3,9 +3,25 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'slim') == -1
 if exists("b:did_ftplugin")
   finish
 endif
+
+" Define some defaults in case the included ftplugins don't set them.
+let s:undo_ftplugin = ""
+
+" Override our defaults if these were set by an included ftplugin.
+if exists("b:undo_ftplugin")
+  let s:undo_ftplugin = b:undo_ftplugin
+  unlet b:undo_ftplugin
+endif
+
+runtime! ftplugin/ruby.vim ftplugin/ruby_*.vim ftplugin/ruby/*.vim
 let b:did_ftplugin = 1
 
-let b:undo_ftplugin = "setl isk<"
+" Combine the new set of values with those previously included.
+if exists("b:undo_ftplugin")
+  let s:undo_ftplugin = b:undo_ftplugin . " | " . s:undo_ftplugin
+endif
+
+let b:undo_ftplugin = "setl isk<" . " | " . s:undo_ftplugin
 
 setlocal iskeyword+=-
 setlocal commentstring=/%s

ftplugin/terraform.vim

@@ -0,0 +1,73 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'terraform') == -1
+  
+" terraform.vim - basic vim/terraform integration
+" Maintainer: HashiVim <https://github.com/hashivim>
+
+if exists("g:loaded_terraform") || v:version < 700 || &cp || !executable('terraform')
+  finish
+endif
+let g:loaded_terraform = 1
+
+if !exists("g:terraform_fmt_on_save")
+  let g:terraform_fmt_on_save = 0
+endif
+
+function! s:commands(A, L, P)
+  return join([
+  \ "apply",
+  \ "console",
+  \ "destroy",
+  \ "env",
+  \ "fmt",
+  \ "get",
+  \ "graph",
+  \ "import",
+  \ "init",
+  \ "output",
+  \ "plan",
+  \ "providers",
+  \ "push",
+  \ "refresh",
+  \ "show",
+  \ "taint",
+  \ "untaint",
+  \ "validate",
+  \ "version",
+  \ "workspace",
+  \ "debug",
+  \ "force-unlock",
+  \ "state"
+  \ ], "\n")
+endfunction
+
+" Adapted from vim-hclfmt:
+" https://github.com/fatih/vim-hclfmt/blob/master/autoload/fmt.vim
+function! terraform#fmt()
+  let l:curw = winsaveview()
+  let l:tmpfile = tempname()
+  call writefile(getline(1, "$"), l:tmpfile)
+  let output = system("terraform fmt -write " . l:tmpfile)
+  if v:shell_error == 0
+    try | silent undojoin | catch | endtry
+    call rename(l:tmpfile, resolve(expand("%")))
+    silent edit!
+    let &syntax = &syntax
+  else
+    echo output
+    call delete(l:tmpfile)
+  endif
+  call winrestview(l:curw)
+endfunction
+
+augroup terraform
+  autocmd!
+  autocmd VimEnter *
+        \ command! -nargs=+ -complete=custom,s:commands Terraform execute '!terraform '.<q-args>. ' -no-color'
+  autocmd VimEnter * command! -nargs=0 TerraformFmt call terraform#fmt()
+  if get(g:, "terraform_fmt_on_save", 1)
+    autocmd BufWritePre *.tf call terraform#fmt()
+    autocmd BufWritePre *.tfvars call terraform#fmt()
+  endif
+augroup END
+
+endif

ftplugin/toml.vim

@@ -31,8 +31,6 @@ else
 endif
 unlet s:delims
 
-let b:undo_ftplugin = ""
-
 let &cpo = s:save_cpo
 unlet s:save_cpo
 

ftplugin/twig.vim

@@ -12,6 +12,27 @@ setlocal comments=s:{#,ex:#}
 setlocal formatoptions+=tcqln
 " setlocal formatlistpat=^\\s*\\d\\+\\.\\s\\+\\\|^[-*+]\\s\\+
 
+if exists('b:match_words')
+    let b:twigMatchWords = [
+                \ ['block', 'endblock'],
+                \ ['for', 'endfor'],
+                \ ['macro', 'endmacro'],
+                \ ['if', 'elseif', 'else', 'endif'],
+                \ ['set', 'endset']
+                \]
+    for s:element in b:twigMatchWords
+        let s:pattern = ''
+        for s:tag in s:element[:-2]
+            if s:pattern != ''
+                let s:pattern .= ':'
+            endif
+            let s:pattern .= '{%\s*\<' . s:tag . '\>\s*\%(.*=\)\@![^}]\{-}%}'
+        endfor
+        let s:pattern .= ':{%\s*\<' . s:element[-1:][0] . '\>\s*.\{-}%}'
+        let b:match_words .= ',' . s:pattern
+    endfor
+endif
+
 if exists("b:did_ftplugin")
   let b:undo_ftplugin .= "|setlocal comments< formatoptions<"
 else

ftplugin/vue.vim

@@ -5,7 +5,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vue') == -1
 " Maintainer: Eduardo San Martin Morote
 " Author: Adriaan Zonnenberg
 
-if exists("b:did_ftplugin")
+if exists('b:did_ftplugin')
   finish
 endif
 
@@ -13,11 +13,16 @@ runtime! ftplugin/html.vim
 
 setlocal suffixesadd+=.vue
 
-if exists('g:loaded_ale')
-  let g:ale_linters = get(g:, 'ale_linters', {})
-  let g:ale_linters.vue = get(g:ale_linters, 'vue', ['eslint'])
-  let g:ale_linter_aliases = get(g:, 'ale_linter_aliases', {})
-  let g:ale_linter_aliases.vue = get(g:ale_linter_aliases, 'vue', 'javascript')
+if !exists('g:no_plugin_maps') && !exists('g:no_vue_maps')
+  nnoremap <silent> <buffer> [[ :call search('^<\(template\<Bar>script\<Bar>style\)', 'bW')<CR>
+  nnoremap <silent> <buffer> ]] :call search('^<\(template\<Bar>script\<Bar>style\)', 'W')<CR>
+  nnoremap <silent> <buffer> [] :call search('^</\(template\<Bar>script\<Bar>style\)', 'bW')<CR>
+  nnoremap <silent> <buffer> ][ :call search('^</\(template\<Bar>script\<Bar>style\)', 'W')<CR>
 endif
 
+" Run only ESLint for Vue files by default.
+" linters specifically for Vue can still be loaded.
+let b:ale_linter_aliases = get(get(g:, 'ale_linter_aliases', {}), 'vue', ['vue', 'javascript'])
+let b:ale_linters = get(get(g:, 'ale_linters', {}), 'vue', ['eslint', 'vls'])
+
 endif

indent/applescript.vim

@@ -0,0 +1,81 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'applescript') == -1
+  
+"Plugin Name: applescript indent file.
+"Author: mityu
+"Last Change: 02-May-2017.
+
+let s:cpo_save=&cpo
+set cpo&vim
+
+setlocal indentexpr=GetAppleScriptIndent()
+setlocal indentkeys+=0=end,0=else,=error
+
+func! GetAppleScriptIndent()
+	let l:ignorecase_save=&ignorecase
+	try
+		let &ignorecase=0
+		return s:returnAppleScriptIndent()
+	finally
+		let &ignorecase=l:ignorecase_save
+	endtry
+endfunc
+
+func! s:returnAppleScriptIndent()
+	let l:current_text=getline(v:lnum)
+
+	let l:prev_line=prevnonblank(v:lnum-1)
+
+	"At the start of the file, use 0 indent.
+	if l:prev_line==0
+		return 0
+	endif
+
+	let l:prev_line_save=l:prev_line
+	let l:prev_line=s:prev_non_connected_line(l:prev_line)
+
+	let l:indent=indent(l:prev_line)
+
+	if l:prev_line_save-l:prev_line==1
+		"連結開始
+		let l:indent+=shiftwidth()*2
+	elseif l:prev_line_save-l:prev_line>=2
+		"絶賛連結中
+		"その時は前の行のインデントをそのまま流用する
+		return indent(l:prev_line_save)
+	elseif l:prev_line_save==l:prev_line && s:doesOrderConnect(getline(l:prev_line-1))
+		"前の行が連結される行の最終行の場合
+		let l:prev_line=s:prev_non_connected_line(l:prev_line-1)
+		if l:prev_line==0 | let l:prev_line=1 | endif
+		let l:indent=indent(l:prev_line)
+	endif
+
+	let l:prev_text=getline(l:prev_line)
+	if l:prev_text=~'^\s*\(on\|\(tell\(.*\<to\>\)\@!\)\|repeat\|try\|if\|else\)'
+		let l:indent+=shiftwidth()
+	endif
+
+	if l:current_text=~'^\s*\(end\|else\|on\serror\)'
+		let l:indent-=shiftwidth()
+	endif
+
+	return l:indent
+endfunc
+
+func! s:prev_non_connected_line(line)
+	let l:prev_line=prevnonblank(a:line)
+	while l:prev_line>0 && s:doesOrderConnect(getline(l:prev_line))
+		let l:prev_line-=1
+	endwhile
+	return l:prev_line
+endfunc
+
+func! s:doesOrderConnect(text)
+	return a:text=~'¬$'
+endfunc
+
+let &cpo=s:cpo_save
+unlet s:cpo_save
+
+" vim: foldmethod=marker
+
+endif

indent/caddyfile.vim

@@ -9,14 +9,13 @@ setlocal nolisp
 setlocal autoindent
 setlocal indentexpr=GetCaddyfileIndent(v:lnum)
 setlocal indentkeys+=<:>,0=},0=)
-" setlocal cindent
 
 if exists('*shiftwidth')
-	func s:sw()
+	function! s:sw()
 		return shiftwidth()
 	endfunc
 else
-	func s:sw()
+	function! s:sw()
 		return &sw
 	endfunc
 endif

indent/crystal.vim

@@ -129,17 +129,17 @@ let s:access_modifier_regex = '\C^\s*\%(public\|protected\|private\)\s*\%(#.*\)\
 
 " Check if the character at lnum:col is inside a string, comment, or is ascii.
 function s:IsInStringOrComment(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_strcom
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~# s:syng_strcom
 endfunction
 
 " Check if the character at lnum:col is inside a string.
 function s:IsInString(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_string
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~# s:syng_string
 endfunction
 
 " Check if the character at lnum:col is inside a string or documentation.
 function s:IsInStringOrDocumentation(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_stringdoc
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~# s:syng_stringdoc
 endfunction
 
 " Check if the character at lnum:col is inside a string delimiter

indent/cython.vim

@@ -0,0 +1,429 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'python-ident') == -1
+  
+" PEP8 compatible Python indent file
+" Language:         Python
+" Maintainer:       Daniel Hahler <https://daniel.hahler.de/>
+" Prev Maintainer:  Hynek Schlawack <hs@ox.cx>
+" Prev Maintainer:  Eric Mc Sween <em@tomcom.de> (address invalid)
+" Original Author:  David Bustos <bustos@caltech.edu> (address invalid)
+" License:          CC0
+"
+" vim-python-pep8-indent - A nicer Python indentation style for vim.
+" Written in 2004 by David Bustos <bustos@caltech.edu>
+" Maintained from 2004-2005 by Eric Mc Sween <em@tomcom.de>
+" Maintained from 2013 by Hynek Schlawack <hs@ox.cx>
+" Maintained from 2017 by Daniel Hahler <https://daniel.hahler.de/>
+"
+" To the extent possible under law, the author(s) have dedicated all copyright
+" and related and neighboring rights to this software to the public domain
+" worldwide. This software is distributed without any warranty.
+" You should have received a copy of the CC0 Public Domain Dedication along
+" with this software. If not, see
+" <http://creativecommons.org/publicdomain/zero/1.0/>.
+
+" Only load this indent file when no other was loaded.
+if exists('b:did_indent')
+    finish
+endif
+let b:did_indent = 1
+
+setlocal nolisp
+setlocal autoindent
+setlocal indentexpr=GetPythonPEPIndent(v:lnum)
+setlocal indentkeys=!^F,o,O,<:>,0),0],0},=elif,=except
+
+if !exists('g:python_pep8_indent_multiline_string')
+    let g:python_pep8_indent_multiline_string = 0
+endif
+
+if !exists('g:python_pep8_indent_hang_closing')
+    let g:python_pep8_indent_hang_closing = 0
+endif
+
+let s:block_rules = {
+            \ '^\s*elif\>': ['if', 'elif'],
+            \ '^\s*except\>': ['try', 'except'],
+            \ '^\s*finally\>': ['try', 'except', 'else']
+            \ }
+let s:block_rules_multiple = {
+            \ '^\s*else\>': ['if', 'elif', 'for', 'try', 'except'],
+            \ }
+" Pairs to look for when searching for opening parenthesis.
+" The value is the maximum offset in lines.
+let s:paren_pairs = {'()': 50, '[]': 100, '{}': 1000}
+
+if &filetype ==# 'pyrex' || &filetype ==# 'cython'
+    let b:control_statement = '\v^\s*(class|def|if|while|with|for|except|cdef|cpdef)>'
+else
+    let b:control_statement = '\v^\s*(class|def|if|while|with|for|except)>'
+endif
+let s:stop_statement = '^\s*\(break\|continue\|raise\|return\|pass\)\>'
+
+" Skip strings and comments. Return 1 for chars to skip.
+" jedi* refers to syntax definitions from jedi-vim for call signatures, which
+" are inserted temporarily into the buffer.
+let s:skip_special_chars = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "\\vstring|comment|^pythonbytes%(contents)=$|jedi\\S"'
+
+let s:skip_after_opening_paren = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "\\vcomment|jedi\\S"'
+
+" Also ignore anything concealed.
+" Wrapper around synconcealed for older Vim (7.3.429, used on Travis CI).
+function! s:is_concealed(line, col)
+    let concealed = synconcealed(a:line, a:col)
+    return len(concealed) && concealed[0]
+endfunction
+if has('conceal')
+    let s:skip_special_chars .= '|| s:is_concealed(line("."), col("."))'
+endif
+
+
+let s:skip_search = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "comment"'
+
+" Use 'shiftwidth()' instead of '&sw'.
+" (Since Vim patch 7.3.629, 'shiftwidth' can be set to 0 to follow 'tabstop').
+if exists('*shiftwidth')
+    function! s:sw()
+        return shiftwidth()
+    endfunction
+else
+    function! s:sw()
+        return &shiftwidth
+    endfunction
+endif
+
+" Find backwards the closest open parenthesis/bracket/brace.
+function! s:find_opening_paren(...)
+    " optional arguments: line and column (defaults to 1) to search around
+    if a:0 > 0
+        let view = winsaveview()
+        call cursor(a:1, a:0 > 1 ? a:2 : 1)
+        let ret = s:find_opening_paren()
+        call winrestview(view)
+        return ret
+    endif
+
+    " Return if cursor is in a comment.
+    exe 'if' s:skip_search '| return [0, 0] | endif'
+
+    let nearest = [0, 0]
+    for [p, maxoff] in items(s:paren_pairs)
+        let stopline = max([0, line('.') - maxoff, nearest[0]])
+        let next = searchpairpos(
+           \ '\V'.p[0], '', '\V'.p[1], 'bnW', s:skip_special_chars, stopline)
+        if next[0] && (next[0] > nearest[0] || (next[0] == nearest[0] && next[1] > nearest[1]))
+            let nearest = next
+        endif
+    endfor
+    return nearest
+endfunction
+
+" Find the start of a multi-line statement
+function! s:find_start_of_multiline_statement(lnum)
+    let lnum = a:lnum
+    while lnum > 0
+        if getline(lnum - 1) =~# '\\$'
+            let lnum = prevnonblank(lnum - 1)
+        else
+            let [paren_lnum, _] = s:find_opening_paren(lnum)
+            if paren_lnum < 1
+                return lnum
+            else
+                let lnum = paren_lnum
+            endif
+        endif
+    endwhile
+endfunction
+
+" Find possible indent(s) of the block starter that matches the current line.
+function! s:find_start_of_block(lnum, types, multiple)
+    let r = []
+    let re = '\V\^\s\*\('.join(a:types, '\|').'\)\>'
+    let lnum = a:lnum
+    let last_indent = indent(lnum) + 1
+    while lnum > 0 && last_indent > 0
+        let indent = indent(lnum)
+        if indent < last_indent
+            if getline(lnum) =~# re
+                if !a:multiple
+                    return [indent]
+                endif
+                if index(r, indent) == -1
+                    let r += [indent]
+                endif
+                let last_indent = indent
+            endif
+        endif
+        let lnum = prevnonblank(lnum - 1)
+    endwhile
+    return r
+endfunction
+
+" Is "expr" true for every position in "lnum", beginning at "start"?
+" (optionally up to a:1 / 4th argument)
+function! s:match_expr_on_line(expr, lnum, start, ...)
+    let text = getline(a:lnum)
+    let end = a:0 ? a:1 : len(text)
+    if a:start > end
+        return 1
+    endif
+    let save_pos = getpos('.')
+    let r = 1
+    for i in range(a:start, end)
+        call cursor(a:lnum, i)
+        if !(eval(a:expr) || text[i-1] =~# '\s')
+            let r = 0
+            break
+        endif
+    endfor
+    call setpos('.', save_pos)
+    return r
+endfunction
+
+" Line up with open parenthesis/bracket/brace.
+function! s:indent_like_opening_paren(lnum)
+    let [paren_lnum, paren_col] = s:find_opening_paren(a:lnum)
+    if paren_lnum <= 0
+        return -2
+    endif
+    let text = getline(paren_lnum)
+    let base = indent(paren_lnum)
+
+    let nothing_after_opening_paren = s:match_expr_on_line(
+                \ s:skip_after_opening_paren, paren_lnum, paren_col+1)
+    let starts_with_closing_paren = getline(a:lnum) =~# '^\s*[])}]'
+
+    let hang_closing = get(b:, 'python_pep8_indent_hang_closing',
+                \ get(g:, 'python_pep8_indent_hang_closing', 0))
+
+    if nothing_after_opening_paren
+        if starts_with_closing_paren && !hang_closing
+            let res = base
+        else
+            let res = base + s:sw()
+        endif
+    else
+        " Indent to match position of opening paren.
+        let res = paren_col
+    endif
+
+    " If this line is the continuation of a control statement
+    " indent further to distinguish the continuation line
+    " from the next logical line.
+    if text =~# b:control_statement && res == base + s:sw()
+        " But only if not inside parens itself (Flake's E127).
+        let [paren_lnum, _] = s:find_opening_paren(paren_lnum)
+        if paren_lnum <= 0
+            return res + s:sw()
+        endif
+    endif
+    return res
+endfunction
+
+" Match indent of first block of this type.
+function! s:indent_like_block(lnum)
+    let text = getline(a:lnum)
+    for [multiple, block_rules] in [
+                \ [0, s:block_rules],
+                \ [1, s:block_rules_multiple]]
+        for [line_re, blocks] in items(block_rules)
+            if text !~# line_re
+                continue
+            endif
+
+            let indents = s:find_start_of_block(a:lnum - 1, blocks, multiple)
+            if !len(indents)
+                return -1
+            endif
+            if len(indents) == 1
+                return indents[0]
+            endif
+
+            " Multiple valid indents, e.g. for 'else' with both try and if.
+            let indent = indent(a:lnum)
+            if index(indents, indent) != -1
+                " The indent is valid, keep it.
+                return indent
+            endif
+            " Fallback to the first/nearest one.
+            return indents[0]
+        endfor
+    endfor
+    return -2
+endfunction
+
+function! s:indent_like_previous_line(lnum)
+    let lnum = prevnonblank(a:lnum - 1)
+
+    " No previous line, keep current indent.
+    if lnum < 1
+      return -1
+    endif
+
+    let text = getline(lnum)
+    let start = s:find_start_of_multiline_statement(lnum)
+    let base = indent(start)
+    let current = indent(a:lnum)
+
+    " Jump to last character in previous line.
+    call cursor(lnum, len(text))
+    let ignore_last_char = eval(s:skip_special_chars)
+
+    " Search for final colon that is not inside something to be ignored.
+    while 1
+        let curpos = getpos('.')[2]
+        if curpos == 1 | break | endif
+        if eval(s:skip_special_chars) || text[curpos-1] =~# '\s'
+            normal! h
+            continue
+        elseif text[curpos-1] ==# ':'
+            return base + s:sw()
+        endif
+        break
+    endwhile
+
+    if text =~# '\\$' && !ignore_last_char
+        " If this line is the continuation of a control statement
+        " indent further to distinguish the continuation line
+        " from the next logical line.
+        if getline(start) =~# b:control_statement
+            return base + s:sw() * 2
+        endif
+
+        " Nest (other) explicit continuations only one level deeper.
+        return base + s:sw()
+    endif
+
+    let empty = getline(a:lnum) =~# '^\s*$'
+
+    " Current and prev line are empty, next is not -> indent like next.
+    if empty && a:lnum > 1 &&
+          \ (getline(a:lnum - 1) =~# '^\s*$') &&
+          \ !(getline(a:lnum + 1) =~# '^\s*$')
+      return indent(a:lnum + 1)
+    endif
+
+    " If the previous statement was a stop-execution statement or a pass
+    if getline(start) =~# s:stop_statement
+        " Remove one level of indentation if the user hasn't already dedented
+        if empty || current > base - s:sw()
+            return base - s:sw()
+        endif
+        " Otherwise, trust the user
+        return -1
+    endif
+
+    if !empty && s:is_dedented_already(current, base)
+        return -1
+    endif
+
+    " In all other cases, line up with the start of the previous statement.
+    return base
+endfunction
+
+" If this line is dedented and the number of indent spaces is valid
+" (multiple of the indentation size), trust the user.
+function! s:is_dedented_already(current, base)
+    let dedent_size = a:current - a:base
+    return (dedent_size < 0 && a:current % s:sw() == 0) ? 1 : 0
+endfunction
+
+" Is the syntax at lnum (and optionally cnum) a python string?
+function! s:is_python_string(lnum, ...)
+    let line = getline(a:lnum)
+    if a:0
+      let cols = type(a:1) != type([]) ? [a:1] : a:1
+    else
+      let cols = range(1, max([1, len(line)]))
+    endif
+    for cnum in cols
+        if match(map(synstack(a:lnum, cnum),
+                    \ "synIDattr(v:val, 'name')"), 'python\S*String') == -1
+            return 0
+        end
+    endfor
+    return 1
+endfunction
+
+function! GetPythonPEPIndent(lnum)
+    " First line has indent 0
+    if a:lnum == 1
+        return 0
+    endif
+
+    let line = getline(a:lnum)
+    let prevline = getline(a:lnum-1)
+
+    " Multilinestrings: continous, docstring or starting.
+    if s:is_python_string(a:lnum-1, max([1, len(prevline)]))
+                \ && (s:is_python_string(a:lnum, 1)
+                \     || match(line, '^\%("""\|''''''\)') != -1)
+
+        " Indent closing quotes as the line with the opening ones.
+        let match_quotes = match(line, '^\s*\zs\%("""\|''''''\)')
+        if match_quotes != -1
+            " closing multiline string
+            let quotes = line[match_quotes:(match_quotes+2)]
+            let pairpos = searchpairpos(quotes, '', quotes, 'b')
+            if pairpos[0] != 0
+                return indent(pairpos[0])
+            else
+                " TODO: test to cover this!
+            endif
+        endif
+
+        if s:is_python_string(a:lnum-1)
+            " Previous line is (completely) a string: keep current indent.
+            return -1
+        endif
+
+        if match(prevline, '^\s*\%("""\|''''''\)') != -1
+            " docstring.
+            return indent(a:lnum-1)
+        endif
+
+        let indent_multi = get(b:, 'python_pep8_indent_multiline_string',
+                    \ get(g:, 'python_pep8_indent_multiline_string', 0))
+        if match(prevline, '\v%("""|'''''')$') != -1
+            " Opening multiline string, started in previous line.
+            if (&autoindent && indent(a:lnum) == indent(a:lnum-1))
+                        \ || match(line, '\v^\s+$') != -1
+                " <CR> with empty line or to split up 'foo("""bar' into
+                " 'foo("""' and 'bar'.
+                if indent_multi == -2
+                    return indent(a:lnum-1) + s:sw()
+                endif
+                return indent_multi
+            endif
+        endif
+
+        " Keep existing indent.
+        if match(line, '\v^\s*\S') != -1
+            return -1
+        endif
+
+        if indent_multi != -2
+            return indent_multi
+        endif
+
+        return s:indent_like_opening_paren(a:lnum)
+    endif
+
+    " Parens: If we can find an open parenthesis/bracket/brace, line up with it.
+    let indent = s:indent_like_opening_paren(a:lnum)
+    if indent >= -1
+        return indent
+    endif
+
+    " Blocks: Match indent of first block of this type.
+    let indent = s:indent_like_block(a:lnum)
+    if indent >= -1
+        return indent
+    endif
+
+    return s:indent_like_previous_line(a:lnum)
+endfunction
+
+endif

indent/dart.vim

@@ -6,7 +6,7 @@ endif
 let b:did_indent = 1
 
 setlocal cindent
-setlocal cinoptions+=j1,J1
+setlocal cinoptions+=j1,J1,(2s,u2s,U1,m1,+2s
 
 setlocal indentexpr=DartIndent()
 

indent/eruby.vim

@@ -6,7 +6,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'ruby') == -1
 " URL:			https://github.com/vim-ruby/vim-ruby
 " Release Coordinator:	Doug Kearns <dougkearns@gmail.com>
 
-if exists("b:did_indent")
+if get(b:, 'did_indent') =~# '\<eruby\>'
   finish
 endif
 
@@ -14,12 +14,14 @@ runtime! indent/ruby.vim
 unlet! b:did_indent
 setlocal indentexpr=
 
-if exists("b:eruby_subtype") && b:eruby_subtype != '' && b:eruby_subtype !=# 'eruby'
-  exe "runtime! indent/".b:eruby_subtype.".vim"
-else
-  runtime! indent/html.vim
+if &filetype =~# '^eruby\>'
+  if exists("b:eruby_subtype") && b:eruby_subtype != '' && b:eruby_subtype !=# 'eruby'
+    exe "runtime! indent/".b:eruby_subtype.".vim"
+  else
+    runtime! indent/html.vim
+  endif
 endif
-unlet! b:did_indent
+let b:did_indent = get(b:, 'did_indent', 1) . '.eruby'
 
 " Force HTML indent to not keep state.
 let b:html_indent_usestate = 0
@@ -33,8 +35,6 @@ if &l:indentexpr == ''
 endif
 let b:eruby_subtype_indentexpr = &l:indentexpr
 
-let b:did_indent = 1
-
 setlocal indentexpr=GetErubyIndent()
 setlocal indentkeys=o,O,*<Return>,<>>,{,},0),0],o,O,!^F,=end,=else,=elsif,=rescue,=ensure,=when
 

indent/go.vim

@@ -26,17 +26,6 @@ if exists("*GoIndent")
   finish
 endif
 
-" use shiftwidth function only if it's available
-if exists('*shiftwidth')
-  func s:sw()
-    return shiftwidth()
-  endfunc
-else
-  func s:sw()
-    return &sw
-  endfunc
-endif
-
 function! GoIndent(lnum)
   let prevlnum = prevnonblank(a:lnum-1)
   if prevlnum == 0
@@ -51,19 +40,23 @@ function! GoIndent(lnum)
 
   let ind = previ
 
+  if prevl =~ ' = `[^`]*$'
+    " previous line started a multi-line raw string
+    return 0
+  endif
   if prevl =~ '[({]\s*$'
     " previous line opened a block
-    let ind += s:sw()
+    let ind += shiftwidth()
   endif
   if prevl =~# '^\s*\(case .*\|default\):$'
     " previous line is part of a switch statement
-    let ind += s:sw()
+    let ind += shiftwidth()
   endif
   " TODO: handle if the previous line is a label.
 
   if thisl =~ '^\s*[)}]'
     " this line closed a block
-    let ind -= s:sw()
+    let ind -= shiftwidth()
   endif
 
   " Colons are tricky.
@@ -71,7 +64,7 @@ function! GoIndent(lnum)
   " We ignore trying to deal with jump labels because (a) they're rare, and
   " (b) they're hard to disambiguate from a composite literal key.
   if thisl =~# '^\s*\(case .*\|default\):$'
-    let ind -= s:sw()
+    let ind -= shiftwidth()
   endif
 
   return ind

indent/graphql.vim

@@ -0,0 +1,81 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+  
+" Vim indent file
+" Language: GraphQL
+" Maintainer: Jon Parise <jon@indelible.org>
+
+if exists('b:did_indent')
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal nocindent
+setlocal nolisp
+setlocal nosmartindent
+
+setlocal indentexpr=GetGraphQLIndent()
+setlocal indentkeys=0{,0},0),0[,0],0#,!^F,o,O,e
+
+" If our indentation function already exists, we have nothing more to do.
+if exists('*GetGraphQLIndent')
+  finish
+endif
+
+let s:cpo_save = &cpoptions
+set cpoptions&vim
+
+" Check if the character at lnum:col is inside a string.
+function s:InString(lnum, col)
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') is# 'graphqlString'
+endfunction
+
+function GetGraphQLIndent()
+  " If this is the first non-blank line, we have nothing more to do because
+  " all of our indentation rules are based on matching against earlier lines.
+  let l:prevlnum = prevnonblank(v:lnum - 1)
+  if l:prevlnum == 0
+    return 0
+  endif
+
+  let l:line = getline(v:lnum)
+
+  " If this line contains just a closing bracket, find its matching opening
+  " bracket and indent the closing backet to match.
+  let l:col = matchend(l:line, '^\s*[]})]')
+  if l:col > 0 && !s:InString(v:lnum, l:col)
+    let l:bracket = l:line[l:col - 1]
+    call cursor(v:lnum, l:col)
+
+    if l:bracket is# '}'
+      let l:matched = searchpair('{', '', '}', 'bW')
+    elseif l:bracket is# ']'
+      let l:matched = searchpair('\[', '', '\]', 'bW')
+    elseif l:bracket is# ')'
+      let l:matched = searchpair('(', '', ')', 'bW')
+    else
+      let l:matched = -1
+    endif
+
+    return l:matched > 0 ? indent(l:matched) : virtcol('.') - 1
+  endif
+
+  " If we're inside of a multiline string, continue with the same indentation.
+  if s:InString(v:lnum, matchend(l:line, '^\s*') + 1)
+    return indent(v:lnum)
+  endif
+
+  " If the previous line contained an opening bracket, and we are still in it,
+  " add indent depending on the bracket type.
+  if getline(l:prevlnum) =~# '[[{(]\s*$'
+    return indent(l:prevlnum) + shiftwidth()
+  endif
+
+  " Default to the existing indentation level.
+  return indent(l:prevlnum)
+endfunction
+
+let &cpoptions = s:cpo_save
+unlet s:cpo_save
+
+endif

indent/haskell.vim

@@ -42,12 +42,6 @@ if !exists('g:haskell_indent_let')
   let g:haskell_indent_let = 4
 endif
 
-if !exists('g:haskell_indent_let_no_in')
-  " let x = 0
-  "     x
-  let g:haskell_indent_let_no_in = 4
-endif
-
 if !exists('g:haskell_indent_where')
   " where f :: Int -> Int
   " >>>>>>f x = x
@@ -73,7 +67,7 @@ if !exists('g:haskell_indent_guard')
 endif
 
 setlocal indentexpr=GetHaskellIndent()
-setlocal indentkeys=0},0),0],!^F,o,O,0=where,0=let,0=deriving,<space>
+setlocal indentkeys=!^F,o,O,0{,0},0(,0),0[,0],0,,0=where,0=let,0=deriving,0=in\ ,0=::\ ,0=\-\>\ ,0=\=\>\ ,0=\|\ ,=\=\ 
 
 function! s:isInBlock(hlstack)
   return index(a:hlstack, 'haskellDelimiter') > -1 || index(a:hlstack, 'haskellParens') > -1 || index(a:hlstack, 'haskellBrackets') > -1 || index(a:hlstack, 'haskellBlock') > -1 || index(a:hlstack, 'haskellBlockComment') > -1 || index(a:hlstack, 'haskellPragma') > -1
@@ -115,25 +109,26 @@ endfunction
 " backtrack to find guard clause
 function! s:indentGuard(pos, prevline)
   let l:l = a:prevline
-  let l:c = 1
+  let l:c = v:lnum - 1
+  let l:s = indent(l:c)
 
-  while v:lnum != l:c
-    " empty line, stop looking
-    if l:l =~ '^$'
-      return a:pos
-    " guard found
-    elseif l:l =~ '^\s*|\s\+'
-      return match(l:l, '|')
-    " found less deeper indentation (not starting with `,` or `=`)
-    " stop looking
+  while l:c >= 1
+    if l:s == 0 && strlen(l:l) > 0
+      " top-level start, stop looking
+      return g:haskell_indent_guard
+    elseif l:l =~ '^\s\+[|,=]\s\+'
+      " guard block found
+      return match(l:l, '[|,=]')
     else
-      let l:m = match(l:l, '\S')
-      if l:l !~ '^\s*[=,]' && l:m <= a:pos
-        return l:m + g:haskell_indent_guard
+      if l:s > 0 && l:s <= a:pos
+        " found less deeper indentation (not starting with `,` or `=`)
+        " stop looking
+        return l:s + g:haskell_indent_guard
       endif
     endif
-    let l:c += 1
-    let l:l = getline(v:lnum - l:c)
+    let l:c -= 1
+    let l:l = getline(l:c)
+    let l:s = indent(l:c)
   endwhile
 
   return -1
@@ -196,7 +191,7 @@ function! GetHaskellIndent()
 
   " operator at end of previous line
   if l:prevline =~ '[!#$%&*+./<>?@\\^|~-]\s*$'
-    return match(l:prevline, '\S') + &shiftwidth
+    return indent(v:lnum - 1) + &shiftwidth
   endif
 
   " let foo =
@@ -207,7 +202,7 @@ function! GetHaskellIndent()
 
   " let x = 1 in
   " >>>>x
-  if l:prevline =~ '\C\<let\>\s\+.\+\<in\>\?$' && l:line !~ '\C^\s*\<in\>'
+  if l:prevline =~ '\C\<let\>.\{-}\<in\>\s*$' && l:line !~ '\C^\s*\<in\>'
     return match(l:prevline, '\C\<let\>') + g:haskell_indent_let
   endif
 
@@ -215,9 +210,6 @@ function! GetHaskellIndent()
   " let y = 2
   "
   " let x = 1
-  " >in x
-  "
-  " let x = 1
   " >>>>y = 2
   "
   " let x = 1
@@ -228,21 +220,11 @@ function! GetHaskellIndent()
       if s:isSYN('haskellLet', v:lnum - 1, l:s + 1)
         return l:s
       endif
-    elseif l:line =~ '\C^\s*\<in\>'
-      let l:s = match(l:prevline, '\C\<let\>')
-      if s:isSYN('haskellLet', v:lnum - 1, l:s + 1)
-        return l:s + g:haskell_indent_in
-      endif
     elseif l:line =~ '\s=\s'
       let l:s = match(l:prevline, '\C\<let\>')
       if s:isSYN('haskellLet', v:lnum - 1, l:s + 1)
         return l:s + g:haskell_indent_let
       endif
-    else
-      let l:s = match(l:prevline, '\C\<let\>')
-      if s:isSYN('haskellLet', v:lnum - 1, l:s + 1)
-        return l:s + g:haskell_indent_let_no_in
-      endif
     endif
   endif
 
@@ -263,7 +245,7 @@ function! GetHaskellIndent()
   " >>foo
   "
   if l:prevline =~ '\C\<where\>\s*$'
-    return match(l:prevline, '\S') + get(g:, 'haskell_indent_after_bare_where', &shiftwidth)
+    return indent(v:lnum - 1) + get(g:, 'haskell_indent_after_bare_where', &shiftwidth)
   endif
 
   " do
@@ -272,7 +254,7 @@ function! GetHaskellIndent()
   " foo =
   " >>bar
   if l:prevline =~ '\C\(\<do\>\|=\)\s*$'
-    return match(l:prevline, '\S') + &shiftwidth
+    return indent(v:lnum - 1) + &shiftwidth
   endif
 
   " do foo
@@ -288,7 +270,7 @@ function! GetHaskellIndent()
   " >>bar -> quux
   if l:prevline =~ '\C\<case\>.\+\<of\>\s*$'
     if get(g:,'haskell_indent_case_alternative', 0)
-      return match(l:prevline, '\S') + &shiftwidth
+      return indent(v:lnum - 1) + &shiftwidth
     else
       return match(l:prevline, '\C\<case\>') + g:haskell_indent_case
     endif
@@ -296,9 +278,20 @@ function! GetHaskellIndent()
 
   "" where foo
   "" >>>>>>bar
+  ""
+  "" where foo :: Int
+  "" >>>>>>>>>>-> Int
+  ""
+  "" where foo x
+  "" >>>>>>>>|
   if l:prevline =~ '\C\<where\>\s\+\S\+.*$'
     if  l:line =~ '^\s*[=-]>\s' && l:prevline =~ ' :: '
       return match(l:prevline, ':: ')
+    elseif  l:line =~ '^\s*|\s'
+      let l:s = match(l:prevline, '\C\<where\>')
+      if s:isSYN('haskellWhere', v:lnum - 1, l:s + 1)
+        return l:s + g:haskell_indent_where + g:haskell_indent_guard
+      endif
     else
       let l:s = match(l:prevline, '\C\<where\>')
       if s:isSYN('haskellWhere', v:lnum - 1, l:s + 1)
@@ -309,8 +302,8 @@ function! GetHaskellIndent()
 
   " newtype Foo = Foo
   " >>deriving
-  if l:prevline =~ '\C\s*\<\(newtype\|data\)\>[^{]\+' && l:line =~ '\C^\s*\<deriving\>'
-    return match(l:prevline, '\S') + &shiftwidth
+  if l:prevline =~ '\C^\s*\<\(newtype\|data\)\>[^{]\+' && l:line =~ '\C^\s*\<deriving\>'
+    return indent(v:lnum - 1) + &shiftwidth
   endif
 
   " foo :: Int
@@ -352,9 +345,9 @@ function! GetHaskellIndent()
       else
         let l:m = matchstr(l:line, '^\s*\zs\<\S\+\>\ze')
         let l:l = l:prevline
-        let l:c = 1
+        let l:c = v:lnum - 1
 
-        while v:lnum != l:c
+        while l:c >= 1
           " fun decl
           if l:l =~ ('^\s*' . l:m . '\(\s*::\|\n\s\+::\)')
             let l:s = match(l:l, l:m)
@@ -367,8 +360,8 @@ function! GetHaskellIndent()
           elseif l:l =~ '^$'
              return 0
           endif
-          let l:c += 1
-          let l:l = getline(v:lnum - l:c)
+          let l:c -= 1
+          let l:l = getline(l:c)
         endwhile
 
         return 0
@@ -414,8 +407,8 @@ function! GetHaskellIndent()
 
   " foo
   " >>{
-  if l:line =~ '^\s*{ '
-    let l:s = match(l:prevline, '\S')
+  if l:line =~ '^\s*{'
+    let l:s = indent(v:lnum - 1)
     if l:s >= 0
       return l:s + &shiftwidth
     endif
@@ -433,14 +426,27 @@ function! GetHaskellIndent()
       return match(l:prevline, 'in') - g:haskell_indent_in
     endif
 
-    return match(l:prevline, '\S') + get(g:, 'haskell_indent_before_where', &shiftwidth)
+    return indent(v:lnum - 1) + get(g:, 'haskell_indent_before_where', &shiftwidth)
   endif
 
   " let x = 1
   "     y = 2
   " >in x + 1
   if l:line =~ '\C^\s*\<in\>'
-    return match(l:prevline, '\S') - (4 - g:haskell_indent_in)
+    let l:s = 0
+    let l:c = v:lnum - 1
+
+    while l:s <= 0 && l:c >= 1
+      let l:l = getline(l:c)
+      let l:s = match(l:l, '\C\<let\>')
+      if l:s >= 1 && s:isSYN('haskellLet', l:c, l:s + 1)
+        break
+      elseif l:l =~ '^\S'
+        return -1
+      endif
+      let l:c -= 1
+    endwhile
+    return l:s + g:haskell_indent_in
   endif
 
   " data Foo
@@ -485,7 +491,7 @@ function! GetHaskellIndent()
   " foo
   " >>:: Int
   if l:line =~ '^\s*::\s'
-    return match(l:prevline, '\S') + &shiftwidth
+    return indent(v:lnum - 1) + &shiftwidth
   endif
 
   " indent closing brace, paren or bracket

indent/javascript.vim

@@ -4,7 +4,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') ==
 " Language: Javascript
 " Maintainer: Chris Paul ( https://github.com/bounceme )
 " URL: https://github.com/pangloss/vim-javascript
-" Last Change: September 18, 2017
+" Last Change: December 4, 2017
 
 " Only load this indent file when no other was loaded.
 if exists('b:did_indent')
@@ -89,22 +89,22 @@ function s:SynAt(l,c)
 endfunction
 
 function s:ParseCino(f)
-  let [divider, n, cstr] = [0] + matchlist(&cino,
-        \ '\%(.*,\)\=\%(\%d'.char2nr(a:f).'\(-\)\=\([.s0-9]*\)\)\=')[1:2]
-  for c in split(cstr,'\zs')
-    if c == '.' && !divider
+  let [s, n, divider] = [strridx(&cino, a:f)+1, '', 0]
+  while s && &cino[ s ] =~ '[^,]'
+    if &cino[ s ] == '.'
       let divider = 1
-    elseif c ==# 's'
+    elseif &cino[ s ] ==# 's'
       if n !~ '\d'
         return n . s:sw() + 0
       endif
       let n = str2nr(n) * s:sw()
       break
     else
-      let [n, divider] .= [c, 0]
+      let [n, divider] .= [&cino[ s ], 0]
     endif
-  endfor
-  return str2nr(n) / max([str2nr(divider),1])
+    let s += 1
+  endwhile
+  return str2nr(n) / max([divider, 1])
 endfunction
 
 " Optimized {skip} expr, only callable from the search loop which
@@ -121,11 +121,14 @@ function s:SkipFunc()
     if eval(s:skip_expr)
       return 1
     endif
-  elseif search('\m`\|\${\|\*\/','nW'.s:z,s:looksyn) && eval(s:skip_expr)
-    let s:check_in = 1
-    return 1
+  elseif search('\m`\|\${\|\*\/','nW'.s:z,s:looksyn)
+    if eval(s:skip_expr)
+      let s:check_in = 1
+      return 1
+    endif
+  else
+    let s:synid_cache[:] += [[line2byte('.') + col('.') - 1], ['']]
   endif
-  let s:synid_cache[:] += [[line2byte('.') + col('.') - 1], ['']]
   let [s:looksyn, s:top_col] = getpos('.')[1:2]
 endfunction
 
@@ -205,18 +208,15 @@ function s:ExprCol()
   let bal = 0
   while s:SearchLoop('[{}?:]','bW',s:skip_expr)
     if s:LookingAt() == ':'
-      if getline('.')[col('.')-2] == ':'
-        call cursor(0,col('.')-1)
-        continue
-      endif
-      let bal -= 1
+      let bal -= !search('\m:\%#','bW')
     elseif s:LookingAt() == '?'
       if getline('.')[col('.'):col('.')+1] =~ '^\.\d\@!'
-        continue
+        " ?. conditional chain, not ternary start
       elseif !bal
         return 1
+      else
+        let bal += 1
       endif
-      let bal += 1
     elseif s:LookingAt() == '{'
       return !s:IsBlock()
     elseif !s:GetPair('{','}','bW',s:skip_expr)
@@ -242,18 +242,18 @@ function s:Continues()
 endfunction
 
 " Check if line 'lnum' has a balanced amount of parentheses.
-function s:Balanced(lnum)
-  let [l:open, l:line] = [0, getline(a:lnum)]
-  let pos = match(l:line, '[][(){}]')
+function s:Balanced(lnum,line)
+  let l:open = 0
+  let pos = match(a:line, '[][(){}]')
   while pos != -1
     if s:SynAt(a:lnum,pos + 1) !~? b:syng_strcom
-      let l:open += match(' ' . l:line[pos],'[[({]')
+      let l:open += matchend(a:line[pos],'[[({]')
       if l:open < 0
         return
       endif
     endif
-    let pos = match(l:line, !l:open ? '[][(){}]' : '()' =~ l:line[pos] ?
-          \ '[()]' : '{}' =~ l:line[pos] ? '[{}]' : '[][]', pos + 1)
+    let pos = match(a:line, !l:open ? '[][(){}]' : '()' =~ a:line[pos] ?
+          \ '[()]' : '{}' =~ a:line[pos] ? '[{}]' : '[][]', pos + 1)
   endwhile
   return !l:open
 endfunction
@@ -266,8 +266,10 @@ function s:OneScope()
           \ s:Pure('s:PreviousToken') != '.' && !(tok == 'while' && s:DoWhile())
   elseif s:Token() =~# '^else$\|^do$'
     return s:Pure('s:PreviousToken') != '.'
+  elseif strpart(getline('.'),col('.')-2,2) == '=>'
+    call cursor(0,col('.')-1)
+    return s:PreviousToken() != ')' || s:GetPair('(', ')', 'bW', s:skip_expr)
   endif
-  return strpart(getline('.'),col('.')-2,2) == '=>'
 endfunction
 
 function s:DoWhile()
@@ -291,9 +293,9 @@ endfunction
 " encloses the entire context, 'cont' if whether a:firstline is a continued
 " expression, which could have started in a braceless context
 function s:IsContOne(cont)
-  let [l:num, b_l] = [b:js_cache[1] + !b:js_cache[1], 0]
-  let pind = b:js_cache[1] ? indent(b:js_cache[1]) + s:sw() : 0
-  let ind = indent('.') + !a:cont
+  let [l:num, pind] = b:js_cache[1] ?
+        \ [b:js_cache[1], indent(b:js_cache[1]) + s:sw()] : [1,0]
+  let [ind, b_l] = [indent('.') + !a:cont, 0]
   while line('.') > l:num && ind > pind || line('.') == l:num
     if indent('.') < ind && s:OneScope()
       let b_l += 1
@@ -311,8 +313,8 @@ function s:IsContOne(cont)
 endfunction
 
 function s:IsSwitch()
-  call call('cursor',b:js_cache[1:])
-  return search('\m\C\%#.\_s*\%(\%(\/\/.*\_$\|\/\*\_.\{-}\*\/\)\@>\_s*\)*\%(case\|default\)\>','nWc'.s:z)
+  return search(printf('\m\C\%%%dl\%%%dc%s',b:js_cache[1],b:js_cache[2],
+        \ '{\_s*\%(\%(\/\/.*\_$\|\/\*\_.\{-}\*\/\)\@>\_s*\)*\%(case\|default\)\>'),'nW'.s:z)
 endfunction
 
 " https://github.com/sweet-js/sweet.js/wiki/design#give-lookbehind-to-the-reader
@@ -352,28 +354,26 @@ function GetJavascriptIndent()
 
   " start with strings,comments,etc.
   if s:stack[-1] =~? 'comment\|doc'
-    if l:line =~ '^\s*\*'
-      return cindent(v:lnum)
-    elseif l:line !~ '^\s*\/[/*]'
-      return -1
+    if l:line !~ '^\s*\/[/*]'
+      return l:line =~ '^\s*\*' ? cindent(v:lnum) : -1
     endif
   elseif s:stack[-1] =~? b:syng_str
-    if b:js_cache[0] == v:lnum - 1 && s:Balanced(v:lnum-1)
+    if b:js_cache[0] == v:lnum - 1 && s:Balanced(v:lnum-1,getline(v:lnum-1))
       let b:js_cache[0] = v:lnum
     endif
     return -1
   endif
 
-  let s:l1 = max([0,prevnonblank(v:lnum) - (s:rel ? 2000 : 1000),
-        \ get(get(b:,'hi_indent',{}),'blocklnr')])
+  let nest = get(get(b:,'hi_indent',{}),'blocklnr')
+  let s:l1 = max([0, prevnonblank(v:lnum) - (s:rel ? 2000 : 1000), nest])
   call cursor(v:lnum,1)
   if s:PreviousToken() is ''
     return
   endif
-  let [l:lnum, pline] = [line('.'), getline('.')[:col('.')-1]]
+  let [l:lnum, lcol, pline] = getpos('.')[1:2] + [getline('.')[:col('.')-1]]
 
   let l:line = substitute(l:line,'^\s*','','')
-  let l:line_raw = l:line
+  let l:line_s = l:line[0]
   if l:line[:1] == '/*'
     let l:line = substitute(l:line,'^\%(\/\*.\{-}\*\/\s*\)*','','')
   endif
@@ -385,7 +385,7 @@ function GetJavascriptIndent()
   call cursor(v:lnum,1)
   let idx = index([']',')','}'],l:line[0])
   if b:js_cache[0] > l:lnum && b:js_cache[0] < v:lnum ||
-        \ b:js_cache[0] == l:lnum && s:Balanced(l:lnum)
+        \ b:js_cache[0] == l:lnum && s:Balanced(l:lnum,pline)
     call call('cursor',b:js_cache[1:])
   else
     let [s:looksyn, s:top_col, s:check_in, s:l1] = [v:lnum - 1,0,0,
@@ -423,7 +423,7 @@ function GetJavascriptIndent()
       endif
     endif
     if idx == -1 && pline[-1:] !~ '[{;]'
-      call cursor(l:lnum, len(pline))
+      call cursor(l:lnum, lcol)
       let sol = matchstr(l:line,s:opfirst)
       if sol is '' || sol == '/' && s:SynAt(v:lnum,
             \ 1 + len(getline(v:lnum)) - len(l:line)) =~? 'regex'
@@ -439,14 +439,15 @@ function GetJavascriptIndent()
       else
         let is_op = s:sw()
       endif
-      call cursor(l:lnum, len(pline))
+      call cursor(l:lnum, lcol)
       let b_l = s:Nat(s:IsContOne(is_op) - (!is_op && l:line =~ '^{')) * s:sw()
     endif
-  elseif idx.s:LookingAt().&cino =~ '^-1(.*(' && (search('\m\S','nbW',num) || s:ParseCino('U'))
+  elseif idx == -1 && s:LookingAt() == '(' && &cino =~ '(' &&
+        \ (search('\m\S','nbW',num) || s:ParseCino('U'))
     let pval = s:ParseCino('(')
     if !pval
       let [Wval, vcol] = [s:ParseCino('W'), virtcol('.')]
-      if search('\m\S','W',num)
+      if search('\m'.get(g:,'javascript_indent_W_pat','\S'),'W',num)
         return s:ParseCino('w') ? vcol : virtcol('.')-1
       endif
       return Wval ? s:Nat(num_ind + Wval) : vcol
@@ -456,7 +457,7 @@ function GetJavascriptIndent()
 
   " main return
   if l:line =~ '^[])}]\|^|}'
-    if l:line_raw[0] == ')'
+    if l:line_s == ')'
       if s:ParseCino('M')
         return indent(l:lnum)
       elseif num && &cino =~# 'm' && !s:ParseCino('m')
@@ -466,6 +467,8 @@ function GetJavascriptIndent()
     return num_ind
   elseif num
     return s:Nat(num_ind + get(l:,'case_offset',s:sw()) + l:switch_offset + b_l + is_op)
+  elseif nest
+    return indent(nextnonblank(nest+1)) + b_l + is_op
   endif
   return b_l + is_op
 endfunction

indent/julia.vim

@@ -3,13 +3,13 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
 " Vim indent file
 " Language:	Julia
 " Maintainer:	Carlo Baldassi <carlobaldassi@gmail.com>
-" Last Change:	2011 dec 11
-" Notes:        based on Bram Moneaar's indent file for vim
+" Last Change:	2016 jun 16
+" Notes:        originally based on Bram Molenaar's indent file for vim
 
 setlocal autoindent
 
 setlocal indentexpr=GetJuliaIndent()
-setlocal indentkeys+==end,=else,=catch,=finally
+setlocal indentkeys+==end,=else,=catch,=finally,),],}
 setlocal indentkeys-=0#
 setlocal indentkeys-=:
 setlocal indentkeys-=0{
@@ -21,15 +21,19 @@ if exists("*GetJuliaIndent")
   finish
 endif
 
-let s:skipPatterns = '\<julia\%(Comment\)\>'
+let s:skipPatterns = '\<julia\%(Comprehension\%(For\|If\)\|RangeEnd\|Comment[LM]\|\%([bsv]\|ip\|big\|MIME\|Shell\|Printf\|Doc\)\=String\|RegEx\|SymbolS\?\)\>'
 
-function JuliaMatch(lnum, str, regex, st)
+function JuliaMatch(lnum, str, regex, st, ...)
   let s = a:st
+  let e = a:0 > 0 ? a:1 : -1
   while 1
-    let f = match(a:str, a:regex, s)
+    let f = match(a:str, '\C' . a:regex, s)
+    if e >= 0 && f >= e
+      return -1
+    endif
     if f >= 0
       let attr = synIDattr(synID(a:lnum,f+1,1),"name")
-      if attr =~ s:skipPatterns
+      if attr =~# s:skipPatterns
         let s = f+1
         continue
       endif
@@ -39,15 +43,17 @@ function JuliaMatch(lnum, str, regex, st)
   return f
 endfunction
 
-function GetJuliaNestingStruct(lnum)
+function GetJuliaNestingStruct(lnum, ...)
   " Auxiliary function to inspect the block structure of a line
   let line = getline(a:lnum)
-  let s = 0
+  let s = a:0 > 0 ? a:1 : 0
+  let e = a:0 > 1 ? a:2 : -1
   let blocks_stack = []
   let num_closed_blocks = 0
+  let tt = get(b:, 'julia_syntax_version', 10) == 6 ? '\|\%(\%(abstract\|primitive\)\s\+\)\@<!type' : ''
   while 1
-    let fb = JuliaMatch(a:lnum, line, '@\@<!\<\%(if\|else\%(if\)\=\|while\|for\|try\|catch\|finally\|function\|macro\|begin\|type\|immutable\|let\|\%(bare\)\?module\|quote\|do\)\>', s)
-    let fe = JuliaMatch(a:lnum, line, '@\@<!\<end\>', s)
+    let fb = JuliaMatch(a:lnum, line, '@\@<!\<\%(if\|else\%(if\)\?\|while\|for\|try\|catch\|finally\|\%(staged\)\?function\|macro\|begin\|mutable\s\+struct\|\%(mutable\s\+\)\@<!struct\|\%(abstract\|primitive\)\s\+type\|immutable\|let\|\%(bare\)\?module\|quote\|do'.tt.'\)\>', s, e)
+    let fe = JuliaMatch(a:lnum, line, '@\@<!\<end\>', s, e)
 
     if fb < 0 && fe < 0
       " No blocks found
@@ -79,7 +85,7 @@ function GetJuliaNestingStruct(lnum)
       let i = JuliaMatch(a:lnum, line, '@\@<!\<else\>', s)
       if i >= 0 && i == fb
         let s = i+1
-        if len(blocks_stack) > 0 && blocks_stack[-1] =~ '\<\%(else\)\=if\>'
+        if len(blocks_stack) > 0 && blocks_stack[-1] =~# '\<\%(else\)\=if\>'
           let blocks_stack[-1] = 'else'
         else
           call add(blocks_stack, 'else')
@@ -128,9 +134,13 @@ function GetJuliaNestingStruct(lnum)
         continue
       endif
 
-      let i = JuliaMatch(a:lnum, line, '@\@<!\<\%(while\|for\|function\|macro\|begin\|type\|immutable\|let\|quote\|do\)\>', s)
+      let i = JuliaMatch(a:lnum, line, '@\@<!\<\%(while\|for\|\%(staged\)\?function\|macro\|begin\|\%(mutable\s\+\)\?struct\|\%(abstract\|primitive\)\s\+type\|immutable\|let\|quote\|do'.tt.'\)\>', s)
       if i >= 0 && i == fb
-        let s = i+1
+        if match(line, '\C\<\%(mutable\|abstract\|primitive\)', i) != -1
+          let s = i+11
+        else
+          let s = i+1
+        endif
         call add(blocks_stack, 'other')
         continue
       endif
@@ -158,33 +168,212 @@ function GetJuliaNestingStruct(lnum)
   return [num_open_blocks, num_closed_blocks]
 endfunction
 
-function GetJuliaIndent()
-  let s:save_ignorecase = &ignorecase
-  set noignorecase
+function GetJuliaNestingBrackets(lnum, c)
+  " Auxiliary function to inspect the brackets structure of a line
+  let line = getline(a:lnum)[0 : (a:c - 1)]
+  let s = 0
+  let brackets_stack = []
+  let last_closed_bracket = -1
+  while 1
+    let fb = JuliaMatch(a:lnum, line, '[([{]', s)
+    let fe = JuliaMatch(a:lnum, line, '[])}]', s)
 
+    if fb < 0 && fe < 0
+      " No brackets found
+      break
+    end
+
+    if fb >= 0 && (fb < fe || fe < 0)
+      " The first occurrence is an opening bracket
+
+      let i = JuliaMatch(a:lnum, line, '(', s)
+      if i >= 0 && i == fb
+        let s = i+1
+        call add(brackets_stack, ['par',i])
+        continue
+      endif
+
+      let i = JuliaMatch(a:lnum, line, '\[', s)
+      if i >= 0 && i == fb
+        let s = i+1
+        call add(brackets_stack, ['sqbra',i])
+        continue
+      endif
+
+      let i = JuliaMatch(a:lnum, line, '{', s)
+      if i >= 0 && i == fb
+        let s = i+1
+        call add(brackets_stack, ['curbra',i])
+        continue
+      endif
+
+      " Note: it should be impossible to get here
+      break
+
+    else
+      " The first occurrence is a closing bracket
+
+      let i = JuliaMatch(a:lnum, line, ')', s)
+      if i >= 0 && i == fe
+        let s = i+1
+        if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'par'
+          call remove(brackets_stack, -1)
+        else
+          let last_closed_bracket = i + 1
+        endif
+        continue
+      endif
+
+      let i = JuliaMatch(a:lnum, line, ']', s)
+      if i >= 0 && i == fe
+        let s = i+1
+        if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'sqbra'
+          call remove(brackets_stack, -1)
+        else
+          let last_closed_bracket = i + 1
+        endif
+        continue
+      endif
+
+      let i = JuliaMatch(a:lnum, line, '}', s)
+      if i >= 0 && i == fe
+        let s = i+1
+        if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'curbra'
+          call remove(brackets_stack, -1)
+        else
+          let last_closed_bracket = i + 1
+        endif
+        continue
+      endif
+
+      " Note: it should be impossible to get here
+      break
+
+    endif
+
+    " Note: it should be impossible to get here
+    break
+  endwhile
+  let first_open_bracket = -1
+  let last_open_bracket = -1
+  if len(brackets_stack) > 0
+    let first_open_bracket = brackets_stack[0][1]
+    let last_open_bracket = brackets_stack[-1][1]
+  endif
+  return [first_open_bracket, last_open_bracket, last_closed_bracket]
+endfunction
+
+let s:bracketBlocks = '\<julia\%(\%(\%(Printf\)\?Par\|SqBra\|CurBra\)Block\|ParBlockInRange\|StringVars\%(Par\|SqBra\|CurBra\)\|Dollar\%(Par\|SqBra\)\|QuotedParBlockS\?\)\>'
+
+function IsInBrackets(lnum, c)
+  let stack = map(synstack(a:lnum, a:c), 'synIDattr(v:val, "name")')
+  call filter(stack, 'v:val =~# s:bracketBlocks')
+  return len(stack) > 0
+endfunction
+
+" Auxiliary function to find a line which does not start in the middle of a
+" multiline bracketed expression, to be used as reference for block
+" indentation.
+function LastBlockIndent(lnum)
+  let lnum = a:lnum
+  let ind = 0
+  while lnum > 0
+    let ind = indent(lnum)
+    if ind == 0
+      return [lnum, 0]
+    endif
+    if !IsInBrackets(lnum, 1)
+      break
+    endif
+    let lnum = prevnonblank(lnum - 1)
+  endwhile
+  return [max([lnum,1]), ind]
+endfunction
+
+function GetJuliaIndent()
   " Find a non-blank line above the current line.
   let lnum = prevnonblank(v:lnum - 1)
 
   " At the start of the file use zero indent.
   if lnum == 0
-    let &ignorecase = s:save_ignorecase
-    unlet s:save_ignorecase
     return 0
   endif
 
-  let ind = indent(lnum)
+  let ind = -1
+  let st = -1
+  let lim = -1
 
-  " Analyse previous line
-  let [num_open_blocks, num_closed_blocks] = GetJuliaNestingStruct(lnum)
+  " Multiline bracketed expressions take precedence
+  let c = len(getline(lnum)) + 1
+  while IsInBrackets(lnum, c)
+    let [first_open_bracket, last_open_bracket, last_closed_bracket] = GetJuliaNestingBrackets(lnum, c)
+
+    " First scenario: the previous line has a hanging open bracket:
+    " set the indentation to match the opening bracket (plus an extra space)
+    if last_open_bracket != -1
+      let st = last_open_bracket
+      let ind = virtcol([lnum, st + 1])
+
+    " Second scenario: some multiline bracketed expression was closed in the
+    " previous line. But since we know we are still in a bracketed expression,
+    " we need to find the line where the bracket was open
+    elseif last_closed_bracket != -1 " && exists("loaded_matchit")
+      " we use the % command to skip back (this is buggy without matchit, and
+      " is potentially a disaster if % got remapped)
+      call cursor(lnum, last_closed_bracket)
+      normal %
+      if line(".") == lnum
+        " something wrong here, give up
+        let ind = indent(lnum)
+      else
+        let lnum = line(".")
+        let c = col(".") - 1
+        if c == 0
+          " uhm, give up
+          let ind = 0
+        else
+          " we skipped a bracket set, keep searching for an opening bracket
+          let lim = c
+          continue
+        endif
+      endif
+
+    " Third scenario: nothing special, or matchit not available: keep the indentation
+    else
+      let ind = indent(lnum)
+    endif
+
+    " In case the current line starts with a closing bracket, we align it with
+    " the opening one.
+    if JuliaMatch(v:lnum, getline(v:lnum), '[])}]', indent(v:lnum)) == indent(v:lnum) && ind > 0
+      return ind - 1
+    endif
+
+    break
+  endwhile
+
+  if ind == -1
+    " We are not in a multiline bracketed expression. Thus we look for a
+    " previous line to use as a reference
+    let [lnum,ind] = LastBlockIndent(lnum)
+    let c = len(getline(lnum)) + 1
+    if IsInBrackets(lnum, c)
+      let [first_open_bracket, last_open_bracket, last_closed_bracket] = GetJuliaNestingBrackets(lnum, c)
+      let lim = first_open_bracket
+    endif
+  end
+
+  " Analyse the reference line
+  let [num_open_blocks, num_closed_blocks] = GetJuliaNestingStruct(lnum, st, lim)
 
   " Increase indentation for each newly opened block
-  " in the previous line
+  " in the reference line
   while num_open_blocks > 0
     let ind += &sw
     let num_open_blocks -= 1
   endwhile
 
-  " Analyse current line
+  " Analyse the current line
   let [num_open_blocks, num_closed_blocks] = GetJuliaNestingStruct(v:lnum)
 
   " Decrease indentation for each closed block
@@ -194,8 +383,6 @@ function GetJuliaIndent()
     let num_closed_blocks -= 1
   endwhile
 
-  let &ignorecase = s:save_ignorecase
-  unlet s:save_ignorecase
   return ind
 endfunction
 

indent/markdown.vim

@@ -0,0 +1,79 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'markdown') == -1
+  
+if exists("b:did_indent") | finish | endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetMarkdownIndent()
+setlocal nolisp
+setlocal autoindent
+
+" Automatically continue blockquote on line break
+setlocal formatoptions+=r
+setlocal comments=b:>
+if get(g:, "vim_markdown_auto_insert_bullets", 1)
+    " Do not automatically insert bullets when auto-wrapping with text-width
+    setlocal formatoptions-=c
+    " Accept various markers as bullets
+    setlocal comments+=b:*,b:+,b:-
+endif
+
+" Only define the function once
+if exists("*GetMarkdownIndent") | finish | endif
+
+function! s:IsMkdCode(lnum)
+    let name = synIDattr(synID(a:lnum, 1, 0), 'name')
+    return (name =~ '^mkd\%(Code$\|Snippet\)' || name != '' && name !~ '^\%(mkd\|html\)')
+endfunction
+
+function! s:IsLiStart(line)
+    return a:line !~ '^ *\([*-]\)\%( *\1\)\{2}\%( \|\1\)*$' &&
+      \    a:line =~ '^\s*[*+-] \+'
+endfunction
+
+function! s:IsHeaderLine(line)
+    return a:line =~ '^\s*#'
+endfunction
+
+function! s:IsBlankLine(line)
+    return a:line =~ '^$'
+endfunction
+
+function! s:PrevNonBlank(lnum)
+    let i = a:lnum
+    while i > 1 && s:IsBlankLine(getline(i))
+        let i -= 1
+    endwhile
+    return i
+endfunction
+
+function GetMarkdownIndent()
+    if v:lnum > 2 && s:IsBlankLine(getline(v:lnum - 1)) && s:IsBlankLine(getline(v:lnum - 2))
+        return 0
+    endif
+    let list_ind = get(g:, "vim_markdown_new_list_item_indent", 4)
+    " Find a non-blank line above the current line.
+    let lnum = s:PrevNonBlank(v:lnum - 1)
+    " At the start of the file use zero indent.
+    if lnum == 0 | return 0 | endif
+    let ind = indent(lnum)
+    let line = getline(lnum)    " Last line
+    let cline = getline(v:lnum) " Current line
+    if s:IsLiStart(cline)
+        " Current line is the first line of a list item, do not change indent
+        return indent(v:lnum)
+    elseif s:IsHeaderLine(cline) && !s:IsMkdCode(v:lnum)
+        " Current line is the header, do not indent
+        return 0
+    elseif s:IsLiStart(line)
+        if s:IsMkdCode(lnum)
+            return ind
+        else
+            " Last line is the first line of a list item, increase indent
+            return ind + list_ind
+        end
+    else
+        return ind
+    endif
+endfunction
+
+endif

indent/nix.vim

@@ -11,7 +11,7 @@ endif
 let b:did_indent = 1
 
 setlocal indentexpr=GetNixIndent()
-setlocal indentkeys+=0=then,0=else,0=inherit,*<Return>
+setlocal indentkeys+=0=then,0=else,0=inherit,0=in,*<Return>
 
 if exists("*GetNixIndent")
   finish
@@ -21,6 +21,8 @@ let s:cpo_save = &cpo
 set cpo&vim
 
 let s:skip_syntax = '\%(Comment\|String\)$'
+let s:binding_open = '\%(\<let\>\)'
+let s:binding_close = '\%(\<in\>\)'
 let s:block_open  = '\%({\|[\)'
 let s:block_close = '\%(}\|]\)'
 
@@ -33,10 +35,25 @@ function! GetNixIndent()
     return 0
   endif
 
+  " Skip indentation for single line comments explicitly, in case a
+  " comment was just inserted (eg. visual block mode)
+  if getline(v:lnum) =~ '^\s*#'
+    return indent(v:lnum)
+  endif
+
   if synIDattr(synID(v:lnum, 1, 1), "name") !~ s:skip_syntax
     let current_line = getline(v:lnum)
     let last_line = getline(lnum)
 
+    if current_line =~ '^\s*in\>'
+      let save_cursor = getcurpos()
+      normal ^
+      let bslnum = searchpair(s:binding_open, '', s:binding_close, 'bnW',
+            \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "StringSpecial$"')
+      call setpos('.', save_cursor)
+      return indent(bslnum)
+    endif
+
     if last_line =~ s:block_open . '\s*$'
       let ind += &sw
     endif
@@ -45,11 +62,15 @@ function! GetNixIndent()
       let ind -= &sw
     endif
 
+    if last_line =~ '[(=]$'
+      let ind += &sw
+    endif
+
     if last_line =~ '\<let\s*$'
       let ind += &sw
     endif
 
-    if getline(v:lnum - 1) =~ '^\<in\s*$'
+    if last_line =~ '^\<in\s*$'
       let ind += &sw
     endif
 
@@ -63,7 +84,7 @@ function! GetNixIndent()
 
     let ind = indent(v:lnum)
     let bslnum = searchpair('''''', '', '''''', 'bnW',
-          \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "InterpolationSpecial$"')
+          \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "StringSpecial$"')
 
     if ind <= indent(bslnum)
       let ind = indent(bslnum) + &sw

indent/purescript.vim

@@ -103,7 +103,7 @@ function! GetPurescriptIndent()
     return s
   endif
 
-  if prevline =~ '^\S.*::' && line !~ '^\s*\(\.\|->\|→\|=>\|⇒\)' && !~ '^instance'
+  if prevline =~ '^\S.*::' && line !~ '^\s*\(\.\|->\|→\|=>\|⇒\)' && prevline !~ '^instance'
     " f :: String
     "	-> String
     return 0

indent/python.vim

@@ -1,217 +1,429 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'python') == -1
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'python-ident') == -1
   
 " PEP8 compatible Python indent file
+" Language:         Python
+" Maintainer:       Daniel Hahler <https://daniel.hahler.de/>
+" Prev Maintainer:  Hynek Schlawack <hs@ox.cx>
+" Prev Maintainer:  Eric Mc Sween <em@tomcom.de> (address invalid)
+" Original Author:  David Bustos <bustos@caltech.edu> (address invalid)
+" License:          CC0
+"
+" vim-python-pep8-indent - A nicer Python indentation style for vim.
+" Written in 2004 by David Bustos <bustos@caltech.edu>
+" Maintained from 2004-2005 by Eric Mc Sween <em@tomcom.de>
+" Maintained from 2013 by Hynek Schlawack <hs@ox.cx>
+" Maintained from 2017 by Daniel Hahler <https://daniel.hahler.de/>
+"
+" To the extent possible under law, the author(s) have dedicated all copyright
+" and related and neighboring rights to this software to the public domain
+" worldwide. This software is distributed without any warranty.
+" You should have received a copy of the CC0 Public Domain Dedication along
+" with this software. If not, see
+" <http://creativecommons.org/publicdomain/zero/1.0/>.
+
 " Only load this indent file when no other was loaded.
-if exists("b:did_indent")
+if exists('b:did_indent')
     finish
 endif
 let b:did_indent = 1
 
-setlocal expandtab
 setlocal nolisp
 setlocal autoindent
 setlocal indentexpr=GetPythonPEPIndent(v:lnum)
 setlocal indentkeys=!^F,o,O,<:>,0),0],0},=elif,=except
 
-let s:maxoff = 50
+if !exists('g:python_pep8_indent_multiline_string')
+    let g:python_pep8_indent_multiline_string = 0
+endif
+
+if !exists('g:python_pep8_indent_hang_closing')
+    let g:python_pep8_indent_hang_closing = 0
+endif
+
+let s:block_rules = {
+            \ '^\s*elif\>': ['if', 'elif'],
+            \ '^\s*except\>': ['try', 'except'],
+            \ '^\s*finally\>': ['try', 'except', 'else']
+            \ }
+let s:block_rules_multiple = {
+            \ '^\s*else\>': ['if', 'elif', 'for', 'try', 'except'],
+            \ }
+" Pairs to look for when searching for opening parenthesis.
+" The value is the maximum offset in lines.
+let s:paren_pairs = {'()': 50, '[]': 100, '{}': 1000}
+
+if &filetype ==# 'pyrex' || &filetype ==# 'cython'
+    let b:control_statement = '\v^\s*(class|def|if|while|with|for|except|cdef|cpdef)>'
+else
+    let b:control_statement = '\v^\s*(class|def|if|while|with|for|except)>'
+endif
+let s:stop_statement = '^\s*\(break\|continue\|raise\|return\|pass\)\>'
+
+" Skip strings and comments. Return 1 for chars to skip.
+" jedi* refers to syntax definitions from jedi-vim for call signatures, which
+" are inserted temporarily into the buffer.
+let s:skip_special_chars = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "\\vstring|comment|^pythonbytes%(contents)=$|jedi\\S"'
+
+let s:skip_after_opening_paren = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "\\vcomment|jedi\\S"'
+
+" Also ignore anything concealed.
+" Wrapper around synconcealed for older Vim (7.3.429, used on Travis CI).
+function! s:is_concealed(line, col)
+    let concealed = synconcealed(a:line, a:col)
+    return len(concealed) && concealed[0]
+endfunction
+if has('conceal')
+    let s:skip_special_chars .= '|| s:is_concealed(line("."), col("."))'
+endif
+
+
+let s:skip_search = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "comment"'
+
+" Use 'shiftwidth()' instead of '&sw'.
+" (Since Vim patch 7.3.629, 'shiftwidth' can be set to 0 to follow 'tabstop').
+if exists('*shiftwidth')
+    function! s:sw()
+        return shiftwidth()
+    endfunction
+else
+    function! s:sw()
+        return &shiftwidth
+    endfunction
+endif
 
 " Find backwards the closest open parenthesis/bracket/brace.
-function! s:SearchParensPair()
-  let line = line('.')
-  let col = col('.')
+function! s:find_opening_paren(...)
+    " optional arguments: line and column (defaults to 1) to search around
+    if a:0 > 0
+        let view = winsaveview()
+        call cursor(a:1, a:0 > 1 ? a:2 : 1)
+        let ret = s:find_opening_paren()
+        call winrestview(view)
+        return ret
+    endif
 
-  " Skip strings and comments and don't look too far
-  let skip = "line('.') < " . (line - s:maxoff) . " ? dummy :" .
-        \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? ' .
-        \ '"string\\|comment"'
+    " Return if cursor is in a comment.
+    exe 'if' s:skip_search '| return [0, 0] | endif'
 
-  " Search for parentheses
-  call cursor(line, col)
-  let parlnum = searchpair('(', '', ')', 'bW', skip)
-  let parcol = col('.')
-
-  " Search for brackets
-  call cursor(line, col)
-  let par2lnum = searchpair('\[', '', '\]', 'bW', skip)
-  let par2col = col('.')
-
-  " Search for braces
-  call cursor(line, col)
-  let par3lnum = searchpair('{', '', '}', 'bW', skip)
-  let par3col = col('.')
-
-  " Get the closest match
-  if par2lnum > parlnum || (par2lnum == parlnum && par2col > parcol)
-    let parlnum = par2lnum
-    let parcol = par2col
-  endif
-  if par3lnum > parlnum || (par3lnum == parlnum && par3col > parcol)
-    let parlnum = par3lnum
-    let parcol = par3col
-  endif
-
-  " Put the cursor on the match
-  if parlnum > 0
-    call cursor(parlnum, parcol)
-  endif
-  return parlnum
+    let nearest = [0, 0]
+    for [p, maxoff] in items(s:paren_pairs)
+        let stopline = max([0, line('.') - maxoff, nearest[0]])
+        let next = searchpairpos(
+           \ '\V'.p[0], '', '\V'.p[1], 'bnW', s:skip_special_chars, stopline)
+        if next[0] && (next[0] > nearest[0] || (next[0] == nearest[0] && next[1] > nearest[1]))
+            let nearest = next
+        endif
+    endfor
+    return nearest
 endfunction
 
 " Find the start of a multi-line statement
-function! s:StatementStart(lnum)
-  let lnum = a:lnum
-  while 1
-    if getline(lnum - 1) =~ '\\$'
-      let lnum = lnum - 1
-    else
-      call cursor(lnum, 1)
-      let maybe_lnum = s:SearchParensPair()
-      if maybe_lnum < 1
-        return lnum
-      else
-        let lnum = maybe_lnum
-      endif
-    endif
-  endwhile
+function! s:find_start_of_multiline_statement(lnum)
+    let lnum = a:lnum
+    while lnum > 0
+        if getline(lnum - 1) =~# '\\$'
+            let lnum = prevnonblank(lnum - 1)
+        else
+            let [paren_lnum, _] = s:find_opening_paren(lnum)
+            if paren_lnum < 1
+                return lnum
+            else
+                let lnum = paren_lnum
+            endif
+        endif
+    endwhile
 endfunction
 
-" Find the block starter that matches the current line
-function! s:BlockStarter(lnum, block_start_re)
-  let lnum = a:lnum
-  let maxindent = 10000       " whatever
-  while lnum > 1
-    let lnum = prevnonblank(lnum - 1)
-    if indent(lnum) < maxindent
-      if getline(lnum) =~ a:block_start_re
-        return lnum
-      else
-        let maxindent = indent(lnum)
-        " It's not worth going further if we reached the top level
-        if maxindent == 0
-          return -1
+" Find possible indent(s) of the block starter that matches the current line.
+function! s:find_start_of_block(lnum, types, multiple)
+    let r = []
+    let re = '\V\^\s\*\('.join(a:types, '\|').'\)\>'
+    let lnum = a:lnum
+    let last_indent = indent(lnum) + 1
+    while lnum > 0 && last_indent > 0
+        let indent = indent(lnum)
+        if indent < last_indent
+            if getline(lnum) =~# re
+                if !a:multiple
+                    return [indent]
+                endif
+                if index(r, indent) == -1
+                    let r += [indent]
+                endif
+                let last_indent = indent
+            endif
         endif
-      endif
+        let lnum = prevnonblank(lnum - 1)
+    endwhile
+    return r
+endfunction
+
+" Is "expr" true for every position in "lnum", beginning at "start"?
+" (optionally up to a:1 / 4th argument)
+function! s:match_expr_on_line(expr, lnum, start, ...)
+    let text = getline(a:lnum)
+    let end = a:0 ? a:1 : len(text)
+    if a:start > end
+        return 1
     endif
-  endwhile
-  return -1
+    let save_pos = getpos('.')
+    let r = 1
+    for i in range(a:start, end)
+        call cursor(a:lnum, i)
+        if !(eval(a:expr) || text[i-1] =~# '\s')
+            let r = 0
+            break
+        endif
+    endfor
+    call setpos('.', save_pos)
+    return r
+endfunction
+
+" Line up with open parenthesis/bracket/brace.
+function! s:indent_like_opening_paren(lnum)
+    let [paren_lnum, paren_col] = s:find_opening_paren(a:lnum)
+    if paren_lnum <= 0
+        return -2
+    endif
+    let text = getline(paren_lnum)
+    let base = indent(paren_lnum)
+
+    let nothing_after_opening_paren = s:match_expr_on_line(
+                \ s:skip_after_opening_paren, paren_lnum, paren_col+1)
+    let starts_with_closing_paren = getline(a:lnum) =~# '^\s*[])}]'
+
+    let hang_closing = get(b:, 'python_pep8_indent_hang_closing',
+                \ get(g:, 'python_pep8_indent_hang_closing', 0))
+
+    if nothing_after_opening_paren
+        if starts_with_closing_paren && !hang_closing
+            let res = base
+        else
+            let res = base + s:sw()
+        endif
+    else
+        " Indent to match position of opening paren.
+        let res = paren_col
+    endif
+
+    " If this line is the continuation of a control statement
+    " indent further to distinguish the continuation line
+    " from the next logical line.
+    if text =~# b:control_statement && res == base + s:sw()
+        " But only if not inside parens itself (Flake's E127).
+        let [paren_lnum, _] = s:find_opening_paren(paren_lnum)
+        if paren_lnum <= 0
+            return res + s:sw()
+        endif
+    endif
+    return res
+endfunction
+
+" Match indent of first block of this type.
+function! s:indent_like_block(lnum)
+    let text = getline(a:lnum)
+    for [multiple, block_rules] in [
+                \ [0, s:block_rules],
+                \ [1, s:block_rules_multiple]]
+        for [line_re, blocks] in items(block_rules)
+            if text !~# line_re
+                continue
+            endif
+
+            let indents = s:find_start_of_block(a:lnum - 1, blocks, multiple)
+            if !len(indents)
+                return -1
+            endif
+            if len(indents) == 1
+                return indents[0]
+            endif
+
+            " Multiple valid indents, e.g. for 'else' with both try and if.
+            let indent = indent(a:lnum)
+            if index(indents, indent) != -1
+                " The indent is valid, keep it.
+                return indent
+            endif
+            " Fallback to the first/nearest one.
+            return indents[0]
+        endfor
+    endfor
+    return -2
+endfunction
+
+function! s:indent_like_previous_line(lnum)
+    let lnum = prevnonblank(a:lnum - 1)
+
+    " No previous line, keep current indent.
+    if lnum < 1
+      return -1
+    endif
+
+    let text = getline(lnum)
+    let start = s:find_start_of_multiline_statement(lnum)
+    let base = indent(start)
+    let current = indent(a:lnum)
+
+    " Jump to last character in previous line.
+    call cursor(lnum, len(text))
+    let ignore_last_char = eval(s:skip_special_chars)
+
+    " Search for final colon that is not inside something to be ignored.
+    while 1
+        let curpos = getpos('.')[2]
+        if curpos == 1 | break | endif
+        if eval(s:skip_special_chars) || text[curpos-1] =~# '\s'
+            normal! h
+            continue
+        elseif text[curpos-1] ==# ':'
+            return base + s:sw()
+        endif
+        break
+    endwhile
+
+    if text =~# '\\$' && !ignore_last_char
+        " If this line is the continuation of a control statement
+        " indent further to distinguish the continuation line
+        " from the next logical line.
+        if getline(start) =~# b:control_statement
+            return base + s:sw() * 2
+        endif
+
+        " Nest (other) explicit continuations only one level deeper.
+        return base + s:sw()
+    endif
+
+    let empty = getline(a:lnum) =~# '^\s*$'
+
+    " Current and prev line are empty, next is not -> indent like next.
+    if empty && a:lnum > 1 &&
+          \ (getline(a:lnum - 1) =~# '^\s*$') &&
+          \ !(getline(a:lnum + 1) =~# '^\s*$')
+      return indent(a:lnum + 1)
+    endif
+
+    " If the previous statement was a stop-execution statement or a pass
+    if getline(start) =~# s:stop_statement
+        " Remove one level of indentation if the user hasn't already dedented
+        if empty || current > base - s:sw()
+            return base - s:sw()
+        endif
+        " Otherwise, trust the user
+        return -1
+    endif
+
+    if !empty && s:is_dedented_already(current, base)
+        return -1
+    endif
+
+    " In all other cases, line up with the start of the previous statement.
+    return base
+endfunction
+
+" If this line is dedented and the number of indent spaces is valid
+" (multiple of the indentation size), trust the user.
+function! s:is_dedented_already(current, base)
+    let dedent_size = a:current - a:base
+    return (dedent_size < 0 && a:current % s:sw() == 0) ? 1 : 0
+endfunction
+
+" Is the syntax at lnum (and optionally cnum) a python string?
+function! s:is_python_string(lnum, ...)
+    let line = getline(a:lnum)
+    if a:0
+      let cols = type(a:1) != type([]) ? [a:1] : a:1
+    else
+      let cols = range(1, max([1, len(line)]))
+    endif
+    for cnum in cols
+        if match(map(synstack(a:lnum, cnum),
+                    \ "synIDattr(v:val, 'name')"), 'python\S*String') == -1
+            return 0
+        end
+    endfor
+    return 1
 endfunction
 
 function! GetPythonPEPIndent(lnum)
-  let scol = col('.')
-
-  " First line has indent 0
-  if a:lnum == 1
-    return 0
-  endif
-
-  " If we can find an open parenthesis/bracket/brace, line up with it.
-  call cursor(a:lnum, 1)
-  let parlnum = s:SearchParensPair()
-  if parlnum > 0
-    let parcol = col('.')
-    let matches = matchlist(getline(a:lnum), '^\(\s*\)[])}]')
-    if len(matches) == 0
-      let closing_paren = 0
-      let closing_paren_pos = 0
-    else
-      let closing_paren = 1
-      let closing_paren_pos = len(matches[1])
+    " First line has indent 0
+    if a:lnum == 1
+        return 0
     endif
-    if match(getline(parlnum), '[([{]\s*$', parcol - 1) != -1
-      if closing_paren
-        return indent(parlnum)
-      else
-        return indent(parlnum) + &shiftwidth
-      endif
-    elseif a:lnum - 1 != parlnum
-      if closing_paren && closing_paren_pos > scol
-        return indent(parlnum)
-      else
-        let lastindent = match(getline(a:lnum - 1), '\S')
-        if lastindent != -1 && lastindent < parcol
-          return lastindent
+
+    let line = getline(a:lnum)
+    let prevline = getline(a:lnum-1)
+
+    " Multilinestrings: continous, docstring or starting.
+    if s:is_python_string(a:lnum-1, max([1, len(prevline)]))
+                \ && (s:is_python_string(a:lnum, 1)
+                \     || match(line, '^\%("""\|''''''\)') != -1)
+
+        " Indent closing quotes as the line with the opening ones.
+        let match_quotes = match(line, '^\s*\zs\%("""\|''''''\)')
+        if match_quotes != -1
+            " closing multiline string
+            let quotes = line[match_quotes:(match_quotes+2)]
+            let pairpos = searchpairpos(quotes, '', quotes, 'b')
+            if pairpos[0] != 0
+                return indent(pairpos[0])
+            else
+                " TODO: test to cover this!
+            endif
         endif
-      endif
+
+        if s:is_python_string(a:lnum-1)
+            " Previous line is (completely) a string: keep current indent.
+            return -1
+        endif
+
+        if match(prevline, '^\s*\%("""\|''''''\)') != -1
+            " docstring.
+            return indent(a:lnum-1)
+        endif
+
+        let indent_multi = get(b:, 'python_pep8_indent_multiline_string',
+                    \ get(g:, 'python_pep8_indent_multiline_string', 0))
+        if match(prevline, '\v%("""|'''''')$') != -1
+            " Opening multiline string, started in previous line.
+            if (&autoindent && indent(a:lnum) == indent(a:lnum-1))
+                        \ || match(line, '\v^\s+$') != -1
+                " <CR> with empty line or to split up 'foo("""bar' into
+                " 'foo("""' and 'bar'.
+                if indent_multi == -2
+                    return indent(a:lnum-1) + s:sw()
+                endif
+                return indent_multi
+            endif
+        endif
+
+        " Keep existing indent.
+        if match(line, '\v^\s*\S') != -1
+            return -1
+        endif
+
+        if indent_multi != -2
+            return indent_multi
+        endif
+
+        return s:indent_like_opening_paren(a:lnum)
     endif
 
-    " If we line up with an opening column there is a special case
-    " we want to handle: a docstring as argument.  In that case we
-    " don't want to line up with the paren but with the statement
-    " imagine foo(doc=""" as example
-    echo getline(parlnum)
-    if match(getline(parlnum), '\("""\|' . "'''" . '\)\s*$') != -1
-      return indent(parlnum)
+    " Parens: If we can find an open parenthesis/bracket/brace, line up with it.
+    let indent = s:indent_like_opening_paren(a:lnum)
+    if indent >= -1
+        return indent
     endif
 
-    return parcol
-  endif
-
-  " Examine this line
-  let thisline = getline(a:lnum)
-  let thisindent = indent(a:lnum)
-
-  " If the line starts with 'elif' or 'else', line up with 'if' or 'elif'
-  if thisline =~ '^\s*\(elif\|else\)\>'
-    let bslnum = s:BlockStarter(a:lnum, '^\s*\(if\|elif\)\>')
-    if bslnum > 0
-      return indent(bslnum)
-    else
-      return -1
+    " Blocks: Match indent of first block of this type.
+    let indent = s:indent_like_block(a:lnum)
+    if indent >= -1
+        return indent
     endif
-  endif
 
-  " If the line starts with 'except' or 'finally', line up with 'try'
-  " or 'except'
-  if thisline =~ '^\s*\(except\|finally\)\>'
-    let bslnum = s:BlockStarter(a:lnum, '^\s*\(try\|except\)\>')
-    if bslnum > 0
-      return indent(bslnum)
-    else
-      return -1
-    endif
-  endif
-
-  " Examine previous line
-  let plnum = a:lnum - 1
-  let pline = getline(plnum)
-  let sslnum = s:StatementStart(plnum)
-
-  " If the previous line is blank, keep the same indentation
-  if pline =~ '^\s*$'
-    return -1
-  endif
-
-  " If this line is explicitly joined, try to find an indentation that looks
-  " good.
-  if pline =~ '\\$'
-    let compound_statement = '^\s*\(if\|while\|from\|import\|for\s.*\sin\|except\)\s*'
-    let maybe_indent = matchend(getline(sslnum), compound_statement)
-    if maybe_indent != -1
-      return maybe_indent
-    else
-      return indent(sslnum) + &sw * 2
-    endif
-  endif
-
-  " If the previous line ended with a colon and is not a comment, indent
-  " relative to statement start.
-  if pline =~ '^[^#]*:\s*\(#.*\)\?$'
-    return indent(sslnum) + &sw
-  endif
-
-  " If the previous line was a stop-execution statement or a pass
-  if getline(sslnum) =~ '^\s*\(break\|continue\|raise\|return\|pass\)\>'
-    " See if the user has already dedented
-    if indent(a:lnum) > indent(sslnum) - &sw
-      " If not, recommend one dedent
-      return indent(sslnum) - &sw
-    endif
-    " Otherwise, trust the user
-    return -1
-  endif
-
-  " In all other cases, line up with the start of the previous statement.
-  return indent(sslnum)
+    return s:indent_like_previous_line(a:lnum)
 endfunction
 
 endif

indent/ruby.vim

@@ -69,7 +69,7 @@ let s:skip_expr =
 let s:ruby_indent_keywords =
       \ '^\s*\zs\<\%(module\|class\|if\|for' .
       \   '\|while\|until\|else\|elsif\|case\|when\|unless\|begin\|ensure\|rescue' .
-      \   '\|\%(public\|protected\|private\)\=\s*def\):\@!\>' .
+      \   '\|\%(\K\k*[!?]\?\)\=\s*def\):\@!\>' .
       \ '\|\%([=,*/%+-]\|<<\|>>\|:\s\)\s*\zs' .
       \    '\<\%(if\|for\|while\|until\|case\|unless\|begin\):\@!\>'
 
@@ -83,7 +83,7 @@ let s:ruby_deindent_keywords =
 let s:end_start_regex =
       \ '\C\%(^\s*\|[=,*/%+\-|;{]\|<<\|>>\|:\s\)\s*\zs' .
       \ '\<\%(module\|class\|if\|for\|while\|until\|case\|unless\|begin' .
-      \   '\|\%(public\|protected\|private\)\=\s*def\):\@!\>' .
+      \   '\|\%(\K\k*[!?]\?\)\=\s*def\):\@!\>' .
       \ '\|\%(^\|[^.:@$]\)\@<=\<do:\@!\>'
 
 " Regex that defines the middle-match for the 'end' keyword.
@@ -195,8 +195,29 @@ function! GetRubyIndent(...) abort
 
   " 2.3. Work on the previous line. {{{2
   " -------------------------------
+
+  " Special case: we don't need the real s:PrevNonBlankNonString for an empty
+  " line inside a string. And that call can be quite expensive in that
+  " particular situation.
   let indent_callback_names = [
         \ 's:EmptyInsideString',
+        \ ]
+
+  for callback_name in indent_callback_names
+"    Decho "Running: ".callback_name
+    let indent = call(function(callback_name), [indent_info])
+
+    if indent >= 0
+"      Decho "Match: ".callback_name." indent=".indent." info=".string(indent_info)
+      return indent
+    endif
+  endfor
+
+  " Previous line number
+  let indent_info.plnum = s:PrevNonBlankNonString(indent_info.clnum - 1)
+  let indent_info.pline = getline(indent_info.plnum)
+
+  let indent_callback_names = [
         \ 's:StartOfFile',
         \ 's:AfterAccessModifier',
         \ 's:ContinuedLine',
@@ -208,10 +229,6 @@ function! GetRubyIndent(...) abort
         \ 's:AfterIndentKeyword',
         \ ]
 
-  " Previous line number
-  let indent_info.plnum = s:PrevNonBlankNonString(indent_info.clnum - 1)
-  let indent_info.pline = getline(indent_info.plnum)
-
   for callback_name in indent_callback_names
 "    Decho "Running: ".callback_name
     let indent = call(function(callback_name), [indent_info])
@@ -389,12 +406,17 @@ function! s:LeadingOperator(cline_info) abort
 endfunction
 
 function! s:EmptyInsideString(pline_info) abort
-  " If the line is empty and inside a string (plnum would not be the real
-  " prevnonblank in that case), use the previous line's indent
+  " If the line is empty and inside a string (the previous line is a string,
+  " too), use the previous line's indent
   let info = a:pline_info
 
-  if info.cline =~ '^\s*$' && info.plnum != prevnonblank(info.clnum - 1)
-    return indent(prevnonblank(info.clnum))
+  let plnum = prevnonblank(info.clnum - 1)
+  let pline = getline(plnum)
+
+  if info.cline =~ '^\s*$'
+        \ && s:IsInStringOrComment(plnum, 1)
+        \ && s:IsInStringOrComment(plnum, strlen(pline))
+    return indent(plnum)
   endif
   return -1
 endfunction

indent/rust.vim

@@ -3,17 +3,17 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 " Vim indent file
 " Language:         Rust
 " Author:           Chris Morgan <me@chrismorgan.info>
-" Last Change:      2017 Mar 21
+" Last Change:      2018 Jan 10
 " For bugs, patches and license go to https://github.com/rust-lang/rust.vim
 
 " Only load this indent file when no other was loaded.
 if exists("b:did_indent")
-	finish
+    finish
 endif
 let b:did_indent = 1
 
 setlocal cindent
-setlocal cinoptions=L0,(0,Ws,J1,j1
+setlocal cinoptions=L0,(0,Ws,J1,j1,m1
 setlocal cinkeys=0{,0},!^F,o,O,0[,0]
 " Don't think cinwords will actually do anything at all... never mind
 setlocal cinwords=for,if,else,while,loop,impl,mod,unsafe,trait,struct,enum,fn,extern,macro
@@ -28,190 +28,196 @@ setlocal indentexpr=GetRustIndent(v:lnum)
 
 " Only define the function once.
 if exists("*GetRustIndent")
-	finish
+    finish
 endif
 
+" vint: -ProhibitAbbreviationOption
 let s:save_cpo = &cpo
 set cpo&vim
+" vint: +ProhibitAbbreviationOption
 
 " Come here when loading the script the first time.
 
 function! s:get_line_trimmed(lnum)
-	" Get the line and remove a trailing comment.
-	" Use syntax highlighting attributes when possible.
-	" NOTE: this is not accurate; /* */ or a line continuation could trick it
-	let line = getline(a:lnum)
-	let line_len = strlen(line)
-	if has('syntax_items')
-		" If the last character in the line is a comment, do a binary search for
-		" the start of the comment.  synID() is slow, a linear search would take
-		" too long on a long line.
-		if synIDattr(synID(a:lnum, line_len, 1), "name") =~ 'Comment\|Todo'
-			let min = 1
-			let max = line_len
-			while min < max
-				let col = (min + max) / 2
-				if synIDattr(synID(a:lnum, col, 1), "name") =~ 'Comment\|Todo'
-					let max = col
-				else
-					let min = col + 1
-				endif
-			endwhile
-			let line = strpart(line, 0, min - 1)
-		endif
-		return substitute(line, "\s*$", "", "")
-	else
-		" Sorry, this is not complete, nor fully correct (e.g. string "//").
-		" Such is life.
-		return substitute(line, "\s*//.*$", "", "")
-	endif
+    " Get the line and remove a trailing comment.
+    " Use syntax highlighting attributes when possible.
+    " NOTE: this is not accurate; /* */ or a line continuation could trick it
+    let line = getline(a:lnum)
+    let line_len = strlen(line)
+    if has('syntax_items')
+        " If the last character in the line is a comment, do a binary search for
+        " the start of the comment.  synID() is slow, a linear search would take
+        " too long on a long line.
+        if synIDattr(synID(a:lnum, line_len, 1), "name") =~? 'Comment\|Todo'
+            let min = 1
+            let max = line_len
+            while min < max
+                let col = (min + max) / 2
+                if synIDattr(synID(a:lnum, col, 1), "name") =~? 'Comment\|Todo'
+                    let max = col
+                else
+                    let min = col + 1
+                endif
+            endwhile
+            let line = strpart(line, 0, min - 1)
+        endif
+        return substitute(line, "\s*$", "", "")
+    else
+        " Sorry, this is not complete, nor fully correct (e.g. string "//").
+        " Such is life.
+        return substitute(line, "\s*//.*$", "", "")
+    endif
 endfunction
 
 function! s:is_string_comment(lnum, col)
-	if has('syntax_items')
-		for id in synstack(a:lnum, a:col)
-			let synname = synIDattr(id, "name")
-			if synname == "rustString" || synname =~ "^rustComment"
-				return 1
-			endif
-		endfor
-	else
-		" without syntax, let's not even try
-		return 0
-	endif
+    if has('syntax_items')
+        for id in synstack(a:lnum, a:col)
+            let synname = synIDattr(id, "name")
+            if synname ==# "rustString" || synname =~# "^rustComment"
+                return 1
+            endif
+        endfor
+    else
+        " without syntax, let's not even try
+        return 0
+    endif
 endfunction
 
 function GetRustIndent(lnum)
 
-	" Starting assumption: cindent (called at the end) will do it right
-	" normally. We just want to fix up a few cases.
+    " Starting assumption: cindent (called at the end) will do it right
+    " normally. We just want to fix up a few cases.
 
-	let line = getline(a:lnum)
+    let line = getline(a:lnum)
 
-	if has('syntax_items')
-		let synname = synIDattr(synID(a:lnum, 1, 1), "name")
-		if synname == "rustString"
-			" If the start of the line is in a string, don't change the indent
-			return -1
-		elseif synname =~ '\(Comment\|Todo\)'
-					\ && line !~ '^\s*/\*'  " not /* opening line
-			if synname =~ "CommentML" " multi-line
-				if line !~ '^\s*\*' && getline(a:lnum - 1) =~ '^\s*/\*'
-					" This is (hopefully) the line after a /*, and it has no
-					" leader, so the correct indentation is that of the
-					" previous line.
-					return GetRustIndent(a:lnum - 1)
-				endif
-			endif
-			" If it's in a comment, let cindent take care of it now. This is
-			" for cases like "/*" where the next line should start " * ", not
-			" "* " as the code below would otherwise cause for module scope
-			" Fun fact: "  /*\n*\n*/" takes two calls to get right!
-			return cindent(a:lnum)
-		endif
-	endif
+    if has('syntax_items')
+        let synname = synIDattr(synID(a:lnum, 1, 1), "name")
+        if synname ==# "rustString"
+            " If the start of the line is in a string, don't change the indent
+            return -1
+        elseif synname =~? '\(Comment\|Todo\)'
+                    \ && line !~# '^\s*/\*'  " not /* opening line
+            if synname =~? "CommentML" " multi-line
+                if line !~# '^\s*\*' && getline(a:lnum - 1) =~# '^\s*/\*'
+                    " This is (hopefully) the line after a /*, and it has no
+                    " leader, so the correct indentation is that of the
+                    " previous line.
+                    return GetRustIndent(a:lnum - 1)
+                endif
+            endif
+            " If it's in a comment, let cindent take care of it now. This is
+            " for cases like "/*" where the next line should start " * ", not
+            " "* " as the code below would otherwise cause for module scope
+            " Fun fact: "  /*\n*\n*/" takes two calls to get right!
+            return cindent(a:lnum)
+        endif
+    endif
 
-	" cindent gets second and subsequent match patterns/struct members wrong,
-	" as it treats the comma as indicating an unfinished statement::
-	"
-	" match a {
-	"     b => c,
-	"         d => e,
-	"         f => g,
-	" };
+    " cindent gets second and subsequent match patterns/struct members wrong,
+    " as it treats the comma as indicating an unfinished statement::
+    "
+    " match a {
+    "     b => c,
+    "         d => e,
+    "         f => g,
+    " };
 
-	" Search backwards for the previous non-empty line.
-	let prevlinenum = prevnonblank(a:lnum - 1)
-	let prevline = s:get_line_trimmed(prevlinenum)
-	while prevlinenum > 1 && prevline !~ '[^[:blank:]]'
-		let prevlinenum = prevnonblank(prevlinenum - 1)
-		let prevline = s:get_line_trimmed(prevlinenum)
-	endwhile
+    " Search backwards for the previous non-empty line.
+    let prevlinenum = prevnonblank(a:lnum - 1)
+    let prevline = s:get_line_trimmed(prevlinenum)
+    while prevlinenum > 1 && prevline !~# '[^[:blank:]]'
+        let prevlinenum = prevnonblank(prevlinenum - 1)
+        let prevline = s:get_line_trimmed(prevlinenum)
+    endwhile
 
-	" Handle where clauses nicely: subsequent values should line up nicely.
-	if prevline[len(prevline) - 1] == ","
-				\ && prevline =~# '^\s*where\s'
-		return indent(prevlinenum) + 6
-	endif
+    " Handle where clauses nicely: subsequent values should line up nicely.
+    if prevline[len(prevline) - 1] ==# ","
+                \ && prevline =~# '^\s*where\s'
+        return indent(prevlinenum) + 6
+    endif
 
-	if prevline[len(prevline) - 1] == ","
-				\ && s:get_line_trimmed(a:lnum) !~ '^\s*[\[\]{}]'
-				\ && prevline !~ '^\s*fn\s'
-				\ && prevline !~ '([^()]\+,$'
-				\ && s:get_line_trimmed(a:lnum) !~ '^\s*\S\+\s*=>'
-		" Oh ho! The previous line ended in a comma! I bet cindent will try to
-		" take this too far... For now, let's normally use the previous line's
-		" indent.
+    if prevline[len(prevline) - 1] ==# ","
+                \ && s:get_line_trimmed(a:lnum) !~# '^\s*[\[\]{}]'
+                \ && prevline !~# '^\s*fn\s'
+                \ && prevline !~# '([^()]\+,$'
+                \ && s:get_line_trimmed(a:lnum) !~# '^\s*\S\+\s*=>'
+        " Oh ho! The previous line ended in a comma! I bet cindent will try to
+        " take this too far... For now, let's normally use the previous line's
+        " indent.
 
-		" One case where this doesn't work out is where *this* line contains
-		" square or curly brackets; then we normally *do* want to be indenting
-		" further.
-		"
-		" Another case where we don't want to is one like a function
-		" definition with arguments spread over multiple lines:
-		"
-		" fn foo(baz: Baz,
-		"        baz: Baz) // <-- cindent gets this right by itself
-		"
-		" Another case is similar to the previous, except calling a function
-		" instead of defining it, or any conditional expression that leaves
-		" an open paren:
-		"
-		" foo(baz,
-		"     baz);
-		"
-		" if baz && (foo ||
-		"            bar) {
-		"
-		" Another case is when the current line is a new match arm.
-		"
-		" There are probably other cases where we don't want to do this as
-		" well. Add them as needed.
-		return indent(prevlinenum)
-	endif
+        " One case where this doesn't work out is where *this* line contains
+        " square or curly brackets; then we normally *do* want to be indenting
+        " further.
+        "
+        " Another case where we don't want to is one like a function
+        " definition with arguments spread over multiple lines:
+        "
+        " fn foo(baz: Baz,
+        "        baz: Baz) // <-- cindent gets this right by itself
+        "
+        " Another case is similar to the previous, except calling a function
+        " instead of defining it, or any conditional expression that leaves
+        " an open paren:
+        "
+        " foo(baz,
+        "     baz);
+        "
+        " if baz && (foo ||
+        "            bar) {
+        "
+        " Another case is when the current line is a new match arm.
+        "
+        " There are probably other cases where we don't want to do this as
+        " well. Add them as needed.
+        return indent(prevlinenum)
+    endif
 
-	if !has("patch-7.4.355")
-		" cindent before 7.4.355 doesn't do the module scope well at all; e.g.::
-		"
-		" static FOO : &'static [bool] = [
-		" true,
-		"	 false,
-		"	 false,
-		"	 true,
-		"	 ];
-		"
-		"	 uh oh, next statement is indented further!
+    if !has("patch-7.4.355")
+        " cindent before 7.4.355 doesn't do the module scope well at all; e.g.::
+        "
+        " static FOO : &'static [bool] = [
+        " true,
+        "	 false,
+        "	 false,
+        "	 true,
+        "	 ];
+        "
+        "	 uh oh, next statement is indented further!
 
-		" Note that this does *not* apply the line continuation pattern properly;
-		" that's too hard to do correctly for my liking at present, so I'll just
-		" start with these two main cases (square brackets and not returning to
-		" column zero)
+        " Note that this does *not* apply the line continuation pattern properly;
+        " that's too hard to do correctly for my liking at present, so I'll just
+        " start with these two main cases (square brackets and not returning to
+        " column zero)
 
-		call cursor(a:lnum, 1)
-		if searchpair('{\|(', '', '}\|)', 'nbW',
-					\ 's:is_string_comment(line("."), col("."))') == 0
-			if searchpair('\[', '', '\]', 'nbW',
-						\ 's:is_string_comment(line("."), col("."))') == 0
-				" Global scope, should be zero
-				return 0
-			else
-				" At the module scope, inside square brackets only
-				"if getline(a:lnum)[0] == ']' || search('\[', '', '\]', 'nW') == a:lnum
-				if line =~ "^\\s*]"
-					" It's the closing line, dedent it
-					return 0
-				else
-					return &shiftwidth
-				endif
-			endif
-		endif
-	endif
+        call cursor(a:lnum, 1)
+        if searchpair('{\|(', '', '}\|)', 'nbW',
+                    \ 's:is_string_comment(line("."), col("."))') == 0
+            if searchpair('\[', '', '\]', 'nbW',
+                        \ 's:is_string_comment(line("."), col("."))') == 0
+                " Global scope, should be zero
+                return 0
+            else
+                " At the module scope, inside square brackets only
+                "if getline(a:lnum)[0] == ']' || search('\[', '', '\]', 'nW') == a:lnum
+                if line =~# "^\\s*]"
+                    " It's the closing line, dedent it
+                    return 0
+                else
+                    return &shiftwidth
+                endif
+            endif
+        endif
+    endif
 
-	" Fall back on cindent, which does it mostly right
-	return cindent(a:lnum)
+    " Fall back on cindent, which does it mostly right
+    return cindent(a:lnum)
 endfunction
 
+" vint: -ProhibitAbbreviationOption
 let &cpo = s:save_cpo
 unlet s:save_cpo
+" vint: +ProhibitAbbreviationOption
+
+" vim: set et sw=4 sts=4 ts=8:
 
 endif

indent/slime.vim

@@ -0,0 +1,79 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'slime') == -1
+  
+" Vim indent file
+" Language:	Slime
+
+if exists("b:did_indent")
+  finish
+endif
+runtime! indent/ruby.vim
+unlet! b:did_indent
+let b:did_indent = 1
+
+setlocal autoindent sw=2 et
+setlocal indentexpr=GetSlimeIndent()
+setlocal indentkeys=o,O,*<Return>,},],0),!^F,=end,=else,=elsif,=rescue,=ensure,=when
+
+" Only define the function once.
+if exists("*GetSlimeIndent")
+  finish
+endif
+
+let s:attributes = '\%({.\{-\}}\|\[.\{-\}\]\)'
+let s:tag = '\%([%.#][[:alnum:]_-]\+\|'.s:attributes.'\)*[<>]*'
+
+if !exists('g:haml_self_closing_tags')
+  let g:haml_self_closing_tags = 'meta|link|img|hr|br'
+endif
+
+function! GetSlimeIndent()
+  let lnum = prevnonblank(v:lnum-1)
+  if lnum == 0
+    return 0
+  endif
+  let line = substitute(getline(lnum),'\s\+$','','')
+  let cline = substitute(substitute(getline(v:lnum),'\s\+$','',''),'^\s\+','','')
+  let lastcol = strlen(line)
+  let line = substitute(line,'^\s\+','','')
+  let indent = indent(lnum)
+  let cindent = indent(v:lnum)
+  if cline =~# '\v^-\s*%(elsif|else|when)>'
+    let indent = cindent < indent ? cindent : indent - &sw
+  endif
+  let increase = indent + &sw
+  if indent == indent(lnum)
+    let indent = cindent <= indent ? -1 : increase
+  endif
+
+  let group = synIDattr(synID(lnum,lastcol,1),'name')
+
+  if line =~ '^doctype'
+    return indent
+  elseif line =~ '^/\%(\[[^]]*\]\)\=$'
+    return increase
+  elseif line =~ '^[\.#]'
+    return increase
+  elseif line =~? '^div'
+    return increase
+  elseif group == 'hamlFilter'
+    return increase
+  elseif line =~ '^'.s:tag.'[&!]\=[=~-]\s*\%(\%(if\|else\|elsif\|unless\|case\|when\|while\|until\|for\|begin\|module\|class\|def\)\>\%(.*\<end\>\)\@!\|.*do\%(\s*|[^|]*|\)\=\s*$\)'
+    return increase
+  elseif line =~ '^'.s:tag.'[&!]\=[=~-].*,\s*$'
+    return increase
+  elseif line == '-#'
+    return increase
+  elseif group =~? '\v^(hamlSelfCloser)$' || line =~? '^\v('.g:haml_self_closing_tags.')>'
+    return indent
+  elseif group =~? '\v^(hamlTag|hamlAttributesDelimiter|hamlObjectDelimiter|hamlClass|hamlId|htmlTagName|htmlSpecialTagName)$'
+    return increase
+  elseif synIDattr(synID(v:lnum,1,1),'name') ==? 'hamlRubyFilter'
+    return GetRubyIndent()
+  else
+    return indent
+  endif
+endfunction
+
+" vim:set sw=2:
+
+endif

indent/swift.vim

@@ -42,11 +42,15 @@ endfunction
 
 function! s:IsExcludedFromIndentAtPosition(line, column)
   let name = s:SyntaxNameAtPosition(a:line, a:column)
-  return name ==# "swiftComment" || name ==# "swiftString"
+  return s:IsSyntaxNameExcludedFromIndent(name)
 endfunction
 
 function! s:IsExcludedFromIndent()
-  return s:SyntaxName() ==# "swiftComment" || s:SyntaxName() ==# "swiftString"
+  return s:IsSyntaxNameExcludedFromIndent(s:SyntaxName())
+endfunction
+
+function! s:IsSyntaxNameExcludedFromIndent(name)
+  return a:name ==# "swiftComment" || a:name ==# "swiftString" || a:name ==# "swiftInterpolatedWrapper" || a:name ==# "swiftMultilineInterpolatedWrapper" || a:name ==# "swiftMultilineString"
 endfunction
 
 function! s:IsCommentLine(lnum)
@@ -103,10 +107,10 @@ function! SwiftIndent(...)
     return indent(openingSquare) + shiftwidth()
   endif
 
-  if line =~ ":$"
+  if line =~ ":$" && (line =~ '^\s*case\W' || line =~ '^\s*default\W')
     let switch = search("switch", "bWn")
     return indent(switch)
-  elseif previous =~ ":$"
+  elseif previous =~ ":$" && (previous =~ '^\s*case\W' || previous =~ '^\s*default\W')
     return previousIndent + shiftwidth()
   endif
 
@@ -133,12 +137,26 @@ function! SwiftIndent(...)
       return previousIndent + shiftwidth()
     elseif line =~ "}.*{"
       let openingBracket = searchpair("{", "", "}", "bWn", "s:IsExcludedFromIndent()")
+
+      let bracketLine = getline(openingBracket)
+      let numOpenParensBracketLine = s:NumberOfMatches("(", bracketLine, openingBracket)
+      let numCloseParensBracketLine = s:NumberOfMatches(")", bracketLine, openingBracket)
+      if numOpenParensBracketLine > numCloseParensBracketLine
+        let line = line(".")
+        let column = col(".")
+        call cursor(openingParen, column)
+        let openingParenCol = searchpairpos("(", "", ")", "bWn", "s:IsExcludedFromIndent()")[1]
+        call cursor(line, column)
+        return openingParenCol
+      endif
+
       return indent(openingBracket)
     elseif currentCloseBrackets > currentOpenBrackets
       let column = col(".")
-      call cursor(line("."), 1)
+      let line = line(".")
+      call cursor(line, 1)
       let openingBracket = searchpair("{", "", "}", "bWn", "s:IsExcludedFromIndent()")
-      call cursor(line("."), column)
+      call cursor(line, column)
 
       let bracketLine = getline(openingBracket)
 
@@ -151,8 +169,23 @@ function! SwiftIndent(...)
         let openingParen = searchpair("(", "", ")", "bWn", "s:IsExcludedFromIndent()")
         call cursor(line, column)
         return indent(openingParen)
+      elseif numOpenParensBracketLine > numCloseParensBracketLine
+        let line = line(".")
+        let column = col(".")
+        call cursor(openingParen, column)
+        let openingParenCol = searchpairpos("(", "", ")", "bWn", "s:IsExcludedFromIndent()")[1]
+        call cursor(line, column)
+        return openingParenCol
       endif
+
       return indent(openingBracket)
+    elseif line =~ '^\s*)$'
+      let line = line(".")
+      let column = col(".")
+      call cursor(line, 1)
+      let openingParen = searchpair("(", "", ")", "bWn", "s:IsExcludedFromIndent()")
+      call cursor(line, column)
+      return indent(openingParen)
     else
       " - Current line is blank, and the user presses 'o'
       return previousIndent
@@ -196,8 +229,19 @@ function! SwiftIndent(...)
         return previousIndent + shiftwidth()
       endif
 
-      let previousParen = match(previous, "(")
-      return indent(previousParen) + shiftwidth()
+      let previousParen = match(previous, '\v\($')
+      if previousParen != -1
+        return previousIndent + shiftwidth()
+      endif
+
+      let line = line(".")
+      let column = col(".")
+      call cursor(previousNum, col([previousNum, "$"]))
+      let previousParen = searchpairpos("(", "", ")", "cbWn", "s:IsExcludedFromIndent()")
+      call cursor(line, column)
+
+      " Match the last non escaped paren on the previous line
+      return previousParen[1]
     endif
 
     if numOpenBrackets > numCloseBrackets
@@ -206,7 +250,7 @@ function! SwiftIndent(...)
       call cursor(previousNum, column)
       let openingParen = searchpair("(", "", ")", "bWn", "s:IsExcludedFromIndent()")
       call cursor(line, column)
-      return indent(openingParen) + shiftwidth()
+      return openingParen + 1
     endif
 
     " - Previous line has close then open braces, indent previous + 1 'sw'
@@ -226,11 +270,23 @@ function! SwiftIndent(...)
   " - Line above has (unmatched) open paren, next line needs indent
   if numOpenParens > 0
     let savePosition = getcurpos()
+    let lastColumnOfPreviousLine = col([previousNum, "$"]) - 1
     " Must be at EOL because open paren has to be above (left of) the cursor
-    call cursor(previousNum, [previousNum, col("$")])
-    let previousParen = searchpair("(", "", ")", "cbWn", "s:IsExcludedFromIndent()")
+    call cursor(previousNum, lastColumnOfPreviousLine)
+    let previousParen = searchpairpos("(", "", ")", "cbWn", "s:IsExcludedFromIndent()")[1]
+    " If the paren on the last line is the last character, indent the contents
+    " at shiftwidth + previous indent
+    if previousParen == lastColumnOfPreviousLine
+      return previousIndent + shiftwidth()
+    endif
+
+    " The previous line opens a closure and doesn't close it
+    if numOpenBrackets > numCloseBrackets
+      return previousParen + shiftwidth()
+    endif
+
     call setpos(".", savePosition)
-    return indent(previousParen) + shiftwidth()
+    return previousParen
   endif
 
   return cindent

indent/terraform.vim

@@ -1,13 +1,13 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'terraform') == -1
   
+" Only load this file if no other indent file was loaded
 if exists("b:did_indent")
   finish
 endif
-
 let b:did_indent = 1
 
 setlocal nolisp
-setlocal autoindent
+setlocal autoindent sw=2 ts=2
 setlocal indentexpr=TerraformIndent(v:lnum)
 setlocal indentkeys+=<:>,0=},0=)
 
@@ -16,29 +16,30 @@ if exists("*TerraformIndent")
 endif
 
 function! TerraformIndent(lnum)
-  " previous non-blank line
-  let prevlnum = prevnonblank(a:lnum-1)
-
-  " beginning of file?
-  if prevlnum == 0
+  " Beginning of the file should have no indent
+  if a:lnum == 0
     return 0
   endif
 
-  " previous line without comments
+  " Previous non-blank line should continue the indent level
+  let prevlnum = prevnonblank(a:lnum-1)
+
+  " Previous line without comments should continue the indent level
   let prevline = substitute(getline(prevlnum), '//.*$', '', '')
   let previndent = indent(prevlnum)
   let thisindent = previndent
 
-  " block open?
+  " Config block starting with [ { ( should increase the indent level
   if prevline =~ '[\[{\(]\s*$'
     let thisindent += &sw
   endif
 
-  " current line without comments
+  " Current line without comments should continue the indent level
   let thisline = substitute(getline(a:lnum), '//.*$', '', '')
 
-  " block close?
-  if thisline =~ '^\s*[\)\]}]'
+  " Config block ending with ) } ] should get the indentation
+  " level from the initial config block
+  if thisline =~ '^\s*[\)}\]]'
     let thisindent -= &sw
   endif
 

spec/loading_spec.rb

@@ -11,7 +11,7 @@ describe "My Vim plugin" do
 
   extensions.each do |ext|
     it "should parse #{ext} file" do
-      Timeout::timeout(5) do
+      Timeout::timeout(15) do
         write_file "#{ext}", ""
         vim.edit "#{ext}"
         vim.insert "sample"