Add Rust syntax formatting
This commit is contained in:
parent
fb07c25466
commit
1706e93f17
37 changed files with 3841 additions and 0 deletions
9
pack/acp/start/rust.vim/.github/workflows/ci.yml
vendored
Normal file
9
pack/acp/start/rust.vim/.github/workflows/ci.yml
vendored
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
on: push
|
||||
jobs:
|
||||
test:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Run tests
|
||||
run: cd test && ./run-tests
|
||||
shell: bash
|
||||
1
pack/acp/start/rust.vim/.gitignore
vendored
Normal file
1
pack/acp/start/rust.vim/.gitignore
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
/doc/tags
|
||||
10
pack/acp/start/rust.vim/.vintrc.yml
Normal file
10
pack/acp/start/rust.vim/.vintrc.yml
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
cmdargs:
|
||||
# Checking more strictly
|
||||
severity: style_problem
|
||||
|
||||
policies:
|
||||
# Disable a violation
|
||||
ProhibitUnnecessaryDoubleQuote:
|
||||
enabled: false
|
||||
ProhibitImplicitScopeVariable:
|
||||
enabled: false
|
||||
28
pack/acp/start/rust.vim/ISSUE_TEMPLATE.md
Normal file
28
pack/acp/start/rust.vim/ISSUE_TEMPLATE.md
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
<!--
|
||||
|
||||
Hi, and thanks for reporting an issue with rust.vim.
|
||||
|
||||
Details about your environment will help us assist you.
|
||||
|
||||
Please edit this template!
|
||||
|
||||
-->
|
||||
|
||||
* rust.vim version: <!-- Describe if you use a Vim plugin manager, and you
|
||||
can use it to tell which version of rust.vim you are running. -->
|
||||
|
||||
Steps to reproduce:
|
||||
|
||||
<!-- It's best to try to reproduce the issue with the master version of
|
||||
rust.vim. The issue may already be fixed! -->
|
||||
_?_
|
||||
|
||||
Expected vs. actual behavior:
|
||||
|
||||
_?_
|
||||
|
||||
Paste debugging info from the Rust Vim plugin via _one_ of the following
|
||||
commands: `:RustInfo`, `:RustInfoToClipboard`, or `:RustInfoToFile <filename>`.
|
||||
<!-- To ensure these commands are available, open a Rust source file first. -->
|
||||
|
||||
_?_
|
||||
201
pack/acp/start/rust.vim/LICENSE-APACHE
Normal file
201
pack/acp/start/rust.vim/LICENSE-APACHE
Normal file
|
|
@ -0,0 +1,201 @@
|
|||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
25
pack/acp/start/rust.vim/LICENSE-MIT
Normal file
25
pack/acp/start/rust.vim/LICENSE-MIT
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
Copyright (c) 2015 The Rust Project Developers
|
||||
|
||||
Permission is hereby granted, free of charge, to any
|
||||
person obtaining a copy of this software and associated
|
||||
documentation files (the "Software"), to deal in the
|
||||
Software without restriction, including without
|
||||
limitation the rights to use, copy, modify, merge,
|
||||
publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software
|
||||
is furnished to do so, subject to the following
|
||||
conditions:
|
||||
|
||||
The above copyright notice and this permission notice
|
||||
shall be included in all copies or substantial portions
|
||||
of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
135
pack/acp/start/rust.vim/README.md
Normal file
135
pack/acp/start/rust.vim/README.md
Normal file
|
|
@ -0,0 +1,135 @@
|
|||
# rust.vim
|
||||
|
||||
## Description
|
||||
|
||||
This is a Vim plugin that provides [Rust][r] file detection, syntax highlighting, formatting,
|
||||
[Syntastic][syn] integration, and more. It requires Vim 8 or higher for full functionality.
|
||||
Some things may not work on earlier versions.
|
||||
|
||||
## Installation
|
||||
|
||||
For activating the full functionality, this plugin requires either the plugin
|
||||
manager or the `.vimrc` to have the following:
|
||||
|
||||
```vim
|
||||
syntax enable
|
||||
filetype plugin indent on
|
||||
```
|
||||
|
||||
Most plugin managers don't do this automatically, so these statements are
|
||||
usually added by users in their `vimrc` _right after_ the plugin manager load
|
||||
section.
|
||||
|
||||
### [Vim8 packages][vim8pack]
|
||||
|
||||
```sh
|
||||
git clone https://github.com/rust-lang/rust.vim ~/.vim/pack/plugins/start/rust.vim
|
||||
```
|
||||
|
||||
### [Vundle][v]
|
||||
|
||||
```vim
|
||||
Plugin 'rust-lang/rust.vim'
|
||||
```
|
||||
|
||||
### [Pathogen][p]
|
||||
|
||||
```sh
|
||||
git clone --depth=1 https://github.com/rust-lang/rust.vim.git ~/.vim/bundle/rust.vim
|
||||
```
|
||||
|
||||
### [vim-plug][vp]
|
||||
|
||||
```vim
|
||||
Plug 'rust-lang/rust.vim'
|
||||
```
|
||||
|
||||
### [dein.vim][d]
|
||||
|
||||
```vim
|
||||
call dein#add('rust-lang/rust.vim')
|
||||
```
|
||||
|
||||
### [NeoBundle][nb]
|
||||
|
||||
```vim
|
||||
NeoBundle 'rust-lang/rust.vim'
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
### Error checking with [Syntastic][syn]
|
||||
|
||||
`rust.vim` automatically registers `cargo` as a syntax checker with
|
||||
[Syntastic][syn], if nothing else is specified. See `:help rust-syntastic`
|
||||
for more details.
|
||||
|
||||
### Source browsing with [Tagbar][tgbr]
|
||||
|
||||
The installation of Tagbar along with [Universal Ctags][uctags] is recommended
|
||||
for a good Tagbar experience. For other kinds of setups, `rust.vim` tries to
|
||||
configure Tagbar to some degree.
|
||||
|
||||
### Formatting with [rustfmt][rfmt]
|
||||
|
||||
The `:RustFmt` command will format your code with
|
||||
[rustfmt][rfmt] if installed. `rustfmt` can be installed
|
||||
via `rustup component add rustfmt`.
|
||||
|
||||
Placing `let g:rustfmt_autosave = 1` in your `~/.vimrc` will
|
||||
enable automatic running of `:RustFmt` when you save a buffer.
|
||||
|
||||
Do `:help :RustFmt` for further formatting help and customization
|
||||
options.
|
||||
|
||||
### [Playpen][pp] integration
|
||||
|
||||
*Note:* This feature requires [webapi-vim][wav] to be installed.
|
||||
|
||||
The `:RustPlay` command will send the current selection, or if
|
||||
nothing is selected the current buffer, to the [Rust playpen][pp].
|
||||
|
||||
If you set g:rust_clip_command RustPlay will copy the url to the clipboard.
|
||||
|
||||
- Mac:
|
||||
|
||||
let g:rust_clip_command = 'pbcopy'
|
||||
|
||||
- Linux:
|
||||
|
||||
let g:rust_clip_command = 'xclip -selection clipboard'
|
||||
|
||||
### Running a test under cursor
|
||||
|
||||
In a Cargo project, the `:RustTest` command will run the test that is under the cursor.
|
||||
This is useful when your project is big and running all of the tests takes a long time.
|
||||
|
||||
## Help
|
||||
|
||||
Further help can be found in the documentation with `:Helptags` then `:help rust`.
|
||||
|
||||
Detailed help can be found in the documentation with `:help rust`.
|
||||
Helptags (`:help helptags`) need to be generated for this plugin
|
||||
in order to navigate the help. Most plugin managers will do this
|
||||
automatically, but check their documentation if that is not the case.
|
||||
|
||||
## License
|
||||
|
||||
Like Rust, rust.vim is primarily distributed under the terms of both the MIT
|
||||
license and the Apache License (Version 2.0). See LICENSE-APACHE and
|
||||
LICENSE-MIT for details.
|
||||
|
||||
[r]: https://www.rust-lang.org
|
||||
[v]: https://github.com/gmarik/vundle
|
||||
[vqs]: https://github.com/gmarik/vundle#quick-start
|
||||
[p]: https://github.com/tpope/vim-pathogen
|
||||
[nb]: https://github.com/Shougo/neobundle.vim
|
||||
[vp]: https://github.com/junegunn/vim-plug
|
||||
[d]: https://github.com/Shougo/dein.vim
|
||||
[rfmt]: https://github.com/rust-lang-nursery/rustfmt
|
||||
[syn]: https://github.com/scrooloose/syntastic
|
||||
[tgbr]: https://github.com/majutsushi/tagbar
|
||||
[uctags]: https://ctags.io
|
||||
[wav]: https://github.com/mattn/webapi-vim
|
||||
[pp]: https://play.rust-lang.org/
|
||||
[vim8pack]: http://vimhelp.appspot.com/repeat.txt.html#packages
|
||||
41
pack/acp/start/rust.vim/after/syntax/rust.vim
Normal file
41
pack/acp/start/rust.vim/after/syntax/rust.vim
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
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 get(g:, 'rust_conceal_mod_path', 0)
|
||||
syn match rustNiceOperator "::" conceal cchar=ㆍ
|
||||
endif
|
||||
|
||||
syn match rustRightArrowHead contained ">" conceal cchar=
|
||||
syn match rustRightArrowTail contained "-" conceal cchar=⟶
|
||||
syn match rustNiceOperator "->" contains=rustRightArrowHead,rustRightArrowTail
|
||||
|
||||
syn match rustFatRightArrowHead contained ">" conceal cchar=
|
||||
syn match rustFatRightArrowTail contained "=" conceal cchar=⟹
|
||||
syn match rustNiceOperator "=>" contains=rustFatRightArrowHead,rustFatRightArrowTail
|
||||
|
||||
syn match rustNiceOperator /\<\@!_\(_*\>\)\@=/ conceal cchar=′
|
||||
|
||||
" For those who don't want to see `pub`...
|
||||
if get(g:, 'rust_conceal_pub', 0)
|
||||
syn match rustPublicSigil contained "pu" conceal cchar=＊
|
||||
syn match rustPublicRest contained "b" conceal cchar=
|
||||
syn match rustNiceOperator "pub " contains=rustPublicSigil,rustPublicRest
|
||||
endif
|
||||
|
||||
hi link rustNiceOperator Operator
|
||||
|
||||
if !get(g:, 'rust_conceal_mod_path', 0)
|
||||
hi! link Conceal Operator
|
||||
|
||||
augroup rust.vim.after
|
||||
autocmd!
|
||||
" And keep it after a colorscheme change
|
||||
autocmd ColorScheme <buffer> hi! link Conceal Operator
|
||||
augroup END
|
||||
endif
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
147
pack/acp/start/rust.vim/autoload/cargo.vim
Normal file
147
pack/acp/start/rust.vim/autoload/cargo.vim
Normal file
|
|
@ -0,0 +1,147 @@
|
|||
function! cargo#Load()
|
||||
" Utility call to get this script loaded, for debugging
|
||||
endfunction
|
||||
|
||||
function! cargo#cmd(args) abort
|
||||
" Trim trailing spaces. This is necessary since :terminal command parses
|
||||
" trailing spaces as an empty argument.
|
||||
let args = substitute(a:args, '\s\+$', '', '')
|
||||
if exists('g:cargo_shell_command_runner')
|
||||
let cmd = g:cargo_shell_command_runner
|
||||
elseif has('terminal')
|
||||
let cmd = 'terminal'
|
||||
elseif has('nvim')
|
||||
let cmd = 'noautocmd new | terminal'
|
||||
else
|
||||
let cmd = '!'
|
||||
endif
|
||||
execute cmd 'cargo' args
|
||||
endfunction
|
||||
|
||||
function! s:nearest_cargo(...) abort
|
||||
" If the second argument is not specified, the first argument determines
|
||||
" whether we will start from the current directory or the directory of the
|
||||
" current buffer, otherwise, we start with the provided path on the
|
||||
" second argument.
|
||||
|
||||
let l:is_getcwd = get(a:, 1, 0)
|
||||
if l:is_getcwd
|
||||
let l:starting_path = get(a:, 2, getcwd())
|
||||
else
|
||||
let l:starting_path = get(a:, 2, expand('%:p:h'))
|
||||
endif
|
||||
|
||||
return findfile('Cargo.toml', l:starting_path . ';')
|
||||
endfunction
|
||||
|
||||
function! cargo#nearestCargo(is_getcwd) abort
|
||||
return s:nearest_cargo(a:is_getcwd)
|
||||
endfunction
|
||||
|
||||
function! cargo#nearestWorkspaceCargo(is_getcwd) abort
|
||||
let l:nearest = s:nearest_cargo(a:is_getcwd)
|
||||
while l:nearest !=# ''
|
||||
for l:line in readfile(l:nearest, '', 0x100)
|
||||
if l:line =~# '\V[workspace]'
|
||||
return l:nearest
|
||||
endif
|
||||
endfor
|
||||
let l:next = fnamemodify(l:nearest, ':p:h:h')
|
||||
let l:nearest = s:nearest_cargo(0, l:next)
|
||||
endwhile
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
function! cargo#nearestRootCargo(is_getcwd) abort
|
||||
" Try to find a workspace Cargo.toml, and if not found, take the nearest
|
||||
" regular Cargo.toml
|
||||
let l:workspace_cargo = cargo#nearestWorkspaceCargo(a:is_getcwd)
|
||||
if l:workspace_cargo !=# ''
|
||||
return l:workspace_cargo
|
||||
endif
|
||||
return s:nearest_cargo(a:is_getcwd)
|
||||
endfunction
|
||||
|
||||
|
||||
function! cargo#build(args)
|
||||
call cargo#cmd("build " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#check(args)
|
||||
call cargo#cmd("check " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#clean(args)
|
||||
call cargo#cmd("clean " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#doc(args)
|
||||
call cargo#cmd("doc " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#new(args)
|
||||
call cargo#cmd("new " . a:args)
|
||||
cd `=a:args`
|
||||
endfunction
|
||||
|
||||
function! cargo#init(args)
|
||||
call cargo#cmd("init " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#run(args)
|
||||
call cargo#cmd("run " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#test(args)
|
||||
call cargo#cmd("test " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#bench(args)
|
||||
call cargo#cmd("bench " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#update(args)
|
||||
call cargo#cmd("update " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#search(args)
|
||||
call cargo#cmd("search " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#publish(args)
|
||||
call cargo#cmd("publish " . a:args)
|
||||
endfunction
|
||||
|
||||
function! cargo#install(args)
|
||||
call cargo#cmd("install " . 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:
|
||||
27
pack/acp/start/rust.vim/autoload/cargo/quickfix.vim
Normal file
27
pack/acp/start/rust.vim/autoload/cargo/quickfix.vim
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
function! cargo#quickfix#CmdPre() abort
|
||||
if &filetype ==# 'rust' && get(b:, 'current_compiler', '') ==# 'cargo' &&
|
||||
\ &makeprg =~ '\V\^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:
|
||||
570
pack/acp/start/rust.vim/autoload/rust.vim
Normal file
570
pack/acp/start/rust.vim/autoload/rust.vim
Normal file
|
|
@ -0,0 +1,570 @@
|
|||
" Description: Helper functions for Rust commands/mappings
|
||||
" Last Modified: May 27, 2014
|
||||
" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
|
||||
|
||||
function! rust#Load()
|
||||
" Utility call to get this script loaded, for debugging
|
||||
endfunction
|
||||
|
||||
function! rust#GetConfigVar(name, default)
|
||||
" Local buffer variable with same name takes predeence over global
|
||||
if has_key(b:, a:name)
|
||||
return get(b:, a:name)
|
||||
endif
|
||||
if has_key(g:, a:name)
|
||||
return get(g:, a:name)
|
||||
endif
|
||||
return a:default
|
||||
endfunction
|
||||
|
||||
" Include expression {{{1
|
||||
|
||||
function! rust#IncludeExpr(fname) abort
|
||||
" Remove leading 'crate::' to deal with 2018 edition style 'use'
|
||||
" statements
|
||||
let l:fname = substitute(a:fname, '^crate::', '', '')
|
||||
|
||||
" Remove trailing colons arising from lines like
|
||||
"
|
||||
" use foo::{Bar, Baz};
|
||||
let l:fname = substitute(l:fname, ':\+$', '', '')
|
||||
|
||||
" Replace '::' with '/'
|
||||
let l:fname = substitute(l:fname, '::', '/', 'g')
|
||||
|
||||
" When we have
|
||||
"
|
||||
" use foo::bar::baz;
|
||||
"
|
||||
" we can't tell whether baz is a module or a function; and we can't tell
|
||||
" which modules correspond to files.
|
||||
"
|
||||
" So we work our way up, trying
|
||||
"
|
||||
" foo/bar/baz.rs
|
||||
" foo/bar.rs
|
||||
" foo.rs
|
||||
while l:fname !=# '.'
|
||||
let l:path = findfile(l:fname)
|
||||
if !empty(l:path)
|
||||
return l:fname
|
||||
endif
|
||||
let l:fname = fnamemodify(l:fname, ':h')
|
||||
endwhile
|
||||
return l:fname
|
||||
endfunction
|
||||
|
||||
" Jump {{{1
|
||||
|
||||
function! rust#Jump(mode, function) range
|
||||
let cnt = v:count1
|
||||
normal! m'
|
||||
if a:mode ==# 'v'
|
||||
norm! gv
|
||||
endif
|
||||
let foldenable = &foldenable
|
||||
set nofoldenable
|
||||
while cnt > 0
|
||||
execute "call <SID>Jump_" . a:function . "()"
|
||||
let cnt = cnt - 1
|
||||
endwhile
|
||||
let &foldenable = foldenable
|
||||
endfunction
|
||||
|
||||
function! s:Jump_Back()
|
||||
call search('{', 'b')
|
||||
keepjumps normal! w99[{
|
||||
endfunction
|
||||
|
||||
function! s:Jump_Forward()
|
||||
normal! j0
|
||||
call search('{', 'b')
|
||||
keepjumps normal! w99[{%
|
||||
call search('{')
|
||||
endfunction
|
||||
|
||||
" Run {{{1
|
||||
|
||||
function! rust#Run(bang, args)
|
||||
let args = s:ShellTokenize(a:args)
|
||||
if a:bang
|
||||
let idx = index(l:args, '--')
|
||||
if idx != -1
|
||||
let rustc_args = idx == 0 ? [] : l:args[:idx-1]
|
||||
let args = l:args[idx+1:]
|
||||
else
|
||||
let rustc_args = l:args
|
||||
let args = []
|
||||
endif
|
||||
else
|
||||
let rustc_args = []
|
||||
endif
|
||||
|
||||
let b:rust_last_rustc_args = l:rustc_args
|
||||
let b:rust_last_args = l:args
|
||||
|
||||
call s:WithPath(function("s:Run"), rustc_args, args)
|
||||
endfunction
|
||||
|
||||
function! s:Run(dict, rustc_args, args)
|
||||
let exepath = a:dict.tmpdir.'/'.fnamemodify(a:dict.path, ':t:r')
|
||||
if has('win32')
|
||||
let exepath .= '.exe'
|
||||
endif
|
||||
|
||||
let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
|
||||
let rustc_args = [relpath, '-o', exepath] + a:rustc_args
|
||||
|
||||
let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
|
||||
|
||||
let pwd = a:dict.istemp ? a:dict.tmpdir : ''
|
||||
let output = s:system(pwd, shellescape(rustc) . " " . join(map(rustc_args, 'shellescape(v:val)')))
|
||||
if output !=# ''
|
||||
echohl WarningMsg
|
||||
echo output
|
||||
echohl None
|
||||
endif
|
||||
if !v:shell_error
|
||||
exe '!' . shellescape(exepath) . " " . join(map(a:args, 'shellescape(v:val)'))
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" Expand {{{1
|
||||
|
||||
function! rust#Expand(bang, args)
|
||||
let args = s:ShellTokenize(a:args)
|
||||
if a:bang && !empty(l:args)
|
||||
let pretty = remove(l:args, 0)
|
||||
else
|
||||
let pretty = "expanded"
|
||||
endif
|
||||
call s:WithPath(function("s:Expand"), pretty, args)
|
||||
endfunction
|
||||
|
||||
function! s:Expand(dict, pretty, args)
|
||||
try
|
||||
let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
|
||||
|
||||
if a:pretty =~? '^\%(everybody_loops$\|flowgraph=\)'
|
||||
let flag = '--xpretty'
|
||||
else
|
||||
let flag = '--pretty'
|
||||
endif
|
||||
let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
|
||||
let args = [relpath, '-Z', 'unstable-options', l:flag, a:pretty] + a:args
|
||||
let pwd = a:dict.istemp ? a:dict.tmpdir : ''
|
||||
let output = s:system(pwd, shellescape(rustc) . " " . join(map(args, 'shellescape(v:val)')))
|
||||
if v:shell_error
|
||||
echohl WarningMsg
|
||||
echo output
|
||||
echohl None
|
||||
else
|
||||
new
|
||||
silent put =output
|
||||
1
|
||||
d
|
||||
setl filetype=rust
|
||||
setl buftype=nofile
|
||||
setl bufhidden=hide
|
||||
setl noswapfile
|
||||
" give the buffer a nice name
|
||||
let suffix = 1
|
||||
let basename = fnamemodify(a:dict.path, ':t:r')
|
||||
while 1
|
||||
let bufname = basename
|
||||
if suffix > 1 | let bufname .= ' ('.suffix.')' | endif
|
||||
let bufname .= '.pretty.rs'
|
||||
if bufexists(bufname)
|
||||
let suffix += 1
|
||||
continue
|
||||
endif
|
||||
exe 'silent noautocmd keepalt file' fnameescape(bufname)
|
||||
break
|
||||
endwhile
|
||||
endif
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
function! rust#CompleteExpand(lead, line, pos)
|
||||
if a:line[: a:pos-1] =~# '^RustExpand!\s*\S*$'
|
||||
" first argument and it has a !
|
||||
let list = ["normal", "expanded", "typed", "expanded,identified", "flowgraph=", "everybody_loops"]
|
||||
if !empty(a:lead)
|
||||
call filter(list, "v:val[:len(a:lead)-1] == a:lead")
|
||||
endif
|
||||
return list
|
||||
endif
|
||||
|
||||
return glob(escape(a:lead, "*?[") . '*', 0, 1)
|
||||
endfunction
|
||||
|
||||
" Emit {{{1
|
||||
|
||||
function! rust#Emit(type, args)
|
||||
let args = s:ShellTokenize(a:args)
|
||||
call s:WithPath(function("s:Emit"), a:type, args)
|
||||
endfunction
|
||||
|
||||
function! s:Emit(dict, type, args)
|
||||
try
|
||||
let output_path = a:dict.tmpdir.'/output'
|
||||
|
||||
let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
|
||||
|
||||
let relpath = get(a:dict, 'tmpdir_relpath', a:dict.path)
|
||||
let args = [relpath, '--emit', a:type, '-o', output_path] + a:args
|
||||
let pwd = a:dict.istemp ? a:dict.tmpdir : ''
|
||||
let output = s:system(pwd, shellescape(rustc) . " " . join(map(args, 'shellescape(v:val)')))
|
||||
if output !=# ''
|
||||
echohl WarningMsg
|
||||
echo output
|
||||
echohl None
|
||||
endif
|
||||
if !v:shell_error
|
||||
new
|
||||
exe 'silent keepalt read' fnameescape(output_path)
|
||||
1
|
||||
d
|
||||
if a:type ==# "llvm-ir"
|
||||
setl filetype=llvm
|
||||
let extension = 'll'
|
||||
elseif a:type ==# "asm"
|
||||
setl filetype=asm
|
||||
let extension = 's'
|
||||
endif
|
||||
setl buftype=nofile
|
||||
setl bufhidden=hide
|
||||
setl noswapfile
|
||||
if exists('l:extension')
|
||||
" give the buffer a nice name
|
||||
let suffix = 1
|
||||
let basename = fnamemodify(a:dict.path, ':t:r')
|
||||
while 1
|
||||
let bufname = basename
|
||||
if suffix > 1 | let bufname .= ' ('.suffix.')' | endif
|
||||
let bufname .= '.'.extension
|
||||
if bufexists(bufname)
|
||||
let suffix += 1
|
||||
continue
|
||||
endif
|
||||
exe 'silent noautocmd keepalt file' fnameescape(bufname)
|
||||
break
|
||||
endwhile
|
||||
endif
|
||||
endif
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
" Utility functions {{{1
|
||||
|
||||
" Invokes func(dict, ...)
|
||||
" Where {dict} is a dictionary with the following keys:
|
||||
" 'path' - The path to the file
|
||||
" 'tmpdir' - The path to a temporary directory that will be deleted when the
|
||||
" function returns.
|
||||
" 'istemp' - 1 if the path is a file inside of {dict.tmpdir} or 0 otherwise.
|
||||
" If {istemp} is 1 then an additional key is provided:
|
||||
" 'tmpdir_relpath' - The {path} relative to the {tmpdir}.
|
||||
"
|
||||
" {dict.path} may be a path to a file inside of {dict.tmpdir} or it may be the
|
||||
" existing path of the current buffer. If the path is inside of {dict.tmpdir}
|
||||
" then it is guaranteed to have a '.rs' extension.
|
||||
function! s:WithPath(func, ...)
|
||||
let buf = bufnr('')
|
||||
let saved = {}
|
||||
let dict = {}
|
||||
try
|
||||
let saved.write = &write
|
||||
set write
|
||||
let dict.path = expand('%')
|
||||
let pathisempty = empty(dict.path)
|
||||
|
||||
" Always create a tmpdir in case the wrapped command wants it
|
||||
let dict.tmpdir = tempname()
|
||||
call mkdir(dict.tmpdir)
|
||||
|
||||
if pathisempty || !saved.write
|
||||
let dict.istemp = 1
|
||||
" if we're doing this because of nowrite, preserve the filename
|
||||
if !pathisempty
|
||||
let filename = expand('%:t:r').".rs"
|
||||
else
|
||||
let filename = 'unnamed.rs'
|
||||
endif
|
||||
let dict.tmpdir_relpath = filename
|
||||
let dict.path = dict.tmpdir.'/'.filename
|
||||
|
||||
let saved.mod = &modified
|
||||
set nomodified
|
||||
|
||||
silent exe 'keepalt write! ' . fnameescape(dict.path)
|
||||
if pathisempty
|
||||
silent keepalt 0file
|
||||
endif
|
||||
else
|
||||
let dict.istemp = 0
|
||||
update
|
||||
endif
|
||||
|
||||
call call(a:func, [dict] + a:000)
|
||||
finally
|
||||
if bufexists(buf)
|
||||
for [opt, value] in items(saved)
|
||||
silent call setbufvar(buf, '&'.opt, value)
|
||||
unlet value " avoid variable type mismatches
|
||||
endfor
|
||||
endif
|
||||
if has_key(dict, 'tmpdir') | silent call s:RmDir(dict.tmpdir) | endif
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
function! rust#AppendCmdLine(text)
|
||||
call setcmdpos(getcmdpos())
|
||||
let cmd = getcmdline() . a:text
|
||||
return cmd
|
||||
endfunction
|
||||
|
||||
" Tokenize the string according to sh parsing rules
|
||||
function! s:ShellTokenize(text)
|
||||
" states:
|
||||
" 0: start of word
|
||||
" 1: unquoted
|
||||
" 2: unquoted backslash
|
||||
" 3: double-quote
|
||||
" 4: double-quoted backslash
|
||||
" 5: single-quote
|
||||
let l:state = 0
|
||||
let l:current = ''
|
||||
let l:args = []
|
||||
for c in split(a:text, '\zs')
|
||||
if l:state == 0 || l:state == 1 " unquoted
|
||||
if l:c ==# ' '
|
||||
if l:state == 0 | continue | endif
|
||||
call add(l:args, l:current)
|
||||
let l:current = ''
|
||||
let l:state = 0
|
||||
elseif l:c ==# '\'
|
||||
let l:state = 2
|
||||
elseif l:c ==# '"'
|
||||
let l:state = 3
|
||||
elseif l:c ==# "'"
|
||||
let l:state = 5
|
||||
else
|
||||
let l:current .= l:c
|
||||
let l:state = 1
|
||||
endif
|
||||
elseif l:state == 2 " unquoted backslash
|
||||
if l:c !=# "\n" " can it even be \n?
|
||||
let l:current .= l:c
|
||||
endif
|
||||
let l:state = 1
|
||||
elseif l:state == 3 " double-quote
|
||||
if l:c ==# '\'
|
||||
let l:state = 4
|
||||
elseif l:c ==# '"'
|
||||
let l:state = 1
|
||||
else
|
||||
let l:current .= l:c
|
||||
endif
|
||||
elseif l:state == 4 " double-quoted backslash
|
||||
if stridx('$`"\', l:c) >= 0
|
||||
let l:current .= l:c
|
||||
elseif l:c ==# "\n" " is this even possible?
|
||||
" skip it
|
||||
else
|
||||
let l:current .= '\'.l:c
|
||||
endif
|
||||
let l:state = 3
|
||||
elseif l:state == 5 " single-quoted
|
||||
if l:c ==# "'"
|
||||
let l:state = 1
|
||||
else
|
||||
let l:current .= l:c
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
if l:state != 0
|
||||
call add(l:args, l:current)
|
||||
endif
|
||||
return l:args
|
||||
endfunction
|
||||
|
||||
function! s:RmDir(path)
|
||||
" sanity check; make sure it's not empty, /, or $HOME
|
||||
if empty(a:path)
|
||||
echoerr 'Attempted to delete empty path'
|
||||
return 0
|
||||
elseif a:path ==# '/' || a:path ==# $HOME
|
||||
let l:path = expand(a:path)
|
||||
if l:path ==# '/' || l:path ==# $HOME
|
||||
echoerr 'Attempted to delete protected path: ' . a:path
|
||||
return 0
|
||||
endif
|
||||
endif
|
||||
|
||||
if !isdirectory(a:path)
|
||||
return 0
|
||||
endif
|
||||
|
||||
" delete() returns 0 when removing file successfully
|
||||
return delete(a:path, 'rf') == 0
|
||||
endfunction
|
||||
|
||||
" Executes {cmd} with the cwd set to {pwd}, without changing Vim's cwd.
|
||||
" If {pwd} is the empty string then it doesn't change the cwd.
|
||||
function! s:system(pwd, cmd)
|
||||
let cmd = a:cmd
|
||||
if !empty(a:pwd)
|
||||
let cmd = 'cd ' . shellescape(a:pwd) . ' && ' . cmd
|
||||
endif
|
||||
return system(cmd)
|
||||
endfunction
|
||||
|
||||
" Playpen Support {{{1
|
||||
" Parts of gist.vim by Yasuhiro Matsumoto <mattn.jp@gmail.com> reused
|
||||
" gist.vim available under the BSD license, available at
|
||||
" http://github.com/mattn/gist-vim
|
||||
function! s:has_webapi()
|
||||
if !exists("*webapi#http#post")
|
||||
try
|
||||
call webapi#http#post()
|
||||
catch
|
||||
endtry
|
||||
endif
|
||||
return exists("*webapi#http#post")
|
||||
endfunction
|
||||
|
||||
function! rust#Play(count, line1, line2, ...) abort
|
||||
redraw
|
||||
|
||||
let l:rust_playpen_url = get(g:, 'rust_playpen_url', 'https://play.rust-lang.org/')
|
||||
let l:rust_shortener_url = get(g:, 'rust_shortener_url', 'https://is.gd/')
|
||||
|
||||
if !s:has_webapi()
|
||||
echohl ErrorMsg | echomsg ':RustPlay depends on webapi.vim (https://github.com/mattn/webapi-vim)' | echohl None
|
||||
return
|
||||
endif
|
||||
|
||||
let bufname = bufname('%')
|
||||
if a:count < 1
|
||||
let content = join(getline(a:line1, a:line2), "\n")
|
||||
else
|
||||
let save_regcont = @"
|
||||
let save_regtype = getregtype('"')
|
||||
silent! normal! gvy
|
||||
let content = @"
|
||||
call setreg('"', save_regcont, save_regtype)
|
||||
endif
|
||||
|
||||
let url = l:rust_playpen_url."?code=".webapi#http#encodeURI(content)
|
||||
|
||||
if strlen(url) > 5000
|
||||
echohl ErrorMsg | echomsg 'Buffer too large, max 5000 encoded characters ('.strlen(url).')' | echohl None
|
||||
return
|
||||
endif
|
||||
|
||||
let payload = "format=simple&url=".webapi#http#encodeURI(url)
|
||||
let res = webapi#http#post(l:rust_shortener_url.'create.php', payload, {})
|
||||
if res.status[0] ==# '2'
|
||||
let url = res.content
|
||||
endif
|
||||
|
||||
let footer = ''
|
||||
if exists('g:rust_clip_command')
|
||||
call system(g:rust_clip_command, url)
|
||||
if !v:shell_error
|
||||
let footer = ' (copied to clipboard)'
|
||||
endif
|
||||
endif
|
||||
redraw | echomsg 'Done: '.url.footer
|
||||
endfunction
|
||||
|
||||
" Run a test under the cursor or all tests {{{1
|
||||
|
||||
" Finds a test function name under the cursor. Returns empty string when a
|
||||
" test function is not found.
|
||||
function! s:SearchTestFunctionNameUnderCursor() abort
|
||||
let cursor_line = line('.')
|
||||
|
||||
" Find #[test] attribute
|
||||
if search('\m\C#\[test\]', 'bcW') is 0
|
||||
return ''
|
||||
endif
|
||||
|
||||
" Move to an opening brace of the test function
|
||||
let test_func_line = search('\m\C^\s*fn\s\+\h\w*\s*(.\+{$', 'eW')
|
||||
if test_func_line is 0
|
||||
return ''
|
||||
endif
|
||||
|
||||
" Search the end of test function (closing brace) to ensure that the
|
||||
" cursor position is within function definition
|
||||
if maparg('<Plug>(MatchitNormalForward)') ==# ''
|
||||
keepjumps normal! %
|
||||
else
|
||||
" Prefer matchit.vim official plugin to native % since the plugin
|
||||
" provides better behavior than original % (#391)
|
||||
" To load the plugin, run:
|
||||
" :packadd matchit
|
||||
execute 'keepjumps' 'normal' "\<Plug>(MatchitNormalForward)"
|
||||
endif
|
||||
if line('.') < cursor_line
|
||||
return ''
|
||||
endif
|
||||
|
||||
return matchstr(getline(test_func_line), '\m\C^\s*fn\s\+\zs\h\w*')
|
||||
endfunction
|
||||
|
||||
function! rust#Test(mods, winsize, all, options) abort
|
||||
let manifest = findfile('Cargo.toml', expand('%:p:h') . ';')
|
||||
if manifest ==# ''
|
||||
return rust#Run(1, '--test ' . a:options)
|
||||
endif
|
||||
|
||||
" <count> defaults to 0, but we prefer an empty string
|
||||
let winsize = a:winsize ? a:winsize : ''
|
||||
|
||||
if has('terminal')
|
||||
if has('patch-8.0.910')
|
||||
let cmd = printf('%s noautocmd %snew | terminal ++curwin ', a:mods, winsize)
|
||||
else
|
||||
let cmd = printf('%s terminal ', a:mods)
|
||||
endif
|
||||
elseif has('nvim')
|
||||
let cmd = printf('%s noautocmd %snew | terminal ', a:mods, winsize)
|
||||
else
|
||||
let cmd = '!'
|
||||
let manifest = shellescape(manifest)
|
||||
endif
|
||||
|
||||
if a:all
|
||||
if a:options ==# ''
|
||||
execute cmd . 'cargo test --manifest-path' manifest
|
||||
else
|
||||
execute cmd . 'cargo test --manifest-path' manifest a:options
|
||||
endif
|
||||
return
|
||||
endif
|
||||
|
||||
let saved = getpos('.')
|
||||
try
|
||||
let func_name = s:SearchTestFunctionNameUnderCursor()
|
||||
finally
|
||||
call setpos('.', saved)
|
||||
endtry
|
||||
if func_name ==# ''
|
||||
echohl ErrorMsg
|
||||
echomsg 'No test function was found under the cursor. Please add ! to command if you want to run all tests'
|
||||
echohl None
|
||||
return
|
||||
endif
|
||||
if a:options ==# ''
|
||||
execute cmd . 'cargo test --manifest-path' manifest func_name
|
||||
else
|
||||
execute cmd . 'cargo test --manifest-path' manifest func_name a:options
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
103
pack/acp/start/rust.vim/autoload/rust/debugging.vim
Normal file
103
pack/acp/start/rust.vim/autoload/rust/debugging.vim
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
" For debugging, inspired by https://github.com/w0rp/rust/blob/master/autoload/rust/debugging.vim
|
||||
|
||||
let s:global_variable_list = [
|
||||
\ '_rustfmt_autosave_because_of_config',
|
||||
\ '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_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
|
||||
if l:key !~# '^_'
|
||||
call s:Echo('let g:' . l:key . ' = ' . string(get(g:, l:key, v:null)))
|
||||
endif
|
||||
|
||||
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:
|
||||
44
pack/acp/start/rust.vim/autoload/rust/delimitmate.vim
Normal file
44
pack/acp/start/rust.vim/autoload/rust/delimitmate.vim
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
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:
|
||||
|
||||
18
pack/acp/start/rust.vim/autoload/rust/tags.vim
Normal file
18
pack/acp/start/rust.vim/autoload/rust/tags.vim
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
" Tagbar support code, for the sake of not automatically overriding its
|
||||
" configuration in case Universal Ctags is detected.
|
||||
|
||||
let s:ctags_is_uctags = 0
|
||||
let s:checked_ctags = 0
|
||||
|
||||
function! rust#tags#IsUCtags() abort
|
||||
if s:checked_ctags == 0
|
||||
let l:ctags_bin = get(g:, 'tagbar_ctags_bin', 'ctags')
|
||||
if system(l:ctags_bin.' --version') =~? 'universal ctags'
|
||||
let s:ctags_is_uctags = 1
|
||||
endif
|
||||
let s:checked_ctags = 1
|
||||
endif
|
||||
return s:ctags_is_uctags
|
||||
endfunction
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
260
pack/acp/start/rust.vim/autoload/rustfmt.vim
Normal file
260
pack/acp/start/rust.vim/autoload/rustfmt.vim
Normal file
|
|
@ -0,0 +1,260 @@
|
|||
" Author: Stephen Sugden <stephen@stephensugden.com>
|
||||
"
|
||||
" Adapted from https://github.com/fatih/vim-go
|
||||
" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
|
||||
|
||||
if !exists("g:rustfmt_autosave")
|
||||
let g:rustfmt_autosave = 0
|
||||
endif
|
||||
|
||||
if !exists("g:rustfmt_command")
|
||||
let g:rustfmt_command = "rustfmt"
|
||||
endif
|
||||
|
||||
if !exists("g:rustfmt_options")
|
||||
let g:rustfmt_options = ""
|
||||
endif
|
||||
|
||||
if !exists("g:rustfmt_fail_silently")
|
||||
let g:rustfmt_fail_silently = 0
|
||||
endif
|
||||
|
||||
function! rustfmt#DetectVersion()
|
||||
" Save rustfmt '--help' for feature inspection
|
||||
silent let s:rustfmt_help = system(g:rustfmt_command . " --help")
|
||||
let s:rustfmt_unstable_features = s:rustfmt_help =~# "--unstable-features"
|
||||
|
||||
" Build a comparable rustfmt version varible out of its `--version` output:
|
||||
silent let l:rustfmt_version_full = system(g:rustfmt_command . " --version")
|
||||
let l:rustfmt_version_list = matchlist(l:rustfmt_version_full,
|
||||
\ '\vrustfmt ([0-9]+[.][0-9]+[.][0-9]+)')
|
||||
if len(l:rustfmt_version_list) < 3
|
||||
let s:rustfmt_version = "0"
|
||||
else
|
||||
let s:rustfmt_version = l:rustfmt_version_list[1]
|
||||
endif
|
||||
return s:rustfmt_version
|
||||
endfunction
|
||||
|
||||
call rustfmt#DetectVersion()
|
||||
|
||||
if !exists("g:rustfmt_emit_files")
|
||||
let g:rustfmt_emit_files = s:rustfmt_version >= "0.8.2"
|
||||
endif
|
||||
|
||||
if !exists("g:rustfmt_file_lines")
|
||||
let g:rustfmt_file_lines = s:rustfmt_help =~# "--file-lines JSON"
|
||||
endif
|
||||
|
||||
let s:got_fmt_error = 0
|
||||
|
||||
function! rustfmt#Load()
|
||||
" Utility call to get this script loaded, for debugging
|
||||
endfunction
|
||||
|
||||
function! s:RustfmtWriteMode()
|
||||
if g:rustfmt_emit_files
|
||||
return "--emit=files"
|
||||
else
|
||||
return "--write-mode=overwrite"
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! s:RustfmtConfigOptions()
|
||||
let l:rustfmt_toml = findfile('rustfmt.toml', expand('%:p:h') . ';')
|
||||
if l:rustfmt_toml !=# ''
|
||||
return '--config-path '.shellescape(fnamemodify(l:rustfmt_toml, ":p"))
|
||||
endif
|
||||
|
||||
let l:_rustfmt_toml = findfile('.rustfmt.toml', expand('%:p:h') . ';')
|
||||
if l:_rustfmt_toml !=# ''
|
||||
return '--config-path '.shellescape(fnamemodify(l:_rustfmt_toml, ":p"))
|
||||
endif
|
||||
|
||||
" Default to edition 2018 in case no rustfmt.toml was found.
|
||||
return '--edition 2018'
|
||||
endfunction
|
||||
|
||||
function! s:RustfmtCommandRange(filename, line1, line2)
|
||||
if g:rustfmt_file_lines == 0
|
||||
echo "--file-lines is not supported in the installed `rustfmt` executable"
|
||||
return
|
||||
endif
|
||||
|
||||
let l:arg = {"file": shellescape(a:filename), "range": [a:line1, a:line2]}
|
||||
let l:write_mode = s:RustfmtWriteMode()
|
||||
let l:rustfmt_config = s:RustfmtConfigOptions()
|
||||
|
||||
" 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()
|
||||
let write_mode = g:rustfmt_emit_files ? '--emit=stdout' : '--write-mode=display'
|
||||
let config = s:RustfmtConfigOptions()
|
||||
return join([g:rustfmt_command, write_mode, config, g:rustfmt_options])
|
||||
endfunction
|
||||
|
||||
function! s:DeleteLines(start, end) abort
|
||||
silent! execute a:start . ',' . a:end . 'delete _'
|
||||
endfunction
|
||||
|
||||
function! s:RunRustfmt(command, tmpname, from_writepre)
|
||||
let l:view = winsaveview()
|
||||
|
||||
let l:stderr_tmpname = tempname()
|
||||
call writefile([], l:stderr_tmpname)
|
||||
|
||||
let l:command = a:command . ' 2> ' . l:stderr_tmpname
|
||||
|
||||
if a:tmpname ==# ''
|
||||
" Rustfmt in stdin/stdout mode
|
||||
|
||||
" chdir to the directory of the file
|
||||
let l:has_lcd = haslocaldir()
|
||||
let l:prev_cd = getcwd()
|
||||
execute 'lchdir! '.expand('%:h')
|
||||
|
||||
let l:buffer = getline(1, '$')
|
||||
if exists("*systemlist")
|
||||
silent let out = systemlist(l:command, l:buffer)
|
||||
else
|
||||
silent let out = split(system(l:command,
|
||||
\ join(l:buffer, "\n")), '\r\?\n')
|
||||
endif
|
||||
else
|
||||
if exists("*systemlist")
|
||||
silent let out = systemlist(l:command)
|
||||
else
|
||||
silent let out = split(system(l:command), '\r\?\n')
|
||||
endif
|
||||
endif
|
||||
|
||||
let l:stderr = readfile(l:stderr_tmpname)
|
||||
|
||||
call delete(l:stderr_tmpname)
|
||||
|
||||
let l:open_lwindow = 0
|
||||
if v:shell_error == 0
|
||||
if a:from_writepre
|
||||
" remove undo point caused via BufWritePre
|
||||
try | silent undojoin | catch | endtry
|
||||
endif
|
||||
|
||||
if a:tmpname ==# ''
|
||||
let l:content = l:out
|
||||
else
|
||||
" take the tmpfile's content, this is better than rename
|
||||
" because it preserves file modes.
|
||||
let l:content = readfile(a:tmpname)
|
||||
endif
|
||||
|
||||
call s:DeleteLines(len(l:content), line('$'))
|
||||
call setline(1, l:content)
|
||||
|
||||
" only clear location list if it was previously filled to prevent
|
||||
" clobbering other additions
|
||||
if s:got_fmt_error
|
||||
let s:got_fmt_error = 0
|
||||
call setloclist(0, [])
|
||||
let l:open_lwindow = 1
|
||||
endif
|
||||
elseif g:rustfmt_fail_silently == 0 && !a:from_writepre
|
||||
" otherwise get the errors and put them in the location list
|
||||
let l:errors = []
|
||||
|
||||
let l:prev_line = ""
|
||||
for l:line in l:stderr
|
||||
" error: expected one of `;` or `as`, found `extern`
|
||||
" --> src/main.rs:2:1
|
||||
let tokens = matchlist(l:line, '^\s\+-->\s\(.\{-}\):\(\d\+\):\(\d\+\)$')
|
||||
if !empty(tokens)
|
||||
call add(l:errors, {"filename": @%,
|
||||
\"lnum": tokens[2],
|
||||
\"col": tokens[3],
|
||||
\"text": l:prev_line})
|
||||
endif
|
||||
let l:prev_line = l:line
|
||||
endfor
|
||||
|
||||
if !empty(l:errors)
|
||||
call setloclist(0, l:errors, 'r')
|
||||
echohl Error | echomsg "rustfmt returned error" | echohl None
|
||||
else
|
||||
echo "rust.vim: was not able to parse rustfmt messages. Here is the raw output:"
|
||||
echo "\n"
|
||||
for l:line in l:stderr
|
||||
echo l:line
|
||||
endfor
|
||||
endif
|
||||
|
||||
let s:got_fmt_error = 1
|
||||
let l:open_lwindow = 1
|
||||
endif
|
||||
|
||||
" Restore the current directory if needed
|
||||
if a:tmpname ==# ''
|
||||
if l:has_lcd
|
||||
execute 'lchdir! '.l:prev_cd
|
||||
else
|
||||
execute 'chdir! '.l:prev_cd
|
||||
endif
|
||||
endif
|
||||
|
||||
" Open lwindow after we have changed back to the previous directory
|
||||
if l:open_lwindow == 1
|
||||
lwindow
|
||||
endif
|
||||
|
||||
call winrestview(l:view)
|
||||
endfunction
|
||||
|
||||
function! rustfmt#FormatRange(line1, line2)
|
||||
let l:tmpname = tempname()
|
||||
call writefile(getline(1, '$'), l:tmpname)
|
||||
let command = s:RustfmtCommandRange(l:tmpname, a:line1, a:line2)
|
||||
call s:RunRustfmt(command, l:tmpname, v:false)
|
||||
call delete(l:tmpname)
|
||||
endfunction
|
||||
|
||||
function! rustfmt#Format()
|
||||
call s:RunRustfmt(s:RustfmtCommand(), '', v:false)
|
||||
endfunction
|
||||
|
||||
function! rustfmt#Cmd()
|
||||
" Mainly for debugging
|
||||
return s:RustfmtCommand()
|
||||
endfunction
|
||||
|
||||
function! rustfmt#PreWrite()
|
||||
if !filereadable(expand("%@"))
|
||||
return
|
||||
endif
|
||||
if rust#GetConfigVar('rustfmt_autosave_if_config_present', 0)
|
||||
if findfile('rustfmt.toml', '.;') !=# '' || findfile('.rustfmt.toml', '.;') !=# ''
|
||||
let b:rustfmt_autosave = 1
|
||||
let b:_rustfmt_autosave_because_of_config = 1
|
||||
endif
|
||||
else
|
||||
if has_key(b:, '_rustfmt_autosave_because_of_config')
|
||||
unlet b:_rustfmt_autosave_because_of_config
|
||||
unlet b:rustfmt_autosave
|
||||
endif
|
||||
endif
|
||||
|
||||
if !rust#GetConfigVar("rustfmt_autosave", 0)
|
||||
return
|
||||
endif
|
||||
|
||||
call s:RunRustfmt(s:RustfmtCommand(), '', v:true)
|
||||
endfunction
|
||||
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
51
pack/acp/start/rust.vim/compiler/cargo.vim
Normal file
51
pack/acp/start/rust.vim/compiler/cargo.vim
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
" Vim compiler file
|
||||
" Compiler: Cargo Compiler
|
||||
" Maintainer: Damien Radtke <damienradtke@gmail.com>
|
||||
" Latest Revision: 2014 Sep 24
|
||||
" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
|
||||
|
||||
if exists('current_compiler')
|
||||
finish
|
||||
endif
|
||||
runtime compiler/rustc.vim
|
||||
let current_compiler = "cargo"
|
||||
|
||||
" vint: -ProhibitAbbreviationOption
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
" vint: +ProhibitAbbreviationOption
|
||||
|
||||
if exists(':CompilerSet') != 2
|
||||
command -nargs=* CompilerSet setlocal <args>
|
||||
endif
|
||||
|
||||
if exists('g:cargo_makeprg_params')
|
||||
execute 'CompilerSet makeprg=cargo\ '.escape(g:cargo_makeprg_params, ' \|"').'\ $*'
|
||||
else
|
||||
CompilerSet makeprg=cargo\ $*
|
||||
endif
|
||||
|
||||
augroup RustCargoQuickFixHooks
|
||||
autocmd!
|
||||
autocmd QuickFixCmdPre make call cargo#quickfix#CmdPre()
|
||||
autocmd QuickFixCmdPost make call cargo#quickfix#CmdPost()
|
||||
augroup END
|
||||
|
||||
" Ignore general cargo progress messages
|
||||
CompilerSet errorformat+=
|
||||
\%-G%\\s%#Downloading%.%#,
|
||||
\%-G%\\s%#Checking%.%#,
|
||||
\%-G%\\s%#Compiling%.%#,
|
||||
\%-G%\\s%#Finished%.%#,
|
||||
\%-G%\\s%#error:\ Could\ not\ compile\ %.%#,
|
||||
\%-G%\\s%#To\ learn\ more\\,%.%#,
|
||||
\%-G%\\s%#For\ more\ information\ about\ this\ error\\,%.%#,
|
||||
\%-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:
|
||||
57
pack/acp/start/rust.vim/compiler/rustc.vim
Normal file
57
pack/acp/start/rust.vim/compiler/rustc.vim
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
" Vim compiler file
|
||||
" Compiler: Rust Compiler
|
||||
" Maintainer: Chris Morgan <me@chrismorgan.info>
|
||||
" Latest Revision: 2013 Jul 12
|
||||
" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
|
||||
|
||||
if exists("current_compiler")
|
||||
finish
|
||||
endif
|
||||
let current_compiler = "rustc"
|
||||
|
||||
" vint: -ProhibitAbbreviationOption
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
" vint: +ProhibitAbbreviationOption
|
||||
|
||||
if exists(":CompilerSet") != 2
|
||||
command -nargs=* CompilerSet setlocal <args>
|
||||
endif
|
||||
|
||||
if get(g:, 'rustc_makeprg_no_percent', 0)
|
||||
CompilerSet makeprg=rustc
|
||||
else
|
||||
if has('patch-7.4.191')
|
||||
CompilerSet makeprg=rustc\ \%:S
|
||||
else
|
||||
CompilerSet makeprg=rustc\ \"%\"
|
||||
endif
|
||||
endif
|
||||
|
||||
" 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,
|
||||
\%E\ \ left:%m,%C\ right:%m\ %f:%l:%c,%Z
|
||||
|
||||
" 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:
|
||||
11
pack/acp/start/rust.vim/ctags/rust.ctags
Normal file
11
pack/acp/start/rust.vim/ctags/rust.ctags
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
--langdef=Rust
|
||||
--langmap=Rust:.rs
|
||||
--regex-Rust=/^[ \t]*(#\[[^\]]\][ \t]*)*(pub[ \t]+)?(extern[ \t]+)?("[^"]+"[ \t]+)?(unsafe[ \t]+)?fn[ \t]+([a-zA-Z0-9_]+)/\6/f,functions,function definitions/
|
||||
--regex-Rust=/^[ \t]*(pub[ \t]+)?type[ \t]+([a-zA-Z0-9_]+)/\2/T,types,type definitions/
|
||||
--regex-Rust=/^[ \t]*(pub[ \t]+)?enum[ \t]+([a-zA-Z0-9_]+)/\2/g,enum,enumeration names/
|
||||
--regex-Rust=/^[ \t]*(pub[ \t]+)?struct[ \t]+([a-zA-Z0-9_]+)/\2/s,structure names/
|
||||
--regex-Rust=/^[ \t]*(pub[ \t]+)?mod[ \t]+([a-zA-Z0-9_]+)/\2/m,modules,module names/
|
||||
--regex-Rust=/^[ \t]*(pub[ \t]+)?(static|const)[ \t]+([a-zA-Z0-9_]+)/\3/c,consts,static constants/
|
||||
--regex-Rust=/^[ \t]*(pub[ \t]+)?trait[ \t]+([a-zA-Z0-9_]+)/\2/t,traits,traits/
|
||||
--regex-Rust=/^[ \t]*(pub[ \t]+)?impl([ \t\n]*<[^>]*>)?[ \t]+(([a-zA-Z0-9_:]+)[ \t]*(<[^>]*>)?[ \t]+(for)[ \t]+)?([a-zA-Z0-9_]+)/\4 \6 \7/i,impls,trait implementations/
|
||||
--regex-Rust=/^[ \t]*macro_rules![ \t]+([a-zA-Z0-9_]+)/\1/d,macros,macro definitions/
|
||||
486
pack/acp/start/rust.vim/doc/rust.txt
Normal file
486
pack/acp/start/rust.vim/doc/rust.txt
Normal file
|
|
@ -0,0 +1,486 @@
|
|||
*ft_rust.txt* Filetype plugin for Rust
|
||||
|
||||
==============================================================================
|
||||
CONTENTS *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. It requires Vim 8 or higher for full functionality. Some commands
|
||||
will not work on earlier versions.
|
||||
|
||||
==============================================================================
|
||||
SETTINGS *rust-settings*
|
||||
|
||||
This plugin has a few variables you can define in your vimrc that change the
|
||||
behavior of the plugin.
|
||||
|
||||
Some variables can be set buffer local (`:b` prefix), and the buffer local
|
||||
will take precedence over the global `g:` counterpart.
|
||||
|
||||
*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:rust_use_custom_ctags_defs*
|
||||
g:rust_use_custom_ctags_defs~
|
||||
Set this option to 1 if you have customized ctags definitions for Rust
|
||||
and do not wish for those included with rust.vim to be used: >
|
||||
let g:rust_use_custom_ctags_defs = 1
|
||||
<
|
||||
|
||||
NOTE: rust.vim's built-in definitions are only used for the Tagbar Vim
|
||||
plugin, if you have it installed, AND if Universal Ctags is not
|
||||
detected. This is because Universal Ctags already has built-in
|
||||
support for Rust when used with Tagbar.
|
||||
|
||||
Also, note that when using ctags other than Universal Ctags, it is not
|
||||
automatically used when generating |tags| files that Vim can use to
|
||||
navigate to definitions across different source files. Feel free to
|
||||
copy `rust.vim/ctags/rust.ctags` into your own `~/.ctags` if you wish
|
||||
to generate |tags| files.
|
||||
|
||||
|
||||
*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:rustfmt_command*
|
||||
g:rustfmt_command~
|
||||
Set this option to the name of the 'rustfmt' executable in your $PATH. If
|
||||
not specified it defaults to 'rustfmt' : >
|
||||
let g:rustfmt_command = 'rustfmt'
|
||||
<
|
||||
*g:rustfmt_autosave*
|
||||
g:rustfmt_autosave~
|
||||
Set this option to 1 to run |:RustFmt| automatically when saving a
|
||||
buffer. If not specified it defaults to 0 : >
|
||||
let g:rustfmt_autosave = 0
|
||||
<
|
||||
There is also a buffer-local b:rustfmt_autosave that can be set for
|
||||
the same purpose, and can override the global setting.
|
||||
|
||||
*g:rustfmt_autosave_if_config_present*
|
||||
g:rustfmt_autosave_if_config_present~
|
||||
Set this option to 1 to have *b:rustfmt_autosave* be set automatically
|
||||
if a `rustfmt.toml` file is present in any parent directly leading to
|
||||
the file being edited. If not set, default to 0: >
|
||||
let g:rustfmt_autosave_if_config_present = 0
|
||||
<
|
||||
This is useful to have `rustfmt` only execute on save, on projects
|
||||
that have `rustfmt.toml` configuration.
|
||||
|
||||
There is also a buffer-local b:rustfmt_autosave_if_config_present
|
||||
that can be set for the same purpose, which can overrides the global
|
||||
setting.
|
||||
*g:rustfmt_fail_silently*
|
||||
g:rustfmt_fail_silently~
|
||||
Set this option to 1 to prevent 'rustfmt' from populating the
|
||||
|location-list| with errors. If not specified it defaults to 0: >
|
||||
let g:rustfmt_fail_silently = 0
|
||||
<
|
||||
*g:rustfmt_options*
|
||||
g:rustfmt_options~
|
||||
Set this option to a string of options to pass to 'rustfmt'. The
|
||||
write-mode is already set to 'overwrite'. If not specified it
|
||||
defaults to '' : >
|
||||
let g:rustfmt_options = ''
|
||||
<
|
||||
*g:rustfmt_emit_files*
|
||||
g:rustfmt_emit_files~
|
||||
If not specified rust.vim tries to detect the right parameter to
|
||||
pass to rustfmt based on its reported version. Otherwise, it
|
||||
determines whether to run rustfmt with '--emit=files' (when 1 is
|
||||
provided) instead of '--write-mode=overwrite'. >
|
||||
let g:rustfmt_emit_files = 0
|
||||
|
||||
|
||||
*g:rust_playpen_url*
|
||||
g:rust_playpen_url~
|
||||
Set this option to override the url for the playpen to use: >
|
||||
let g:rust_playpen_url = 'https://play.rust-lang.org/'
|
||||
<
|
||||
|
||||
*g:rust_shortener_url*
|
||||
g:rust_shortener_url~
|
||||
Set this option to override the url for the url shortener: >
|
||||
let g:rust_shortener_url = 'https://is.gd/'
|
||||
<
|
||||
|
||||
*g:rust_clip_command*
|
||||
g:rust_clip_command~
|
||||
Set this option to the command used in your OS to copy the Rust Play
|
||||
url to the clipboard: >
|
||||
let g:rust_clip_command = 'xclip -selection clipboard'
|
||||
<
|
||||
|
||||
*g:cargo_makeprg_params*
|
||||
g:cargo_makeprg_params~
|
||||
Set this option to the string of parameters to pass to cargo. If not
|
||||
specified it defaults to '$*' : >
|
||||
let g:cargo_makeprg_params = 'build'
|
||||
<
|
||||
|
||||
*g:cargo_shell_command_runner*
|
||||
g:cargo_shell_command_runner~
|
||||
Set this option to change how to run shell commands for cargo commands
|
||||
|:Cargo|, |:Cbuild|, |:Crun|, ...
|
||||
By default, |:terminal| is used to run shell command in terminal window
|
||||
asynchronously. But if you prefer |:!| for running the commands, it can
|
||||
be specified: >
|
||||
let g:cargo_shell_command_runner = '!'
|
||||
<
|
||||
|
||||
|
||||
Integration with Syntastic *rust-syntastic*
|
||||
--------------------------
|
||||
|
||||
This plugin automatically integrates with the Syntastic checker. There are two
|
||||
checkers provided: 'rustc', and 'cargo'. The latter invokes 'Cargo' in order to
|
||||
build code, and the former delivers a single edited '.rs' file as a compilation
|
||||
target directly to the Rust compiler, `rustc`.
|
||||
|
||||
Because Cargo is almost exclusively being used for building Rust code these
|
||||
days, 'cargo' is the default checker. >
|
||||
|
||||
let g:syntastic_rust_checkers = ['cargo']
|
||||
<
|
||||
If you would like to change it, you can set `g:syntastic_rust_checkers` to a
|
||||
different value.
|
||||
*g:rust_cargo_avoid_whole_workspace*
|
||||
*b:rust_cargo_avoid_whole_workspace*
|
||||
g:rust_cargo_avoid_whole_workspace~
|
||||
When editing a crate that is part of a Cargo workspace, and this
|
||||
option is set to 1 (the default), then 'cargo' will be executed
|
||||
directly in that crate directory instead of in the workspace
|
||||
directory. Setting 0 prevents this behavior - however be aware that if
|
||||
you are working in large workspace, Cargo commands may take more time,
|
||||
plus the Syntastic error list may include all the crates in the
|
||||
workspace. >
|
||||
let g:rust_cargo_avoid_whole_workspace = 0
|
||||
<
|
||||
*g:rust_cargo_check_all_targets*
|
||||
*b:rust_cargo_check_all_targets*
|
||||
g:rust_cargo_check_all_targets~
|
||||
When set to 1, the `--all-targets` option will be passed to cargo when
|
||||
Syntastic executes it, allowing the linting of all targets under the
|
||||
package.
|
||||
The default is 0.
|
||||
|
||||
*g:rust_cargo_check_all_features*
|
||||
*b:rust_cargo_check_all_features*
|
||||
g:rust_cargo_check_all_features~
|
||||
When set to 1, the `--all-features` option will be passed to cargo when
|
||||
Syntastic executes it, allowing the linting of all features of the
|
||||
package.
|
||||
The default is 0.
|
||||
|
||||
*g:rust_cargo_check_examples*
|
||||
*b:rust_cargo_check_examples*
|
||||
g:rust_cargo_check_examples~
|
||||
When set to 1, the `--examples` option will be passed to cargo when
|
||||
Syntastic executes it, to prevent the exclusion of examples from
|
||||
linting. The examples are normally under the `examples/` directory of
|
||||
the crate.
|
||||
The default is 0.
|
||||
|
||||
*g:rust_cargo_check_tests*
|
||||
*b:rust_cargo_check_tests*
|
||||
g:rust_cargo_check_tests~
|
||||
When set to 1, the `--tests` option will be passed to cargo when
|
||||
Syntastic executes it, to prevent the exclusion of tests from linting.
|
||||
The tests are normally under the `tests/` directory of the crate.
|
||||
The default is 0.
|
||||
|
||||
*g:rust_cargo_check_benches*
|
||||
*b:rust_cargo_check_benches*
|
||||
g:rust_cargo_check_benches~
|
||||
When set to 1, the `--benches` option will be passed to cargo when
|
||||
Syntastic executes it. The benches are normally under the `benches/`
|
||||
directory of the crate.
|
||||
The default is 0.
|
||||
|
||||
Integration with auto-pairs *rust-auto-pairs*
|
||||
---------------------------
|
||||
|
||||
This plugin automatically configures the auto-pairs plugin not to duplicate
|
||||
single quotes, which are used more often for lifetime annotations than for
|
||||
single character literals.
|
||||
|
||||
*g:rust_keep_autopairs_default*
|
||||
g:rust_keep_autopairs_default~
|
||||
|
||||
Don't override auto-pairs default for the Rust filetype. The default
|
||||
is 0.
|
||||
|
||||
==============================================================================
|
||||
COMMANDS *rust-commands*
|
||||
|
||||
Invoking Cargo
|
||||
--------------
|
||||
|
||||
This plug defines very simple shortcuts for invoking Cargo from with Vim.
|
||||
|
||||
:Cargo <args> *:Cargo*
|
||||
Runs 'cargo' with the provided arguments.
|
||||
|
||||
:Cbuild <args> *:Cbuild*
|
||||
Shortcut for 'cargo build`.
|
||||
|
||||
:Cclean <args> *:Cclean*
|
||||
Shortcut for 'cargo clean`.
|
||||
|
||||
:Cdoc <args> *:Cdoc*
|
||||
Shortcut for 'cargo doc`.
|
||||
|
||||
:Cinit <args> *:Cinit*
|
||||
Shortcut for 'cargo init`.
|
||||
|
||||
:Crun <args> *:Crun*
|
||||
Shortcut for 'cargo run`.
|
||||
|
||||
:Ctest <args> *:Ctest*
|
||||
Shortcut for 'cargo test`.
|
||||
|
||||
:Cupdate <args> *:Cupdate*
|
||||
Shortcut for 'cargo update`.
|
||||
|
||||
:Cbench <args> *:Cbench*
|
||||
Shortcut for 'cargo bench`.
|
||||
|
||||
:Csearch <args> *:Csearch*
|
||||
Shortcut for 'cargo search`.
|
||||
|
||||
:Cpublish <args> *:Cpublish*
|
||||
Shortcut for 'cargo publish`.
|
||||
|
||||
:Cinstall <args> *:Cinstall*
|
||||
Shortcut for 'cargo install`.
|
||||
|
||||
:Cruntarget <args> *:Cruntarget*
|
||||
Shortcut for 'cargo run --bin' or 'cargo run --example',
|
||||
depending on the currently open buffer.
|
||||
|
||||
Formatting
|
||||
----------
|
||||
|
||||
:RustFmt *:RustFmt*
|
||||
Runs |g:rustfmt_command| on the current buffer. If
|
||||
|g:rustfmt_options| is set then those will be passed to the
|
||||
executable.
|
||||
|
||||
If |g:rustfmt_fail_silently| is 0 (the default) then it
|
||||
will populate the |location-list| with the errors from
|
||||
|g:rustfmt_command|. If |g:rustfmt_fail_silently| is set to 1
|
||||
then it will not populate the |location-list|.
|
||||
|
||||
:RustFmtRange *:RustFmtRange*
|
||||
Runs |g:rustfmt_command| with selected range. See
|
||||
|:RustFmt| for any other information.
|
||||
|
||||
|
||||
Playpen integration
|
||||
-------------------
|
||||
|
||||
:RustPlay *:RustPlay*
|
||||
This command will only work if you have web-api.vim installed
|
||||
(available at https://github.com/mattn/webapi-vim). It sends the
|
||||
current selection, or if nothing is selected, the entirety of the
|
||||
current buffer to the Rust playpen, and emits a message with the
|
||||
shortened URL to the playpen.
|
||||
|
||||
|g:rust_playpen_url| is the base URL to the playpen, by default
|
||||
"https://play.rust-lang.org/".
|
||||
|
||||
|g:rust_shortener_url| is the base url for the shorterner, by
|
||||
default "https://is.gd/"
|
||||
|
||||
|g:rust_clip_command| is the command to run to copy the
|
||||
playpen url to the clipboard of your system.
|
||||
|
||||
|
||||
Evaluation of a single Rust file
|
||||
--------------------------------
|
||||
|
||||
NOTE: These commands are useful only when working with standalone Rust files,
|
||||
which is usually not the case for common Rust development. If you wish to
|
||||
building Rust crates from with Vim can should use Vim's make, Syntastic, or
|
||||
functionality from other plugins.
|
||||
|
||||
|
||||
: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.
|
||||
|
||||
|
||||
Running test(s)
|
||||
---------------
|
||||
|
||||
:[N]RustTest[!] [options] *:RustTest*
|
||||
Runs a test under the cursor when the current buffer is in a
|
||||
cargo project with "cargo test" command. If the command did
|
||||
not find any test function under the cursor, it stops with an
|
||||
error message.
|
||||
|
||||
When N is given, adjust the size of the new window to N lines
|
||||
or columns.
|
||||
|
||||
When ! is given, runs all tests regardless of current cursor
|
||||
position.
|
||||
|
||||
When [options] is given, it is passed to "cargo" command
|
||||
arguments.
|
||||
|
||||
When the current buffer is outside cargo project, the command
|
||||
runs "rustc --test" command instead of "cargo test" as
|
||||
fallback. All tests are run regardless of adding ! since there
|
||||
is no way to run specific test function with rustc. [options]
|
||||
is passed to "rustc" command arguments in the case.
|
||||
|
||||
Takes optional modifiers (see |<mods>|): >
|
||||
:tab RustTest
|
||||
:belowright 16RustTest
|
||||
:leftabove vert 80RustTest
|
||||
<
|
||||
rust.vim Debugging
|
||||
------------------
|
||||
|
||||
:RustInfo *:RustInfo*
|
||||
Emits debugging info of the Vim Rust plugin.
|
||||
|
||||
:RustInfoToClipboard *:RustInfoClipboard*
|
||||
Saves debugging info of the Vim Rust plugin to the default
|
||||
register.
|
||||
|
||||
:RustInfoToFile [filename] *:RustInfoToFile*
|
||||
Saves debugging info of the Vim Rust plugin to the the given
|
||||
file, overwritting it.
|
||||
|
||||
==============================================================================
|
||||
MAPPINGS *rust-mappings*
|
||||
|
||||
This plugin defines mappings for |[[| and |]]| to support hanging indents.
|
||||
|
||||
==============================================================================
|
||||
vim:tw=78:sw=4:noet:ts=8:ft=help:norl:
|
||||
15
pack/acp/start/rust.vim/ftdetect/rust.vim
Normal file
15
pack/acp/start/rust.vim/ftdetect/rust.vim
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
" vint: -ProhibitAutocmdWithNoGroup
|
||||
|
||||
autocmd BufRead,BufNewFile *.rs call s:set_rust_filetype()
|
||||
|
||||
if has('patch-8.0.613')
|
||||
autocmd BufRead,BufNewFile Cargo.toml setf FALLBACK cfg
|
||||
endif
|
||||
|
||||
function! s:set_rust_filetype() abort
|
||||
if &filetype !=# 'rust'
|
||||
set filetype=rust
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
200
pack/acp/start/rust.vim/ftplugin/rust.vim
Normal file
200
pack/acp/start/rust.vim/ftplugin/rust.vim
Normal file
|
|
@ -0,0 +1,200 @@
|
|||
" Language: Rust
|
||||
" Description: Vim ftplugin for Rust
|
||||
" Maintainer: Chris Morgan <me@chrismorgan.info>
|
||||
" Last Change: June 08, 2016
|
||||
" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
|
||||
|
||||
if exists("b:did_ftplugin")
|
||||
finish
|
||||
endif
|
||||
let b:did_ftplugin = 1
|
||||
|
||||
" vint: -ProhibitAbbreviationOption
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
" vint: +ProhibitAbbreviationOption
|
||||
|
||||
if get(b:, 'current_compiler', '') ==# ''
|
||||
if strlen(findfile('Cargo.toml', '.;')) > 0
|
||||
compiler cargo
|
||||
else
|
||||
compiler rustc
|
||||
endif
|
||||
endif
|
||||
|
||||
" 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 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:/*!,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 get(g:, 'rust_recommended_style', 1)
|
||||
let b:rust_set_style = 1
|
||||
setlocal shiftwidth=4 softtabstop=4 expandtab
|
||||
setlocal textwidth=99
|
||||
endif
|
||||
|
||||
setlocal include=\\v^\\s*(pub\\s+)?use\\s+\\zs(\\f\|:)+
|
||||
setlocal includeexpr=rust#IncludeExpr(v:fname)
|
||||
|
||||
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
|
||||
|
||||
augroup rust.vim.DelimitMate
|
||||
autocmd!
|
||||
|
||||
autocmd User delimitMate_map :call rust#delimitmate#onMap()
|
||||
autocmd User delimitMate_unmap :call rust#delimitmate#onUnmap()
|
||||
augroup END
|
||||
endif
|
||||
|
||||
" Integration with auto-pairs (https://github.com/jiangmiao/auto-pairs)
|
||||
if exists("g:AutoPairsLoaded") && !get(g:, 'rust_keep_autopairs_default', 0)
|
||||
let b:AutoPairs = {'(':')', '[':']', '{':'}','"':'"', '`':'`'}
|
||||
endif
|
||||
|
||||
if has("folding") && 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
|
||||
|
||||
" 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 -buffer RustRun call rust#Run(<bang>0, <q-args>)
|
||||
|
||||
" See |:RustExpand| for docs
|
||||
command! -nargs=* -complete=customlist,rust#CompleteExpand -bang -buffer RustExpand call rust#Expand(<bang>0, <q-args>)
|
||||
|
||||
" See |:RustEmitIr| for docs
|
||||
command! -nargs=* -buffer RustEmitIr call rust#Emit("llvm-ir", <q-args>)
|
||||
|
||||
" See |:RustEmitAsm| for docs
|
||||
command! -nargs=* -buffer RustEmitAsm call rust#Emit("asm", <q-args>)
|
||||
|
||||
" See |:RustPlay| for docs
|
||||
command! -range=% RustPlay :call rust#Play(<count>, <line1>, <line2>, <f-args>)
|
||||
|
||||
" See |:RustFmt| for docs
|
||||
command! -bar -buffer RustFmt call rustfmt#Format()
|
||||
|
||||
" See |:RustFmtRange| for docs
|
||||
command! -range -buffer RustFmtRange call rustfmt#FormatRange(<line1>, <line2>)
|
||||
|
||||
" See |:RustInfo| for docs
|
||||
command! -bar RustInfo call rust#debugging#Info()
|
||||
|
||||
" 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=* -count -bang RustTest call rust#Test(<q-mods>, <count>, <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 = []
|
||||
endif
|
||||
|
||||
" Cleanup {{{1
|
||||
|
||||
let b:undo_ftplugin = "
|
||||
\ setlocal formatoptions< comments< commentstring< include< 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
|
||||
augroup rust.vim.PreWrite
|
||||
autocmd!
|
||||
autocmd BufWritePre *.rs silent! call rustfmt#PreWrite()
|
||||
augroup END
|
||||
|
||||
setlocal matchpairs+=<:>
|
||||
" For matchit.vim (rustArrow stops `Fn() -> X` messing things up)
|
||||
let b:match_skip = 's:comment\|string\|rustCharacter\|rustArrow'
|
||||
|
||||
" vint: -ProhibitAbbreviationOption
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
" vint: +ProhibitAbbreviationOption
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
40
pack/acp/start/rust.vim/ftplugin/rust/tagbar.vim
Normal file
40
pack/acp/start/rust.vim/ftplugin/rust/tagbar.vim
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
"
|
||||
" Support for Tagbar -- https://github.com/majutsushi/tagbar
|
||||
"
|
||||
if !exists(':Tagbar') || rust#tags#IsUCtags()
|
||||
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:
|
||||
286
pack/acp/start/rust.vim/indent/rust.vim
Normal file
286
pack/acp/start/rust.vim/indent/rust.vim
Normal file
|
|
@ -0,0 +1,286 @@
|
|||
" Vim indent file
|
||||
" Language: Rust
|
||||
" Author: Chris Morgan <me@chrismorgan.info>
|
||||
" 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
|
||||
endif
|
||||
let b:did_indent = 1
|
||||
|
||||
setlocal cindent
|
||||
setlocal cinoptions=L0,(s,Ws,J1,j1,m1
|
||||
setlocal cinkeys=0{,0},!^F,o,O,0[,0],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
|
||||
|
||||
" 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],0(,0)
|
||||
|
||||
setlocal indentexpr=GetRustIndent(v:lnum)
|
||||
|
||||
let b:undo_indent = "setlocal cindent< cinoptions< cinkeys< cinwords< lisp< autoindent< indentkeys< indentexpr<"
|
||||
|
||||
" Only define the function once.
|
||||
if exists("*GetRustIndent")
|
||||
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
|
||||
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
|
||||
|
||||
if exists('*shiftwidth')
|
||||
function! s:shiftwidth()
|
||||
return shiftwidth()
|
||||
endfunc
|
||||
else
|
||||
function! s:shiftwidth()
|
||||
return &shiftwidth
|
||||
endfunc
|
||||
endif
|
||||
|
||||
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
|
||||
|
||||
" A standalone '{', '}', or 'where'
|
||||
let l:standalone_open = line =~# '\V\^\s\*{\s\*\$'
|
||||
let l:standalone_close = line =~# '\V\^\s\*}\s\*\$'
|
||||
let l:standalone_where = line =~# '\V\^\s\*where\s\*\$'
|
||||
if l:standalone_open || l:standalone_close || l:standalone_where
|
||||
" ToDo: we can search for more items than 'fn' and 'if'.
|
||||
let [l:found_line, l:col, l:submatch] =
|
||||
\ searchpos('\<\(fn\)\|\(if\)\>', 'bnWp')
|
||||
if l:found_line !=# 0
|
||||
" Now we count the number of '{' and '}' in between the match
|
||||
" locations and the current line (there is probably a better
|
||||
" way to compute this).
|
||||
let l:i = l:found_line
|
||||
let l:search_line = strpart(getline(l:i), l:col - 1)
|
||||
let l:opens = 0
|
||||
let l:closes = 0
|
||||
while l:i < a:lnum
|
||||
let l:search_line2 = substitute(l:search_line, '\V{', '', 'g')
|
||||
let l:opens += strlen(l:search_line) - strlen(l:search_line2)
|
||||
let l:search_line3 = substitute(l:search_line2, '\V}', '', 'g')
|
||||
let l:closes += strlen(l:search_line2) - strlen(l:search_line3)
|
||||
let l:i += 1
|
||||
let l:search_line = getline(l:i)
|
||||
endwhile
|
||||
if l:standalone_open || l:standalone_where
|
||||
if l:opens ==# l:closes
|
||||
return indent(l:found_line)
|
||||
endif
|
||||
else
|
||||
" Expect to find just one more close than an open
|
||||
if l:opens ==# l:closes + 1
|
||||
return indent(l:found_line)
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
" A standalone 'where' adds a shift.
|
||||
let l:standalone_prevline_where = prevline =~# '\V\^\s\*where\s\*\$'
|
||||
if l:standalone_prevline_where
|
||||
return indent(prevlinenum) + 4
|
||||
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
|
||||
|
||||
let l:last_prevline_character = prevline[len(prevline) - 1]
|
||||
|
||||
" A line that ends with '.<expr>;' is probably an end of a long list
|
||||
" of method operations.
|
||||
if prevline =~# '\V\^\s\*.' && l:last_prevline_character ==# ';'
|
||||
call cursor(a:lnum - 1, 1)
|
||||
let l:scope_start = searchpair('{\|(', '', '}\|)', 'nbW',
|
||||
\ 's:is_string_comment(line("."), col("."))')
|
||||
if l:scope_start != 0 && l:scope_start < a:lnum
|
||||
return indent(l:scope_start) + 4
|
||||
endif
|
||||
endif
|
||||
|
||||
if l:last_prevline_character ==# ","
|
||||
\ && 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
|
||||
|
||||
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
|
||||
|
||||
" vint: -ProhibitAbbreviationOption
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
" vint: +ProhibitAbbreviationOption
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
27
pack/acp/start/rust.vim/plugin/cargo.vim
Normal file
27
pack/acp/start/rust.vim/plugin/cargo.vim
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
if exists('g:loaded_rust_vim_plugin_cargo')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_rust_vim_plugin_cargo = 1
|
||||
let s:save_cpo = &cpoptions
|
||||
set cpoptions&vim
|
||||
|
||||
command! -nargs=+ Cargo call cargo#cmd(<q-args>)
|
||||
command! -nargs=* Cbuild call cargo#build(<q-args>)
|
||||
command! -nargs=* Ccheck call cargo#check(<q-args>)
|
||||
command! -nargs=* Cclean call cargo#clean(<q-args>)
|
||||
command! -nargs=* Cdoc call cargo#doc(<q-args>)
|
||||
command! -nargs=+ Cnew call cargo#new(<q-args>)
|
||||
command! -nargs=* Cinit call cargo#init(<q-args>)
|
||||
command! -nargs=* Crun call cargo#run(<q-args>)
|
||||
command! -nargs=* Ctest call cargo#test(<q-args>)
|
||||
command! -nargs=* Cbench call cargo#bench(<q-args>)
|
||||
command! -nargs=* Cupdate call cargo#update(<q-args>)
|
||||
command! -nargs=* Csearch call cargo#search(<q-args>)
|
||||
command! -nargs=* Cpublish call cargo#publish(<q-args>)
|
||||
command! -nargs=* Cinstall call cargo#install(<q-args>)
|
||||
command! -nargs=* Cruntarget call cargo#runtarget(<q-args>)
|
||||
|
||||
let &cpoptions = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
28
pack/acp/start/rust.vim/plugin/rust.vim
Normal file
28
pack/acp/start/rust.vim/plugin/rust.vim
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
" Vim syntastic plugin helper
|
||||
" Language: Rust
|
||||
" Maintainer: Andrew Gallant <jamslam@gmail.com>
|
||||
|
||||
if exists('g:loaded_rust_vim')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_rust_vim = 1
|
||||
let s:save_cpo = &cpoptions
|
||||
set cpoptions&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
|
||||
|
||||
if !exists('g:syntastic_rust_checkers')
|
||||
let g:syntastic_rust_checkers = ['cargo']
|
||||
endif
|
||||
|
||||
let &cpoptions = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
387
pack/acp/start/rust.vim/syntax/rust.vim
Normal file
387
pack/acp/start/rust.vim/syntax/rust.vim
Normal file
|
|
@ -0,0 +1,387 @@
|
|||
" 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: Feb 24, 2016
|
||||
" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
|
||||
|
||||
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 rustRepeat loop while
|
||||
" `:syn match` must be used to prioritize highlighting `for` keyword.
|
||||
syn match rustRepeat /\<for\>/
|
||||
" Highlight `for` keyword in `impl ... for ... {}` statement. This line must
|
||||
" be put after previous `syn match` line to overwrite it.
|
||||
syn match rustKeyword /\%(\<impl\>.\+\)\@<=\<for\>/
|
||||
syn keyword rustRepeat in
|
||||
syn keyword rustTypedef type nextgroup=rustIdentifier skipwhite skipempty
|
||||
syn keyword rustStructure struct enum nextgroup=rustIdentifier skipwhite skipempty
|
||||
syn keyword rustUnion union nextgroup=rustIdentifier skipwhite skipempty contained
|
||||
syn match rustUnionContextual /\<union\_s\+\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*/ transparent contains=rustUnion
|
||||
syn keyword rustOperator as
|
||||
syn keyword rustExistential existential nextgroup=rustTypedef skipwhite skipempty contained
|
||||
syn match rustExistentialContextual /\<existential\_s\+type/ transparent contains=rustExistential,rustTypedef
|
||||
|
||||
syn match rustAssert "\<assert\(\w\)*!" contained
|
||||
syn match rustPanic "\<panic\(\w\)*!" contained
|
||||
syn match rustAsync "\<async\%(\s\|\n\)\@="
|
||||
syn keyword rustKeyword break
|
||||
syn keyword rustKeyword box
|
||||
syn keyword rustKeyword continue
|
||||
syn keyword rustKeyword crate
|
||||
syn keyword rustKeyword extern nextgroup=rustExternCrate,rustObsoleteExternMod skipwhite skipempty
|
||||
syn keyword rustKeyword fn nextgroup=rustFuncName skipwhite skipempty
|
||||
syn keyword rustKeyword impl let
|
||||
syn keyword rustKeyword macro
|
||||
syn keyword rustKeyword pub nextgroup=rustPubScope skipwhite skipempty
|
||||
syn keyword rustKeyword return
|
||||
syn keyword rustKeyword yield
|
||||
syn keyword rustSuper super
|
||||
syn keyword rustKeyword where
|
||||
syn keyword rustUnsafeKeyword unsafe
|
||||
syn keyword rustKeyword use nextgroup=rustModPath skipwhite skipempty
|
||||
" FIXME: Scoped impl's name is also fallen in this category
|
||||
syn keyword rustKeyword mod trait nextgroup=rustIdentifier skipwhite skipempty
|
||||
syn keyword rustStorage move mut ref static const
|
||||
syn match rustDefault /\<default\ze\_s\+\(impl\|fn\|type\|const\)\>/
|
||||
syn keyword rustAwait await
|
||||
syn match rustKeyword /\<try\>!\@!/ display
|
||||
|
||||
syn keyword rustPubScopeCrate crate contained
|
||||
syn match rustPubScopeDelim /[()]/ contained
|
||||
syn match rustPubScope /([^()]*)/ contained contains=rustPubScopeDelim,rustPubScopeCrate,rustSuper,rustModPath,rustModPathSep,rustSelf transparent
|
||||
|
||||
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 "\%(r#\)\=\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
|
||||
|
||||
syn region rustMacroRepeat matchgroup=rustMacroRepeatDelimiters start="$(" end="),\=[*+]" contains=TOP
|
||||
syn match rustMacroVariable "$\w\+"
|
||||
syn match rustRawIdent "\<r#\h\w*" contains=NONE
|
||||
|
||||
" Reserved (but not yet used) keywords {{{2
|
||||
syn keyword rustReservedKeyword become do priv typeof unsized abstract virtual final override
|
||||
|
||||
" Built-in types {{{2
|
||||
syn keyword rustType isize usize char bool u8 u16 u32 u64 u128 f32
|
||||
syn keyword rustType f64 i8 i16 i32 i64 i128 str Self
|
||||
|
||||
" Things from the libstd v1 prelude (src/libstd/prelude/v1.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
|
||||
" There’s no point in highlighting these; when one writes drop( or drop::< it
|
||||
" gets the same highlighting anyway, and if someone writes `let drop = …;` we
|
||||
" don’t really want *that* drop to be highlighted.
|
||||
"syn keyword rustFunction drop
|
||||
|
||||
" Reexported types and traits {{{3
|
||||
syn keyword rustTrait Box
|
||||
syn keyword rustTrait ToOwned
|
||||
syn keyword rustTrait Clone
|
||||
syn keyword rustTrait PartialEq PartialOrd Eq Ord
|
||||
syn keyword rustTrait AsRef AsMut Into From
|
||||
syn keyword rustTrait Default
|
||||
syn keyword rustTrait Iterator Extend IntoIterator
|
||||
syn keyword rustTrait DoubleEndedIterator ExactSizeIterator
|
||||
syn keyword rustEnum Option
|
||||
syn keyword rustEnumVariant Some None
|
||||
syn keyword rustEnum Result
|
||||
syn keyword rustEnumVariant Ok Err
|
||||
syn keyword rustTrait SliceConcatExt
|
||||
syn keyword rustTrait String ToString
|
||||
syn keyword rustTrait Vec
|
||||
|
||||
" 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 "&&\|||"
|
||||
" This is rustArrowCharacter rather than rustArrow for the sake of matchparen,
|
||||
" so it skips the ->; see http://stackoverflow.com/a/30309949 for details.
|
||||
syn match rustArrowCharacter display "->"
|
||||
syn match rustQuestionMark display "?\([a-zA-Z]\+\)\@!"
|
||||
|
||||
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_*\)\{1,6}}/
|
||||
syn match rustStringContinuation display contained /\\\n\s*/
|
||||
syn region rustString matchgroup=rustStringDelimiter start=+b"+ skip=+\\\\\|\\"+ end=+"+ contains=rustEscape,rustEscapeError,rustStringContinuation
|
||||
syn region rustString matchgroup=rustStringDelimiter start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustEscape,rustEscapeUnicode,rustEscapeError,rustStringContinuation,@Spell
|
||||
syn region rustString matchgroup=rustStringDelimiter start='b\?r\z(#*\)"' end='"\z1' contains=@Spell
|
||||
|
||||
" Match attributes with either arbitrary syntax or special highlighting for
|
||||
" derives. We still highlight strings and comments inside of the attribute.
|
||||
syn region rustAttribute start="#!\?\[" end="\]" contains=@rustAttributeContents,rustAttributeParenthesizedParens,rustAttributeParenthesizedCurly,rustAttributeParenthesizedBrackets,rustDerive
|
||||
syn region rustAttributeParenthesizedParens matchgroup=rustAttribute start="\w\%(\w\)*("rs=e end=")"re=s transparent contained contains=rustAttributeBalancedParens,@rustAttributeContents
|
||||
syn region rustAttributeParenthesizedCurly matchgroup=rustAttribute start="\w\%(\w\)*{"rs=e end="}"re=s transparent contained contains=rustAttributeBalancedCurly,@rustAttributeContents
|
||||
syn region rustAttributeParenthesizedBrackets matchgroup=rustAttribute start="\w\%(\w\)*\["rs=e end="\]"re=s transparent contained contains=rustAttributeBalancedBrackets,@rustAttributeContents
|
||||
syn region rustAttributeBalancedParens matchgroup=rustAttribute start="("rs=e end=")"re=s transparent contained contains=rustAttributeBalancedParens,@rustAttributeContents
|
||||
syn region rustAttributeBalancedCurly matchgroup=rustAttribute start="{"rs=e end="}"re=s transparent contained contains=rustAttributeBalancedCurly,@rustAttributeContents
|
||||
syn region rustAttributeBalancedBrackets matchgroup=rustAttribute start="\["rs=e end="\]"re=s transparent contained contains=rustAttributeBalancedBrackets,@rustAttributeContents
|
||||
syn cluster rustAttributeContents contains=rustString,rustCommentLine,rustCommentBlock,rustCommentLineDocError,rustCommentBlockDocError
|
||||
syn region rustDerive start="derive(" end=")" contained contains=rustDeriveTrait
|
||||
" This list comes from src/libsyntax/ext/deriving/mod.rs
|
||||
" Some are deprecated (Encodable, Decodable) or to be removed after a new snapshot (Show).
|
||||
syn keyword rustDeriveTrait contained Clone Hash RustcEncodable RustcDecodable Encodable Decodable PartialEq Eq PartialOrd Ord Rand Show Debug Default FromPrimitive Send Sync Copy
|
||||
|
||||
" dyn keyword: It's only a keyword when used inside a type expression, so
|
||||
" we make effort here to highlight it only when Rust identifiers follow it
|
||||
" (not minding the case of pre-2018 Rust where a path starting with :: can
|
||||
" follow).
|
||||
"
|
||||
" This is so that uses of dyn variable names such as in 'let &dyn = &2'
|
||||
" and 'let dyn = 2' will not get highlighted as a keyword.
|
||||
syn match rustKeyword "\<dyn\ze\_s\+\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)" contains=rustDynKeyword
|
||||
syn keyword rustDynKeyword dyn contained
|
||||
|
||||
" Number literals
|
||||
syn match rustDecNumber display "\<[0-9][0-9_]*\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
|
||||
syn match rustHexNumber display "\<0x[a-fA-F0-9_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
|
||||
syn match rustOctNumber display "\<0o[0-7_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
|
||||
syn match rustBinNumber display "\<0b[01_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
|
||||
|
||||
" 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_*\)\{1,6}}\)\)'\)\@!/ 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 rustLabel display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*:"
|
||||
syn match rustLabel display "\%(\<\%(break\|continue\)\s*\)\@<=\'\%([^[: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_*\)\{1,6}}\)\)'/ contains=rustEscape,rustEscapeUnicode,rustEscapeError,rustCharacterInvalid
|
||||
|
||||
syn match rustShebang /\%^#![^[].*/
|
||||
syn region rustCommentLine start="//" end="$" contains=rustTodo,@Spell
|
||||
syn region rustCommentLineDoc start="//\%(//\@!\|!\)" end="$" contains=rustTodo,@Spell
|
||||
syn region rustCommentLineDocError start="//\%(//\@!\|!\)" end="$" contains=rustTodo,@Spell contained
|
||||
syn region rustCommentBlock matchgroup=rustCommentBlock start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,rustCommentBlockNest,@Spell
|
||||
syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)" end="\*/" contains=rustTodo,rustCommentBlockDocNest,rustCommentBlockDocRustCode,@Spell
|
||||
syn region rustCommentBlockDocError matchgroup=rustCommentBlockDocError start="/\*\%(!\|\*[*/]\@!\)" end="\*/" contains=rustTodo,rustCommentBlockDocNestError,@Spell contained
|
||||
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
|
||||
syn region rustCommentBlockDocNestError matchgroup=rustCommentBlockDocError start="/\*" end="\*/" contains=rustTodo,rustCommentBlockDocNestError,@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 SAFETY
|
||||
|
||||
" asm! macro {{{2
|
||||
syn region rustAsmMacro matchgroup=rustMacro start="\<asm!\s*(" end=")" contains=rustAsmDirSpec,rustAsmSym,rustAsmConst,rustAsmOptionsGroup,rustComment.*,rustString.*
|
||||
|
||||
" Clobbered registers
|
||||
syn keyword rustAsmDirSpec in out lateout inout inlateout contained nextgroup=rustAsmReg skipwhite skipempty
|
||||
syn region rustAsmReg start="(" end=")" contained contains=rustString
|
||||
|
||||
" Symbol operands
|
||||
syn keyword rustAsmSym sym contained nextgroup=rustAsmSymPath skipwhite skipempty
|
||||
syn region rustAsmSymPath start="\S" end=",\|)"me=s-1 contained contains=rustComment.*,rustIdentifier
|
||||
|
||||
" Const
|
||||
syn region rustAsmConstBalancedParens start="("ms=s+1 end=")" contained contains=@rustAsmConstExpr
|
||||
syn cluster rustAsmConstExpr contains=rustComment.*,rust.*Number,rustString,rustAsmConstBalancedParens
|
||||
syn region rustAsmConst start="const" end=",\|)"me=s-1 contained contains=rustStorage,@rustAsmConstExpr
|
||||
|
||||
" Options
|
||||
syn region rustAsmOptionsGroup start="options\s*(" end=")" contained contains=rustAsmOptions,rustAsmOptionsKey
|
||||
syn keyword rustAsmOptionsKey options contained
|
||||
syn keyword rustAsmOptions pure nomem readonly preserves_flags noreturn nostack att_syntax contained
|
||||
|
||||
" 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
|
||||
|
||||
if !exists("b:current_syntax_embed")
|
||||
let b:current_syntax_embed = 1
|
||||
syntax include @RustCodeInComment <sfile>:p:h/rust.vim
|
||||
unlet b:current_syntax_embed
|
||||
|
||||
" Currently regions marked as ```<some-other-syntax> will not get
|
||||
" highlighted at all. In the future, we can do as vim-markdown does and
|
||||
" highlight with the other syntax. But for now, let's make sure we find
|
||||
" the closing block marker, because the rules below won't catch it.
|
||||
syn region rustCommentLinesDocNonRustCode matchgroup=rustCommentDocCodeFence start='^\z(\s*//[!/]\s*```\).\+$' end='^\z1$' keepend contains=rustCommentLineDoc
|
||||
|
||||
" We borrow the rules from rust’s src/librustdoc/html/markdown.rs, so that
|
||||
" we only highlight as Rust what it would perceive as Rust (almost; it’s
|
||||
" possible to trick it if you try hard, and indented code blocks aren’t
|
||||
" supported because Markdown is a menace to parse and only mad dogs and
|
||||
" Englishmen would try to handle that case correctly in this syntax file).
|
||||
syn region rustCommentLinesDocRustCode matchgroup=rustCommentDocCodeFence start='^\z(\s*//[!/]\s*```\)[^A-Za-z0-9_-]*\%(\%(should_panic\|no_run\|ignore\|allow_fail\|rust\|test_harness\|compile_fail\|E\d\{4}\|edition201[58]\)\%([^A-Za-z0-9_-]\+\|$\)\)*$' end='^\z1$' keepend contains=@RustCodeInComment,rustCommentLineDocLeader
|
||||
syn region rustCommentBlockDocRustCode matchgroup=rustCommentDocCodeFence start='^\z(\%(\s*\*\)\?\s*```\)[^A-Za-z0-9_-]*\%(\%(should_panic\|no_run\|ignore\|allow_fail\|rust\|test_harness\|compile_fail\|E\d\{4}\|edition201[58]\)\%([^A-Za-z0-9_-]\+\|$\)\)*$' end='^\z1$' keepend contains=@RustCodeInComment,rustCommentBlockDocStar
|
||||
" Strictly, this may or may not be correct; this code, for example, would
|
||||
" mishighlight:
|
||||
"
|
||||
" /**
|
||||
" ```rust
|
||||
" println!("{}", 1
|
||||
" * 1);
|
||||
" ```
|
||||
" */
|
||||
"
|
||||
" … but I don’t care. Balance of probability, and all that.
|
||||
syn match rustCommentBlockDocStar /^\s*\*\s\?/ contained
|
||||
syn match rustCommentLineDocLeader "^\s*//\%(//\@!\|!\)" contained
|
||||
endif
|
||||
|
||||
" 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 rustDeriveTrait rustTrait
|
||||
|
||||
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 rustStringDelimiter 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 rustArrowCharacter rustOperator
|
||||
hi def link rustOperator Operator
|
||||
hi def link rustKeyword Keyword
|
||||
hi def link rustDynKeyword rustKeyword
|
||||
hi def link rustTypedef Keyword " More precise is Typedef, but it doesn't feel right for Rust
|
||||
hi def link rustStructure Keyword " More precise is Structure
|
||||
hi def link rustUnion rustStructure
|
||||
hi def link rustExistential rustKeyword
|
||||
hi def link rustPubScopeDelim Delimiter
|
||||
hi def link rustPubScopeCrate rustKeyword
|
||||
hi def link rustSuper rustKeyword
|
||||
hi def link rustUnsafeKeyword Exception
|
||||
hi def link rustReservedKeyword Error
|
||||
hi def link rustRepeat Conditional
|
||||
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 rustShebang Comment
|
||||
hi def link rustCommentLine Comment
|
||||
hi def link rustCommentLineDoc SpecialComment
|
||||
hi def link rustCommentLineDocLeader rustCommentLineDoc
|
||||
hi def link rustCommentLineDocError Error
|
||||
hi def link rustCommentBlock rustCommentLine
|
||||
hi def link rustCommentBlockDoc rustCommentLineDoc
|
||||
hi def link rustCommentBlockDocStar rustCommentBlockDoc
|
||||
hi def link rustCommentBlockDocError Error
|
||||
hi def link rustCommentDocCodeFence 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 rustDefault StorageClass
|
||||
hi def link rustStorage StorageClass
|
||||
hi def link rustObsoleteStorage Error
|
||||
hi def link rustLifetime Special
|
||||
hi def link rustLabel Label
|
||||
hi def link rustExternCrate rustKeyword
|
||||
hi def link rustObsoleteExternMod Error
|
||||
hi def link rustQuestionMark Special
|
||||
hi def link rustAsync rustKeyword
|
||||
hi def link rustAwait rustKeyword
|
||||
hi def link rustAsmDirSpec rustKeyword
|
||||
hi def link rustAsmSym rustKeyword
|
||||
hi def link rustAsmOptions rustKeyword
|
||||
hi def link rustAsmOptionsKey rustAttribute
|
||||
|
||||
" 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"
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
93
pack/acp/start/rust.vim/syntax_checkers/rust/cargo.vim
Normal file
93
pack/acp/start/rust.vim/syntax_checkers/rust/cargo.vim
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
" Vim syntastic plugin
|
||||
" Language: Rust
|
||||
" Maintainer: Julien Levesy <jlevesy@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_cargo_checker")
|
||||
finish
|
||||
endif
|
||||
|
||||
let g:loaded_syntastic_rust_cargo_checker = 1
|
||||
|
||||
" Force syntastic to call cargo without a specific file name
|
||||
let g:syntastic_rust_cargo_fname = ""
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_rust_cargo_IsAvailable() dict
|
||||
if exists("*syntastic#util#getVersion")
|
||||
echom "rust.vim: version of Syntastic is too old. Needs to be at least 3.7.0."
|
||||
return v:false
|
||||
endif
|
||||
|
||||
return executable(self.getExec()) &&
|
||||
\ syntastic#util#versionIsAtLeast(self.getVersion(), [0, 16, 0])
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_rust_cargo_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ "args": "check" })
|
||||
let l:root_cargo_toml = cargo#nearestRootCargo(0)
|
||||
let l:nearest_cargo_toml = cargo#nearestCargo(0)
|
||||
let b:rust_recent_root_cargo_toml = l:root_cargo_toml
|
||||
let b:rust_recent_nearest_cargo_toml = l:nearest_cargo_toml
|
||||
|
||||
" All pathname prints are relative to the Cargo.toml of the workspace, if
|
||||
" there is a workspace, otherwise they are relative to the Cargo.toml of
|
||||
" the single crate. Where to actually execute under these varying
|
||||
" circumtances 'cargo' is determined here, and controlled by
|
||||
" configuration.
|
||||
|
||||
if rust#GetConfigVar('rust_cargo_avoid_whole_workspace', 1)
|
||||
if l:root_cargo_toml !=# l:nearest_cargo_toml
|
||||
let makeprg = "cd " . fnamemodify(l:nearest_cargo_toml, ":p:h")
|
||||
\ . " && " . makeprg
|
||||
endif
|
||||
else
|
||||
let makeprg = "cd " . fnamemodify(l:root_cargo_toml, ":p:h")
|
||||
\ . " && " . makeprg
|
||||
endif
|
||||
|
||||
let l:check_all_targets = rust#GetConfigVar('rust_cargo_check_all_targets', 0)
|
||||
let l:check_all_features = rust#GetConfigVar('rust_cargo_check_all_features', 0)
|
||||
let l:check_examples = rust#GetConfigVar('rust_cargo_check_examples', 0)
|
||||
let l:check_tests = rust#GetConfigVar('rust_cargo_check_tests', 0)
|
||||
let l:check_benches = rust#GetConfigVar('rust_cargo_check_benches', 0)
|
||||
|
||||
let makeprg = makeprg. ' '
|
||||
\ . (l:check_all_targets ? ' --all-targets' : '')
|
||||
\ . (l:check_all_features ? ' --all-features' : '')
|
||||
\ . (l:check_benches ? ' --benches' : '')
|
||||
\ . (l:check_examples ? ' --examples' : '')
|
||||
\ . (l:check_tests ? ' --tests' : '')
|
||||
|
||||
" Ignored patterns, and blank lines
|
||||
let errorformat =
|
||||
\ '%-G,' .
|
||||
\ '%-Gerror: aborting %.%#,' .
|
||||
\ '%-Gerror: Could not compile %.%#,'
|
||||
|
||||
" Meaningful lines (errors, notes, warnings, contextual information)
|
||||
let errorformat .=
|
||||
\ '%Eerror: %m,' .
|
||||
\ '%Eerror[E%n]: %m,' .
|
||||
\ '%Wwarning: %m,' .
|
||||
\ '%Inote: %m,' .
|
||||
\ '%C %#--> %f:%l:%c'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'cwd': fnamemodify(l:root_cargo_toml, ":p:h:."),
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'rust',
|
||||
\ 'name': 'cargo'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
54
pack/acp/start/rust.vim/syntax_checkers/rust/rustc.vim
Normal file
54
pack/acp/start/rust.vim/syntax_checkers/rust/rustc.vim
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
" 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
|
||||
|
||||
" vint: -ProhibitAbbreviationOption
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
" vint: +ProhibitAbbreviationOption
|
||||
|
||||
function! SyntaxCheckers_rust_rustc_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({})
|
||||
|
||||
" Old errorformat (before nightly 2016/08/10)
|
||||
let errorformat =
|
||||
\ '%E%f:%l:%c: %\d%#:%\d%# %.%\{-}error:%.%\{-} %m,' .
|
||||
\ '%W%f:%l:%c: %\d%#:%\d%# %.%\{-}warning:%.%\{-} %m,' .
|
||||
\ '%C%f:%l %m'
|
||||
|
||||
" New errorformat (after nightly 2016/08/10)
|
||||
let errorformat .=
|
||||
\ ',' .
|
||||
\ '%-G,' .
|
||||
\ '%-Gerror: aborting %.%#,' .
|
||||
\ '%-Gerror: Could not compile %.%#,' .
|
||||
\ '%Eerror: %m,' .
|
||||
\ '%Eerror[E%n]: %m,' .
|
||||
\ '%-Gwarning: the option `Z` is unstable %.%#,' .
|
||||
\ '%Wwarning: %m,' .
|
||||
\ '%Inote: %m,' .
|
||||
\ '%C %#--> %f:%l:%c'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'rust',
|
||||
\ 'name': 'rustc'})
|
||||
|
||||
" vint: -ProhibitAbbreviationOption
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
" vint: +ProhibitAbbreviationOption
|
||||
|
||||
" vim: set et sw=4 sts=4 ts=8:
|
||||
0
pack/acp/start/rust.vim/test/.gitignore
vendored
Normal file
0
pack/acp/start/rust.vim/test/.gitignore
vendored
Normal file
34
pack/acp/start/rust.vim/test/Dockerfile
Normal file
34
pack/acp/start/rust.vim/test/Dockerfile
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
# This is brought as reference, to be able to reproduce a new image
|
||||
|
||||
FROM alonid/vim-testbed:10
|
||||
|
||||
RUN install_vim -tag v7.4.052 -name vim74-trusty -build \
|
||||
-tag v8.0.1850 -name vim80 -build \
|
||||
-tag v8.1.0105 -name vim81 -build \
|
||||
-tag neovim:v0.1.7 -build \
|
||||
-tag neovim:v0.2.2 -build
|
||||
|
||||
ENV PACKAGES="\
|
||||
bash \
|
||||
git \
|
||||
python \
|
||||
python2-pip \
|
||||
curl \
|
||||
"
|
||||
|
||||
RUN dnf install -y $PACKAGES
|
||||
|
||||
RUN pip install vim-vint==0.3.19
|
||||
|
||||
RUN export HOME=/rust ; mkdir $HOME ; curl https://sh.rustup.rs -sSf | sh -s -- -y
|
||||
|
||||
RUN chown vimtest.vimtest -R /rust
|
||||
|
||||
RUN (dnf remove -y gcc \*-devel ; \
|
||||
dnf install -y gpm msgpack libvterm libtermkey unibilium ) || true
|
||||
RUN dnf clean all
|
||||
|
||||
RUN echo "export PATH=~/.cargo/bin:$PATH" >> ~/.bashrc
|
||||
|
||||
RUN git clone https://github.com/da-x/vader.vim vader && \
|
||||
cd vader && git checkout v2017-12-26
|
||||
24
pack/acp/start/rust.vim/test/coverage.vader
Normal file
24
pack/acp/start/rust.vim/test/coverage.vader
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
Given rust (Some Rust code):
|
||||
fn main() {
|
||||
println!("Hello World\n")
|
||||
}
|
||||
|
||||
Execute (RustInfo - call it to see that it works):
|
||||
redir => m
|
||||
silent RustInfo
|
||||
redir END
|
||||
Log m
|
||||
|
||||
Execute (RustEmitAsm - see that we actually get assembly output):
|
||||
silent! w test.rs
|
||||
silent! e! test.rs
|
||||
redir => m
|
||||
silent! RustEmitAsm
|
||||
redir END
|
||||
AssertEqual 'asm', &filetype
|
||||
normal! ggVGy:q<CR>
|
||||
AssertEqual 1,(@" =~# '\V.section')
|
||||
bd
|
||||
call delete('test.rs')
|
||||
|
||||
# TODO: a lot more tests
|
||||
292
pack/acp/start/rust.vim/test/indent.vader
Normal file
292
pack/acp/start/rust.vim/test/indent.vader
Normal file
|
|
@ -0,0 +1,292 @@
|
|||
Given rust:
|
||||
fn main() {
|
||||
let a = 2;
|
||||
println!("Hello World\n")
|
||||
}
|
||||
|
||||
Do:
|
||||
vip=
|
||||
|
||||
Expect rust (very basic indentation result):
|
||||
fn main() {
|
||||
let a = 2;
|
||||
println!("Hello World\n")
|
||||
}
|
||||
|
||||
############################################
|
||||
# Issue #195
|
||||
|
||||
Given rust:
|
||||
fn main() {
|
||||
let paths: Vec<_> = ({
|
||||
fs::read_dir("test_data")
|
||||
.unwrap()
|
||||
.cloned()
|
||||
})
|
||||
.collect();
|
||||
|
||||
println!("Hello World\n");
|
||||
}
|
||||
|
||||
Do:
|
||||
/collect\<cr>
|
||||
ostatement();\<ESC>\<ESC>
|
||||
|
||||
Expect rust (issue #195):
|
||||
fn main() {
|
||||
let paths: Vec<_> = ({
|
||||
fs::read_dir("test_data")
|
||||
.unwrap()
|
||||
.cloned()
|
||||
})
|
||||
.collect();
|
||||
statement();
|
||||
|
||||
println!("Hello World\n");
|
||||
}
|
||||
|
||||
############################################
|
||||
# Issue #189
|
||||
|
||||
Given rust:
|
||||
impl X for {
|
||||
pub fn get<Q>(&self, key: &Q) -> Option<Entry<K, V>>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Ord + ?Sized,
|
||||
{
|
||||
self.inner.get(key).map(Entry::new)
|
||||
}
|
||||
}
|
||||
|
||||
Do:
|
||||
vip=
|
||||
|
||||
Expect rust (issue #189):
|
||||
impl X for {
|
||||
pub fn get<Q>(&self, key: &Q) -> Option<Entry<K, V>>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Ord + ?Sized,
|
||||
{
|
||||
self.inner.get(key).map(Entry::new)
|
||||
}
|
||||
}
|
||||
|
||||
############################################
|
||||
# Issue #189b
|
||||
|
||||
Given rust:
|
||||
impl X for {
|
||||
pub fn get<Q>(&self, key: &Q) -> Option<Entry<K, V>>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Ord + ?Sized
|
||||
{
|
||||
self.inner.get(key).map(Entry::new)
|
||||
}
|
||||
}
|
||||
|
||||
Do:
|
||||
vip=
|
||||
|
||||
Expect rust (issue #189b):
|
||||
impl X for {
|
||||
pub fn get<Q>(&self, key: &Q) -> Option<Entry<K, V>>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Ord + ?Sized
|
||||
{
|
||||
self.inner.get(key).map(Entry::new)
|
||||
}
|
||||
}
|
||||
|
||||
############################################
|
||||
# Issue #189c
|
||||
|
||||
Given rust:
|
||||
impl X for {
|
||||
pub fn get<Q>(&self, key: &Q) -> Option<Entry<K, V>>
|
||||
where K: Borrow<Q>, Q: Ord + ?Sized
|
||||
{
|
||||
self.inner.get(key).map(Entry::new)
|
||||
}
|
||||
}
|
||||
|
||||
Do:
|
||||
vip=
|
||||
|
||||
Expect rust (issue #189b):
|
||||
impl X for {
|
||||
pub fn get<Q>(&self, key: &Q) -> Option<Entry<K, V>>
|
||||
where K: Borrow<Q>, Q: Ord + ?Sized
|
||||
{
|
||||
self.inner.get(key).map(Entry::new)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
############################################
|
||||
# Issue #149
|
||||
|
||||
Given rust:
|
||||
fn test() {
|
||||
let t = "a
|
||||
wah";
|
||||
}
|
||||
|
||||
Do:
|
||||
/wah\<cr>
|
||||
i#\<ESC>\<ESC>
|
||||
/;\<cr>o
|
||||
statement();\<ESC>\<ESC>
|
||||
|
||||
# Disabled
|
||||
# Expect rust (issue #149):
|
||||
fn test() {
|
||||
let t = "a
|
||||
#wah";
|
||||
statement();
|
||||
}
|
||||
|
||||
|
||||
############################################
|
||||
# Issue #77
|
||||
|
||||
Given rust:
|
||||
fn test() {
|
||||
}
|
||||
|
||||
Do:
|
||||
of(x, y,\<CR>z);\<CR>
|
||||
f((x, y),\<CR>z);\<CR>
|
||||
|
||||
# Disabled
|
||||
# Expect rust (issue #77):
|
||||
fn test() {
|
||||
f(x, y,
|
||||
z);
|
||||
f((x, y),
|
||||
z);
|
||||
|
||||
}
|
||||
|
||||
############################################
|
||||
# Issue #44
|
||||
|
||||
Given rust:
|
||||
fn main() {
|
||||
a
|
||||
|
||||
let philosophers = vec![
|
||||
Philosopher::new("Judith Butler"),
|
||||
Philosopher::new("Gilles Deleuze"),
|
||||
Philosopher::new("Karl Marx"),
|
||||
Philosopher::new("Emma Goldman"),
|
||||
Philosopher::new("Michel Foucault"),
|
||||
];
|
||||
}
|
||||
|
||||
Do:
|
||||
/let\<CR>
|
||||
vip=
|
||||
|
||||
# Disabled
|
||||
# Expect rust (issue #44):
|
||||
fn main() {
|
||||
a
|
||||
|
||||
let philosophers = vec![
|
||||
Philosopher::new("Judith Butler"),
|
||||
Philosopher::new("Gilles Deleuze"),
|
||||
Philosopher::new("Karl Marx"),
|
||||
Philosopher::new("Emma Goldman"),
|
||||
Philosopher::new("Michel Foucault"),
|
||||
];
|
||||
}
|
||||
|
||||
############################################
|
||||
# Issue #5
|
||||
|
||||
Given rust:
|
||||
fn f() {
|
||||
if x &&
|
||||
y {
|
||||
}
|
||||
}
|
||||
|
||||
Do:
|
||||
vip=
|
||||
|
||||
Expect rust (issue #5):
|
||||
fn f() {
|
||||
if x &&
|
||||
y {
|
||||
}
|
||||
}
|
||||
|
||||
############################################
|
||||
# Issue #366
|
||||
|
||||
Given rust:
|
||||
fn f() {
|
||||
g(|_| {
|
||||
h();
|
||||
})
|
||||
.unwrap();
|
||||
h();
|
||||
}
|
||||
|
||||
Do:
|
||||
vip=
|
||||
|
||||
Expect rust (issue #366):
|
||||
fn f() {
|
||||
g(|_| {
|
||||
h();
|
||||
})
|
||||
.unwrap();
|
||||
h();
|
||||
}
|
||||
|
||||
Given rust:
|
||||
fn f() {
|
||||
let a = g(|_| {
|
||||
h();
|
||||
})
|
||||
.unwrap();
|
||||
h();
|
||||
}
|
||||
|
||||
Do:
|
||||
vip=
|
||||
|
||||
Expect rust (issue #366, variation #2):
|
||||
fn f() {
|
||||
let a = g(|_| {
|
||||
h();
|
||||
})
|
||||
.unwrap();
|
||||
h();
|
||||
}
|
||||
|
||||
############################################
|
||||
|
||||
Given rust:
|
||||
fn f() {
|
||||
let mut state = State::new(
|
||||
backend,
|
||||
header.clone(),
|
||||
).expect("Something");
|
||||
}
|
||||
|
||||
Do:
|
||||
vip=
|
||||
|
||||
Expect rust (Trailing comma in call):
|
||||
fn f() {
|
||||
let mut state = State::new(
|
||||
backend,
|
||||
header.clone(),
|
||||
).expect("Something");
|
||||
}
|
||||
105
pack/acp/start/rust.vim/test/run-tests
Executable file
105
pack/acp/start/rust.vim/test/run-tests
Executable file
|
|
@ -0,0 +1,105 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
REPO = "alonid/vim-testbed"
|
||||
TAG = "10-rust.vim"
|
||||
IMAGE = "%s:%s" % (REPO, TAG)
|
||||
|
||||
class Error(Exception):
|
||||
pass
|
||||
|
||||
def system(cmd, capture=False, ok_fail=False):
|
||||
if capture:
|
||||
f = os.popen(cmd)
|
||||
d = f.read()
|
||||
return d
|
||||
|
||||
res = os.system(cmd)
|
||||
if res != 0:
|
||||
if ok_fail:
|
||||
return res
|
||||
|
||||
raise Error("Error executing: %s" % (cmd, ))
|
||||
return 0
|
||||
|
||||
def root():
|
||||
return os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
|
||||
|
||||
def prep():
|
||||
d = os.path.join(root(), "test")
|
||||
for i in [".cargo", ".rustup", ".multirust"]:
|
||||
l = os.path.join(d, i)
|
||||
if not os.path.lexists(l):
|
||||
os.symlink("/rust/" + i, l)
|
||||
|
||||
l = os.path.join(root(), "test/.vimrc")
|
||||
if not os.path.lexists(l):
|
||||
os.symlink("vimrc", l)
|
||||
|
||||
if not os.path.exists(os.path.join(d, ".profile")):
|
||||
f = open(os.path.join(d, ".profile"), "w")
|
||||
f.write('export PATH="$HOME/.cargo/bin:$PATH"\n')
|
||||
f.close()
|
||||
|
||||
def docker_run(cmd, interactive=False, ok_fail=False):
|
||||
prep()
|
||||
d = root()
|
||||
params = "-v %s:/testplugin -v %s/test:/home/vimtest" % (d, d)
|
||||
params += " -e HOME=/home/vimtest"
|
||||
if not interactive:
|
||||
params += " -a stderr"
|
||||
params += " -e VADER_OUTPUT_FILE=/dev/stderr"
|
||||
params += " -u %s" % (os.getuid(), )
|
||||
params += " -w /testplugin"
|
||||
if interactive:
|
||||
interactive_str = "-it"
|
||||
else:
|
||||
interactive_str = ""
|
||||
return system("docker run %s --rm %s %s %s" % (interactive_str, params, IMAGE, cmd),
|
||||
ok_fail=ok_fail)
|
||||
|
||||
def image_exists():
|
||||
r = system("docker images -q %s" % (IMAGE, ), capture=True)
|
||||
return len(r.strip().splitlines()) >= 1
|
||||
|
||||
def tests_on_docker():
|
||||
res = docker_run("bash -lc 'python /home/vimtest/run-tests inside-docker'", ok_fail=True)
|
||||
if res == 0:
|
||||
print("Tests OK")
|
||||
else:
|
||||
print("Tests Failed")
|
||||
sys.exit(1)
|
||||
|
||||
def inside_docker():
|
||||
res = system("/vim-build/bin/vim80 --not-a-term '+Vader! test/*.vader'", ok_fail=True)
|
||||
if res != 0:
|
||||
sys.exit(1)
|
||||
|
||||
def run_with_vimrc(vimrc):
|
||||
res = system("vim -u %s --not-a-term '+Vader! test/*.vader'" % (vimrc, ), ok_fail=True)
|
||||
if res != 0:
|
||||
sys.exit(1)
|
||||
|
||||
def main():
|
||||
if sys.argv[1:] == ["inside-docker"]:
|
||||
inside_docker()
|
||||
return
|
||||
|
||||
if sys.argv[1:2] == ["run-with-vimrc"]:
|
||||
run_with_vimrc(sys.argv[2])
|
||||
return
|
||||
|
||||
if not image_exists():
|
||||
print("Need to take image from remote")
|
||||
system("docker pull %s" % (IMAGE, ))
|
||||
|
||||
if "-i" in sys.argv[1:]:
|
||||
docker_run("bash -l", interactive=True)
|
||||
return
|
||||
|
||||
tests_on_docker()
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
0
pack/acp/start/rust.vim/test/sample.rs
Normal file
0
pack/acp/start/rust.vim/test/sample.rs
Normal file
30
pack/acp/start/rust.vim/test/vimrc
Normal file
30
pack/acp/start/rust.vim/test/vimrc
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
" vint: -ProhibitSetNoCompatible
|
||||
"
|
||||
|
||||
set nocompatible
|
||||
filetype off
|
||||
|
||||
" This script is currently designed to be run from within Docker, the
|
||||
" following paths are intrinsic to the container:
|
||||
source /rtp.vim
|
||||
|
||||
" Paths need prepending (instead of what is originally done
|
||||
" in vim-testbed) in order to supersede the rust.vim that is
|
||||
" supplied with Vim.
|
||||
exec 'set runtimepath=/vader,/testplugin,' . &runtimepath
|
||||
cd /testplugin
|
||||
|
||||
filetype plugin indent on
|
||||
syntax on
|
||||
|
||||
set nocompatible
|
||||
set tabstop=8
|
||||
set softtabstop=4
|
||||
set shiftwidth=4
|
||||
set expandtab
|
||||
set backspace=2
|
||||
set nofoldenable
|
||||
set foldmethod=syntax
|
||||
set foldlevelstart=10
|
||||
set foldnestmax=10
|
||||
set ttimeoutlen=0
|
||||
1
pack/acp/start/rust.vim/triagebot.toml
Normal file
1
pack/acp/start/rust.vim/triagebot.toml
Normal file
|
|
@ -0,0 +1 @@
|
|||
[assign]
|
||||
|
|
@ -13,6 +13,7 @@ Git submodules are slow, so handle this manually.
|
|||
* [landscape.vim](https://github.com/itchyny/landscape.vim)
|
||||
* [limelight.vim](https://github.com/junegunn/limelight.vim)
|
||||
* [mom.vim](http://git.savannah.gnu.org/cgit/groff.git/plain/contrib/mom/examples/mom.vim)
|
||||
* [rust.vim](https://github.com/rust-lang/rust.vim)
|
||||
* [tempus-themes-vim](https://gitlab.com/protesilaos/tempus-themes-vim)
|
||||
* [vim-actodo](https://github.com/acperkins/vim-actodo)
|
||||
* [vim-asciidoctor](https://github.com/habamax/vim-asciidoctor)
|
||||
|
|
|
|||
Loading…
Reference in a new issue