Remove liquid syntax, closes #384

closes #379
closes #378

.gitattributes

@@ -1,6 +1,5 @@
 .gitignore export-ignore
 .gitattributes export-ignore
-build export-ignore
 README.md export-ignore
 /spec export-ignore
 Gemfile export-ignore

.github/ISSUE_TEMPLATE/add-language.md

@@ -0,0 +1,18 @@
+---
+name: Add language
+about: Add support for new language
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!--- vim-polyglot accepts only lightweight, maintained github-hosted vim plugins -->
+
+**GitHub repository url**
+
+
+**Is this plugin well maintained?**
+
+
+**Is this plugin lightweight? (no advanced functionality, just indent and syntax support)**

.github/ISSUE_TEMPLATE/add-support-for-language.md

@@ -0,0 +1,20 @@
+---
+name: Add support for language
+about: ''
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,16 @@
+---
+name: Bug report
+about: Report vim-polyglot bug
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!-- Vim-polyglot is not responsible for bugs of plugins it uses. Please report only bugs that happen when plugin is used as part of vim-polyglot and doesn't happen when just install the plugin -->
+
+**Does this bug happen when you install plugin without vim-polyglot?**
+
+**Describe the bug:**
+
+**To Reproduce:**

.travis.yml

@@ -1,7 +1,11 @@
 language: ruby
 rvm:
-  - 1.9.3
-before_install: sudo apt-get install vim-gtk
+  - 2.6
+sudo: false
+addons:
+  apt:
+    packages:
+      - vim-gtk
 before_script:
   - "export DISPLAY=:99.0"
   - "sh -e /etc/init.d/xvfb start"

Gemfile.lock

@@ -1,16 +1,21 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.1.3)
-    rspec (2.12.0)
-      rspec-core (~> 2.12.0)
-      rspec-expectations (~> 2.12.0)
-      rspec-mocks (~> 2.12.0)
-    rspec-core (2.12.2)
-    rspec-expectations (2.12.1)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.12.0)
-    vimrunner (0.3.0)
+    diff-lcs (1.3)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    vimrunner (0.3.4)
 
 PLATFORMS
   ruby
@@ -18,3 +23,6 @@ PLATFORMS
 DEPENDENCIES
   rspec
   vimrunner
+
+BUNDLED WITH
+   1.16.2

README.md

@@ -1,97 +1,214 @@
-# vim-polyglot [![Build Status][travis-img-url]][travis-url]
+![vim-polyglot](https://i.imgur.com/9RxQK6k.png)
 
-[travis-img-url]: https://travis-ci.org/sheerun/vim-polyglot.png
+[![Build Status][travis-img-url]][travis-url] [![Maintenance](https://img.shields.io/maintenance/yes/2019.svg?maxAge=2592000)]()
+
+[travis-img-url]: https://travis-ci.org/sheerun/vim-polyglot.svg
 [travis-url]: https://travis-ci.org/sheerun/vim-polyglot
 
 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 50+ times faster** than 50+ packages it consist of.
-- Solid syntax and indentation support. Only the best language packs.
+- It **won't affect your startup time**, as scripts are loaded only on demand\*.
+- It **installs and updates 120+ times faster** than the <!--Package Count-->134<!--/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`).
 - Each build is tested by automated vimrunner script on CI. See `spec` directory.
 
-\*To be completely honest, concatenated `ftdetect` script takes around `3ms` to load.
+\*To be completely honest, concatenated `ftdetect` script takes up to `17ms` to load.
 
 ## Installation
 
-1. Install pathogen, Vundle or NeoBundle package manager.
+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:
+
+```
+mkdir -p ~/.vim/pack/default/start
+git clone https://github.com/sheerun/vim-polyglot ~/.vim/pack/default/start/vim-polyglot
+```
+
+NOTE: Not all features of listed language packs are available. We strip them from functionality slowing vim startup in general (for example we ignore `plugins` folder that is loaded regardless of file type, use `ftplugin` instead).
+
+If you need full functionality of any plugin, please use it directly with your plugin manager.
+
 ## Language packs
 
-- [arduino](https://github.com/sudar/vim-arduino-syntax) (syntax, indent, ftdetect)
+<!--Language Packs-->
+- [acpiasl](https://github.com/martinlroth/vim-acpi-asl) (syntax)
+- [ansible](https://github.com/pearofducks/ansible-vim) (syntax, indent, ftplugin)
+- [apiblueprint](https://github.com/sheerun/apiblueprint.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)
+- [blade](https://github.com/jwalton512/vim-blade) (syntax, indent, ftplugin)
 - [c++11](https://github.com/octol/vim-cpp-enhanced-highlight) (syntax)
-- [c/c++](https://github.com/vim-jp/cpp-vim) (syntax)
-- [c-extensions](https://github.com/kergoth/aftersyntaxc.vim) (syntax)
-- [clojure](https://github.com/guns/vim-clojure-static) (syntax, indent, autoload, ftplugin, ftdetect)
-- [coffee-script](https://github.com/kchmck/vim-coffee-script) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [csv](https://github.com/chrisbra/csv.vim) (syntax, ftplugin, ftdetect)
-- [cucumber](https://github.com/tpope/vim-cucumber) (syntax, indent, compiler, ftplugin, ftdetect)
-- [dockerfile](https://github.com/honza/dockerfile.vim) (syntax, ftdetect)
-- [elixir](https://github.com/elixir-lang/vim-elixir) (syntax, indent, compiler, ftplugin, ftdetect)
-- [emberscript](https://github.com/heartsentwined/vim-ember-script) (syntax, indent, ftplugin, ftdetect)
-- [erlang](https://github.com/oscarh/vimerl) (syntax, indent, compiler, autoload, ftplugin)
-- [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin, ftdetect)
-- [go](https://github.com/jnwhiteh/vim-golang) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [haml](https://github.com/tpope/vim-haml) (syntax, indent, compiler, ftplugin, ftdetect)
-- [handlebars](https://github.com/mustache/vim-mustache-handlebars) (syntax, ftplugin, ftdetect)
-- [haskell](https://github.com/travitch/hasksyn) (syntax, indent, ftplugin)
-- [haxe](https://github.com/yaymukund/vim-haxe) (syntax, ftdetect)
+- [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)
+- [coffee-script](https://github.com/kchmck/vim-coffee-script) (syntax, compiler, indent, autoload, ftplugin)
+- [cql](https://github.com/elubow/cql-vim) (syntax)
+- [cryptol](https://github.com/victoredwardocallaghan/cryptol.vim) (syntax, compiler, ftplugin)
+- [crystal](https://github.com/rhysd/vim-crystal) (syntax, indent, autoload, ftplugin)
+- [csv](https://github.com/chrisbra/csv.vim) (syntax, autoload, ftplugin)
+- [cucumber](https://github.com/tpope/vim-cucumber) (syntax, indent, compiler, ftplugin)
+- [cue](https://github.com/mgrabovsky/vim-cuesheet) (syntax)
+- [dart](https://github.com/dart-lang/dart-vim-plugin) (syntax, indent, autoload, ftplugin)
+- [dockerfile](https://github.com/ekalinin/Dockerfile.vim) (syntax, indent, ftplugin)
+- [elixir](https://github.com/elixir-lang/vim-elixir) (syntax, indent, compiler, autoload, ftplugin)
+- [elm](https://github.com/ElmCast/elm-vim) (syntax, indent, autoload, ftplugin)
+- [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)
+- [flatbuffers](https://github.com/dcharbon/vim-flatbuffers) (syntax)
+- [fsharp](https://github.com/fsharp/vim-fsharp) (syntax, indent)
+- [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin)
+- [glsl](https://github.com/tikhomirov/vim-glsl) (syntax, indent)
+- [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)
+- [gradle](https://github.com/tfnico/vim-gradle) (compiler)
+- [groovy-indent](https://github.com/vim-scripts/groovyindent-unix) (indent)
+- [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)
-- [jade](https://github.com/digitaltoad/vim-jade) (syntax, indent, ftplugin, ftdetect)
-- [jasmine](https://github.com/glanotte/vim-jasmine) (syntax, ftdetect)
-- [javascript](https://github.com/pangloss/vim-javascript) (syntax, indent, ftdetect)
-- [json](https://github.com/leshill/vim-json) (syntax, ftdetect)
-- [jst](https://github.com/briancollins/vim-jst) (syntax, indent, ftdetect)
+- [i3](https://github.com/mboughaba/i3config.vim) (syntax, ftplugin)
+- [idris](https://github.com/idris-hackers/idris-vim) (syntax, indent, ftplugin)
+- [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)
+- [jinja](https://github.com/lepture/vim-jinja) (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/amadeus/vim-jsx) (syntax, indent, ftplugin)
+- [julia](https://github.com/JuliaEditorSupport/julia-vim) (syntax, indent, autoload, ftplugin)
+- [kotlin](https://github.com/udalov/kotlin-vim) (syntax, indent, ftplugin)
 - [latex](https://github.com/LaTeX-Box-Team/LaTeX-Box) (syntax, indent, ftplugin)
-- [less](https://github.com/groenewege/vim-less) (syntax, indent, ftplugin, ftdetect)
-- [liquid](https://github.com/tpope/vim-liquid) (syntax, indent, ftplugin, ftdetect)
-- [markdown](https://github.com/tpope/vim-markdown) (syntax, ftplugin, ftdetect)
-- [nginx](https://github.com/mutewinter/nginx.vim) (syntax, ftdetect)
-- [ocaml](https://github.com/jrk/vim-ocaml) (syntax, indent, ftplugin)
+- [less](https://github.com/groenewege/vim-less) (syntax, indent, ftplugin)
+- [lilypond](https://github.com/anowlcalledjosh/vim-lilypond) (syntax, indent, compiler, ftplugin)
+- [livescript](https://github.com/gkz/vim-ls) (syntax, indent, compiler, ftplugin)
+- [llvm](https://github.com/rhysd/vim-llvm) (syntax, indent, 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, indent)
+- [mathematica](https://github.com/voldikss/vim-mma) (syntax, autoload, ftplugin)
+- [mdx](https://github.com/jxnblk/vim-mdx-js) (syntax)
+- [meson](https://github.com/mesonbuild/meson) (syntax, indent, ftplugin)
+- [moonscript](https://github.com/leafo/moonscript-vim) (syntax, indent, 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, compiler, ftplugin)
+- [objc](https://github.com/b4winckler/vim-objc) (ftplugin, syntax, indent)
+- [ocaml](https://github.com/rgrinberg/vim-ocaml) (syntax, indent, compiler, ftplugin)
 - [octave](https://github.com/vim-scripts/octave.vim--) (syntax)
-- [opencl](https://github.com/petRUShka/vim-opencl) (syntax, indent, ftplugin, ftdetect)
-- [perl](https://github.com/vim-perl/vim-perl) (syntax, indent, ftplugin, ftdetect)
+- [opencl](https://github.com/petRUShka/vim-opencl) (syntax, indent, ftplugin)
+- [perl](https://github.com/vim-perl/vim-perl) (syntax, indent, ftplugin)
+- [pgsql](https://github.com/lifepillar/pgsql.vim) (syntax, indent)
 - [php](https://github.com/StanAngeloff/php.vim) (syntax)
-- [puppet](https://github.com/rodjek/vim-puppet) (syntax, indent, ftplugin, ftdetect)
-- [protobuf](https://github.com/uarun/vim-protobuf) (syntax, ftdetect)
-- [python](https://github.com/mitsuhiko/vim-python-combined) (syntax, indent)
+- [plantuml](https://github.com/aklt/plantuml-syntax) (syntax, indent, ftplugin)
+- [pony](https://github.com/jakwings/vim-pony) (syntax, indent, autoload, ftplugin)
+- [powershell](https://github.com/PProvost/vim-ps1) (syntax, indent, ftplugin)
+- [protobuf](https://github.com/uarun/vim-protobuf) (syntax, indent)
+- [pug](https://github.com/digitaltoad/vim-pug) (syntax, indent, ftplugin)
+- [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-indent](https://github.com/Vimjas/vim-python-pep8-indent) (indent)
+- [python](https://github.com/vim-python/python-syntax) (syntax)
+- [qmake](https://github.com/artoj/qmake-syntax-vim) (syntax)
+- [qml](https://github.com/peterhoeg/vim-qml) (syntax, indent, ftplugin)
 - [r-lang](https://github.com/vim-scripts/R.vim) (syntax, ftplugin)
-- [rspec](https://github.com/sheerun/rspec.vim) (syntax, ftdetect)
-- [ruby](https://github.com/vim-ruby/vim-ruby) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [rust](https://github.com/wting/rust.vim) (syntax, indent, compiler, ftplugin, ftdetect)
-- [sbt](https://github.com/derekwyatt/vim-sbt) (syntax, ftdetect)
-- [scala](https://github.com/derekwyatt/vim-scala) (syntax, indent, ftplugin, ftdetect)
-- [slim](https://github.com/slim-template/vim-slim) (syntax, indent, ftdetect)
-- [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin, ftdetect)
-- [systemd](https://github.com/kurayama/systemd-vim-syntax) (syntax, ftdetect)
-- [textile](https://github.com/timcharper/textile.vim) (syntax, ftplugin, ftdetect)
-- [tmux](https://github.com/acustodioo/vim-tmux) (syntax, ftdetect)
-- [tomdoc](https://github.com/duwanis/tomdoc.vim) (syntax)
-- [typescript](https://github.com/leafgarland/typescript-vim) (syntax, compiler, ftplugin, ftdetect)
+- [racket](https://github.com/wlangstroth/vim-racket) (syntax, indent, ftplugin)
+- [ragel](https://github.com/jneen/ragel.vim) (syntax)
+- [raml](https://github.com/IN3D/vim-raml) (syntax, ftplugin)
+- [reason](https://github.com/reasonml-editor/vim-reason-plus) (syntax, indent)
+- [rspec](https://github.com/sheerun/rspec.vim) (syntax)
+- [rst](https://github.com/marshallward/vim-restructuredtext) (syntax, autoload, ftplugin)
+- [ruby](https://github.com/vim-ruby/vim-ruby) (syntax, indent, compiler, autoload, ftplugin)
+- [rust](https://github.com/rust-lang/rust.vim) (syntax, indent, compiler, autoload, ftplugin)
+- [sbt](https://github.com/derekwyatt/vim-sbt) (syntax)
+- [scala](https://github.com/derekwyatt/vim-scala) (syntax, indent, compiler, ftplugin)
+- [scss](https://github.com/cakebaker/scss-syntax.vim) (syntax, indent, ftplugin)
+- [slim](https://github.com/slim-template/vim-slim) (syntax, indent, ftplugin)
+- [slime](https://github.com/slime-lang/vim-slime-syntax) (syntax, indent)
+- [smt2](https://github.com/bohlender/vim-smt2) (syntax, autoload, ftplugin)
+- [solidity](https://github.com/tomlion/vim-solidity) (syntax, indent, ftplugin)
+- [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin)
+- [svg-indent](https://github.com/jasonshell/vim-svg-indent) (indent)
+- [svg](https://github.com/vim-scripts/svg.vim) (syntax)
+- [swift](https://github.com/keith/swift.vim) (syntax, indent, ftplugin)
+- [sxhkd](https://github.com/baskerville/vim-sxhkdrc) (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)
+- [tmux](https://github.com/keith/tmux.vim) (syntax, ftplugin)
+- [tomdoc](https://github.com/wellbredgrapefruit/tomdoc.vim) (syntax)
+- [toml](https://github.com/cespare/vim-toml) (syntax, ftplugin)
+- [twig](https://github.com/lumiliet/vim-twig) (syntax, indent, ftplugin)
+- [typescript](https://github.com/leafgarland/typescript-vim) (syntax, indent, compiler, ftplugin)
+- [vala](https://github.com/arrufat/vala.vim) (syntax, indent)
 - [vbnet](https://github.com/vim-scripts/vbnet.vim) (syntax)
-- [toml](https://github.com/cespare/vim-toml) (syntax, ftdetect)
-- [twig](https://github.com/beyondwords/vim-twig) (syntax, ftplugin, ftdetect)
+- [vcl](https://github.com/smerrill/vcl-vim-plugin) (syntax)
+- [vifm](https://github.com/vifm/vifm.vim) (syntax, autoload, ftplugin)
+- [vm](https://github.com/lepture/vim-velocity) (syntax, indent)
+- [vue](https://github.com/posva/vim-vue) (syntax, indent, ftplugin)
+- [xdc](https://github.com/amal-khailtash/vim-xdc-syntax) (syntax)
 - [xls](https://github.com/vim-scripts/XSLT-syntax) (syntax)
+- [xml](https://github.com/amadeus/vim-xml) (syntax)
+- [yaml](https://github.com/stephpy/vim-yaml) (syntax, ftplugin)
 - [yard](https://github.com/sheerun/vim-yardoc) (syntax)
-- [css-color](https://github.com/ap/vim-css-color) (autoload, syntax)
+<!--/Language Packs-->
+
+## Updating
+
+You can either wait for new patch release with updates or run the `./build` script by yourself.
+
+## Troubleshooting
+
+Please make sure you have `syntax on` in your `.vimrc`, otherwise syntax files are not loaded at all.
+
+Individual language packs can be disabled by setting `g:polyglot_disabled` as follows:
+
+```viml
+" ~/.vimrc
+let g:polyglot_disabled = ['css']
+```
+
+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
 
 See linked repositories for detailed license information.
-
-
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/sheerun/vim-polyglot/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
-

after/ftdetect/rspec.vim

@@ -1,2 +1,6 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rspec') == -1
+  
 autocmd BufReadPost,BufNewFile *_spec.rb set syntax=rspec
 autocmd BufReadPost,BufNewFile *_spec.rb setlocal commentstring=#\ %s
+
+endif

after/ftplugin/cabal.vim

@@ -0,0 +1,7 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'haskell') != -1
+  finish
+endif
+
+setlocal comments=s1fl:{-,mb:-,ex:-},:--
+setlocal iskeyword+=-,.,*
+setlocal commentstring=--\ %s

after/ftplugin/coffee.vim

@@ -0,0 +1,9 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'cjsx') != -1
+  finish
+endif
+
+if exists("loaded_matchit")
+  let b:match_ignorecase = 0
+  let b:match_words = '(:),\[:\],{:},<:>,' .
+    \ '<\@<=\([^/][^ \t>]*\)[^>]*\%(>\|$\):<\@<=/\1>'
+endif

after/ftplugin/haskell.vim

@@ -1,9 +1,6 @@
-" Vim ftplugin file
-" Language: Haskell
-" Maintainer: Tristan Ravitch
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'haskell') != -1
+  finish
+endif
 
-" I don't fully understand what the vim-default ftplugin does, but I do know
-" that the three-part comment entry really messes up this indenter (I also
-" hate the leading '-'s it puts in on each line).  Disable it here.
-setlocal comments&
-setlocal comments=:--
+setlocal comments=s1fl:{-,mb:\ \ ,ex:-},:--
+setlocal iskeyword+='

after/ftplugin/idris.vim

@@ -0,0 +1,5 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'idris') != -1
+  finish
+endif
+
+setlocal iskeyword+='

after/ftplugin/javascript.vim

@@ -0,0 +1,16 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'javascript') != -1
+  finish
+endif
+
+" Vim filetype plugin file
+" Language:     JavaScript
+" Maintainer:   vim-javascript community
+" URL:          https://github.com/pangloss/vim-javascript
+
+setlocal iskeyword+=$ suffixesadd+=.js
+
+if exists('b:undo_ftplugin')
+  let b:undo_ftplugin .= ' | setlocal iskeyword< suffixesadd<'
+else
+  let b:undo_ftplugin = 'setlocal iskeyword< suffixesadd<'
+endif

after/ftplugin/jsx.vim

@@ -0,0 +1,31 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'jsx') != -1
+  finish
+endif
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Vim ftplugin file
+"
+" Language: JSX (JavaScript)
+" Maintainer: Max Wang <mxawng@gmail.com>
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+" modified from html.vim
+if exists("loaded_matchit")
+  let b:match_ignorecase = 0
+  let s:jsx_match_words = '<\([a-zA-Z0-9.]\+\)\(>\|$\|\s\):<\/\1>'
+
+  if !exists('b:loaded_jsx_match_words')
+    let b:loaded_jsx_match_words = 0
+  endif
+
+  if b:loaded_jsx_match_words == 0
+    let b:match_words = exists('b:match_words')
+      \ ? b:match_words . ',' . s:jsx_match_words
+      \ : s:jsx_match_words
+  endif
+
+  let b:loaded_jsx_match_words = 1
+endif
+
+setlocal suffixesadd+=.jsx

after/ftplugin/llvm.vim

@@ -0,0 +1,477 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'llvm') != -1
+  finish
+endif
+
+" Copyright (c) 2018 rhysd
+"
+" Permission is hereby granted, free of charge, to any person obtaining a copy
+" of this software and associated documentation files (the "Software"), to deal
+" in the Software without restriction, including without limitation the rights
+" to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+" copies of the Software, and to permit persons to whom the Software is
+" furnished to do so, subject to the following conditions:
+"
+" The above copyright notice and this permission notice shall be included in
+" all copies or substantial portions of the Software.
+"
+" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+" AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+" LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+" OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+" THE SOFTWARE.
+
+if get(g:, 'llvm_extends_official', 1) == 0
+    finish
+endif
+
+let g:llvm_ext_no_mapping = get(g:, 'llvm_ext_no_mapping', 0)
+let g:llvm_ext_lli_executable = get(g:, 'llvm_ext_lli_executable', 'lli')
+
+let s:KIND_BLOCK_PREC = 0
+let s:KIND_BLOCK_FOLLOW = 1
+let s:KIND_FUNC_BEGIN = 2
+let s:KIND_FUNC_END = 3
+
+function! s:section_delim_at(lnum) abort
+    let line = getline(a:lnum)
+    let m = matchlist(line, '^\([^:]\+\):\%( \+; preds = \(%.\+\)\)\=$')
+    if !empty(m)
+        if m[2] ==# ''
+            return [s:KIND_BLOCK_PREC, m[1]]
+        else
+            return [s:KIND_BLOCK_FOLLOW, m[1], split(m[2], ',\s*')]
+        endif
+    endif
+    if line =~# '^}$'
+        return [s:KIND_FUNC_END]
+    endif
+    if line =~# '^define\>'
+        return [s:KIND_FUNC_BEGIN]
+    endif
+    return []
+endfunction
+
+function! s:is_section_delim(line, func_delim) abort
+    let sec = s:section_delim_at(a:line)
+    if empty(sec)
+        return 0
+    endif
+    let kind = sec[0]
+    return kind == s:KIND_BLOCK_PREC || kind == s:KIND_BLOCK_FOLLOW || kind == func_delim
+endfunction
+
+function! s:next_section(stop_func_begin) abort
+    let func_delim = a:stop_func_begin ? s:KIND_FUNC_BEGIN : s:KIND_FUNC_END
+    let last = line('$') - 1
+    let line = line('.')
+    while line < last
+        let line += 1
+        if s:is_section_delim(line, func_delim)
+            call cursor(line, col('.'))
+            return
+        endif
+    endwhile
+endfunction
+
+function! s:prev_section(stop_func_begin) abort
+    let func_delim = a:stop_func_begin ? s:KIND_FUNC_BEGIN : s:KIND_FUNC_END
+    let line = line('.')
+    while line > 1
+        let line -= 1
+        if s:is_section_delim(line, func_delim)
+            call cursor(line, col('.'))
+            return
+        endif
+    endwhile
+endfunction
+
+if !g:llvm_ext_no_mapping
+    nnoremap <buffer><silent>]] :<C-u>call <SID>next_section(1)<CR>
+    nnoremap <buffer><silent>[[ :<C-u>call <SID>prev_section(1)<CR>
+    nnoremap <buffer><silent>][ :<C-u>call <SID>next_section(0)<CR>
+    nnoremap <buffer><silent>[] :<C-u>call <SID>prev_section(0)<CR>
+endif
+
+function! s:function_range_at(linum) abort
+    let line = a:linum
+    while line >= 1
+        let s = getline(line)
+        if s =~# '^define\>'
+            let start = line
+            break
+        elseif s =~# '^}$'
+            return []
+        endif
+        let line -= 1
+    endwhile
+    if line < 1
+        return []
+    endif
+
+    let line = a:linum
+    let last = line('$')
+    while line <= last
+        let s = getline(line)
+        if s =~# '^}$'
+            let end = line
+            break
+        elseif s =~# '^define\>'
+            return []
+        endif
+        let line += 1
+    endwhile
+    if line > last
+        return []
+    endif
+
+    return [start, end]
+endfunction
+
+function! s:blocks_graph_at(linum) abort
+    let func_range = s:function_range_at(a:linum)
+    if empty(func_range)
+        return {}
+    endif
+    let line = func_range[0] + 1
+    let last = func_range[1] - 1
+    let graph = {}
+    while line <= last
+        let block = s:section_delim_at(line)
+        if empty(block)
+            let line += 1
+            continue
+        endif
+        let block_name = '%' . block[1]
+        if block[0] == s:KIND_BLOCK_PREC
+            let graph[block_name] = {'line': line, 'follows': [], 'preds': []}
+        elseif block[0] == s:KIND_BLOCK_FOLLOW
+            let graph[block_name] = {'line': line, 'follows': [], 'preds': block[2]}
+            for follow in block[2]
+                call add(graph[follow].follows, block_name)
+            endfor
+        else
+            echoerr 'unreachable'
+        endif
+        let line += 1
+    endwhile
+    return graph
+endfunction
+
+function! s:find_pred_block(linum) abort
+    let sec = s:section_delim_at(a:linum)
+    if empty(sec) || sec[0] != s:KIND_BLOCK_PREC && sec[0] != s:KIND_BLOCK_FOLLOW
+        throw 'No block is starting at line ' . a:linum
+    endif
+    if sec[0] != s:KIND_BLOCK_FOLLOW
+        throw printf("Block '%s' has no pred block", sec[1])
+    endif
+    let block_name = '%' . sec[1]
+    let pred_block = sec[2][0]
+
+    let graph = s:blocks_graph_at(a:linum)
+    if empty(graph)
+        throw 'No block is found in function at line ' . a:linum
+    endif
+
+    if !has_key(graph, pred_block)
+        throw printf("Block '%s' (pred block of '%s') not found in function", pred_block, block_name)
+    endif
+    return graph[pred_block]
+endfunction
+
+function! s:move_to_pred_block() abort
+    try
+        let b = s:find_pred_block(line('.'))
+        call cursor(b.line, col('.'))
+    catch
+        echohl ErrorMsg | echom v:exception | echohl None
+    endtry
+endfunction
+
+function! s:find_following_block(linum) abort
+    let sec = s:section_delim_at(a:linum)
+    if empty(sec) || sec[0] != s:KIND_BLOCK_PREC && sec[0] != s:KIND_BLOCK_FOLLOW
+        throw 'No block is starting at line ' . a:linum
+    endif
+    let block_name = '%' . sec[1]
+
+    let graph = s:blocks_graph_at(a:linum)
+    if empty(graph)
+        throw 'No block is found in function at line ' . a:linum
+    endif
+
+    let follows = graph[block_name].follows
+    if empty(follows)
+        throw printf("Block '%s' has no following block", block_name)
+    endif
+
+    echom printf("Block '%s' has %d following blocks: %s", block_name, len(follows), join(follows, ', '))
+
+    if !has_key(graph, follows[0])
+        throw printf("Block '%s' is not defined in function at line %d", follows[0], a:linum)
+    endif
+    return graph[follows[0]]
+endfunction
+
+function! s:move_to_following_block() abort
+    try
+        let b = s:find_following_block(line('.'))
+        call cursor(b.line, col('.'))
+    catch
+        echohl ErrorMsg | echom v:exception | echohl None
+    endtry
+endfunction
+
+if !g:llvm_ext_no_mapping
+    nnoremap <buffer><silent>[b :<C-u>call <SID>move_to_pred_block()<CR>
+    nnoremap <buffer><silent>]b :<C-u>call <SID>move_to_following_block()<CR>
+endif
+
+function! s:get_func_identifiers(line) abort
+    let idx = stridx(a:line, '@')
+    if idx == -1
+        " Invalid signature
+        return []
+    endif
+
+    " e.g. define internal i32 @foo(...) { -> @foo(...) {
+    let sig = a:line[idx:]
+
+    let idx = stridx(sig, '(')
+    if idx == -1
+        " Invalid signature
+        return []
+    endif
+
+    " @foo(...) { -> @foo
+    let idents = [sig[:idx-1]]
+
+    " @foo(...) { -> ...) {
+    let params = sig[idx+1:]
+
+    let idx = strridx(sig, ')')
+    if idx == -1
+        return idents
+    endif
+
+    " ...) { -> ...
+    let params = params[:idx-1]
+
+    " Gather parameters in function signature
+    while params !=# ''
+        let m = matchlist(params, '^[^%]*\(%\%("[^"]\+"\|[[:alnum:]_.]\+\)\)\s*\(.*\)$')
+        if empty(m)
+            break
+        endif
+        let idents += [m[1]]
+        let params = m[2]
+    endwhile
+
+    return idents
+endfunction
+
+function! s:get_identifiers(line) abort
+    " Registers and type defs
+    let m = matchlist(a:line, '^\s*\(%\S\+\)\s\+=')
+    if !empty(m)
+        return [m[1]]
+    endif
+
+    " Constants
+    let m = matchlist(a:line, '^\(@\S\+\)\s\+=.\+\<constant\>')
+    if !empty(m)
+        return [m[1]]
+    endif
+
+    " Labels for basic blocks
+    let m = matchlist(a:line, '^\([^:]\+\):\%(\s\+; preds = .\+\)\=$')
+    if !empty(m)
+        return ['%' . m[1]]
+    endif
+
+    " Meta variables
+    let m = matchlist(a:line, '^\(!\S\+\)\s\+=')
+    if !empty(m)
+        return [m[1]]
+    endif
+
+    " Attributes
+    let m = matchlist(a:line, '^attributes\s\+\(#\d\+\)\s\+=')
+    if !empty(m)
+        return [m[1]]
+    endif
+
+    if a:line =~# '^\%(declare\|define\)\>'
+        return s:get_func_identifiers(a:line)
+    endif
+
+    return []
+endfunction
+
+function! s:extract_identifier(word) abort
+    if strlen(a:word) <= 1
+        return ''
+    endif
+
+    let prefix = a:word[0]
+    if prefix ==# '@' || prefix ==# '%' || prefix ==# '!'
+        if prefix ==# '!' && a:word[1] ==# '{'
+            return ''
+        endif
+
+        if a:word[1] == '"'
+            let idx = stridx(a:word, '"', 2)
+            if idx == -1
+                return ''
+            endif
+            " @"foo" or %"foo"
+            return a:word[:idx]
+        else
+            " @foo or %foo
+            return matchstr(a:word, '^[@%!][[:alnum:]_.]\+')
+        endif
+    endif
+
+    if prefix ==# '#'
+        return matchstr(a:word, '^#\d\+')
+    endif
+
+    return ''
+endfunction
+
+function! s:jump_to_identifier_at(linum, ident) abort
+    let line = getline(a:linum)
+    let column = stridx(line, a:ident) + 1
+    if column == 0
+        let column = col('.')
+    endif
+    call cursor(a:linum, column)
+endfunction
+
+function! s:browser_open_command() abort
+    if exists('g:llvm_ext_browser_open_command')
+        return g:llvm_ext_browser_open_command
+    endif
+    if exists('s:browser_opener')
+        return s:browser_opener
+    endif
+    let s:browser_opener = ''
+    if has('mac')
+        let s:browser_opener = 'open'
+    elseif has('win32') || has('win64')
+        let s:browser_opener =  'cmd /q /c start ""'
+    else
+        for cmd in ['xdg-open', 'chromium', 'google-chrome', 'firefox']
+            if executable(cmd)
+                let s:browser_opener = cmd
+                break
+            endif
+        endfor
+    endif
+    return s:browser_opener
+endfunction
+
+function! s:open_browser(url) abort
+    let cmd = s:browser_open_command()
+    if cmd ==# ''
+        throw "Failed to open a browser. I don't know how to open a browser: Please set g:llvm_ext_browser_open_command"
+    endif
+    let cmdline = cmd . ' ' . shellescape(a:url)
+    let out = system(cmdline)
+    if v:shell_error
+        throw printf("Failed to open a browser with command '%s': %s", cmdline, out)
+    endif
+endfunction
+
+function! s:goto_definition() abort
+    " Open language reference manual under the cursor in browser
+    let syn_name = synIDattr(synID(line('.'),col('.'),1),'name')
+    if syn_name ==# 'llvmStatement'
+        let word = expand('<cword>')
+        if word !=# ''
+            try
+                " Open browser assuming a word under the cursor is an instruction
+                call s:open_browser('https://llvm.org/docs/LangRef.html#' . word . '-instruction')
+            catch /^Failed to open a browser/
+                echohl ErrorMsg | echom v:exception | echohl None
+            endtry
+        endif
+        return
+    endif
+
+    " XXX: This does not support identifiers which contains spaces
+    let word = expand('<cWORD>')
+    if word ==# ''
+        echom 'No identifier found under the cursor'
+        return
+    endif
+    let ident = s:extract_identifier(word)
+    if ident ==# ''
+        echom 'No identifier found under the cursor'
+        return
+    endif
+
+    " Definition tends to be near its usages. Look back at first.
+    let line = line('.')
+    while line > 0
+        for found in s:get_identifiers(getline(line))
+            if ident ==# found
+                call s:jump_to_identifier_at(line, ident)
+                return
+            endif
+        endfor
+        let line -= 1
+    endwhile
+
+    let line = line('.') + 1
+    let last = line('$')
+    while line <= last
+        for found in s:get_identifiers(getline(line))
+            if ident ==# found
+                call s:jump_to_identifier_at(line, ident)
+                return
+            endif
+        endfor
+        let line += 1
+    endwhile
+
+    echom "No definition for '" . ident . "' found"
+endfunction
+
+if !g:llvm_ext_no_mapping
+    nnoremap <buffer><silent>K :<C-u>call <SID>goto_definition()<CR>
+endif
+
+function! s:run_lli(...) abort
+    if !has('job') || !has('channel') || !has('terminal')
+        echohl ErrorMsg
+        echomsg ':LLI requires terminal feature. Please update your Vim to 8.0+'
+        echohl None
+        return
+    endif
+
+    if !executable(g:llvm_ext_lli_executable)
+        echohl ErrorMsg
+        echomsg g:llvm_ext_lli_executable . ' is not executable. Please set g:llvm_ext_lli_executable'
+        echohl None
+        return
+    endif
+
+    if a:0 > 0
+        let bufnr = term_start([g:llvm_ext_lli_executable, a:1])
+        echo 'Run lli in termnal buffer(' . bufnr . ')'
+        return
+    endif
+
+    let tmpfile = tempname()
+    call writefile(getline(1, '$'), tmpfile)
+    let Cleanup = {ch -> filereadable(tmpfile) ? delete(tmpfile) : 0}
+    let bufnr = term_start([g:llvm_ext_lli_executable, tmpfile], {'close_cb': Cleanup, 'exit_cb': Cleanup})
+    echo 'Run lli in termnal buffer(' . bufnr . ')'
+endfunction
+
+if !exists(':LLI')
+    command! -buffer -nargs=? -bar -complete=file LLI call <SID>run_lli(<f-args>)
+endif

after/ftplugin/puppet.vim

@@ -1,11 +1,20 @@
-inoremap <buffer> <silent> > ><Esc>:call <SID>puppetalign()<CR>A
-function! s:puppetalign()
-    let p = '^\s*\w+\s*[=+]>.*$'
-    let lineContainsHashrocket = getline('.') =~# '^\s*\w+\s*[=+]>'
-    let hashrocketOnPrevLine = getline(line('.') - 1) =~# p
-    let hashrocketOnNextLine = getline(line('.') + 1) =~# p
-    if exists(':Tabularize') " && lineContainsHashrocket && (hashrocketOnPrevLine || hashrocketOnNextLine)
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'puppet') != -1
+  finish
+endif
+
+if !exists('g:puppet_align_hashes')
+    let g:puppet_align_hashes = 1
+endif
+
+if g:puppet_align_hashes && exists(':Tabularize')
+    inoremap <buffer> <silent> > ><Esc>:call <SID>puppetalign()<CR>a
+    function! s:puppetalign()
+        let p = '^\s*\w+\s*[=+]>.*$'
+        let column = strlen(substitute(getline('.')[0:col('.')],'\([^=]\|=[^>]\)','','g'))
+        let position = strlen(matchstr(getline('.')[0:col('.')],'.*=>\s*\zs.*'))
         Tabularize /=>/l1
         normal! 0
-    endif
-endfunction
+        echo repeat('\([^=]\|=[^>]\)*=>',column).'\s\{-\}'.repeat('.',position)
+        call search(repeat('\([^=]\|=[^>]\)*=>',column).'\s\{-\}'.repeat('.',position),'ce',line('.'))
+    endfunction
+endif

after/ftplugin/terraform.vim

@@ -0,0 +1,85 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'terraform') != -1
+  finish
+endif
+
+if !exists('g:terraform_align')
+  let g:terraform_align = 0
+endif
+
+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()
+    let p = '^.*=[^>]*$'
+    if exists(':Tabularize') && getline('.') =~# '^.*=' && (getline(line('.')-1) =~# p || getline(line('.')+1) =~# p)
+      let column = strlen(substitute(getline('.')[0:col('.')],'[^=]','','g'))
+      let position = strlen(matchstr(getline('.')[0:col('.')],'.*=\s*\zs.*'))
+      Tabularize/=/l1
+      normal! 0
+      call search(repeat('[^=]*=',column).'\s\{-\}'.repeat('.',position),'ce',line('.'))
+    endif
+  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! 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)
+  "inoremap <space> <C-O>za
+  nnoremap <space> za
+  onoremap <space> <C-C>za
+  vnoremap <space> zf
+endif
+
+" Match the identation put in place by Hashicorp and :TerraformFmt, https://github.com/hashivim/vim-terraform/issues/21
+if get(g:, "terraform_align", 1)
+  setlocal tabstop=2
+  setlocal softtabstop=2
+  setlocal shiftwidth=2
+endif
+
+" Set the commentstring
+if exists('g:terraform_commentstring')
+    let &l:commentstring=g:terraform_commentstring
+else
+    setlocal commentstring=#%s
+endif

after/ftplugin/yaml.vim

@@ -0,0 +1,11 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'yaml') != -1
+  finish
+endif
+
+" Vim indent file
+" Language: Yaml
+" Author: Henrique Barcelos
+" Date: 2014-10-08
+" URL: https://github.com/hjpbarcelos
+setlocal autoindent sw=2 ts=2 expandtab
+" vim:set sw=2:

after/indent/html.vim

@@ -1,33 +0,0 @@
-" Language:    CoffeeScript
-" Maintainer:  Mick Koch <kchmck@gmail.com>
-" URL:         http://github.com/kchmck/vim-coffee-script
-" License:     WTFPL
-
-" Load the coffee and html indent functions.
-silent! unlet b:did_indent
-runtime indent/coffee.vim
-let s:coffeeIndentExpr = &l:indentexpr
-
-" Load html last so it can overwrite coffee settings.
-silent! unlet b:did_indent
-runtime indent/html.vim
-let s:htmlIndentExpr = &l:indentexpr
-
-" Inject our wrapper indent function.
-setlocal indentexpr=GetCoffeeHtmlIndent(v:lnum)
-
-function! GetCoffeeHtmlIndent(curlinenum)
-  " See if we're inside a coffeescript block.
-  let scriptlnum = searchpair('<script [^>]*type="text/coffeescript"[^>]*>', '',
-  \                           '</script>', 'bWn')
-  let prevlnum = prevnonblank(a:curlinenum)
-
-  " If we're in the script block and the previous line isn't the script tag
-  " itself, use coffee indenting.
-  if scriptlnum && scriptlnum != prevlnum
-    exec 'return ' s:coffeeIndentExpr
-  endif
-
-  " Otherwise use html indenting.
-  exec 'return ' s:htmlIndentExpr
-endfunction

after/indent/jsx.vim

@@ -0,0 +1,118 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'jsx') != -1
+  finish
+endif
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Vim indent file
+"
+" Language: JSX (JavaScript)
+" Maintainer: Max Wang <mxawng@gmail.com>
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+" Save the current JavaScript indentexpr.
+let b:jsx_js_indentexpr = &indentexpr
+
+" Prologue; load in XML indentation.
+if exists('b:did_indent')
+  let s:did_indent=b:did_indent
+  unlet b:did_indent
+endif
+exe 'runtime! indent/xml.vim'
+if exists('s:did_indent')
+  let b:did_indent=s:did_indent
+endif
+
+setlocal indentexpr=GetJsxIndent()
+
+" JS indentkeys
+setlocal indentkeys=0{,0},0),0],0\,,!^F,o,O,e
+" XML indentkeys
+setlocal indentkeys+=*<Return>,<>>,<<>,/
+
+" Multiline end tag regex (line beginning with '>' or '/>')
+let s:endtag = '^\s*\/\?>\s*;\='
+
+" Get all syntax types at the beginning of a given line.
+fu! SynSOL(lnum)
+  return map(synstack(a:lnum, 1), 'synIDattr(v:val, "name")')
+endfu
+
+" Get all syntax types at the end of a given line.
+fu! SynEOL(lnum)
+  let lnum = prevnonblank(a:lnum)
+  let col = strlen(getline(lnum))
+  return map(synstack(lnum, col), 'synIDattr(v:val, "name")')
+endfu
+
+" Check if a syntax attribute is XMLish.
+fu! SynAttrXMLish(synattr)
+  return a:synattr =~ "^xml" || a:synattr =~ "^jsx"
+endfu
+
+" Check if a synstack is XMLish (i.e., has an XMLish last attribute).
+fu! SynXMLish(syns)
+  return SynAttrXMLish(get(a:syns, -1))
+endfu
+
+" Check if a synstack denotes the end of a JSX block.
+fu! SynJSXBlockEnd(syns)
+  return get(a:syns, -1) =~ '\%(js\|javascript\)Braces' &&
+       \ SynAttrXMLish(get(a:syns, -2))
+endfu
+
+" Determine how many jsxRegions deep a synstack is.
+fu! SynJSXDepth(syns)
+  return len(filter(copy(a:syns), 'v:val ==# "jsxRegion"'))
+endfu
+
+" Check whether `cursyn' continues the same jsxRegion as `prevsyn'.
+fu! SynJSXContinues(cursyn, prevsyn)
+  let curdepth = SynJSXDepth(a:cursyn)
+  let prevdepth = SynJSXDepth(a:prevsyn)
+
+  " In most places, we expect the nesting depths to be the same between any
+  " two consecutive positions within a jsxRegion (e.g., between a parent and
+  " child node, between two JSX attributes, etc.).  The exception is between
+  " sibling nodes, where after a completed element (with depth N), we return
+  " to the parent's nesting (depth N - 1).  This case is easily detected,
+  " since it is the only time when the top syntax element in the synstack is
+  " jsxRegion---specifically, the jsxRegion corresponding to the parent.
+  return prevdepth == curdepth ||
+      \ (prevdepth == curdepth + 1 && get(a:cursyn, -1) ==# 'jsxRegion')
+endfu
+
+" Cleverly mix JS and XML indentation.
+fu! GetJsxIndent()
+  let cursyn  = SynSOL(v:lnum)
+  let prevsyn = SynEOL(v:lnum - 1)
+
+  " Use XML indenting iff:
+  "   - the syntax at the end of the previous line was either JSX or was the
+  "     closing brace of a jsBlock whose parent syntax was JSX; and
+  "   - the current line continues the same jsxRegion as the previous line.
+  if (SynXMLish(prevsyn) || SynJSXBlockEnd(prevsyn)) &&
+        \ SynJSXContinues(cursyn, prevsyn)
+    let ind = XmlIndentGet(v:lnum, 0)
+
+    " Align '/>' and '>' with '<' for multiline tags.
+    if getline(v:lnum) =~? s:endtag
+      let ind = ind - &sw
+    endif
+
+    " Then correct the indentation of any JSX following '/>' or '>'.
+    if getline(v:lnum - 1) =~? s:endtag
+      let ind = ind + &sw
+    endif
+  else
+    if len(b:jsx_js_indentexpr)
+      " Invoke the base JS package's custom indenter.  (For vim-javascript,
+      " e.g., this will be GetJavascriptIndent().)
+      let ind = eval(b:jsx_js_indentexpr)
+    else
+      let ind = cindent(v:lnum)
+    endif
+  endif
+
+  return ind
+endfu

after/indent/objc.vim

@@ -0,0 +1,97 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'objc') != -1
+  finish
+endif
+
+" Vim indent file
+" Language:	Objective-C
+" Maintainer:	Bjorn Winckler <bjorn.winckler@gmail.com>
+" Last Change:	2012 Jan 01
+
+" Ensure 'cpo' is set to Vim default values and restore later
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Only load this indent file when no other was loaded.
+"if exists("b:did_indent")
+"    finish
+"endif
+"let b:did_indent = 1
+"setlocal cindent
+
+setl indentkeys=0{,0},:,0#,!^F,o,O,e,<:>
+
+setlocal indentexpr=GetObjCIndentImproved()
+
+" Top level statements which should not be indented, and which should not
+" cause next (non-blank) line to be indented either.
+let s:topLev = '^\s*@\%(class\|end\|implementation\|interface\|protocol\|\)\>'
+
+function! GetObjCIndentImproved()
+  " NOTE: Ignore leading white space to avoid having to deal with space vs.
+  " tab issues.  Rely on the indent() function instead.
+  let thisLine = substitute(getline(v:lnum), '^\s*', '', '')
+
+  if thisLine =~# s:topLev || getline(prevnonblank(v:lnum - 1)) =~# s:topLev
+    return 0
+  endif
+
+  " If current line looks like an argument to a message dispatch, then line
+  " up colon with previous line.  This will indent the second line so that
+  " the colons line up in
+  "
+  "   [obj firstParameter:value
+  "                paramB:value2];
+  "
+  " but it will not line up colons in
+  "
+  "   if ([obj something:here])
+  "       [obj other:here];
+  "
+  let thisColon = match(thisLine, '^\s*\K\k*\zs:')
+  if thisColon > 0
+    let prevLine = substitute(getline(v:lnum - 1), '^\s*', '', '')
+    let prevColon = match(prevLine, ':')
+    if prevColon > 0
+      " Try to align colons, always making sure line is indented at least
+      " one shiftwidth more than the indentation at the beginning of the
+      " message.  Avoids situations like this:
+      "
+      "     if ([obj a:x
+      "  aLongParameter:y])
+      "
+      let [lnum,lcol] = searchpairpos('\[', '', '\]', 'b', 0,
+            \ max([1, v:lnum - 10]))
+      let minInd = &sw + (lnum > 0 ? indent(lnum) : 0)
+      let alignedInd = indent(v:lnum - 1) + prevColon - thisColon
+      return alignedInd > minInd ? alignedInd : minInd
+    endif
+  endif
+
+  let prevLnum = v:lnum - 1
+  let ind      = indent(prevLnum)
+
+  " Indent one shiftwidth after opening block, e.g.:
+  "
+  "   call_func_with_block(param, ^{
+  "       do_stuff();
+  "   });
+  "
+  let blockPat = '\^\s*\(([^)]*)\)\?\s*{$'
+  if thisLine =~ '^}'
+    norm '^%'
+    if getline(".") =~ blockPat
+      return indent(".")
+    endif
+  endif
+
+  if getline(prevLnum) =~ blockPat
+    return ind + &sw
+  endif
+
+  return cindent(v:lnum)
+endfunction
+
+
+" Restore 'cpo' options
+let &cpo = s:save_cpo
+unlet s:save_cpo

after/syntax/c.vim

@@ -1,19 +1,46 @@
-" Vim syntax file
-" Language:	C Additions
-" Maintainer:	Mikhail Wolfson <mywolfson@gmail.com>
-" URL: http://web.mit.edu/wolfsonm
-" Last Change:	2010 Dec. 3
-" Version: 0.4
-"
-" Changelog:
-"   0.4 - updates and fixes to cDelimiter to fix break with foldmethod=syntax,
-"         entirely suggested and solved by Ivan Freitas
-"         <ivansichfreitas@gmail.com>
-"   0.3 - updates and fixes to cUserFunctionPointer, thanks to 
-"         Alexei <lxmzhv@gmail.com>
-"   0.2 - change [] to operator
-"   0.1 - initial upload, modification from vimscript#1201, Extended c.vim
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'c++11') != -1
+  finish
+endif
 
+" Vim syntax file
+" Language: C Additions
+" Maintainer: Jon Haggblad <jon@haeggblad.com>
+" Contributor: Mikhail Wolfson <mywolfson@gmail.com>
+" URL: http://www.haeggblad.com
+" Last Change: 6 Sep 2014
+" Version: 0.3
+" Changelog:
+"   0.3 - integration of aftersyntaxc.vim
+"   0.2 - Cleanup
+"   0.1 - initial version.
+"
+" Syntax highlighting for functions in C.
+"
+" Based on:
+"   http://stackoverflow.com/questions/736701/class-function-names-highlighting-in-vim
+
+" -----------------------------------------------------------------------------
+"  Highlight function names.
+" -----------------------------------------------------------------------------
+if !exists('g:cpp_no_function_highlight')
+    syn match    cCustomParen    transparent "(" contains=cParen contains=cCppParen
+    syn match    cCustomFunc     "\w\+\s*(\@=" contains=cCustomParen
+    hi def link cCustomFunc  Function
+endif
+
+" -----------------------------------------------------------------------------
+"  Highlight member variable names.
+" -----------------------------------------------------------------------------
+if exists('g:cpp_member_variable_highlight') && g:cpp_member_variable_highlight
+    syn match   cCustomDot    "\." contained
+    syn match   cCustomPtr    "->" contained
+    syn match   cCustomMemVar "\(\.\|->\)\h\w*" contains=cCustomDot,cCustomPtr
+    hi def link cCustomMemVar Function
+endif
+
+" -----------------------------------------------------------------------------
+"  Source: aftersyntaxc.vim
+" -----------------------------------------------------------------------------
 
 " Common ANSI-standard functions
 syn keyword cAnsiFunction	MULU_ DIVU_ MODU_ MUL_ DIV_ MOD_
@@ -61,7 +88,8 @@ syn keyword cAnsiFunction	wcstombs mbstowcs wctomb
 syn keyword cAnsiFunction	mbtowc mblen lldiv
 syn keyword cAnsiFunction	ldiv div llabs
 syn keyword cAnsiFunction	labs abs qsort
-syn keyword cAnsiFunction	bsearch system getenv
+"syn keyword cAnsiFunction	bsearch system getenv
+syn keyword cAnsiFunction	bsearch getenv
 syn keyword cAnsiFunction	exit atexit abort
 syn keyword cAnsiFunction	realloc malloc free
 syn keyword cAnsiFunction	calloc srand rand
@@ -238,42 +266,43 @@ syn keyword	cAnsiName	bitand not or_eq
 
 hi def link cAnsiFunction cFunction
 hi def link cAnsiName cIdentifier
-
-" Operators
-syn match cOperator	"\(<<\|>>\|[-+*/%&^|<>!=]\)="
-syn match cOperator	"<<\|>>\|&&\|||\|++\|--\|->"
-syn match cOperator	"[.!~*&%<>^|=,+-]"
-syn match cOperator	"/[^/*=]"me=e-1
-syn match cOperator	"/$"
-syn match cOperator "&&\|||"
-syn match cOperator	"[][]"
-
-" Preprocs
-syn keyword cDefined defined contained containedin=cDefine
-hi def link cDefined cDefine
-
-" Functions
-syn match cUserFunction "\<\h\w*\>\(\s\|\n\)*("me=e-1 contains=cType,cDelimiter,cDefine
-syn match cUserFunctionPointer "(\s*\*\s*\h\w*\s*)\(\s\|\n\)*(" contains=cDelimiter,cOperator
-
-hi def link cUserFunction cFunction
-hi def link cUserFunctionPointer cFunction
-
-" Delimiters
-syn match cDelimiter    "[();\\]"
-" foldmethod=syntax fix, courtesy of Ivan Freitas
-syn match cBraces display "[{}]"
-
+hi def link cFunction Function
+hi def link cIdentifier Identifier
 
 " Booleans
 syn keyword cBoolean true false TRUE FALSE
-
-
-" Links
-hi def link cFunction Function
-hi def link cIdentifier Identifier
-hi def link cDelimiter Delimiter
-" foldmethod=syntax fix, courtesy of Ivan Freitas
-hi def link cBraces Delimiter
 hi def link cBoolean Boolean
 
+" -----------------------------------------------------------------------------
+"  Additional optional highlighting
+" -----------------------------------------------------------------------------
+
+" Operators
+"syn match cOperator	"\(<<\|>>\|[-+*/%&^|<>!=]\)="
+"syn match cOperator	"<<\|>>\|&&\|||\|++\|--\|->"
+"syn match cOperator	"[.!~*&%<>^|=,+-]"
+"syn match cOperator	"/[^/*=]"me=e-1
+"syn match cOperator	"/$"
+"syn match cOperator "&&\|||"
+"syn match cOperator	"[][]"
+"
+"" Preprocs
+"syn keyword cDefined defined contained containedin=cDefine
+"hi def link cDefined cDefine
+
+"" Functions
+"syn match cUserFunction "\<\h\w*\>\(\s\|\n\)*("me=e-1 contains=cType,cDelimiter,cDefine
+"syn match cUserFunctionPointer "(\s*\*\s*\h\w*\s*)\(\s\|\n\)*(" contains=cDelimiter,cOperator
+"
+"hi def link cUserFunction cFunction
+"hi def link cUserFunctionPointer cFunction
+"
+"" Delimiters
+"syn match cDelimiter    "[();\\]"
+"" foldmethod=syntax fix, courtesy of Ivan Freitas
+"syn match cBraces display "[{}]"
+
+" Links
+"hi def link cDelimiter Delimiter
+" foldmethod=syntax fix, courtesy of Ivan Freitas
+"hi def link cBraces Delimiter

after/syntax/coffee.vim

@@ -1,20 +1,31 @@
-" This file describes a very basic syntax for TomDoc comments in a
-" CoffeeScript file.
-"
-" For more information on TomDoc, check it out here: http://tomdoc.org/
-"
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'cjsx') != -1
+  finish
+endif
 
-syn keyword tomdocKeywords Returns containedin=coffeeComment contained
-syn keyword tomdocKeywords Throws containedin=coffeeComment contained
-syn keyword tomdocKeywords Examples containedin=coffeeComment contained
-syn keyword tomdocKeywords Signature containedin=coffeeComment contained
+if exists('b:current_syntax')
+  let s:current_syntax=b:current_syntax
+  unlet b:current_syntax
+endif
 
-syn match tomdocArguments +\s*[A-Za-z0-9_\-&\*:]*\(\s*- \)+he=e-3 containedin=coffeeComment contained
+if exists('s:current_syntax')
+  let b:current_syntax=s:current_syntax
+endif
 
-syn match tomdocDescriptions +\s*Public:+he=e-1 containedin=coffeeComment contained
-syn match tomdocDescriptions +\s*Internal:+he=e-1 containedin=coffeeComment contained
-syn match tomdocDescriptions +\s*Deprecated:+he=e-1 containedin=coffeeComment contained
+syn match   cjsxEntity       contained "&[^; \t]*;" contains=cjsxEntityPunct
+syn match   cjsxEntityPunct  contained "[&.;]"
 
-hi default link tomdocDescriptions String
-hi default link tomdocKeywords String
-hi default link tomdocArguments HELP
+syn match   cjsxAttribProperty /[A-Za-z_][A-Za-z0-9_-]*/ contained
+syn region  cjsxAttrib start=/\s[A-Za-z_][A-Za-z0-9_-]/hs=s+1 end=/=/ end=/\s[A-Za-z_]/me=e-2 end=+[/>]+me=e-1 contained contains=cjsxAttribProperty
+
+syn region  cjsxBody start=+[^/]>+ms=s+2 start=/>/ms=s+1 end=+<\/+me=e-2 contained contains=cjsxElement,coffeeCurlies,cjsxEntity
+
+syn region  cjsxElement start=/<@\=[A-Za-z_][A-Za-z0-9-_\.]*/ end=/\/>/ end=/<\/@\=[A-Za-z_][A-Za-z0-9-_\.]*>/ contains=cjsxOpenTag,cjsxBody,coffeeCurlies,coffeeString,cjsxAttrib,coffeeNumber,coffeeFloat
+
+syn cluster coffeeAll add=cjsxElement
+
+" The default highlighting.
+hi def link cjsxElement         Function
+hi def link cjsxTagName         Function
+hi def link cjsxEntity          Statement
+hi def link cjsxEntityPunct     Type
+hi def link cjsxAttribProperty  Type

after/syntax/css.vim

@@ -1,6 +0,0 @@
-" Language:     Colorful CSS Color Preview
-" Author:       Aristotle Pagaltzis <pagaltzis@gmx.de>
-
-if !( has('gui_running') || &t_Co==256 ) | finish | endif
-
-call css_color#init('css', 'cssMediaBlock,cssFunction,cssDefinition,cssAttrRegion,cssComment')

after/syntax/haml.vim

@@ -1,13 +0,0 @@
-" Language:    CoffeeScript
-" Maintainer:  Sven Felix Oberquelle <Svelix.Github@gmail.com>
-" URL:         http://github.com/kchmck/vim-coffee-script
-" License:     WTFPL
-
-" Inherit coffee from html so coffeeComment isn't redefined and given higher
-" priority than hamlInterpolation.
-syn cluster hamlCoffeescript contains=@htmlCoffeeScript
-syn region  hamlCoffeescriptFilter matchgroup=hamlFilter
-\                                  start="^\z(\s*\):coffee\z(script\)\?\s*$"
-\                                  end="^\%(\z1 \| *$\)\@!"
-\                                  contains=@hamlCoffeeScript,hamlInterpolation
-\                                  keepend

after/syntax/help.vim

@@ -1,6 +1,16 @@
-let b:current_syntax = ''
-unlet b:current_syntax
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'scala') != -1
+  finish
+endif
+
+" Extends standard help syntax with highlighting of Scala code.
+"
+" Place code between !sc! and !/sc! delimiters. These will be hidden if Vim is
+" built with conceal support.
+
+unlet! b:current_syntax
+
 syntax include @ScalaCode syntax/scala.vim
+
 if has('conceal')
   syntax region rgnScala matchgroup=Ignore concealends start='!sc!' end='!/sc!' contains=@ScalaCode
 else

after/syntax/html.vim

@@ -1,18 +1,16 @@
-" Language:    CoffeeScript
-" Maintainer:  Mick Koch <kchmck@gmail.com>
-" URL:         http://github.com/kchmck/vim-coffee-script
-" License:     WTFPL
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'html5') != -1
+  finish
+endif
 
-" Syntax highlighting for text/coffeescript script tags
-syn include @htmlCoffeeScript syntax/coffee.vim
-syn region coffeeScript start=#<script [^>]*type="text/coffeescript"[^>]*>#
-\                       end=#</script>#me=s-1 keepend
-\                       contains=@htmlCoffeeScript,htmlScriptTag,@htmlPreproc
-\                       containedin=htmlHead
-" Language:     Colorful CSS Color Preview
-" Author:       Aristotle Pagaltzis <pagaltzis@gmx.de>
+" Vim syntax file
+" Language:     HTML (version 5.1)
+" Last Change:  2017 Feb 15
+" License:      Public domain
+"               (but let me know if you like :) )
+"
+" Maintainer:   Kao, Wei-Ko(othree) ( othree AT gmail DOT com )
 
-if !( has('gui_running') || &t_Co==256 ) | finish | endif
-
-" default html syntax should already be including the css syntax
-syn cluster colorableGroup add=htmlString,htmlCommentPart
+" Comment
+" https://github.com/w3c/html/issues/694
+syntax region htmlComment start=+<!--+ end=+-->+ contains=@Spell
+syntax region htmlComment start=+<!DOCTYPE+ keepend end=+>+

after/syntax/idris.vim

@@ -0,0 +1,82 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'idris') != -1
+  finish
+endif
+
+" This script allows for unicode concealing of certain characters
+" For instance -> goes to →
+"
+" It needs vim >= 7.3, set nocompatible, set enc=utf-8
+"
+" If you want to turn this on, let g:idris_conceal = 1
+
+if !exists('g:idris_conceal') || !has('conceal') || &enc != 'utf-8'
+    finish
+endif
+
+" vim: set fenc=utf-8:
+syntax match idrNiceOperator "\\\ze[[:alpha:][:space:]_([]" conceal cchar=λ
+syntax match idrNiceOperator "<-" conceal cchar=←
+syntax match idrNiceOperator "->" conceal cchar=→
+syntax match idrNiceOperator "\<sum\>" conceal cchar=∑
+syntax match idrNiceOperator "\<product\>" conceal cchar=∏
+syntax match idrNiceOperator "\<sqrt\>" conceal cchar=√
+syntax match idrNiceOperator "\<pi\>" conceal cchar=π
+syntax match idrNiceOperator "==" conceal cchar=≡
+syntax match idrNiceOperator "\/=" conceal cchar=≠
+
+
+let s:extraConceal = 1
+
+let s:doubleArrow = 1
+" Set this to 0 to use the more technically correct arrow from bar
+
+" Some windows font don't support some of the characters,
+" so if they are the main font, we don't load them :)
+if has("win32")
+    let s:incompleteFont = [ 'Consolas'
+                        \ , 'Lucida Console'
+                        \ , 'Courier New'
+                        \ ]
+    let s:mainfont = substitute( &guifont, '^\([^:,]\+\).*', '\1', '')
+    for s:fontName in s:incompleteFont
+        if s:mainfont ==? s:fontName
+            let s:extraConceal = 0
+            break
+        endif
+    endfor
+endif
+
+if s:extraConceal
+    syntax match idrNiceOperator "Void" conceal cchar=⊥
+
+    " Match greater than and lower than w/o messing with Kleisli composition
+    syntax match idrNiceOperator "<=\ze[^<]" conceal cchar=≤
+    syntax match idrNiceOperator ">=\ze[^>]" conceal cchar=≥
+
+    if s:doubleArrow
+      syntax match idrNiceOperator "=>" conceal cchar=⇒
+    else
+      syntax match idrNiceOperator "=>" conceal cchar=↦
+    endif
+
+    syntax match idrNiceOperator "=\zs<<" conceal cchar=«
+
+    syntax match idrNiceOperator "++" conceal cchar=⧺
+    syntax match idrNiceOperator "::" conceal cchar=∷
+    syntax match idrNiceOperator "-<" conceal cchar=↢
+    syntax match idrNiceOperator ">-" conceal cchar=↣
+    syntax match idrNiceOperator "-<<" conceal cchar=⤛
+    syntax match idrNiceOperator ">>-" conceal cchar=⤜
+
+    " Only replace the dot, avoid taking spaces around.
+    syntax match idrNiceOperator /\s\.\s/ms=s+1,me=e-1 conceal cchar=∘
+    syntax match idrNiceOperator "\.\." conceal cchar=‥
+
+    syntax match idrNiceOperator "`elem`" conceal cchar=∈
+    syntax match idrNiceOperator "`notElem`" conceal cchar=∉
+endif
+
+hi link idrNiceOperator Operator
+hi! link Conceal Operator
+setlocal conceallevel=2
+

after/syntax/jsx.vim

@@ -0,0 +1,83 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'jsx') != -1
+  finish
+endif
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Vim syntax file
+"
+" Language: JSX (JavaScript)
+" Maintainer: Max Wang <mxawng@gmail.com>
+" Depends: pangloss/vim-javascript
+"
+" CREDITS: Inspired by Facebook.
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+" Prologue; load in XML syntax.
+if exists('b:current_syntax')
+  let s:current_syntax=b:current_syntax
+  unlet b:current_syntax
+endif
+syn include @XMLSyntax syntax/xml.vim
+if exists('s:current_syntax')
+  let b:current_syntax=s:current_syntax
+endif
+
+" Officially, vim-jsx depends on the pangloss/vim-javascript syntax package
+" (and is tested against it exclusively).  However, in practice, we make some
+" effort towards compatibility with other packages.
+"
+" These are the plugin-to-syntax-element correspondences:
+"
+"   - pangloss/vim-javascript:      jsBlock, jsExpression
+"   - jelera/vim-javascript-syntax: javascriptBlock
+"   - othree/yajs.vim:              javascriptNoReserved
+
+
+" JSX attributes should color as JS.  Note the trivial end pattern; we let
+" 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.
+syn region jsxChild contained start=+{+ end=++ contains=jsBlock,javascriptBlock
+  \ extend
+
+" Highlight JSX regions as XML; recursively match.
+"
+" Note that we prohibit JSX tags from having a < or word character immediately
+" preceding it, to avoid conflicts with, respectively, the left shift operator
+" 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:\-.]*\>[:,]\@!\)\([^>]*>(\)\@!+
+  \ skip=+<!--\_.\{-}-->+
+  \ end=+</\z1\_\s\{-}>+
+  \ end=+/>+
+  \ keepend
+  \ extend
+
+" Shorthand fragment support
+"
+" Note that since the main jsxRegion contains @XMLSyntax, we cannot simply
+" adjust the regex above since @XMLSyntax will highlight the opening `<` as an
+" XMLError. Instead we create a new group with the same name that does not
+" include @XMLSyntax and instead uses matchgroup to get the same highlighting.
+syn region jsxRegion
+  \ contains=@Spell,jsxRegion,jsxChild,jsBlock,javascriptBlock
+  \ matchgroup=xmlTag
+  \ start=/<>/
+  \ end=/<\/>/
+  \ keepend
+  \ extend
+
+" Add jsxRegion to the lowest-level JS syntax cluster.
+syn cluster jsExpression add=jsxRegion
+
+" Allow jsxRegion to contain reserved words.
+syn cluster javascriptNoReserved add=jsxRegion

after/syntax/less.vim

@@ -1,6 +0,0 @@
-" Language:     Colorful CSS Color Preview
-" Author:       Aristotle Pagaltzis <pagaltzis@gmx.de>
-
-if !( has('gui_running') || &t_Co==256 ) | finish | endif
-
-call css_color#init('css', 'lessVariableValue')

after/syntax/llvm.vim

@@ -0,0 +1,26 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'llvm') != -1
+  finish
+endif
+
+" Copyright (c) 2018 rhysd
+"
+" Permission is hereby granted, free of charge, to any person obtaining a copy
+" of this software and associated documentation files (the "Software"), to deal
+" in the Software without restriction, including without limitation the rights
+" to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+" copies of the Software, and to permit persons to whom the Software is
+" furnished to do so, subject to the following conditions:
+"
+" The above copyright notice and this permission notice shall be included in
+" all copies or substantial portions of the Software.
+"
+" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+" AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+" LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+" OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+" THE SOFTWARE.
+
+syn keyword llvmKeyword attributes
+syn match llvmNoName /#\d\+\>/

after/syntax/mdx.vim

@@ -0,0 +1,45 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'mdx') != -1
+  finish
+endif
+
+
+" based on mxw/vim-jsx
+
+if exists('b:current_syntax')
+  let s:current_syntax=b:current_syntax
+  unlet b:current_syntax
+endif
+syn include @XMLSyntax syntax/xml.vim
+if exists('s:current_syntax')
+  let b:current_syntax=s:current_syntax
+endif
+
+" JSX attributes should color as JS.  Note the trivial end pattern; we let
+" jsBlock take care of ending the region.
+syn region xmlString contained start=+{+ end=++ contains=jsBlock,javascriptBlock
+
+" 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.
+syn region jsxChild contained start=+{+ end=++ contains=jsBlock,javascriptBlock
+  \ extend
+
+" Highlight JSX regions as XML; recursively match.
+"
+" Note that we prohibit JSX tags from having a < or word character immediately
+" preceding it, to avoid conflicts with, respectively, the left shift operator
+" 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:\-.]*\)+
+  \ skip=+<!--\_.\{-}-->+
+  \ end=+</\z1\_\s\{-}>+
+  \ end=+/>+
+  \ keepend
+  \ extend
+
+" Add jsxRegion to the lowest-level JS syntax cluster.
+syn cluster jsExpression add=jsxRegion
+
+" Allow jsxRegion to contain reserved words.
+syn cluster javascriptNoReserved add=jsxRegion

after/syntax/objc.vim

@@ -0,0 +1,23 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'objc') != -1
+  finish
+endif
+
+" ARC type modifiers
+syn keyword objcTypeModifier __bridge __bridge_retained __bridge_transfer __autoreleasing __strong __weak __unsafe_unretained
+
+" Block modifiers
+syn keyword objcTypeModifier __block
+
+" Remote messaging modifiers
+syn keyword objcTypeModifier byref
+
+" Property keywords - these are only highlighted inside '@property (...)'
+syn keyword objcPropertyAttribute contained getter setter readwrite readonly strong weak copy assign retain nonatomic
+syn match objcProperty display "^\s*@property\>\s*([^)]*)" contains=objcPropertyAttribute
+
+" The @property directive must be defined after objcProperty or it won't be
+" highlighted
+syn match objcDirective "@property\|@synthesize\|@dynamic\|@package"
+
+" Highlight property attributes as if they were type modifiers
+hi def link objcPropertyAttribute objcTypeModifier

after/syntax/reason.vim

@@ -0,0 +1,4 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'reason') != -1
+  finish
+endif
+

after/syntax/rspec.vim

@@ -1,3 +1,7 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rspec') != -1
+  finish
+endif
+
 "
 " An rspec syntax file
 " Originally from http://www.vim.org/scripts/script.php?script_id=2286

after/syntax/ruby.vim

@@ -1,23 +1,7 @@
-" This file describes a very basic syntax for TomDoc comments in a Ruby file.
-"
-" For more information on TomDoc, check it out here: http://tomdoc.org/
-"
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'yard') != -1
+  finish
+endif
 
-syn keyword tomdocKeywords Returns containedin=rubyComment contained
-syn keyword tomdocKeywords Yields containedin=rubyComment contained
-syn keyword tomdocKeywords Raises containedin=rubyComment contained
-syn keyword tomdocKeywords Examples containedin=rubyComment contained
-syn keyword tomdocKeywords Signature containedin=rubyComment contained
-
-syn match tomdocArguments +\s*[A-Za-z0-9_\-&\*:]*\(\s*- \)+he=e-3 containedin=rubyComment contained
-
-syn match tomdocDescriptions +\s*Public:+he=e-1 containedin=rubyComment contained
-syn match tomdocDescriptions +\s*Internal:+he=e-1 containedin=rubyComment contained
-syn match tomdocDescriptions +\s*Deprecated:+he=e-1 containedin=rubyComment contained
-
-hi default link tomdocDescriptions String
-hi default link tomdocKeywords String
-hi default link tomdocArguments HELP
 " Ruby syntax extensions for highlighting YARD documentation.
 "
 " Author: Joel Holdbrooks <https://github.com/noprompt>

after/syntax/rust.vim

@@ -1,10 +1,16 @@
-if !exists('g:rust_conceal') || !has('conceal') || &enc != 'utf-8'
-	finish
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rust') != -1
+  finish
+endif
+
+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')
-	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= 
@@ -18,7 +24,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')
+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
@@ -26,8 +32,14 @@ endif
 
 hi link rustNiceOperator Operator
 
-if !exists('g:rust_conceal_mod_path')
+if !get(g:, 'rust_conceal_mod_path', 0)
     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
 
-setlocal conceallevel=2
+" vim: set et sw=4 sts=4 ts=8:

after/syntax/sass.vim

@@ -1,6 +0,0 @@
-" Language:     Colorful CSS Color Preview
-" Author:       Aristotle Pagaltzis <pagaltzis@gmx.de>
-
-if !( has('gui_running') || &t_Co==256 ) | finish | endif
-
-call css_color#init('css', 'sassCssAttribute,sassComment,sassCssComment')

after/syntax/stylus.vim

@@ -1,6 +0,0 @@
-" Language:     Colorful CSS Color Preview
-" Author:       Aristotle Pagaltzis <pagaltzis@gmx.de>
-
-if !( has('gui_running') || &t_Co==256 ) | finish | endif
-
-call css_color#init('css', 'stylusCssAttribute,stylusComment,cssComment')

after/syntax/tex.vim

@@ -1,3 +1,7 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'latex') != -1
+  finish
+endif
+
 " adds support for cleverref package
 " \Cref, \cref, \cpageref, \labelcref, \labelcpageref
 syn region texRefZone		matchgroup=texStatement start="\\Cref{"				end="}\|%stopzone\>"	contains=@texRefGroup

after/syntax/vim.vim

@@ -1,6 +0,0 @@
-" Language:     Colorful CSS Color Preview
-" Author:       Aristotle Pagaltzis <pagaltzis@gmx.de>
-
-if !( has('gui_running') || &t_Co==256 ) | finish | endif
-
-call css_color#init('any', 'vimHiGuiRgb,vimComment,vimLineComment')

after/syntax/yaml.vim

@@ -0,0 +1,65 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'yaml') != -1
+  finish
+endif
+
+" To make this file do stuff, add something like the following (without the
+" leading ") to your ~/.vimrc:
+" au BufNewFile,BufRead *.yaml,*.yml so ~/src/PyYaml/YAML.vim
+
+" Vim syntax/macro file
+" Language:	YAML
+" Author:	Igor Vergeichik <iverg@mail.ru>
+" Sponsor: Tom Sawyer <transami@transami.net>
+" Stayven: Ryan King <jking@panoptic.com>
+" Copyright (c) 2002 Tom Saywer
+
+" Add an item to a gangly list:
+"map , o<bs><bs><bs><bs>-<esc>o
+" Convert to Canonical form:
+"map \c :%!python -c 'from yaml.redump import redump; import sys; print redump(sys.stdin.read()).rstrip()'
+
+if version < 600
+  syntax clear
+endif
+syntax clear
+
+syn match yamlInline "[\[\]\{\}]"
+syn match yamlBlock "[>|]\d\?[+-]"
+
+syn region yamlComment	start="\#" end="$"
+syn match yamlIndicator	"#YAML:\S\+"
+
+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
+
+syn match  yamlType	"!\S\+"
+
+syn keyword yamlConstant NULL Null null NONE None none NIL Nil nil
+syn keyword yamlConstant TRUE True true YES Yes yes ON On on
+syn keyword yamlConstant FALSE False false NO No no OFF Off off
+
+syn match  yamlKey	"^\s*\zs[^ \t\"]\+\ze\s*:"
+syn match  yamlKey	"^\s*-\s*\zs[^ \t\"\']\+\ze\s*:"
+syn match  yamlAnchor	"&\S\+"
+syn match  yamlAlias	"*\S\+"
+
+" Setup the highlighting links
+
+hi link yamlConstant Keyword
+hi link yamlIndicator PreCondit
+hi link yamlAnchor	Function
+hi link yamlAlias	Function
+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,654 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'julia') != -1
+  finish
+endif
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" 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
+  if !has_key(b:, "l2u_keymap_set")
+    let b:l2u_keymap_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")
+    let s:l2u_esc_sequence = "\u0006"
+  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 that performs the substitution in command-line mode
+function! LaTeXtoUnicode#CmdTab(triggeredbytab)
+  " 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
+    if a:triggeredbytab
+      call feedkeys("\<Tab>", 'nt') " fall-back to the default <Tab>
+    endif
+    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
+    if a:triggeredbytab
+      call feedkeys("\<Tab>", 'nt') " fall-back to the default <Tab>
+    endif
+    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
+    let b:l2u_cmdtab_keys = get(g:, "latex_to_unicode_cmd_mapping", ['<Tab>','<S-Tab>'])
+    if type(b:l2u_cmdtab_keys) != type([]) " avoid using v:t_list for backward compatibility
+      let b:l2u_cmdtab_keys = [b:l2u_cmdtab_keys]
+    endif
+    for k in b:l2u_cmdtab_keys
+      exec 'cnoremap <buffer> '.k.' <C-\>eLaTeXtoUnicode#CmdTab('.(k ==? '<Tab>').')<CR>'
+    endfor
+    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
+    for k in b:l2u_cmdtab_keys
+      exec 'cunmap <buffer> '.k
+    endfor
+    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
+
+function! s:L2U_SetKeymap()
+  if !b:l2u_keymap_set && get(g:, "latex_to_unicode_keymap", 0) && b:l2u_enabled
+    setlocal keymap=latex2unicode
+    let b:l2u_keymap_set = 1
+  endif
+endfunction
+
+function! s:L2U_UnsetKeymap()
+  if !b:l2u_keymap_set
+    return
+  endif
+  setlocal keymap=
+  let b:l2u_keymap_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_UnsetKeymap()
+
+  call s:L2U_SetTab(wait_insert_enter)
+  call s:L2U_SetAutoSub(wait_insert_enter)
+  call s:L2U_SetKeymap()
+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

autoload/RstFold.vim

@@ -0,0 +1,66 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rst') != -1
+  finish
+endif
+
+" Author: Antony Lee <anntzer.lee@gmail.com>
+" Description: Helper functions for reStructuredText syntax folding
+" Last Modified: 2018-12-29
+
+function s:CacheRstFold()
+  if !g:rst_fold_enabled
+    return
+  endif
+
+  let closure = {'header_types': {}, 'max_level': 0, 'levels': {}}
+  function closure.Process(match) dict
+    let curline = getcurpos()[1]
+    if has_key(self.levels, curline - 1)
+      " For over+under-lined headers, the regex will match both at the
+      " overline and at the title itself; in that case, skip the second match.
+      return
+    endif
+    let lines = split(a:match, '\n')
+    let key = repeat(lines[-1][0], len(lines))
+    if !has_key(self.header_types, key)
+      let self.max_level += 1
+      let self.header_types[key] = self.max_level
+    endif
+    let self.levels[curline] = self.header_types[key]
+  endfunction
+  let save_cursor = getcurpos()
+  let save_mark = getpos("'[")
+  silent keeppatterns %s/\v^%(%(([=`:.'"~^_*+#-])\1+\n)?.{1,2}\n([=`:.'"~^_*+#-])\2+)|%(%(([=`:.''"~^_*+#-])\3{2,}\n)?.{3,}\n([=`:.''"~^_*+#-])\4{2,})$/\=closure.Process(submatch(0))/gn
+  call setpos('.', save_cursor)
+  call setpos("'[", save_mark)
+  let b:RstFoldCache = closure.levels
+endfunction
+
+function RstFold#GetRstFold()
+  if !g:rst_fold_enabled
+    return
+  endif
+
+  if !has_key(b:, 'RstFoldCache')
+    call s:CacheRstFold()
+  endif
+  if has_key(b:RstFoldCache, v:lnum)
+    return '>' . b:RstFoldCache[v:lnum]
+  else
+    return '='
+  endif
+endfunction
+
+function RstFold#GetRstFoldText()
+  if !g:rst_fold_enabled
+    return
+  endif
+
+  if !has_key(b:, 'RstFoldCache')
+    call s:CacheRstFold()
+  endif
+  let indent = repeat('  ', b:RstFoldCache[v:foldstart] - 1)
+  let thisline = getline(v:foldstart)
+  " For over+under-lined headers, skip the overline.
+  let text = thisline =~ '^\([=`:.''"~^_*+#-]\)\1\+$' ? getline(v:foldstart + 1) : thisline
+  return indent . text
+endfunction

autoload/cargo.vim

@@ -0,0 +1,119 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rust') != -1
+  finish
+endif
+
+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
+
+function! cargo#runtarget(args)
+    let l:filename = expand('%:p')
+    let l:read_manifest = system('cargo read-manifest')
+    let l:metadata = json_decode(l:read_manifest)
+    let l:targets = get(l:metadata, 'targets', [])
+    let l:did_run = 0
+    for l:target in l:targets
+        let l:src_path = get(l:target, 'src_path', '')
+        let l:kinds = get(l:target, 'kind', [])
+        let l:name = get(l:target, 'name', '')
+        if l:src_path == l:filename
+        if index(l:kinds, 'example') != -1
+            let l:did_run = 1
+            call cargo#run("--example " . shellescape(l:name) . " " . a:args)
+            return
+        elseif index(l:kinds, 'bin') != -1
+            let l:did_run = 1
+            call cargo#run("--bin " . shellescape(l:name) . " " . a:args)
+            return
+        endif
+        endif
+    endfor
+    if l:did_run != 1
+        call cargo#run(a:args)
+        return
+    endif
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:

autoload/cargo/quickfix.vim

@@ -0,0 +1,30 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rust') != -1
+  finish
+endif
+
+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 exists("b:rust_compiler_cargo_qf_prev_cd_saved") && 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:

autoload/coffee.vim

@@ -1,5 +1,9 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'coffee-script') != -1
+  finish
+endif
+
 " Language:    CoffeeScript
-" Maintainer:  Mick Koch <kchmck@gmail.com>
+" Maintainer:  Mick Koch <mick@kochm.co>
 " URL:         http://github.com/kchmck/vim-coffee-script
 " License:     WTFPL
 

autoload/crystal_lang.vim

@@ -0,0 +1,344 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'crystal') != -1
+  finish
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+let s:V = vital#crystal#new()
+let s:P = s:V.import('Process')
+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
+        echomsg a:msg
+    else
+        echomsg call('printf', [a:msg] + a:000)
+    endif
+    echohl None
+endfunction
+
+function! s:run_cmd(cmd) abort
+    if !executable(g:crystal_compiler_command)
+        throw "vim-crystal: Error: '" . g:crystal_compiler_command . "' command is not found."
+    endif
+    return s:P.system(a:cmd)
+endfunction
+
+function! s:find_root_by(search_dir, d) abort
+    let found_dir = finddir(a:search_dir, a:d . ';')
+    if found_dir ==# ''
+        return ''
+    endif
+
+    " Note: ':h:h' for {root}/{search_dir}/ -> {root}/{search_dir} -> {root}
+    return fnamemodify(found_dir, ':p:h:h')
+endfunction
+
+" Search the root directory containing a 'spec/' and a 'src/' directories.
+"
+" Searching for the 'spec/' directory is not enough: for example the crystal
+" compiler has a 'cr_sources/src/spec/' directory that would otherwise give the root
+" directory as 'cr_source/src/' instead of 'cr_sources/'.
+function! s:find_root_by_spec_and_src(d) abort
+    " Search for 'spec/'
+    let root = s:find_root_by('spec', a:d)
+    " Check that 'src/' is also there
+    if root !=# '' && isdirectory(root . '/src')
+        return root
+    endif
+
+    " Search for 'src/'
+    let root = s:find_root_by('src', a:d)
+    " Check that 'spec/' is also there
+    if root !=# '' && isdirectory(root . '/spec')
+        return root
+    endif
+
+    " Cannot find a directory containing both 'src/' and 'spec/'
+    return ''
+endfunction
+
+function! crystal_lang#entrypoint_for(file_path) abort
+    let parent_dir = fnamemodify(a:file_path, ':p:h')
+    let root_dir = s:find_root_by_spec_and_src(parent_dir)
+    if root_dir ==# ''
+        " No spec directory found. No need to make temporary file
+        return a:file_path
+    endif
+
+    let temp_name = root_dir . '/__vim-crystal-temporary-entrypoint-' . fnamemodify(a:file_path, ':t')
+    let contents = [
+                \   'require "spec"',
+                \   'require "./spec/**"',
+                \   printf('require "./%s"', fnamemodify(a:file_path, ':p')[strlen(root_dir)+1 : ])
+                \ ]
+
+    let result = writefile(contents, temp_name)
+    if result == -1
+        " Note: When writefile() failed
+        return a:file_path
+    endif
+
+    return temp_name
+endfunction
+
+function! crystal_lang#tool(name, file, pos, option_str) abort
+    let entrypoint = crystal_lang#entrypoint_for(a:file)
+    let cmd = printf(
+                \   '%s tool %s --no-color %s --cursor %s:%d:%d %s',
+                \   g:crystal_compiler_command,
+                \   a:name,
+                \   a:option_str,
+                \   a:file,
+                \   a:pos[1],
+                \   a:pos[2],
+                \   entrypoint
+                \ )
+
+    try
+        let output = s:run_cmd(cmd)
+        return {'failed': s:P.get_last_status(), 'output': output}
+    finally
+        " Note:
+        " If the entry point is temporary file, delete it finally.
+        if a:file !=# entrypoint
+            call delete(entrypoint)
+        endif
+    endtry
+endfunction
+
+" `pos` is assumed a returned value from getpos()
+function! crystal_lang#impl(file, pos, option_str) abort
+    return crystal_lang#tool('implementations', a:file, a:pos, a:option_str)
+endfunction
+
+function! s:jump_to_impl(impl) abort
+    execute 'edit' a:impl.filename
+    call cursor(a:impl.line, a:impl.column)
+endfunction
+
+function! crystal_lang#jump_to_definition(file, pos) abort
+    echo 'analyzing definitions under cursor...'
+
+    let cmd_result = crystal_lang#impl(a:file, a:pos, '--format json')
+    if cmd_result.failed
+        return s:echo_error(cmd_result.output)
+    endif
+
+    let impl = s:decode_json(cmd_result.output)
+    if impl.status !=# 'ok'
+        return s:echo_error(impl.message)
+    endif
+
+    if len(impl.implementations) == 1
+        call s:jump_to_impl(impl.implementations[0])
+        return
+    endif
+
+    let message = "Multiple definitions detected.  Choose a number\n\n"
+    for idx in range(len(impl.implementations))
+        let i = impl.implementations[idx]
+        let message .= printf("[%d] %s:%d:%d\n", idx, i.filename, i.line, i.column)
+    endfor
+    let message .= "\n"
+    let idx = str2nr(input(message, "\n> "))
+    call s:jump_to_impl(impl.implementations[idx])
+endfunction
+
+function! crystal_lang#context(file, pos, option_str) abort
+    return crystal_lang#tool('context', a:file, a:pos, a:option_str)
+endfunction
+
+function! crystal_lang#type_hierarchy(file, option_str) abort
+    let cmd = printf(
+                \   '%s tool hierarchy --no-color %s %s',
+                \   g:crystal_compiler_command,
+                \   a:option_str,
+                \   a:file
+                \ )
+
+    return s:run_cmd(cmd)
+endfunction
+
+function! s:find_completion_start() abort
+    let c = col('.')
+    if c <= 1
+        return -1
+    endif
+
+    let line = getline('.')[:c-2]
+    return match(line, '\w\+$')
+endfunction
+
+function! crystal_lang#complete(findstart, base) abort
+    if a:findstart
+        return s:find_completion_start()
+    endif
+
+    let cmd_result = crystal_lang#context(expand('%'), getpos('.'), '--format json')
+    if cmd_result.failed
+        return
+    endif
+
+    let contexts = s:decode_json(cmd_result.output)
+    if contexts.status !=# 'ok'
+        return
+    endif
+
+    let candidates = []
+
+    for c in contexts.contexts
+        for [name, desc] in items(c)
+            let candidates += [{
+                        \   'word': name,
+                        \   'menu': ': ' . desc . ' [var]',
+                        \ }]
+        endfor
+    endfor
+
+    return candidates
+endfunction
+
+function! crystal_lang#get_spec_switched_path(absolute_path) abort
+    let base = fnamemodify(a:absolute_path, ':t:r')
+
+    " TODO: Make cleverer
+    if base =~# '_spec$'
+        let parent = fnamemodify(substitute(a:absolute_path, '/spec/', '/src/', ''), ':h')
+        return parent . '/' . matchstr(base, '.\+\ze_spec$') . '.cr'
+    else
+        let parent = fnamemodify(substitute(a:absolute_path, '/src/', '/spec/', ''), ':h')
+        return parent . '/' . base . '_spec.cr'
+    endif
+endfunction
+
+function! crystal_lang#switch_spec_file(...) abort
+    let path = a:0 == 0 ? expand('%:p') : fnamemodify(a:1, ':p')
+    if path !~# '.cr$'
+        return s:echo_error('Not crystal source file: ' . path)
+    endif
+
+    execute 'edit!' crystal_lang#get_spec_switched_path(path)
+endfunction
+
+function! s:run_spec(root, path, ...) abort
+    " Note:
+    " `crystal spec` can't understand absolute path.
+    let cmd = printf(
+            \   '%s spec %s%s',
+            \   g:crystal_compiler_command,
+            \   a:path,
+            \   a:0 == 0 ? '' : (':' . a:1)
+            \ )
+
+    let saved_cwd = getcwd()
+    let cd = haslocaldir() ? 'lcd' : 'cd'
+    try
+        execute cd a:root
+        call s:C.echo(s:run_cmd(cmd))
+    finally
+        execute cd saved_cwd
+    endtry
+endfunction
+
+function! crystal_lang#run_all_spec(...) abort
+    let path = a:0 == 0 ? expand('%:p:h') : a:1
+    let root_path = s:find_root_by_spec_and_src(path)
+    if root_path ==# ''
+        return s:echo_error("'spec' directory is not found")
+    endif
+    call s:run_spec(root_path, 'spec')
+endfunction
+
+function! crystal_lang#run_current_spec(...) abort
+    " /foo/bar/src/poyo.cr
+    let path = a:0 == 0 ? expand('%:p') : fnamemodify(a:1, ':p')
+    if path !~# '.cr$'
+        return s:echo_error('Not crystal source file: ' . path)
+    endif
+
+    " /foo/bar/src
+    let source_dir = fnamemodify(path, ':h')
+
+    " /foo/bar
+    let root_dir = s:find_root_by_spec_and_src(source_dir)
+    if root_dir ==# ''
+        return s:echo_error("Root directory with 'src/' and 'spec/' not found")
+    endif
+
+    " src
+    let rel_path = source_dir[strlen(root_dir)+1 : ]
+
+    if path =~# '_spec.cr$'
+        call s:run_spec(root_dir, path[strlen(root_dir)+1 : ], line('.'))
+    else
+        let spec_path = substitute(rel_path, '^src', 'spec', '') . '/' . fnamemodify(path, ':t:r') . '_spec.cr'
+        if !filereadable(root_dir . '/' . spec_path)
+            return s:echo_error('Error: Could not find a spec source corresponding to ' . path)
+        endif
+        call s:run_spec(root_dir, spec_path)
+    endif
+endfunction
+
+function! crystal_lang#format_string(code, ...) abort
+    let cmd = printf(
+            \   '%s tool format --no-color %s -',
+            \   g:crystal_compiler_command,
+            \   get(a:, 1, '')
+            \ )
+    let output = s:P.system(cmd, a:code)
+    if s:P.get_last_status()
+        throw 'vim-crystal: Error on formatting: ' . output
+    endif
+    return output
+endfunction
+
+" 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 on_save = a:0 > 0 ? a:1 : 0
+
+    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
+
+    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
+unlet s:save_cpo

autoload/css_color.vim

@@ -1,559 +0,0 @@
-" Language:     Colorful CSS Color Preview
-" Author:       Aristotle Pagaltzis <pagaltzis@gmx.de>
-" Last Change:  2014-01-14
-" Licence:      No Warranties. WTFPL. But please tell me!
-" Version:      1.0
-
-if v:version < 700
-	echoerr printf('Vim 7 is required for css-color (this is only %d.%d)',v:version/100,v:version%100)
-	finish
-endif
-
-if !( has('gui_running') || &t_Co==256 ) | finish | endif
-
-function! s:rgb2color(r,g,b)
-	" Convert 80% -> 204, 100% -> 255, etc.
-	let rgb = map( [a:r,a:g,a:b], 'v:val =~ "%$" ? ( 255 * v:val ) / 100 : v:val' )
-	return printf( '%02x%02x%02x', rgb[0], rgb[1], rgb[2] )
-endfunction
-
-function! s:hsl2color(h,s,l)
-	" Convert 80% -> 0.8, 100% -> 1.0, etc.
-	let [s,l] = map( [a:s, a:l], 'v:val =~ "%$" ? v:val / 100.0 : v:val + 0.0' )
-	" algorithm transcoded to vim from http://www.w3.org/TR/css3-color/#hsl-color
-	let hh = ( a:h % 360 ) / 360.0
-	let m2 = l <= 0.5 ? l * ( s + 1 ) : l + s - l * s
-	let m1 = l * 2 - m2
-	let rgb = []
-	for h in [ hh + (1/3.0), hh, hh - (1/3.0) ]
-		let h = h < 0 ? h + 1 : h > 1 ? h - 1 : h
-		let v =
-			\ h * 6 < 1 ? m1 + ( m2 - m1 ) * h * 6 :
-			\ h * 2 < 1 ? m2 :
-			\ h * 3 < 2 ? m1 + ( m2 - m1 ) * ( 2/3.0 - h ) * 6 :
-			\ m1
-		if v > 1.0 | return '' | endif
-		let rgb += [ float2nr( 255 * v ) ]
-	endfor
-	return printf( '%02x%02x%02x', rgb[0], rgb[1], rgb[2] )
-endfunction
-
-let s:hex={}
-for i in range(0, 255)
-	let s:hex[ printf( '%02x', i ) ] = i
-endfor
-
-if has('gui_running')
-	let s:is_gui = 1
-else
-	let s:is_gui = 0
-
-	" preset 16 vt100 colors
-	let s:xtermcolor = [
-		\ [ 0x00, 0x00, 0x00,  0 ],
-		\ [ 0xCD, 0x00, 0x00,  1 ],
-		\ [ 0x00, 0xCD, 0x00,  2 ],
-		\ [ 0xCD, 0xCD, 0x00,  3 ],
-		\ [ 0x00, 0x00, 0xEE,  4 ],
-		\ [ 0xCD, 0x00, 0xCD,  5 ],
-		\ [ 0x00, 0xCD, 0xCD,  6 ],
-		\ [ 0xE5, 0xE5, 0xE5,  7 ],
-		\ [ 0x7F, 0x7F, 0x7F,  8 ],
-		\ [ 0xFF, 0x00, 0x00,  9 ],
-		\ [ 0x00, 0xFF, 0x00, 10 ],
-		\ [ 0xFF, 0xFF, 0x00, 11 ],
-		\ [ 0x5C, 0x5C, 0xFF, 12 ],
-		\ [ 0xFF, 0x00, 0xFF, 13 ],
-		\ [ 0x00, 0xFF, 0xFF, 14 ],
-		\ [ 0xFF, 0xFF, 0xFF, 15 ]]
-	" grayscale ramp
-	" (value is 8+10*lum for lum in 0..23)
-	let s:xtermcolor += [
-		\ [ 0x08, 0x08, 0x08, 232 ],
-		\ [ 0x12, 0x12, 0x12, 233 ],
-		\ [ 0x1C, 0x1C, 0x1C, 234 ],
-		\ [ 0x26, 0x26, 0x26, 235 ],
-		\ [ 0x30, 0x30, 0x30, 236 ],
-		\ [ 0x3A, 0x3A, 0x3A, 237 ],
-		\ [ 0x44, 0x44, 0x44, 238 ],
-		\ [ 0x4E, 0x4E, 0x4E, 239 ],
-		\ [ 0x58, 0x58, 0x58, 240 ],
-		\ [ 0x62, 0x62, 0x62, 241 ],
-		\ [ 0x6C, 0x6C, 0x6C, 242 ],
-		\ [ 0x76, 0x76, 0x76, 243 ],
-		\ [ 0x80, 0x80, 0x80, 244 ],
-		\ [ 0x8A, 0x8A, 0x8A, 245 ],
-		\ [ 0x94, 0x94, 0x94, 246 ],
-		\ [ 0x9E, 0x9E, 0x9E, 247 ],
-		\ [ 0xA8, 0xA8, 0xA8, 248 ],
-		\ [ 0xB2, 0xB2, 0xB2, 249 ],
-		\ [ 0xBC, 0xBC, 0xBC, 250 ],
-		\ [ 0xC6, 0xC6, 0xC6, 251 ],
-		\ [ 0xD0, 0xD0, 0xD0, 252 ],
-		\ [ 0xDA, 0xDA, 0xDA, 253 ],
-		\ [ 0xE4, 0xE4, 0xE4, 254 ],
-		\ [ 0xEE, 0xEE, 0xEE, 255 ]]
-
-	" the 6 values used in the xterm color cube
-	"                    0    95   135   175   215   255
-	let s:cubergb = [ 0x00, 0x5F, 0x87, 0xAF, 0xD7, 0xFF ]
-
-	" 0..255 mapped to 0..5 based on the color cube values
-	let s:xvquant = repeat([0],48)
-				\ + repeat([1],68)
-				\ + repeat([2],40)
-				\ + repeat([3],40)
-				\ + repeat([4],40)
-				\ + repeat([5],20)
-	" tweak the mapping for the exact matches (0 and 1 already correct)
-	let s:xvquant[s:cubergb[2]] = 2
-	let s:xvquant[s:cubergb[3]] = 3
-	let s:xvquant[s:cubergb[4]] = 4
-	let s:xvquant[s:cubergb[5]] = 5
-
-	" selects the nearest xterm color for a rgb value like #FF0000
-	function! s:rgb2xterm(color)
-		let best_match=0
-		let smallest_distance = 10000000000
-		let color = tolower(a:color)
-		let r = s:hex[color[0:1]]
-		let g = s:hex[color[2:3]]
-		let b = s:hex[color[4:5]]
-
-		let vr = s:xvquant[r]
-		let vg = s:xvquant[g]
-		let vb = s:xvquant[b]
-		let cidx = vr * 36 + vg * 6 + vb + 16
-		let ccol = [ s:cubergb[vr], s:cubergb[vg], s:cubergb[vb], cidx ]
-
-		for [tr,tg,tb,idx] in [ ccol ] + s:xtermcolor
-			let dr = tr - r
-			let dg = tg - g
-			let db = tb - b
-			let distance = dr*dr + dg*dg + db*db
-			if distance == 0 | return idx | endif
-			if distance > smallest_distance | continue | endif
-			let smallest_distance = distance
-			let best_match = idx
-		endfor
-		return best_match
-	endfunction
-endif
-
-let s:pattern_color = {}
-let s:color_fg      = {}
-let s:color_bg      = {}
-let [s:hi_cmd, s:black, s:white] = s:is_gui
-	\ ? ['hi %s  guibg=#%s   guifg=%s', '#000000', '#ffffff']
-	\ : ['hi %s ctermbg=%s ctermfg=%s', 0, 15]
-function! s:create_syn_match()
-
-	let pattern = submatch(0)
-
-	if has_key( b:has_pattern_syn, pattern ) | return | endif
-	let b:has_pattern_syn[pattern] = 1
-
-	let rgb_color = get( s:pattern_color, pattern, '' )
-
-	if ! strlen( rgb_color )
-		let hexcolor = submatch(1)
-		let funcname = submatch(2)
-
-		if funcname == 'rgb'
-			let rgb_color = s:rgb2color(submatch(3),submatch(4),submatch(5))
-		elseif funcname == 'hsl'
-			let rgb_color = s:hsl2color(submatch(3),submatch(4),submatch(5))
-		elseif strlen(hexcolor) == 6
-			let rgb_color = tolower(hexcolor)
-		elseif strlen(hexcolor) == 3
-			let rgb_color = substitute(tolower(hexcolor), '\(.\)', '\1\1', 'g')
-		else
-			throw 'css_color: create_syn_match invoked on bad match data'
-		endif
-
-		let s:pattern_color[pattern] = rgb_color
-	endif
-
-	if ! has_key( b:has_color_hi, rgb_color )
-		" check GUI flag early here to avoid pure-overhead caching
-		let syn_bg = s:is_gui ? rgb_color : get( s:color_bg, rgb_color, '' )
-		if ! strlen(syn_bg)
-			let syn_bg = s:rgb2xterm(rgb_color)
-			let s:color_bg[rgb_color] = syn_bg
-		endif
-
-		let syn_fg = get( s:color_fg, rgb_color, '' )
-		if ! strlen(syn_fg)
-			let r = s:hex[rgb_color[0:1]]
-			let g = s:hex[rgb_color[2:3]]
-			let b = s:hex[rgb_color[4:5]]
-			let syn_fg = r*30 + g*59 + b*11 > 12000 ? s:black : s:white
-			let s:color_fg[rgb_color] = syn_fg
-		endif
-	endif
-
-	let group = 'BG' . rgb_color
-
-	if ! has_key( b:has_color_hi, rgb_color )
-		exe printf( s:hi_cmd, group, syn_bg, syn_fg )
-		let b:has_color_hi[rgb_color] = 1
-	endif
-
-	" iff pattern ends on word character, require word break to match
-	if pattern =~ '\>$' | let pattern .= '\>' | endif
-	exe 'syn match' group '/'.escape(pattern, '/').'/ contained containedin=@colorableGroup'
-
-	return ''
-endfunction
-
-function! s:update_matches()
-	call filter(b:color_match_id, 'matchdelete(v:val)')
-	if &l:cursorline
-		" adds matches based that duplicate the highlighted colors on the current line
-		let lnr = line('.')
-		let group = ''
-		let groupstart = 0
-		let endcol = col('$')
-		for col in range( 1, endcol )
-			let nextgroup = col < endcol ? synIDattr( synID( lnr, col, 1 ), 'name' ) : ''
-			if group == nextgroup | continue | endif
-			if group =~ '^BG\x\{6}$'
-				let regex = '\%'.lnr.'l\%'.groupstart.'c'.repeat( '.', col - groupstart )
-				let match = matchadd( group, regex, -1 )
-				let b:color_match_id += [ match ]
-			endif
-			let group = nextgroup
-			let groupstart = col
-		endfor
-	endif
-endfunction
-
-let s:_hexcolor   = '#\(\x\{3}\|\x\{6}\)\>' " submatch 1
-let s:_funcname   = '\(rgb\|hsl\)a\?' " submatch 2
-let s:_numval     = '\(\d\{1,3}%\?\)' " submatch 3,4,5
-let s:_ws_        = '\s*'
-let s:_listsep    = s:_ws_ . ',' . s:_ws_
-let s:_otherargs_ = '\%(,[^)]*\)\?'
-let s:_funcexpr   = s:_funcname . '[(]' . s:_numval . s:_listsep . s:_numval . s:_listsep . s:_numval . s:_ws_ . s:_otherargs_ . '[)]'
-let s:_csscolor   = s:_hexcolor . '\|' . s:_funcexpr
-" N.B. these substitute() calls are here just for the side effect
-"      of invoking s:create_syn_match during substitution -- because
-"      match() and friends do not allow finding all matches in a single
-"      scan without examining the start of the string over and over
-function! s:parse_css_screen()
-	call substitute( join( getline('w0','w$'), "\n" ), s:_csscolor, '\=s:create_syn_match()', 'g' )
-	call s:update_matches()
-endfunction
-function! s:parse_any_screen()
-	call substitute( join( getline('w0','w$'), "\n" ), s:_hexcolor, '\=s:create_syn_match()', 'g' )
-	call s:update_matches()
-endfunction
-
-""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-
-function! css_color#init(type, groups)
-	exe 'syn cluster colorableGroup contains=' . a:groups
-
-	let b:has_color_hi    = {}
-	let b:has_pattern_syn = {}
-	let b:color_match_id  = []
-
-	augroup CSSColor
-		autocmd! * <buffer>
-		exe 'autocmd CursorMoved,CursorMovedI <buffer> call s:parse_'.a:type.'_screen()'
-	augroup END
-
-	do CSSColor CursorMoved <buffer>
-
-	if a:type != 'css' | return | endif
-
-	hi BG000000 guibg=#000000 guifg=#FFFFFF ctermbg=16  ctermfg=231
-	hi BG000080 guibg=#000080 guifg=#FFFFFF ctermbg=235 ctermfg=231
-	hi BG00008b guibg=#00008B guifg=#FFFFFF ctermbg=4   ctermfg=231
-	hi BG0000cd guibg=#0000CD guifg=#FFFFFF ctermbg=4   ctermfg=231
-	hi BG0000ff guibg=#0000FF guifg=#FFFFFF ctermbg=4   ctermfg=231
-	hi BG006400 guibg=#006400 guifg=#FFFFFF ctermbg=235 ctermfg=231
-	hi BG008000 guibg=#008000 guifg=#FFFFFF ctermbg=2   ctermfg=231
-	hi BG008080 guibg=#008080 guifg=#FFFFFF ctermbg=30  ctermfg=231
-	hi BG008b8b guibg=#008B8B guifg=#FFFFFF ctermbg=30  ctermfg=231
-	hi BG00bfff guibg=#00BFFF guifg=#000000 ctermbg=6   ctermfg=16
-	hi BG00ced1 guibg=#00CED1 guifg=#000000 ctermbg=6   ctermfg=16
-	hi BG00fa9a guibg=#00FA9A guifg=#000000 ctermbg=6   ctermfg=16
-	hi BG00ff00 guibg=#00FF00 guifg=#000000 ctermbg=10  ctermfg=16
-	hi BG00ff7f guibg=#00FF7F guifg=#000000 ctermbg=6   ctermfg=16
-	hi BG00ffff guibg=#00FFFF guifg=#000000 ctermbg=51  ctermfg=16
-	hi BG191970 guibg=#191970 guifg=#FFFFFF ctermbg=237 ctermfg=231
-	hi BG1e90ff guibg=#1E90FF guifg=#000000 ctermbg=12  ctermfg=16
-	hi BG20b2aa guibg=#20B2AA guifg=#000000 ctermbg=37  ctermfg=16
-	hi BG228b22 guibg=#228B22 guifg=#FFFFFF ctermbg=2   ctermfg=231
-	hi BG2e8b57 guibg=#2E8B57 guifg=#FFFFFF ctermbg=240 ctermfg=231
-	hi BG2f4f4f guibg=#2F4F4F guifg=#FFFFFF ctermbg=238 ctermfg=231
-	hi BG32cd32 guibg=#32CD32 guifg=#000000 ctermbg=2   ctermfg=16
-	hi BG3cb371 guibg=#3CB371 guifg=#000000 ctermbg=71  ctermfg=16
-	hi BG40e0d0 guibg=#40E0D0 guifg=#000000 ctermbg=80  ctermfg=16
-	hi BG4169e1 guibg=#4169E1 guifg=#FFFFFF ctermbg=12  ctermfg=231
-	hi BG4682b4 guibg=#4682B4 guifg=#FFFFFF ctermbg=67  ctermfg=231
-	hi BG483d8b guibg=#483D8B guifg=#FFFFFF ctermbg=240 ctermfg=231
-	hi BG48d1cc guibg=#48D1CC guifg=#000000 ctermbg=80  ctermfg=16
-	hi BG4b0082 guibg=#4B0082 guifg=#FFFFFF ctermbg=238 ctermfg=231
-	hi BG556b2f guibg=#556B2F guifg=#FFFFFF ctermbg=239 ctermfg=231
-	hi BG5f9ea0 guibg=#5F9EA0 guifg=#000000 ctermbg=73  ctermfg=16
-	hi BG6495ed guibg=#6495ED guifg=#000000 ctermbg=12  ctermfg=16
-	hi BG66cdaa guibg=#66CDAA guifg=#000000 ctermbg=79  ctermfg=16
-	hi BG696969 guibg=#696969 guifg=#FFFFFF ctermbg=242 ctermfg=231
-	hi BG6a5acd guibg=#6A5ACD guifg=#FFFFFF ctermbg=12  ctermfg=231
-	hi BG6b8e23 guibg=#6B8E23 guifg=#FFFFFF ctermbg=241 ctermfg=231
-	hi BG708090 guibg=#708090 guifg=#000000 ctermbg=66  ctermfg=16
-	hi BG778899 guibg=#778899 guifg=#000000 ctermbg=102 ctermfg=16
-	hi BG7b68ee guibg=#7B68EE guifg=#000000 ctermbg=12  ctermfg=16
-	hi BG7cfc00 guibg=#7CFC00 guifg=#000000 ctermbg=3   ctermfg=16
-	hi BG7fff00 guibg=#7FFF00 guifg=#000000 ctermbg=3   ctermfg=16
-	hi BG7fffd4 guibg=#7FFFD4 guifg=#000000 ctermbg=122 ctermfg=16
-	hi BG800000 guibg=#800000 guifg=#FFFFFF ctermbg=88  ctermfg=231
-	hi BG800080 guibg=#800080 guifg=#FFFFFF ctermbg=240 ctermfg=231
-	hi BG808000 guibg=#808000 guifg=#FFFFFF ctermbg=240 ctermfg=231
-	hi BG808080 guibg=#808080 guifg=#000000 ctermbg=244 ctermfg=16
-	hi BG87ceeb guibg=#87CEEB guifg=#000000 ctermbg=117 ctermfg=16
-	hi BG87cefa guibg=#87CEFA guifg=#000000 ctermbg=117 ctermfg=16
-	hi BG8a2be2 guibg=#8A2BE2 guifg=#FFFFFF ctermbg=12  ctermfg=231
-	hi BG8b0000 guibg=#8B0000 guifg=#FFFFFF ctermbg=88  ctermfg=231
-	hi BG8b008b guibg=#8B008B guifg=#FFFFFF ctermbg=5   ctermfg=231
-	hi BG8b4513 guibg=#8B4513 guifg=#FFFFFF ctermbg=94  ctermfg=231
-	hi BG8fbc8f guibg=#8FBC8F guifg=#000000 ctermbg=108 ctermfg=16
-	hi BG90ee90 guibg=#90EE90 guifg=#000000 ctermbg=249 ctermfg=16
-	hi BG9370d8 guibg=#9370D8 guifg=#000000 ctermbg=12  ctermfg=16
-	hi BG9400d3 guibg=#9400D3 guifg=#FFFFFF ctermbg=5   ctermfg=231
-	hi BG98fb98 guibg=#98FB98 guifg=#000000 ctermbg=250 ctermfg=16
-	hi BG9932cc guibg=#9932CC guifg=#FFFFFF ctermbg=5   ctermfg=231
-	hi BG9acd32 guibg=#9ACD32 guifg=#000000 ctermbg=3   ctermfg=16
-	hi BGa0522d guibg=#A0522D guifg=#FFFFFF ctermbg=130 ctermfg=231
-	hi BGa52a2a guibg=#A52A2A guifg=#FFFFFF ctermbg=124 ctermfg=231
-	hi BGa9a9a9 guibg=#A9A9A9 guifg=#000000 ctermbg=248 ctermfg=16
-	hi BGadd8e6 guibg=#ADD8E6 guifg=#000000 ctermbg=152 ctermfg=16
-	hi BGadff2f guibg=#ADFF2F guifg=#000000 ctermbg=3   ctermfg=16
-	hi BGafeeee guibg=#AFEEEE guifg=#000000 ctermbg=159 ctermfg=16
-	hi BGb0c4de guibg=#B0C4DE guifg=#000000 ctermbg=152 ctermfg=16
-	hi BGb0e0e6 guibg=#B0E0E6 guifg=#000000 ctermbg=152 ctermfg=16
-	hi BGb22222 guibg=#B22222 guifg=#FFFFFF ctermbg=124 ctermfg=231
-	hi BGb8860b guibg=#B8860B guifg=#000000 ctermbg=3   ctermfg=16
-	hi BGba55d3 guibg=#BA55D3 guifg=#000000 ctermbg=5   ctermfg=16
-	hi BGbc8f8f guibg=#BC8F8F guifg=#000000 ctermbg=138 ctermfg=16
-	hi BGbdb76b guibg=#BDB76B guifg=#000000 ctermbg=247 ctermfg=16
-	hi BGc0c0c0 guibg=#C0C0C0 guifg=#000000 ctermbg=250 ctermfg=16
-	hi BGc71585 guibg=#C71585 guifg=#FFFFFF ctermbg=5   ctermfg=231
-	hi BGcd5c5c guibg=#CD5C5C guifg=#000000 ctermbg=167 ctermfg=16
-	hi BGcd853f guibg=#CD853F guifg=#000000 ctermbg=173 ctermfg=16
-	hi BGd2691e guibg=#D2691E guifg=#000000 ctermbg=166 ctermfg=16
-	hi BGd2b48c guibg=#D2B48C guifg=#000000 ctermbg=180 ctermfg=16
-	hi BGd3d3d3 guibg=#D3D3D3 guifg=#000000 ctermbg=252 ctermfg=16
-	hi BGd87093 guibg=#D87093 guifg=#000000 ctermbg=168 ctermfg=16
-	hi BGd8bfd8 guibg=#D8BFD8 guifg=#000000 ctermbg=252 ctermfg=16
-	hi BGda70d6 guibg=#DA70D6 guifg=#000000 ctermbg=249 ctermfg=16
-	hi BGdaa520 guibg=#DAA520 guifg=#000000 ctermbg=3   ctermfg=16
-	hi BGdc143c guibg=#DC143C guifg=#FFFFFF ctermbg=161 ctermfg=231
-	hi BGdcdcdc guibg=#DCDCDC guifg=#000000 ctermbg=253 ctermfg=16
-	hi BGdda0dd guibg=#DDA0DD guifg=#000000 ctermbg=182 ctermfg=16
-	hi BGdeb887 guibg=#DEB887 guifg=#000000 ctermbg=180 ctermfg=16
-	hi BGe0ffff guibg=#E0FFFF guifg=#000000 ctermbg=195 ctermfg=16
-	hi BGe6e6fa guibg=#E6E6FA guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGe9967a guibg=#E9967A guifg=#000000 ctermbg=174 ctermfg=16
-	hi BGee82ee guibg=#EE82EE guifg=#000000 ctermbg=251 ctermfg=16
-	hi BGeee8aa guibg=#EEE8AA guifg=#000000 ctermbg=223 ctermfg=16
-	hi BGf08080 guibg=#F08080 guifg=#000000 ctermbg=210 ctermfg=16
-	hi BGf0e68c guibg=#F0E68C guifg=#000000 ctermbg=222 ctermfg=16
-	hi BGf0f8ff guibg=#F0F8FF guifg=#000000 ctermbg=15  ctermfg=16
-	hi BGf0fff0 guibg=#F0FFF0 guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGf0ffff guibg=#F0FFFF guifg=#000000 ctermbg=15  ctermfg=16
-	hi BGf4a460 guibg=#F4A460 guifg=#000000 ctermbg=215 ctermfg=16
-	hi BGf5deb3 guibg=#F5DEB3 guifg=#000000 ctermbg=223 ctermfg=16
-	hi BGf5f5dc guibg=#F5F5DC guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGf5f5f5 guibg=#F5F5F5 guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGf5fffa guibg=#F5FFFA guifg=#000000 ctermbg=15  ctermfg=16
-	hi BGf8f8ff guibg=#F8F8FF guifg=#000000 ctermbg=15  ctermfg=16
-	hi BGfa8072 guibg=#FA8072 guifg=#000000 ctermbg=209 ctermfg=16
-	hi BGfaebd7 guibg=#FAEBD7 guifg=#000000 ctermbg=7   ctermfg=16
-	hi BGfaf0e6 guibg=#FAF0E6 guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGfafad2 guibg=#FAFAD2 guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGfdf5e6 guibg=#FDF5E6 guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGff0000 guibg=#FF0000 guifg=#FFFFFF ctermbg=196 ctermfg=231
-	hi BGff00ff guibg=#FF00FF guifg=#FFFFFF ctermbg=13  ctermfg=231
-	hi BGff1493 guibg=#FF1493 guifg=#FFFFFF ctermbg=5   ctermfg=231
-	hi BGff4500 guibg=#FF4500 guifg=#FFFFFF ctermbg=9   ctermfg=231
-	hi BGff6347 guibg=#FF6347 guifg=#000000 ctermbg=203 ctermfg=16
-	hi BGff69b4 guibg=#FF69B4 guifg=#000000 ctermbg=205 ctermfg=16
-	hi BGff7f50 guibg=#FF7F50 guifg=#000000 ctermbg=209 ctermfg=16
-	hi BGff8c00 guibg=#FF8C00 guifg=#000000 ctermbg=3   ctermfg=16
-	hi BGffa07a guibg=#FFA07A guifg=#000000 ctermbg=216 ctermfg=16
-	hi BGffa500 guibg=#FFA500 guifg=#000000 ctermbg=3   ctermfg=16
-	hi BGffb6c1 guibg=#FFB6C1 guifg=#000000 ctermbg=217 ctermfg=16
-	hi BGffc0cb guibg=#FFC0CB guifg=#000000 ctermbg=218 ctermfg=16
-	hi BGffd700 guibg=#FFD700 guifg=#000000 ctermbg=11  ctermfg=16
-	hi BGffdab9 guibg=#FFDAB9 guifg=#000000 ctermbg=223 ctermfg=16
-	hi BGffdead guibg=#FFDEAD guifg=#000000 ctermbg=223 ctermfg=16
-	hi BGffe4b5 guibg=#FFE4B5 guifg=#000000 ctermbg=223 ctermfg=16
-	hi BGffe4c4 guibg=#FFE4C4 guifg=#000000 ctermbg=224 ctermfg=16
-	hi BGffe4e1 guibg=#FFE4E1 guifg=#000000 ctermbg=224 ctermfg=16
-	hi BGffebcd guibg=#FFEBCD guifg=#000000 ctermbg=7   ctermfg=16
-	hi BGffefd5 guibg=#FFEFD5 guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGfff0f5 guibg=#FFF0F5 guifg=#000000 ctermbg=15  ctermfg=16
-	hi BGfff5ee guibg=#FFF5EE guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGfff8dc guibg=#FFF8DC guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGfffacd guibg=#FFFACD guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGfffaf0 guibg=#FFFAF0 guifg=#000000 ctermbg=15  ctermfg=16
-	hi BGfffafa guibg=#FFFAFA guifg=#000000 ctermbg=15  ctermfg=16
-	hi BGffff00 guibg=#FFFF00 guifg=#000000 ctermbg=11  ctermfg=16
-	hi BGffffe0 guibg=#FFFFE0 guifg=#000000 ctermbg=255 ctermfg=16
-	hi BGfffff0 guibg=#FFFFF0 guifg=#000000 ctermbg=15  ctermfg=16
-	hi BGffffff guibg=#FFFFFF guifg=#000000 ctermbg=231 ctermfg=16
-
-	" W3C Colors
-	syn keyword BG000000 black   contained containedin=@colorableGroup
-	syn keyword BGc0c0c0 silver  contained containedin=@colorableGroup
-	syn keyword BG808080 gray    contained containedin=@colorableGroup
-	syn match BGffffff "\<white\(-\)\@!\>" contained containedin=@colorableGroup
-	syn keyword BG800000 maroon  contained containedin=@colorableGroup
-	syn keyword BGff0000 red     contained containedin=@colorableGroup
-	syn keyword BG800080 purple  contained containedin=@colorableGroup
-	syn keyword BGff00ff fuchsia contained containedin=@colorableGroup
-	syn keyword BG008000 green   contained containedin=@colorableGroup
-	syn keyword BG00ff00 lime    contained containedin=@colorableGroup
-	syn keyword BG808000 olive   contained containedin=@colorableGroup
-	syn keyword BGffff00 yellow  contained containedin=@colorableGroup
-	syn keyword BG000080 navy    contained containedin=@colorableGroup
-	syn keyword BG0000ff blue    contained containedin=@colorableGroup
-	syn keyword BG008080 teal    contained containedin=@colorableGroup
-	syn keyword BG00ffff aqua    contained containedin=@colorableGroup
-
-	" extra colors
-	syn keyword BGf0f8ff AliceBlue            contained containedin=@colorableGroup
-	syn keyword BGfaebd7 AntiqueWhite         contained containedin=@colorableGroup
-	syn keyword BG7fffd4 Aquamarine           contained containedin=@colorableGroup
-	syn keyword BGf0ffff Azure                contained containedin=@colorableGroup
-	syn keyword BGf5f5dc Beige                contained containedin=@colorableGroup
-	syn keyword BGffe4c4 Bisque               contained containedin=@colorableGroup
-	syn keyword BGffebcd BlanchedAlmond       contained containedin=@colorableGroup
-	syn keyword BG8a2be2 BlueViolet           contained containedin=@colorableGroup
-	syn keyword BGa52a2a Brown                contained containedin=@colorableGroup
-	syn keyword BGdeb887 BurlyWood            contained containedin=@colorableGroup
-	syn keyword BG5f9ea0 CadetBlue            contained containedin=@colorableGroup
-	syn keyword BG7fff00 Chartreuse           contained containedin=@colorableGroup
-	syn keyword BGd2691e Chocolate            contained containedin=@colorableGroup
-	syn keyword BGff7f50 Coral                contained containedin=@colorableGroup
-	syn keyword BG6495ed CornflowerBlue       contained containedin=@colorableGroup
-	syn keyword BGfff8dc Cornsilk             contained containedin=@colorableGroup
-	syn keyword BGdc143c Crimson              contained containedin=@colorableGroup
-	syn keyword BG00ffff Cyan                 contained containedin=@colorableGroup
-	syn keyword BG00008b DarkBlue             contained containedin=@colorableGroup
-	syn keyword BG008b8b DarkCyan             contained containedin=@colorableGroup
-	syn keyword BGb8860b DarkGoldenRod        contained containedin=@colorableGroup
-	syn keyword BGa9a9a9 DarkGray             contained containedin=@colorableGroup
-	syn keyword BG006400 DarkGreen            contained containedin=@colorableGroup
-	syn keyword BGa9a9a9 DarkGrey             contained containedin=@colorableGroup
-	syn keyword BGbdb76b DarkKhaki            contained containedin=@colorableGroup
-	syn keyword BG8b008b DarkMagenta          contained containedin=@colorableGroup
-	syn keyword BG556b2f DarkOliveGreen       contained containedin=@colorableGroup
-	syn keyword BG9932cc DarkOrchid           contained containedin=@colorableGroup
-	syn keyword BG8b0000 DarkRed              contained containedin=@colorableGroup
-	syn keyword BGe9967a DarkSalmon           contained containedin=@colorableGroup
-	syn keyword BG8fbc8f DarkSeaGreen         contained containedin=@colorableGroup
-	syn keyword BG483d8b DarkSlateBlue        contained containedin=@colorableGroup
-	syn keyword BG2f4f4f DarkSlateGray        contained containedin=@colorableGroup
-	syn keyword BG2f4f4f DarkSlateGrey        contained containedin=@colorableGroup
-	syn keyword BG00ced1 DarkTurquoise        contained containedin=@colorableGroup
-	syn keyword BG9400d3 DarkViolet           contained containedin=@colorableGroup
-	syn keyword BGff8c00 Darkorange           contained containedin=@colorableGroup
-	syn keyword BGff1493 DeepPink             contained containedin=@colorableGroup
-	syn keyword BG00bfff DeepSkyBlue          contained containedin=@colorableGroup
-	syn keyword BG696969 DimGray              contained containedin=@colorableGroup
-	syn keyword BG696969 DimGrey              contained containedin=@colorableGroup
-	syn keyword BG1e90ff DodgerBlue           contained containedin=@colorableGroup
-	syn keyword BGb22222 FireBrick            contained containedin=@colorableGroup
-	syn keyword BGfffaf0 FloralWhite          contained containedin=@colorableGroup
-	syn keyword BG228b22 ForestGreen          contained containedin=@colorableGroup
-	syn keyword BGdcdcdc Gainsboro            contained containedin=@colorableGroup
-	syn keyword BGf8f8ff GhostWhite           contained containedin=@colorableGroup
-	syn keyword BGffd700 Gold                 contained containedin=@colorableGroup
-	syn keyword BGdaa520 GoldenRod            contained containedin=@colorableGroup
-	syn keyword BGadff2f GreenYellow          contained containedin=@colorableGroup
-	syn keyword BG808080 Grey                 contained containedin=@colorableGroup
-	syn keyword BGf0fff0 HoneyDew             contained containedin=@colorableGroup
-	syn keyword BGff69b4 HotPink              contained containedin=@colorableGroup
-	syn keyword BGcd5c5c IndianRed            contained containedin=@colorableGroup
-	syn keyword BG4b0082 Indigo               contained containedin=@colorableGroup
-	syn keyword BGfffff0 Ivory                contained containedin=@colorableGroup
-	syn keyword BGf0e68c Khaki                contained containedin=@colorableGroup
-	syn keyword BGe6e6fa Lavender             contained containedin=@colorableGroup
-	syn keyword BGfff0f5 LavenderBlush        contained containedin=@colorableGroup
-	syn keyword BG7cfc00 LawnGreen            contained containedin=@colorableGroup
-	syn keyword BGfffacd LemonChiffon         contained containedin=@colorableGroup
-	syn keyword BGadd8e6 LightBlue            contained containedin=@colorableGroup
-	syn keyword BGf08080 LightCoral           contained containedin=@colorableGroup
-	syn keyword BGe0ffff LightCyan            contained containedin=@colorableGroup
-	syn keyword BGfafad2 LightGoldenRodYellow contained containedin=@colorableGroup
-	syn keyword BGd3d3d3 LightGray            contained containedin=@colorableGroup
-	syn keyword BG90ee90 LightGreen           contained containedin=@colorableGroup
-	syn keyword BGd3d3d3 LightGrey            contained containedin=@colorableGroup
-	syn keyword BGffb6c1 LightPink            contained containedin=@colorableGroup
-	syn keyword BGffa07a LightSalmon          contained containedin=@colorableGroup
-	syn keyword BG20b2aa LightSeaGreen        contained containedin=@colorableGroup
-	syn keyword BG87cefa LightSkyBlue         contained containedin=@colorableGroup
-	syn keyword BG778899 LightSlateGray       contained containedin=@colorableGroup
-	syn keyword BG778899 LightSlateGrey       contained containedin=@colorableGroup
-	syn keyword BGb0c4de LightSteelBlue       contained containedin=@colorableGroup
-	syn keyword BGffffe0 LightYellow          contained containedin=@colorableGroup
-	syn keyword BG32cd32 LimeGreen            contained containedin=@colorableGroup
-	syn keyword BGfaf0e6 Linen                contained containedin=@colorableGroup
-	syn keyword BGff00ff Magenta              contained containedin=@colorableGroup
-	syn keyword BG66cdaa MediumAquaMarine     contained containedin=@colorableGroup
-	syn keyword BG0000cd MediumBlue           contained containedin=@colorableGroup
-	syn keyword BGba55d3 MediumOrchid         contained containedin=@colorableGroup
-	syn keyword BG9370d8 MediumPurple         contained containedin=@colorableGroup
-	syn keyword BG3cb371 MediumSeaGreen       contained containedin=@colorableGroup
-	syn keyword BG7b68ee MediumSlateBlue      contained containedin=@colorableGroup
-	syn keyword BG00fa9a MediumSpringGreen    contained containedin=@colorableGroup
-	syn keyword BG48d1cc MediumTurquoise      contained containedin=@colorableGroup
-	syn keyword BGc71585 MediumVioletRed      contained containedin=@colorableGroup
-	syn keyword BG191970 MidnightBlue         contained containedin=@colorableGroup
-	syn keyword BGf5fffa MintCream            contained containedin=@colorableGroup
-	syn keyword BGffe4e1 MistyRose            contained containedin=@colorableGroup
-	syn keyword BGffe4b5 Moccasin             contained containedin=@colorableGroup
-	syn keyword BGffdead NavajoWhite          contained containedin=@colorableGroup
-	syn keyword BGfdf5e6 OldLace              contained containedin=@colorableGroup
-	syn keyword BG6b8e23 OliveDrab            contained containedin=@colorableGroup
-	syn keyword BGffa500 Orange               contained containedin=@colorableGroup
-	syn keyword BGff4500 OrangeRed            contained containedin=@colorableGroup
-	syn keyword BGda70d6 Orchid               contained containedin=@colorableGroup
-	syn keyword BGeee8aa PaleGoldenRod        contained containedin=@colorableGroup
-	syn keyword BG98fb98 PaleGreen            contained containedin=@colorableGroup
-	syn keyword BGafeeee PaleTurquoise        contained containedin=@colorableGroup
-	syn keyword BGd87093 PaleVioletRed        contained containedin=@colorableGroup
-	syn keyword BGffefd5 PapayaWhip           contained containedin=@colorableGroup
-	syn keyword BGffdab9 PeachPuff            contained containedin=@colorableGroup
-	syn keyword BGcd853f Peru                 contained containedin=@colorableGroup
-	syn keyword BGffc0cb Pink                 contained containedin=@colorableGroup
-	syn keyword BGdda0dd Plum                 contained containedin=@colorableGroup
-	syn keyword BGb0e0e6 PowderBlue           contained containedin=@colorableGroup
-	syn keyword BGbc8f8f RosyBrown            contained containedin=@colorableGroup
-	syn keyword BG4169e1 RoyalBlue            contained containedin=@colorableGroup
-	syn keyword BG8b4513 SaddleBrown          contained containedin=@colorableGroup
-	syn keyword BGfa8072 Salmon               contained containedin=@colorableGroup
-	syn keyword BGf4a460 SandyBrown           contained containedin=@colorableGroup
-	syn keyword BG2e8b57 SeaGreen             contained containedin=@colorableGroup
-	syn keyword BGfff5ee SeaShell             contained containedin=@colorableGroup
-	syn keyword BGa0522d Sienna               contained containedin=@colorableGroup
-	syn keyword BG87ceeb SkyBlue              contained containedin=@colorableGroup
-	syn keyword BG6a5acd SlateBlue            contained containedin=@colorableGroup
-	syn keyword BG708090 SlateGray            contained containedin=@colorableGroup
-	syn keyword BG708090 SlateGrey            contained containedin=@colorableGroup
-	syn keyword BGfffafa Snow                 contained containedin=@colorableGroup
-	syn keyword BG00ff7f SpringGreen          contained containedin=@colorableGroup
-	syn keyword BG4682b4 SteelBlue            contained containedin=@colorableGroup
-	syn keyword BGd2b48c Tan                  contained containedin=@colorableGroup
-	syn keyword BGd8bfd8 Thistle              contained containedin=@colorableGroup
-	syn keyword BGff6347 Tomato               contained containedin=@colorableGroup
-	syn keyword BG40e0d0 Turquoise            contained containedin=@colorableGroup
-	syn keyword BGee82ee Violet               contained containedin=@colorableGroup
-	syn keyword BGf5deb3 Wheat                contained containedin=@colorableGroup
-	syn keyword BGf5f5f5 WhiteSmoke           contained containedin=@colorableGroup
-	syn keyword BG9acd32 YellowGreen          contained containedin=@colorableGroup
-endfunction

autoload/dart.vim

@@ -0,0 +1,174 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'dart') != -1
+  finish
+endif
+
+
+function! s:error(text) abort
+  echohl Error
+  echomsg printf('[dart-vim-plugin] %s', a:text)
+  echohl None
+endfunction
+
+function! s:cexpr(errorformat, joined_lines) abort
+  let temp_errorfomat = &errorformat
+  try
+    let &errorformat = a:errorformat
+    cexpr a:joined_lines
+    copen
+  finally
+    let &errorformat = temp_errorfomat
+  endtry
+endfunction
+
+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")
+      silent keepjumps call setline(1, lines)
+      if line('$') > len(lines)
+        silent keepjumps execute string(len(lines)+1).',$ delete'
+      endif
+      call winrestview(win_view)
+    else
+      let errors = split(joined_lines, "\n")[2:]
+      let file_path = expand('%')
+      call map(errors, 'file_path.":".v:val')
+      let error_format = '%A%f:line %l\, column %c of stdin: %m,%C%.%#'
+      call s:cexpr(error_format, join(errors, "\n"))
+    endif
+  else
+    call s:error('cannot execute binary file: dartfmt')
+  endif
+endfunction
+
+function! dart#analyzer(q_args) abort
+  if executable('dartanalyzer')
+    let path = expand('%:p:gs:\:/:')
+    if filereadable(path)
+      let joined_lines = system(printf('dartanalyzer %s %s', a:q_args, shellescape(path)))
+      call s:cexpr('%m (%f\, line %l\, col %c)', joined_lines)
+    else
+      call s:error(printf('cannot read a file: "%s"', path))
+    endif
+  else
+    call s:error('cannot execute binary file: dartanalyzer')
+  endif
+endfunction
+
+function! dart#tojs(q_args) abort
+  if executable('dart2js')
+    let path = expand('%:p:gs:\:/:')
+    if filereadable(path)
+      let joined_lines = system(printf('dart2js %s %s', a:q_args, shellescape(path)))
+      call s:cexpr('%m (%f\, line %l\, col %c)', joined_lines)
+    else
+      call s:error(printf('cannot read a file: "%s"', path))
+    endif
+  else
+    call s:error('cannot execute binary file: dartanalyzer')
+  endif
+endfunction
+
+" Finds the path to `uri`.
+"
+" If the file is a package: uri, looks for a .packages file to resolve the path.
+" If the path cannot be resolved, or is not a package: uri, returns the
+" original.
+function! dart#resolveUri(uri) abort
+  if a:uri !~ 'package:'
+    return a:uri
+  endif
+  let package_name = substitute(a:uri, 'package:\(\w\+\)\/.*', '\1', '')
+  let [found, package_map] = s:PackageMap()
+  if !found
+    call s:error('cannot find .packages file')
+    return a:uri
+  endif
+  if !has_key(package_map, package_name)
+    call s:error('no package mapping for '.package_name)
+    return a:uri
+  endif
+  let package_lib = package_map[package_name]
+  return substitute(a:uri,
+      \ 'package:'.package_name,
+      \ escape(package_map[package_name], '\'),
+      \ '')
+endfunction
+
+" A map from package name to lib directory parse from a '.packages' file.
+"
+" Returns [found, package_map]
+function! s:PackageMap() abort
+  let [found, dot_packages] = s:DotPackagesFile()
+  if !found
+    return [v:false, {}]
+  endif
+  let dot_packages_dir = fnamemodify(dot_packages, ':p:h')
+  let lines = readfile(dot_packages)
+  let map = {}
+  for line in lines
+    if line =~ '\s*#'
+      continue
+    endif
+    let package = substitute(line, ':.*$', '', '')
+    let lib_dir = substitute(line, '^[^:]*:', '', '')
+    if lib_dir =~ 'file:/'
+      let lib_dir = substitute(lib_dir, 'file://', '', '')
+      if lib_dir =~ '/[A-Z]:/'
+        let lib_dir = lib_dir[1:]
+      endif
+    else
+      let lib_dir = resolve(dot_packages_dir.'/'.lib_dir)
+    endif
+    if lib_dir =~ '/$'
+      let lib_dir = lib_dir[:len(lib_dir) - 2]
+    endif
+    let map[package] = lib_dir
+  endfor
+  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.
+"
+" Returns [found, file].
+function! s:DotPackagesFile() abort
+  if filereadable('.packages')
+    return [v:true, '.packages']
+  endif
+  let dir_path = expand('%:p:h')
+  while v:true
+    let file_path = dir_path.'/.packages'
+    if filereadable(file_path)
+      return [v:true, file_path]
+    endif
+    let parent = fnamemodify(dir_path, ':h')
+    if dir_path == parent
+      break
+    endif
+    let dir_path = parent
+  endwhile
+  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

autoload/db/adapter/ecto.vim

@@ -0,0 +1,24 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'elixir') != -1
+  finish
+endif
+
+let s:path = expand('<sfile>:h')
+let s:cmd = join(['mix', 'run', '--no-start', '--no-compile', shellescape(s:path.'/get_repos.exs')])
+
+function! s:repo_list() abort
+    return map(systemlist(s:cmd), 'split(v:val)')
+endfunction
+
+function! db#adapter#ecto#canonicalize(url) abort
+    for l:item in s:repo_list()
+        let l:name = get(l:item, 0)
+        let l:url = get(l:item, 1)
+        if !empty(l:name) && 'ecto:'.l:name ==# a:url
+            return l:url
+        endif
+    endfor
+endfunction
+
+function! db#adapter#ecto#complete_opaque(url) abort
+    return map(s:repo_list(), 'v:val[0]')
+endfunction

autoload/elixir/indent.vim

@@ -0,0 +1,347 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'elixir') != -1
+  finish
+endif
+
+if !exists("g:elixir_indent_max_lookbehind")
+  let g:elixir_indent_max_lookbehind = 30
+endif
+
+" Return the effective value of 'shiftwidth'
+function! s:sw()
+  return &shiftwidth == 0 ? &tabstop : &shiftwidth
+endfunction
+
+function! elixir#indent#indent(lnum)
+  let lnum = a:lnum
+  let text = getline(lnum)
+  let prev_nb_lnum = prevnonblank(lnum-1)
+  let prev_nb_text = getline(prev_nb_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',
+        \'following_trailing_binary_operator',
+        \'starts_with_pipe',
+        \'starts_with_binary_operator',
+        \'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 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
+
+function! s:debug(str)
+  if exists("g:elixir_indent_debug") && g:elixir_indent_debug
+    echom a: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)
+  let pos = match(a:text, '^\s*'.a:expr)
+  if pos == -1
+    return 0
+  else
+    " NOTE: @jbodah 2017-02-24: pos is the index of the match which is
+    " zero-indexed. Add one to make it the column number
+    if s:is_string_or_comment(a:lnum, pos + 1)
+      return 0
+    else
+      return 1
+    end
+  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)
+  let pos = match(a:text, a:expr.'\s*$')
+  if pos == -1
+    return 0
+  else
+    if s:is_string_or_comment(a:lnum, pos)
+      return 0
+    else
+      return 1
+    end
+  end
+endfunction
+
+" Returns 0 or 1 based on whether or not the given line number and column
+" number pair is a string or comment
+function! s:is_string_or_comment(line, col)
+  return synIDattr(synID(a:line, a:col, 1), "name") =~ '\%(String\|Comment\)'
+endfunction
+
+" Skip expression for searchpair. Returns 0 or 1 based on whether the value
+" under the cursor is a string or comment
+function! elixir#indent#searchpair_back_skip()
+  " NOTE: @jbodah 2017-02-27: for some reason this function gets called with
+  " and index that doesn't exist in the line sometimes. Detect and account for
+  " that situation
+  let curr_col = col('.')
+  if getline('.')[curr_col-1] == ''
+    let curr_col = curr_col-1
+  endif
+  return s:is_string_or_comment(line('.'), curr_col)
+endfunction
+
+" DRY up regex for keywords that 1) makes sure we only look at complete words
+" and 2) ignores atoms
+function! s:keyword(expr)
+  return ':\@<!\<\C\%('.a:expr.'\)\>:\@!'
+endfunction
+
+" Start at the end of text and search backwards looking for a match. Also peek
+" ahead if we get a match to make sure we get a complete match. This means
+" that the result should be the position of the start of the right-most match
+function! s:find_last_pos(lnum, text, match)
+  let last = len(a:text) - 1
+  let c = last
+
+  while c >= 0
+    let substr = strpart(a:text, c, last)
+    let peek = strpart(a:text, c - 1, last)
+    let ss_match = match(substr, a:match)
+    if ss_match != -1
+      let peek_match = match(peek, a:match)
+      if peek_match == ss_match + 1
+        let syng = synIDattr(synID(a:lnum, c + ss_match, 1), 'name')
+        if syng !~ '\%(String\|Comment\)'
+          return c + ss_match
+        end
+      end
+    end
+    let c -= 1
+  endwhile
+
+  return -1
+endfunction
+
+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(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'
+" for this line. In particular it traverses backwards up things like pipelines
+" to find the beginning of the expression
+function! s:get_base_indent(lnum, text)
+  let prev_nb_lnum = prevnonblank(a:lnum - 1)
+  let prev_nb_text = getline(prev_nb_lnum)
+
+  let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
+  let data_structure_close = '\%(\]\|}\|)\)'
+  let pipe = '|>'
+
+  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)
+    return s:get_base_indent(prev_nb_lnum, prev_nb_text)
+  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)
+    let data_structure_open = '\%(\[\|{\|(\)'
+    let close_match_idx = match(a:text, data_structure_close . '\s*$')
+    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)
+  else
+    return indent(a:lnum)
+  endif
+endfunction
+
+function! elixir#indent#handle_following_trailing_binary_operator(context)
+  let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
+
+  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_starts_with_pipe(context)
+  if s:starts_with(a:context, '|>')
+    let 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:context.prev_nb_lnum)
+    else
+      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:context.prev_nb_lnum) + s:sw()
+      else
+        return pos + 1 + next_word_pos
+      end
+    end
+  else
+    return -1
+  endif
+endfunction
+
+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
+    return -1
+  endif
+endfunction
+
+function! elixir#indent#handle_starts_with_binary_operator(context)
+  let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
+
+  if s:starts_with(a:context, binary_operator)
+    let 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:context.prev_nb_lnum)
+    else
+      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:context.prev_nb_lnum) + s:sw()
+      else
+        return pos + 1 + next_word_pos
+      end
+    end
+  else
+    return -1
+  endif
+endfunction
+
+" To handle nested structures properly we need to find the innermost
+" 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_block(context)
+  let start_pattern = '\C\%(\<with\>\|\<if\>\|\<case\>\|\<cond\>\|\<try\>\|\<receive\>\|\<fn\>\|{\|\[\|(\)'
+  let end_pattern = '\C\%(\<end\>\|\]\|}\|)\)'
+  " 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\|else'), 'pattern_match_clauses': s:keyword('catch\|rescue\|else')},
+          \'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
+      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
+        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
+  end
+endfunction
+
+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:prev_ends_with(a:context, ',')
+      return indent(pair_lnum) + 2 * s:sw()
+    else
+      return indent(pair_lnum) + s:sw()
+    endif
+  else
+    return -1
+  endif
+endfunction

autoload/elixir/util.vim

@@ -0,0 +1,28 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'elixir') != -1
+  finish
+endif
+
+function! elixir#util#get_filename(word) abort
+  let word = a:word
+
+  " get first thing that starts uppercase, until the first space or end of line
+  let word = substitute(word,'^\s*\(\u[^ ]\+\).*$','\1','g')
+
+  " remove any trailing characters that don't look like a nested module
+  let word = substitute(word,'\.\U.*$','','g')
+
+  " replace module dots with slash
+  let word = substitute(word,'\.','/','g')
+
+  " remove any special chars
+  let word = substitute(word,'[^A-z0-9-_/]','','g')
+
+  " convert to snake_case
+  let word = substitute(word,'\(\u\+\)\(\u\l\)','\1_\2','g')
+  let word = substitute(word,'\(\u\+\)\(\u\l\)','\1_\2','g')
+  let word = substitute(word,'\(\l\|\d\)\(\u\)','\1_\2','g')
+  let word = substitute(word,'-','_','g')
+  let word = tolower(word)
+
+  return word
+endfunction

autoload/elm.vim

@@ -0,0 +1,385 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'elm') != -1
+  finish
+endif
+
+let s:errors = []
+
+function! s:elmOracle(...) abort
+	let l:project = finddir('elm-stuff/..', '.;')
+	if len(l:project) == 0
+		echoerr '`elm-stuff` not found! run `elm-package install` for autocomplete.'
+		return []
+	endif
+
+	let l:filename = expand('%:p')
+
+	if a:0 == 0
+		let l:oldiskeyword = &iskeyword
+		" Some non obvious values used in 'iskeyword':
+		"    @     = all alpha
+		"    48-57 = numbers 0 to 9
+		"    @-@   = character @
+		"    124   = |
+		setlocal iskeyword=@,48-57,@-@,_,-,~,!,#,$,%,&,*,+,=,<,>,/,?,.,\\,124,^
+		let l:word = expand('<cword>')
+		let &iskeyword = l:oldiskeyword
+	else
+		let l:word = a:1
+	endif
+
+	let l:infos = elm#Oracle(l:filename, l:word)
+	if v:shell_error != 0
+		call elm#util#EchoError("elm-oracle failed:\n\n", l:infos)
+		return []
+	endif
+
+	let l:d = split(l:infos, '\n')
+	if len(l:d) > 0
+		return elm#util#DecodeJSON(l:d[0])
+	endif
+
+	return []
+endf
+
+" Vim command to format Elm files with elm-format
+function! elm#Format() abort
+	" check for elm-format
+	if elm#util#CheckBin('elm-format', 'https://github.com/avh4/elm-format') ==# ''
+		return
+	endif
+
+	" save cursor position, folds and many other things
+    let l:curw = {}
+    try
+      mkview!
+    catch
+      let l:curw = winsaveview()
+    endtry
+
+    " save our undo file to be restored after we are done.
+    let l:tmpundofile = tempname()
+    exe 'wundo! ' . l:tmpundofile
+
+	" write current unsaved buffer to a temporary file
+	let l:tmpname = tempname() . '.elm'
+	call writefile(getline(1, '$'), l:tmpname)
+
+	" call elm-format on the temporary file
+	let l:out = system('elm-format ' . l:tmpname . ' --output ' . l:tmpname)
+
+	" if there is no error
+	if v:shell_error == 0
+		try | silent undojoin | catch | endtry
+
+		" replace current file with temp file, then reload buffer
+		let l:old_fileformat = &fileformat
+		call rename(l:tmpname, expand('%'))
+		silent edit!
+		let &fileformat = l:old_fileformat
+		let &syntax = &syntax
+	elseif g:elm_format_fail_silently == 0
+		call elm#util#EchoLater('EchoError', 'elm-format:', l:out)
+	endif
+
+    " save our undo history
+    silent! exe 'rundo ' . l:tmpundofile
+    call delete(l:tmpundofile)
+
+	" restore our cursor/windows positions, folds, etc..
+    if empty(l:curw)
+      silent! loadview
+    else
+      call winrestview(l:curw)
+    endif
+endf
+
+" Query elm-oracle and echo the type and docs for the word under the cursor.
+function! elm#ShowDocs() abort
+	" check for the elm-oracle binary
+	if elm#util#CheckBin('elm-oracle', 'https://github.com/elmcast/elm-oracle') ==# ''
+		return
+	endif
+
+	let l:response = s:elmOracle()
+
+	if len(l:response) > 0
+		let l:info = l:response[0]
+		redraws! | echohl Identifier | echon l:info.fullName | echohl None | echon ' : ' | echohl Function | echon l:info.signature | echohl None | echon "\n\n" . l:info.comment
+	else
+		call elm#util#Echo('elm-oracle:', '...no match found')
+	endif
+endf
+
+" Query elm-oracle and open the docs for the word under the cursor.
+function! elm#BrowseDocs() abort
+	" check for the elm-oracle binary
+	if elm#util#CheckBin('elm-oracle', 'https://github.com/elmcast/elm-oracle') ==# ''
+		return
+	endif
+
+	let l:response = s:elmOracle()
+
+	if len(l:response) > 0
+		let l:info = l:response[0]
+		call elm#util#OpenBrowser(l:info.href)
+	else
+		call elm#util#Echo('elm-oracle:', '...no match found')
+	endif
+endf
+
+
+function! elm#Syntastic(input) abort
+	let l:fixes = []
+
+	let l:bin = 'elm-make'
+	let l:format = '--report=json'
+	let l:input = shellescape(a:input)
+	let l:output = '--output=' . shellescape(syntastic#util#DevNull())
+	let l:command = l:bin . ' ' . l:format  . ' ' . l:input . ' ' . l:output
+	let l:reports = s:ExecuteInRoot(l:command)
+
+	for l:report in split(l:reports, '\n')
+		if l:report[0] ==# '['
+            for l:error in elm#util#DecodeJSON(l:report)
+                if g:elm_syntastic_show_warnings == 0 && l:error.type ==? 'warning'
+                else
+                    if a:input == l:error.file
+                        call add(s:errors, l:error)
+                        call add(l:fixes, {'filename': l:error.file,
+                                    \'valid': 1,
+                                    \'bufnr': bufnr('%'),
+                                    \'type': (l:error.type ==? 'error') ? 'E' : 'W',
+                                    \'lnum': l:error.region.start.line,
+                                    \'col': l:error.region.start.column,
+                                    \'text': l:error.overview})
+                    endif
+                endif
+            endfor
+        endif
+	endfor
+
+	return l:fixes
+endf
+
+function! elm#Build(input, output, show_warnings) abort
+	let s:errors = []
+	let l:fixes = []
+	let l:rawlines = []
+
+	let l:bin = 'elm-make'
+	let l:format = '--report=json'
+	let l:input = shellescape(a:input)
+	let l:output = '--output=' . shellescape(a:output)
+	let l:command = l:bin . ' ' . l:format  . ' ' . l:input . ' ' . l:output
+	let l:reports = s:ExecuteInRoot(l:command)
+
+	for l:report in split(l:reports, '\n')
+		if l:report[0] ==# '['
+			for l:error in elm#util#DecodeJSON(l:report)
+				if a:show_warnings == 0 && l:error.type ==? 'warning'
+				else
+					call add(s:errors, l:error)
+					call add(l:fixes, {'filename': l:error.file,
+								\'valid': 1,
+								\'type': (l:error.type ==? 'error') ? 'E' : 'W',
+								\'lnum': l:error.region.start.line,
+								\'col': l:error.region.start.column,
+								\'text': l:error.overview})
+				endif
+			endfor
+		else
+			call add(l:rawlines, l:report)
+		endif
+	endfor
+
+	let l:details = join(l:rawlines, "\n")
+	let l:lines = split(l:details, "\n")
+	if !empty(l:lines)
+		let l:overview = l:lines[0]
+	else
+		let l:overview = ''
+	endif
+
+	if l:details ==# '' || l:details =~? '^Successfully.*'
+	else
+		call add(s:errors, {'overview': l:details, 'details': l:details})
+		call add(l:fixes, {'filename': expand('%', 1),
+					\'valid': 1,
+					\'type': 'E',
+					\'lnum': 0,
+					\'col': 0,
+					\'text': l:overview})
+	endif
+
+	return l:fixes
+endf
+
+" Make the given file, or the current file if none is given.
+function! elm#Make(...) abort
+	if elm#util#CheckBin('elm-make', 'http://elm-lang.org/install') ==# ''
+		return
+	endif
+
+	call elm#util#Echo('elm-make:', 'building...')
+
+	let l:input = (a:0 == 0) ? expand('%:p') : a:1
+	let l:fixes = elm#Build(l:input, g:elm_make_output_file, g:elm_make_show_warnings)
+
+	if len(l:fixes) > 0
+		call elm#util#EchoWarning('', 'found ' . len(l:fixes) . ' errors')
+
+		call setqflist(l:fixes, 'r')
+		cwindow
+
+		if get(g:, 'elm_jump_to_error', 1)
+			ll 1
+		endif
+	else
+		call elm#util#EchoSuccess('', 'Sucessfully compiled')
+
+		call setqflist([])
+		cwindow
+	endif
+endf
+
+" Show the detail of the current error in the quickfix window.
+function! elm#ErrorDetail() abort
+	if !empty(filter(tabpagebuflist(), 'getbufvar(v:val, "&buftype") ==? "quickfix"'))
+		exec ':copen'
+		let l:linenr = line('.')
+		exec ':wincmd p'
+		if len(s:errors) > 0
+			let l:detail = s:errors[l:linenr-1].details
+			if l:detail ==# ''
+				let l:detail = s:errors[l:linenr-1].overview
+			endif
+			echo l:detail
+		endif
+	endif
+endf
+
+" Open the elm repl in a subprocess.
+function! elm#Repl() abort
+	" check for the elm-repl binary
+	if elm#util#CheckBin('elm-repl', 'http://elm-lang.org/install') ==# ''
+		return
+	endif
+
+	if has('nvim')
+		term('elm-repl')
+	else
+		!elm-repl
+	endif
+endf
+
+function! elm#Oracle(filepath, word) abort
+	let l:bin = 'elm-oracle'
+	let l:filepath = shellescape(a:filepath)
+	let l:word = shellescape(a:word)
+	let l:command = l:bin . ' ' . l:filepath . ' ' . l:word
+	return s:ExecuteInRoot(l:command)
+endfunction
+
+let s:fullComplete = ''
+
+" Complete the current token using elm-oracle
+function! elm#Complete(findstart, base) abort
+" a:base is unused, but the callback function for completion expects 2 arguments
+	if a:findstart
+		let l:line = getline('.')
+
+		let l:idx = col('.') - 1
+		let l:start = 0
+		while l:idx > 0 && l:line[l:idx - 1] =~# '[a-zA-Z0-9_\.]'
+			if l:line[l:idx - 1] ==# '.' && l:start == 0
+				let l:start = l:idx
+			endif
+			let l:idx -= 1
+		endwhile
+
+		if l:start == 0
+			let l:start = l:idx
+		endif
+
+		let s:fullComplete = l:line[l:idx : col('.')-2]
+
+		return l:start
+	else
+		" check for the elm-oracle binary
+		if elm#util#CheckBin('elm-oracle', 'https://github.com/elmcast/elm-oracle') ==# ''
+			return []
+		endif
+
+		let l:res = []
+		let l:response = s:elmOracle(s:fullComplete)
+
+		let l:detailed = get(g:, 'elm_detailed_complete', 0)
+
+		for l:r in l:response
+			let l:menu = ''
+			if l:detailed
+				let l:menu = ': ' . l:r.signature
+			endif
+			call add(l:res, {'word': l:r.name, 'menu': l:menu})
+		endfor
+
+		return l:res
+	endif
+endf
+
+" If the current buffer contains a consoleRunner, run elm-test with it.
+" Otherwise run elm-test in the root of your project which deafults to
+" running 'elm-test tests/TestRunner'.
+function! elm#Test() abort
+	if elm#util#CheckBin('elm-test', 'https://github.com/rtfeldman/node-elm-test') ==# ''
+		return
+	endif
+
+	if match(getline(1, '$'), 'consoleRunner') < 0
+		let l:out = s:ExecuteInRoot('elm-test')
+		call elm#util#EchoSuccess('elm-test', l:out)
+	else
+		let l:filepath = shellescape(expand('%:p'))
+		let l:out = s:ExecuteInRoot('elm-test ' . l:filepath)
+		call elm#util#EchoSuccess('elm-test', l:out)
+	endif
+endf
+
+" Returns the closest parent with an elm-package.json file.
+function! elm#FindRootDirectory() abort
+	let l:elm_root = getbufvar('%', 'elmRoot')
+	if empty(l:elm_root)
+		let l:current_file = expand('%:p')
+		let l:dir_current_file = fnameescape(fnamemodify(l:current_file, ':h'))
+		let l:old_match = findfile('elm-package.json', l:dir_current_file . ';')
+		let l:new_match = findfile('elm.json', l:dir_current_file . ';')
+		if !empty(l:new_match)
+			let l:elm_root = fnamemodify(l:new_match, ':p:h')
+		elseif !empty(l:old_match)
+			let l:elm_root = fnamemodify(l:old_match, ':p:h')
+		else
+			let l:elm_root = ''
+		endif
+
+		if !empty(l:elm_root)
+			call setbufvar('%', 'elmRoot', l:elm_root)
+		endif
+	endif
+	return l:elm_root
+endfunction
+
+" Executes a command in the project directory.
+function! s:ExecuteInRoot(cmd) abort
+	let l:cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
+	let l:current_dir = getcwd()
+	let l:root_dir = elm#FindRootDirectory()
+
+	try
+		execute l:cd . fnameescape(l:root_dir)
+		let l:out = system(a:cmd)
+	finally
+		execute l:cd . fnameescape(l:current_dir)
+	endtry
+
+	return l:out
+endfunction

autoload/elm/util.vim

@@ -0,0 +1,184 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'elm') != -1
+  finish
+endif
+
+" IsWin returns 1 if current OS is Windows or 0 otherwise
+fun! elm#util#IsWin() abort
+  let l:win = ['win16', 'win32', 'win32unix', 'win64', 'win95']
+  for l:w in l:win
+    if (has(l:w))
+      return 1
+    endif
+  endfor
+
+  return 0
+endf
+
+fun! elm#util#CheckBin(bin, url) abort
+  let l:binpath = substitute(a:bin, '^\s*\(.\{-}\)\s*$', '\1', '')
+
+  if executable(l:binpath)
+    return l:binpath
+  endif
+
+  call elm#util#EchoWarning('elm-vim:', 'could not find ' . l:binpath . ' [' . a:url . ']')
+
+  return ''
+endf
+
+" Determines the browser command to use
+fun! s:get_browser_command() abort
+  let l:elm_browser_command = get(g:, 'elm_browser_command', '')
+  if l:elm_browser_command ==? ''
+    if elm#util#IsWin()
+      let l:elm_browser_command = '!start rundll32 url.dll,FileProtocolHandler %URL%'
+    elseif has('mac') || has('macunix') || has('gui_macvim') || system('uname') =~? '^darwin'
+      let l:elm_browser_command = 'open %URL%'
+    elseif executable('xdg-open')
+      let l:elm_browser_command = 'xdg-open %URL%'
+    elseif executable('firefox')
+      let l:elm_browser_command = 'firefox %URL% &'
+    else
+      let l:elm_browser_command = ''
+    endif
+  endif
+  return l:elm_browser_command
+endf
+
+" OpenBrowser opens a url in the default browser
+fun! elm#util#OpenBrowser(url) abort
+  let l:cmd = s:get_browser_command()
+  if len(l:cmd) == 0
+    redraw
+    echohl WarningMsg
+    echo "It seems that you don't have general web browser. Open URL below."
+    echohl None
+    echo a:url
+    return
+  endif
+  if l:cmd =~? '^!'
+    let l:cmd = substitute(l:cmd, '%URL%', '\=shellescape(a:url)', 'g')
+    silent! exec l:cmd
+  elseif l:cmd =~# '^:[A-Z]'
+    let l:cmd = substitute(l:cmd, '%URL%', '\=a:url', 'g')
+    exec l:cmd
+  else
+    let l:cmd = substitute(l:cmd, '%URL%', '\=shellescape(a:url)', 'g')
+    call system(l:cmd)
+  endif
+endf
+
+" DecodeJSON decodes a string of json into a viml object
+fun! elm#util#DecodeJSON(s) abort
+  let l:true = 1
+  let l:false = 0
+  let l:null = 0
+  return eval(a:s)
+endf
+
+" Remove ANSI escape characters used for highlighting purposes
+fun! s:strip_color(msg) abort
+  return substitute(a:msg, '\e\[[0-9;]\+[mK]', '', 'g')
+endf
+
+" Print functions
+fun! elm#util#Echo(title, msg) abort
+  redraws! | echon a:title . ' ' | echohl Identifier | echon s:strip_color(a:msg) | echohl None
+endf
+
+fun! elm#util#EchoSuccess(title, msg) abort
+  redraws! | echon a:title . ' ' | echohl Function | echon s:strip_color(a:msg) | echohl None
+endf
+
+fun! elm#util#EchoWarning(title, msg) abort
+  redraws! | echon a:title . ' ' | echohl WarningMsg | echon s:strip_color(a:msg) | echohl None
+endf
+
+fun! elm#util#EchoError(title, msg) abort
+  redraws! | echon a:title . ' ' | echohl ErrorMsg | echon s:strip_color(a:msg) | echohl None
+endf
+
+fun! elm#util#EchoLater(func_name, title, msg) abort
+  let s:echo_func_name = a:func_name
+  let s:echo_title = a:title
+  let s:echo_msg = a:msg
+endf
+
+fun! elm#util#EchoStored() abort
+  if exists('s:echo_func_name') && exists('s:echo_title') && exists('s:echo_msg')
+    call elm#util#{s:echo_func_name}(s:echo_title, s:echo_msg)
+    unlet s:echo_func_name
+    unlet s:echo_title
+    unlet s:echo_msg
+  endif
+endf
+
+function! elm#util#GoToModule(name)
+  if empty(a:name) | return | endif
+  if empty(matchstr(a:name, '^Native\.'))
+    let l:extension = '.elm'
+  else
+    let l:extension = '.js'
+  endif
+  let l:rel_path = substitute(a:name, '\.', '/', 'g') . l:extension
+  let l:root = elm#FindRootDirectory()
+
+  let l:module_file = s:findLocalModule(l:rel_path, l:root)
+  if !filereadable(l:module_file)
+    let l:module_file = s:findDependencyModule(l:rel_path, l:root)
+  endif
+
+  if filereadable(l:module_file)
+    exec 'edit ' . fnameescape(l:module_file)
+  else
+    return s:error("Can't find module \"" . a:name . "\"")
+  endif
+endfunction
+
+function! s:findLocalModule(rel_path, root)
+  let l:old_match = findfile('elm-package.json', a:root . ';')
+  let l:new_match = findfile('elm.json', a:root . ';')
+  if !empty(l:new_match)
+    let l:package_json = l:new_match
+  elseif !empty(l:old_match)
+    let l:package_json = l:old_match
+  endif
+  if exists('*json_decode')
+    let l:package = json_decode(readfile(l:package_json))
+    let l:source_roots = l:package['source-directories']
+  else
+    " This is a fallback for vim's which do not support json_decode.
+    " It simply only looks in the 'src' subdirectory and fails otherwise.
+    let l:source_roots = ['src']
+  end
+  for l:source_root in l:source_roots
+    let l:file_path = a:root . '/' . l:source_root . '/' . a:rel_path
+    if !filereadable(l:file_path)
+      continue
+    endif
+    return l:file_path
+  endfor
+endfunction
+
+function! s:findDependencyModule(rel_path, root)
+  " If we are a dependency ourselves, we need to check our siblings.
+  " This is because elm package doesn't install dependencies recursively.
+  let l:root = substitute(a:root, '\/elm-stuff/packages.\+$', '', '')
+
+  " We naively craws the dependencies dir for any fitting module name.
+  " If it exists, we'll find it. If multiple filenames match,
+  " there's a chance we return the wrong one.
+  let l:module_paths = glob(l:root . '/elm-stuff/packages/**/' . a:rel_path, 0, 1)
+  if len(l:module_paths) > 0
+    return l:module_paths[0]
+  endif
+endfunction
+
+" Using the built-in :echoerr prints a stacktrace, which isn't that nice.
+" From: https://github.com/moll/vim-node/blob/master/autoload/node.vim
+function! s:error(msg)
+	echohl ErrorMsg
+	echomsg a:msg
+	echohl NONE
+	let v:errmsg = a:msg
+endfunction

autoload/erlangcomplete.vim

@@ -1,161 +0,0 @@
-" ------------------------------------------------------------------------------
-" Vim omni-completion script
-" Author: Oscar Hellström
-" Email: oscar@oscarh.net
-" Version: 2010-08-10
-" Contributors: kTT (http://github.com/kTT)
-" 		Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
-" ------------------------------------------------------------------------------
-
-" Patterns for completions {{{1
-let s:erlangLocalFuncBeg    = '\(\<[0-9A-Za-z_-]*\|\s*\)$'
-let s:erlangExternalFuncBeg = '\<[0-9A-Za-z_-]\+:[0-9A-Za-z_-]*$'
-let s:ErlangBlankLine       = '^\s*\(%.*\)\?$'
-let s:erlangCompletionPath  = expand('<sfile>:p:h') . '/erlang_completion.erl'
-
-if !exists('g:erlangCompletionGrep')
-	let g:erlangCompletionGrep = 'grep'
-endif
-
-if !exists('g:erlangManSuffix')
-	let g:erlangManSuffix = ''
-endif
-
-if !exists('g:erlangManPath')
-	let g:erlangManPath = '/usr/lib/erlang/man'
-endif
-
-if !exists('g:erlangCompletionDisplayDoc')
-	let g:erlangCompletionDisplayDoc = 1
-endif
-
-" Main function for completion {{{1
-function! erlangcomplete#Complete(findstart, base)
-	" 0) Init {{{2
-	let lnum = line('.')
-	let column = col('.') 
-	let line = strpart(getline('.'), 0, column - 1)
-
-	" 1) First, check if completion is impossible {{{2
-	if line =~ '[^~\\]%'
-		return -1
-	endif
-
-	"echo "line[col - 1]:" . line[column - 1] . " line[col - 2]:" . line[column - 2] .  "\n" . line . "\n"
-
-	" 2) Check if the char to the left of us are part of a function call {{{2
-	"
-	" Nothing interesting is written at the char just before the cursor
-	" This means _anything_ could be started here
-	" In this case, keyword completion should probably be used,
-	" for now we'll only try and complete local functions.
-	" TODO: Examine if we can stare Identifiers end complete on them
-	" Is this worth it? Is /completion/ of a "blank" wanted? Can we consider (
-	" interesting and check if we are in a function call etc.?
-	if line[column - 2] !~ '[0-9A-Za-z:_-]'
-		if a:findstart
-			return column
-		else
-			return s:erlangFindLocalFunc(a:base)
-		endif
-	endif
-	
-
-	" 3) Function in external module {{{2
-	if line =~ s:erlangExternalFuncBeg
-		let delimiter = match(line, ':[0-9A-Za-z_-]*$') + 1
-		if a:findstart
-			return delimiter
-		else
-                        let module = matchstr(line[:-2], '\<\k*\>$')
-			return s:erlangFindExternalFunc(module, a:base)
-		endif
-	endif
-
-	" 4) Local function {{{2
-	if line =~ s:erlangLocalFuncBeg
-		let funcstart = match(line, ':\@<![0-9A-Za-z_-]*$')
-		if a:findstart
-			return funcstart
-		else
-			return s:erlangFindLocalFunc(a:base)
-		endif
-	endif
-
-	" 5) Unhandled situation {{{2
-	if a:findstart
-		return -1
-	else
-		return []
-	endif
-endfunction
-
-" Auxiliary functions for completion {{{1 
-" Find the next non-blank line {{{2
-function s:erlangFindNextNonBlank(lnum)
-	let lnum = nextnonblank(a:lnum + 1)
-	let line = getline(lnum)
-	while line =~ s:ErlangBlankLine && 0 != lnum
-		let lnum = nextnonblank(lnum + 1)
-		let line = getline(lnum)
-   endwhile
-   return lnum
-endfunction
-			
-" vim: foldmethod=marker:
-" Find external function names {{{2
-function s:erlangFindExternalFunc(module, base)
-        " If it's a local module, try to compile it
-        if filereadable(a:module . '.erl') && !filereadable(a:module . '.beam')
-            silent execute '!erlc' a:module . '.erl' '>/dev/null' '2>/dev/null'
-            redraw!
-        endif
-        let functions = system(s:erlangCompletionPath . ' ' . a:module)
-        for element in sort(split(functions, '\n'))
-            if match(element, a:base) == 0
-                let function_name = matchstr(element, a:base . '\w\+')
-                let number_of_args = matchstr(element, '\d\+', len(function_name))
-                let number_of_comma = max([number_of_args - 1, 0])
-                let file_path = g:erlangManPath . '/man?/' . a:module . '\.?' . g:erlangManSuffix
-                " [:-2] cutting some weird characters at the end
-                " becouse grep doesn't support multilines, we have to filter
-                " first by .B and next by looking via function name
-                " if someone have better idea, please change it
-                let description = ''
-                " Don't look man pages if the module is present in the current directory
-                if g:erlangCompletionDisplayDoc != 0 && !filereadable(a:module . '.erl')
-                    let system_command = g:erlangCompletionGrep . ' -A 1 "\.B" ' . file_path . ' | grep -EZo "\<' .
-\                           function_name . '\>\((\w+, ){' . number_of_comma . '}[^),]*\) -> .*"'
-                    let description = system(system_command)
-                    let description = description[:-2]
-                endif
-                if description == ''
-                    let description = element " if function doesn't have description e.g. lists:rmerge, put rmerge/2 instead
-                endif
-                let field = {'word': function_name . '(', 'abbr': description, 'kind': 'f', 'dup': 1} " always duplicate functions
-                call complete_add(field)
-            endif
-        endfor
-        return []
-endfunction
-
-" Find local function names {{{2
-function s:erlangFindLocalFunc(base)
-	" begin at line 1
-	let lnum = s:erlangFindNextNonBlank(1)
-	if "" == a:base
-		let base = '\w' " used to match against word symbol
-	else
-		let base = a:base
-	endif
-	while 0 != lnum && !complete_check()
-		let line = getline(lnum)
-		let function_name = matchstr(line, '^' . base . '[0-9A-Za-z_-]\+(\@=')
-		if function_name != ""
-			call complete_add(function_name)
-		endif
-		let lnum = s:erlangFindNextNonBlank(lnum)
-	endwhile
-	return []
-endfunction
-

autoload/fish.vim

@@ -0,0 +1,71 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'fish') != -1
+  finish
+endif
+
+function! fish#Indent()
+    let l:shiftwidth = shiftwidth()
+    let l:prevlnum = prevnonblank(v:lnum - 1)
+    if l:prevlnum ==# 0
+        return 0
+    endif
+    let l:indent = 0
+    let l:prevline = getline(l:prevlnum)
+    if l:prevline =~# '\v^\s*switch>'
+        let l:indent = l:shiftwidth * 2
+    elseif l:prevline =~# '\v^\s*%(begin|if|else|while|for|function|case)>'
+        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 ? l:shiftwidth : l:indent)
+    elseif l:line =~# '\v^\s*%(case|else)>'
+        return indent(v:lnum) - l:shiftwidth
+    endif
+    return indent(l:prevlnum) + l:indent
+endfunction
+
+function! fish#Format()
+    if mode() =~# '\v^%(i|R)$'
+        return 1
+    else
+        let l:command = v:lnum.','.(v:lnum+v:count-1).'!fish_indent'
+        echo l:command
+        execute l:command
+    endif
+endfunction
+
+function! fish#Fold()
+    let l:line = getline(v:lnum)
+    if l:line =~# '\v^\s*%(begin|if|while|for|function|switch)>'
+        return 'a1'
+    elseif l:line =~# '\v^\s*end>'
+        return 's1'
+    else
+        return '='
+    end
+endfunction
+
+function! fish#Complete(findstart, base)
+    if a:findstart
+        return getline('.') =~# '\v^\s*$' ? -1 : 0
+    else
+        if empty(a:base)
+            return []
+        endif
+        let l:results = []
+        let l:completions =
+                    \ system('fish -c "complete -C'.shellescape(a:base).'"')
+        let l:cmd = substitute(a:base, '\v\S+$', '', '')
+        for l:line in split(l:completions, '\n')
+            let l:tokens = split(l:line, '\t')
+            call add(l:results, {'word': l:cmd.l:tokens[0],
+                                \'abbr': l:tokens[0],
+                                \'menu': get(l:tokens, 1, '')})
+        endfor
+        return l:results
+    endif
+endfunction
+
+function! fish#errorformat()
+    return '%Afish: %m,%-G%*\\ ^,%-Z%f (line %l):%s'
+endfunction

autoload/go/complete.vim

@@ -1,103 +0,0 @@
-" Copyright 2011 The Go Authors. All rights reserved.
-" Use of this source code is governed by a BSD-style
-" license that can be found in the LICENSE file.
-"
-" This file provides a utility function that performs auto-completion of
-" package names, for use by other commands.
-
-let s:goos = $GOOS
-let s:goarch = $GOARCH
-
-if len(s:goos) == 0
-  if exists('g:golang_goos')
-    let s:goos = g:golang_goos
-  elseif has('win32') || has('win64')
-    let s:goos = 'windows'
-  elseif has('macunix')
-    let s:goos = 'darwin'
-  else
-    let s:goos = '*'
-  endif
-endif
-
-if len(s:goarch) == 0
-  if exists('g:golang_goarch')
-    let s:goarch = g:golang_goarch
-  else
-    let s:goarch = '*'
-  endif
-endif
-
-function! go#complete#PackageMembers(package, member)
-  silent! let content = system('godoc ' . a:package)
-  if v:shell_error || !len(content)
-    return []
-  endif
-  let lines = filter(split(content, "\n"),"v:val !~ '^\\s\\+$'")
-  try
-    let mx1 = '^\s\+\(\S+\)\s\+=\s\+.*'
-    let mx2 = '^\%(const\|var\|type\|func\) \([A-Z][^ (]\+\).*'
-    let candidates =
-    \   map(filter(copy(lines), 'v:val =~ mx1'), 'substitute(v:val, mx1, "\\1", "")')
-    \ + map(filter(copy(lines), 'v:val =~ mx2'), 'substitute(v:val, mx2, "\\1", "")')
-    return filter(candidates, '!stridx(v:val, a:member)')
-  catch
-    return []
-  endtry
-endfunction
-
-function! go#complete#Package(ArgLead, CmdLine, CursorPos)
-  let dirs = []
-
-  let words = split(a:CmdLine, '\s\+', 1)
-  if len(words) > 2
-    " Complete package members
-    return go#complete#PackageMembers(words[1], words[2])
-  endif
-
-  if executable('go')
-    let goroot = substitute(system('go env GOROOT'), '\n', '', 'g')
-    if v:shell_error
-      echomsg '''go env GOROOT'' failed'
-    endif
-  else
-    let goroot = $GOROOT
-  endif
-
-  if len(goroot) != 0 && isdirectory(goroot)
-    let dirs += [goroot]
-  endif
-
-  let pathsep = ':'
-  if s:goos == 'windows'
-    let pathsep = ';'
-  endif
-  let workspaces = split($GOPATH, pathsep)
-  if workspaces != []
-    let dirs += workspaces
-  endif
-
-  if len(dirs) == 0
-    " should not happen
-    return []
-  endif
-
-  let ret = {}
-  for dir in dirs
-    " this may expand to multiple lines
-    let root = split(expand(dir . '/pkg/' . s:goos . '_' . s:goarch), "\n")
-    call add(root, expand(dir . '/src'))
-    for r in root
-      for i in split(globpath(r, a:ArgLead.'*'), "\n")
-        if isdirectory(i)
-          let i .= '/'
-        elseif i !~ '\.a$'
-          continue
-        endif
-        let i = substitute(substitute(i[len(r)+1:], '[\\]', '/', 'g'), '\.a$', '', 'g')
-        let ret[i] = i
-      endfor
-    endfor
-  endfor
-  return sort(keys(ret))
-endfunction

autoload/go/config.vim

@@ -0,0 +1,483 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'go') != -1
+  finish
+endif
+
+" don't spam the user when Vim is started in Vi compatibility mode
+let s:cpo_save = &cpo
+set cpo&vim
+
+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 has('nvim') && 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
+
+function! go#config#GocodeUnimportedPackages() abort
+  return get(g:, 'go_gocode_unimported_packages', 0)
+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', 0)
+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#DebugLogOutput() abort
+  return get(g:, 'go_debug_log_output', 'debugger, rpc')
+endfunction
+
+function! go#config#LspLog() abort
+  " make sure g:go_lsp_log is set so that it can be added to easily.
+  let g:go_lsp_log = get(g:, 'go_lsp_log', [])
+  return g:go_lsp_log
+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", "gometalinter")
+endfunction
+
+function! go#config#MetalinterAutosaveEnabled() abort
+  let l:default_enabled = ["vet", "golint"]
+
+  if go#config#MetalinterCommand() == "golangci-lint"
+    let l:default_enabled = ["govet", "golint"]
+  endif
+
+  return get(g:, "go_metalinter_autosave_enabled", default_enabled)
+endfunction
+
+function! go#config#MetalinterEnabled() abort
+  let l:default_enabled = ["vet", "golint", "errcheck"]
+
+  if go#config#MetalinterCommand() == "golangci-lint"
+    let l:default_enabled = ["govet", "golint"]
+  endif
+
+  return get(g:, "go_metalinter_enabled", default_enabled)
+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#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#SearchBinPathFirst() abort
+  return get(g:, 'go_search_bin_path_first', 1)
+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#HighlightFunctionParameters() abort
+  " fallback to highlight_function_arguments for backwards compatibility
+  return get(g:, 'go_highlight_function_parameters', 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#HighlightDebug() abort
+  return get(g:, 'go_highlight_debug', 1)
+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
+
+function! go#config#EchoGoInfo() abort
+  return get(g:, "go_echo_go_info", 1)
+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
+
+" restore Vi compatibility settings
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim: sw=2 ts=2 et

autoload/julia.vim

@@ -0,0 +1,188 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'julia') != -1
+  finish
+endif
+
+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
+

autoload/julia/doc.vim

@@ -0,0 +1,246 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'julia') != -1
+  finish
+endif
+
+" 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

autoload/julia_blocks.vim

@@ -0,0 +1,798 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'julia') != -1
+  finish
+endif
+
+" 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

autoload/pony.vim

@@ -0,0 +1,536 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'pony') != -1
+  finish
+endif
+
+" Vim plugin file
+" Language:     Pony
+" Maintainer:   Jak Wings
+
+" TODO: Make sure echomsg is off for release.
+let s:cpo_save = &cpo
+set cpo&vim
+
+
+"let s:skip = '<SID>InCommentOrLiteral(line("."), col("."))'
+let s:skip2 = '<SID>InLiteral(line("."), col(".")) || <SID>InComment(line("."), col(".")) == 1'
+let s:skip3 = '!<SID>InKeyword(line("."), col("."))'
+let s:skip4 = '!<SID>InBracket(line("."), col("."))'
+let s:cfstart = '\v<%(ifdef|if|match|while|for|repeat|try|with|recover|object|lambda|iftype)>'
+let s:cfmiddle = '\v<%(then|elseif|else|until|do|in|elseiftype)>|\|'
+let s:cfend = '\v<end>'
+let s:bstartp = '\v<%(ifdef|if|then|elseif|else|(match)|while|for|in|do|try|with|recover|repeat|until|(object)|lambda|iftype|elseiftype)>'
+
+function! pony#Indent()
+  if v:lnum <= 1
+    return 0
+  endif
+
+  call cursor(v:lnum, 1)
+  let l:pnzpos = searchpos('.', 'cbnW')
+  if l:pnzpos == [0, 0]
+    return 0
+  endif
+
+  if s:InComment2(l:pnzpos) > 1
+    "echomsg 'Comment' (l:pnzpos[0] . '-' . v:lnum) -1
+    return cindent(v:lnum)
+  endif
+
+  if s:InLiteral2(l:pnzpos)
+    "echomsg 'String' (l:pnzpos[0] . '-' . v:lnum) -1
+    return -1
+  endif
+
+  unlet! l:pnzpos
+
+  " NOTE: Lines started in comments and strings are checked already.
+
+  let l:pnblnum = s:PrevNonblank(v:lnum - 1)
+  if l:pnblnum < 1
+    return 0
+  endif
+
+  let l:pnbline = getline(l:pnblnum)
+  let l:pnbindent = indent(l:pnblnum)
+
+  let l:line = getline(v:lnum)
+  let l:indent = l:pnbindent
+  let l:shiftwidth = shiftwidth()
+
+  " FIXME?
+  let l:continuing = 0
+  " If the previous line ends with a unary or binary operator,
+  if s:IsContinued(l:pnblnum)
+    let l:contlnum = l:pnblnum
+    let l:ppcontinued = 0
+    let l:ppnblnum = s:PrevNonblank(l:pnblnum - 1)
+    while s:IsContinued(l:ppnblnum)
+      let l:ppcontinued += 1
+      let l:contlnum = l:ppnblnum
+      let l:ppnblnum = s:PrevNonblank(l:ppnblnum - 1)
+    endwhile
+    "echomsg 'Continued1' l:pnblnum l:contlnum
+    " If the previous line is also continuing another line,
+    if l:ppcontinued
+      let l:continuing = 1
+      if getline(l:contlnum) =~# '\v^\s*%(actor|class|struct|primitive|trait|type|interface)>'
+        " reset the indent level.
+        "echomsg 'Continuing0' (l:contlnum . '-' . v:lnum) (l:shiftwidth * 2)
+        let l:indent = l:shiftwidth * 2
+      else
+        " keep using the previous indent.
+        "echomsg 'Continuing1' (l:pnblnum . '-' . v:lnum) l:pnbindent
+        let l:indent = l:pnbindent
+      endif
+    " if the previous line is part of the definition of a class,
+    elseif l:pnbline =~# '\v^\s*%(actor|class|struct|primitive|trait|type|interface)>'
+      " reset the indent level.
+      "echomsg 'Continuing2' (l:pnblnum . '-' . v:lnum) (l:shiftwidth * 2)
+      let l:continuing = 1
+      let l:indent = l:shiftwidth * 2
+    " if the previous line is part of the definition of a method,
+    elseif l:pnbline =~# '\v^\s*%(fun|new|be)>'
+      " reset the indent level.
+      "echomsg 'Continuing3' (l:pnblnum . '-' . v:lnum) (l:pnbindent + l:shiftwidth)
+      let l:continuing = 1
+      let l:indent = l:pnbindent + l:shiftwidth
+    " if the previous line is the start of a definition body,
+    elseif l:pnbline =~# '=>\s*$'
+      " indent this line.
+      "echomsg 'Continuing4' (l:pnblnum . '-' . v:lnum) (l:pnbindent + l:shiftwidth)
+      let l:continuing = 1
+      let l:indent = l:pnbindent + l:shiftwidth
+    else
+      " indent this line twice as far.
+      "echomsg 'Continuing5' (l:pnblnum . '-' . v:lnum) (l:pnbindent + l:shiftwidth * 2)
+      let l:continuing = 1
+      let l:indent = l:pnbindent + l:shiftwidth * 2
+    endif
+
+    unlet! l:contlnum l:ppnblnum l:ppcontinued
+  endif
+
+  " If this line starts a document string,
+  if !l:continuing && l:line =~# '^\s*"""'
+    let l:ppnblnum = s:PrevNonblank(l:pnblnum - 1)
+    if s:IsContinued(l:ppnblnum)
+      let l:contlnum = l:ppnblnum
+      while s:IsContinued(l:ppnblnum)
+        let l:contlnum = l:ppnblnum
+        let l:ppnblnum = s:PrevNonblank(l:ppnblnum - 1)
+      endwhile
+      if getline(l:contlnum) =~# '\v^\s*%(actor|class|struct|primitive|trait|type|interface)>'
+        " reset the indent level.
+        "echomsg 'DocString' (l:contlnum . '-' . v:lnum) l:shiftwidth
+        return l:shiftwidth
+      endif
+    endif
+
+    unlet! l:contlnum l:ppnblnum
+  endif
+
+  " If the previous line contains an unmatched opening bracket
+  if !l:continuing && l:pnbline =~# '[{[(]'
+    " if the line ends with an opening bracket,
+    if l:pnbline =~# '[{[(]\s*$' && !s:InCommentOrLiteral(l:pnblnum, col([l:pnblnum, '$']) - 1)
+      " indent this line.
+      let l:indent += l:shiftwidth
+    else
+      " find the unmatched opening bracket,
+      let l:start = [0, 0]
+      let l:end = col([l:pnblnum, '$']) - 1
+      call cursor(l:pnblnum, l:end)
+      while l:end > 0
+        let l:start = s:OuterPos(l:start, searchpairpos('(', '', ')', 'bnW', s:skip4, l:pnblnum))
+        let l:start = s:OuterPos(l:start, searchpairpos('\[', '', '\]', 'bnW', s:skip4, l:pnblnum))
+        let l:start = s:OuterPos(l:start, searchpairpos('{', '', '}', 'bnW', s:skip4, l:pnblnum))
+        if l:start == [0, 0]
+          break
+        endif
+        " find the matched closing bracket on the same line,
+        call cursor(l:start[0], l:start[1])
+        let l:c = s:CharAtCursor(l:start[0], l:start[1])
+        if searchpair(escape(l:c, '['), '', escape(tr(l:c, '([{', ')]}'), ']'),
+              \ 'znW', s:skip4, l:pnblnum) < 1
+          " the unmatched opening bracket is found,
+          break
+        endif
+        let l:end = l:start[1]
+        let l:start = [0, 0]
+      endwhile
+      if l:start != [0, 0]
+        " indent this line.
+        "echomsg 'Open bracket' (l:pnblnum . '-' . v:lnum) (l:indent + l:shiftwidth)
+        let l:indent += l:shiftwidth
+      endif
+    endif
+
+    unlet! l:start l:end l:c
+  endif
+
+  " If there is a matched closing bracket on the previous line,
+  " NOTE:
+  " >|[
+  "  |  (1 -
+  "  |      1) * 2]
+  "  |  command
+  "   ^
+  if !l:continuing
+    call cursor(l:pnblnum, 1)
+    " find the last closing bracket,
+    let l:end = [0, 0]
+    let l:end = s:OuterPos(l:end, searchpairpos('(', '', ')', 'zncr', s:skip4, l:pnblnum))
+    let l:end = s:OuterPos(l:end, searchpairpos('\[', '', '\]', 'zncr', s:skip4, l:pnblnum))
+    let l:end = s:OuterPos(l:end, searchpairpos('{', '', '}', 'zncr', s:skip4, l:pnblnum))
+    if l:end != [0, 0]
+      " find the matched opening bracket on another line,
+      let l:c = s:CharAtCursor(l:end[0], l:end[1])
+      let l:start = searchpairpos(escape(tr(l:c, ')]}', '([{'), '['), '', escape(l:c, ']'), 'nbW', s:skip4)
+      if l:start[0] != l:end[0]
+        " and then this line has the same indent as the line the matched bracket stays.
+        "echomsg 'Matched bracket' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+        let l:indent = indent(l:start[0])
+      endif
+    endif
+
+    unlet! l:start l:end l:c
+  endif
+
+  " If there is a matched closing bracket on this line,
+  " NOTE:
+  "  |[
+  " >|  (1 -
+  "  |      1) * 2
+  "  |]
+  "   ^     ^
+  if l:line =~# '^\s*[)\]}]'
+    " find the first closing bracket,
+    call cursor(v:lnum, 1)
+    let l:end = [0, 0]
+    let l:end = s:InnerPos(l:end, searchpairpos('(', '', ')', 'zncW', s:skip4, v:lnum))
+    let l:end = s:InnerPos(l:end, searchpairpos('\[', '', '\]', 'zncW', s:skip4, v:lnum))
+    let l:end = s:InnerPos(l:end, searchpairpos('{', '', '}', 'zncW', s:skip4, v:lnum))
+    if l:end != [0, 0]
+      " find the matched opening bracket on another line,
+      let l:c = s:CharAtCursor(l:end[0], l:end[1])
+      let l:start = searchpairpos(escape(tr(l:c, ')]}', '([{'), '['), '', escape(l:c, ']'), 'nbW', s:skip4)
+      if l:start[0] != l:end[0]
+        " and then this line has the same indent as the line the matched bracket stays.
+        "echomsg 'Closing Bracket' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+        let l:indent = indent(l:start[0])
+      endif
+    endif
+
+    unlet! l:start l:end l:c
+  endif
+
+  " If this line starts the definition of a method, closure or match case,
+  if l:line =~# '^\s*=>'
+    " find the start of the definition,
+    call cursor(v:lnum, 1)
+    let l:start = searchpairpos('\v<%(new|be|fun|lambda)>|\|', '', '=>\zs', 'bnW', s:skip3)
+    if l:start != [0, 0]
+      " then this line has the same indent as the start.
+      "echomsg 'Method body' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+      return indent(l:start[0])
+    endif
+
+    unlet! l:start
+  endif
+
+  " If this line starts a class definition or starts an alias,
+  if l:line =~# '\v^\s*%(actor|class|struct|primitive|trait|interface|use|type)>'
+    " reset the indent level.
+    return 0
+  endif
+
+  " If this line starts a method definition,
+  if l:line =~# '\v^\s*%(new|be|fun)>'
+    call cursor(v:lnum, 1)
+    let l:start = searchpairpos(s:cfstart, s:cfmiddle, s:cfend, 'bW', s:skip3)
+    if l:start != [0, 0]
+      let l:start = searchpos(s:bstartp, 'zcnpW', l:start[0])
+      " see if it is in an object block,
+      if l:start[2] == 3
+        "echomsg 'Method in object' (l:start[0] . '-' . v:lnum) (l:shiftwidth + indent(l:start[0]))
+        return l:shiftwidth + indent(l:start[0])
+      endif
+    endif
+    return l:shiftwidth
+  endif
+
+  " If this line starts a match case,
+  call cursor(v:lnum, 1)
+  if l:line =~# '^\s*|' && s:InKeyword(searchpos('|', 'znW', v:lnum))
+    " find the start or the previous case of the match block,
+    let l:start = searchpairpos(s:cfstart, s:cfmiddle, s:cfend, 'bnW', s:skip3)
+    if l:start != [0, 0]
+      " then this line has the same indent as the start.
+      "echomsg 'Match case' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+      return indent(l:start[0])
+    endif
+
+    unlet! l:start
+  endif
+
+  " If this line ends (part of) a control flow,
+  if l:line =~# '\v^\s*%(end|elseif|else|then|in|do|until|elseiftype)>'
+    " find the start or middle of the control block,
+    call cursor(v:lnum, 1)
+    let l:start = searchpairpos(s:cfstart, s:cfmiddle, s:cfend, 'bnW', s:skip3)
+    if l:start != [0, 0]
+      " then this line has the same indent as the start.
+      "echomsg 'Block end' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+      return indent(l:start[0])
+    endif
+
+    unlet! l:start
+  endif
+
+  " If the previous line starts a class definition,
+  if l:pnbline =~# '\v^\s*%(actor|class|struct|primitive|trait|type|interface)>'
+    " reset the indent level.
+    if s:IsContinued(l:pnblnum)
+      return l:shiftwidth * 2
+    else
+      return l:shiftwidth
+    endif
+  endif
+
+  " If the previous line starts a method definition,
+  if l:pnbline =~# '\v^\s*%(new|be|fun)>'
+    return l:pnbindent + l:shiftwidth
+  endif
+
+  " If the previous line starts (part of) a control flow,
+  call cursor(l:pnblnum, 1)
+  while 1
+    " find the start of the control block,
+    let l:start = searchpos(s:bstartp, 'zcepW', l:pnblnum)
+    if l:start[2] == 0
+      break
+    endif
+    if !s:InKeyword(l:start[0:1])
+      call cursor(l:pnblnum, l:start[1] + 3)
+      continue
+    endif
+    let l:index = l:start[2]
+    " find the end of the control block on the same line,
+    let l:end = searchpair(s:cfstart, '', s:cfend, 'znW', s:skip3, l:pnblnum)
+    " if the control block is not ended,
+    if l:end < 1
+      " if this line is a case for a match,
+      if l:index == 2 && l:line =~# '^\s*|'
+        " then this line has the same indent as the start of the match block.
+        return l:pnbindent
+      else
+        " then indent this line.
+        "echomsg 'Block start' (l:pnblnum . '-' . v:lnum) (l:pnbindent + l:shiftwidth)
+        return l:pnbindent + l:shiftwidth
+      endif
+    endif
+  endwhile
+
+  unlet! l:start l:end l:index
+
+  return l:indent
+endfunction
+
+function! s:PrevNonblank(lnum)
+  let l:lnum = prevnonblank(a:lnum)
+  while l:lnum > 0 && (s:InComment2(l:lnum, 1) || s:InLiteral2(l:lnum, 1))
+    let l:lnum = prevnonblank(l:lnum - 1)
+  endwhile
+  return l:lnum
+endfunction
+
+" NOTE:
+"                 v
+"  |1 /* comment */
+"  |2
+function! s:IsContinued(lnum)
+  let l:lnum = s:PrevNonblank(a:lnum)
+  if l:lnum < 1
+    return 0
+  endif
+  let l:line = getline(l:lnum)
+  let l:width = strwidth(substitute(l:line, '\s*$', '', ''))
+  " FIXME?
+  "  | 1 + //
+  "  | //
+  "  |     2
+  return !s:InCommentOrLiteral(a:lnum, l:width)
+        \ && (l:line =~# '\v<%(and|or|xor|is|isnt|as|not|consume|addressof|digestof)\s*$'
+        \ || l:line =~# '\v%([=\-.]\>|[<!=>]\=\~?|\<\<\~?|\>\>\~?|\<:|[+\-*/%<>]\~?|[.,|:@~])\s*$'
+        \ )
+endfunction
+
+function! s:InCommentOrLiteral(...)
+  return call('s:InComment', a:000) || call('s:InLiteral', a:000)
+endfunction
+
+function! s:InKeyword(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  for id in s:Or(synstack(l:lnum, l:col), [])
+    if synIDattr(id, 'name') =~# '^ponyKw'
+      return 1
+    endif
+  endfor
+  return 0
+endfunction
+
+function! s:InBracket(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  for id in s:Or(synstack(l:lnum, l:col), [])
+    if synIDattr(id, 'name') ==# 'ponyBracket'
+      return 1
+    endif
+  endfor
+  return 0
+endfunction
+
+function! s:InComment(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  let l:stack = synstack(l:lnum, l:col)
+  let l:i = len(l:stack)
+  while l:i > 0
+    let l:sname = synIDattr(l:stack[l:i - 1], 'name')
+    if l:sname =~# '^ponyNestedCommentX\?$'
+      return 1 + l:i - (l:sname =~# 'X$')
+    elseif l:sname =~# '^ponyCommentX\?$'
+      return 1
+    endif
+    let l:i -= 1
+  endwhile
+  return 0
+endfunction
+
+function! s:InLiteral(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  let l:stack = synstack(l:lnum, l:col)
+  let l:i = len(l:stack)
+  while l:i > 0
+    let l:sname = synIDattr(l:stack[l:i - 1], 'name')
+    if l:sname =~# '^ponyDocumentStringX\?$'
+      return 3
+    elseif l:sname =~# '^ponyStringX\?$'
+      return 2
+    elseif l:sname =~# '^ponyCharacterX\?$'
+      return 1
+    endif
+    let l:i -= 1
+  endwhile
+  return 0
+endfunction
+
+" NOTE:
+" |// //inside
+"   ^^^^^^^^^^
+" |/* /*inside*/ */
+"   ^^^^^^^^^^^^^^
+function! s:InComment2(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  let l:stack = synstack(l:lnum, l:col)
+  let l:i = len(l:stack)
+  while l:i > 0
+    let l:sname = synIDattr(l:stack[l:i - 1], 'name')
+    if l:sname ==# 'ponyNestedComment'
+      return 1 + l:i
+    elseif l:sname ==# 'ponyComment'
+      return 1
+    elseif l:sname =~# '\v^pony%(Nested)?CommentX$'
+      return 0
+    endif
+    let l:i -= 1
+  endwhile
+  return 0
+endfunction
+
+" NOTE:
+" |"inside"
+"   ^^^^^^
+" |"""inside"""""
+"   ^^^^^^^^^^^^
+function! s:InLiteral2(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  let l:stack = synstack(l:lnum, l:col)
+  let l:i = len(l:stack)
+  while l:i > 0
+    let l:sname = synIDattr(l:stack[l:i - 1], 'name')
+    if l:sname ==# 'ponyDocumentString'
+      return 3
+    elseif l:sname ==# 'ponyString'
+      return 2
+    elseif l:sname ==# 'ponyCharacter'
+      return 1
+    elseif l:sname =~# '\v^pony%(DocumentString|String|Character)X$'
+      return 0
+    endif
+    let l:i -= 1
+  endwhile
+  return 0
+endfunction
+
+function! s:CharAtCursor(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  return matchstr(getline(l:lnum), '\%' . l:col . 'c.')
+endfunction
+
+function! s:Or(x, y)
+  return !empty(a:x) ? a:x : a:y
+endfunction
+
+function! s:InnerPos(x, y)
+  if a:x == [0, 0]
+    return a:y
+  elseif a:y == [0, 0]
+    return a:x
+  else
+    return a:x[1] < a:y[1] ? a:x : a:y
+  end
+endfunction
+
+function! s:OuterPos(x, y)
+  if a:x == [0, 0]
+    return a:y
+  elseif a:y == [0, 0]
+    return a:x
+  else
+    return a:x[1] > a:y[1] ? a:x : a:y
+  end
+endfunction
+
+function! pony#ClearTrailingSpace(all, alt, ...)
+  let l:force = (a:0 > 0 ? a:1 : 0)
+  if !l:force && (&readonly || !&modifiable || !&modified)
+    return
+  endif
+  if a:all
+    for lnum in range(1, line('$'))
+      let l:line = getline(lnum)
+      let l:end = col([lnum, '$']) - 1
+      if l:end > 0 && l:line =~# '\s$' && !s:InLiteral(lnum, l:end)
+        if a:alt
+          call setline(lnum, substitute(l:line, '\S\@<=\s\s*$', '', ''))
+        else
+          call setline(lnum, substitute(l:line, '\s\+$', '', ''))
+        endif
+      endif
+    endfor
+  else
+    let l:lnum = line('.')
+    let l:end = col('$') - 1
+    let l:line = getline(l:lnum)
+    if l:line =~# '\s$' && !s:InLiteral(l:lnum, l:end)
+      if a:alt
+        call setline(l:lnum, substitute(l:line, '\s\+$', '', ''))
+      else
+        call setline(l:lnum, substitute(l:line, '\S\@<=\s\s*$', '', ''))
+      endif
+    endif
+  endif
+endfunction
+
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

autoload/python/utils.vim

@@ -0,0 +1,21 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'python-compiler') != -1
+  finish
+endif
+
+" Sometimes Python issues debugging messages
+" which don't belong to a call stack context
+" this function filters these messages
+function! python#utils#fix_qflist() " {{{
+  let l:traceback = []
+  let l:qflist = getqflist()
+
+  for l:item in l:qflist
+    if !empty(l:item.type)
+      call add(l:traceback, l:item)
+    endif
+  endfor
+
+  if !empty(l:traceback)
+    call setqflist(l:traceback)
+  endif
+endfunction " }}}

autoload/rubycomplete.vim

@@ -1,9 +1,12 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'ruby') != -1
+  finish
+endif
+
 " Vim completion script
-" Language:             Ruby
-" Maintainer:           Mark Guzman <segfault@hasno.info>
-" URL:                  https://github.com/vim-ruby/vim-ruby
-" Release Coordinator:  Doug Kearns <dougkearns@gmail.com>
-" Maintainer Version:   0.8.1
+" Language:		Ruby
+" Maintainer:		Mark Guzman <segfault@hasno.info>
+" URL:			https://github.com/vim-ruby/vim-ruby
+" Release Coordinator:	Doug Kearns <dougkearns@gmail.com>
 " ----------------------------------------------------------------------------
 "
 " Ruby IRB/Complete author: Keiju ISHITSUKA(keiju@ishitsuka.com)
@@ -53,6 +56,23 @@ if !exists("g:rubycomplete_include_objectspace")
 endif
 " }}} configuration failsafe initialization
 
+" {{{ regex patterns
+
+" Regex that defines the start-match for the 'end' keyword.
+let s:end_start_regex =
+      \ '\C\%(^\s*\|[=,*/%+\-|;{]\|<<\|>>\|:\s\)\s*\zs' .
+      \ '\<\%(module\|class\|if\|for\|while\|until\|case\|unless\|begin' .
+      \   '\|\%(\K\k*[!?]\?\s\+\)\=def\):\@!\>' .
+      \ '\|\%(^\|[^.:@$]\)\@<=\<do:\@!\>'
+
+" Regex that defines the middle-match for the 'end' keyword.
+let s:end_middle_regex = '\<\%(ensure\|else\|\%(\%(^\|;\)\s*\)\@<=\<rescue:\@!\>\|when\|elsif\):\@!\>'
+
+" Regex that defines the end-match for the 'end' keyword.
+let s:end_end_regex = '\%(^\|[^.:@$]\)\@<=\<end:\@!\>'
+
+" }}} regex patterns
+
 " {{{ vim-side support functions
 let s:rubycomplete_debug = 0
 
@@ -103,7 +123,7 @@ function! s:GetBufferRubyEntity( name, type, ... )
     endif
 
     let curpos = getpos(".")
-    let [enum,ecol] = searchpairpos( crex, '', '\(end\|}\)', 'wr' )
+    let [enum,ecol] = searchpairpos( s:end_start_regex, s:end_middle_regex, s:end_end_regex, 'W' )
     call cursor(lastpos[1], lastpos[2])
 
     if lnum > enum
@@ -128,19 +148,28 @@ function! s:IsPosInClassDef(pos)
     return ret
 endfunction
 
+function! s:IsInComment(pos)
+    let stack = synstack(a:pos[0], a:pos[1])
+    if !empty(stack)
+        return synIDattr(stack[0], 'name') =~ 'ruby\%(.*Comment\|Documentation\)'
+    else
+        return 0
+    endif
+endfunction
+
 function! s:GetRubyVarType(v)
     let stopline = 1
     let vtp = ''
-    let pos = getpos('.')
+    let curpos = getpos('.')
     let sstr = '^\s*#\s*@var\s*'.escape(a:v, '*').'\>\s\+[^ \t]\+\s*$'
     let [lnum,lcol] = searchpos(sstr,'nb',stopline)
     if lnum != 0 && lcol != 0
-        call setpos('.',pos)
+        call setpos('.',curpos)
         let str = getline(lnum)
         let vtp = substitute(str,sstr,'\1','')
         return vtp
     endif
-    call setpos('.',pos)
+    call setpos('.',curpos)
     let ctors = '\(now\|new\|open\|get_instance'
     if exists('g:rubycomplete_rails') && g:rubycomplete_rails == 1 && s:rubycomplete_rails_loaded == 1
         let ctors = ctors.'\|find\|create'
@@ -150,9 +179,13 @@ function! s:GetRubyVarType(v)
 
     let fstr = '=\s*\([^ \t]\+.' . ctors .'\>\|[\[{"''/]\|%[xwQqr][(\[{@]\|[A-Za-z0-9@:\-()\.]\+...\?\|lambda\|&\)'
     let sstr = ''.escape(a:v, '*').'\>\s*[+\-*/]*'.fstr
-    let [lnum,lcol] = searchpos(sstr,'nb',stopline)
-    if lnum != 0 && lcol != 0
-        let str = matchstr(getline(lnum),fstr,lcol)
+    let pos = searchpos(sstr,'bW')
+    while pos != [0,0] && s:IsInComment(pos)
+        let pos = searchpos(sstr,'bW')
+    endwhile
+    if pos != [0,0]
+        let [lnum, col] = pos
+        let str = matchstr(getline(lnum),fstr,col)
         let str = substitute(str,'^=\s*','','')
 
         call setpos('.',pos)
@@ -174,7 +207,7 @@ function! s:GetRubyVarType(v)
         end
         return ''
     endif
-    call setpos('.',pos)
+    call setpos('.',curpos)
     return ''
 endfunction
 
@@ -196,7 +229,7 @@ function! rubycomplete#Complete(findstart, base)
             if c =~ '\w'
                 continue
             elseif ! c =~ '\.'
-                idx = -1
+                let idx = -1
                 break
             else
                 break
@@ -253,15 +286,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
@@ -344,8 +389,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)
@@ -423,7 +473,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?
@@ -529,7 +578,6 @@ class VimRubyCompletion
         ret += ActiveRecord::ConnectionAdapters::SchemaStatements.methods
     end
 
-
     return ret
   end
 
@@ -587,11 +635,13 @@ class VimRubyCompletion
 # {{{ main completion code
   def self.preload_rails
     a = VimRubyCompletion.new
-    require 'Thread'
-    Thread.new(a) do |b|
-      begin
-      b.load_rails
-      rescue
+    if VIM::evaluate("has('nvim')") == 0
+      require 'thread'
+      Thread.new(a) do |b|
+        begin
+        b.load_rails
+        rescue
+        end
       end
     end
     a.load_rails
@@ -612,7 +662,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
@@ -655,25 +704,25 @@ class VimRubyCompletion
           methods.delete_if { |c| c.match( /'/ ) }
         end
 
-      when /^::([A-Z][^:\.\(]*)$/ # Absolute Constant or class methods
+      when /^::([A-Z][^:\.\(]*)?$/ # Absolute Constant or class methods
         dprint "const or cls"
         receiver = $1
-        methods = Object.constants
-        methods.grep(/^#{receiver}/).collect{|e| "::" + e}
+        methods = Object.constants.collect{ |c| c.to_s }.grep(/^#{receiver}/)
 
       when /^(((::)?[A-Z][^:.\(]*)+?)::?([^:.]*)$/ # Constant or class methods
         receiver = $1
         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")
+          constants = eval("#{receiver}.constants").collect{ |c| c.to_s }.grep(/^#{message}/)
+          methods = eval("#{receiver}.methods").collect{ |m| m.to_s }.grep(/^#{message}/)
         rescue Exception
           dprint "exception: %s" % $!
+          constants = []
           methods = []
         end
-        methods.grep(/^#{message}/).collect{|e| receiver + "::" + e}
 
       when /^(:[^:.]+)\.([^.]*)$/ # Symbol
         dprint "symbol"
@@ -704,7 +753,9 @@ class VimRubyCompletion
         cv = eval("self.class.constants")
         vartype = get_var_type( receiver )
         dprint "vartype: %s" % vartype
-        if vartype != ''
+
+        invalid_vartype = ['', "gets"]
+        if !invalid_vartype.include?(vartype)
           load_buffer_class( vartype )
 
           begin
@@ -732,7 +783,7 @@ class VimRubyCompletion
             methods.concat m.instance_methods(false)
           }
         end
-        variables += add_rails_columns( "#{vartype}" ) if vartype && vartype.length > 0
+        variables += add_rails_columns( "#{vartype}" ) if vartype && !invalid_vartype.include?(vartype)
 
       when /^\(?\s*[A-Za-z0-9:^@.%\/+*\(\)]+\.\.\.?[A-Za-z0-9:^@.%\/+*\(\)]+\s*\)?\.([^.]*)/
         message = $1
@@ -784,7 +835,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"
@@ -827,5 +877,4 @@ 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:

autoload/rust.vim

@@ -0,0 +1,550 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rust') != -1
+  finish
+endif
+
+" Author: Kevin Ballard
+" Description: Helper functions for Rust commands/mappings
+" Last Modified: May 27, 2014
+" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
+
+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
+
+" Include expression {{{1
+
+function! rust#IncludeExpr(fname) abort
+    " Remove leading 'crate::' to deal with 2018 edition style 'use'
+    " statements
+    let l:fname = substitute(a:fname, '^crate::', '', '')
+
+    " Remove trailing colons arising from lines like
+    "
+    "     use foo::{Bar, Baz};
+    let l:fname = substitute(l:fname, ':\+$', '', '')
+
+    " Replace '::' with '/'
+    let l:fname = substitute(l:fname, '::', '/', 'g')
+
+    " When we have
+    "
+    "    use foo::bar::baz;
+    "
+    " we can't tell whether baz is a module or a function; and we can't tell
+    " which modules correspond to files.
+    "
+    " So we work our way up, trying
+    "
+    "     foo/bar/baz.rs
+    "     foo/bar.rs
+    "     foo.rs
+    while l:fname !=# '.'
+        let l:path = findfile(l:fname)
+        if !empty(l:path)
+            return l:fname
+        endif
+        let l:fname = fnamemodify(l:fname, ':h')
+    endwhile
+    return l:fname
+endfunction
+
+" Jump {{{1
+
+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
+endfunction
+
+function! s:Jump_Back()
+    call search('{', 'b')
+    keepjumps normal! w99[{
+endfunction
+
+function! s:Jump_Forward()
+    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 b:rust_last_rustc_args = l:rustc_args
+    let b:rust_last_args = l: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 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 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)
+endfunction
+
+function! s:Expand(dict, pretty, args)
+    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
+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
+
+    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)
+endfunction
+
+function! s:Emit(dict, type, args)
+    try
+        let output_path = a:dict.tmpdir.'/output'
+
+        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
+endfunction
+
+" Utility functions {{{1
+
+" Invokes func(dict, ...)
+" Where {dict} is a dictionary with the following keys:
+"   'path' - The path to the file
+"   'tmpdir' - The path to a temporary directory that will be deleted when the
+"              function returns.
+"   'istemp' - 1 if the path is a file inside of {dict.tmpdir} or 0 otherwise.
+" If {istemp} is 1 then an additional key is provided:
+"   'tmpdir_relpath' - The {path} relative to the {tmpdir}.
+"
+" {dict.path} may be a path to a file inside of {dict.tmpdir} or it may be the
+" 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)
+
+        " 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
+
+            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
+
+        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
+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
+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))
+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)
+endfunction
+
+" Playpen Support {{{1
+" Parts of gist.vim by Yasuhiro Matsumoto <mattn.jp@gmail.com> reused
+" gist.vim available under the BSD license, available at
+" http://github.com/mattn/gist-vim
+function! s:has_webapi()
+    if !exists("*webapi#http#post")
+        try
+            call webapi#http#post()
+        catch
+        endtry
+    endif
+    return exists("*webapi#http#post")
+endfunction
+
+function! rust#Play(count, line1, line2, ...) abort
+    redraw
+
+    let l:rust_playpen_url = get(g:, 'rust_playpen_url', 'https://play.rust-lang.org/')
+    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
+    endif
+
+    let bufname = bufname('%')
+    if a:count < 1
+        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)
+    endif
+
+    let url = l:rust_playpen_url."?code=".webapi#http#encodeURI(content)
+
+    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(url)
+    let res = webapi#http#post(l:rust_shortener_url.'create.php', payload, {})
+    if res.status[0] ==# '2'
+        let url = res.content
+    endif
+
+    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('\m\C#\[test\]', 'bcW') is 0
+        return ''
+    endif
+
+    " Move to an opening brace of the test function
+    let test_func_line = search('\m\C^\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), '\m\C^\s*fn\s\+\zs\h\w*')
+endfunction
+
+function! rust#Test(all, options) abort
+    let manifest = findfile('Cargo.toml', expand('%:p:h') . ';')
+    if manifest ==# ''
+        return rust#Run(1, '--test ' . a:options)
+    endif
+
+    if exists(':terminal')
+        let cmd = 'terminal '
+    else
+        let cmd = '!'
+        let manifest = shellescape(manifest)
+    endif
+
+    if a:all
+        if a:options ==# ''
+            execute cmd . 'cargo test --manifest-path' manifest
+        else
+            execute cmd . 'cargo test --manifest-path' manifest a:options
+        endif
+        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
+        if a:options ==# ''
+            execute cmd . 'cargo test --manifest-path' manifest func_name
+        else
+            execute cmd . 'cargo test --manifest-path' manifest func_name a:options
+        endif
+        return
+    finally
+        call setpos('.', saved)
+    endtry
+endfunction
+
+" }}}1
+
+" vim: set et sw=4 sts=4 ts=8:

autoload/rust/debugging.vim

@@ -0,0 +1,105 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rust') != -1
+  finish
+endif
+
+" 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
+
+    if exists(":SyntasticInfo")
+        echo "----"
+        echo "Info from Syntastic:"
+        execute "SyntasticInfo"
+    endif
+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:

autoload/rust/delimitmate.vim

@@ -0,0 +1,48 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rust') != -1
+  finish
+endif
+
+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:
+

autoload/rustfmt.vim

@@ -0,0 +1,261 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rust') != -1
+  finish
+endif
+
+" Author: Stephen Sugden <stephen@stephensugden.com>
+"
+" Adapted from https://github.com/fatih/vim-go
+" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
+
+if !exists("g:rustfmt_autosave")
+    let g:rustfmt_autosave = 0
+endif
+
+if !exists("g:rustfmt_command")
+    let g:rustfmt_command = "rustfmt"
+endif
+
+if !exists("g:rustfmt_options")
+    let g:rustfmt_options = ""
+endif
+
+if !exists("g:rustfmt_fail_silently")
+    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 = s:rustfmt_help =~# "--unstable-features"
+
+    " Build a comparable rustfmt version varible out of its `--version` output:
+    silent let l:rustfmt_version_full = system(g:rustfmt_command . " --version")
+    let l:rustfmt_version_list = matchlist(l:rustfmt_version_full,
+        \    '\vrustfmt ([0-9]+[.][0-9]+[.][0-9]+)')
+    if len(l:rustfmt_version_list) < 3
+        let s:rustfmt_version = "0"
+    else
+        let s:rustfmt_version = l:rustfmt_version_list[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 = 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)
+    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, add version range checking
+    " accordingly.
+    let l:unstable_features = s:rustfmt_unstable_features ? '--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()
+    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:DeleteLines(start, end) abort
+    silent! execute a:start . ',' . a:end . 'delete _'
+endfunction
+
+function! s:RunRustfmt(command, tmpname, fail_silently)
+    mkview!
+
+    let l:stderr_tmpname = tempname()
+    call writefile([], l:stderr_tmpname)
+
+    let l:command = a:command . ' 2> ' . l:stderr_tmpname
+
+    if a:tmpname ==# ''
+        " Rustfmt in stdin/stdout mode
+
+        " chdir to the directory of the file
+        let l:has_lcd = haslocaldir()
+        let l:prev_cd = getcwd()
+        execute 'lchdir! '.expand('%:h')
+
+        let l:buffer = getline(1, '$')
+        if exists("*systemlist")
+            silent let out = systemlist(l:command, l:buffer)
+        else
+            silent let out = split(system(l:command,
+                        \ join(l:buffer, "\n")), '\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
+
+    let l:stderr = readfile(l:stderr_tmpname)
+
+    call delete(l:stderr_tmpname)
+
+    let l:open_lwindow = 0
+    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, [])
+            let l:open_lwindow = 1
+        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
+        let l:open_lwindow = 1
+    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
+
+    " Open lwindow after we have changed back to the previous directory
+    if l:open_lwindow == 1
+        lwindow
+    endif
+
+    silent! loadview
+endfunction
+
+function! rustfmt#FormatRange(line1, line2)
+    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()
+    call s:RunRustfmt(s:RustfmtCommand(), '', 0)
+endfunction
+
+function! rustfmt#Cmd()
+    " Mainly for debugging
+    return s:RustfmtCommand()
+endfunction
+
+function! rustfmt#PreWrite()
+    if !filereadable(expand("%@"))
+        return
+    endif
+    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:

autoload/smt2.vim

@@ -0,0 +1,34 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'smt2') != -1
+  finish
+endif
+
+" Invokes the solver on current file
+function! smt2#RunSolver()
+    silent !clear
+    execute "!" . g:smt2_solver_command . " " . bufname("%")
+endfunction
+
+" Puts the solver's output in new split (replaces old split)
+function! smt2#RunSolverAndShowResult()
+    let output = system(g:smt2_solver_command . " " . bufname("%") . " 2>&1")
+
+    " Create split (or reuse existent)
+    if exists("s:outputbufnr") && bufwinnr(s:outputbufnr) > 0
+        execute bufwinnr(s:outputbufnr) . 'wincmd w'
+    else
+        silent! vnew
+        let s:outputbufnr=bufnr('%')
+    endif
+
+    " Clear & (re-)fill contents
+    silent! normal! ggdG
+    setlocal filetype=smt2 buftype=nofile nobuflisted noswapfile
+    call append(0, split(output, '\v\n'))
+    normal! gg
+endfunction
+
+" Requests the solver's version
+function! smt2#PrintSolverVersion()
+    silent !clear
+    execute "!" . g:smt2_solver_command . " " . g:smt2_solver_version_switch
+endfunction

autoload/vifm/edit.vim

@@ -0,0 +1,18 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'vifm') != -1
+  finish
+endif
+
+" common functions for vifm command-line editing buffer filetype plugins
+" Maintainer:  xaizek <xaizek@posteo.net>
+" Last Change: August 18, 2013
+
+" Prepare buffer
+function! vifm#edit#Init()
+    " Mappings for quick leaving the buffer (behavior similar to Command line
+    " buffer in Vim)
+    nnoremap <buffer> <cr> :copy 0 \| wq<cr>
+    imap <buffer> <cr> <esc><cr>
+
+    " Start buffer editing in insert mode
+    startinsert
+endfunction

autoload/vifm/globals.vim

@@ -0,0 +1,35 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'vifm') != -1
+  finish
+endif
+
+" common functions for vifm plugin related to globals
+" Maintainer:  xaizek <xaizek@posteo.net>
+" Last Change: November 03, 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
+
+    if !exists('g:vifm_embed_term')
+        let g:vifm_embed_term = has('gui_running')
+    endif
+endfunction

autoload/vital/_crystal.vim

@@ -0,0 +1,13 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'crystal') != -1
+  finish
+endif
+
+let s:_plugin_name = expand('<sfile>:t:r')
+
+function! vital#{s:_plugin_name}#new() abort
+  return vital#{s:_plugin_name[1:]}#new()
+endfunction
+
+function! vital#{s:_plugin_name}#function(funcname) abort
+  silent! return function(a:funcname)
+endfunction

autoload/vital/_crystal/ColorEcho.vim

@@ -0,0 +1,191 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'crystal') != -1
+  finish
+endif
+
+" ___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
+
+function! s:_is_available() abort
+    if has('gui_running')
+        return 1
+    endif
+
+    if has('win32') || has('win64')
+        return 0
+    endif
+
+    return exists('&t_Co') && (&t_Co == 8 || &t_Co == 256)
+endfunction
+
+function! s:is_available() abort
+    if exists('s:is_available_cache')
+        return s:is_available_cache
+    endif
+    let s:is_available_cache = s:_is_available()
+    return s:is_available_cache
+endfunction
+
+function! s:_define_ansi_highlights() abort
+    hi ansiNone cterm=NONE gui=NONE
+
+    hi ansiBlackBg ctermbg=black guibg=black cterm=none gui=none
+    hi ansiRedBg ctermbg=red guibg=red cterm=none gui=none
+    hi ansiGreenBg ctermbg=green guibg=green cterm=none gui=none
+    hi ansiYellowBg ctermbg=yellow guibg=yellow cterm=none gui=none
+    hi ansiBlueBg ctermbg=blue guibg=blue cterm=none gui=none
+    hi ansiMagentaBg ctermbg=magenta guibg=magenta cterm=none gui=none
+    hi ansiCyanBg ctermbg=cyan guibg=cyan cterm=none gui=none
+    hi ansiWhiteBg ctermbg=white guibg=white cterm=none gui=none
+    hi ansiGrayBg ctermbg=gray guibg=gray cterm=none gui=none
+
+    hi ansiBlackFg ctermfg=black guifg=black cterm=none gui=none
+    hi ansiRedFg ctermfg=red guifg=red cterm=none gui=none
+    hi ansiGreenFg ctermfg=green guifg=green cterm=none gui=none
+    hi ansiYellowFg ctermfg=yellow guifg=yellow cterm=none gui=none
+    hi ansiBlueFg ctermfg=blue guifg=blue cterm=none gui=none
+    hi ansiMagentaFg ctermfg=magenta guifg=magenta cterm=none gui=none
+    hi ansiCyanFg ctermfg=cyan guifg=cyan cterm=none gui=none
+    hi ansiWhiteFg ctermfg=white guifg=white cterm=none gui=none
+    hi ansiGrayFg ctermfg=gray guifg=gray cterm=none gui=none
+
+    hi ansiBoldBlackFg ctermfg=black guifg=black cterm=none gui=none cterm=bold gui=bold
+    hi ansiBoldRedFg ctermfg=red guifg=red cterm=none gui=none cterm=bold gui=bold
+    hi ansiBoldGreenFg ctermfg=green guifg=green cterm=none gui=none cterm=bold gui=bold
+    hi ansiBoldYellowFg ctermfg=yellow guifg=yellow cterm=none gui=none cterm=bold gui=bold
+    hi ansiBoldBlueFg ctermfg=blue guifg=blue cterm=none gui=none cterm=bold gui=bold
+    hi ansiBoldMagentaFg ctermfg=magenta guifg=magenta cterm=none gui=none cterm=bold gui=bold
+    hi ansiBoldCyanFg ctermfg=cyan guifg=cyan cterm=none gui=none cterm=bold gui=bold
+    hi ansiBoldWhiteFg ctermfg=white guifg=white cterm=none gui=none cterm=bold gui=bold
+    hi ansiBoldGrayFg ctermfg=gray guifg=gray cterm=none gui=none cterm=bold gui=bold
+
+    hi ansiUnderlineBlackFg ctermfg=black guifg=black cterm=none gui=none cterm=underline gui=underline
+    hi ansiUnderlineRedFg ctermfg=red guifg=red cterm=none gui=none cterm=underline gui=underline
+    hi ansiUnderlineGreenFg ctermfg=green guifg=green cterm=none gui=none cterm=underline gui=underline
+    hi ansiUnderlineYellowFg ctermfg=yellow guifg=yellow cterm=none gui=none cterm=underline gui=underline
+    hi ansiUnderlineBlueFg ctermfg=blue guifg=blue cterm=none gui=none cterm=underline gui=underline
+    hi ansiUnderlineMagentaFg ctermfg=magenta guifg=magenta cterm=none gui=none cterm=underline gui=underline
+    hi ansiUnderlineCyanFg ctermfg=cyan guifg=cyan cterm=none gui=none cterm=underline gui=underline
+    hi ansiUnderlineWhiteFg ctermfg=white guifg=white cterm=none gui=none cterm=underline gui=underline
+    hi ansiUnderlineGrayFg ctermfg=gray guifg=gray cterm=none gui=none cterm=underline gui=underline
+
+endfunction
+
+let s:echorizer = {
+        \   'value': '',
+        \   'attr': '',
+        \ }
+
+function s:echorizer.eat() abort
+    let matched = match(self.value, '\e\[\d*;\=m')
+    if matched == -1
+        return {}
+    endif
+
+    let matched_end = matchend(self.value, '\e\[\d*;\=m')
+
+    let token = {
+        \   'body': matched == 0 ? '' : self.value[ : matched-1],
+        \   'code': matchstr(self.value[matched : matched_end-1], '\d\+')
+        \ }
+
+    let self.value = self.value[matched_end : ]
+
+    return token
+endfunction
+
+let s:COLORS = {
+    \   0: "None",
+    \   30: "BlackFg",
+    \   31: "RedFg",
+    \   32: "GreenFg",
+    \   33: "YellowFg",
+    \   34: "BlueFg",
+    \   35: "MagentaFg",
+    \   36: "CyanFg",
+    \   37: "WhiteFg",
+    \   40: "BlackBg",
+    \   41: "RedBg",
+    \   42: "GreenBg",
+    \   43: "YellowBg",
+    \   44: "BlueBg",
+    \   45: "MagentaBg",
+    \   46: "CyanBg",
+    \   47: "WhiteBg",
+    \   90: "GrayFg",
+    \ }
+
+function s:echorizer.echo_ansi(code) abort
+    if !has_key(s:COLORS, a:code)
+        return
+    endif
+
+    execute 'echohl' 'ansi' . self.attr . s:COLORS[a:code]
+
+    if a:code == 0
+        let self.attr = ''
+    endif
+endfunction
+
+function s:echorizer.echo() abort
+    echo
+
+    while 1
+        let token = self.eat()
+        if token == {}
+            break
+        endif
+
+        if token.body !=# ''
+            echon token.body
+        endif
+
+        " TODO: Now only one attribute can be specified
+        if token.code == 1
+            let self.attr = 'Bold'
+        elseif token.code == 4
+            let self.attr = 'Underline'
+        elseif token.code ==# ''
+            call self.echo_ansi(0)
+        else
+            call self.echo_ansi(token.code)
+        endif
+    endwhile
+
+    echon self.value
+    echohl None
+    let self.value = ''
+endfunction
+
+function! s:get_echorizer(str) abort
+    let e = deepcopy(s:echorizer)
+    let e.value = a:str
+    return e
+endfunction
+
+function! s:echo(str) abort
+    if !s:is_available()
+        echo substitute(a:str, '\e[.*m', '', 'g')
+        return
+    endif
+
+    if !exists('g:__vital_color_echo_already_highlighted')
+        call s:_define_ansi_highlights()
+        let g:__vital_color_echo_already_highlighted = 1
+    endif
+
+    let echorizer = s:get_echorizer(a:str)
+    call echorizer.echo()
+endfunction
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

autoload/vital/_crystal/Data/List.vim

@@ -0,0 +1,468 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'crystal') != -1
+  finish
+endif
+
+" ___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
+set cpo&vim
+
+function! s:pop(list) abort
+  return remove(a:list, -1)
+endfunction
+
+function! s:push(list, val) abort
+  call add(a:list, a:val)
+  return a:list
+endfunction
+
+function! s:shift(list) abort
+  return remove(a:list, 0)
+endfunction
+
+function! s:unshift(list, val) abort
+  return insert(a:list, a:val)
+endfunction
+
+function! s:cons(x, xs) abort
+  return [a:x] + a:xs
+endfunction
+
+function! s:conj(xs, x) abort
+  return a:xs + [a:x]
+endfunction
+
+" Removes duplicates from a list.
+function! s:uniq(list) abort
+  return s:uniq_by(a:list, 'v:val')
+endfunction
+
+" Removes duplicates from a list.
+function! s:uniq_by(list, f) abort
+  let list = map(copy(a:list), printf('[v:val, %s]', a:f))
+  let i = 0
+  let seen = {}
+  while i < len(list)
+    let key = string(list[i][1])
+    if has_key(seen, key)
+      call remove(list, i)
+    else
+      let seen[key] = 1
+      let i += 1
+    endif
+  endwhile
+  return map(list, 'v:val[0]')
+endfunction
+
+function! s:clear(list) abort
+  if !empty(a:list)
+    unlet! a:list[0 : len(a:list) - 1]
+  endif
+  return a:list
+endfunction
+
+" Concatenates a list of lists.
+" XXX: Should we verify the input?
+function! s:concat(list) abort
+  let memo = []
+  for Value in a:list
+    let memo += Value
+  endfor
+  return memo
+endfunction
+
+" Take each elements from lists to a new list.
+function! s:flatten(list, ...) abort
+  let limit = a:0 > 0 ? a:1 : -1
+  let memo = []
+  if limit == 0
+    return a:list
+  endif
+  let limit -= 1
+  for Value in a:list
+    let memo +=
+          \ type(Value) == type([]) ?
+          \   s:flatten(Value, limit) :
+          \   [Value]
+    unlet! Value
+  endfor
+  return memo
+endfunction
+
+" Sorts a list with expression to compare each two values.
+" a:a and a:b can be used in {expr}.
+function! s:sort(list, expr) abort
+  if type(a:expr) == type(function('function'))
+    return sort(a:list, a:expr)
+  endif
+  let s:expr = a:expr
+  return sort(a:list, 's:_compare')
+endfunction
+
+function! s:_compare(a, b) abort
+  return eval(s:expr)
+endfunction
+
+" Sorts a list using a set of keys generated by mapping the values in the list
+" through the given expr.
+" v:val is used in {expr}
+function! s:sort_by(list, expr) abort
+  let pairs = map(a:list, printf('[v:val, %s]', a:expr))
+  return map(s:sort(pairs,
+  \      'a:a[1] ==# a:b[1] ? 0 : a:a[1] ># a:b[1] ? 1 : -1'), 'v:val[0]')
+endfunction
+
+" Returns a maximum value in {list} through given {expr}.
+" Returns 0 if {list} is empty.
+" v:val is used in {expr}
+function! s:max_by(list, expr) abort
+  if empty(a:list)
+    return 0
+  endif
+  let list = map(copy(a:list), a:expr)
+  return a:list[index(list, max(list))]
+endfunction
+
+" Returns a minimum value in {list} through given {expr}.
+" Returns 0 if {list} is empty.
+" v:val is used in {expr}
+" FIXME: -0x80000000 == 0x80000000
+function! s:min_by(list, expr) abort
+  return s:max_by(a:list, '-(' . a:expr . ')')
+endfunction
+
+" Returns List of character sequence between [a:from, a:to]
+" e.g.: s:char_range('a', 'c') returns ['a', 'b', 'c']
+function! s:char_range(from, to) abort
+  return map(
+  \   range(char2nr(a:from), char2nr(a:to)),
+  \   'nr2char(v:val)'
+  \)
+endfunction
+
+" Returns true if a:list has a:value.
+" Returns false otherwise.
+function! s:has(list, value) abort
+  return index(a:list, a:value) isnot -1
+endfunction
+
+" Returns true if a:list[a:index] exists.
+" Returns false otherwise.
+" NOTE: Returns false when a:index is negative number.
+function! s:has_index(list, index) abort
+  " Return true when negative index?
+  " let index = a:index >= 0 ? a:index : len(a:list) + a:index
+  return 0 <= a:index && a:index < len(a:list)
+endfunction
+
+" similar to Haskell's Data.List.span
+function! s:span(f, xs) abort
+  let border = len(a:xs)
+  for i in range(len(a:xs))
+    if !eval(substitute(a:f, 'v:val', string(a:xs[i]), 'g'))
+      let border = i
+      break
+    endif
+  endfor
+  return border == 0 ? [[], copy(a:xs)] : [a:xs[: border - 1], a:xs[border :]]
+endfunction
+
+" similar to Haskell's Data.List.break
+function! s:break(f, xs) abort
+  return s:span(printf('!(%s)', a:f), a:xs)
+endfunction
+
+" similar to Haskell's Data.List.takeWhile
+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 . ')')]
+endfunction
+
+" similar to Haskell's Prelude.all
+function! s:all(f, xs) abort
+  return !s:any(printf('!(%s)', a:f), a:xs)
+endfunction
+
+" similar to Haskell's Prelude.any
+function! s:any(f, xs) abort
+  return !empty(filter(map(copy(a:xs), a:f), 'v:val'))
+endfunction
+
+" similar to Haskell's Prelude.and
+function! s:and(xs) abort
+  return s:all('v:val', a:xs)
+endfunction
+
+" similar to Haskell's Prelude.or
+function! s:or(xs) abort
+  return s:any('v:val', a:xs)
+endfunction
+
+function! s:map_accum(expr, xs, init) abort
+  let memo = []
+  let init = a:init
+  for x in a:xs
+    let expr = substitute(a:expr, 'v:memo', init, 'g')
+    let expr = substitute(expr, 'v:val', x, 'g')
+    let [tmp, init] = eval(expr)
+    call add(memo, tmp)
+  endfor
+  return memo
+endfunction
+
+" similar to Haskell's Prelude.foldl
+function! s:foldl(f, init, xs) abort
+  let memo = a:init
+  for x in a:xs
+    let expr = substitute(a:f, 'v:val', string(x), 'g')
+    let expr = substitute(expr, 'v:memo', string(memo), 'g')
+    unlet memo
+    let memo = eval(expr)
+  endfor
+  return memo
+endfunction
+
+" similar to Haskell's Prelude.foldl1
+function! s:foldl1(f, xs) abort
+  if len(a:xs) == 0
+    throw 'vital: Data.List: foldl1'
+  endif
+  return s:foldl(a:f, a:xs[0], a:xs[1:])
+endfunction
+
+" similar to Haskell's Prelude.foldr
+function! s:foldr(f, init, xs) abort
+  return s:foldl(a:f, a:init, reverse(copy(a:xs)))
+endfunction
+
+" similar to Haskell's Prelude.fold11
+function! s:foldr1(f, xs) abort
+  if len(a:xs) == 0
+    throw 'vital: Data.List: foldr1'
+  endif
+  return s:foldr(a:f, a:xs[-1], a:xs[0:-2])
+endfunction
+
+" similar to python's zip()
+function! s:zip(...) abort
+  return map(range(min(map(copy(a:000), 'len(v:val)'))), "map(copy(a:000), 'v:val['.v:val.']')")
+endfunction
+
+" similar to zip(), but goes until the longer one.
+function! s:zip_fill(xs, ys, filler) abort
+  if empty(a:xs) && empty(a:ys)
+    return []
+  elseif empty(a:ys)
+    return s:cons([a:xs[0], a:filler], s:zip_fill(a:xs[1 :], [], a:filler))
+  elseif empty(a:xs)
+    return s:cons([a:filler, a:ys[0]], s:zip_fill([], a:ys[1 :], a:filler))
+  else
+    return s:cons([a:xs[0], a:ys[0]], s:zip_fill(a:xs[1 :], a:ys[1: ], a:filler))
+  endif
+endfunction
+
+" Inspired by Ruby's with_index method.
+function! s:with_index(list, ...) abort
+  let base = a:0 > 0 ? a:1 : 0
+  return map(copy(a:list), '[v:val, v:key + base]')
+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 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)
+  let start = a:0 > 0 ? (a:1 < 0 ? len + a:1 : a:1) : 0
+  let default = a:0 > 1 ? a:2 : -1
+  if start >=# len || start < 0
+    return default
+  endif
+  for i in range(start, len - 1)
+    if eval(substitute(a:f, 'v:val', string(a:xs[i]), 'g'))
+      return i
+    endif
+  endfor
+  return default
+endfunction
+
+" Returns the index of the last element which satisfies the given expr.
+function! s:find_last_index(xs, f, ...) abort
+  let len = len(a:xs)
+  let start = a:0 > 0 ? (a:1 < 0 ? len + a:1 : a:1) : len - 1
+  let default = a:0 > 1 ? a:2 : -1
+  if start >=# len || start < 0
+    return default
+  endif
+  for i in range(start, 0, -1)
+    if eval(substitute(a:f, 'v:val', string(a:xs[i]), 'g'))
+      return i
+    endif
+  endfor
+  return default
+endfunction
+
+" Similar to find_index but returns the list of indices satisfying the given expr.
+function! s:find_indices(xs, f, ...) abort
+  let len = len(a:xs)
+  let start = a:0 > 0 ? (a:1 < 0 ? len + a:1 : a:1) : 0
+  let result = []
+  if start >=# len || start < 0
+    return result
+  endif
+  for i in range(start, len - 1)
+    if eval(substitute(a:f, 'v:val', string(a:xs[i]), 'g'))
+      call add(result, i)
+    endif
+  endfor
+  return result
+endfunction
+
+" Return non-zero if a:list1 and a:list2 have any common item(s).
+" Return zero otherwise.
+function! s:has_common_items(list1, list2) abort
+  return !empty(filter(copy(a:list1), 'index(a:list2, v:val) isnot -1'))
+endfunction
+
+function! s:intersect(list1, list2) abort
+  let items = []
+  " for funcref
+  for X in a:list1
+    if index(a:list2, X) != -1 && index(items, X) == -1
+      let items += [X]
+    endif
+  endfor
+  return items
+endfunction
+
+" similar to Ruby's group_by.
+function! s:group_by(xs, f) abort
+  let result = {}
+  let list = map(copy(a:xs), printf('[v:val, %s]', a:f))
+  for x in list
+    let Val = x[0]
+    let key = type(x[1]) !=# type('') ? string(x[1]) : x[1]
+    if has_key(result, key)
+      call add(result[key], Val)
+    else
+      let result[key] = [Val]
+    endif
+    unlet Val
+  endfor
+  return result
+endfunction
+
+function! s:_default_compare(a, b) abort
+  return a:a <# a:b ? -1 : a:a ># a:b ? 1 : 0
+endfunction
+
+function! s:binary_search(list, value, ...) abort
+  let Predicate = a:0 >= 1 ? a:1 : 's:_default_compare'
+  let dic = a:0 >= 2 ? a:2 : {}
+  let start = 0
+  let end = len(a:list) - 1
+
+  while 1
+    if start > end
+      return -1
+    endif
+
+    let middle = (start + end) / 2
+
+    let compared = call(Predicate, [a:value, a:list[middle]], dic)
+
+    if compared < 0
+      let end = middle - 1
+    elseif compared > 0
+      let start = middle + 1
+    else
+      return middle
+    endif
+  endwhile
+endfunction
+
+function! s:product(lists) abort
+  let result = [[]]
+  for pool in a:lists
+    let tmp = []
+    for x in result
+      let tmp += map(copy(pool), 'x + [v:val]')
+    endfor
+    let result = tmp
+  endfor
+  return result
+endfunction
+
+function! s:permutations(list, ...) abort
+  if a:0 > 1
+    throw 'vital: Data.List: too many arguments'
+  endif
+  let r = a:0 == 1 ? a:1 : len(a:list)
+  if r > len(a:list)
+    return []
+  elseif r < 0
+    throw 'vital: Data.List: {r} must be non-negative integer'
+  endif
+  let n = len(a:list)
+  let result = []
+  for indices in s:product(map(range(r), 'range(n)'))
+    if len(s:uniq(indices)) == r
+      call add(result, map(indices, 'a:list[v:val]'))
+    endif
+  endfor
+  return result
+endfunction
+
+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'
+  endif
+  let n = len(a:list)
+  let result = []
+  for indices in s:permutations(range(n), a:r)
+    if s:sort(copy(indices), 'a:a - a:b') == indices
+      call add(result, map(indices, 'a:list[v:val]'))
+    endif
+  endfor
+  return result
+endfunction
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim:set et ts=2 sts=2 sw=2 tw=0:

autoload/vital/_crystal/Data/String.vim

@@ -0,0 +1,631 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'crystal') != -1
+  finish
+endif
+
+" ___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
+set cpo&vim
+
+function! s:_vital_loaded(V) abort
+  let s:V = a:V
+  let s:L = s:V.import('Data.List')
+endfunction
+
+function! s:_vital_depends() abort
+  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.
+" To substitute by pattern, use substitute() instead.
+function! s:replace(str, from, to) abort
+  return s:_replace(a:str, a:from, a:to, 'g')
+endfunction
+
+" Substitute a:from => a:to only once.
+" cf. s:replace()
+function! s:replace_first(str, from, to) abort
+  return s:_replace(a:str, a:from, a:to, '')
+endfunction
+
+" implement of replace() and replace_first()
+function! s:_replace(str, from, to, flags) abort
+  return substitute(a:str, '\V'.escape(a:from, '\'), escape(a:to, '\'), a:flags)
+endfunction
+
+function! s:scan(str, pattern) abort
+  let list = []
+  call substitute(a:str, a:pattern, '\=add(list, submatch(0)) == [] ? "" : ""', 'g')
+  return list
+endfunction
+
+function! s:reverse(str) abort
+  return join(reverse(split(a:str, '.\zs')), '')
+endfunction
+
+function! s:starts_with(str, prefix) abort
+  return stridx(a:str, a:prefix) == 0
+endfunction
+
+function! s:ends_with(str, suffix) abort
+  let idx = strridx(a:str, a:suffix)
+  return 0 <= idx && idx + len(a:suffix) == len(a:str)
+endfunction
+
+function! s:common_head(strs) abort
+  if empty(a:strs)
+    return ''
+  endif
+  let len = len(a:strs)
+  if len == 1
+    return a:strs[0]
+  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 . ']')
+endfunction
+
+" Split to two elements of List. ([left, right])
+" e.g.: s:split3('neocomplcache', 'compl') returns ['neo', 'compl', 'cache']
+function! s:split_leftright(expr, pattern) abort
+  let [left, _, right] = s:split3(a:expr, a:pattern)
+  return [left, right]
+endfunction
+
+function! s:split3(expr, pattern) abort
+  let ERROR = ['', '', '']
+  if a:expr ==# '' || a:pattern ==# ''
+    return ERROR
+  endif
+  let begin = match(a:expr, a:pattern)
+  if begin is -1
+    return ERROR
+  endif
+  let end   = matchend(a:expr, a:pattern)
+  let left  = begin <=# 0 ? '' : a:expr[: begin - 1]
+  let right = a:expr[end :]
+  return [left, a:expr[begin : end-1], right]
+endfunction
+
+" Slices into strings determines the number of substrings.
+" e.g.: s:nsplit("neo compl cache", 2, '\s') returns ['neo', 'compl cache']
+function! s:nsplit(expr, n, ...) abort
+  let pattern = get(a:000, 0, '\s')
+  let keepempty = get(a:000, 1, 1)
+  let ret = []
+  let expr = a:expr
+  if a:n <= 1
+    return [expr]
+  endif
+  while 1
+    let pos = match(expr, pattern)
+    if pos == -1
+      if expr !~ pattern || keepempty
+        call add(ret, expr)
+      endif
+      break
+    elseif pos >= 0
+      let left = pos > 0 ? expr[:pos-1] : ''
+      if pos > 0 || keepempty
+        call add(ret, left)
+      endif
+      let ml = len(matchstr(expr, pattern))
+      if pos == 0 && ml == 0
+        let pos = 1
+      endif
+      let expr = expr[pos+ml :]
+    endif
+    if len(expr) == 0
+      break
+    endif
+    if len(ret) == a:n - 1
+      call add(ret, expr)
+      break
+    endif
+  endwhile
+  return ret
+endfunction
+
+" Returns the number of character in a:str.
+" NOTE: This returns proper value
+" even if a:str contains multibyte character(s).
+" s:strchars(str) {{{
+if exists('*strchars')
+  let s:strchars = function('strchars')
+else
+  function! s:strchars(str) abort
+    return strlen(substitute(copy(a:str), '.', 'x', 'g'))
+  endfunction
+endif "}}}
+
+" Returns the bool of contains any multibyte character in s:str
+function! s:contains_multibyte(str) abort "{{{
+  return strlen(a:str) != s:strchars(a:str)
+endfunction "}}}
+
+" Remove last character from a:str.
+" NOTE: This returns proper value
+" even if a:str contains multibyte character(s).
+function! s:chop(str) abort "{{{
+  return substitute(a:str, '.$', '', '')
+endfunction "}}}
+
+" Remove last \r,\n,\r\n from a:str.
+function! s:chomp(str) abort "{{{
+  return substitute(a:str, '\%(\r\n\|[\r\n]\)$', '', '')
+endfunction "}}}
+
+" wrap() and its internal functions
+" * _split_by_wcswidth_once()
+" * _split_by_wcswidth()
+" * _concat()
+" * wrap()
+"
+" NOTE _concat() is just a copy of Data.List.concat().
+" FIXME don't repeat yourself
+function! s:_split_by_wcswidth_once(body, x) abort
+  let fst = s:strwidthpart(a:body, a:x)
+  let snd = s:strwidthpart_reverse(a:body, s:wcswidth(a:body) - s:wcswidth(fst))
+  return [fst, snd]
+endfunction
+
+function! s:_split_by_wcswidth(body, x) abort
+  let memo = []
+  let body = a:body
+  while s:wcswidth(body) > a:x
+    let [tmp, body] = s:_split_by_wcswidth_once(body, a:x)
+    call add(memo, tmp)
+  endwhile
+  call add(memo, body)
+  return memo
+endfunction
+
+function! s:trim(str) abort
+  return matchstr(a:str,'^\s*\zs.\{-}\ze\s*$')
+endfunction
+
+function! s:trim_start(str) abort
+  return matchstr(a:str,'^\s*\zs.\{-}$')
+endfunction
+
+function! s:trim_end(str) abort
+  return matchstr(a:str,'^.\{-}\ze\s*$')
+endfunction
+
+function! s:wrap(str,...) abort
+  let _columns = a:0 > 0 ? a:1 : &columns
+  return s:L.concat(
+        \ map(split(a:str, '\r\n\|[\r\n]'), 's:_split_by_wcswidth(v:val, _columns - 1)'))
+endfunction
+
+function! s:nr2byte(nr) abort
+  if a:nr < 0x80
+    return nr2char(a:nr)
+  elseif a:nr < 0x800
+    return nr2char(a:nr/64+192).nr2char(a:nr%64+128)
+  else
+    return nr2char(a:nr/4096%16+224).nr2char(a:nr/64%64+128).nr2char(a:nr%64+128)
+  endif
+endfunction
+
+function! s:nr2enc_char(charcode) abort
+  if &encoding ==# 'utf-8'
+    return nr2char(a:charcode)
+  endif
+  let char = s:nr2byte(a:charcode)
+  if strlen(char) > 1
+    let char = strtrans(iconv(char, 'utf-8', &encoding))
+  endif
+  return char
+endfunction
+
+function! s:nr2hex(nr) abort
+  let n = a:nr
+  let r = ''
+  while n
+    let r = '0123456789ABCDEF'[n % 16] . r
+    let n = n / 16
+  endwhile
+  return r
+endfunction
+
+" If a ==# b, returns -1.
+" If a !=# b, returns first index of different character.
+function! s:diffidx(a, b) abort
+  return a:a ==# a:b ? -1 : strlen(s:common_head([a:a, a:b]))
+endfunction
+
+function! s:substitute_last(expr, pat, sub) abort
+  return substitute(a:expr, printf('.*\zs%s', a:pat), a:sub, '')
+endfunction
+
+function! s:dstring(expr) abort
+  let x = substitute(string(a:expr), "^'\\|'$", '', 'g')
+  let x = substitute(x, "''", "'", 'g')
+  return printf('"%s"', escape(x, '"'))
+endfunction
+
+function! s:lines(str) abort
+  return split(a:str, '\r\?\n')
+endfunction
+
+function! s:_pad_with_char(str, left, right, char) abort
+  return repeat(a:char, a:left). a:str. repeat(a:char, a:right)
+endfunction
+
+function! s:pad_left(str, width, ...) abort
+  let char = get(a:, 1, ' ')
+  if strdisplaywidth(char) != 1
+    throw "vital: Data.String: Can't use non-half-width characters for padding."
+  endif
+  let left = max([0, a:width - strdisplaywidth(a:str)])
+  return s:_pad_with_char(a:str, left, 0, char)
+endfunction
+
+function! s:pad_right(str, width, ...) abort
+  let char = get(a:, 1, ' ')
+  if strdisplaywidth(char) != 1
+    throw "vital: Data.String: Can't use non-half-width characters for padding."
+  endif
+  let right = max([0, a:width - strdisplaywidth(a:str)])
+  return s:_pad_with_char(a:str, 0, right, char)
+endfunction
+
+function! s:pad_both_sides(str, width, ...) abort
+  let char = get(a:, 1, ' ')
+  if strdisplaywidth(char) != 1
+    throw "vital: Data.String: Can't use non-half-width characters for padding."
+  endif
+  let space = max([0, a:width - strdisplaywidth(a:str)])
+  let left = space / 2
+  let right = space - left
+  return s:_pad_with_char(a:str, left, right, char)
+endfunction
+
+function! s:pad_between_letters(str, width, ...) abort
+  let char = get(a:, 1, ' ')
+  if strdisplaywidth(char) != 1
+    throw "vital: Data.String: Can't use non-half-width characters for padding."
+  endif
+  let letters = split(a:str, '\zs')
+  let each_width = a:width / len(letters)
+  let str = join(map(letters, 's:pad_both_sides(v:val, each_width, char)'), '')
+  if a:width - strdisplaywidth(str) > 0
+    return char. s:pad_both_sides(str, a:width - 1, char)
+  endif
+  return str
+endfunction
+
+function! s:justify_equal_spacing(str, width, ...) abort
+  let char = get(a:, 1, ' ')
+  if strdisplaywidth(char) != 1
+    throw "vital: Data.String: Can't use non-half-width characters for padding."
+  endif
+  let letters = split(a:str, '\zs')
+  let first_letter = letters[0]
+  " {width w/o the first letter} / {length w/o the first letter}
+  let each_width = (a:width - strdisplaywidth(first_letter)) / (len(letters) - 1)
+  let remainder = (a:width - strdisplaywidth(first_letter)) % (len(letters) - 1)
+  return first_letter. join(s:L.concat([
+\     map(letters[1:remainder], 's:pad_left(v:val, each_width + 1, char)'),
+\     map(letters[remainder + 1:], 's:pad_left(v:val, each_width, char)')
+\   ]), '')
+endfunction
+
+function! s:levenshtein_distance(str1, str2) abort
+  let letters1 = split(a:str1, '\zs')
+  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'')')
+
+  for i1 in range(0, length1)
+    let distances[i1][0] = i1
+  endfor
+  for i2 in range(0, length2)
+    let distances[0][i2] = i2
+  endfor
+
+  for i1 in range(1, length1)
+    for i2 in range(1, length2)
+      let cost = (letters1[i1 - 1] ==# letters2[i2 - 1]) ? 0 : 1
+
+      let distances[i1][i2] = min([
+      \ distances[i1 - 1][i2    ] + 1,
+      \ distances[i1    ][i2 - 1] + 1,
+      \ distances[i1 - 1][i2 - 1] + cost,
+      \])
+    endfor
+  endfor
+
+  return distances[length1][length2]
+endfunction
+
+function! s:padding_by_displaywidth(expr, width, float) abort
+  let padding_char = ' '
+  let n = a:width - strdisplaywidth(a:expr)
+  if n <= 0
+    let n = 0
+  endif
+  if a:float < 0
+    return a:expr . repeat(padding_char, n)
+  elseif 0 < a:float
+    return repeat(padding_char, n) . a:expr
+  else
+    if n % 2 is 0
+      return repeat(padding_char, n / 2) . a:expr . repeat(padding_char, n / 2)
+    else
+      return repeat(padding_char, (n - 1) / 2) . a:expr . repeat(padding_char, (n - 1) / 2) . padding_char
+    endif
+  endif
+endfunction
+
+function! s:split_by_displaywidth(expr, width, float, is_wrap) abort
+  if a:width is 0
+    return ['']
+  endif
+
+  let lines = []
+
+  let cs = split(a:expr, '\zs')
+  let cs_index = 0
+
+  let text = ''
+  while cs_index < len(cs)
+    if cs[cs_index] is# "\n"
+      let text = s:padding_by_displaywidth(text, a:width, a:float)
+      let lines += [text]
+      let text = ''
+    else
+      let w = strdisplaywidth(text . cs[cs_index])
+
+      if w < a:width
+        let text .= cs[cs_index]
+      elseif a:width < w
+        let text = s:padding_by_displaywidth(text, a:width, a:float)
+      else
+        let text .= cs[cs_index]
+      endif
+
+      if a:width <= w
+        let lines += [text]
+        let text = ''
+        if a:is_wrap
+          if a:width < w
+            if a:width < strdisplaywidth(cs[cs_index])
+              while get(cs, cs_index, "\n") isnot# "\n"
+                let cs_index += 1
+              endwhile
+              continue
+            else
+              let text = cs[cs_index]
+            endif
+          endif
+        else
+          while get(cs, cs_index, "\n") isnot# "\n"
+            let cs_index += 1
+          endwhile
+          continue
+        endif
+      endif
+
+    endif
+    let cs_index += 1
+  endwhile
+
+  if !empty(text)
+    let lines += [ s:padding_by_displaywidth(text, a:width, a:float) ]
+  endif
+
+  return lines
+endfunction
+
+function! s:hash(str) abort
+  if exists('*sha256')
+    return sha256(a:str)
+  else
+    " This gives up sha256ing but just adds up char with index.
+    let sum = 0
+    for i in range(len(a:str))
+      let sum += char2nr(a:str[i]) * (i + 1)
+    endfor
+
+    return printf('%x', sum)
+  endif
+endfunction
+
+function! s:truncate(str, width) abort
+  " Original function is from mattn.
+  " 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)
+  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:truncate_skipping(str, max, footer_width, separator) abort
+  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:strwidthpart(str, width) abort
+  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
+  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.
+  let s:wcswidth = function('strwidth')
+else
+  function! s:wcswidth(str) abort
+    if a:str =~# '^[\x00-\x7f]*$'
+      return strlen(a:str)
+    endif
+    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
+
+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:

autoload/vital/_crystal/Process.vim

@@ -0,0 +1,177 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'crystal') != -1
+  finish
+endif
+
+" ___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.
+"
+"
+" FIXME: This module name should be Vital.System ?
+" But the name has been already taken.
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" FIXME: Unfortunately, can't use s:_vital_loaded() for this purpose.
+" Because these variables are used when this script file is loaded.
+let s:is_windows = has('win16') || has('win32') || has('win64') || has('win95')
+let s:is_unix = has('unix')
+" As of 7.4.122, the system()'s 1st argument is converted internally by Vim.
+" Note that Patch 7.4.122 does not convert system()'s 2nd argument and
+" return-value. We must convert them manually.
+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('')
+
+function! s:spawn(expr, ...) abort
+  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
+  return ''
+endfunction
+
+" iconv() wrapper for safety.
+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 result !=# '' ? result : a:expr
+endfunction
+
+" Check vimproc.
+function! s:has_vimproc() abort
+  if !exists('s:exists_vimproc')
+    try
+      call vimproc#version()
+      let s:exists_vimproc = 1
+    catch
+      let s:exists_vimproc = 0
+    endtry
+  endif
+  return s:exists_vimproc
+endfunction
+
+" * {command} [, {input} [, {timeout}]]
+" * {command} [, {dict}]
+"   {dict} = {
+"     use_vimproc: bool,
+"     input: string,
+"     timeout: bool,
+"     background: bool,
+"   }
+function! s:system(str, ...) abort
+  " Process optional arguments at first
+  " because use_vimproc is required later
+  " for a:str argument.
+  let input = ''
+  let use_vimproc = s:has_vimproc()
+  let background = 0
+  let args = []
+  if a:0 ==# 1
+    " {command} [, {dict}]
+    " a:1 = {dict}
+    if type(a:1) is s:TYPE_DICT
+      if has_key(a:1, 'use_vimproc')
+        let use_vimproc = a:1.use_vimproc
+      endif
+      if has_key(a:1, 'input')
+        let args += [s:iconv(a:1.input, &encoding, 'char')]
+      endif
+      if use_vimproc && has_key(a:1, 'timeout')
+        " ignores timeout unless you have vimproc.
+        let args += [a:1.timeout]
+      endif
+      if has_key(a:1, 'background')
+        let background = a:1.background
+      endif
+    elseif type(a:1) is s:TYPE_STRING
+      let args += [s:iconv(a:1, &encoding, 'char')]
+    else
+      throw 'vital: Process: invalid argument (value type:' . type(a:1) . ')'
+    endif
+  elseif a:0 >= 2
+    " {command} [, {input} [, {timeout}]]
+    " a:000 = [{input} [, {timeout}]]
+    let [input; rest] = a:000
+    let input   = s:iconv(input, &encoding, 'char')
+    let args += [input] + rest
+  endif
+
+  " Process a:str argument.
+  if type(a:str) is s:TYPE_LIST
+    let expr = use_vimproc ? '"''" . v:val . "''"' : 's:shellescape(v:val)'
+    let command = join(map(copy(a:str), expr), ' ')
+  elseif type(a:str) is s:TYPE_STRING
+    let command = a:str
+  else
+    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
+
+  let funcname = use_vimproc ? 'vimproc#system' : 'system'
+  let output = call(funcname, args)
+  let output = s:iconv(output, 'char', &encoding)
+  return output
+endfunction
+
+function! s:get_last_status() abort
+  return s:has_vimproc() ?
+        \ vimproc#get_last_status() : v:shell_error
+endfunction
+
+if s:is_windows
+  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
+    return call('shellescape', a:000)
+  endfunction
+endif
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim:set et ts=2 sts=2 sw=2 tw=0:

autoload/vital/_crystal/Web/JSON.vim

@@ -0,0 +1,182 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'crystal') != -1
+  finish
+endif
+
+" ___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
+
+function! s:_true() abort
+  return 1
+endfunction
+
+function! s:_false() abort
+  return 0
+endfunction
+
+function! s:_null() abort
+  return 0
+endfunction
+
+function! s:_resolve(val, prefix) abort
+  let t = type(a:val)
+  if t == type('')
+    let m = matchlist(a:val, '^' . a:prefix . '\(null\|true\|false\)$')
+    if !empty(m)
+      return s:const[m[1]]
+    endif
+  elseif t == type([]) || t == type({})
+    return map(a:val, 's:_resolve(v:val, a:prefix)')
+  endif
+  return a:val
+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
+
+function! s:_vital_loaded(V) abort
+  let s:V = a:V
+  let s:string = s:V.import('Data.String')
+endfunction
+
+function! s:_vital_depends() abort
+  return ['Data.String']
+endfunction
+
+" @vimlint(EVL102, 1, l:null)
+" @vimlint(EVL102, 1, l:true)
+" @vimlint(EVL102, 1, l:false)
+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 = 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')
+  if settings.use_token
+    let prefix = '__Web.JSON__'
+    while stridx(json, prefix) != -1
+      let prefix .= '_'
+    endwhile
+    let [null,true,false] = map(['null','true','false'], 'prefix . v:val')
+    sandbox return s:_resolve(eval(json), prefix)
+  else
+    let [null,true,false] = [s:const.null(),s:const.true(),s:const.false()]
+    sandbox return eval(json)
+  endif
+endfunction
+" @vimlint(EVL102, 0, l:null)
+" @vimlint(EVL102, 0, l:true)
+" @vimlint(EVL102, 0, l:false)
+
+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
+    let json = '"' . escape(a:val, '\"') . '"'
+    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')
+  elseif type(a:val) == 2
+    if s:const.true == a:val
+      return 'true'
+    elseif s:const.false == a:val
+      return 'false'
+    elseif s:const.null == a:val
+      return 'null'
+    else
+      " backward compatibility
+      return string(a:val)
+    endif
+  elseif type(a:val) == 3
+    return s:_encode_list(a:val, settings)
+  elseif type(a:val) == 4
+    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
+
+" vim:set et ts=2 sts=2 sw=2 tw=0:

autoload/vital/crystal.vim

@@ -0,0 +1,332 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'crystal') != -1
+  finish
+endif
+
+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

autoload/vital/crystal.vital

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

autoload/xml/aria.vim

@@ -1,31 +1,241 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'html5') != -1
+  finish
+endif
+
 " Vim completion for WAI-ARIA data file
 " Language:       HTML + WAI-ARIA
 " Maintainer:     othree <othree@gmail.com>
-" Last Change:    2010 Sep 09
+" Last Change:    2017 Mar 07
 
 " WAI_ARIA: {{{
-" Ref: http://www.w3.org/TR/wai-aria/
-" Version: Draft 15 December 2009
+" Ref: https://www.w3.org/TR/wai-aria-1.1/
+" Version: W3C Candidate Recommendation 27 October 2016
 
 let abstract_role = {}
 let role_attributes = {}
 let default_role = {}
 
-" Ref: http://www.w3.org/TR/wai-aria/roles
-" Version: Draft 15 December 2009
-let widget_role = ['alert', 'alertdialog', 'button', 'checkbox', 'combobox', 'dialog', 'gridcell', 'link', 'log', 'marquee', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'slider', 'spinbutton', 'status', 'tab', 'tabpanel', 'textbox', 'timer', 'tooltip', 'treeitem', 'combobox', 'grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'tablist', 'tree', 'treegrid']
-let document_structure = ['article', 'columnheader', 'definition', 'directory', 'document', 'group', 'heading', 'img', 'list', 'listitem', 'math', 'note', 'presentation', 'region', 'row', 'rowheader', 'separator']
-let landmark_role = ['application', 'banner', 'complementary', 'contentinfo', 'form', 'main', 'navigation', 'search']
+" Ref: https://www.w3.org/TR/wai-aria-1.1/#roles_categorization
+" Version: W3C Candidate Recommendation 27 October 2016
+let widget_role = [
+    \ 'alert',
+    \ 'alertdialog',
+    \ 'button',
+    \ 'checkbox',
+    \ 'combobox',
+    \ 'dialog',
+    \ 'gridcell',
+    \ 'link',
+    \ 'log',
+    \ 'marquee',
+    \ 'menuitem',
+    \ 'menuitemcheckbox',
+    \ 'menuitemradio',
+    \ 'option',
+    \ 'progressbar',
+    \ 'radio',
+    \ 'radiogroup',
+    \ 'scrollbar',
+    \ 'searchbox',
+    \ 'slider',
+    \ 'spinbutton',
+    \ 'status',
+    \ 'switch',
+    \ 'tab',
+    \ 'tabpanel',
+    \ 'textbox',
+    \ 'timer',
+    \ 'tooltip',
+    \ 'treeitem',
+    \ 'combobox',
+    \ 'grid',
+    \ 'listbox',
+    \ 'menu',
+    \ 'menubar',
+    \ 'radiogroup',
+    \ 'tablist',
+    \ 'tree',
+    \ 'treegrid'
+\ ]
+
+let document_structure = [
+    \ 'article',
+    \ 'cell',
+    \ 'columnheader',
+    \ 'definition',
+    \ 'directory',
+    \ 'document',
+    \ 'feed',
+    \ 'figure',
+    \ 'group',
+    \ 'heading',
+    \ 'img',
+    \ 'list',
+    \ 'listitem',
+    \ 'math',
+    \ 'none',
+    \ 'note',
+    \ 'presentation',
+    \ 'region',
+    \ 'row',
+    \ 'rowheader',
+    \ 'separator',
+    \ 'table',
+    \ 'term'
+\ ]
+
+let landmark_role = [
+    \ 'application',
+    \ 'banner',
+    \ 'complementary',
+    \ 'contentinfo',
+    \ 'form',
+    \ 'main',
+    \ 'navigation',
+    \ 'search'
+\ ]
+
+" Ref: https://www.w3.org/TR/dpub-aria-1.0/
+" Version: W3C Recommendation 14 December 2017
+let dpub_role = [
+    \ '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)
 
-" http://www.w3.org/TR/wai-aria/states_and_properties#state_prop_taxonomy
-"let global_states_and_properties = {'aria-atomic': ['true', 'false'], 'aria-busy': ['true', 'false'], 'aria-controls': [], 'aria-describedby': [], 'aria-disabled': ['true', 'false'], 'aria-dropeffect': ['copy', 'move', 'link', 'execute', 'popup', 'none'], 'aria-flowto': [], 'aria-grabbed': ['true', 'false', 'undefined'], 'aria-haspopup': ['true', 'false'], 'aria-hidden': ['true', 'false'], 'aria-invalid': ['grammar', 'spelling', 'true', 'false'], 'aria-label': [], 'aria-labelledby': [], 'aria-live': ['off', 'polite', 'assertive'], 'aria-owns': [], 'aria-relevant': ['additions', 'removals', 'text', 'all']}
-let widget_attributes = {'aria-autocomplete': ['inline', 'list', 'both', 'none'], 'aria-checked': ['true', 'false', 'mixed', 'undefined'], 'aria-disabled': ['true', 'false'], 'aria-expanded': ['true', 'false', 'undefined'], 'aria-haspopup': ['true', 'false'], 'aria-hidden': ['true', 'false'], 'aria-invalid': ['grammar', 'spelling', 'true', 'false'], 'aria-label': [], 'aria-level': [], 'aria-multiline': ['true', 'false'], 'aria-multiselectable': ['true', 'false'], 'aria-orientation': ['horizontal', 'vertical'], 'aria-pressed': ['true', 'false', 'mixed', 'undefined'], 'aria-readonly': ['true', 'false'], 'aria-required': ['true', 'false'], 'aria-selected': ['true', 'false', 'undefined'], 'aria-sort': ['ascending', 'descending', 'none', 'other'], 'aria-valuemax': [], 'aria-valuemin': [], 'aria-valuenow': [], 'aria-valuetext': []}
-let live_region_attributes = {'aria-atomic': ['true', 'false'], 'aria-busy': ['true', 'false'], 'aria-live': ['off', 'polite', 'assertive'], 'aria-relevant': ['additions', 'removals', 'text', 'all', 'additions text']}
-let drag_and_drop_attributes = {'aria-dropeffect': ['copy', 'move', 'link', 'execute', 'popup', 'none'], 'aria-grabbed': ['true', 'false', 'undefined']}
-let relationship_attributes = {'aria-activedescendant': [], 'aria-controls': [], 'aria-describedby': [], 'aria-flowto': [], 'aria-labelledby': [], 'aria-owns': [], 'aria-posinset': [], 'aria-setsize': []}
-let aria_attributes = widget_attributes
+" https://www.w3.org/TR/wai-aria-1.1/#states_and_properties
+let global_states_and_properties = {
+    \ 'aria-atomic': ['true', 'false'],
+    \ 'aria-busy': ['true', 'false'],
+    \ 'aria-controls': [],
+    \ 'aria-current': [],
+    \ 'aria-describedby': [],
+    \ 'aria-disabled': ['true', 'false'],
+    \ 'aria-dropeffect': ['copy', 'move', 'link', 'execute', 'popup', 'none'],
+    \ 'aria-errormessage': [],
+    \ 'aria-flowto': [],
+    \ 'aria-grabbed': ['true', 'false', 'undefined'],
+    \ 'aria-haspopup': ['true', 'false'],
+    \ 'aria-hidden': ['true', 'false'],
+    \ 'aria-invalid': ['grammar', 'spelling', 'true', 'false'],
+    \ 'aria-keyshortcuts': [],
+    \ 'aria-label': [],
+    \ 'aria-labelledby': [],
+    \ 'aria-live': ['off', 'polite', 'assertive'],
+    \ 'aria-owns': [],
+    \ 'aria-relevant': ['additions', 'removals', 'text', 'all'],
+    \ 'aria-roledescription': [],
+\ }
+
+let widget_attributes = {
+    \ 'aria-autocomplete': ['inline', 'list', 'both', 'none'],
+    \ 'aria-checked': ['true', 'false', 'mixed', 'undefined'],
+    \ 'aria-disabled': ['true', 'false'],
+    \ 'aria-errormessage': [],
+    \ 'aria-expanded': ['true', 'false', 'undefined'],
+    \ 'aria-haspopup': ['true', 'false'],
+    \ 'aria-hidden': ['true', 'false'],
+    \ 'aria-invalid': ['grammar', 'spelling', 'true', 'false'],
+    \ 'aria-label': [],
+    \ 'aria-level': [],
+    \ 'aria-modal': ['true', 'false'],
+    \ 'aria-multiline': ['true', 'false'],
+    \ 'aria-multiselectable': ['true', 'false'],
+    \ 'aria-orientation': ['horizontal', 'vertical'],
+    \ 'aria-placeholder': [],
+    \ 'aria-pressed': ['true', 'false', 'mixed', 'undefined'],
+    \ 'aria-readonly': ['true', 'false'],
+    \ 'aria-required': ['true', 'false'],
+    \ 'aria-selected': ['true', 'false', 'undefined'],
+    \ 'aria-sort': ['ascending', 'descending', 'none', 'other'],
+    \ 'aria-valuemax': [],
+    \ 'aria-valuemin': [],
+    \ 'aria-valuenow': [],
+    \ 'aria-valuetext': []
+\ }
+
+let live_region_attributes = {
+    \ 'aria-atomic': ['true', 'false'],
+    \ 'aria-busy': ['true', 'false'],
+    \ 'aria-live': ['off', 'polite', 'assertive'],
+    \ 'aria-relevant': ['additions', 'removals', 'text', 'all', 'additions text']
+\ }
+
+let drag_and_drop_attributes = {
+    \ 'aria-dropeffect': ['copy', 'move', 'link', 'execute', 'popup', 'none'],
+    \ 'aria-grabbed': ['true', 'false', 'undefined']
+\ }
+
+let relationship_attributes = {
+    \ 'aria-activedescendant': [],
+    \ 'aria-colcount': [],
+    \ 'aria-colindex': [],
+    \ 'aria-colspan': [],
+    \ 'aria-controls': [],
+    \ 'aria-describedby': [],
+    \ 'aria-details': [],
+    \ 'aria-errormessage': [],
+    \ 'aria-flowto': [],
+    \ 'aria-labelledby': [],
+    \ 'aria-owns': [],
+    \ 'aria-posinset': [],
+    \ 'aria-rowcount': [],
+    \ 'aria-rowindex': [],
+    \ 'aria-rowspan': [],
+    \ 'aria-setsize': []
+\ }
+
+let aria_attributes = global_states_and_properties
+let aria_attributes = extend(aria_attributes, widget_attributes)
 let aria_attributes = extend(aria_attributes, live_region_attributes)
 let aria_attributes = extend(aria_attributes, drag_and_drop_attributes)
 let aria_attributes = extend(aria_attributes, relationship_attributes)
@@ -80,6 +290,8 @@ let role_attributes['status'] = abstract_role['composite'] + role_attributes['re
 let role_attributes['tab'] = abstract_role['sectionhead'] + abstract_role['widget'] + ['aria-selected']
 let role_attributes['tabpanel'] = role_attributes['region']
 let role_attributes['textbox'] = abstract_role['input'] + ['aria-autocomplete', 'aria-multiline', 'aria-readonly', 'aria-required']
+let role_attributes['searchbox'] = role_attributes['textbox']
+let role_attributes['switch'] = role_attributes['checkbox']
 let role_attributes['timer'] = role_attributes['status'] 
 let role_attributes['tooltip'] = abstract_role['section'] 
 let role_attributes['treeitem'] = role_attributes['listitem'] + role_attributes['option']
@@ -97,16 +309,22 @@ let role_attributes['treegrid'] = role_attributes['grid'] + role_attributes['tre
 let role_attributes['document'] = abstract_role['structure'] + ['aria-expanded'] 
 
 let role_attributes['article'] = role_attributes['document'] + role_attributes['region'] 
+let role_attributes['cell'] = abstract_role['section'] + ['aria-colindex', 'aria-colspan', 'aria-rowindex', 'aria-rowspan']
 let role_attributes['columnheader'] = role_attributes['gridcell'] + abstract_role['sectionhead'] + ['aria-sort']
 let role_attributes['definition'] = abstract_role['section'] 
+let role_attributes['feed'] = role_attributes['list']
+let role_attributes['figure'] = abstract_role['section'] 
 let role_attributes['heading'] = abstract_role['sectionhead'] + ['aria-level'] 
 let role_attributes['img'] = abstract_role['section'] 
 let role_attributes['math'] = abstract_role['section'] 
 let role_attributes['note'] = abstract_role['section'] 
 let role_attributes['presentation'] = abstract_role['structure']
+let role_attributes['none'] = role_attributes['presentation']
 let role_attributes['row'] = role_attributes['group'] + ['aria-level', 'aria-selected']
 let role_attributes['rowheader'] = role_attributes['gridcell'] + abstract_role['sectionhead']
 let role_attributes['separator'] = abstract_role['structure'] + ['aria-expanded'] 
+let role_attributes['table'] = abstract_role['section'] + ['aria-colcount', 'aria-rowcount']
+let role_attributes['term'] = abstract_role['section']
 
 " Landmark Roles
 let role_attributes['application'] = abstract_role['landmark'] 
@@ -122,19 +340,30 @@ let role_attributes['search'] = abstract_role['landmark']
 let aria_attributes_value = {
     \ 'aria-autocomplete': ['ID', ''],
     \ 'aria-checked': ['Token', ''],
+    \ 'aria-colcount': ['Number', ''],
+    \ 'aria-colindex': ['Number', ''],
+    \ 'aria-colspan': ['Number', ''],
     \ 'aria-disabled': ['true/false', ''],
+    \ 'aria-errormessage': ['ID', ''],
     \ 'aria-expanded': ['Token', ''],
-    \ 'aria-haspopup': ['true/false', ''],
+    \ 'aria-haspopup': ['Token', ''],
     \ 'aria-hidden': ['true/false', ''],
     \ 'aria-invalid': ['Token', ''],
+    \ 'aria-keyshortcuts': ['String', ''],
     \ 'aria-label': ['String', ''],
     \ 'aria-level': ['Int', ''],
+    \ 'aria-modal': ['true/false', ''],
     \ 'aria-multiline': ['true/false', ''],
     \ 'aria-multiselectable': ['true/false', ''],
     \ 'aria-orientation': ['Token', ''],
+    \ 'aria-placeholder': ['String', ''],
     \ 'aria-pressed': ['Token', ''],
     \ 'aria-readonly': ['true/false', ''],
     \ 'aria-required': ['true/false', ''],
+    \ 'aria-roledescription': ['String', ''],
+    \ 'aria-rowcount': ['Number', ''],
+    \ 'aria-rowindex': ['Number', ''],
+    \ 'aria-rowspan': ['Number', ''],
     \ 'aria-selected': ['Token', ''],
     \ 'aria-sort': ['Token', ''],
     \ 'aria-valuemax': ['Number', ''],

autoload/xml/html5.vim

@@ -1,7 +1,11 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'html5') != -1
+  finish
+endif
+
 " Vim completion for HTML5 data file
-" Language:       HTML5
-" Maintainer:     othree <othree@gmail.com>
-" Last Change:    2011 Apr 9
+" Language:	    HTML (version 5.1 Draft 2016 Jan 13)
+" Maintainer:   Kao, Wei-Ko(othree) ( othree AT gmail DOT com )
+" Last Change:  2016 Jan 20
 
 
 " Lang Tag: {{{
@@ -60,6 +64,8 @@ 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', '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': []}
 let xml_attributes = {'xml:lang': lang_tag, 'xml:space': ['preserve'], 'xml:base': [], 'xmlns': ['http://www.w3.org/1999/xhtml', 'http://www.w3.org/1998/Math/MathML', 'http://www.w3.org/2000/svg', 'http://www.w3.org/1999/xlink']}
@@ -76,9 +82,13 @@ let attributes_value = {
     \ 'accept-charset': ['Charset', ''],
     \ 'accesskey': ['Character', ''],
     \ 'action': ['URL', ''],
+    \ 'allowfullscreen': ['Bool', ''],
+    \ 'allowpaymentrequest': ['Bool', ''],
+    \ 'allowpresentation': ['Bool', ''],
+    \ 'allowusermedia': ['Bool', ''],
     \ 'alt': ['Text', ''],
     \ 'async': ['Bool', ''],
-    \ 'autocomplete': ['on/off', ''],
+    \ 'autocomplete': ['*Token', ''],
     \ 'autofocus': ['Bool', ''],
     \ 'autoplay': ['Bool', ''],
     \ 'border': ['1', ''],
@@ -138,6 +148,7 @@ let attributes_value = {
     \ 'optimum': ['Number', ''],
     \ 'pattern': ['Pattern', ''],
     \ 'placeholder': ['Text', ''],
+    \ 'playsinline': ['Bool', ''],
     \ 'poster': ['URL', ''],
     \ 'preload': ['Token', ''],
     \ 'pubdate': ['Bool', ''],
@@ -182,7 +193,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': []}
@@ -205,6 +216,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', ''],
@@ -311,33 +324,61 @@ if !exists('g:html5_aria_attributes_complete')
     let g:html5_aria_attributes_complete = 1
 endif
 if g:html5_aria_attributes_complete == 1
-    " Ref: http://www.w3.org/TR/wai-aria/roles
-    " Version: Draft 15 December 2009
-    let widget_role = ['alert', 'alertdialog', 'button', 'checkbox', 'combobox', 'dialog', 'gridcell', 'link', 'log', 'marquee', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'slider', 'spinbutton', 'status', 'tab', 'tabpanel', 'textbox', 'timer', 'tooltip', 'treeitem', 'combobox', 'grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'tablist', 'tree', 'treegrid']
-    let document_structure = ['article', 'columnheader', 'definition', 'directory', 'document', 'group', 'heading', 'img', 'list', 'listitem', 'math', 'note', 'presentation', 'region', 'row', 'rowheader', 'separator']
+    " Ref: https://www.w3.org/TR/wai-aria-1.1/#role_definitions
+    " Version: W3C Candidate Recommendation 27 October 2016
+    let widget_role = ['alert', 'alertdialog', 'button', 'checkbox', 'combobox', 'dialog', 'gridcell', 'link', 'log', 'marquee', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'searchbox', 'slider', 'spinbutton', 'status', 'switch', 'tab', 'tabpanel', 'textbox', 'timer', 'tooltip', 'treeitem', 'combobox', 'grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'tablist', 'tree', 'treegrid']
+    let document_structure = ['article', 'cell', 'columnheader', 'definition', 'directory', 'document', 'feed', 'figure', 'group', 'heading', 'img', 'list', 'listitem', 'math', 'none', 'note', 'presentation', 'region', 'row', 'rowheader', 'separator', 'table', 'term']
     let landmark_role = ['application', 'banner', 'complementary', 'contentinfo', 'form', 'main', 'navigation', 'search']
+    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']
     let role = extend(widget_role, document_structure)
     let role = extend(role, landmark_role)
+    let role = extend(role, dpub_role)
     let global_attributes = extend(global_attributes, {'role': role})
 endif
 " }}}
 
 " Ref: http://dev.w3.org/html5/markup/
 " Version: Draft 05 April 2011
-let phrasing_elements = ['a', 'em', 'strong', 'small', 'mark', 'abbr', 'dfn', 'i', 'b', 'u', 'code', 'var', 'samp', 'kbd', 'sup', 'sub', 'q', 'cite', 'span', 'bdo', 'bdi', 'br', 'wbr', 'ins', 'del', 'img', 'embed', 'object', 'iframe', 'map', 'area', 'script', 'noscript', 'ruby', 'video', 'audio', 'input', 'textarea', 'select', 'button', 'label', 'output', 'datalist', 'keygen', 'progress', 'command', 'canvas', 'time', 'meter', 'data', 'content', 'shadow']
+let phrasing_elements = ['a', 'em', 'strong', 'small', 'mark', 'abbr', 'dfn', 'i', 'b', 'u', 'code', 'var', 'samp', 'kbd', 'sup', 'sub', 'q', 'cite', 'span', 'bdo', 'bdi', 'br', 'wbr', 'ins', 'del', 'img', 'picture', 'embed', 'object', 'iframe', 'map', 'area', 'script', 'noscript', 'ruby', 'video', 'audio', 'input', 'textarea', 'select', 'button', 'label', 'output', 'datalist', 'keygen', 'progress', 'command', 'canvas', 'time', 'meter', 'data', 'content', 'shadow']
 
 let metadata_elements = ['link', 'style', 'meta', 'script', 'noscript', 'command']
 
 let flow_elements = phrasing_elements + ['p', 'hr', 'pre', 'ul', 'ol', 'dl', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hgroup', 'address', 'blockquote', 'ins', 'del', 'element', 'object', 'main', 'map', 'noscript', 'section', 'nav', 'article', 'aside', 'header', 'footer', 'video', 'audio', 'figure', 'table', 'template', 'form', 'fieldset', 'menu', 'canvas', 'details']
 
-" http://dev.w3.org/html5/spec/Overview.html#linkTypes
-let linktypes = ['alternate', 'author', 'bookmark', 'external', 'help', 'icon', 'license', 'next', 'nofollow', 'noreferrer', 'pingback', 'prefetch', 'prev', 'search', 'stylesheet', 'sidebar', 'tag']
+" https://html.spec.whatwg.org/#linkTypes
+let linktypes = ['alternate', 'author', 'bookmark', 'dns-prefetch', 'external', 'help', 'icon', 'license', 'next', 'nofollow', 'noreferrer', 'noopener', 'pingback', 'preconnect', 'prefetch', 'preload', 'prerender', 'prev', 'search', 'stylesheet', 'tag']
+" https://w3c.github.io/manifest/
+let linkreltypes = linktypes
+let linkreltypes = linkreltypes + ['manifest']
 " http://googlewebmastercentral.blogspot.com/2009/02/specify-your-canonical.html
-let linkreltypes = linktypes + ['canonical', 'import']
+" http://www.ysearchblog.com/2009/02/12/fighting-duplication-adding-more-arrows-to-your-quiver/
+" http://blogs.bing.com/webmaster/2009/02/12/partnering-to-help-solve-duplicate-content-issues
+let linkreltypes = linkreltypes + ['canonical']
+" http://w3c.github.io/webcomponents/spec/imports/
+let linkreltypes = linkreltypes + ['import']
+" https://www.w3.org/TR/webmention/#sender-discovers-receiver-webmention-endpoint
+let linkreltypes = linkreltypes + ['webmention']
+" http://www.opensearch.org/Specifications/OpenSearch/1.1#Autodiscovery_in_HTML.2FXHTML
+let linkreltypes = linkreltypes + ['search']
+" http://microformats.org/wiki/rel-sitemap
+let linkreltypes = linkreltypes + ['sitemap']
+" https://www.ampproject.org/docs/get_started/create/prepare_for_discovery
+let linkreltypes = linkreltypes + ['amphtml']
+" https://developer.apple.com/library/content/documentation/AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/ConfiguringWebApplications.html
+let linkreltypes = linkreltypes + ['apple-touch-icon', 'apple-touch-icon-precomposed', 'apple-touch-startup-image']
+" https://developer.chrome.com/webstore/inline_installation
+let linkreltypes = linkreltypes + ['chrome-webstore-item']
+" http://pubsubhubbub.github.io/PubSubHubbub/pubsubhubbub-core-0.4.html#rfc.section.4
+let linkreltypes = linkreltypes + ['hub']
+" https://golem.ph.utexas.edu/~distler/blog/archives/000320.html
+let linkreltypes = linkreltypes + ['pgpkey']
 
 " a and button are special elements for interactive, some element can't be its descendent
 let abutton_dec = 'details\\|embed\\|iframe\\|keygen\\|label\\|menu\\|select\\|textarea'
 
+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 = {
@@ -345,7 +386,7 @@ let g:xmldata_html5 = {
 \ 'vimxmlroot': ['html', 'head', 'body'] + flow_elements, 
 \ 'a': [
     \ filter(copy(flow_elements), "!(v:val =~ '". abutton_dec ."')"),
-    \ extend(copy(global_attributes), {'name': [], 'href': [], 'target': [], 'rel': linktypes, 'hreflang': lang_tag, 'media': [], 'type': []}) 
+    \ extend(copy(global_attributes), {'name': [], 'href': [], 'target': [], 'rel': linktypes, 'hreflang': lang_tag, 'media': [], 'type': [], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url']}) 
 \ ],
 \ 'abbr': [
     \ phrasing_elements,
@@ -357,7 +398,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': []})
+    \ 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'],
@@ -455,6 +496,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
@@ -493,7 +538,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'form': [
     \ flow_elements,
-    \ extend(copy(global_attributes), {'name': [], 'action': [], 'enctype': ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'], 'method': ['get', 'post', 'put', 'delete'], 'target': [], 'novalidate': ['novalidate', ''], 'accept-charset': charset, 'autocomplete': ['on', 'off']})
+    \ extend(copy(global_attributes), {'name': [], 'action': [], 'enctype': ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'], 'method': ['get', 'post', 'put', 'delete'], 'target': [], 'novalidate': ['novalidate', ''], 'accept-charset': charset, 'autocomplete': autofill_tokens})
 \ ],
 \ 'h1': [
     \ phrasing_elements,
@@ -545,15 +590,15 @@ let g:xmldata_html5 = {
 \ ],
 \ 'iframe': [
     \ [],
-    \ extend(copy(global_attributes), {'src': [], 'name': [], 'width': [], 'height': [], 'sandbox': ['allow-same-origin', 'allow-forms', 'allow-scripts'], 'seamless': ['seamless', '']})
+    \ 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', '']})
+    \ extend(copy(global_attributes), {'src': [], 'alt': [], 'height': [], 'width': [], 'decoding': ['async', 'sync', 'auto'], 'usemap': [], 'ismap': ['ismap', ''], 'referrerpolicy': referrerpolicy, 'crossorigin': ['anonymous', 'use-credentials']})
 \ ],
 \ 'input': [
     \ [],
-    \ extend(copy(global_attributes), {'type': ['text', 'password', 'checkbox', 'radio', 'button', 'submit', 'reset', 'file', 'hidden', 'image', 'datetime', 'datetime-local', 'date', 'month', 'time', 'week', 'number', 'range', 'email', 'url', 'search', 'tel', 'coloe'], 'name': [], 'disabled': ['disabled', ''], 'form': [], 'maxlength': [], 'readonly': ['readonly', ''], 'size': [], 'value': [], 'autocomplete': ['on', 'off'], 'autofocus': ['autofocus', ''], 'list': [], 'pattern': [], 'required': ['required', ''], 'placeholder': [], 'checked': ['checked'], 'accept': [], 'multiple': ['multiple', ''], 'alt': [], 'src': [], 'height': [], 'width': [], 'min': [], 'max': [], 'step': [], 'formenctype': ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'], 'formmethod': ['get', 'post', 'put', 'delete'], 'formtarget': [], 'formnovalidate': ['formnovalidate', '']})
+    \ extend(copy(global_attributes), {'type': ['text', 'password', 'checkbox', 'radio', 'button', 'submit', 'reset', 'file', 'hidden', 'image', 'datetime-local', 'date', 'month', 'time', 'week', 'number', 'range', 'email', 'url', 'search', 'tel', 'color'], 'name': [], 'disabled': ['disabled', ''], 'form': [], 'maxlength': [], 'readonly': ['readonly', ''], 'size': [], 'value': [], 'autocomplete': autofill_tokens, 'autofocus': ['autofocus', ''], 'list': [], 'pattern': [], 'required': ['required', ''], 'placeholder': [], 'checked': ['checked'], 'accept': [], 'multiple': ['multiple', ''], 'alt': [], 'src': [], 'height': [], 'width': [], 'min': [], 'max': [], 'step': [], 'formenctype': ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'], 'formmethod': ['get', 'post', 'put', 'delete'], 'formtarget': [], 'formnovalidate': ['formnovalidate', '']})
 \ ],
 \ 'ins': [
     \ flow_elements,
@@ -581,7 +626,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'link': [
     \ [],
-    \ extend(copy(global_attributes), {'href': [], 'rel': linkreltypes, 'hreflang': lang_tag, 'media': [], 'type': [], 'sizes': ['any']})
+    \ 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'],
@@ -596,12 +641,16 @@ let g:xmldata_html5 = {
     \ global_attributes
 \ ],
 \ 'menu': [
-    \ flow_elements + ['li'],
+    \ flow_elements + ['menuitem'],
     \ extend(copy(global_attributes), {'type': ['toolbar', 'context'], 'label': []})
 \ ],
+\ 'menuitem': [
+    \ flow_elements + ['li'],
+    \ extend(copy(global_attributes), {'type': ['toolbar', 'context'], 'label': [], 'icon': [], 'disabled': [], 'checked': [], 'radiogroup': [], 'default': [], 'command': []})
+\ ],
 \ 'meta': [
     \ [],
-    \ extend(copy(global_attributes), {'name': [], 'http-equiv': ['refresh', 'default-style', 'content-type'], 'content': [], 'charset': charset})
+    \ extend(copy(global_attributes), {'name': ['application-name', 'author', 'description', 'generator', 'referrer', 'creator', 'googlebot', 'publisher', 'robots', 'slurp', 'viewport', 'theme-color'], 'http-equiv': ['refresh', 'default-style', 'content-type'], 'content': [], 'charset': charset})
 \ ],
 \ 'meter': [
     \ phrasing_elements,
@@ -643,6 +692,10 @@ let g:xmldata_html5 = {
     \ [],
     \ extend(copy(global_attributes), {'name': [], 'value': []})
 \ ],
+\ 'picture': [
+    \ flow_elements + ['source'],
+    \ global_attributes
+\ ],
 \ 'pre': [
     \ phrasing_elements,
     \ global_attributes
@@ -655,6 +708,10 @@ let g:xmldata_html5 = {
     \ phrasing_elements,
     \ extend(copy(global_attributes), {'cite': []})
 \ ],
+\ 'rb': [
+    \ phrasing_elements,
+    \ global_attributes
+\ ],
 \ 'rp': [
     \ phrasing_elements,
     \ global_attributes
@@ -663,17 +720,21 @@ let g:xmldata_html5 = {
     \ phrasing_elements,
     \ global_attributes
 \ ],
-\ 'ruby': [
+\ 'rtc': [
     \ phrasing_elements + ['rp', 'rt'],
     \ global_attributes
 \ ],
+\ 'ruby': [
+    \ phrasing_elements + ['rb', 'rp', 'rt', 'rtc'],
+    \ global_attributes
+\ ],
 \ 'samp': [
     \ phrasing_elements,
     \ global_attributes
 \ ],
 \ 'script': [
     \ [],
-    \ extend(copy(global_attributes), {'src': [], 'defer': ['defer', ''], 'async': ['async', ''], 'type': [], 'charset': charset})
+    \ extend(copy(global_attributes), {'src': [], 'defer': ['defer', ''], 'async': ['async', ''], 'type': [], 'charset': charset, 'nonce': [], 'crossorigin': crossorigin})
 \ ],
 \ 'section': [
     \ flow_elements + ['style'],
@@ -693,7 +754,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'source': [
     \ [],
-    \ extend(copy(global_attributes), {'src': [], 'type': [], 'media': []})
+    \ extend(copy(global_attributes), {'src': [], 'type': [], 'media': [], 'srcset': [], 'sizes': []})
 \ ],
 \ 'span': [
     \ phrasing_elements,
@@ -705,7 +766,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'style': [
     \ [],
-    \ extend(copy(global_attributes), {'type': [], 'media': [], 'scoped': ['scoped', '']})
+    \ extend(copy(global_attributes), {'type': [], 'media': [], 'scoped': ['scoped', ''], 'nonce': []})
 \ ],
 \ 'sub': [
     \ phrasing_elements,
@@ -785,7 +846,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'video': [
     \ flow_elements + ['source', 'track'],
-    \ extend(copy(global_attributes), {'autoplay': ['autoplay', ''], 'preload': ['none', 'metadata', 'auto', ''], 'controls': ['controls', ''], 'loop': ['loop', ''], 'poster': [], 'height': [], 'width': [], 'src': []})
+    \ extend(copy(global_attributes), {'autoplay': ['autoplay', ''], 'preload': ['none', 'metadata', 'auto', ''], 'controls': ['controls', ''], 'loop': ['loop', ''], 'playsinline': ['playsinline', ''], 'poster': [], 'height': [], 'width': [], 'src': [], 'crossorigin': crossorigin})
 \ ],
 \ 'wbr': [
     \ [],

build

@@ -2,135 +2,300 @@
 
 set -E
 
-DIRS="syntax indent compiler autoload ftplugin ftdetect after/syntax after/indent after/ftplugin after/ftdetect"
+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"
+# shellcheck disable=SC2034
+DIRS_SYNTAX="syntax indent after/syntax after/indent"
+# shellcheck disable=SC2034
+DIRS_NOAFTER="syntax compiler indent autoload ftplugin"
+DIRS_JAVASCRIPT="${DIRS} extras"
+read -r -a DIRS_RM <<<"$DIRS_JAVASCRIPT"
+
+OUTPUT=""
+
+output() {
+  OUTPUT="$OUTPUT$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"
-    (git clone -q --recursive "https://github.com/$path.git" "$dir" && 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)"
-    printf -- "- [$name](https://github.com/$path) ("
+    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=""
-    for subdir in $DIRS; do
-      if [ -d "$dir/$subdir" ]; then
+    for subdir in ${!directories}; do
+      if [ -d "${dir}${subtree:-/}${subdir}" ]; then
         base="$(basename "$subdir")"
         if [[ "$subdirs" != *"$base"* ]]; then
           subdirs="$subdirs, $base"
         fi
 
-        copy_dir "$dir" "$subdir"
+        copy_dir "${dir}${subtree}" "$subdir" "$name"
       fi
     done
 
+    # 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 jinja" | grep -qF "$name"); then
+      echo "Skipping ftdetect installation of $name" >&2
+      continue
+    fi
+
+    [ -d "${dir}${subtree:-/}ftdetect" ] && for f in "${dir}${subtree:-/}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
 
-    printf "${subdirs##, })\n"
   done
 
-  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)"
+  mv tmp/polyglot.vim ftdetect/
 
-    if [ -d "$dir/plugin" ]; then
-      printf "Possible error (plugin directory exists): $path\n"
+  for pack in $1; do
+    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
+      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")"
-    cat $file >> $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
 }
 
-concat_ftdetect() {
-  cat ftdetect/* | grep -E '^[^"]' > tmp/polyglot.vim
-  rm -f ftdetect/*
-  mv tmp/polyglot.vim ftdetect/
+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() {
+  local tf of
+  tf="$(mktemp)"
+  of="$(mktemp)"
+  LC_ALL=C 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="
+  acpiasl:martinlroth/vim-acpi-asl
+  ansible:pearofducks/ansible-vim
+  apiblueprint:sheerun/apiblueprint.vim
+  applescript:mityu/vim-applescript:_SYNTAX
   arduino:sudar/vim-arduino-syntax
+  asciidoc:asciidoc/vim-asciidoc
+  autohotkey:hnamikaw/vim-autohotkey
+  blade:jwalton512/vim-blade
   c++11:octol/vim-cpp-enhanced-highlight
-  c/c++:vim-jp/cpp-vim
-  c-extensions:kergoth/aftersyntaxc.vim
+  c/c++:vim-jp/vim-cpp
+  caddyfile:isobit/vim-caddyfile
+  carp:hellerve/carp-vim
+  cjsx:mtscout6/vim-cjsx
   clojure:guns/vim-clojure-static
-  coffee-script:kchmck/vim-coffee-script
+  cmake:pboettch/vim-cmake-syntax
+  coffee-script:kchmck/vim-coffee-script:_NOAFTER
+  cql:elubow/cql-vim
+  cryptol:victoredwardocallaghan/cryptol.vim
+  crystal:rhysd/vim-crystal
   csv:chrisbra/csv.vim
   cucumber:tpope/vim-cucumber
-  dockerfile:honza/dockerfile.vim
+  cue:mgrabovsky/vim-cuesheet
+  dart:dart-lang/dart-vim-plugin
+  dockerfile:ekalinin/Dockerfile.vim
   elixir:elixir-lang/vim-elixir
-  emberscript:heartsentwined/vim-ember-script
-  erlang:oscarh/vimerl
+  elm:ElmCast/elm-vim
+  emberscript:yalesov/vim-ember-script
+  emblem:yalesov/vim-emblem
+  erlang:vim-erlang/vim-erlang-runtime
+  ferm:vim-scripts/ferm.vim
+  fish:dag/vim-fish
+  flatbuffers:dcharbon/vim-flatbuffers
+  fsharp:fsharp/vim-fsharp:_BASIC
   git:tpope/vim-git
-  go:jnwhiteh/vim-golang
-  haml:tpope/vim-haml
+  glsl:tikhomirov/vim-glsl:_NOAFTER
+  gmpl:maelvalais/gmpl.vim
+  gnuplot:vim-scripts/gnuplot-syntax-highlighting
+  go:fatih/vim-go:_BASIC
+  gradle:tfnico/vim-gradle
+  groovy:vim-scripts/groovy.vim
+  groovy-indent:vim-scripts/groovyindent-unix
+  haml:sheerun/vim-haml
   handlebars:mustache/vim-mustache-handlebars
-  haskell:travitch/hasksyn
+  haproxy:CH-DanReif/haproxy.vim
+  haskell:neovimhaskell/haskell-vim
   haxe:yaymukund/vim-haxe
   html5:othree/html5.vim
-  jade:digitaltoad/vim-jade
+  i3:mboughaba/i3config.vim
+  idris:idris-hackers/idris-vim
   jasmine:glanotte/vim-jasmine
-  javascript:pangloss/vim-javascript
-  json:leshill/vim-json
+  javascript:pangloss/vim-javascript:_JAVASCRIPT
+  jenkins:martinda/Jenkinsfile-vim-syntax
+  jinja:lepture/vim-jinja
+  json5:GutenYe/json5.vim
+  json:elzr/vim-json
   jst:briancollins/vim-jst
+  jsx:amadeus/vim-jsx
+  julia:JuliaEditorSupport/julia-vim
+  kotlin:udalov/kotlin-vim
   latex:LaTeX-Box-Team/LaTeX-Box
-  less:groenewege/vim-less
-  liquid:tpope/vim-liquid
-  markdown:tpope/vim-markdown
-  nginx:mutewinter/nginx.vim
-  ocaml:jrk/vim-ocaml
+  less:groenewege/vim-less:_NOAFTER
+  lilypond:anowlcalledjosh/vim-lilypond
+  livescript:gkz/vim-ls
+  llvm:rhysd/vim-llvm
+  lua:tbastos/vim-lua
+  mako:sophacles/vim-bundle-mako
+  markdown:plasticboy/vim-markdown:_SYNTAX
+  mathematica:voldikss/vim-mma
+  mdx:jxnblk/vim-mdx-js
+  meson:mesonbuild/meson:_ALL:/data/syntax-highlighting/vim/
+  moonscript:leafo/moonscript-vim
+  nginx:chr4/nginx.vim
+  nim:zah/nim.vim:_BASIC
+  nix:LnL7/vim-nix
+  objc:b4winckler/vim-objc
+  ocaml:rgrinberg/vim-ocaml
   octave:vim-scripts/octave.vim--
   opencl:petRUShka/vim-opencl
   perl:vim-perl/vim-perl
+  pgsql:lifepillar/pgsql.vim
   php:StanAngeloff/php.vim
-  puppet:rodjek/vim-puppet
+  plantuml:aklt/plantuml-syntax
+  pony:jakwings/vim-pony
+  powershell:PProvost/vim-ps1
   protobuf:uarun/vim-protobuf
-  python:mitsuhiko/vim-python-combined
+  pug:digitaltoad/vim-pug
+  puppet:voxpupuli/vim-puppet
+  purescript:purescript-contrib/purescript-vim
+  python-compiler:aliev/vim-compiler-python
+  python-indent:Vimjas/vim-python-pep8-indent
+  python:vim-python/python-syntax
+  qmake:artoj/qmake-syntax-vim
+  qml:peterhoeg/vim-qml
   r-lang:vim-scripts/R.vim
+  racket:wlangstroth/vim-racket
+  ragel:jneen/ragel.vim
+  raml:IN3D/vim-raml
+  reason:reasonml-editor/vim-reason-plus
   rspec:sheerun/rspec.vim
+  rst:marshallward/vim-restructuredtext
   ruby:vim-ruby/vim-ruby
-  rust:wting/rust.vim
+  rust:rust-lang/rust.vim
   sbt:derekwyatt/vim-sbt
   scala:derekwyatt/vim-scala
+  scss:cakebaker/scss-syntax.vim
   slim:slim-template/vim-slim
+  slime:slime-lang/vim-slime-syntax
+  smt2:bohlender/vim-smt2
+  solidity:tomlion/vim-solidity
   stylus:wavded/vim-stylus
-  systemd:kurayama/systemd-vim-syntax
+  svg-indent:jasonshell/vim-svg-indent
+  svg:vim-scripts/svg.vim
+  swift:keith/swift.vim
+  sxhkd:baskerville/vim-sxhkdrc
+  systemd:wgwoods/vim-systemd-syntax
+  terraform:hashivim/vim-terraform
   textile:timcharper/textile.vim
-  tmux:acustodioo/vim-tmux
-  tomdoc:duwanis/tomdoc.vim
-  typescript:leafgarland/typescript-vim
-  vbnet:vim-scripts/vbnet.vim
+  thrift:solarnz/thrift.vim
+  tmux:keith/tmux.vim
+  tomdoc:wellbredgrapefruit/tomdoc.vim
   toml:cespare/vim-toml
-  twig:beyondwords/vim-twig
+  twig:lumiliet/vim-twig
+  typescript:leafgarland/typescript-vim
+  vala:arrufat/vala.vim
+  vbnet:vim-scripts/vbnet.vim
+  vcl:smerrill/vcl-vim-plugin
+  vifm:vifm/vifm.vim
+  vm:lepture/vim-velocity
+  vue:posva/vim-vue
+  xdc:amal-khailtash/vim-xdc-syntax
+  xml:amadeus/vim-xml
   xls:vim-scripts/XSLT-syntax
+  yaml:stephpy/vim-yaml
   yard:sheerun/vim-yardoc
-  css-color:ap/vim-css-color
 "
 
 rm -rf tmp
-rm -rf $DIRS
+rm -rf "${DIRS_RM[@]}"
 mkdir tmp
 
 printf "Downloading packs..."
-download "$PACKS"
-extract "$PACKS"
-concat_ftdetect
+download "$(sed '/^#/d' <<<"$PACKS")"
+extract "$(sed '/^#/d' <<<"$PACKS")"
+update_readme
 
 rm -rf tmp

compiler/cake.vim

@@ -1,5 +1,9 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'coffee-script') != -1
+  finish
+endif
+
 " Language:    CoffeeScript
-" Maintainer:  Mick Koch <kchmck@gmail.com>
+" Maintainer:  Mick Koch <mick@kochm.co>
 " URL:         http://github.com/kchmck/vim-coffee-script
 " License:     WTFPL
 

compiler/cargo.vim

@@ -0,0 +1,53 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'rust') != -1
+  finish
+endif
+
+" Vim compiler file
+" Compiler:         Cargo Compiler
+" Maintainer:       Damien Radtke <damienradtke@gmail.com>
+" Latest Revision:  2014 Sep 24
+" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
+
+if exists('current_compiler')
+    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>
+endif
+
+if exists('g:cargo_makeprg_params')
+    execute 'CompilerSet makeprg=cargo\ '.escape(g:cargo_makeprg_params, ' \|"').'\ $*'
+else
+    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:%c
+
+" vint: -ProhibitAbbreviationOption
+let &cpo = s:save_cpo
+unlet s:save_cpo
+" vint: +ProhibitAbbreviationOption
+
+" vim: set et sw=4 sts=4 ts=8:

compiler/coffee.vim

@@ -1,5 +1,9 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'coffee-script') != -1
+  finish
+endif
+
 " Language:    CoffeeScript
-" Maintainer:  Mick Koch <kchmck@gmail.com>
+" Maintainer:  Mick Koch <mick@kochm.co>
 " URL:         http://github.com/kchmck/vim-coffee-script
 " License:     WTFPL
 

compiler/credo.vim

@@ -0,0 +1,15 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'elixir') != -1
+  finish
+endif
+
+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

compiler/cryptol.vim

@@ -0,0 +1,24 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'cryptol') != -1
+  finish
+endif
+
+" Vim compiler file
+" Compiler:         Cryptol version 1.8.19-academic Compiler
+" Maintainer:       Edward O'Callaghan <victoredwardocallaghan AT gmail DOT com>
+" Latest Revision:  25-Apr-2013
+
+if exists("current_compiler")
+  finish
+endif
+let current_compiler = "cryptol"
+
+if exists(":CompilerSet") != 2
+   command = -nargs =* CompilerSet setlocal <args>
+endif
+
+" TODO: Work out errorformat for the Cryptol compiler, see
+" :help errorformat
+CompilerSet errorformat&     " use the default 'errorformat'
+
+" "%<" means the current file name without extension.
+CompilerSet makeprg=cryptol\ -o\ %<\ %

compiler/cucumber.vim

@@ -1,3 +1,7 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'cucumber') != -1
+  finish
+endif
+
 " Vim compiler file
 " Compiler:	Cucumber
 " Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
@@ -19,7 +23,7 @@ CompilerSet makeprg=cucumber
 
 CompilerSet errorformat=
       \%W%m\ (Cucumber::Undefined),
-      \%E%m\ (%.%#),
+      \%E%m\ (%\\S%#),
       \%Z%f:%l,
       \%Z%f:%l:%.%#
 

compiler/erlang.vim

@@ -1,80 +0,0 @@
-" Erlang compiler file
-" Language:   Erlang
-" Maintainer: Pawel 'kTT' Salata <rockplayer.pl@gmail.com>
-" URL:        http://ktototaki.info
-
-if exists("current_compiler")
-    finish
-endif
-let current_compiler = "erlang"
-
-if exists(":CompilerSet") != 2
-    command -nargs=* CompilerSet setlocal <args>
-endif
-
-if !exists('g:erlangCheckFile')
-    let g:erlangCheckFile = "~/.vim/compiler/erlang_check_file.erl"
-endif
-
-if !exists('g:erlangHighlightErrors')
-    let g:erlangHighlightErrors = 0
-endif
-
-let b:error_list = {}
-let b:is_showing_msg = 0
-
-function! HighlightErlangErrors()
-    if match(getline(1), "#!.*escript") != -1
-        setlocal makeprg=escript\ -s\ %
-    else
-        execute "setlocal makeprg=" . g:erlangCheckFile . "\\ \%"
-    endif
-    silent make!
-    call s:clear_matches()
-    for error in getqflist()
-        let item = {}
-        let item['lnum'] = error.lnum
-        let item['msg'] = error.text
-        let b:error_list[error.lnum] = item
-        call matchadd('SpellBad', "\\%" . error.lnum . "l")
-    endfor
-    if len(getqflist())
-        redraw!
-    endif
-    call s:show_msg()
-    setlocal makeprg=erlc\ %
-endfunction
-
-function! s:show_msg()
-    let pos = getpos(".")
-    if has_key(b:error_list, pos[1])
-        let item = get(b:error_list, pos[1])
-        echo item.msg
-        let b:is_showing_msg = 1
-    else
-        if exists("b:is_showing_msg") && b:is_showing_msg == 1
-            echo
-            let b:is_showing_msg = 0
-        endif
-    endif
-endf
-
-function! s:clear_matches()
-    call clearmatches()
-    let b:error_list = {}
-    if exists("b:is_showing_msg") && b:is_showing_msg == 1
-        echo
-        let b:is_showing_msg = 0
-    endif
-endfunction
-
-CompilerSet makeprg=erlc\ %
-CompilerSet errorformat=%f:%l:\ %tarning:\ %m,%E%f:%l:\ %m
-
-if g:erlangHighlightErrors
-    autocmd BufLeave *.erl call s:clear_matches()
-    autocmd BufEnter *.erl call s:clear_matches()
-    autocmd BufWritePost *.erl call HighlightErlangErrors()
-    autocmd CursorHold *.erl call s:show_msg()
-    autocmd CursorMoved *.erl call s:show_msg()
-endif

compiler/eruby.vim

@@ -1,3 +1,7 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'ruby') != -1
+  finish
+endif
+
 " Vim compiler file
 " Language:		eRuby
 " Maintainer:		Doug Kearns <dougkearns@gmail.com>
@@ -28,8 +32,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/eslint.vim

@@ -0,0 +1,20 @@
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'javascript') != -1
+  finish
+endif
+
+" Vim compiler plugin
+" Language:     JavaScript
+" Maintainer:   vim-javascript community
+" URL:          https://github.com/pangloss/vim-javascript
+
+if exists("current_compiler")
+  finish
+endif
+let current_compiler = "eslint"
+
+if exists(":CompilerSet") != 2
+  command! -nargs=* CompilerSet setlocal <args>
+endif
+
+CompilerSet makeprg=eslint\ -f\ compact\ %
+CompilerSet errorformat=%f:\ line\ %l\\,\ col\ %c\\,\ %m

compiler/exunit.vim

@@ -1,7 +1,6 @@
-" Vim compiler file
-" Language:     ExUnit
-" Maintainer:   Rein Henrichs <rein.henrichs@gmail.com>
-" URL:          https://github.com/elixir-lang/vim-elixir
+if exists('g:polyglot_disabled') && index(g:polyglot_disabled, 'elixir') != -1
+  finish
+endif
 
 if exists("current_compiler")
   finish
@@ -14,9 +13,15 @@ endif
 
 let s:cpo_save = &cpo
 set cpo-=C
-
 CompilerSet makeprg=mix\ test
-CompilerSet errorformat=%A\ \ %.)\ %m(%.%#),%C\ \ \ \ \ **%m,%C\ \ \ \ \ \ \ %m,%Z\ \ \ \ \ at\ %f:%l,%-G%.%#
+CompilerSet errorformat=
+  \%E\ \ %n)\ %m,
+  \%+G\ \ \ \ \ **\ %m,
+  \%+G\ \ \ \ \ stacktrace:,
+  \%C\ \ \ \ \ %f:%l,
+  \%+G\ \ \ \ \ \ \ (%\\w%\\+)\ %f:%l:\ %m,
+  \%+G\ \ \ \ \ \ \ %f:%l:\ %.%#,
+  \**\ (%\\w%\\+)\ %f:%l:\ %m
 
 let &cpo = s:cpo_save
 unlet s:cpo_save