Add pony support

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

README.md

@@ -1,4 +1,4 @@
-# vim-polyglot [![Build Status][travis-img-url]][travis-url] [![Maintenance](https://img.shields.io/maintenance/yes/2017.svg?maxAge=2592000)]()
+# vim-polyglot [![Build Status][travis-img-url]][travis-url] [![Maintenance](https://img.shields.io/maintenance/yes/2018.svg?maxAge=2592000)]()
 
 [travis-img-url]: https://travis-ci.org/sheerun/vim-polyglot.svg
 [travis-url]: https://travis-ci.org/sheerun/vim-polyglot
@@ -8,7 +8,7 @@ A collection of language packs for Vim.
 > One to rule them all, one to find them, one to bring them all and in the darkness bind them.
 
 - It **won't affect your startup time**, as scripts are loaded only on demand\*.
-- It **installs and updates 100+ times faster** than 100+ packages it consists of.
+- It **installs and updates 100+ times faster** than the <!--Package Count-->118<!--/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`).
@@ -42,9 +42,10 @@ If you need full functionality of any plugin, please use it directly with your p
 
 ## Language packs
 
+<!--Language Packs-->
 - [ansible](https://github.com/pearofducks/ansible-vim) (syntax, indent, ftplugin)
 - [apiblueprint](https://github.com/sheerun/apiblueprint.vim) (syntax)
-- [applescript](https://github.com/vim-scripts/applescript.vim) (syntax)
+- [applescript](https://github.com/mityu/vim-applescript) (syntax, indent)
 - [arduino](https://github.com/sudar/vim-arduino-syntax) (syntax, indent)
 - [asciidoc](https://github.com/asciidoc/vim-asciidoc) (syntax)
 - [autohotkey](https://github.com/hnamikaw/vim-autohotkey) (indent)
@@ -62,12 +63,13 @@ If you need full functionality of any plugin, please use it directly with your p
 - [crystal](https://github.com/rhysd/vim-crystal) (syntax, indent, autoload, ftplugin)
 - [cucumber](https://github.com/tpope/vim-cucumber) (syntax, indent, compiler, ftplugin)
 - [dart](https://github.com/dart-lang/dart-vim-plugin) (syntax, indent, autoload, ftplugin)
-- [dockerfile](https://github.com/docker/docker) (syntax)
+- [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)
 - [fsharp](https://github.com/fsharp/vim-fsharp) (syntax, indent)
 - [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin)
@@ -75,13 +77,15 @@ If you need full functionality of any plugin, please use it directly with your p
 - [gmpl](https://github.com/maelvalais/gmpl.vim) (syntax)
 - [gnuplot](https://github.com/vim-scripts/gnuplot-syntax-highlighting) (syntax)
 - [go](https://github.com/fatih/vim-go) (syntax, compiler, indent)
+- [graphql](https://github.com/jparise/vim-graphql) (syntax, indent, ftplugin)
 - [groovy](https://github.com/vim-scripts/groovy.vim) (syntax)
 - [haml](https://github.com/sheerun/vim-haml) (syntax, indent, compiler, ftplugin)
 - [handlebars](https://github.com/mustache/vim-mustache-handlebars) (syntax, indent, ftplugin)
+- [haproxy](https://github.com/CH-DanReif/haproxy.vim) (syntax)
 - [haskell](https://github.com/neovimhaskell/haskell-vim) (syntax, indent, ftplugin)
 - [haxe](https://github.com/yaymukund/vim-haxe) (syntax)
 - [html5](https://github.com/othree/html5.vim) (syntax, indent, autoload, ftplugin)
-- [i3](https://github.com/PotatoesMaster/i3-vim-syntax) (syntax, ftplugin)
+- [i3](https://github.com/mboughaba/i3config.vim) (syntax, 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)
@@ -99,17 +103,20 @@ If you need full functionality of any plugin, please use it directly with your p
 - [mako](https://github.com/sophacles/vim-bundle-mako) (syntax, indent, ftplugin)
 - [markdown](https://github.com/plasticboy/vim-markdown) (syntax, indent)
 - [mathematica](https://github.com/rsmenon/vim-mathematica) (syntax, 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, ftplugin)
+- [nix](https://github.com/LnL7/vim-nix) (syntax, indent, compiler, ftplugin)
 - [objc](https://github.com/b4winckler/vim-objc) (ftplugin, syntax, indent)
 - [ocaml](https://github.com/jrk/vim-ocaml) (syntax, indent, ftplugin)
 - [octave](https://github.com/vim-scripts/octave.vim--) (syntax)
 - [opencl](https://github.com/petRUShka/vim-opencl) (syntax, indent, ftplugin)
+- [org](https://github.com/jceb/vim-orgmode) (syntax, indent, ftplugin)
 - [perl](https://github.com/vim-perl/vim-perl) (syntax, indent, ftplugin)
 - [pgsql](https://github.com/exu/pgsql.vim) (syntax)
 - [php](https://github.com/StanAngeloff/php.vim) (syntax)
 - [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)
@@ -124,6 +131,7 @@ If you need full functionality of any plugin, please use it directly with your p
 - [ragel](https://github.com/jneen/ragel.vim) (syntax)
 - [raml](https://github.com/IN3D/vim-raml) (syntax, ftplugin)
 - [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)
@@ -135,7 +143,7 @@ If you need full functionality of any plugin, please use it directly with your p
 - [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin)
 - [swift](https://github.com/keith/swift.vim) (syntax, indent, ftplugin)
 - [sxhkd](https://github.com/baskerville/vim-sxhkdrc) (syntax)
-- [systemd](https://github.com/kurayama/systemd-vim-syntax) (syntax)
+- [systemd](https://github.com/wgwoods/vim-systemd-syntax) (syntax)
 - [terraform](https://github.com/hashivim/vim-terraform) (syntax, indent, ftplugin)
 - [textile](https://github.com/timcharper/textile.vim) (syntax, ftplugin)
 - [thrift](https://github.com/solarnz/thrift.vim) (syntax)
@@ -153,6 +161,7 @@ If you need full functionality of any plugin, please use it directly with your p
 - [xls](https://github.com/vim-scripts/XSLT-syntax) (syntax)
 - [yaml](https://github.com/stephpy/vim-yaml) (syntax, ftplugin)
 - [yard](https://github.com/sheerun/vim-yardoc) (syntax)
+<!--/Language Packs-->
 
 ## Updating
 
@@ -169,13 +178,18 @@ Individual language packs can be disabled by setting `g:polyglot_disabled` as fo
 let g:polyglot_disabled = ['css']
 ```
 
-Note that disabiling languages won't make in general your vim startup any faster / slower (only for specific file type). Vim-polyglot is selection of language plugins that are loaded only on demand.
+Note that disabling languages won't make in general your vim startup any faster / slower (only for specific file type). Vim-polyglot is selection of language plugins that are loaded only on demand.
 
 ## Contributing
 
 Language packs are periodically updated using automated `build` script.
 
-Feel free to add your language, and send pull-request.
+Feel free to add your language, and send pull-request.  In your pull request, please include:
+1. How you chose the particular repo from which to pull support for this language.
+2. An updated https://github.com/sheerun/vim-polyglot/blob/master/build .
+3. If at all possible, absolutely nothing else (in particular, please don't run `build` and include that in your PR).
+
+The easier it is to validate that the new language won't do anything wacky, the faster it'll be merged.  In particular, languages that utilize global plugins (loaded for every filetype), or plugins with dangerous features (like `call` based on the contents of a file being edited), will never be merged, as they will be slow or dangerous, respectively.
 
 ## License
 

after/ftplugin/jsx.vim

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

after/ftplugin/terraform.vim

@@ -75,4 +75,11 @@ if get(g:, "terraform_align", 1)
   setlocal shiftwidth=2
 endif
 
+" Set the commentstring
+if exists('g:terraform_commentstring')
+    let &l:commentstring=g:terraform_commentstring
+else
+    setlocal commentstring=#%s
+endif
+
 endif

after/syntax/javascript/graphql.vim

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

after/syntax/jsx.vim

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

after/syntax/rust.vim

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

after/syntax/typescript/graphql.vim

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

after/syntax/yaml.vim

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

autoload/LaTeXtoUnicode.vim

@@ -21,6 +21,9 @@ function! s:L2U_Setup()
   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")
@@ -76,11 +79,7 @@ function! s:L2U_SetupGlobal()
   " A hack to forcibly get out of completion mode: feed
   " this string with feedkeys()
   if has("win32") || has("win64")
-    if has("gui_running")
-      let s:l2u_esc_sequence = "\u0006"
-    else
-      let s:l2u_esc_sequence = "\u0006\b"
-    endif
+    let s:l2u_esc_sequence = "\u0006"
   else
     let s:l2u_esc_sequence = "\u0091\b"
   end
@@ -409,8 +408,8 @@ function! LaTeXtoUnicode#FallbackCallback()
   return
 endfunction
 
-" This is the function which is mapped to <S-Tab> in command-line mode
-function! LaTeXtoUnicode#CmdTab()
+" 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
@@ -419,6 +418,9 @@ function! LaTeXtoUnicode#CmdTab()
   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]
@@ -434,6 +436,9 @@ function! LaTeXtoUnicode#CmdTab()
     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
@@ -463,8 +468,13 @@ endfunction
 " Setup the L2U tab mapping
 function! s:L2U_SetTab(wait_insert_enter)
   if !b:l2u_cmdtab_set && get(g:, "latex_to_unicode_tab", 1) && b:l2u_enabled
-    cmap <buffer> <S-Tab> <Plug>L2UCmdTab
-    cnoremap <buffer> <Plug>L2UCmdTab <C-\>eLaTeXtoUnicode#CmdTab()<CR>
+    let b:l2u_cmdtab_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
@@ -500,7 +510,9 @@ endfunction
 " Revert the LaTeX-to-Unicode tab mapping settings
 function! s:L2U_UnsetTab()
   if b:l2u_cmdtab_set
-    cunmap <buffer> <S-Tab>
+    for k in b:l2u_cmdtab_keys
+      exec 'cunmap <buffer> '.k
+    endfor
     let b:l2u_cmdtab_set = 0
   endif
   if !b:l2u_tab_set
@@ -593,6 +605,21 @@ function! s:L2U_UnsetAutoSub()
   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
@@ -605,9 +632,11 @@ function! LaTeXtoUnicode#Init(...)
 
   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()

autoload/RstFold.vim

@@ -0,0 +1,54 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rst') == -1
+  
+" Author: Antony Lee <anntzer.lee@gmail.com>
+" Description: Helper functions for reStructuredText syntax folding
+" Last Modified: 2018-01-07
+
+function s:CacheRstFold()
+  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 !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 !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
+
+endif

autoload/cargo.vim

@@ -1,89 +1,119 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
   
-function! cargo#cmd(args)
-    silent! clear
-    if !a:args
-        execute "!" . "cargo ". a:args
-    else
-        echom "Missing arguments"
-    endif
+function! cargo#Load() 
+    " Utility call to get this script loaded, for debugging
 endfunction
 
-function! cargo#build(args)
-    silent! clear
-    if !a:args
-        execute "!" . "cargo build " . a:args
+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
-        execute "!" . "cargo build"
+        let l:starting_path = get(a:, 2, expand('%:p:h'))
     endif
-    silent! clear
-    execute "!" . "cargo build"
+
+    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)
-    silent! clear
-    if !a:args
-        execute "!" . "cargo clean " . a:args
-    else
-        execute "!" . "cargo clean"
-    endif
-    silent! clear
-    execute "!" . "cargo clean"
+    call cargo#cmd("clean " . a:args)
 endfunction
 
 function! cargo#doc(args)
-    silent! clear
-    if !a:args
-        execute "!" . "cargo doc " . a:args
-    else
-        execute "!" . "cargo doc"
-    endif
+    call cargo#cmd("doc " . a:args)
 endfunction
 
 function! cargo#new(args)
-    silent! clear
-    if !a:args
-        execute "!cargo new " . a:args
-        :cd `=a:args`
-    else
-        echom "Missing arguments"
-    endif
+    call cargo#cmd("new " . a:args)
+    cd `=a:args`
 endfunction
 
 function! cargo#init(args)
-    silent! clear
-    if !a:args
-        execute "!" . "cargo init " . a:args
-    else
-        execute "!" . "cargo init"
-    endif
+    call cargo#cmd("init " . a:args)
 endfunction
 
 function! cargo#run(args)
-    silent! clear
-    if !a:args
-        execute "!" . "cargo run " . a:args
-    else
-        execute "!" . "cargo run"
-    endif
+    call cargo#cmd("run " . a:args)
 endfunction
 
 function! cargo#test(args)
-    silent! clear
-    if !a:args
-        execute "!" . "cargo test " . a:args
-    else
-        execute "!" . "cargo test"
-    endif
+    call cargo#cmd("test " . a:args)
 endfunction
 
 function! cargo#bench(args)
-    silent! clear
-    if !a:args
-        execute "!" . "cargo bench " . a:args
-    else
-        execute "!" . "cargo bench"
+    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:
+
 endif

autoload/cargo/quickfix.vim

@@ -0,0 +1,30 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+  
+function! cargo#quickfix#CmdPre() abort
+    if &filetype ==# 'rust' && get(b:, 'current_compiler', '') ==# 'cargo'
+        " Preserve the current directory, and 'lcd' to the nearest Cargo file.
+        let b:rust_compiler_cargo_qf_has_lcd = haslocaldir()
+        let b:rust_compiler_cargo_qf_prev_cd = getcwd()
+        let b:rust_compiler_cargo_qf_prev_cd_saved = 1
+        let l:nearest = fnamemodify(cargo#nearestRootCargo(0), ':h')
+        execute 'lchdir! '.l:nearest
+    else
+        let b:rust_compiler_cargo_qf_prev_cd_saved = 0
+    endif
+endfunction
+
+function! cargo#quickfix#CmdPost() abort
+    if 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:
+
+endif

autoload/crystal_lang.vim

@@ -310,6 +310,10 @@ function! crystal_lang#format(option_str, ...) abort
     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/dart.vim

@@ -22,6 +22,7 @@ function! dart#fmt(q_args) abort
   if executable('dartfmt')
     let buffer_content = join(getline(1, '$'), "\n")
     let joined_lines = system(printf('dartfmt %s', a:q_args), buffer_content)
+    if buffer_content ==# joined_lines[:-2] | return | endif
     if 0 == v:shell_error
       let win_view = winsaveview()
       let lines = split(joined_lines, "\n")
@@ -129,6 +130,15 @@ function! s:PackageMap() abort
   return [v:true, map]
 endfunction
 
+" Toggle whether dartfmt is run on save or not.
+function! dart#ToggleFormatOnSave() abort
+  if get(g:, "dart_format_on_save", 0)
+    let g:dart_format_on_save = 0
+    return
+  endif
+  let g:dart_format_on_save = 1
+endfunction
+
 " Finds a file name '.packages' in the cwd, or in any directory above the open
 " file.
 "

autoload/elixir/indent.vim

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

autoload/elm.vim

@@ -349,11 +349,14 @@ function! elm#FindRootDirectory() abort
 	if empty(l:elm_root)
 		let l:current_file = expand('%:p')
 		let l:dir_current_file = fnameescape(fnamemodify(l:current_file, ':h'))
-		let l:match = findfile('elm-package.json', l:dir_current_file . ';')
-		if empty(l:match)
-			let l:elm_root = ''
+		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 = fnamemodify(l:match, ':p:h')
+			let l:elm_root = ''
 		endif
 
 		if !empty(l:elm_root)

autoload/go/config.vim

@@ -0,0 +1,456 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'go') == -1
+  
+" 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 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#SetDebugDiag(value) abort
+  let g:go_debug_diag = a:value
+endfunction
+
+function! go#config#AutoSameids() abort
+    return get(g:, 'go_auto_sameids', 0)
+endfunction
+
+function! go#config#SetAutoSameids(value) abort
+  let g:go_auto_sameids = a:value
+endfunction
+
+function! go#config#AddtagsTransform() abort
+  return get(g:, 'go_addtags_transform', "snakecase")
+endfunction
+
+function! go#config#TemplateAutocreate() abort
+  return get(g:, "go_template_autocreate", 1)
+endfunction
+
+function! go#config#SetTemplateAutocreate(value) abort
+  let g:go_template_autocreate = a:value
+endfunction
+
+function! go#config#MetalinterCommand() abort
+  return get(g:, "go_metalinter_command", "")
+endfunction
+
+function! go#config#MetalinterAutosaveEnabled() abort
+  return get(g:, 'go_metalinter_autosave_enabled', ['vet', 'golint'])
+endfunction
+
+function! go#config#MetalinterEnabled() abort
+  return get(g:, "go_metalinter_enabled", ['vet', 'golint', 'errcheck'])
+endfunction
+
+function! go#config#MetalinterDisabled() abort
+  return get(g:, "go_metalinter_disabled", [])
+endfunction
+
+function! go#config#GolintBin() abort
+  return get(g:, "go_golint_bin", "golint")
+endfunction
+
+function! go#config#ErrcheckBin() abort
+  return get(g:, "go_errcheck_bin", "errcheck")
+endfunction
+
+function! go#config#MetalinterAutosave() abort
+  return get(g:, "go_metalinter_autosave", 0)
+endfunction
+
+function! go#config#SetMetalinterAutosave(value) abort
+  let g:go_metalinter_autosave = a:value
+endfunction
+
+function! go#config#ListHeight() abort
+  return get(g:, "go_list_height", 0)
+endfunction
+
+function! go#config#FmtAutosave() abort
+	return get(g:, "go_fmt_autosave", 1)
+endfunction
+
+function! go#config#SetFmtAutosave(value) abort
+  let g:go_fmt_autosave = a:value
+endfunction
+
+function! go#config#AsmfmtAutosave() abort
+  return get(g:, "go_asmfmt_autosave", 0)
+endfunction
+
+function! go#config#SetAsmfmtAutosave(value) abort
+  let g:go_asmfmt_autosave = a:value
+endfunction
+
+function! go#config#ModFmtAutosave() abort
+	return get(g:, "go_mod_fmt_autosave", 1)
+endfunction
+
+function! go#config#SetModFmtAutosave(value) abort
+  let g:go_mod_fmt_autosave = a:value
+endfunction
+
+function! go#config#DocMaxHeight() abort
+  return get(g:, "go_doc_max_height", 20)
+endfunction
+
+function! go#config#AutoTypeInfo() abort
+  return get(g:, "go_auto_type_info", 0)
+endfunction
+
+function! go#config#SetAutoTypeInfo(value) abort
+  let g:go_auto_type_info = a:value
+endfunction
+
+function! go#config#AlternateMode() abort
+  return get(g:, "go_alternate_mode", "edit")
+endfunction
+
+function! go#config#DeclsMode() abort
+  return get(g:, "go_decls_mode", "")
+endfunction
+
+function! go#config#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#HighlightFunctionArguments() abort
+  return get(g:, 'go_highlight_function_arguments', 0)
+endfunction
+
+function! go#config#HighlightFunctionCalls() abort
+  return get(g:, 'go_highlight_function_calls', 0)
+endfunction
+
+function! go#config#HighlightFields() abort
+  return get(g:, 'go_highlight_fields', 0)
+endfunction
+
+function! go#config#HighlightTypes() abort
+  return get(g:, 'go_highlight_types', 0)
+endfunction
+
+function! go#config#HighlightBuildConstraints() abort
+  return get(g:, 'go_highlight_build_constraints', 0)
+endfunction
+
+function! go#config#HighlightStringSpellcheck() abort
+  return get(g:, 'go_highlight_string_spellcheck', 1)
+endfunction
+
+function! go#config#HighlightFormatStrings() abort
+  return get(g:, 'go_highlight_format_strings', 1)
+endfunction
+
+function! go#config#HighlightGenerateTags() abort
+  return get(g:, 'go_highlight_generate_tags', 0)
+endfunction
+
+function! go#config#HighlightVariableAssignments() abort
+  return get(g:, 'go_highlight_variable_assignments', 0)
+endfunction
+
+function! go#config#HighlightVariableDeclarations() abort
+  return get(g:, 'go_highlight_variable_declarations', 0)
+endfunction
+
+function! go#config#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
+
+" 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
+
+endif

autoload/julia/doc.vim

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

autoload/julia_blocks.vim

@@ -244,8 +244,8 @@ function! julia_blocks#init_mappings()
   call julia_blocks#select_reset()
   augroup JuliaBlocks
     au!
-    au InsertEnter *.jl call julia_blocks#select_reset()
-    au CursorMoved *.jl call s:cursor_moved()
+    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

autoload/pony.vim

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

autoload/rubycomplete.vim

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

autoload/rust.vim

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

autoload/rust/debugging.vim

@@ -0,0 +1,105 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+  
+" For debugging, inspired by https://github.com/w0rp/rust/blob/master/autoload/rust/debugging.vim
+
+let s:global_variable_list = [
+            \ 'ftplugin_rust_source_path',
+            \ 'loaded_syntastic_rust_cargo_checker',
+            \ 'loaded_syntastic_rust_filetype',
+            \ 'loaded_syntastic_rust_rustc_checker',
+            \ 'rust_bang_comment_leader',
+            \ 'rust_cargo_avoid_whole_workspace',
+            \ 'rust_clip_command',
+            \ 'rust_conceal',
+            \ 'rust_conceal_mod_path',
+            \ 'rust_conceal_pub',
+            \ 'rust_fold',
+            \ 'rust_last_args',
+            \ 'rust_last_rustc_args',
+            \ 'rust_original_delimitMate_excluded_regions',
+            \ 'rust_playpen_url',
+            \ 'rust_prev_delimitMate_quotes',
+            \ 'rust_recent_nearest_cargo_tol',
+            \ 'rust_recent_root_cargo_toml',
+            \ 'rust_recommended_style',
+            \ 'rust_set_conceallevel',
+            \ 'rust_set_conceallevel=1',
+            \ 'rust_set_foldmethod',
+            \ 'rust_set_foldmethod=1',
+            \ 'rust_shortener_url',
+            \ 'rustc_makeprg_no_percent',
+            \ 'rustc_path',
+            \ 'rustfmt_autosave',
+            \ 'rustfmt_autosave_because_of_config',
+            \ 'rustfmt_autosave_if_config_present',
+            \ 'rustfmt_command',
+            \ 'rustfmt_emit_files',
+            \ 'rustfmt_fail_silently',
+            \ 'rustfmt_options',
+            \ 'syntastic_extra_filetypes',
+            \ 'syntastic_rust_cargo_fname',
+            \]
+
+function! s:Echo(message) abort
+    execute 'echo a:message'
+endfunction
+
+function! s:EchoGlobalVariables() abort
+    for l:key in s:global_variable_list
+        call s:Echo('let g:' . l:key . ' = ' . string(get(g:, l:key, v:null)))
+
+        if has_key(b:, l:key)
+            call s:Echo('let b:' . l:key . ' = ' . string(b:[l:key]))
+        endif
+    endfor
+endfunction
+
+function! rust#debugging#Info() abort
+    call cargo#Load()
+    call rust#Load()
+    call rustfmt#Load()
+    call s:Echo('rust.vim Global Variables:')
+    call s:Echo('')
+    call s:EchoGlobalVariables()
+
+    silent let l:output = system(g:rustfmt_command . ' --version')
+    echo l:output
+
+    let l:rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
+    silent let l:output = system(l:rustc . ' --version')
+    echo l:output
+
+    silent let l:output = system('cargo --version')
+    echo l:output
+
+    version
+
+    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:
+
+endif

autoload/rust/delimitmate.vim

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

autoload/rustfmt.vim

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

autoload/vifm/globals.vim

@@ -2,7 +2,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vifm') == -1
   
 " common functions for vifm plugin related to globals
 " Maintainer:  xaizek <xaizek@posteo.net>
-" Last Change: January 02, 2018
+" Last Change: November 03, 2018
 
 " Initializes global variables to defaults unless they are already set
 function! vifm#globals#Init()
@@ -26,6 +26,10 @@ function! vifm#globals#Init()
             let g:vifm_term = 'xterm -e'
         endif
     endif
+
+    if !exists('g:vifm_embed_term')
+        let g:vifm_embed_term = has('gui_running')
+    endif
 endfunction
 
 endif

autoload/xml/aria.vim

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

autoload/xml/html5.vim

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

build

@@ -3,41 +3,44 @@
 set -E
 
 DIRS="syntax indent compiler autoload ftplugin after/syntax after/indent after/ftplugin"
+# shellcheck disable=SC2034
 DIRS_BASIC="syntax compiler indent after/syntax after/indent"
+# shellcheck disable=SC2034
 DIRS_ALL="syntax indent compiler autoload ftplugin after"
+# shellcheck disable=SC2034
 DIRS_SYNTAX="syntax indent after/syntax after/indent"
 DIRS_JAVASCRIPT="${DIRS} extras"
-DIRS_RM="$DIRS_JAVASCRIPT"
+read -r -a DIRS_RM <<<"$DIRS_JAVASCRIPT"
 
 OUTPUT=""
 
 output() {
   OUTPUT="$OUTPUT$1"
-  printf -- "$1"
+  echo -n "$1"
 }
 
 download() {
   for pack in $1; do
-    path="$(printf "$pack" | cut -d ':' -f 2)"
-    dir="tmp/$(printf "$path" | cut -d '/' -f 2)"
+    path="$(cut -d ':' -f 2 <<<"$pack")"
+    dir="tmp/$(cut -d '/' -f 2 <<<"$path")"
     rm -rf "$dir"
-    (mkdir -p "$dir" && curl --silent -L https://codeload.github.com/$path/tar.gz/master | tar -zx -C "$dir" --strip 1 && printf '.') &
+    (mkdir -p "$dir" && curl --silent -L "https://codeload.github.com/$path/tar.gz/master" | tar -zx -C "$dir" --strip 1 && printf '.') &
   done
 
   wait
 }
 
 extract() {
-  printf "\n"
+  echo
 
   cat config.vim >> tmp/polyglot.vim
 
   for pack in $1; do
-    name="$(printf "$pack" | cut -d ':' -f 1)"
-    path="$(printf "$pack" | cut -d ':' -f 2)"
-    dir="tmp/$(printf "$path" | cut -d '/' -f 2)"
-    directories="DIRS$(printf "$pack" | cut -d ':' -f 3)"
-    subtree="$(printf "$pack" | cut -d ':' -f 4)"
+    name="$(cut -d ':' -f 1 <<<"$pack")"
+    path="$(cut -d ':' -f 2 <<<"$pack")"
+    dir="tmp/$(cut -d '/' -f 2 <<<"$path")"
+    directories="DIRS$(cut -d ':' -f 3 <<<"$pack")"
+    subtree="$(cut -d ':' -f 4 <<<"$pack")"
     output "- [$name](https://github.com/$path) ("
 
     subdirs=""
@@ -52,21 +55,29 @@ extract() {
       fi
     done
 
-    output "${subdirs##, })\n"
-
-    if (echo "julia coffee-script elixir fish git plantuml scala swift"  | fgrep -q "$name"); then
-	echo "Skipping ftdetect installation of $name"
-	continue
+    # 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
 
-    for f in ${dir}/ftdetect/*; do
-      (
-        echo "augroup filetypedetect";
-        echo '" '"$pack";
-        cat "${f}";
-        echo "augroup END";
-        echo
-      ) >> tmp/polyglot.vim;
+    output "${subdirs##, })"$'\n'
+
+    if (echo "julia coffee-script elixir fish git plantuml scala swift" | grep -qF "$name"); then
+      echo "Skipping ftdetect installation of $name" >&2
+      continue
+    fi
+
+    [ -d "${dir}/ftdetect" ] && for f in "${dir}/ftdetect/"*; do
+      cat <<EOF >> tmp/polyglot.vim
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, '${pack%%:*}') == -1
+  augroup filetypedetect
+  " ${pack%%:*}, from ${f##*/ftdetect/} in ${pack#*:}
+$(cat "${f}")
+  augroup end
+endif
+
+EOF
     done
 
   done
@@ -74,47 +85,74 @@ extract() {
   mv tmp/polyglot.vim ftdetect/
 
   for pack in $1; do
-    name="$(printf "$pack" | cut -d ':' -f 1)"
-    path="$(printf "$pack" | cut -d ':' -f 2)"
-    dir="tmp/$(printf "$path" | cut -d '/' -f 2)"
-    subtree="$(printf "$pack" | cut -d ':' -f 4)"
+    name="$(cut -d ':' -f 1 <<<"$pack")"
+    path="$(cut -d ':' -f 2 <<<"$pack")"
+    dir="tmp/$(cut -d '/' -f 2 <<<"$path")"
+    subtree="$(cut -d ':' -f 4 <<<"$pack")"
 
     if [ -d "$dir${subtree:-/}plugin" ]; then
-      printf "Possible error (plugin directory exists): $path\n"
+      echo "Possible error (plugin directory exists): $path" >&2
     fi
   done
 }
 
 copy_dir() {
-  for file in $(find "$1/$2" -name '*.vim' -o -name '*.vital'); do
-    file_path="$(dirname "${file##$1/}")"
-    mkdir -p "$file_path"
-    touch "$file_path/$(basename "$file")"
-
-    # Use comma instead of / to handle cases like c/c++
-    sed -e "s,%%PACK%%,$3," -e "/%%CONTENT%%/{r $file" -e "d;}" plugin_guard.vim.template >> $file_path/$(basename "$file")
+  find "$1/$2" \( -name '*.vim' -o -name '*.vital' \) -print0 | while read -r -d $'\0' file; do
+    copy_file "$1" "$file" "$3"
   done
 }
 
+copy_file() {
+  ## $1 is the build dir (e.g. tmp/vim-go)
+  ## $2 is the full file path, as returned by `find` (e.g. tmp/vim-go/indent/go.vim)
+  ## $3 is the name of the package (so that we can detect if it's disabled at runtime)
+  local tmp_dir="$1"
+  local file_in_tmp="$2"
+  local file_basename="${2##*/}"
+  local file_path="${file_in_tmp##$tmp_dir/}" # Just this file's (full) path
+  file_path="${file_path%/*}"                # Minus the actual name of the file
+  local file_in_dst="${file_path}/${file_basename}" # Could also be ${file_in_tmp##$tmp_dir/}
+  local package_name="$3"
+
+  if [ "${file_in_tmp##$tmp_dir/}" != "${file_in_dst}" ]; then
+    echo "Failure in logic in build script; '${file_in_tmp##$tmp_dir/}' != '${file_in_dst}'.  Bailing." >&2
+    exit 1
+  fi
+
+  mkdir -p "${file_path}"
+  touch "$file_in_dst"
+
+  # Use comma instead of / to handle cases like c/c++
+  sed -e "s,%%PACK%%,${package_name}," -e "/%%CONTENT%%/{r ${file_in_tmp}" -e "d;}" plugin_guard.vim.template >> "$file_in_dst"
+}
+
 update_readme() {
-  OLD_README="$(cat README.md)"
-
-  ed README.md <<- EOF
-/Language packs
-+2kb
-/##
-'b,-2c
-$(printf -- "$OUTPUT" | sort)
-.
-w
-q
-EOF
+  local tf of
+  tf="$(mktemp)"
+  of="$(mktemp)"
+  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="
   apiblueprint:sheerun/apiblueprint.vim
-  applescript:vim-scripts/applescript.vim
+  applescript:mityu/vim-applescript:_SYNTAX
   asciidoc:asciidoc/vim-asciidoc
   yaml:stephpy/vim-yaml
   ansible:pearofducks/ansible-vim
@@ -134,12 +172,13 @@ PACKS="
   cql:elubow/cql-vim
   cucumber:tpope/vim-cucumber
   dart:dart-lang/dart-vim-plugin
-  dockerfile:docker/docker::/contrib/syntax/vim/
+  dockerfile:ekalinin/Dockerfile.vim
   elixir:elixir-lang/vim-elixir
   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
   fsharp:fsharp/vim-fsharp:_BASIC
   git:tpope/vim-git
@@ -147,13 +186,15 @@ PACKS="
   glsl:tikhomirov/vim-glsl
   gnuplot:vim-scripts/gnuplot-syntax-highlighting
   go:fatih/vim-go:_BASIC
+  graphql:jparise/vim-graphql
   groovy:vim-scripts/groovy.vim
   haml:sheerun/vim-haml
   handlebars:mustache/vim-mustache-handlebars
+  haproxy:CH-DanReif/haproxy.vim
   haskell:neovimhaskell/haskell-vim
   haxe:yaymukund/vim-haxe
   html5:othree/html5.vim
-  i3:PotatoesMaster/i3-vim-syntax
+  i3:mboughaba/i3config.vim
   jasmine:glanotte/vim-jasmine
   javascript:pangloss/vim-javascript:_JAVASCRIPT
   jenkins:martinda/Jenkinsfile-vim-syntax
@@ -171,6 +212,7 @@ PACKS="
   mako:sophacles/vim-bundle-mako
   markdown:plasticboy/vim-markdown:_SYNTAX
   mathematica:rsmenon/vim-mathematica
+  moonscript:leafo/moonscript-vim
   nginx:chr4/nginx.vim
   nim:zah/nim.vim:_BASIC
   nix:LnL7/vim-nix
@@ -178,10 +220,12 @@ PACKS="
   ocaml:jrk/vim-ocaml
   octave:vim-scripts/octave.vim--
   opencl:petRUShka/vim-opencl
+  org:jceb/vim-orgmode
   perl:vim-perl/vim-perl
   pgsql:exu/pgsql.vim
   php:StanAngeloff/php.vim
   plantuml:aklt/plantuml-syntax
+  pony:jakwings/vim-pony
   powershell:PProvost/vim-ps1
   protobuf:uarun/vim-protobuf
   pug:digitaltoad/vim-pug
@@ -198,6 +242,7 @@ PACKS="
   rspec:sheerun/rspec.vim
   ruby:vim-ruby/vim-ruby
   rust:rust-lang/rust.vim
+  rst:marshallward/vim-restructuredtext
   sbt:derekwyatt/vim-sbt
   scala:derekwyatt/vim-scala
   scss:cakebaker/scss-syntax.vim
@@ -207,7 +252,7 @@ PACKS="
   stylus:wavded/vim-stylus
   swift:keith/swift.vim
   sxhkd:baskerville/vim-sxhkdrc
-  systemd:kurayama/systemd-vim-syntax
+  systemd:wgwoods/vim-systemd-syntax
   terraform:hashivim/vim-terraform
   textile:timcharper/textile.vim
   thrift:solarnz/thrift.vim
@@ -227,12 +272,12 @@ PACKS="
 "
 
 rm -rf tmp
-rm -rf $DIRS_RM
+rm -rf "${DIRS_RM[@]}"
 mkdir tmp
 
 printf "Downloading packs..."
-download "$PACKS"
-extract "$PACKS"
+download "$(sed '/^#/d' <<<"$PACKS")"
+extract "$(sed '/^#/d' <<<"$PACKS")"
 update_readme
 
 rm -rf tmp

compiler/cargo.vim

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

compiler/credo.vim

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

compiler/eruby.vim

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

compiler/go.vim

@@ -11,6 +11,10 @@ if exists("g:current_compiler")
 endif
 let g:current_compiler = "go"
 
+" don't spam the user when Vim is started in Vi compatibility mode
+let s:cpo_save = &cpo
+set cpo&vim
+
 if exists(":CompilerSet") != 2
   command -nargs=* CompilerSet setlocal <args>
 endif
@@ -40,6 +44,10 @@ CompilerSet errorformat+=%-G%.%#                      " All lines not matching a
 let &cpo = s:save_cpo
 unlet s:save_cpo
 
+" restore Vi compatibility settings
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
 " vim: sw=2 ts=2 et
 
 endif

compiler/mix.vim

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

compiler/nim.vim

@@ -13,7 +13,7 @@ endif
 let s:cpo_save = &cpo
 set cpo-=C
 
-CompilerSet makeprg=nim\ c\ --verbosity:0\ $*\ %:p
+CompilerSet makeprg=nim\ c\ --verbosity:0\ --listfullpaths\ $*\ %:p
 
 CompilerSet errorformat=
   \%-GHint:\ %m,
@@ -23,5 +23,7 @@ CompilerSet errorformat=
 let &cpo = s:cpo_save
 unlet s:cpo_save
 
+let g:syntastic_nim_checkers = ['nim']
+
 
 endif

compiler/nix-build.vim

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

compiler/rake.vim

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

compiler/rspec.vim

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

compiler/ruby.vim

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

compiler/rustc.vim

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

config.vim

@@ -59,7 +59,7 @@ augroup filetypedetect
   autocmd BufNewFile,BufRead .gitsendemail.*                               set ft=gitsendemail
 
   " plantuml
-  autocmd BufRead,BufNewFile *.pu,*.uml,*.plantuml setfiletype plantuml | set filetype=plantuml
+  autocmd BufRead,BufNewFile *.pu,*.uml,*.plantuml,*.puml setfiletype plantuml | set filetype=plantuml
 
   " scala
   au BufRead,BufNewFile *.scala,*.sc set filetype=scala
@@ -69,3 +69,7 @@ augroup filetypedetect
   autocmd BufNewFile,BufRead *.swift set filetype=swift
 augroup END
 
+" Fix for https://github.com/sheerun/vim-polyglot/issues/236#issuecomment-387984954
+if (!exists('g:graphql_javascript_tags'))
+  let g:graphql_javascript_tags = ['gql', 'graphql', 'Relay.QL']
+endif

extras/flow.vim

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

extras/jsdoc.vim

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

ftplugin/Dockerfile.vim

@@ -0,0 +1,31 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'dockerfile') == -1
+  
+function! DockerfileReplaceInstruction(original, replacement)
+    let syn = synIDtrans(synID(line("."), col(".") - 1, 0))
+    if syn != hlID("Comment") && syn != hlID("Constant") && strlen(getline(".")) == 0
+        let word = a:replacement
+    else
+        let word = a:original
+    endif
+    let g:UnduBuffer = a:original
+    return word
+endfunction
+
+inoreabbr <silent> <buffer> from <C-R>=DockerfileReplaceInstruction("from", "FROM")<CR>
+inoreabbr <silent> <buffer> maintainer <C-R>=DockerfileReplaceInstruction("maintainer", "MAINTAINER")<CR>
+inoreabbr <silent> <buffer> run <C-R>=DockerfileReplaceInstruction("run", "RUN")<CR>
+inoreabbr <silent> <buffer> cmd <C-R>=DockerfileReplaceInstruction("cmd", "CMD")<CR>
+inoreabbr <silent> <buffer> label <C-R>=DockerfileReplaceInstruction("label", "LABEL")<CR>
+inoreabbr <silent> <buffer> expose <C-R>=DockerfileReplaceInstruction("expose", "EXPOSE")<CR>
+inoreabbr <silent> <buffer> env <C-R>=DockerfileReplaceInstruction("env", "ENV")<CR>
+inoreabbr <silent> <buffer> add <C-R>=DockerfileReplaceInstruction("add", "ADD")<CR>
+inoreabbr <silent> <buffer> copy <C-R>=DockerfileReplaceInstruction("copy", "COPY")<CR>
+inoreabbr <silent> <buffer> entrypoint <C-R>=DockerfileReplaceInstruction("entrypoint", "ENTRYPOINT")<CR>
+inoreabbr <silent> <buffer> volume <C-R>=DockerfileReplaceInstruction("volume", "VOLUME")<CR>
+inoreabbr <silent> <buffer> user <C-R>=DockerfileReplaceInstruction("user", "USER")<CR>
+inoreabbr <silent> <buffer> workdir <C-R>=DockerfileReplaceInstruction("workdir", "WORKDIR")<CR>
+inoreabbr <silent> <buffer> arg <C-R>=DockerfileReplaceInstruction("arg", "ARG")<CR>
+inoreabbr <silent> <buffer> onbuild <C-R>=DockerfileReplaceInstruction("onbuild", "ONBUILD")<CR>
+inoreabbr <silent> <buffer> stopsignal <C-R>=DockerfileReplaceInstruction("stopsignal", "STOPSIGNAL")<CR>
+
+endif

ftplugin/ansible.vim

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

ftplugin/cabal.vim

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

ftplugin/crystal.vim

@@ -51,6 +51,7 @@ command! -buffer -nargs=? CrystalSpecSwitch call crystal_lang#switch_spec_file(<
 command! -buffer -nargs=? CrystalSpecRunAll call crystal_lang#run_all_spec(<f-args>)
 command! -buffer -nargs=? CrystalSpecRunCurrent call crystal_lang#run_current_spec(<f-args>)
 command! -buffer -nargs=* -bar CrystalFormat call crystal_lang#format(<q-args>, 0)
+command! -buffer -nargs=* CrystalExpand echo crystal_lang#expand(expand('%'), getpos('.'), <q-args>).output
 
 nnoremap <buffer><Plug>(crystal-jump-to-definition) :<C-u>CrystalDef<CR>
 nnoremap <buffer><Plug>(crystal-show-context) :<C-u>CrystalContext<CR>

ftplugin/elixir.vim

@@ -32,11 +32,7 @@ let &l:path =
 setlocal includeexpr=elixir#util#get_filename(v:fname)
 setlocal suffixesadd=.ex,.exs,.eex,.erl,.yrl,.hrl
 
-if empty(&formatprg)
-    setlocal formatprg=mix\ format\ -
-endif
-
-let &l:define = 'def\(macro|guard|delegate\)p'
+let &l:define = 'def\(macro\|guard\|delegate\)\=p\='
 
 silent! setlocal formatoptions-=t formatoptions+=croqlj
 

ftplugin/elm.vim

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

ftplugin/eruby.vim

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

ftplugin/git.vim

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

ftplugin/graphql.vim

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

ftplugin/haml.vim

@@ -3,7 +3,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haml') == -1
 " Vim filetype plugin
 " Language:	Haml
 " Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2010 May 21
+" Last Change:	2016 Aug 29
 
 " Only do this when not done yet for this buffer
 if exists("b:did_ftplugin")
@@ -39,6 +39,8 @@ endif
 runtime! ftplugin/ruby.vim ftplugin/ruby_*.vim ftplugin/ruby/*.vim
 let b:did_ftplugin = 1
 
+let &l:define .= empty(&l:define ? '' : '\|') . '^\s*\%(%\w*\)\=\%(\.[[:alnum:]_-]\+\)*#'
+
 " Combine the new set of values with those previously included.
 if exists("b:undo_ftplugin")
   let s:undo_ftplugin = b:undo_ftplugin . " | " . s:undo_ftplugin
@@ -62,10 +64,11 @@ endif
 
 setlocal comments= commentstring=-#\ %s
 
-let b:undo_ftplugin = "setl cms< com< "
+let b:undo_ftplugin = "setl def< cms< com< "
       \ " | unlet! b:browsefilter b:match_words | " . s:undo_ftplugin
 
 let &cpo = s:save_cpo
+unlet s:save_cpo
 
 " vim:set sw=2:
 

ftplugin/haskell.vim

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

ftplugin/julia.vim

@@ -19,11 +19,12 @@ setlocal comments=:#
 setlocal commentstring=#=%s=#
 setlocal cinoptions+=#1
 setlocal define=^\\s*macro\\>
+setlocal fo-=t fo+=croql
 
 let b:julia_vim_loaded = 1
 
 let b:undo_ftplugin = "setlocal include< suffixesadd< comments< commentstring<"
-      \ . " define< shiftwidth< expandtab< indentexpr< indentkeys< cinoptions< omnifunc<"
+      \ . " define< fo< shiftwidth< expandtab< indentexpr< indentkeys< cinoptions< omnifunc<"
       \ . " | unlet! b:julia_vim_loaded"
 
 " MatchIt plugin support
@@ -33,7 +34,10 @@ if exists("loaded_matchit")
   " note: begin_keywords must contain all blocks in order
   " for nested-structures-skipping to work properly
   let b:julia_begin_keywords = '\%(\%(\.\s*\)\@<!\|\%(@\s*.\s*\)\@<=\)\<\%(\%(staged\)\?function\|macro\|begin\|mutable\s\+struct\|\%(mutable\s\+\)\@<!struct\|\%(abstract\|primitive\)\s\+type\|\%(\(abstract\|primitive\)\s\+\)\@<!type\|immutable\|let\|do\|\%(bare\)\?module\|quote\|if\|for\|while\|try\)\>'
-  let s:macro_regex = '@\%(#\@!\S\)\+\s\+'
+  " note: the following regex not only recognizes macros, but also local/global keywords.
+  " the purpose is recognizing things like `@inline myfunction()`
+  " or `global myfunction(...)` etc, for matchit and block movement functionality
+  let s:macro_regex = '\%(@\%(#\@!\S\)\+\|\<\%(local\|global\)\)\s\+'
   let s:nomacro = '\%(' . s:macro_regex . '\)\@<!'
   let s:yesmacro = s:nomacro . '\%('. s:macro_regex . '\)\+'
   let b:julia_begin_keywordsm = '\%(' . s:yesmacro . b:julia_begin_keywords . '\)\|'
@@ -45,7 +49,7 @@ if exists("loaded_matchit")
     let [l,c] = [line('.'),col('.')]
     let attr = synIDattr(synID(l, c, 1),"name")
     let c1 = c
-    while attr == 'juliaMacro'
+    while attr == 'juliaMacro' || expand('<cword>') =~# '\<\%(global\|local\)\>'
       normal! W
       if line('.') > l || col('.') == c1
         call cursor(l, c)
@@ -93,6 +97,14 @@ if has("gui_win32")
   let b:undo_ftplugin = b:undo_ftplugin . " | unlet! b:browsefilter"
 endif
 
+" Lookup documents
+nnoremap <silent><buffer> <Plug>(JuliaDocPrompt) :<C-u>call julia#doc#prompt()<CR>
+command! -nargs=1 -buffer -complete=customlist,julia#doc#complete JuliaDoc call julia#doc#open(<q-args>)
+command! -nargs=1 -buffer JuliaDocKeywordprg call julia#doc#keywordprg(<q-args>)
+setlocal keywordprg=:JuliaDocKeywordprg
+let b:undo_ftplugin .= " | setlocal keywordprg<"
+let b:undo_ftplugin .= " | delcommand JuliaDoc | delcommand JuliaDocKeywordprg"
+
 let &cpo = s:save_cpo
 unlet s:save_cpo
 

ftplugin/juliadoc.vim

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

ftplugin/moon.vim

@@ -0,0 +1,20 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'moonscript') == -1
+  
+" Language:    MoonScript
+" Maintainer:  leafo <leafot@gmail.com>
+" Based On:    CoffeeScript by Mick Koch <kchmck@gmail.com>
+" URL:         http://github.com/leafo/moonscript-vim
+" License:     WTFPL
+
+if exists("b:did_ftplugin")
+  finish
+endif
+let b:did_ftplugin = 1
+
+setlocal formatoptions-=t
+setlocal comments=:--
+setlocal commentstring=--\ %s
+
+let b:undo_ftplugin = "setlocal commentstring< comments< formatoptions<"
+
+endif

ftplugin/mustache.vim

@@ -1,9 +1,9 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'handlebars') == -1
   
-if exists('g:loaded_mustache_handlebars') && g:loaded_mustache_handlebars
+if exists('b:loaded_mustache_handlebars')
   finish
 endif
-let g:loaded_mustache_handlebars = 1
+let b:loaded_mustache_handlebars = 1
 
 let s:cpo_save = &cpo
 set cpo&vim

ftplugin/nix.vim

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

ftplugin/org.vim

@@ -0,0 +1,173 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'org') == -1
+  
+" org.vim -- Text outlining and task management for Vim based on Emacs' Org-Mode
+" @Author       : Jan Christoph Ebersbach (jceb@e-jc.de)
+" @License      : AGPL3 (see http://www.gnu.org/licenses/agpl.txt)
+" @Created      : 2010-10-03
+" @Last Modified: Tue 13. Sep 2011 20:52:57 +0200 CEST
+" @Revision     : 0.4
+" vi: ft=vim:tw=80:sw=4:ts=4:fdm=marker
+
+if v:version > 702
+	if has('python3')
+		let s:py_version = 'python3 '
+		let s:py_env = 'python3 << EOF'
+	elseif has('python')
+		let s:py_version = 'python '
+		let s:py_env = 'python << EOF'
+	else
+		echoerr "Unable to start orgmode. Orgmode depends on Vim >= 7.3 with Python support complied in."
+		finish
+	endif
+else
+	echoerr "Unable to start orgmode. Orgmode depends on Vim >= 7.3 with Python support complied in."
+	finish
+endif
+
+" Init buffer for file {{{1
+if ! exists('b:did_ftplugin')
+	" default emacs settings
+	setlocal comments=fb:*,b:#,fb:-
+	setlocal commentstring=#\ %s
+	setlocal conceallevel=2 concealcursor=nc
+	" original emacs settings are: setlocal tabstop=6 shiftwidth=6, but because
+	" of checkbox indentation the following settings are used:
+	setlocal tabstop=6 shiftwidth=6
+	if exists('g:org_tag_column')
+		exe 'setlocal textwidth='.g:org_tag_column
+	else
+		setlocal textwidth=77
+	endif
+
+	" expand tab for counting level of checkbox
+	setlocal expandtab
+
+	" enable % for angle brackets < >
+	setlocal matchpairs+=<:>
+
+	" register keybindings if they don't have been registered before
+	if exists("g:loaded_org")
+		exe s:py_version . 'ORGMODE.register_keybindings()'
+	endif
+endif
+
+" Load orgmode just once {{{1
+if &cp || exists("g:loaded_org")
+    finish
+endif
+let g:loaded_org = 1
+
+" Default org plugins that will be loaded (in the given order) {{{2
+if ! exists('g:org_plugins') && ! exists('b:org_plugins')
+	let g:org_plugins = ['ShowHide', '|', 'Navigator', 'EditStructure', 'EditCheckbox', '|', 'Hyperlinks', '|', 'Todo', 'TagsProperties', 'Date', 'Agenda', 'Misc', '|', 'Export']
+endif
+
+" Default org plugin settings {{{2
+" What does this do?
+if ! exists('g:org_syntax_highlight_leading_stars') && ! exists('b:org_syntax_highlight_leading_stars')
+	let g:org_syntax_highlight_leading_stars = 1
+endif
+
+" setting to conceal aggresively
+if ! exists('g:org_aggressive_conceal') && ! exists('b:org_aggressive_conceal')
+	let g:org_aggressive_conceal = 0
+endif
+
+" Defined in separate plugins
+" Adding Behavior preference:
+"       1:          go into insert-mode when new heading/checkbox/plainlist added
+"       0:          retain original mode when new heading/checkbox/plainlist added
+if ! exists('g:org_prefer_insert_mode') && ! exists('b:org_prefer_insert_mode')
+    let g:org_prefer_insert_mode = 1
+endif
+
+" Menu and document handling {{{1
+function! <SID>OrgRegisterMenu()
+	exe s:py_version . 'ORGMODE.register_menu()'
+endfunction
+
+function! <SID>OrgUnregisterMenu()
+	exe s:py_version . 'ORGMODE.unregister_menu()'
+endfunction
+
+function! <SID>OrgDeleteUnusedDocument(bufnr)
+	exe s:py_env
+b = int(vim.eval('a:bufnr'))
+if b in ORGMODE._documents:
+	del ORGMODE._documents[b]
+EOF
+endfunction
+
+" show and hide Org menu depending on the filetype
+augroup orgmode
+	au BufEnter * :if &filetype == "org" | call <SID>OrgRegisterMenu() | endif
+	au BufLeave * :if &filetype == "org" | call <SID>OrgUnregisterMenu() | endif
+	au BufDelete * :call <SID>OrgDeleteUnusedDocument(expand('<abuf>'))
+augroup END
+
+" Start orgmode {{{1
+" Expand our path
+exec s:py_env
+import vim, os, sys
+
+for p in vim.eval("&runtimepath").split(','):
+	dname = os.path.join(p, "ftplugin")
+	if os.path.exists(os.path.join(dname, "orgmode")):
+		if dname not in sys.path:
+			sys.path.append(dname)
+			break
+
+from orgmode._vim import ORGMODE, insert_at_cursor, get_user_input, date_to_str
+ORGMODE.start()
+
+from Date import Date
+import datetime
+EOF
+
+" 3rd Party Plugin Integration {{{1
+" * Repeat {{{2
+try
+	call repeat#set()
+catch
+endtry
+
+" * Tagbar {{{2
+let g:tagbar_type_org = {
+			\ 'ctagstype' : 'org',
+			\ 'kinds'     : [
+				\ 's:sections',
+				\ 'h:hyperlinks',
+			\ ],
+			\ 'sort'    : 0,
+			\ 'deffile' : expand('<sfile>:p:h') . '/org.cnf'
+			\ }
+
+" * Taglist {{{2
+if exists('g:Tlist_Ctags_Cmd')
+	" Pass parameters to taglist
+	let g:tlist_org_settings = 'org;s:section;h:hyperlinks'
+	let g:Tlist_Ctags_Cmd .= ' --options=' . expand('<sfile>:p:h') . '/org.cnf '
+endif
+
+" * Calendar.vim {{{2
+fun CalendarAction(day, month, year, week, dir)
+	let g:org_timestamp = printf("%04d-%02d-%02d Fri", a:year, a:month, a:day)
+	let datetime_date = printf("datetime.date(%d, %d, %d)", a:year, a:month, a:day)
+	exe s:py_version . "selected_date = " . datetime_date
+	" get_user_input
+	let msg = printf("Inserting %s | Modify date", g:org_timestamp)
+	exe s:py_version . "modifier = get_user_input('" . msg . "')"
+	" change date according to user input
+	exe s:py_version . "newdate = Date._modify_time(selected_date, modifier)"
+	exe s:py_version . "newdate = date_to_str(newdate)"
+	" close Calendar
+	exe "q"
+	" goto previous window
+	exe "wincmd p"
+	exe s:py_version . "timestamp = '" . g:org_timestamp_template . "' % newdate"
+	exe s:py_version . "insert_at_cursor(timestamp)"
+	" restore calendar_action
+	let g:calendar_action = g:org_calendar_action_backup
+endf
+
+endif

ftplugin/pony.vim

@@ -0,0 +1,44 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'pony') == -1
+  
+" Vim filetype plugin file
+" Language:     Pony
+" Maintainer:   Jak Wings
+
+if exists('b:did_ftplugin')
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+
+setlocal comments=://,nsr:/*,mb:*,ex:*/
+setlocal commentstring=/*%s*/
+setlocal formatoptions-=t fo+=c fo+=r fo+=o fo+=q fo+=l fo+=j
+
+"setlocal path=
+"setlocal includeexpr=
+setlocal include=\\v^\\s*use\\_s+%(\\i+\\_s*\\=\\_s*)?"\\zs[^"]*\\ze"
+setlocal define=\\v^\\s*%(actor\|class\|struct\|primitive\|trait\|interface\|type\|new\|be\|fun\|let\|var\|embed\|use\|for\\_s+%(\\i+\\_s*,\\_s*)*\|with\\_s+%(\\i+\\_s*,\\_s*)*)\|(<\\i+\\_s*:\\_s*\\i+)@=
+setlocal isident=@,48-57,_,39
+setlocal iskeyword=@,48-57,_,39
+setlocal suffixesadd=.pony
+setlocal matchpairs=(:),{:},[:]
+
+let b:match_ignorecase = 0
+let b:match_skip = 's:Comment\|String\|Character\|CaseGuard'
+let b:match_words = '\v<%(ifdef|if|match|while|for|repeat|try|with|recover|object|lambda|iftype)>\m:\v<%(then|elseif|else|until|do|in|elseiftype)>|\|\m:\<end\>,(:),\[:\],{:}'
+" TODO: for more concise behavior
+"let b:match_words = 'pony#GetMatchWords()'
+source $VIMRUNTIME/macros/matchit.vim
+
+let b:undo_ftplugin = 'set comments< commentstring< formatoptions< path< include< includeexpr< define< isident< iskeyword< suffixesadd< matchpairs<'
+      \ . ' | unlet! b:match_ignorecase b:match_skip b:match_words'
+
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+let b:did_ftplugin = 1
+
+endif

ftplugin/purescript.vim

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

ftplugin/rst.vim

@@ -0,0 +1,46 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rst') == -1
+  
+" reStructuredText filetype plugin file
+" Language: reStructuredText documentation format
+" Maintainer: Marshall Ward <marshall.ward@gmail.com>
+" Original Maintainer: Nikolai Weibull <now@bitwi.se>
+" Website: https://github.com/marshallward/vim-restructuredtext
+" Latest Revision: 2018-01-07
+
+if exists("b:did_ftplugin")
+    finish
+endif
+let b:did_ftplugin = 1
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+let b:undo_ftplugin = "setl com< cms< et< fo<"
+
+setlocal comments=fb:.. commentstring=..\ %s expandtab
+setlocal formatoptions+=tcroql
+
+" reStructuredText standard recommends that tabs be expanded to 8 spaces
+" The choice of 3-space indentation is to provide slightly better support for
+" directives (..) and ordered lists (1.), although it can cause problems for
+" many other cases.
+"
+" More sophisticated indentation rules should be revisted in the future.
+
+if !exists("g:rst_style") || g:rst_style != 0
+    setlocal expandtab shiftwidth=3 softtabstop=3 tabstop=8
+endif
+
+if has('patch-7.3.867')  " Introduced the TextChanged event.
+  setlocal foldmethod=expr
+  setlocal foldexpr=RstFold#GetRstFold()
+  setlocal foldtext=RstFold#GetRstFoldText()
+  augroup RstFold
+    autocmd TextChanged,InsertLeave <buffer> unlet! b:RstFoldCache
+  augroup END
+endif
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+endif

ftplugin/ruby.vim

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

ftplugin/rust.vim

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

ftplugin/rust/tagbar.vim

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

ftplugin/slim.vim

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

ftplugin/terraform.vim

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

ftplugin/twig.vim

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

ftplugin/vue.vim

@@ -5,7 +5,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vue') == -1
 " Maintainer: Eduardo San Martin Morote
 " Author: Adriaan Zonnenberg
 
-if exists("b:did_ftplugin")
+if exists('b:did_ftplugin')
   finish
 endif
 
@@ -20,11 +20,4 @@ if !exists('g:no_plugin_maps') && !exists('g:no_vue_maps')
   nnoremap <silent> <buffer> ][ :call search('^</\(template\<Bar>script\<Bar>style\)', 'W')<CR>
 endif
 
-if exists('g:loaded_ale')
-  let g:ale_linters = get(g:, 'ale_linters', {})
-  let g:ale_linters.vue = get(g:ale_linters, 'vue', ['eslint'])
-  let g:ale_linter_aliases = get(g:, 'ale_linter_aliases', {})
-  let g:ale_linter_aliases.vue = get(g:ale_linter_aliases, 'vue', 'javascript')
-endif
-
 endif

indent/Dockerfile.vim

@@ -0,0 +1,27 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'dockerfile') == -1
+  
+if exists('b:did_indent') | finish | endif
+let b:did_indent = 1
+
+
+function! DockerfileIndent(line)
+  let prev_line = getline(a:line - 1)
+  if a:line > 1 && prev_line =~ '\\\s*$'
+    let i = indent(a:line - 1)
+    if i == 0
+      let i += &l:shiftwidth
+      if &l:expandtab && prev_line =~# '^RUN\s'
+        " Overindent past RUN
+        let i = 4 + &l:shiftwidth
+      endif
+    endif
+    return i
+  endif
+
+  return -1
+endfunction
+
+
+set indentexpr=DockerfileIndent(v:lnum)
+
+endif

indent/applescript.vim

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

indent/crystal.vim

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

indent/cython.vim

@@ -36,6 +36,19 @@ if !exists('g:python_pep8_indent_multiline_string')
     let g:python_pep8_indent_multiline_string = 0
 endif
 
+if !exists('g:python_pep8_indent_hang_closing')
+    let g:python_pep8_indent_hang_closing = 0
+endif
+
+" TODO: check required patch for timeout argument, likely lower than 7.3.429 though.
+if !exists('g:python_pep8_indent_searchpair_timeout')
+    if has('patch-8.0.1483')
+        let g:python_pep8_indent_searchpair_timeout = 150
+    else
+        let g:python_pep8_indent_searchpair_timeout = 0
+    endif
+endif
+
 let s:block_rules = {
             \ '^\s*elif\>': ['if', 'elif'],
             \ '^\s*except\>': ['try', 'except'],
@@ -55,29 +68,35 @@ else
 endif
 let s:stop_statement = '^\s*\(break\|continue\|raise\|return\|pass\)\>'
 
-" Skip strings and comments. Return 1 for chars to skip.
-" jedi* refers to syntax definitions from jedi-vim for call signatures, which
-" are inserted temporarily into the buffer.
-let s:skip_special_chars = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
-            \ '=~? "\\vstring|comment|jedi\\S"'
-
 let s:skip_after_opening_paren = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
             \ '=~? "\\vcomment|jedi\\S"'
 
-" Also ignore anything concealed.
-" Wrapper around synconcealed for older Vim (7.3.429, used on Travis CI).
-function! s:is_concealed(line, col)
-    let concealed = synconcealed(a:line, a:col)
-    return len(concealed) && concealed[0]
-endfunction
-if has('conceal')
-    let s:skip_special_chars .= '|| s:is_concealed(line("."), col("."))'
+if !get(g:, 'python_pep8_indent_skip_concealed', 0) || !has('conceal')
+    " Skip strings and comments. Return 1 for chars to skip.
+    " jedi* refers to syntax definitions from jedi-vim for call signatures, which
+    " are inserted temporarily into the buffer.
+    function! s:_skip_special_chars(line, col)
+        return synIDattr(synID(a:line, a:col, 0), 'name')
+                \ =~? "\\vstring|comment|^pythonbytes%(contents)=$|jedi\\S"
+    endfunction
+else
+    " Also ignore anything concealed.
+    " TODO: doc; likely only necessary with jedi-vim, where a better version is
+    " planned (https://github.com/Vimjas/vim-python-pep8-indent/pull/98).
+
+    " Wrapper around synconcealed for older Vim (7.3.429, used on Travis CI).
+    function! s:is_concealed(line, col)
+        let concealed = synconcealed(a:line, a:col)
+        return len(concealed) && concealed[0]
+    endfunction
+
+    function! s:_skip_special_chars(line, col)
+        return synIDattr(synID(a:line, a:col, 0), 'name')
+                \ =~? "\\vstring|comment|^pythonbytes%(contents)=$|jedi\\S"
+                \ || s:is_concealed(a:line, a:col)
+    endfunction
 endif
 
-
-let s:skip_search = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
-            \ '=~? "comment"'
-
 " Use 'shiftwidth()' instead of '&sw'.
 " (Since Vim patch 7.3.629, 'shiftwidth' can be set to 0 to follow 'tabstop').
 if exists('*shiftwidth')
@@ -90,33 +109,22 @@ else
     endfunction
 endif
 
-function! s:pair_sort(x, y)
-    if a:x[0] == a:y[0]
-        return a:x[1] == a:y[1] ? 0 : a:x[1] > a:y[1] ? 1 : -1
-    else
-        return a:x[0] > a:y[0] ? 1 : -1
-    endif
-endfunction
-
 " Find backwards the closest open parenthesis/bracket/brace.
-function! s:find_opening_paren(...)
-    " optional arguments: line and column (defaults to 1) to search around
-    if a:0 > 0
-        let view = winsaveview()
-        call cursor(a:1, a:0 > 1 ? a:2 : 1)
-        let ret = s:find_opening_paren()
-        call winrestview(view)
-        return ret
+function! s:find_opening_paren(lnum, col)
+    " Return if cursor is in a comment.
+    if synIDattr(synID(a:lnum, a:col, 0), 'name') =~? 'comment'
+        return [0, 0]
     endif
 
-    " Return if cursor is in a comment.
-    exe 'if' s:skip_search '| return [0, 0] | endif'
+    call cursor(a:lnum, a:col)
 
     let nearest = [0, 0]
+    let timeout = g:python_pep8_indent_searchpair_timeout
+    let skip_special_chars = 's:_skip_special_chars(line("."), col("."))'
     for [p, maxoff] in items(s:paren_pairs)
         let stopline = max([0, line('.') - maxoff, nearest[0]])
         let next = searchpairpos(
-           \ '\V'.p[0], '', '\V'.p[1], 'bnW', s:skip_special_chars, stopline)
+           \ '\V'.p[0], '', '\V'.p[1], 'bnW', skip_special_chars, stopline, timeout)
         if next[0] && (next[0] > nearest[0] || (next[0] == nearest[0] && next[1] > nearest[1]))
             let nearest = next
         endif
@@ -131,7 +139,7 @@ function! s:find_start_of_multiline_statement(lnum)
         if getline(lnum - 1) =~# '\\$'
             let lnum = prevnonblank(lnum - 1)
         else
-            let [paren_lnum, _] = s:find_opening_paren(lnum)
+            let [paren_lnum, _] = s:find_opening_paren(lnum, 1)
             if paren_lnum < 1
                 return lnum
             else
@@ -144,27 +152,21 @@ endfunction
 " Find possible indent(s) of the block starter that matches the current line.
 function! s:find_start_of_block(lnum, types, multiple)
     let r = []
-    let types = copy(a:types)
     let re = '\V\^\s\*\('.join(a:types, '\|').'\)\>'
     let lnum = a:lnum
     let last_indent = indent(lnum) + 1
     while lnum > 0 && last_indent > 0
         let indent = indent(lnum)
         if indent < last_indent
-            for type in types
-                let re = '\v^\s*'.type.'>'
-                if getline(lnum) =~# re
-                    if !a:multiple
-                        return [indent]
-                    endif
-                    if index(r, indent) == -1
-                        let r += [indent]
-                    endif
-                    " Remove any handled type, e.g. 'if'.
-                    call remove(types, index(types, type))
+            if getline(lnum) =~# re
+                if !a:multiple
+                    return [indent]
                 endif
-            endfor
-            let last_indent = indent(lnum)
+                if index(r, indent) == -1
+                    let r += [indent]
+                endif
+                let last_indent = indent
+            endif
         endif
         let lnum = prevnonblank(lnum - 1)
     endwhile
@@ -194,7 +196,7 @@ endfunction
 
 " Line up with open parenthesis/bracket/brace.
 function! s:indent_like_opening_paren(lnum)
-    let [paren_lnum, paren_col] = s:find_opening_paren(a:lnum)
+    let [paren_lnum, paren_col] = s:find_opening_paren(a:lnum, 1)
     if paren_lnum <= 0
         return -2
     endif
@@ -205,8 +207,11 @@ function! s:indent_like_opening_paren(lnum)
                 \ s:skip_after_opening_paren, paren_lnum, paren_col+1)
     let starts_with_closing_paren = getline(a:lnum) =~# '^\s*[])}]'
 
+    let hang_closing = get(b:, 'python_pep8_indent_hang_closing',
+                \ get(g:, 'python_pep8_indent_hang_closing', 0))
+
     if nothing_after_opening_paren
-        if starts_with_closing_paren
+        if starts_with_closing_paren && !hang_closing
             let res = base
         else
             let res = base + s:sw()
@@ -220,10 +225,13 @@ function! s:indent_like_opening_paren(lnum)
     " indent further to distinguish the continuation line
     " from the next logical line.
     if text =~# b:control_statement && res == base + s:sw()
-        return base + s:sw() * 2
-    else
-        return res
+        " But only if not inside parens itself (Flake's E127).
+        let [paren_lnum, _] = s:find_opening_paren(paren_lnum, 1)
+        if paren_lnum <= 0
+            return res + s:sw()
+        endif
     endif
+    return res
 endfunction
 
 " Match indent of first block of this type.
@@ -271,24 +279,23 @@ function! s:indent_like_previous_line(lnum)
     let base = indent(start)
     let current = indent(a:lnum)
 
-    " Jump to last character in previous line.
-    call cursor(lnum, len(text))
-    let ignore_last_char = eval(s:skip_special_chars)
+    " Ignore last character in previous line?
+    let lastcol = len(text)
+    let col = lastcol
 
     " Search for final colon that is not inside something to be ignored.
     while 1
-        let curpos = getpos('.')[2]
-        if curpos == 1 | break | endif
-        if eval(s:skip_special_chars) || text[curpos-1] =~# '\s'
-            normal! h
+        if col == 1 | break | endif
+        if text[col-1] =~# '\s' || s:_skip_special_chars(lnum, col)
+            let col = col - 1
             continue
-        elseif text[curpos-1] ==# ':'
+        elseif text[col-1] ==# ':'
             return base + s:sw()
         endif
         break
     endwhile
 
-    if text =~# '\\$' && !ignore_last_char
+    if text =~# '\\$' && !s:_skip_special_chars(lnum, lastcol)
         " If this line is the continuation of a control statement
         " indent further to distinguish the continuation line
         " from the next logical line.
@@ -319,7 +326,7 @@ function! s:indent_like_previous_line(lnum)
         return -1
     endif
 
-    if !empty && s:is_dedented_already(current, base)
+    if (current || !empty) && s:is_dedented_already(current, base)
         return -1
     endif
 
@@ -337,11 +344,11 @@ endfunction
 " Is the syntax at lnum (and optionally cnum) a python string?
 function! s:is_python_string(lnum, ...)
     let line = getline(a:lnum)
-    let linelen = len(line)
-    if linelen < 1
-      let linelen = 1
+    if a:0
+      let cols = type(a:1) != type([]) ? [a:1] : a:1
+    else
+      let cols = range(1, max([1, len(line)]))
     endif
-    let cols = a:0 ? type(a:1) != type([]) ? [a:1] : a:1 : range(1, linelen)
     for cnum in cols
         if match(map(synstack(a:lnum, cnum),
                     \ "synIDattr(v:val, 'name')"), 'python\S*String') == -1
@@ -361,7 +368,7 @@ function! GetPythonPEPIndent(lnum)
     let prevline = getline(a:lnum-1)
 
     " Multilinestrings: continous, docstring or starting.
-    if s:is_python_string(a:lnum-1, len(prevline))
+    if s:is_python_string(a:lnum-1, max([1, len(prevline)]))
                 \ && (s:is_python_string(a:lnum, 1)
                 \     || match(line, '^\%("""\|''''''\)') != -1)
 
@@ -370,17 +377,18 @@ function! GetPythonPEPIndent(lnum)
         if match_quotes != -1
             " closing multiline string
             let quotes = line[match_quotes:(match_quotes+2)]
-            let pairpos = searchpairpos(quotes, '', quotes, 'b')
+            call cursor(a:lnum, 1)
+            let pairpos = searchpairpos(quotes, '', quotes, 'bW', '', 0, g:python_pep8_indent_searchpair_timeout)
             if pairpos[0] != 0
                 return indent(pairpos[0])
             else
-                " TODO: test to cover this!
+                return -1
             endif
         endif
 
         if s:is_python_string(a:lnum-1)
-            " Previous line is (completely) a string.
-            return indent(a:lnum-1)
+            " Previous line is (completely) a string: keep current indent.
+            return -1
         endif
 
         if match(prevline, '^\s*\%("""\|''''''\)') != -1

indent/dart.vim

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

indent/eruby.vim

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

indent/go.vim

@@ -26,18 +26,11 @@ if exists("*GoIndent")
   finish
 endif
 
-" use shiftwidth function only if it's available
-if exists('*shiftwidth')
-  func s:sw()
-    return shiftwidth()
-  endfunc
-else
-  func s:sw()
-    return &sw
-  endfunc
-endif
+" don't spam the user when Vim is started in Vi compatibility mode
+let s:cpo_save = &cpo
+set cpo&vim
 
-function! GoIndent(lnum)
+function! GoIndent(lnum) abort
   let prevlnum = prevnonblank(a:lnum-1)
   if prevlnum == 0
     " top of file
@@ -51,19 +44,30 @@ function! GoIndent(lnum)
 
   let ind = previ
 
+  for synid in synstack(a:lnum, 1)
+    if synIDattr(synid, 'name') == 'goRawString'
+      if prevl =~ '\%(\%(:\?=\)\|(\|,\)\s*`[^`]*$'
+        " previous line started a multi-line raw string
+        return 0
+      endif
+      " return -1 to keep the current indent.
+      return -1
+    endif
+  endfor
+
   if prevl =~ '[({]\s*$'
     " previous line opened a block
-    let ind += s:sw()
+    let ind += shiftwidth()
   endif
   if prevl =~# '^\s*\(case .*\|default\):$'
     " previous line is part of a switch statement
-    let ind += s:sw()
+    let ind += shiftwidth()
   endif
   " TODO: handle if the previous line is a label.
 
   if thisl =~ '^\s*[)}]'
     " this line closed a block
-    let ind -= s:sw()
+    let ind -= shiftwidth()
   endif
 
   " Colons are tricky.
@@ -71,12 +75,16 @@ function! GoIndent(lnum)
   " We ignore trying to deal with jump labels because (a) they're rare, and
   " (b) they're hard to disambiguate from a composite literal key.
   if thisl =~# '^\s*\(case .*\|default\):$'
-    let ind -= s:sw()
+    let ind -= shiftwidth()
   endif
 
   return ind
 endfunction
 
+" restore Vi compatibility settings
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
 " vim: sw=2 ts=2 et
 
 endif

indent/gohtmltmpl.vim

@@ -15,6 +15,10 @@ if exists("*GetGoHTMLTmplIndent")
   finish
 endif
 
+" don't spam the user when Vim is started in Vi compatibility mode
+let s:cpo_save = &cpo
+set cpo&vim
+
 function! GetGoHTMLTmplIndent(lnum)
   " Get HTML indent
   if exists('*HtmlIndent')
@@ -45,6 +49,10 @@ function! GetGoHTMLTmplIndent(lnum)
   return ind
 endfunction
 
+" restore Vi compatibility settings
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
 " vim: sw=2 ts=2 et
 
 endif

indent/graphql.vim

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

indent/haml.vim

@@ -3,7 +3,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haml') == -1
 " Vim indent file
 " Language:	Haml
 " Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2010 May 21
+" Last Change:	2016 Aug 29
 
 if exists("b:did_indent")
   finish
@@ -12,7 +12,7 @@ runtime! indent/ruby.vim
 unlet! b:did_indent
 let b:did_indent = 1
 
-setlocal autoindent sw=2 et
+setlocal autoindent
 setlocal indentexpr=GetHamlIndent()
 setlocal indentkeys=o,O,*<Return>,},],0),!^F,=end,=else,=elsif,=rescue,=ensure,=when
 

indent/handlebars.vim

@@ -4,8 +4,8 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'handlebars') ==
 " Language:	Mustache, Handlebars
 " Maintainer:	Juvenn Woo <machese@gmail.com>
 " Screenshot:   http://imgur.com/6F408
-" Version:	2
-" Last Change:  Oct 10th 2015
+" Version:	3
+" Last Change:  26 Nov 2018
 " Remarks: based on eruby indent plugin by tpope
 " References:
 "   [Mustache](http://github.com/defunkt/mustache)
@@ -21,6 +21,9 @@ endif
 unlet! b:did_indent
 setlocal indentexpr=
 
+" keep track of whether or not we are in a block expression for indenting
+unlet! s:in_block_expr
+
 runtime! indent/html.vim
 unlet! b:did_indent
 
@@ -75,26 +78,48 @@ function! GetHandlebarsIndent(...)
     let b:indent.lnum = -1
   endif
   let lnum = prevnonblank(v:lnum-1)
-  let line = getline(lnum)
-  let cline = getline(v:lnum)
+  let prevLine = getline(lnum)
+  let currentLine = getline(v:lnum)
 
   " all indent rules only apply if the block opening/closing
   " tag is on a separate line
 
   " indent after block {{#block
-  if line =~# '\v\s*\{\{\#.*\s*'
+  if prevLine =~# '\v\s*\{\{\#.*\s*'
+    let s:in_block_expr = 1
     let ind = ind + sw
   endif
-  " unindent after block close {{/block}}
-  if cline =~# '\v^\s*\{\{\/\S*\}\}\s*'
+  " but not if the block ends on the same line
+  if prevLine =~# '\v\s*\{\{\#(.+)(\s+|\}\}).*\{\{\/\1'
+    let s:in_block_expr = 0
     let ind = ind - sw
   endif
+  " unindent after block close {{/block}}
+  if currentLine =~# '\v^\s*\{\{\/\S*\}\}\s*'
+    let s:in_block_expr = 0
+    let ind = ind - sw
+  endif
+  " indent after component block {{a-component
+  if prevLine =~# '\v\s*\{\{\w'
+    let s:in_block_expr = 0
+    let ind = ind + sw
+  endif
+  " but not if the component block ends on the same line
+  if prevLine =~# '\v\s*\{\{\w(.+)\}\}'
+    let ind = ind - sw
+  endif
+  " unindent }} lines, and following lines if not inside a block expression
+  if currentLine =~# '\v^\s*\}\}\s*$' || (currentLine !~# '\v^\s*\{\{\/' && prevLine =~# '\v^\s*[^\{\} \t]+\}\}\s*$')
+    if !s:in_block_expr
+      let ind = ind - sw
+    endif
+  endif
   " unindent {{else}}
-  if cline =~# '\v^\s*\{\{else.*\}\}\s*$'
+  if currentLine =~# '\v^\s*\{\{else.*\}\}\s*$'
     let ind = ind - sw
   endif
   " indent again after {{else}}
-  if line =~# '\v^\s*\{\{else.*\}\}\s*$'
+  if prevLine =~# '\v^\s*\{\{else.*\}\}\s*$'
     let ind = ind + sw
   endif
 

indent/haskell.vim

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

indent/javascript.vim

@@ -89,22 +89,22 @@ function s:SynAt(l,c)
 endfunction
 
 function s:ParseCino(f)
-  let [divider, n, cstr] = [0] + matchlist(&cino,
-        \ '\%(.*,\)\=\%(\%d'.char2nr(a:f).'\(-\)\=\([.s0-9]*\)\)\=')[1:2]
-  for c in split(cstr,'\zs')
-    if c == '.' && !divider
+  let [s, n, divider] = [strridx(&cino, a:f)+1, '', 0]
+  while s && &cino[ s ] =~ '[^,]'
+    if &cino[ s ] == '.'
       let divider = 1
-    elseif c ==# 's'
+    elseif &cino[ s ] ==# 's'
       if n !~ '\d'
         return n . s:sw() + 0
       endif
       let n = str2nr(n) * s:sw()
       break
     else
-      let [n, divider] .= [c, 0]
+      let [n, divider] .= [&cino[ s ], 0]
     endif
-  endfor
-  return str2nr(n) / max([str2nr(divider),1])
+    let s += 1
+  endwhile
+  return str2nr(n) / max([divider, 1])
 endfunction
 
 " Optimized {skip} expr, only callable from the search loop which
@@ -208,18 +208,15 @@ function s:ExprCol()
   let bal = 0
   while s:SearchLoop('[{}?:]','bW',s:skip_expr)
     if s:LookingAt() == ':'
-      if getline('.')[col('.')-2] == ':'
-        call cursor(0,col('.')-1)
-        continue
-      endif
-      let bal -= 1
+      let bal -= !search('\m:\%#','bW')
     elseif s:LookingAt() == '?'
       if getline('.')[col('.'):col('.')+1] =~ '^\.\d\@!'
-        continue
+        " ?. conditional chain, not ternary start
       elseif !bal
         return 1
+      else
+        let bal += 1
       endif
-      let bal += 1
     elseif s:LookingAt() == '{'
       return !s:IsBlock()
     elseif !s:GetPair('{','}','bW',s:skip_expr)
@@ -316,8 +313,8 @@ function s:IsContOne(cont)
 endfunction
 
 function s:IsSwitch()
-  return search('\m\C\%'.join(b:js_cache[1:],'l\%').
-        \ 'c{\_s*\%(\%(\/\/.*\_$\|\/\*\_.\{-}\*\/\)\@>\_s*\)*\%(case\|default\)\>','nW'.s:z)
+  return search(printf('\m\C\%%%dl\%%%dc%s',b:js_cache[1],b:js_cache[2],
+        \ '{\_s*\%(\%(\/\/.*\_$\|\/\*\_.\{-}\*\/\)\@>\_s*\)*\%(case\|default\)\>'),'nW'.s:z)
 endfunction
 
 " https://github.com/sweet-js/sweet.js/wiki/design#give-lookbehind-to-the-reader
@@ -367,8 +364,8 @@ function GetJavascriptIndent()
     return -1
   endif
 
-  let s:l1 = max([0,prevnonblank(v:lnum) - (s:rel ? 2000 : 1000),
-        \ get(get(b:,'hi_indent',{}),'blocklnr')])
+  let nest = get(get(b:,'hi_indent',{}),'blocklnr')
+  let s:l1 = max([0, prevnonblank(v:lnum) - (s:rel ? 2000 : 1000), nest])
   call cursor(v:lnum,1)
   if s:PreviousToken() is ''
     return
@@ -376,7 +373,7 @@ function GetJavascriptIndent()
   let [l:lnum, lcol, pline] = getpos('.')[1:2] + [getline('.')[:col('.')-1]]
 
   let l:line = substitute(l:line,'^\s*','','')
-  let l:line_raw = l:line
+  let l:line_s = l:line[0]
   if l:line[:1] == '/*'
     let l:line = substitute(l:line,'^\%(\/\*.\{-}\*\/\s*\)*','','')
   endif
@@ -450,7 +447,7 @@ function GetJavascriptIndent()
     let pval = s:ParseCino('(')
     if !pval
       let [Wval, vcol] = [s:ParseCino('W'), virtcol('.')]
-      if search('\m\S','W',num)
+      if search('\m'.get(g:,'javascript_indent_W_pat','\S'),'W',num)
         return s:ParseCino('w') ? vcol : virtcol('.')-1
       endif
       return Wval ? s:Nat(num_ind + Wval) : vcol
@@ -460,7 +457,7 @@ function GetJavascriptIndent()
 
   " main return
   if l:line =~ '^[])}]\|^|}'
-    if l:line_raw[0] == ')'
+    if l:line_s == ')'
       if s:ParseCino('M')
         return indent(l:lnum)
       elseif num && &cino =~# 'm' && !s:ParseCino('m')
@@ -470,10 +467,8 @@ function GetJavascriptIndent()
     return num_ind
   elseif num
     return s:Nat(num_ind + get(l:,'case_offset',s:sw()) + l:switch_offset + b_l + is_op)
-  endif
-  let nest = get(get(b:,'hi_indent',{}),'blocklnr')
-  if nest
-    return indent(nest) + s:sw() + b_l + is_op
+  elseif nest
+    return indent(nextnonblank(nest+1)) + b_l + is_op
   endif
   return b_l + is_op
 endfunction

indent/julia.vim

@@ -21,19 +21,19 @@ if exists("*GetJuliaIndent")
   finish
 endif
 
-let s:skipPatterns = '\<julia\%(Comprehension\%(For\|If\)\|RangeEnd\|CommentL\|\%([bsv]\|ip\|big\|MIME\|Shell\|Printf\|Doc\)\=String\|RegEx\|SymbolS\?\)\>'
+let s:skipPatterns = '\<julia\%(Comprehension\%(For\|If\)\|RangeEnd\|Comment[LM]\|\%([bsv]\|ip\|big\|MIME\|Shell\|Printf\|Doc\)\=String\|RegEx\|SymbolS\?\)\>'
 
 function JuliaMatch(lnum, str, regex, st, ...)
   let s = a:st
   let e = a:0 > 0 ? a:1 : -1
   while 1
-    let f = match(a:str, a:regex, s)
+    let f = match(a:str, '\C' . a:regex, s)
     if e >= 0 && f >= e
       return -1
     endif
     if f >= 0
       let attr = synIDattr(synID(a:lnum,f+1,1),"name")
-      if attr =~ s:skipPatterns
+      if attr =~# s:skipPatterns
         let s = f+1
         continue
       endif
@@ -50,8 +50,9 @@ function GetJuliaNestingStruct(lnum, ...)
   let e = a:0 > 1 ? a:2 : -1
   let blocks_stack = []
   let num_closed_blocks = 0
+  let tt = get(b:, 'julia_syntax_version', 10) == 6 ? '\|\%(\%(abstract\|primitive\)\s\+\)\@<!type' : ''
   while 1
-    let fb = JuliaMatch(a:lnum, line, '@\@<!\<\%(if\|else\%(if\)\=\|while\|for\|try\|catch\|finally\|\%(staged\)\?function\|macro\|begin\|mutable\s\+struct\|\%(mutable\s\+\)\@<!struct\|\%(abstract\|primitive\)\s\+type\|\%(\%(abstract\|primitive\)\s\+\)\@<!type\|immutable\|let\|\%(bare\)\?module\|quote\|do\)\>', s, e)
+    let fb = JuliaMatch(a:lnum, line, '@\@<!\<\%(if\|else\%(if\)\?\|while\|for\|try\|catch\|finally\|\%(staged\)\?function\|macro\|begin\|mutable\s\+struct\|\%(mutable\s\+\)\@<!struct\|\%(abstract\|primitive\)\s\+type\|immutable\|let\|\%(bare\)\?module\|quote\|do'.tt.'\)\>', s, e)
     let fe = JuliaMatch(a:lnum, line, '@\@<!\<end\>', s, e)
 
     if fb < 0 && fe < 0
@@ -84,7 +85,7 @@ function GetJuliaNestingStruct(lnum, ...)
       let i = JuliaMatch(a:lnum, line, '@\@<!\<else\>', s)
       if i >= 0 && i == fb
         let s = i+1
-        if len(blocks_stack) > 0 && blocks_stack[-1] =~ '\<\%(else\)\=if\>'
+        if len(blocks_stack) > 0 && blocks_stack[-1] =~# '\<\%(else\)\=if\>'
           let blocks_stack[-1] = 'else'
         else
           call add(blocks_stack, 'else')
@@ -133,9 +134,9 @@ function GetJuliaNestingStruct(lnum, ...)
         continue
       endif
 
-      let i = JuliaMatch(a:lnum, line, '@\@<!\<\%(while\|for\|\%(staged\)\?function\|macro\|begin\|\%(mutable\s\+\)\?struct\|\%(\%(abstract\|primitive\)\s\+\)\?type\|immutable\|let\|quote\|do\)\>', s)
+      let i = JuliaMatch(a:lnum, line, '@\@<!\<\%(while\|for\|\%(staged\)\?function\|macro\|begin\|\%(mutable\s\+\)\?struct\|\%(abstract\|primitive\)\s\+type\|immutable\|let\|quote\|do'.tt.'\)\>', s)
       if i >= 0 && i == fb
-        if match(line, '\<\%(mutable\|abstract\|primitive\)', i) != -1
+        if match(line, '\C\<\%(mutable\|abstract\|primitive\)', i) != -1
           let s = i+11
         else
           let s = i+1
@@ -290,16 +291,11 @@ function LastBlockIndent(lnum)
 endfunction
 
 function GetJuliaIndent()
-  let s:save_ignorecase = &ignorecase
-  set noignorecase
-
   " Find a non-blank line above the current line.
   let lnum = prevnonblank(v:lnum - 1)
 
   " At the start of the file use zero indent.
   if lnum == 0
-    let &ignorecase = s:save_ignorecase
-    unlet s:save_ignorecase
     return 0
   endif
 
@@ -387,8 +383,6 @@ function GetJuliaIndent()
     let num_closed_blocks -= 1
   endwhile
 
-  let &ignorecase = s:save_ignorecase
-  unlet s:save_ignorecase
   return ind
 endfunction
 

indent/lua.vim

@@ -113,7 +113,7 @@ function GetLuaIndent()
   " restore cursor
   call setpos(".", original_cursor_pos)
 
-  return indent(prev_line) + (&sw * i)
+  return indent(prev_line) + (shiftwidth() * i)
 
 endfunction
 

indent/markdown.vim

@@ -7,15 +7,15 @@ setlocal indentexpr=GetMarkdownIndent()
 setlocal nolisp
 setlocal autoindent
 
-" Automatically insert bullets
-setlocal formatoptions+=r
-" Do not automatically insert bullets when auto-wrapping with text-width
-setlocal formatoptions-=c
-" Accept various markers as bullets
-setlocal comments=b:*,b:+,b:-
-
 " Automatically continue blockquote on line break
-setlocal comments+=b:>
+setlocal formatoptions+=r
+setlocal comments=b:>
+if get(g:, "vim_markdown_auto_insert_bullets", 1)
+    " Do not automatically insert bullets when auto-wrapping with text-width
+    setlocal formatoptions-=c
+    " Accept various markers as bullets
+    setlocal comments+=b:*,b:+,b:-
+endif
 
 " Only define the function once
 if exists("*GetMarkdownIndent") | finish | endif

indent/moon.vim

@@ -0,0 +1,327 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'moonscript') == -1
+  
+" Language:    MoonScript
+" Maintainer:  leafo <leafot@gmail.com>
+" Based On:    CoffeeScript by Mick Koch <kchmck@gmail.com>
+" URL:         http://github.com/leafo/moonscript-vim
+" License:     WTFPL
+
+if exists("b:did_indent")
+  finish
+endif
+
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentexpr=GetMoonIndent(v:lnum)
+" Make sure GetMoonIndent is run when these are typed so they can be
+" indented or outdented.
+setlocal indentkeys+=0],0),0.,=else,=elseif
+
+" Only define the function once.
+if exists("*GetMoonIndent")
+  finish
+endif
+
+" Keywords to indent after
+let s:INDENT_AFTER_KEYWORD = '^\%(if\|unless\|else\|for\|while\|with\|elseif\|'
+\                          . 'class\|switch\|when\)\>'
+
+" Operators to indent after
+let s:INDENT_AFTER_OPERATOR = '\%([([{:=]\|[-=]>\)$'
+
+" Keywords and operators that continue a line
+let s:CONTINUATION = '\<\%(is\|isnt\|and\|or\)\>$'
+\                  . '\|'
+\                  . '\%(-\@<!-\|+\@<!+\|<\|[-=]\@<!>\|\%(export \)\@<!\*\|/\@<!/\|%\||\|'
+\                  . '&\|,\|\.\@<!\.\)$'
+
+" Operators that block continuation indenting
+let s:CONTINUATION_BLOCK = '[([{:=]$'
+
+" A continuation dot access
+let s:DOT_ACCESS = '^\.'
+
+" Keywords to outdent after
+let s:OUTDENT_AFTER = '^\%(return\|break\)\>'
+
+" A compound assignment like `... = if ...`
+let s:COMPOUND_ASSIGNMENT = '[:=]\s*\%(if\|unless\|for\|while\|'
+\                         . 'with\|class\)\>'
+
+" A postfix condition like `return ... if ...`.
+let s:POSTFIX_CONDITION = '\S\s\+\zs\<\%(if\|unless\)\>'
+
+" A single-line else statement like `else ...` but not `else if ...
+let s:SINGLE_LINE_ELSE = '^else\s\+\%(\<\%(if\)\>\)\@!'
+
+" Max lines to look back for a match
+let s:MAX_LOOKBACK = 50
+
+" Syntax names for strings
+let s:SYNTAX_STRING = 'moon\%(String\|AssignString\|Embed\|Regex\|Heregex\|'
+\                   . 'Heredoc\)'
+
+" Syntax names for comments
+let s:SYNTAX_COMMENT = 'moon\%(Comment\|BlockComment\|HeregexComment\)'
+
+" Syntax names for strings and comments
+let s:SYNTAX_STRING_COMMENT = s:SYNTAX_STRING . '\|' . s:SYNTAX_COMMENT
+
+" Get the linked syntax name of a character.
+function! s:SyntaxName(linenum, col)
+  return synIDattr(synID(a:linenum, a:col, 1), 'name')
+endfunction
+
+" Check if a character is in a comment.
+function! s:IsComment(linenum, col)
+  return s:SyntaxName(a:linenum, a:col) =~ s:SYNTAX_COMMENT
+endfunction
+
+" Check if a character is in a string.
+function! s:IsString(linenum, col)
+  return s:SyntaxName(a:linenum, a:col) =~ s:SYNTAX_STRING
+endfunction
+
+" Check if a character is in a comment or string.
+function! s:IsCommentOrString(linenum, col)
+  return s:SyntaxName(a:linenum, a:col) =~ s:SYNTAX_STRING_COMMENT
+endfunction
+
+" Check if a whole line is a comment.
+function! s:IsCommentLine(linenum)
+  " Check the first non-whitespace character.
+  return s:IsComment(a:linenum, indent(a:linenum) + 1)
+endfunction
+
+" Repeatedly search a line for a regex until one is found outside a string or
+" comment.
+function! s:SmartSearch(linenum, regex)
+  " Start at the first column.
+  let col = 0
+
+  " Search until there are no more matches, unless a good match is found.
+  while 1
+    call cursor(a:linenum, col + 1)
+    let [_, col] = searchpos(a:regex, 'cn', a:linenum)
+
+    " No more matches.
+    if !col
+      break
+    endif
+
+    if !s:IsCommentOrString(a:linenum, col)
+      return 1
+    endif
+  endwhile
+
+  " No good match found.
+  return 0
+endfunction
+
+" Skip a match if it's in a comment or string, is a single-line statement that
+" isn't adjacent, or is a postfix condition.
+function! s:ShouldSkip(startlinenum, linenum, col)
+  if s:IsCommentOrString(a:linenum, a:col)
+    return 1
+  endif
+
+  " Check for a single-line statement that isn't adjacent.
+  if s:SmartSearch(a:linenum, '\<then\>') && a:startlinenum - a:linenum > 1
+    return 1
+  endif
+
+  if s:SmartSearch(a:linenum, s:POSTFIX_CONDITION) &&
+  \ !s:SmartSearch(a:linenum, s:COMPOUND_ASSIGNMENT)
+    return 1
+  endif
+
+  return 0
+endfunction
+
+" Find the farthest line to look back to, capped to line 1 (zero and negative
+" numbers cause bad things).
+function! s:MaxLookback(startlinenum)
+  return max([1, a:startlinenum - s:MAX_LOOKBACK])
+endfunction
+
+" Get the skip expression for searchpair().
+function! s:SkipExpr(startlinenum)
+  return "s:ShouldSkip(" . a:startlinenum . ", line('.'), col('.'))"
+endfunction
+
+" Search for pairs of text.
+function! s:SearchPair(start, end)
+  " The cursor must be in the first column for regexes to match.
+  call cursor(0, 1)
+
+  let startlinenum = line('.')
+
+  " Don't need the W flag since MaxLookback caps the search to line 1.
+  return searchpair(a:start, '', a:end, 'bcn',
+  \                 s:SkipExpr(startlinenum),
+  \                 s:MaxLookback(startlinenum))
+endfunction
+
+" Try to find a previous matching line.
+function! s:GetMatch(curline)
+  let firstchar = a:curline[0]
+
+  if firstchar == '}'
+    return s:SearchPair('{', '}')
+  elseif firstchar == ')'
+    return s:SearchPair('(', ')')
+  elseif firstchar == ']'
+    return s:SearchPair('\[', '\]')
+  elseif a:curline =~ '^else\>'
+    return s:SearchPair('\<\%(if\|unless\|when\)\>', '\<else\>')
+"  elseif a:curline =~ '^catch\>'
+"    return s:SearchPair('\<try\>', '\<catch\>')
+"  elseif a:curline =~ '^finally\>'
+"    return s:SearchPair('\<try\>', '\<finally\>')
+  endif
+
+  return 0
+endfunction
+
+" Get the nearest previous line that isn't a comment.
+function! s:GetPrevNormalLine(startlinenum)
+  let curlinenum = a:startlinenum
+
+  while curlinenum > 0
+    let curlinenum = prevnonblank(curlinenum - 1)
+
+    if !s:IsCommentLine(curlinenum)
+      return curlinenum
+    endif
+  endwhile
+
+  return 0
+endfunction
+
+" Try to find a comment in a line.
+function! s:FindComment(linenum)
+  let col = 0
+
+  while 1
+    call cursor(a:linenum, col + 1)
+    let [_, col] = searchpos('#', 'cn', a:linenum)
+
+    if !col
+      break
+    endif
+
+    if s:IsComment(a:linenum, col)
+      return col
+    endif
+  endwhile
+
+  return 0
+endfunction
+
+" Get a line without comments or surrounding whitespace.
+function! s:GetTrimmedLine(linenum)
+  let comment = 0
+  " let comment = s:FindComment(a:linenum)
+  let line = getline(a:linenum)
+
+  if comment
+    " Subtract 1 to get to the column before the comment and another 1 for
+    " zero-based indexing.
+    let line = line[:comment - 2]
+  endif
+
+  return substitute(substitute(line, '^\s\+', '', ''),
+  \                                  '\s\+$', '', '')
+endfunction
+
+function! s:GetMoonIndent(curlinenum)
+  let prevlinenum = s:GetPrevNormalLine(a:curlinenum)
+
+  " Don't do anything if there's no previous line.
+  if !prevlinenum
+    return -1
+  endif
+
+  let curline = s:GetTrimmedLine(a:curlinenum)
+
+  " Try to find a previous matching statement. This handles outdenting.
+  let matchlinenum = s:GetMatch(curline)
+
+  if matchlinenum
+    return indent(matchlinenum)
+  endif
+
+"  " Try to find a matching `when`.
+"  if curline =~ '^when\>' && !s:SmartSearch(prevlinenum, '\<switch\>')
+"    let linenum = a:curlinenum
+"
+"    while linenum > 0
+"      let linenum = s:GetPrevNormalLine(linenum)
+"
+"      if getline(linenum) =~ '^\s*when\>'
+"        return indent(linenum)
+"      endif
+"    endwhile
+"
+"    return -1
+"  endif
+
+  let prevline = s:GetTrimmedLine(prevlinenum)
+  let previndent = indent(prevlinenum)
+
+  " Always indent after these operators.
+  if prevline =~ s:INDENT_AFTER_OPERATOR
+    return previndent + &shiftwidth
+  endif
+
+  " Indent after a continuation if it's the first.
+  if prevline =~ s:CONTINUATION
+    let prevprevlinenum = s:GetPrevNormalLine(prevlinenum)
+    let prevprevline = s:GetTrimmedLine(prevprevlinenum)
+
+    if prevprevline !~ s:CONTINUATION && prevprevline !~ s:CONTINUATION_BLOCK
+      return previndent + &shiftwidth
+    endif
+
+    return -1
+  endif
+
+  " Indent after these keywords and compound assignments if they aren't a
+  " single-line statement.
+  if prevline =~ s:INDENT_AFTER_KEYWORD || prevline =~ s:COMPOUND_ASSIGNMENT
+    if !s:SmartSearch(prevlinenum, '\<then\>') && prevline !~ s:SINGLE_LINE_ELSE
+      return previndent + &shiftwidth
+    endif
+
+    return -1
+  endif
+
+  " Indent a dot access if it's the first.
+  if curline =~ s:DOT_ACCESS && prevline !~ s:DOT_ACCESS
+    return previndent + &shiftwidth
+  endif
+
+  " Outdent after these keywords if they don't have a postfix condition or are
+  " a single-line statement.
+  if prevline =~ s:OUTDENT_AFTER
+    if !s:SmartSearch(prevlinenum, s:POSTFIX_CONDITION) ||
+    \   s:SmartSearch(prevlinenum, '\<then\>')
+      return previndent - &shiftwidth
+    endif
+  endif
+
+  " No indenting or outdenting is needed.
+  return -1
+endfunction
+
+" Wrap s:GetMoonIndent to keep the cursor position.
+function! GetMoonIndent(curlinenum)
+  let oldcursor = getpos('.')
+  let indent = s:GetMoonIndent(a:curlinenum)
+  call setpos('.', oldcursor)
+
+  return indent
+endfunction
+
+endif

indent/nix.vim

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

indent/org.vim

@@ -0,0 +1,137 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'org') == -1
+  
+" Delete the next line to avoid the special indention of items
+if !exists("g:org_indent")
+  let g:org_indent = 0
+endif
+
+setlocal foldtext=GetOrgFoldtext()
+setlocal fillchars-=fold:-
+setlocal fillchars+=fold:\ 
+setlocal foldexpr=GetOrgFolding()
+setlocal foldmethod=expr
+setlocal indentexpr=GetOrgIndent()
+setlocal nolisp
+setlocal nosmartindent
+setlocal autoindent
+
+if has('python3')
+	let s:py_env = 'python3 << EOF'
+else
+	let s:py_env = 'python << EOF'
+endif
+
+function! GetOrgIndent()
+	if g:org_indent == 0
+		return -1
+	endif
+
+exe s:py_env
+from orgmode._vim import indent_orgmode
+indent_orgmode()
+EOF
+
+	if exists('b:indent_level')
+		let l:tmp = b:indent_level
+		unlet b:indent_level
+		return l:tmp
+	else
+		return -1
+	endif
+endfunction
+
+function! GetOrgFolding()
+	let l:mode = mode()
+	if l:mode == 'i'
+		" the cache size is limited to 3, because vim queries the current and
+		" both surrounding lines when the user is typing in insert mode. The
+		" cache is shared between GetOrgFolding and GetOrgFoldtext
+		if ! exists('b:org_folding_cache')
+			let b:org_folding_cache = {}
+		endif
+
+		if has_key(b:org_folding_cache, v:lnum)
+			if match(b:org_folding_cache[v:lnum], '^>') == 0 &&
+						\ match(getline(v:lnum), '^\*\+\s') != 0
+				" when the user pastes text or presses enter, it happens that
+				" the cache starts to confuse vim's folding abilities
+				" these entries can safely be removed
+				unlet b:org_folding_cache[v:lnum]
+
+				" the fold text cache is probably also damaged, delete it as
+				" well
+				unlet! b:org_foldtext_cache
+			else
+				return b:org_folding_cache[v:lnum]
+			endif
+		endif
+
+		exe s:py_env
+from orgmode._vim import fold_orgmode
+fold_orgmode(allow_dirty=True)
+EOF
+	else
+
+		exe s:py_env
+from orgmode._vim import fold_orgmode
+fold_orgmode()
+EOF
+	endif
+
+	if exists('b:fold_expr')
+		let l:tmp = b:fold_expr
+		unlet b:fold_expr
+		if l:mode == 'i'
+			if ! has_key(b:org_folding_cache, v:lnum)
+				if len(b:org_folding_cache) > 3
+					let b:org_folding_cache = {}
+				endif
+				let b:org_folding_cache[v:lnum] = l:tmp
+			endif
+		endif
+		return l:tmp
+	else
+		return -1
+	endif
+endfunction
+
+function! SetOrgFoldtext(text)
+	let b:foldtext = a:text
+endfunction
+
+function! GetOrgFoldtext()
+	let l:mode = mode()
+	if l:mode == 'i'
+		" add a separate cache for fold text
+		if ! exists('b:org_foldtext_cache') ||
+					\ ! has_key(b:org_foldtext_cache, 'timestamp') ||
+					\ b:org_foldtext_cache['timestamp'] > (localtime() + 10)
+			let b:org_foldtext_cache = {'timestamp': localtime()}
+		endif
+
+		if has_key(b:org_foldtext_cache, v:foldstart)
+			return b:org_foldtext_cache[v:foldstart]
+		endif
+		exe s:py_env
+from orgmode._vim import fold_text
+fold_text(allow_dirty=True)
+EOF
+	else
+		unlet! b:org_foldtext_cache
+		exec s:py_env
+from orgmode._vim import fold_text
+fold_text()
+EOF
+	endif
+
+	if exists('b:foldtext')
+		let l:tmp = b:foldtext
+		unlet b:foldtext
+		if l:mode == 'i'
+			let b:org_foldtext_cache[v:foldstart] = l:tmp
+		endif
+		return l:tmp
+	endif
+endfunction
+
+endif

indent/pony.vim

@@ -0,0 +1,41 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'pony') == -1
+  
+" Vim indent file
+" Language:     Pony
+" Maintainer:   Jak Wings
+
+if exists('b:did_indent')
+  finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+
+setlocal nolisp
+setlocal nocindent
+setlocal nosmartindent
+setlocal autoindent
+setlocal indentexpr=pony#Indent()
+setlocal indentkeys=!^F,o,O,0\|,0(,0),0[,0],0{,0},0==>,0=\"\"\",0=end,0=then,0=else,0=in,0=do,0=until,0=actor,0=class,0=struct,0=primitive,0=trait,0=interface,0=new,0=be,0=fun,0=type,0=use
+setlocal cinkeys=!^F,o,O,0\|,0(,0),0[,0],0{,0},0==>,0=\"\"\",0=end,0=then,0=else,0=in,0=do,0=until,0=actor,0=class,0=struct,0=primitive,0=trait,0=interface,0=new,0=be,0=fun,0=type,0=use
+setlocal cinwords=ifdef,if,match,while,for,repeat,try,with,recover,object,lambda,then,elseif,else,until,do,actor,class,struct,primitive,trait,interface,new,be,fun,iftype,elseiftype
+
+augroup pony
+  autocmd! * <buffer>
+  autocmd CursorHold <buffer> call pony#ClearTrailingSpace(1, 1)
+  "autocmd InsertEnter <buffer> call pony#ClearTrailingSpace(0, 0)
+  autocmd InsertLeave <buffer> call pony#ClearTrailingSpace(0, 1)
+  autocmd BufWritePre <buffer> call pony#ClearTrailingSpace(1, 0, 1)
+augroup END
+
+let b:undo_indent = 'set lisp< cindent< autoindent< smartindent< indentexpr< indentkeys< cinkeys< cinwords<'
+      \ . ' | execute("autocmd! pony * <buffer>")'
+
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+let b:did_indent = 1
+
+endif

indent/purescript.vim

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

indent/python.vim

@@ -36,6 +36,19 @@ if !exists('g:python_pep8_indent_multiline_string')
     let g:python_pep8_indent_multiline_string = 0
 endif
 
+if !exists('g:python_pep8_indent_hang_closing')
+    let g:python_pep8_indent_hang_closing = 0
+endif
+
+" TODO: check required patch for timeout argument, likely lower than 7.3.429 though.
+if !exists('g:python_pep8_indent_searchpair_timeout')
+    if has('patch-8.0.1483')
+        let g:python_pep8_indent_searchpair_timeout = 150
+    else
+        let g:python_pep8_indent_searchpair_timeout = 0
+    endif
+endif
+
 let s:block_rules = {
             \ '^\s*elif\>': ['if', 'elif'],
             \ '^\s*except\>': ['try', 'except'],
@@ -55,29 +68,35 @@ else
 endif
 let s:stop_statement = '^\s*\(break\|continue\|raise\|return\|pass\)\>'
 
-" Skip strings and comments. Return 1 for chars to skip.
-" jedi* refers to syntax definitions from jedi-vim for call signatures, which
-" are inserted temporarily into the buffer.
-let s:skip_special_chars = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
-            \ '=~? "\\vstring|comment|jedi\\S"'
-
 let s:skip_after_opening_paren = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
             \ '=~? "\\vcomment|jedi\\S"'
 
-" Also ignore anything concealed.
-" Wrapper around synconcealed for older Vim (7.3.429, used on Travis CI).
-function! s:is_concealed(line, col)
-    let concealed = synconcealed(a:line, a:col)
-    return len(concealed) && concealed[0]
-endfunction
-if has('conceal')
-    let s:skip_special_chars .= '|| s:is_concealed(line("."), col("."))'
+if !get(g:, 'python_pep8_indent_skip_concealed', 0) || !has('conceal')
+    " Skip strings and comments. Return 1 for chars to skip.
+    " jedi* refers to syntax definitions from jedi-vim for call signatures, which
+    " are inserted temporarily into the buffer.
+    function! s:_skip_special_chars(line, col)
+        return synIDattr(synID(a:line, a:col, 0), 'name')
+                \ =~? "\\vstring|comment|^pythonbytes%(contents)=$|jedi\\S"
+    endfunction
+else
+    " Also ignore anything concealed.
+    " TODO: doc; likely only necessary with jedi-vim, where a better version is
+    " planned (https://github.com/Vimjas/vim-python-pep8-indent/pull/98).
+
+    " Wrapper around synconcealed for older Vim (7.3.429, used on Travis CI).
+    function! s:is_concealed(line, col)
+        let concealed = synconcealed(a:line, a:col)
+        return len(concealed) && concealed[0]
+    endfunction
+
+    function! s:_skip_special_chars(line, col)
+        return synIDattr(synID(a:line, a:col, 0), 'name')
+                \ =~? "\\vstring|comment|^pythonbytes%(contents)=$|jedi\\S"
+                \ || s:is_concealed(a:line, a:col)
+    endfunction
 endif
 
-
-let s:skip_search = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
-            \ '=~? "comment"'
-
 " Use 'shiftwidth()' instead of '&sw'.
 " (Since Vim patch 7.3.629, 'shiftwidth' can be set to 0 to follow 'tabstop').
 if exists('*shiftwidth')
@@ -90,33 +109,22 @@ else
     endfunction
 endif
 
-function! s:pair_sort(x, y)
-    if a:x[0] == a:y[0]
-        return a:x[1] == a:y[1] ? 0 : a:x[1] > a:y[1] ? 1 : -1
-    else
-        return a:x[0] > a:y[0] ? 1 : -1
-    endif
-endfunction
-
 " Find backwards the closest open parenthesis/bracket/brace.
-function! s:find_opening_paren(...)
-    " optional arguments: line and column (defaults to 1) to search around
-    if a:0 > 0
-        let view = winsaveview()
-        call cursor(a:1, a:0 > 1 ? a:2 : 1)
-        let ret = s:find_opening_paren()
-        call winrestview(view)
-        return ret
+function! s:find_opening_paren(lnum, col)
+    " Return if cursor is in a comment.
+    if synIDattr(synID(a:lnum, a:col, 0), 'name') =~? 'comment'
+        return [0, 0]
     endif
 
-    " Return if cursor is in a comment.
-    exe 'if' s:skip_search '| return [0, 0] | endif'
+    call cursor(a:lnum, a:col)
 
     let nearest = [0, 0]
+    let timeout = g:python_pep8_indent_searchpair_timeout
+    let skip_special_chars = 's:_skip_special_chars(line("."), col("."))'
     for [p, maxoff] in items(s:paren_pairs)
         let stopline = max([0, line('.') - maxoff, nearest[0]])
         let next = searchpairpos(
-           \ '\V'.p[0], '', '\V'.p[1], 'bnW', s:skip_special_chars, stopline)
+           \ '\V'.p[0], '', '\V'.p[1], 'bnW', skip_special_chars, stopline, timeout)
         if next[0] && (next[0] > nearest[0] || (next[0] == nearest[0] && next[1] > nearest[1]))
             let nearest = next
         endif
@@ -131,7 +139,7 @@ function! s:find_start_of_multiline_statement(lnum)
         if getline(lnum - 1) =~# '\\$'
             let lnum = prevnonblank(lnum - 1)
         else
-            let [paren_lnum, _] = s:find_opening_paren(lnum)
+            let [paren_lnum, _] = s:find_opening_paren(lnum, 1)
             if paren_lnum < 1
                 return lnum
             else
@@ -144,27 +152,21 @@ endfunction
 " Find possible indent(s) of the block starter that matches the current line.
 function! s:find_start_of_block(lnum, types, multiple)
     let r = []
-    let types = copy(a:types)
     let re = '\V\^\s\*\('.join(a:types, '\|').'\)\>'
     let lnum = a:lnum
     let last_indent = indent(lnum) + 1
     while lnum > 0 && last_indent > 0
         let indent = indent(lnum)
         if indent < last_indent
-            for type in types
-                let re = '\v^\s*'.type.'>'
-                if getline(lnum) =~# re
-                    if !a:multiple
-                        return [indent]
-                    endif
-                    if index(r, indent) == -1
-                        let r += [indent]
-                    endif
-                    " Remove any handled type, e.g. 'if'.
-                    call remove(types, index(types, type))
+            if getline(lnum) =~# re
+                if !a:multiple
+                    return [indent]
                 endif
-            endfor
-            let last_indent = indent(lnum)
+                if index(r, indent) == -1
+                    let r += [indent]
+                endif
+                let last_indent = indent
+            endif
         endif
         let lnum = prevnonblank(lnum - 1)
     endwhile
@@ -194,7 +196,7 @@ endfunction
 
 " Line up with open parenthesis/bracket/brace.
 function! s:indent_like_opening_paren(lnum)
-    let [paren_lnum, paren_col] = s:find_opening_paren(a:lnum)
+    let [paren_lnum, paren_col] = s:find_opening_paren(a:lnum, 1)
     if paren_lnum <= 0
         return -2
     endif
@@ -205,8 +207,11 @@ function! s:indent_like_opening_paren(lnum)
                 \ s:skip_after_opening_paren, paren_lnum, paren_col+1)
     let starts_with_closing_paren = getline(a:lnum) =~# '^\s*[])}]'
 
+    let hang_closing = get(b:, 'python_pep8_indent_hang_closing',
+                \ get(g:, 'python_pep8_indent_hang_closing', 0))
+
     if nothing_after_opening_paren
-        if starts_with_closing_paren
+        if starts_with_closing_paren && !hang_closing
             let res = base
         else
             let res = base + s:sw()
@@ -220,10 +225,13 @@ function! s:indent_like_opening_paren(lnum)
     " indent further to distinguish the continuation line
     " from the next logical line.
     if text =~# b:control_statement && res == base + s:sw()
-        return base + s:sw() * 2
-    else
-        return res
+        " But only if not inside parens itself (Flake's E127).
+        let [paren_lnum, _] = s:find_opening_paren(paren_lnum, 1)
+        if paren_lnum <= 0
+            return res + s:sw()
+        endif
     endif
+    return res
 endfunction
 
 " Match indent of first block of this type.
@@ -271,24 +279,23 @@ function! s:indent_like_previous_line(lnum)
     let base = indent(start)
     let current = indent(a:lnum)
 
-    " Jump to last character in previous line.
-    call cursor(lnum, len(text))
-    let ignore_last_char = eval(s:skip_special_chars)
+    " Ignore last character in previous line?
+    let lastcol = len(text)
+    let col = lastcol
 
     " Search for final colon that is not inside something to be ignored.
     while 1
-        let curpos = getpos('.')[2]
-        if curpos == 1 | break | endif
-        if eval(s:skip_special_chars) || text[curpos-1] =~# '\s'
-            normal! h
+        if col == 1 | break | endif
+        if text[col-1] =~# '\s' || s:_skip_special_chars(lnum, col)
+            let col = col - 1
             continue
-        elseif text[curpos-1] ==# ':'
+        elseif text[col-1] ==# ':'
             return base + s:sw()
         endif
         break
     endwhile
 
-    if text =~# '\\$' && !ignore_last_char
+    if text =~# '\\$' && !s:_skip_special_chars(lnum, lastcol)
         " If this line is the continuation of a control statement
         " indent further to distinguish the continuation line
         " from the next logical line.
@@ -319,7 +326,7 @@ function! s:indent_like_previous_line(lnum)
         return -1
     endif
 
-    if !empty && s:is_dedented_already(current, base)
+    if (current || !empty) && s:is_dedented_already(current, base)
         return -1
     endif
 
@@ -337,11 +344,11 @@ endfunction
 " Is the syntax at lnum (and optionally cnum) a python string?
 function! s:is_python_string(lnum, ...)
     let line = getline(a:lnum)
-    let linelen = len(line)
-    if linelen < 1
-      let linelen = 1
+    if a:0
+      let cols = type(a:1) != type([]) ? [a:1] : a:1
+    else
+      let cols = range(1, max([1, len(line)]))
     endif
-    let cols = a:0 ? type(a:1) != type([]) ? [a:1] : a:1 : range(1, linelen)
     for cnum in cols
         if match(map(synstack(a:lnum, cnum),
                     \ "synIDattr(v:val, 'name')"), 'python\S*String') == -1
@@ -361,7 +368,7 @@ function! GetPythonPEPIndent(lnum)
     let prevline = getline(a:lnum-1)
 
     " Multilinestrings: continous, docstring or starting.
-    if s:is_python_string(a:lnum-1, len(prevline))
+    if s:is_python_string(a:lnum-1, max([1, len(prevline)]))
                 \ && (s:is_python_string(a:lnum, 1)
                 \     || match(line, '^\%("""\|''''''\)') != -1)
 
@@ -370,17 +377,18 @@ function! GetPythonPEPIndent(lnum)
         if match_quotes != -1
             " closing multiline string
             let quotes = line[match_quotes:(match_quotes+2)]
-            let pairpos = searchpairpos(quotes, '', quotes, 'b')
+            call cursor(a:lnum, 1)
+            let pairpos = searchpairpos(quotes, '', quotes, 'bW', '', 0, g:python_pep8_indent_searchpair_timeout)
             if pairpos[0] != 0
                 return indent(pairpos[0])
             else
-                " TODO: test to cover this!
+                return -1
             endif
         endif
 
         if s:is_python_string(a:lnum-1)
-            " Previous line is (completely) a string.
-            return indent(a:lnum-1)
+            " Previous line is (completely) a string: keep current indent.
+            return -1
         endif
 
         if match(prevline, '^\s*\%("""\|''''''\)') != -1

indent/ruby.vim

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

indent/rust.vim

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

indent/swift.vim

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

spec/loading_spec.rb

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