mirror of https://github.com/amix/vimrc.git
Amir Salihefendic
7 years ago
commit
36019409b7
@ -0,0 +1,89 @@ |
||||
ack.vim is distributed under the same license terms as Vim itself, which you |
||||
can find in full with `:help license` within Vim, or copied in full herein. |
||||
|
||||
Copyright (c) 2007-2015 Antoine Imbert <antoine.imbert+ackvim@gmail.com> |
||||
and contributors. |
||||
|
||||
Maintainers may be contacted via GitHub Issues at: |
||||
|
||||
https://github.com/mileszs/ack.vim/issues |
||||
|
||||
|
||||
VIM LICENSE |
||||
|
||||
I) There are no restrictions on distributing unmodified copies of Vim except |
||||
that they must include this license text. You can also distribute |
||||
unmodified parts of Vim, likewise unrestricted except that they must |
||||
include this license text. You are also allowed to include executables |
||||
that you made from the unmodified Vim sources, plus your own usage |
||||
examples and Vim scripts. |
||||
|
||||
II) It is allowed to distribute a modified (or extended) version of Vim, |
||||
including executables and/or source code, when the following four |
||||
conditions are met: |
||||
1) This license text must be included unmodified. |
||||
2) The modified Vim must be distributed in one of the following five ways: |
||||
a) If you make changes to Vim yourself, you must clearly describe in |
||||
the distribution how to contact you. When the maintainer asks you |
||||
(in any way) for a copy of the modified Vim you distributed, you |
||||
must make your changes, including source code, available to the |
||||
maintainer without fee. The maintainer reserves the right to |
||||
include your changes in the official version of Vim. What the |
||||
maintainer will do with your changes and under what license they |
||||
will be distributed is negotiable. If there has been no negotiation |
||||
then this license, or a later version, also applies to your changes. |
||||
The current maintainer is Bram Moolenaar <Bram@vim.org>. If this |
||||
changes it will be announced in appropriate places (most likely |
||||
vim.sf.net, www.vim.org and/or comp.editors). When it is completely |
||||
impossible to contact the maintainer, the obligation to send him |
||||
your changes ceases. Once the maintainer has confirmed that he has |
||||
received your changes they will not have to be sent again. |
||||
b) If you have received a modified Vim that was distributed as |
||||
mentioned under a) you are allowed to further distribute it |
||||
unmodified, as mentioned at I). If you make additional changes the |
||||
text under a) applies to those changes. |
||||
c) Provide all the changes, including source code, with every copy of |
||||
the modified Vim you distribute. This may be done in the form of a |
||||
context diff. You can choose what license to use for new code you |
||||
add. The changes and their license must not restrict others from |
||||
making their own changes to the official version of Vim. |
||||
d) When you have a modified Vim which includes changes as mentioned |
||||
under c), you can distribute it without the source code for the |
||||
changes if the following three conditions are met: |
||||
- The license that applies to the changes permits you to distribute |
||||
the changes to the Vim maintainer without fee or restriction, and |
||||
permits the Vim maintainer to include the changes in the official |
||||
version of Vim without fee or restriction. |
||||
- You keep the changes for at least three years after last |
||||
distributing the corresponding modified Vim. When the maintainer |
||||
or someone who you distributed the modified Vim to asks you (in |
||||
any way) for the changes within this period, you must make them |
||||
available to him. |
||||
- You clearly describe in the distribution how to contact you. This |
||||
contact information must remain valid for at least three years |
||||
after last distributing the corresponding modified Vim, or as long |
||||
as possible. |
||||
e) When the GNU General Public License (GPL) applies to the changes, |
||||
you can distribute the modified Vim under the GNU GPL version 2 or |
||||
any later version. |
||||
3) A message must be added, at least in the output of the ":version" |
||||
command and in the intro screen, such that the user of the modified Vim |
||||
is able to see that it was modified. When distributing as mentioned |
||||
under 2)e) adding the message is only required for as far as this does |
||||
not conflict with the license used for the changes. |
||||
4) The contact information as required under 2)a) and 2)d) must not be |
||||
removed or changed, except that the person himself can make |
||||
corrections. |
||||
|
||||
III) If you distribute a modified version of Vim, you are encouraged to use |
||||
the Vim license for your changes and make them available to the |
||||
maintainer, including the source code. The preferred way to do this is |
||||
by e-mail or by uploading the files to a server and e-mailing the URL. |
||||
If the number of changes is small (e.g., a modified Makefile) e-mailing a |
||||
context diff will do. The e-mail address to be used is |
||||
<maintainer@vim.org> |
||||
|
||||
IV) It is not allowed to remove this license from the distribution of the Vim |
||||
sources, parts of it or from a modified version. You may use this |
||||
license for previous Vim releases instead of the license that they came |
||||
with, at your option. |
||||
@ -0,0 +1 @@ |
||||
/doc/tags |
||||
@ -0,0 +1,30 @@ |
||||
# rust.vim |
||||
|
||||
## Description |
||||
|
||||
This is a vim plugin provides [Rust][r] file detection and syntax highlighting. |
||||
|
||||
It is synchronized daily to the vim support code in [rust-lang/rust][rr]'s |
||||
master branch via cronjob. |
||||
|
||||
## Installation |
||||
|
||||
### Using [Vundle][v] |
||||
|
||||
1. Add `Plugin 'wting/rust.vim'` to `~/.vimrc` |
||||
2. `vim +PluginInstall +qall` |
||||
|
||||
*Note:* Vundle will not automatically detect Rust files properly if `filetype |
||||
on` is executed before Vundle. Please check the [quickstart][vqs] for more |
||||
details. |
||||
|
||||
### Using [Pathogen][p] |
||||
|
||||
1. `cd ~/.vim/bundle` |
||||
2. `git clone https://github.com/wting/rust.vim.git` |
||||
|
||||
[rr]: https://github.com/rust-lang/rust |
||||
[p]: https://github.com/tpope/vim-pathogen |
||||
[r]: https://en.wikipedia.org/wiki/Rust_language |
||||
[v]: https://github.com/gmarik/vundle |
||||
[vqs]: https://github.com/gmarik/vundle#quick-start |
||||
@ -0,0 +1,225 @@ |
||||
" Author: Kevin Ballard |
||||
" Description: Helper functions for Rust commands/mappings |
||||
" Last Modified: May 27, 2014 |
||||
|
||||
" Jump {{{1 |
||||
|
||||
function! rust#Jump(mode, function) range |
||||
let cnt = v:count1 |
||||
normal! m' |
||||
if a:mode ==# 'v' |
||||
norm! gv |
||||
endif |
||||
let foldenable = &foldenable |
||||
set nofoldenable |
||||
while cnt > 0 |
||||
execute "call <SID>Jump_" . a:function . "()" |
||||
let cnt = cnt - 1 |
||||
endwhile |
||||
let &foldenable = foldenable |
||||
endfunction |
||||
|
||||
function! s:Jump_Back() |
||||
call search('{', 'b') |
||||
keepjumps normal! w99[{ |
||||
endfunction |
||||
|
||||
function! s:Jump_Forward() |
||||
normal! j0 |
||||
call search('{', 'b') |
||||
keepjumps normal! w99[{% |
||||
call search('{') |
||||
endfunction |
||||
|
||||
" Run {{{1 |
||||
|
||||
function! rust#Run(bang, args) |
||||
if a:bang |
||||
let idx = index(a:args, '--') |
||||
if idx != -1 |
||||
let rustc_args = idx == 0 ? [] : a:args[:idx-1] |
||||
let args = a:args[idx+1:] |
||||
else |
||||
let rustc_args = a:args |
||||
let args = [] |
||||
endif |
||||
else |
||||
let rustc_args = [] |
||||
let args = a:args |
||||
endif |
||||
|
||||
let b:rust_last_rustc_args = rustc_args |
||||
let b:rust_last_args = args |
||||
|
||||
call s:WithPath(function("s:Run"), rustc_args, args) |
||||
endfunction |
||||
|
||||
function! s:Run(path, rustc_args, args) |
||||
try |
||||
let exepath = tempname() |
||||
if has('win32') |
||||
let exepath .= '.exe' |
||||
endif |
||||
|
||||
let rustc_args = [a:path, '-o', exepath] + a:rustc_args |
||||
|
||||
let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc" |
||||
|
||||
let output = system(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 |
||||
finally |
||||
if exists("exepath") |
||||
silent! call delete(exepath) |
||||
endif |
||||
endtry |
||||
endfunction |
||||
|
||||
" Expand {{{1 |
||||
|
||||
function! rust#Expand(bang, args) |
||||
if a:bang && !empty(a:args) |
||||
let pretty = a:args[0] |
||||
let args = a:args[1:] |
||||
else |
||||
let pretty = "expanded" |
||||
let args = a:args |
||||
endif |
||||
call s:WithPath(function("s:Expand"), pretty, args) |
||||
endfunction |
||||
|
||||
function! s:Expand(path, pretty, args) |
||||
try |
||||
let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc" |
||||
|
||||
let args = [a:path, '--pretty', a:pretty] + a:args |
||||
let output = system(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 |
||||
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="] |
||||
if !empty(a:lead) |
||||
call filter(list, "v:val[:len(a:lead)-1] == a:lead") |
||||
endif |
||||
return list |
||||
endif |
||||
|
||||
return glob(escape(a:lead, "*?[") . '*', 0, 1) |
||||
endfunction |
||||
|
||||
" Emit {{{1 |
||||
|
||||
function! rust#Emit(type, args) |
||||
call s:WithPath(function("s:Emit"), a:type, a:args) |
||||
endfunction |
||||
|
||||
function! s:Emit(path, type, args) |
||||
try |
||||
let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc" |
||||
|
||||
let args = [a:path, '--emit', a:type, '-o', '-'] + a:args |
||||
let output = system(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 |
||||
if a:type == "ir" |
||||
setl filetype=llvm |
||||
elseif a:type == "asm" |
||||
setl filetype=asm |
||||
endif |
||||
setl buftype=nofile |
||||
setl bufhidden=hide |
||||
setl noswapfile |
||||
endif |
||||
endtry |
||||
endfunction |
||||
|
||||
" Utility functions {{{1 |
||||
|
||||
function! s:WithPath(func, ...) |
||||
try |
||||
let save_write = &write |
||||
set write |
||||
let path = expand('%') |
||||
let pathisempty = empty(path) |
||||
if pathisempty || !save_write |
||||
" use a temporary file named 'unnamed.rs' inside a temporary |
||||
" directory. This produces better error messages |
||||
let tmpdir = tempname() |
||||
call mkdir(tmpdir) |
||||
|
||||
let save_cwd = getcwd() |
||||
silent exe 'lcd' fnameescape(tmpdir) |
||||
|
||||
let path = 'unnamed.rs' |
||||
|
||||
let save_mod = &mod |
||||
set nomod |
||||
|
||||
silent exe 'keepalt write! ' . fnameescape(path) |
||||
if pathisempty |
||||
silent keepalt 0file |
||||
endif |
||||
else |
||||
update |
||||
endif |
||||
|
||||
call call(a:func, [path] + a:000) |
||||
finally |
||||
if exists("save_mod") | let &mod = save_mod | endif |
||||
if exists("save_write") | let &write = save_write | endif |
||||
if exists("save_cwd") | silent exe 'lcd' fnameescape(save_cwd) | endif |
||||
if exists("tmpdir") | silent call s:RmDir(tmpdir) | endif |
||||
endtry |
||||
endfunction |
||||
|
||||
function! rust#AppendCmdLine(text) |
||||
call setcmdpos(getcmdpos()) |
||||
let cmd = getcmdline() . a:text |
||||
return cmd |
||||
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 |
||||
silent exe "!rm -rf " . shellescape(a:path) |
||||
endfunction |
||||
|
||||
" }}}1 |
||||
|
||||
" vim: set noet sw=4 ts=4: |
||||
@ -0,0 +1,65 @@ |
||||
" Vim compiler file |
||||
" Compiler: Cargo Compiler |
||||
" Maintainer: Damien Radtke <damienradtke@gmail.com> |
||||
" Latest Revision: 2014 Sep 24 |
||||
|
||||
if exists('current_compiler') |
||||
finish |
||||
endif |
||||
runtime compiler/rustc.vim |
||||
let current_compiler = "cargo" |
||||
|
||||
if exists(':CompilerSet') != 2 |
||||
command -nargs=* CompilerSet setlocal <args> |
||||
endif |
||||
|
||||
if exists('g:cargo_makeprg_params') |
||||
execute 'CompilerSet makeprg=cargo\ '.escape(g:cargo_makeprg_params, ' \|"').'\ $*' |
||||
else |
||||
CompilerSet makeprg=cargo\ $* |
||||
endif |
||||
|
||||
" Allow a configurable global Cargo.toml name. This makes it easy to |
||||
" support variations like 'cargo.toml'. |
||||
let s:cargo_manifest_name = get(g:, 'cargo_manifest_name', 'Cargo.toml') |
||||
|
||||
function! s:is_absolute(path) |
||||
return a:path[0] == '/' || a:path =~ '[A-Z]\+:' |
||||
endfunction |
||||
|
||||
let s:local_manifest = findfile(s:cargo_manifest_name, '.;') |
||||
if s:local_manifest != '' |
||||
let s:local_manifest = fnamemodify(s:local_manifest, ':p:h').'/' |
||||
augroup cargo |
||||
au! |
||||
au QuickfixCmdPost make call s:FixPaths() |
||||
augroup END |
||||
|
||||
" FixPaths() is run after Cargo, and is used to change the file paths |
||||
" to be relative to the current directory instead of Cargo.toml. |
||||
function! s:FixPaths() |
||||
let qflist = getqflist() |
||||
let manifest = s:local_manifest |
||||
for qf in qflist |
||||
if !qf.valid |
||||
let m = matchlist(qf.text, '(file://\(.*\))$') |
||||
if !empty(m) |
||||
let manifest = m[1].'/' |
||||
" Manually strip another slash if needed; usually just an |
||||
" issue on Windows. |
||||
if manifest =~ '^/[A-Z]\+:/' |
||||
let manifest = manifest[1:] |
||||
endif |
||||
endif |
||||
continue |
||||
endif |
||||
let filename = bufname(qf.bufnr) |
||||
if s:is_absolute(filename) |
||||
continue |
||||
endif |
||||
let qf.filename = simplify(manifest.filename) |
||||
call remove(qf, 'bufnr') |
||||
endfor |
||||
call setqflist(qflist, 'r') |
||||
endfunction |
||||
endif |
||||
@ -0,0 +1,33 @@ |
||||
" Vim compiler file |
||||
" Compiler: Rust Compiler |
||||
" Maintainer: Chris Morgan <me@chrismorgan.info> |
||||
" Latest Revision: 2013 Jul 12 |
||||
|
||||
if exists("current_compiler") |
||||
finish |
||||
endif |
||||
let current_compiler = "rustc" |
||||
|
||||
let s:cpo_save = &cpo |
||||
set cpo&vim |
||||
|
||||
if exists(":CompilerSet") != 2 |
||||
command -nargs=* CompilerSet setlocal <args> |
||||
endif |
||||
|
||||
if exists("g:rustc_makeprg_no_percent") && g:rustc_makeprg_no_percent == 1 |
||||
CompilerSet makeprg=rustc |
||||
else |
||||
CompilerSet makeprg=rustc\ \% |
||||
endif |
||||
|
||||
CompilerSet errorformat= |
||||
\%f:%l:%c:\ %t%*[^:]:\ %m, |
||||
\%f:%l:%c:\ %*\\d:%*\\d\ %t%*[^:]:\ %m, |
||||
\%-G%f:%l\ %s, |
||||
\%-G%*[\ ]^, |
||||
\%-G%*[\ ]^%*[~], |
||||
\%-G%*[\ ]... |
||||
|
||||
let &cpo = s:cpo_save |
||||
unlet s:cpo_save |
||||
@ -0,0 +1,178 @@ |
||||
*rust.txt* Filetype plugin for Rust |
||||
|
||||
============================================================================== |
||||
CONTENTS *rust* *ft-rust* |
||||
|
||||
1. Introduction |rust-intro| |
||||
2. Settings |rust-settings| |
||||
3. Commands |rust-commands| |
||||
4. Mappings |rust-mappings| |
||||
|
||||
============================================================================== |
||||
INTRODUCTION *rust-intro* |
||||
|
||||
This plugin provides syntax and supporting functionality for the Rust |
||||
filetype. |
||||
|
||||
============================================================================== |
||||
SETTINGS *rust-settings* |
||||
|
||||
This plugin has a few variables you can define in your vimrc that change the |
||||
behavior of the plugin. |
||||
|
||||
*g:rustc_path* |
||||
g:rustc_path~ |
||||
Set this option to the path to rustc for use in the |:RustRun| and |
||||
|:RustExpand| commands. If unset, "rustc" will be located in $PATH: > |
||||
let g:rustc_path = $HOME."/bin/rustc" |
||||
< |
||||
|
||||
*g:rustc_makeprg_no_percent* |
||||
g:rustc_makeprg_no_percent~ |
||||
Set this option to 1 to have 'makeprg' default to "rustc" instead of |
||||
"rustc %": > |
||||
let g:rustc_makeprg_no_percent = 1 |
||||
< |
||||
|
||||
*g:rust_conceal* |
||||
g:rust_conceal~ |
||||
Set this option to turn on the basic |conceal| support: > |
||||
let g:rust_conceal = 1 |
||||
< |
||||
|
||||
*g:rust_conceal_mod_path* |
||||
g:rust_conceal_mod_path~ |
||||
Set this option to turn on |conceal| for the path connecting token |
||||
"::": > |
||||
let g:rust_conceal_mod_path = 1 |
||||
< |
||||
|
||||
*g:rust_conceal_pub* |
||||
g:rust_conceal_pub~ |
||||
Set this option to turn on |conceal| for the "pub" token: > |
||||
let g:rust_conceal_pub = 1 |
||||
< |
||||
|
||||
*g:rust_recommended_style* |
||||
g:rust_recommended_style~ |
||||
Set this option to enable vim indentation and textwidth settings to |
||||
conform to style conventions of the rust standard library (i.e. use 4 |
||||
spaces for indents and sets 'textwidth' to 99). This option is enabled |
||||
by default. To disable it: > |
||||
let g:rust_recommended_style = 0 |
||||
< |
||||
|
||||
*g:rust_fold* |
||||
g:rust_fold~ |
||||
Set this option to turn on |folding|: > |
||||
let g:rust_fold = 1 |
||||
< |
||||
Value Effect ~ |
||||
0 No folding |
||||
1 Braced blocks are folded. All folds are open by |
||||
default. |
||||
2 Braced blocks are folded. 'foldlevel' is left at the |
||||
global value (all folds are closed by default). |
||||
|
||||
*g:rust_bang_comment_leader* |
||||
g:rust_bang_comment_leader~ |
||||
Set this option to 1 to preserve the leader on multi-line doc comments |
||||
using the /*! syntax: > |
||||
let g:rust_bang_comment_leader = 1 |
||||
< |
||||
|
||||
*g:ftplugin_rust_source_path* |
||||
g:ftplugin_rust_source_path~ |
||||
Set this option to a path that should be prepended to 'path' for Rust |
||||
source files: > |
||||
let g:ftplugin_rust_source_path = $HOME.'/dev/rust' |
||||
< |
||||
|
||||
*g:cargo_manifest_name* |
||||
g:cargo_manifest_name~ |
||||
Set this option to the name of the manifest file for your projects. If |
||||
not specified it defaults to 'Cargo.toml' : > |
||||
let g:cargo_manifest_name = 'Cargo.toml' |
||||
< |
||||
|
||||
============================================================================== |
||||
COMMANDS *rust-commands* |
||||
|
||||
:RustRun [args] *:RustRun* |
||||
:RustRun! [rustc-args] [--] [args] |
||||
Compiles and runs the current file. If it has unsaved changes, |
||||
it will be saved first using |:update|. If the current file is |
||||
an unnamed buffer, it will be written to a temporary file |
||||
first. The compiled binary is always placed in a temporary |
||||
directory, but is run from the current directory. |
||||
|
||||
The arguments given to |:RustRun| will be passed to the |
||||
compiled binary. |
||||
|
||||
If ! is specified, the arguments are passed to rustc instead. |
||||
A "--" argument will separate the rustc arguments from the |
||||
arguments passed to the binary. |
||||
|
||||
If |g:rustc_path| is defined, it is used as the path to rustc. |
||||
Otherwise it is assumed rustc can be found in $PATH. |
||||
|
||||
:RustExpand [args] *:RustExpand* |
||||
:RustExpand! [TYPE] [args] |
||||
Expands the current file using --pretty and displays the |
||||
results in a new split. If the current file has unsaved |
||||
changes, it will be saved first using |:update|. If the |
||||
current file is an unnamed buffer, it will be written to a |
||||
temporary file first. |
||||
|
||||
The arguments given to |:RustExpand| will be passed to rustc. |
||||
This is largely intended for specifying various --cfg |
||||
configurations. |
||||
|
||||
If ! is specified, the first argument is the expansion type to |
||||
pass to rustc --pretty. Otherwise it will default to |
||||
"expanded". |
||||
|
||||
If |g:rustc_path| is defined, it is used as the path to rustc. |
||||
Otherwise it is assumed rustc can be found in $PATH. |
||||
|
||||
:RustEmitIr [args] *:RustEmitIr* |
||||
Compiles the current file to LLVM IR and displays the results |
||||
in a new split. If the current file has unsaved changes, it |
||||
will be saved first using |:update|. If the current file is an |
||||
unnamed buffer, it will be written to a temporary file first. |
||||
|
||||
The arguments given to |:RustEmitIr| will be passed to rustc. |
||||
|
||||
If |g:rustc_path| is defined, it is used as the path to rustc. |
||||
Otherwise it is assumed rustc can be found in $PATH. |
||||
|
||||
:RustEmitAsm [args] *:RustEmitAsm* |
||||
Compiles the current file to assembly and displays the results |
||||
in a new split. If the current file has unsaved changes, it |
||||
will be saved first using |:update|. If the current file is an |
||||
unnamed buffer, it will be written to a temporary file first. |
||||
|
||||
The arguments given to |:RustEmitAsm| will be passed to rustc. |
||||
|
||||
If |g:rustc_path| is defined, it is used as the path to rustc. |
||||
Otherwise it is assumed rustc can be found in $PATH. |
||||
|
||||
============================================================================== |
||||
MAPPINGS *rust-mappings* |
||||
|
||||
This plugin defines mappings for |[[| and |]]| to support hanging indents. |
||||
|
||||
It also has a few other mappings: |
||||
|
||||
*rust_<D-r>* |
||||
<D-r> Executes |:RustRun| with no arguments. |
||||
Note: This binding is only available in MacVim. |
||||
|
||||
*rust_<D-R>* |
||||
<D-R> Populates the command line with |:RustRun|! using the |
||||
arguments given to the last invocation, but does not |
||||
execute it. |
||||
Note: This binding is only available in MacVim. |
||||
|
||||
============================================================================== |
||||
vim:tw=78:sw=4:noet:ts=8:ft=help:norl: |
||||
@ -0,0 +1 @@ |
||||
au BufRead,BufNewFile *.rs set filetype=rust |
||||
@ -0,0 +1,150 @@ |
||||
" Language: Rust |
||||
" Description: Vim syntax file for Rust |
||||
" Maintainer: Chris Morgan <me@chrismorgan.info> |
||||
" Maintainer: Kevin Ballard <kevin@sb.org> |
||||
" Last Change: Jul 07, 2014 |
||||
|
||||
if exists("b:did_ftplugin") |
||||
finish |
||||
endif |
||||
let b:did_ftplugin = 1 |
||||
|
||||
let s:save_cpo = &cpo |
||||
set cpo&vim |
||||
|
||||
" Variables {{{1 |
||||
|
||||
" The rust source code at present seems to typically omit a leader on /*! |
||||
" comments, so we'll use that as our default, but make it easy to switch. |
||||
" This does not affect indentation at all (I tested it with and without |
||||
" leader), merely whether a leader is inserted by default or not. |
||||
if exists("g:rust_bang_comment_leader") && g:rust_bang_comment_leader == 1 |
||||
" Why is the `,s0:/*,mb:\ ,ex:*/` there, you ask? I don't understand why, |
||||
" but without it, */ gets indented one space even if there were no |
||||
" leaders. I'm fairly sure that's a Vim bug. |
||||
setlocal comments=s1:/*,mb:*,ex:*/,s0:/*,mb:\ ,ex:*/,:///,://!,:// |
||||
else |
||||
setlocal comments=s0:/*!,m:\ ,ex:*/,s1:/*,mb:*,ex:*/,:///,://!,:// |
||||
endif |
||||
setlocal commentstring=//%s |
||||
setlocal formatoptions-=t formatoptions+=croqnl |
||||
" j was only added in 7.3.541, so stop complaints about its nonexistence |
||||
silent! setlocal formatoptions+=j |
||||
|
||||
" smartindent will be overridden by indentexpr if filetype indent is on, but |
||||
" otherwise it's better than nothing. |
||||
setlocal smartindent nocindent |
||||
|
||||
if !exists("g:rust_recommended_style") || g:rust_recommended_style == 1 |
||||
setlocal tabstop=4 shiftwidth=4 softtabstop=4 expandtab |
||||
setlocal textwidth=99 |
||||
endif |
||||
|
||||
" This includeexpr isn't perfect, but it's a good start |
||||
setlocal includeexpr=substitute(v:fname,'::','/','g') |
||||
|
||||
" NOT adding .rc as it's being phased out (0.7) |
||||
setlocal suffixesadd=.rs |
||||
|
||||
if exists("g:ftplugin_rust_source_path") |
||||
let &l:path=g:ftplugin_rust_source_path . ',' . &l: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 |
||||
let b:delimitMate_excluded_regions = delimitMate#Get("excluded_regions") . ',rustLifetimeCandidate,rustGenericLifetimeCandidate' |
||||
endif |
||||
|
||||
if has("folding") && exists('g:rust_fold') && g:rust_fold != 0 |
||||
let b:rust_set_foldmethod=1 |
||||
setlocal foldmethod=syntax |
||||
if g:rust_fold == 2 |
||||
setlocal foldlevel< |
||||
else |
||||
setlocal foldlevel=99 |
||||
endif |
||||
endif |
||||
|
||||
if has('conceal') && exists('g:rust_conceal') |
||||
let b:rust_set_conceallevel=1 |
||||
setlocal conceallevel=2 |
||||
endif |
||||
|
||||
" Motion Commands {{{1 |
||||
|
||||
" Bind motion commands to support hanging indents |
||||
nnoremap <silent> <buffer> [[ :call rust#Jump('n', 'Back')<CR> |
||||
nnoremap <silent> <buffer> ]] :call rust#Jump('n', 'Forward')<CR> |
||||
xnoremap <silent> <buffer> [[ :call rust#Jump('v', 'Back')<CR> |
||||
xnoremap <silent> <buffer> ]] :call rust#Jump('v', 'Forward')<CR> |
||||
onoremap <silent> <buffer> [[ :call rust#Jump('o', 'Back')<CR> |
||||
onoremap <silent> <buffer> ]] :call rust#Jump('o', 'Forward')<CR> |
||||
|
||||
" Commands {{{1 |
||||
|
||||
" See |:RustRun| for docs |
||||
command! -nargs=* -complete=file -bang -bar -buffer RustRun call rust#Run(<bang>0, [<f-args>]) |
||||
|
||||
" See |:RustExpand| for docs |
||||
command! -nargs=* -complete=customlist,rust#CompleteExpand -bang -bar -buffer RustExpand call rust#Expand(<bang>0, [<f-args>]) |
||||
|
||||
" See |:RustEmitIr| for docs |
||||
command! -nargs=* -bar -buffer RustEmitIr call rust#Emit("ir", [<f-args>]) |
||||
|
||||
" See |:RustEmitAsm| for docs |
||||
command! -nargs=* -bar -buffer RustEmitAsm call rust#Emit("asm", [<f-args>]) |
||||
|
||||
" Mappings {{{1 |
||||
|
||||
" 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> |
||||
|
||||
if !exists("b:rust_last_rustc_args") || !exists("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 |
||||
\|nunmap <buffer> <D-r> |
||||
\|nunmap <buffer> <D-R> |
||||
\|nunmap <buffer> [[ |
||||
\|nunmap <buffer> ]] |
||||
\|xunmap <buffer> [[ |
||||
\|xunmap <buffer> ]] |
||||
\|ounmap <buffer> [[ |
||||
\|ounmap <buffer> ]] |
||||
\" |
||||
|
||||
" }}}1 |
||||
|
||||
let &cpo = s:save_cpo |
||||
unlet s:save_cpo |
||||
|
||||
" vim: set noet sw=4 ts=4: |
||||
@ -0,0 +1,196 @@ |
||||
" Vim indent file |
||||
" Language: Rust |
||||
" Author: Chris Morgan <me@chrismorgan.info> |
||||
" Last Change: 2014 Sep 13 |
||||
|
||||
" Only load this indent file when no other was loaded. |
||||
if exists("b:did_indent") |
||||
finish |
||||
endif |
||||
let b:did_indent = 1 |
||||
|
||||
setlocal cindent |
||||
setlocal cinoptions=L0,(0,Ws,J1,j1 |
||||
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 |
||||
|
||||
" Some preliminary settings |
||||
setlocal nolisp " Make sure lisp indenting doesn't supersede us |
||||
setlocal autoindent " indentexpr isn't much help otherwise |
||||
" Also do indentkeys, otherwise # gets shoved to column 0 :-/ |
||||
setlocal indentkeys=0{,0},!^F,o,O,0[,0] |
||||
|
||||
setlocal indentexpr=GetRustIndent(v:lnum) |
||||
|
||||
" Only define the function once. |
||||
if exists("*GetRustIndent") |
||||
finish |
||||
endif |
||||
|
||||
" 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 |
||||
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 |
||||
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. |
||||
|
||||
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 |
||||
|
||||
" 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 |
||||
if prevline[len(prevline) - 1] == "," |
||||
\ && s:get_line_trimmed(a:lnum) !~ '^\s*[\[\]{}]' |
||||
\ && prevline !~ '^\s*fn\s' |
||||
\ && prevline !~ '([^()]\+,$' |
||||
" 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) { |
||||
" |
||||
" 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! |
||||
|
||||
" 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 |
||||
|
||||
" Fall back on cindent, which does it mostly right |
||||
return cindent(a:lnum) |
||||
endfunction |
||||
@ -0,0 +1,22 @@ |
||||
" Vim syntastic plugin helper |
||||
" Language: Rust |
||||
" Maintainer: Andrew Gallant <jamslam@gmail.com> |
||||
|
||||
if exists("g:loaded_syntastic_rust_filetype") |
||||
finish |
||||
endif |
||||
let g:loaded_syntastic_rust_filetype = 1 |
||||
let s:save_cpo = &cpo |
||||
set cpo&vim |
||||
|
||||
" This is to let Syntastic know about the Rust filetype. |
||||
" It enables tab completion for the 'SyntasticInfo' command. |
||||
" (This does not actually register the syntax checker.) |
||||
if exists('g:syntastic_extra_filetypes') |
||||
call add(g:syntastic_extra_filetypes, 'rust') |
||||
else |
||||
let g:syntastic_extra_filetypes = ['rust'] |
||||
endif |
||||
|
||||
let &cpo = s:save_cpo |
||||
unlet s:save_cpo |
||||
@ -0,0 +1,262 @@ |
||||
" Vim syntax file |
||||
" Language: Rust |
||||
" Maintainer: Patrick Walton <pcwalton@mozilla.com> |
||||
" Maintainer: Ben Blum <bblum@cs.cmu.edu> |
||||
" Maintainer: Chris Morgan <me@chrismorgan.info> |
||||
" Last Change: January 5, 2015 |
||||
|
||||
if version < 600 |
||||
syntax clear |
||||
elseif exists("b:current_syntax") |
||||
finish |
||||
endif |
||||
|
||||
" Syntax definitions {{{1 |
||||
" Basic keywords {{{2 |
||||
syn keyword rustConditional match if else |
||||
syn keyword rustOperator as |
||||
|
||||
syn match rustAssert "\<assert\(\w\)*!" contained |
||||
syn match rustPanic "\<panic\(\w\)*!" contained |
||||
syn keyword rustKeyword break |
||||
syn keyword rustKeyword box nextgroup=rustBoxPlacement skipwhite skipempty |
||||
syn keyword rustKeyword continue |
||||
syn keyword rustKeyword extern nextgroup=rustExternCrate,rustObsoleteExternMod skipwhite skipempty |
||||
syn keyword rustKeyword fn nextgroup=rustFuncName skipwhite skipempty |
||||
syn keyword rustKeyword for in if impl let |
||||
syn keyword rustKeyword loop once pub |
||||
syn keyword rustKeyword return super |
||||
syn keyword rustKeyword unsafe virtual where while |
||||
syn keyword rustKeyword use nextgroup=rustModPath skipwhite skipempty |
||||
" FIXME: Scoped impl's name is also fallen in this category |
||||
syn keyword rustKeyword mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty |
||||
syn keyword rustStorage move mut ref static const |
||||
|
||||
syn keyword rustInvalidBareKeyword crate |
||||
|
||||
syn keyword rustExternCrate crate contained nextgroup=rustIdentifier,rustExternCrateString skipwhite skipempty |
||||
" This is to get the `bar` part of `extern crate "foo" as bar;` highlighting. |
||||
syn match rustExternCrateString /".*"\_s*as/ contained nextgroup=rustIdentifier skipwhite transparent skipempty contains=rustString,rustOperator |
||||
syn keyword rustObsoleteExternMod mod contained nextgroup=rustIdentifier skipwhite skipempty |
||||
|
||||
syn match rustIdentifier contains=rustIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained |
||||
syn match rustFuncName "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained |
||||
|
||||
syn region rustBoxPlacement matchgroup=rustBoxPlacementParens start="(" end=")" contains=TOP contained |
||||
syn keyword rustBoxPlacementExpr GC containedin=rustBoxPlacement |
||||
" Ideally we'd have syntax rules set up to match arbitrary expressions. Since |
||||
" we don't, we'll just define temporary contained rules to handle balancing |
||||
" delimiters. |
||||
syn region rustBoxPlacementBalance start="(" end=")" containedin=rustBoxPlacement transparent |
||||
syn region rustBoxPlacementBalance start="\[" end="\]" containedin=rustBoxPlacement transparent |
||||
" {} are handled by rustFoldBraces |
||||
|
||||
syn region rustMacroRepeat matchgroup=rustMacroRepeatDelimiters start="$(" end=")" contains=TOP nextgroup=rustMacroRepeatCount |
||||
syn match rustMacroRepeatCount ".\?[*+]" contained |
||||
syn match rustMacroVariable "$\w\+" |
||||
|
||||
" Reserved (but not yet used) keywords {{{2 |
||||
syn keyword rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield abstract final override macro |
||||
|
||||
" Built-in types {{{2 |
||||
syn keyword rustType isize usize float char bool u8 u16 u32 u64 f32 |
||||
syn keyword rustType f64 i8 i16 i32 i64 str Self |
||||
|
||||
" Things from the prelude (src/libstd/prelude.rs) {{{2 |
||||
" This section is just straight transformation of the contents of the prelude, |
||||
" to make it easy to update. |
||||
|
||||
" Reexported core operators {{{3 |
||||
syn keyword rustTrait Copy Send Sized Sync |
||||
syn keyword rustTrait Drop Fn FnMut FnOnce |
||||
|
||||
" Reexported functions {{{3 |
||||
syn keyword rustFunction drop |
||||
|
||||
" Reexported types and traits {{{3 |
||||
syn keyword rustTrait Box |
||||
syn keyword rustTrait CharExt |
||||
syn keyword rustTrait Clone |
||||
syn keyword rustTrait PartialEq PartialOrd Eq Ord |
||||
syn keyword rustTrait DoubleEndedIterator |
||||
syn keyword rustTrait ExactSizeIterator |
||||
syn keyword rustTrait Iterator IteratorExt Extend |
||||
syn keyword rustEnum Option |
||||
syn keyword rustEnumVariant Some None |
||||
syn keyword rustTrait PtrExt MutPtrExt |
||||
syn keyword rustEnum Result |
||||
syn keyword rustEnumVariant Ok Err |
||||
syn keyword rustTrait AsSlice |
||||
syn keyword rustTrait SliceExt SliceConcatExt |
||||
syn keyword rustTrait Str StrExt |
||||
syn keyword rustTrait String ToString |
||||
syn keyword rustTrait Vec |
||||
" FIXME: remove when path reform lands |
||||
syn keyword rustTrait Path GenericPath |
||||
" FIXME: remove when I/O reform lands |
||||
syn keyword rustTrait Buffer Writer Reader Seek BufferPrelude |
||||
|
||||
" Other syntax {{{2 |
||||
syn keyword rustSelf self |
||||
syn keyword rustBoolean true false |
||||
|
||||
" If foo::bar changes to foo.bar, change this ("::" to "\."). |
||||
" If foo::bar changes to Foo::bar, change this (first "\w" to "\u"). |
||||
syn match rustModPath "\w\(\w\)*::[^<]"he=e-3,me=e-3 |
||||
syn match rustModPathSep "::" |
||||
|
||||
syn match rustFuncCall "\w\(\w\)*("he=e-1,me=e-1 |
||||
syn match rustFuncCall "\w\(\w\)*::<"he=e-3,me=e-3 " foo::<T>(); |
||||
|
||||
" This is merely a convention; note also the use of [A-Z], restricting it to |
||||
" latin identifiers rather than the full Unicode uppercase. I have not used |
||||
" [:upper:] as it depends upon 'noignorecase' |
||||
"syn match rustCapsIdent display "[A-Z]\w\(\w\)*" |
||||
|
||||
syn match rustOperator display "\%(+\|-\|/\|*\|=\|\^\|&\||\|!\|>\|<\|%\)=\?" |
||||
" This one isn't *quite* right, as we could have binary-& with a reference |
||||
syn match rustSigil display /&\s\+[&~@*][^)= \t\r\n]/he=e-1,me=e-1 |
||||
syn match rustSigil display /[&~@*][^)= \t\r\n]/he=e-1,me=e-1 |
||||
" This isn't actually correct; a closure with no arguments can be `|| { }`. |
||||
" Last, because the & in && isn't a sigil |
||||
syn match rustOperator display "&&\|||" |
||||
|
||||
syn match rustMacro '\w\(\w\)*!' contains=rustAssert,rustPanic |
||||
syn match rustMacro '#\w\(\w\)*' contains=rustAssert,rustPanic |
||||
|
||||
syn match rustEscapeError display contained /\\./ |
||||
syn match rustEscape display contained /\\\([nrt0\\'"]\|x\x\{2}\)/ |
||||
syn match rustEscapeUnicode display contained /\\\(u\x\{4}\|U\x\{8}\)/ |
||||
syn match rustEscapeUnicode display contained /\\u{\x\{1,6}}/ |
||||
syn match rustStringContinuation display contained /\\\n\s*/ |
||||
syn region rustString start=+b"+ skip=+\\\\\|\\"+ end=+"+ contains=rustEscape,rustEscapeError,rustStringContinuation |
||||
syn region rustString start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustEscape,rustEscapeUnicode,rustEscapeError,rustStringContinuation,@Spell |
||||
syn region rustString start='b\?r\z(#*\)"' end='"\z1' contains=@Spell |
||||
|
||||
syn region rustAttribute start="#!\?\[" end="\]" contains=rustString,rustDerive |
||||
syn region rustDerive start="derive(" end=")" contained contains=rustTrait |
||||
|
||||
" Number literals |
||||
syn match rustDecNumber display "\<[0-9][0-9_]*\%([iu]\%(s\|8\|16\|32\|64\)\)\=" |
||||
syn match rustHexNumber display "\<0x[a-fA-F0-9_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\=" |
||||
syn match rustOctNumber display "\<0o[0-7_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\=" |
||||
syn match rustBinNumber display "\<0b[01_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\=" |
||||
|
||||
" Special case for numbers of the form "1." which are float literals, unless followed by |
||||
" an identifier, which makes them integer literals with a method call or field access, |
||||
" or by another ".", which makes them integer literals followed by the ".." token. |
||||
" (This must go first so the others take precedence.) |
||||
syn match rustFloat display "\<[0-9][0-9_]*\.\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\|\.\)\@!" |
||||
" To mark a number as a normal float, it must have at least one of the three things integral values don't have: |
||||
" a decimal point and more numbers; an exponent; and a type suffix. |
||||
syn match rustFloat display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)\=" |
||||
syn match rustFloat display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\(f32\|f64\)\=" |
||||
syn match rustFloat display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)" |
||||
|
||||
" For the benefit of delimitMate |
||||
syn region rustLifetimeCandidate display start=/&'\%(\([^'\\]\|\\\(['nrt0\\\"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'\)\@!/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustSigil,rustLifetime |
||||
syn region rustGenericRegion display start=/<\%('\|[^[cntrl:][:space:][:punct:]]\)\@=')\S\@=/ end=/>/ contains=rustGenericLifetimeCandidate |
||||
syn region rustGenericLifetimeCandidate display start=/\%(<\|,\s*\)\@<='/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustSigil,rustLifetime |
||||
|
||||
"rustLifetime must appear before rustCharacter, or chars will get the lifetime highlighting |
||||
syn match rustLifetime display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" |
||||
syn match rustCharacterInvalid display contained /b\?'\zs[\n\r\t']\ze'/ |
||||
" The groups negated here add up to 0-255 but nothing else (they do not seem to go beyond ASCII). |
||||
syn match rustCharacterInvalidUnicode display contained /b'\zs[^[:cntrl:][:graph:][:alnum:][:space:]]\ze'/ |
||||
syn match rustCharacter /b'\([^\\]\|\\\(.\|x\x\{2}\)\)'/ contains=rustEscape,rustEscapeError,rustCharacterInvalid,rustCharacterInvalidUnicode |
||||
syn match rustCharacter /'\([^\\]\|\\\(.\|x\x\{2}\|u\x\{4}\|U\x\{8}\|u{\x\{1,6}}\)\)'/ contains=rustEscape,rustEscapeUnicode,rustEscapeError,rustCharacterInvalid |
||||
|
||||
syn region rustCommentLine start="//" end="$" contains=rustTodo,@Spell |
||||
syn region rustCommentLineDoc start="//\%(//\@!\|!\)" end="$" contains=rustTodo,@Spell |
||||
syn region rustCommentBlock matchgroup=rustCommentBlock start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,rustCommentBlockNest,@Spell |
||||
syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)" end="\*/" contains=rustTodo,rustCommentBlockDocNest,@Spell |
||||
syn region rustCommentBlockNest matchgroup=rustCommentBlock start="/\*" end="\*/" contains=rustTodo,rustCommentBlockNest,@Spell contained transparent |
||||
syn region rustCommentBlockDocNest matchgroup=rustCommentBlockDoc start="/\*" end="\*/" contains=rustTodo,rustCommentBlockDocNest,@Spell contained transparent |
||||
" FIXME: this is a really ugly and not fully correct implementation. Most |
||||
" importantly, a case like ``/* */*`` should have the final ``*`` not being in |
||||
" a comment, but in practice at present it leaves comments open two levels |
||||
" deep. But as long as you stay away from that particular case, I *believe* |
||||
" the highlighting is correct. Due to the way Vim's syntax engine works |
||||
" (greedy for start matches, unlike Rust's tokeniser which is searching for |
||||
" the earliest-starting match, start or end), I believe this cannot be solved. |
||||
" Oh you who would fix it, don't bother with things like duplicating the Block |
||||
" rules and putting ``\*\@<!`` at the start of them; it makes it worse, as |
||||
" then you must deal with cases like ``/*/**/*/``. And don't try making it |
||||
" worse with ``\%(/\@<!\*\)\@<!``, either... |
||||
|
||||
syn keyword rustTodo contained TODO FIXME XXX NB NOTE |
||||
|
||||
" Folding rules {{{2 |
||||
" Trivial folding rules to begin with. |
||||
" FIXME: use the AST to make really good folding |
||||
syn region rustFoldBraces start="{" end="}" transparent fold |
||||
|
||||
" Default highlighting {{{1 |
||||
hi def link rustDecNumber rustNumber |
||||
hi def link rustHexNumber rustNumber |
||||
hi def link rustOctNumber rustNumber |
||||
hi def link rustBinNumber rustNumber |
||||
hi def link rustIdentifierPrime rustIdentifier |
||||
hi def link rustTrait rustType |
||||
|
||||
hi def link rustMacroRepeatCount rustMacroRepeatDelimiters |
||||
hi def link rustMacroRepeatDelimiters Macro |
||||
hi def link rustMacroVariable Define |
||||
hi def link rustSigil StorageClass |
||||
hi def link rustEscape Special |
||||
hi def link rustEscapeUnicode rustEscape |
||||
hi def link rustEscapeError Error |
||||
hi def link rustStringContinuation Special |
||||
hi def link rustString String |
||||
hi def link rustCharacterInvalid Error |
||||
hi def link rustCharacterInvalidUnicode rustCharacterInvalid |
||||
hi def link rustCharacter Character |
||||
hi def link rustNumber Number |
||||
hi def link rustBoolean Boolean |
||||
hi def link rustEnum rustType |
||||
hi def link rustEnumVariant rustConstant |
||||
hi def link rustConstant Constant |
||||
hi def link rustSelf Constant |
||||
hi def link rustFloat Float |
||||
hi def link rustOperator Operator |
||||
hi def link rustKeyword Keyword |
||||
hi def link rustReservedKeyword Error |
||||
hi def link rustConditional Conditional |
||||
hi def link rustIdentifier Identifier |
||||
hi def link rustCapsIdent rustIdentifier |
||||
hi def link rustModPath Include |
||||
hi def link rustModPathSep Delimiter |
||||
hi def link rustFunction Function |
||||
hi def link rustFuncName Function |
||||
hi def link rustFuncCall Function |
||||
hi def link rustCommentLine Comment |
||||
hi def link rustCommentLineDoc SpecialComment |
||||
hi def link rustCommentBlock rustCommentLine |
||||
hi def link rustCommentBlockDoc rustCommentLineDoc |
||||
hi def link rustAssert PreCondit |
||||
hi def link rustPanic PreCondit |
||||
hi def link rustMacro Macro |
||||
hi def link rustType Type |
||||
hi def link rustTodo Todo |
||||
hi def link rustAttribute PreProc |
||||
hi def link rustDerive PreProc |
||||
hi def link rustStorage StorageClass |
||||
hi def link rustObsoleteStorage Error |
||||
hi def link rustLifetime Special |
||||
hi def link rustInvalidBareKeyword Error |
||||
hi def link rustExternCrate rustKeyword |
||||
hi def link rustObsoleteExternMod Error |
||||
hi def link rustBoxPlacementParens Delimiter |
||||
hi def link rustBoxPlacementExpr rustKeyword |
||||
|
||||
" Other Suggestions: |
||||
" hi rustAttribute ctermfg=cyan |
||||
" hi rustDerive ctermfg=cyan |
||||
" hi rustAssert ctermfg=yellow |
||||
" hi rustPanic ctermfg=red |
||||
" hi rustMacro ctermfg=magenta |
||||
|
||||
syn sync minlines=200 |
||||
syn sync maxlines=500 |
||||
|
||||
let b:current_syntax = "rust" |
||||
@ -0,0 +1,35 @@ |
||||
" Vim syntastic plugin |
||||
" Language: Rust |
||||
" Maintainer: Andrew Gallant <jamslam@gmail.com> |
||||
" |
||||
" See for details on how to add an external Syntastic checker: |
||||
" https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide#external |
||||
|
||||
if exists("g:loaded_syntastic_rust_rustc_checker") |
||||
finish |
||||
endif |
||||
let g:loaded_syntastic_rust_rustc_checker = 1 |
||||
|
||||
let s:save_cpo = &cpo |
||||
set cpo&vim |
||||
|
||||
function! SyntaxCheckers_rust_rustc_GetLocList() dict |
||||
let makeprg = self.makeprgBuild({ 'args': '-Zparse-only' }) |
||||
|
||||
let errorformat = |
||||
\ '%E%f:%l:%c: %\d%#:%\d%# %.%\{-}error:%.%\{-} %m,' . |
||||
\ '%W%f:%l:%c: %\d%#:%\d%# %.%\{-}warning:%.%\{-} %m,' . |
||||
\ '%C%f:%l %m,' . |
||||
\ '%-Z%.%#' |
||||
|
||||
return SyntasticMake({ |
||||
\ 'makeprg': makeprg, |
||||
\ 'errorformat': errorformat }) |
||||
endfunction |
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({ |
||||