rollup merge of #21738: steveklabnik/move_out_editors

As we grow, these don't belong in-tree.

http://internals.rust-lang.org/t/moving-editor-highlighting-into-their-own-repos/1395

* https://github.com/rust-lang/rust.vim
* https://github.com/rust-lang/rust-mode
* https://github.com/rust-lang/gedit-config
* https://github.com/rust-lang/kate-config
* https://github.com/rust-lang/nano-config
* https://github.com/rust-lang/zsh-config

21 files changed, 0 insertions, 3617 deletions

diff --git a/src/etc/emacs/README.md b/src/etc/emacs/README.md
deleted file mode 100644
index 24470c258b3..00000000000
--- a/src/etc/emacs/README.md
+++ /dev/null
@@ -1,79 +0,0 @@
-`rust-mode`: A major Emacs mode for editing Rust source code
-============================================================
-
-`rust-mode` makes editing [Rust](http://rust-lang.org) code with Emacs
-enjoyable.
-
-
-### Manual Installation
-
-To install manually, check out this repository and add this to your
-`.emacs` file:
-
-```lisp
-(add-to-list 'load-path "/path/to/rust-mode/")
-(autoload 'rust-mode "rust-mode" nil t)
-(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))
-```
-
-This associates `rust-mode` with `.rs` files. To enable it explicitly, do
-<kbd>M-x rust-mode</kbd>.
-
-### `package.el` installation via Marmalade or MELPA
-
-It can be more convenient to use Emacs's package manager to handle
-installation for you if you use many elisp libraries. If you have
-`package.el` but haven't added Marmalade or MELPA, the community
-package source, yet, add this to `~/.emacs.d/init.el`:
-
-Using Marmalade:
-
-```lisp
-(require 'package)
-(add-to-list 'package-archives
-             '("marmalade" . "http://marmalade-repo.org/packages/"))
-(package-initialize)
-```
-
-Using MELPA:
-
-```lisp
-(require 'package)
-(add-to-list 'package-archives
-             '("melpa" . "http://melpa.milkbox.net/packages/") t)
-(package-initialize)
-```
-
-Then do this to load the package listing:
-
-* <kbd>M-x eval-buffer</kbd>
-* <kbd>M-x package-refresh-contents</kbd>
-
-If you use a version of Emacs prior to 24 that doesn't include
-`package.el`, you can get it from [here](http://bit.ly/pkg-el23).
-
-If you have an older ELPA `package.el` installed from tromey.com, you
-should upgrade in order to support installation from multiple sources.
-The ELPA archive is deprecated and no longer accepting new packages,
-so the version there (1.7.1) is very outdated.
-
-#### Install `rust-mode`
-
-One you have `package.el`, you can install `rust-mode` or any other
-modes by choosing them from a list:
-
-* <kbd>M-x package-list-packages</kbd>
-
-Now, to install packages, move your cursor to them and press
-<kbd>i</kbd>. This will mark the packages for installation. When
-you're done with marking, press <kbd>x</kbd>, and ELPA will install
-the packages for you (under `~/.emacs.d/elpa/`).
-
-* or using <kbd>M-x package-install rust-mode</kbd>
-
-### Tests via ERT
-
-The file `rust-mode-tests.el` contains tests that can be run via
-[ERT](http://www.gnu.org/software/emacs/manual/html_node/ert/index.html).
-You can use `run_rust_emacs_tests.sh` to run them in batch mode, if
-Emacs is somewhere in your `$PATH`.
diff --git a/src/etc/emacs/run_rust_emacs_tests.sh b/src/etc/emacs/run_rust_emacs_tests.sh
deleted file mode 100755
index b35fcf870c4..00000000000
--- a/src/etc/emacs/run_rust_emacs_tests.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-# file at the top-level directory of this distribution and at
-# http://rust-lang.org/COPYRIGHT.
-#
-# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-# option. This file may not be copied, modified, or distributed
-# except according to those terms.
-#
-# This runs the test for emacs rust-mode.
-# It must be possible to find emacs via PATH.
-emacs -batch -l rust-mode.el -l rust-mode-tests.el -f ert-run-tests-batch-and-exit
diff --git a/src/etc/emacs/rust-mode-tests.el b/src/etc/emacs/rust-mode-tests.el
deleted file mode 100644
index f255dbf1507..00000000000
--- a/src/etc/emacs/rust-mode-tests.el
+++ /dev/null
@@ -1,896 +0,0 @@
-;;; rust-mode-tests.el --- ERT tests for rust-mode.el
-
-(require 'rust-mode)
-(require 'ert)
-(require 'cl)
-
-(setq rust-test-fill-column 32)
-
-(defun rust-compare-code-after-manip (original point-pos manip-func expected got)
-  (equal expected got))
-
-(defun rust-test-explain-bad-manip (original point-pos manip-func expected got)
-  (if (equal expected got)
-      nil
-    (list
-     ;; The (goto-char) and (insert) business here is just for
-     ;; convenience--after an error, you can copy-paste that into emacs eval to
-     ;; insert the bare strings into a buffer
-     "Rust code was manipulated wrong after:"
-     `(insert ,original)
-     `(goto-char ,point-pos)
-     'expected `(insert ,expected)
-     'got `(insert ,got)
-     (loop for i from 0 to (max (length original) (length expected))
-           for oi = (if (< i (length got)) (elt got i))
-           for ei = (if (< i (length expected)) (elt expected i))
-           while (equal oi ei)
-           finally return `(first-difference-at
-                            (goto-char ,(+ 1 i))
-                            expected ,(char-to-string ei)
-                            got ,(char-to-string oi))))))
-(put 'rust-compare-code-after-manip 'ert-explainer
-     'rust-test-explain-bad-manip)
-
-(defun rust-test-manip-code (original point-pos manip-func expected)
-  (with-temp-buffer
-    (rust-mode)
-    (insert original)
-    (goto-char point-pos)
-    (funcall manip-func)
-    (should (rust-compare-code-after-manip
-             original point-pos manip-func expected (buffer-string)))))
-
-(defun test-fill-paragraph (unfilled expected &optional start-pos end-pos)
-  "We're going to run through many scenarios here--the point should be able to be anywhere from the start-pos (defaults to 1) through end-pos (defaults to the length of what was passed in) and (fill-paragraph) should return the same result.
-
-Also, the result should be the same regardless of whether the code is at the beginning or end of the file.  (If you're not careful, that can make a difference.)  So we test each position given above with the passed code at the beginning, the end, neither and both.  So we do this a total of (end-pos - start-pos)*4 times.  Oy."
-  (let* ((start-pos (or start-pos 1))
-         (end-pos (or end-pos (length unfilled)))
-         (padding "\n     \n")
-         (padding-len (length padding)))
-    (loop
-     for pad-at-beginning from 0 to 1
-     do (loop for pad-at-end from 0 to 1
-              with padding-beginning = (if (= 0 pad-at-beginning) "" padding)
-              with padding-end = (if (= 0 pad-at-end) "" padding)
-              with padding-adjust = (* padding-len pad-at-beginning)
-              with padding-beginning = (if (= 0 pad-at-beginning) "" padding)
-              with padding-end = (if (= 0 pad-at-end) "" padding)
-              ;; If we're adding space to the beginning, and our start position
-              ;; is at the very beginning, we want to test within the added space.
-              ;; Otherwise adjust the start and end for the beginning padding.
-              with start-pos = (if (= 1 start-pos) 1 (+ padding-adjust start-pos))
-              with end-pos = (+ end-pos padding-adjust)
-              do (loop for pos from start-pos to end-pos
-                       do (rust-test-manip-code
-                           (concat padding-beginning unfilled padding-end)
-                           pos
-                           (lambda ()
-                             (let ((fill-column rust-test-fill-column))
-                               (fill-paragraph)))
-                           (concat padding-beginning expected padding-end)))))))
-
-(ert-deftest fill-paragraph-top-level-multi-line-style-doc-comment-second-line ()
-  (test-fill-paragraph
-   "/**
- * This is a very very very very very very very long string
- */"
-   "/**
- * This is a very very very very
- * very very very long string
- */"))
-
-
-(ert-deftest fill-paragraph-top-level-multi-line-style-doc-comment-first-line ()
-  (test-fill-paragraph
-   "/** This is a very very very very very very very long string
- */"
-   "/** This is a very very very
- * very very very very long
- * string
- */"))
-
-(ert-deftest fill-paragraph-multi-paragraph-multi-line-style-doc-comment ()
-  (let
-      ((multi-paragraph-unfilled
-        "/**
- * This is the first really really really really really really really long paragraph
- *
- * This is the second really really really really really really long paragraph
- */"))
-    (test-fill-paragraph
-     multi-paragraph-unfilled
-     "/**
- * This is the first really
- * really really really really
- * really really long paragraph
- *
- * This is the second really really really really really really long paragraph
- */"
-     1 89)
-    (test-fill-paragraph
-     multi-paragraph-unfilled
-     "/**
- * This is the first really really really really really really really long paragraph
- *
- * This is the second really
- * really really really really
- * really long paragraph
- */"
-     90)))
-
-(ert-deftest fill-paragraph-multi-paragraph-single-line-style-doc-comment ()
-  (let
-      ((multi-paragraph-unfilled
-        "/// This is the first really really really really really really really long paragraph
-///
-/// This is the second really really really really really really long paragraph"))
-    (test-fill-paragraph
-     multi-paragraph-unfilled
-     "/// This is the first really
-/// really really really really
-/// really really long paragraph
-///
-/// This is the second really really really really really really long paragraph"
-     1 86)
-    (test-fill-paragraph
-     multi-paragraph-unfilled
-     "/// This is the first really really really really really really really long paragraph
-///
-/// This is the second really
-/// really really really really
-/// really long paragraph"
-     87)))
-
-(ert-deftest fill-paragraph-multi-paragraph-single-line-style-indented ()
-  (test-fill-paragraph
-   "     // This is the first really really really really really really really long paragraph
-     //
-     // This is the second really really really really really really long paragraph"
-   "     // This is the first really
-     // really really really
-     // really really really
-     // long paragraph
-     //
-     // This is the second really really really really really really long paragraph" 1 89))
-
-(ert-deftest fill-paragraph-multi-line-style-inner-doc-comment ()
-  (test-fill-paragraph
-   "/*! This is a very very very very very very very long string
- */"
-   "/*! This is a very very very
- * very very very very long
- * string
- */"))
-
-(ert-deftest fill-paragraph-single-line-style-inner-doc-comment ()
-  (test-fill-paragraph
-   "//! This is a very very very very very very very long string"
-   "//! This is a very very very
-//! very very very very long
-//! string"))
-
-(ert-deftest fill-paragraph-prefixless-multi-line-doc-comment ()
-  (test-fill-paragraph
-   "/**
-This is my summary. Blah blah blah blah blah. Dilly dally dilly dally dilly dally doo.
-
-This is some more text.  Fee fie fo fum.  Humpty dumpty sat on a wall.
-*/"
-   "/**
-This is my summary. Blah blah
-blah blah blah. Dilly dally
-dilly dally dilly dally doo.
-
-This is some more text.  Fee fie fo fum.  Humpty dumpty sat on a wall.
-*/" 4 90))
-
-(ert-deftest fill-paragraph-with-no-space-after-star-prefix ()
-  (test-fill-paragraph
-   "/**
- *This is a very very very very very very very long string
- */"
-   "/**
- *This is a very very very very
- *very very very long string
- */"))
-
-(ert-deftest fill-paragraph-single-line-style-with-code-before ()
-  (test-fill-paragraph
-   "fn foo() { }
-/// This is my comment.  This is more of my comment.  This is even more."
-   "fn foo() { }
-/// This is my comment.  This is
-/// more of my comment.  This is
-/// even more." 14))
-
-(ert-deftest fill-paragraph-single-line-style-with-code-after ()
-  (test-fill-paragraph
-   "/// This is my comment.  This is more of my comment.  This is even more.
-fn foo() { }"
-   "/// This is my comment.  This is
-/// more of my comment.  This is
-/// even more.
-fn foo() { }" 1 73))
-
-(ert-deftest fill-paragraph-single-line-style-code-before-and-after ()
-  (test-fill-paragraph
-   "fn foo() { }
-/// This is my comment.  This is more of my comment.  This is even more.
-fn bar() { }"
-   "fn foo() { }
-/// This is my comment.  This is
-/// more of my comment.  This is
-/// even more.
-fn bar() { }" 14 67))
-
-(defun test-auto-fill (initial position inserted expected)
-  (rust-test-manip-code
-   initial
-   position
-   (lambda ()
-     (unwind-protect
-         (progn
-           (let ((fill-column rust-test-fill-column))
-             (auto-fill-mode)
-             (goto-char position)
-             (insert inserted)
-             (syntax-ppss-flush-cache 1)
-             (funcall auto-fill-function)))
-       (auto-fill-mode t)))
-   expected))
-
-(ert-deftest auto-fill-multi-line-doc-comment ()
-  (test-auto-fill
-   "/**
- *
- */"
-   8
-   "This is a very very very very very very very long string"
-   "/**
- * This is a very very very very
- * very very very long string
- */"))
-
-(ert-deftest auto-fill-single-line-doc-comment ()
-  (test-auto-fill
-   "/// This is the first really
-/// really really really really
-/// really really long paragraph
-///
-/// "
-   103
-   "This is the second really really really really really really long paragraph"
-   "/// This is the first really
-/// really really really really
-/// really really long paragraph
-///
-/// This is the second really
-/// really really really really
-/// really long paragraph"
-   ))
-
-(ert-deftest auto-fill-multi-line-prefixless ()
-  (test-auto-fill
-   "/*
-
- */"
-   4
-   "This is a very very very very very very very long string"
-   "/*
-This is a very very very very
-very very very long string
- */"
-   ))
-
-(defun test-indent (indented)
-  (let ((deindented (replace-regexp-in-string "^[[:blank:]]*" "      " indented)))
-    (rust-test-manip-code
-     deindented
-     1
-     (lambda () (indent-region 1 (buffer-size)))
-     indented)))
-
-
-(ert-deftest indent-struct-fields-aligned ()
-  (test-indent
-   "
-struct Foo { bar: int,
-             baz: int }
-
-struct Blah {x:int,
-             y:int,
-             z:String"))
-
-(ert-deftest indent-doc-comments ()
-  (test-indent
-   "
-/**
- * This is a doc comment
- *
- */
-
-/// So is this
-
-fn foo() {
-    /*!
-     * this is a nested doc comment
-     */
-
-    //! And so is this
-}"))
-
-(ert-deftest indent-inside-braces ()
-  (test-indent
-   "
-// struct fields out one level:
-struct foo {
-    a:int,
-    // comments too
-    b:char
-}
-
-fn bar(x:Box<int>) {   // comment here should not affect the next indent
-    bla();
-    bla();
-}"))
-
-(ert-deftest indent-top-level ()
-  (test-indent
-   "
-// Everything here is at the top level and should not be indented
-#[attrib]
-mod foo;
-
-pub static bar = Quux{a: b()}
-
-use foo::bar::baz;
-
-fn foo() { }
-"))
-
-(ert-deftest indent-params-no-align ()
-  (test-indent
-   "
-// Indent out one level because no params appear on the first line
-fn xyzzy(
-    a:int,
-    b:char) { }
-
-fn abcdef(
-    a:int,
-    b:char)
-    -> char
-{ }"))
-
-(ert-deftest indent-params-align ()
-  (test-indent
-   "
-// Align the second line of params to the first
-fn foo(a:int,
-       b:char) { }
-
-fn bar(   a:int,
-          b:char)
-          -> int
-{ }
-
-fn baz(   a:int,  // should work with a comment here
-          b:char)
-          -> int
-{ }
-"))
-
-(ert-deftest indent-square-bracket-alignment ()
-  (test-indent
-   "
-fn args_on_the_next_line( // with a comment
-    a:int,
-    b:String) {
-    let aaaaaa = [
-        1,
-        2,
-        3];
-    let bbbbbbb = [1, 2, 3,
-                   4, 5, 6];
-    let ccc = [   10, 9, 8,
-                  7, 6, 5];
-}
-"))
-
-(ert-deftest indent-nested-fns ()
-  (test-indent
-   "
-fn nexted_fns(a: fn(b:int,
-                    c:char)
-                    -> int,
-              d: int)
-              -> uint
-{
-    0
-}
-"
-   ))
-
-(ert-deftest indent-multi-line-expr ()
-  (test-indent
-   "
-fn foo()
-{
-    x();
-    let a =
-        b();
-}
-"
-   ))
-
-(ert-deftest indent-match ()
-  (test-indent
-   "
-fn foo() {
-    match blah {
-        Pattern => stuff(),
-        _ => whatever
-    }
-}
-"
-   ))
-
-(ert-deftest indent-match-multiline-pattern ()
-  (test-indent
-   "
-fn foo() {
-    match blah {
-        Pattern |
-        Pattern2 => {
-            hello()
-        },
-        _ => whatever
-    }
-}
-"
-   ))
-
-(ert-deftest indent-indented-match ()
-  (test-indent
-   "
-fn foo() {
-    let x =
-        match blah {
-            Pattern |
-            Pattern2 => {
-                hello()
-            },
-            _ => whatever
-        };
-    y();
-}
-"
-   ))
-
-(ert-deftest indent-curly-braces-within-parens ()
-  (test-indent
-   "
-fn foo() {
-    let x =
-        foo(bar(|x| {
-            only_one_indent_here();
-        }));
-    y();
-}
-"
-   ))
-
-(ert-deftest indent-weirdly-indented-block ()
-  (rust-test-manip-code
-   "
-fn foo() {
- {
-this_block_is_over_to_the_left_for_some_reason();
- }
-
-}
-"
-   16
-   #'indent-for-tab-command
-   "
-fn foo() {
- {
-     this_block_is_over_to_the_left_for_some_reason();
- }
-
-}
-"
-   ))
-
-(ert-deftest indent-multi-line-attrib ()
-  (test-indent
-   "
-#[attrib(
-    this,
-    that,
-    theotherthing)]
-fn function_with_multiline_attribute() {}
-"
-   ))
-
-
-;; Make sure that in effort to cover match patterns we don't mistreat || or expressions
-(ert-deftest indent-nonmatch-or-expression ()
-  (test-indent
-   "
-fn foo() {
-    let x = foo() ||
-        bar();
-}
-"
-   ))
-
-(setq rust-test-motion-string
-      "
-fn fn1(arg: int) -> bool {
-    let x = 5;
-    let y = b();
-    true
-}
-
-fn fn2(arg: int) -> bool {
-    let x = 5;
-    let y = b();
-    true
-}
-
-pub fn fn3(arg: int) -> bool {
-    let x = 5;
-    let y = b();
-    true
-}
-
-struct Foo {
-    x: int
-}
-"
-      rust-test-region-string rust-test-motion-string
-      rust-test-indent-motion-string
-      "
-fn blank_line(arg:int) -> bool {
-
-}
-
-fn indenting_closing_brace() {
-    if(true) {
-}
-}
-
-fn indenting_middle_of_line() {
-    if(true) {
- push_me_out();
-} else {
-               pull_me_back_in();
-}
-}
-
-fn indented_already() {
-
-    // The previous line already has its spaces
-}
-"
-
-      ;; Symbol -> (line column)
-      rust-test-positions-alist '((start-of-fn1 (2 0))
-                                  (start-of-fn1-middle-of-line (2 15))
-                                  (middle-of-fn1 (3 7))
-                                  (end-of-fn1 (6 0))
-                                  (between-fn1-fn2 (7 0))
-                                  (start-of-fn2 (8 0))
-                                  (middle-of-fn2 (10 4))
-                                  (before-start-of-fn1 (1 0))
-                                  (after-end-of-fn2 (13 0))
-                                  (beginning-of-fn3 (14 0))
-                                  (middle-of-fn3 (16 4))
-                                  (middle-of-struct (21 10))
-                                  (before-start-of-struct (19 0))
-                                  (after-end-of-struct (23 0))
-                                  (blank-line-indent-start (3 0))
-                                  (blank-line-indent-target (3 4))
-                                  (closing-brace-indent-start (8 1))
-                                  (closing-brace-indent-target (8 5))
-                                  (middle-push-indent-start (13 2))
-                                  (middle-push-indent-target (13 9))
-                                  (after-whitespace-indent-start (13 1))
-                                  (after-whitespace-indent-target (13 8))
-                                  (middle-pull-indent-start (15 19))
-                                  (middle-pull-indent-target (15 12))
-                                  (blank-line-indented-already-bol-start (20 0))
-                                  (blank-line-indented-already-bol-target (20 4))
-                                  (blank-line-indented-already-middle-start (20 2))
-                                  (blank-line-indented-already-middle-target (20 4))
-                                  (nonblank-line-indented-already-bol-start (21 0))
-                                  (nonblank-line-indented-already-bol-target (21 4))
-                                  (nonblank-line-indented-already-middle-start (21 2))
-                                  (nonblank-line-indented-already-middle-target (21 4))))
-
-(defun rust-get-buffer-pos (pos-symbol)
-  "Get buffer position from POS-SYMBOL.
-
-POS-SYMBOL is a symbol found in `rust-test-positions-alist'.
-Convert the line-column information from that list into a buffer position value."
-  (interactive "P")
-  (pcase-let ((`(,line ,column) (cadr (assoc pos-symbol rust-test-positions-alist))))
-    (save-excursion
-      (goto-line line)
-      (move-to-column column)
-      (point))))
-
-;;; FIXME: Maybe add an ERT explainer function (something that shows the
-;;; surrounding code of the final point, not just the position).
-(defun rust-test-motion (source-code init-pos final-pos manip-func &optional &rest args)
-  "Test that MANIP-FUNC moves point from INIT-POS to FINAL-POS.
-
-If ARGS are provided, send them to MANIP-FUNC.
-
-INIT-POS, FINAL-POS are position symbols found in `rust-test-positions-alist'."
-  (with-temp-buffer
-    (rust-mode)
-    (insert source-code)
-    (goto-char (rust-get-buffer-pos init-pos))
-    (apply manip-func args)
-    (should (equal (point) (rust-get-buffer-pos final-pos)))))
-
-(defun rust-test-region (source-code init-pos reg-beg reg-end manip-func &optional &rest args)
-  "Test that MANIP-FUNC marks region from REG-BEG to REG-END.
-
-INIT-POS is the initial position of point.
-If ARGS are provided, send them to MANIP-FUNC.
-All positions are position symbols found in `rust-test-positions-alist'."
-  (with-temp-buffer
-    (rust-mode)
-    (insert source-code)
-    (goto-char (rust-get-buffer-pos init-pos))
-    (apply manip-func args)
-    (should (equal (list (region-beginning) (region-end))
-                   (list (rust-get-buffer-pos reg-beg)
-                         (rust-get-buffer-pos reg-end))))))
-
-(ert-deftest rust-beginning-of-defun-from-middle-of-fn ()
-  (rust-test-motion
-   rust-test-motion-string
-   'middle-of-fn1
-   'start-of-fn1
-   #'beginning-of-defun))
-
-(ert-deftest rust-beginning-of-defun-from-end ()
-  (rust-test-motion
-   rust-test-motion-string
-   'end-of-fn1
-   'start-of-fn1
-   #'beginning-of-defun))
-
-(ert-deftest rust-beginning-of-defun-before-open-brace ()
-  (rust-test-motion
-   rust-test-motion-string
-   'start-of-fn1-middle-of-line
-   'start-of-fn1
-   #'beginning-of-defun))
-
-(ert-deftest rust-beginning-of-defun-between-fns ()
-  (rust-test-motion
-   rust-test-motion-string
-   'between-fn1-fn2
-   'start-of-fn1
-   #'beginning-of-defun))
-
-(ert-deftest rust-beginning-of-defun-with-arg ()
-  (rust-test-motion
-   rust-test-motion-string
-   'middle-of-fn2
-   'start-of-fn1
-   #'beginning-of-defun 2))
-
-(ert-deftest rust-beginning-of-defun-with-negative-arg ()
-  (rust-test-motion
-   rust-test-motion-string
-   'middle-of-fn1
-   'beginning-of-fn3
-   #'beginning-of-defun -2))
-
-(ert-deftest rust-beginning-of-defun-pub-fn ()
-  (rust-test-motion
-   rust-test-motion-string
-   'middle-of-fn3
-   'beginning-of-fn3
-   #'beginning-of-defun))
-
-(ert-deftest rust-end-of-defun-from-middle-of-fn ()
-  (rust-test-motion
-   rust-test-motion-string
-   'middle-of-fn1
-   'between-fn1-fn2
-   #'end-of-defun))
-
-(ert-deftest rust-end-of-defun-from-beg ()
-  (rust-test-motion
-   rust-test-motion-string
-   'start-of-fn1
-   'between-fn1-fn2
-   #'end-of-defun))
-
-(ert-deftest rust-end-of-defun-before-open-brace ()
-  (rust-test-motion
-   rust-test-motion-string
-   'start-of-fn1-middle-of-line
-   'between-fn1-fn2
-   #'end-of-defun))
-
-(ert-deftest rust-end-of-defun-between-fns ()
-  (rust-test-motion
-   rust-test-motion-string
-   'between-fn1-fn2
-   'after-end-of-fn2
-   #'end-of-defun))
-
-(ert-deftest rust-end-of-defun-with-arg ()
-  (rust-test-motion
-   rust-test-motion-string
-   'middle-of-fn1
-   'after-end-of-fn2
-   #'end-of-defun 2))
-
-(ert-deftest rust-end-of-defun-with-negative-arg ()
-  (rust-test-motion
-   rust-test-motion-string
-   'middle-of-fn3
-   'between-fn1-fn2
-   #'end-of-defun -2))
-
-(ert-deftest rust-mark-defun-from-middle-of-fn ()
-  (rust-test-region
-   rust-test-region-string
-   'middle-of-fn2
-   'between-fn1-fn2 'after-end-of-fn2
-   #'mark-defun))
-
-(ert-deftest rust-mark-defun-from-end ()
-  (rust-test-region
-   rust-test-region-string
-   'end-of-fn1
-   'before-start-of-fn1 'between-fn1-fn2
-   #'mark-defun))
-
-(ert-deftest rust-mark-defun-start-of-defun ()
-  (rust-test-region
-   rust-test-region-string
-   'start-of-fn2
-   'between-fn1-fn2 'after-end-of-fn2
-   #'mark-defun))
-
-(ert-deftest rust-mark-defun-from-middle-of-struct ()
-  (rust-test-region
-   rust-test-region-string
-   'middle-of-struct
-   'before-start-of-struct 'after-end-of-struct
-   #'mark-defun))
-
-(ert-deftest indent-line-blank-line-motion ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'blank-line-indent-start
-   'blank-line-indent-target
-   #'indent-for-tab-command))
-
-(ert-deftest indent-line-closing-brace-motion ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'closing-brace-indent-start
-   'closing-brace-indent-target
-   #'indent-for-tab-command))
-
-(ert-deftest indent-line-middle-push-motion ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'middle-push-indent-start
-   'middle-push-indent-target
-   #'indent-for-tab-command))
-
-(ert-deftest indent-line-after-whitespace-motion ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'after-whitespace-indent-start
-   'after-whitespace-indent-target
-   #'indent-for-tab-command))
-
-(ert-deftest indent-line-middle-pull-motion ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'middle-pull-indent-start
-   'middle-pull-indent-target
-   #'indent-for-tab-command))
-
-(ert-deftest indent-line-blank-line-indented-already-bol ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'blank-line-indented-already-bol-start
-   'blank-line-indented-already-bol-target
-   #'indent-for-tab-command))
-
-(ert-deftest indent-line-blank-line-indented-already-middle ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'blank-line-indented-already-middle-start
-   'blank-line-indented-already-middle-target
-   #'indent-for-tab-command))
-
-(ert-deftest indent-line-nonblank-line-indented-already-bol ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'nonblank-line-indented-already-bol-start
-   'nonblank-line-indented-already-bol-target
-   #'indent-for-tab-command))
-
-(ert-deftest indent-line-nonblank-line-indented-already-middle ()
-  (rust-test-motion
-   rust-test-indent-motion-string
-   'nonblank-line-indented-already-middle-start
-   'nonblank-line-indented-already-middle-target
-   #'indent-for-tab-command))
-
-(defun rust-test-fontify-string (str)
-  (with-temp-buffer
-    (rust-mode)
-    (insert str)
-    (font-lock-fontify-buffer)
-    (buffer-string)))
-
-(defun rust-test-group-str-by-face (str)
-  "Fontify `STR' in rust-mode and group it by face, returning a
-list of substrings of `STR' each followed by its face."
-  (cl-loop with fontified = (rust-test-fontify-string str)
-           for start = 0 then end
-           while start
-           for end   = (next-single-property-change start 'face fontified)
-           for prop  = (get-text-property start 'face fontified)
-           for text  = (substring-no-properties fontified start end)
-           if prop
-           append (list text prop)))
-
-(defun rust-test-font-lock (source face-groups)
-  "Test that `SOURCE' fontifies to the expected `FACE-GROUPS'"
-  (should (equal (rust-test-group-str-by-face source)
-                 face-groups)))
-
-(ert-deftest font-lock-attribute-simple ()
-  (rust-test-font-lock
-   "#[foo]"
-   '("#[foo]" font-lock-preprocessor-face)))
-
-(ert-deftest font-lock-attribute-inner ()
-  (rust-test-font-lock
-   "#![foo]"
-   '("#![foo]" font-lock-preprocessor-face)))
-
-(ert-deftest font-lock-attribute-key-value ()
-  (rust-test-font-lock
-   "#[foo = \"bar\"]"
-   '("#[foo = " font-lock-preprocessor-face
-     "\"bar\"" font-lock-string-face
-     "]" font-lock-preprocessor-face)))
-
-(ert-deftest font-lock-attribute-around-comment ()
-  (rust-test-font-lock
-   "#[foo /* bar */]"
-   '("#[foo " font-lock-preprocessor-face
-     "/* " font-lock-comment-delimiter-face
-     "bar */" font-lock-comment-face
-     "]" font-lock-preprocessor-face)))
-
-(ert-deftest font-lock-attribute-inside-string ()
-  (rust-test-font-lock
-   "\"#[foo]\""
-   '("\"#[foo]\"" font-lock-string-face)))
-
-(ert-deftest font-lock-attribute-inside-comment ()
-  (rust-test-font-lock
-   "/* #[foo] */"
-   '("/* " font-lock-comment-delimiter-face
-     "#[foo] */" font-lock-comment-face)))
diff --git a/src/etc/emacs/rust-mode.el b/src/etc/emacs/rust-mode.el
deleted file mode 100644
index dae685f3a54..00000000000
--- a/src/etc/emacs/rust-mode.el
+++ /dev/null
@@ -1,520 +0,0 @@
-;;; rust-mode.el --- A major emacs mode for editing Rust source code
-
-;; Version: 0.2.0
-;; Author: Mozilla
-;; Url: https://github.com/rust-lang/rust
-;; Keywords: languages
-
-;;; Commentary:
-;;
-
-;;; Code:
-
-(eval-when-compile (require 'misc))
-
-;; for GNU Emacs < 24.3
-(eval-when-compile
-  (unless (fboundp 'setq-local)
-    (defmacro setq-local (var val)
-      "Set variable VAR to value VAL in current buffer."
-      (list 'set (list 'make-local-variable (list 'quote var)) val))))
-
-;; Syntax definitions and helpers
-(defvar rust-mode-syntax-table
-  (let ((table (make-syntax-table)))
-
-    ;; Operators
-    (dolist (i '(?+ ?- ?* ?/ ?& ?| ?^ ?! ?< ?> ?~ ?@))
-      (modify-syntax-entry i "." table))
-
-    ;; Strings
-    (modify-syntax-entry ?\" "\"" table)
-    (modify-syntax-entry ?\\ "\\" table)
-
-    ;; mark _ as a word constituent so that identifiers
-    ;; such as xyz_type don't cause type to be highlighted
-    ;; as a keyword
-    (modify-syntax-entry ?_ "w" table)
-
-    ;; Comments
-    (modify-syntax-entry ?/  ". 124b" table)
-    (modify-syntax-entry ?*  ". 23"   table)
-    (modify-syntax-entry ?\n "> b"    table)
-    (modify-syntax-entry ?\^m "> b"   table)
-
-    table))
-
-(defgroup rust-mode nil
-  "Support for Rust code."
-  :link '(url-link "http://www.rust-lang.org/")
-  :group 'languages)
-
-(defcustom rust-indent-offset 4
-  "Indent Rust code by this number of spaces."
-  :type 'integer
-  :group 'rust-mode)
-
-(defcustom rust-indent-method-chain nil
-  "Indent Rust method chains, aligned by the '.' operators"
-  :type 'boolean
-  :group 'rust-mode)
-
-(defun rust-paren-level () (nth 0 (syntax-ppss)))
-(defun rust-in-str-or-cmnt () (nth 8 (syntax-ppss)))
-(defun rust-rewind-past-str-cmnt () (goto-char (nth 8 (syntax-ppss))))
-(defun rust-rewind-irrelevant ()
-  (let ((starting (point)))
-    (skip-chars-backward "[:space:]\n")
-    (if (looking-back "\\*/") (backward-char))
-    (if (rust-in-str-or-cmnt)
-        (rust-rewind-past-str-cmnt))
-    (if (/= starting (point))
-        (rust-rewind-irrelevant))))
-
-(defun rust-align-to-expr-after-brace ()
-  (save-excursion
-    (forward-char)
-    ;; We don't want to indent out to the open bracket if the
-    ;; open bracket ends the line
-    (when (not (looking-at "[[:blank:]]*\\(?://.*\\)?$"))
-      (when (looking-at "[[:space:]]")
-    (forward-word 1)
-    (backward-word 1))
-      (current-column))))
-
-(defun rust-align-to-method-chain ()
-  (save-excursion
-    (previous-line)
-    (end-of-line)
-    (backward-word 1)
-    (backward-char)
-    (when (looking-at "\\..+\(.*\)\n")
-      (- (current-column) rust-indent-offset))))
-
-(defun rust-rewind-to-beginning-of-current-level-expr ()
-  (let ((current-level (rust-paren-level)))
-    (back-to-indentation)
-    (while (> (rust-paren-level) current-level)
-      (backward-up-list)
-      (back-to-indentation))))
-
-(defun rust-mode-indent-line ()
-  (interactive)
-  (let ((indent
-         (save-excursion
-           (back-to-indentation)
-           ;; Point is now at beginning of current line
-           (let* ((level (rust-paren-level))
-                  (baseline
-                   ;; Our "baseline" is one level out from the indentation of the expression
-                   ;; containing the innermost enclosing opening bracket.  That
-                   ;; way if we are within a block that has a different
-                   ;; indentation than this mode would give it, we still indent
-                   ;; the inside of it correctly relative to the outside.
-                   (if (= 0 level)
-                       0
-                     (or
-                      (when rust-indent-method-chain
-                        (rust-align-to-method-chain))
-                     (save-excursion
-                       (backward-up-list)
-                       (rust-rewind-to-beginning-of-current-level-expr)
-                       (+ (current-column) rust-indent-offset))))))
-             (cond
-              ;; A function return type is indented to the corresponding function arguments
-              ((looking-at "->")
-               (save-excursion
-                 (backward-list)
-                 (or (rust-align-to-expr-after-brace)
-                     (+ baseline rust-indent-offset))))
-
-              ;; A closing brace is 1 level unindended
-              ((looking-at "}") (- baseline rust-indent-offset))
-
-              ;;Line up method chains by their .'s
-              ((when (and rust-indent-method-chain
-                          (looking-at "\..+\(.*\);?\n"))
-                 (or
-                  (let ((method-indent (rust-align-to-method-chain)))
-                    (when method-indent
-                      (+ method-indent rust-indent-offset)))
-                  (+ baseline rust-indent-offset))))
-
-              
-              ;; Doc comments in /** style with leading * indent to line up the *s
-              ((and (nth 4 (syntax-ppss)) (looking-at "*"))
-               (+ 1 baseline))
-
-              ;; If we're in any other token-tree / sexp, then:
-              (t
-               (or
-                ;; If we are inside a pair of braces, with something after the
-                ;; open brace on the same line and ending with a comma, treat
-                ;; it as fields and align them.
-                (when (> level 0)
-                  (save-excursion
-                    (rust-rewind-irrelevant)
-                    (backward-up-list)
-                    ;; Point is now at the beginning of the containing set of braces
-                    (rust-align-to-expr-after-brace)))
-
-                (progn
-                  (back-to-indentation)
-                  ;; Point is now at the beginning of the current line
-                  (if (or
-                       ;; If this line begins with "else" or "{", stay on the
-                       ;; baseline as well (we are continuing an expression,
-                       ;; but the "else" or "{" should align with the beginning
-                       ;; of the expression it's in.)
-                       (looking-at "\\<else\\>\\|{")
-
-                       (save-excursion
-                         (rust-rewind-irrelevant)
-                         ;; Point is now at the end of the previous ine
-                         (or
-                          ;; If we are at the first line, no indentation is needed, so stay at baseline...
-                          (= 1 (line-number-at-pos (point)))
-                          ;; ..or if the previous line ends with any of these:
-                          ;;     { ? : ( , ; [ }
-                          ;; then we are at the beginning of an expression, so stay on the baseline...
-                          (looking-back "[(,:;?[{}]\\|[^|]|")
-                          ;; or if the previous line is the end of an attribute, stay at the baseline...
-                          (progn (rust-rewind-to-beginning-of-current-level-expr) (looking-at "#")))))
-                      baseline
-
-                    ;; Otherwise, we are continuing the same expression from the previous line,
-                    ;; so add one additional indent level
-                    (+ baseline rust-indent-offset))))))))))
-
-    ;; If we're at the beginning of the line (before or at the current
-    ;; indentation), jump with the indentation change.  Otherwise, save the
-    ;; excursion so that adding the indentations will leave us at the
-    ;; equivalent position within the line to where we were before.
-    (if (<= (current-column) (current-indentation))
-        (indent-line-to indent)
-      (save-excursion (indent-line-to indent)))))
-
-
-;; Font-locking definitions and helpers
-(defconst rust-mode-keywords
-  '("as"
-    "box" "break"
-    "const" "continue" "crate"
-    "do"
-    "else" "enum" "extern"
-    "false" "fn" "for"
-    "if" "impl" "in"
-    "let" "loop"
-    "match" "mod" "move" "mut"
-    "priv" "pub"
-    "ref" "return"
-    "self" "static" "struct" "super"
-    "true" "trait" "type"
-    "unsafe" "use"
-    "virtual"
-    "where" "while"))
-
-(defconst rust-special-types
-  '("u8" "i8"
-    "u16" "i16"
-    "u32" "i32"
-    "u64" "i64"
-
-    "f32" "f64"
-    "float" "int" "uint" "isize" "usize"
-    "bool"
-    "str" "char"))
-
-(defconst rust-re-ident "[[:word:][:multibyte:]_][[:word:][:multibyte:]_[:digit:]]*")
-(defconst rust-re-CamelCase "[[:upper:]][[:word:][:multibyte:]_[:digit:]]*")
-(defun rust-re-word (inner) (concat "\\<" inner "\\>"))
-(defun rust-re-grab (inner) (concat "\\(" inner "\\)"))
-(defun rust-re-grabword (inner) (rust-re-grab (rust-re-word inner)))
-(defun rust-re-item-def (itype)
-  (concat (rust-re-word itype) "[[:space:]]+" (rust-re-grab rust-re-ident)))
-
-(defvar rust-mode-font-lock-keywords
-  (append
-   `(
-     ;; Keywords proper
-     (,(regexp-opt rust-mode-keywords 'words) . font-lock-keyword-face)
-
-     ;; Special types
-     (,(regexp-opt rust-special-types 'words) . font-lock-type-face)
-
-     ;; Attributes like `#[bar(baz)]` or `#![bar(baz)]` or `#[bar = "baz"]`
-     (,(rust-re-grab (concat "#\\!?\\[" rust-re-ident "[^]]*\\]"))
-      1 font-lock-preprocessor-face keep)
-
-     ;; Syntax extension invocations like `foo!`, highlight including the !
-     (,(concat (rust-re-grab (concat rust-re-ident "!")) "[({[:space:][]")
-      1 font-lock-preprocessor-face)
-
-     ;; Field names like `foo:`, highlight excluding the :
-     (,(concat (rust-re-grab rust-re-ident) ":[^:]") 1 font-lock-variable-name-face)
-
-     ;; Module names like `foo::`, highlight including the ::
-     (,(rust-re-grab (concat rust-re-ident "::")) 1 font-lock-type-face)
-
-     ;; Lifetimes like `'foo`
-     (,(concat "'" (rust-re-grab rust-re-ident) "[^']") 1 font-lock-variable-name-face)
-
-     ;; Character constants, since they're not treated as strings
-     ;; in order to have sufficient leeway to parse 'lifetime above.
-     (,(rust-re-grab "'[^']'") 1 font-lock-string-face)
-     (,(rust-re-grab "'\\\\[nrt]'") 1 font-lock-string-face)
-     (,(rust-re-grab "'\\\\x[[:xdigit:]]\\{2\\}'") 1 font-lock-string-face)
-     (,(rust-re-grab "'\\\\u[[:xdigit:]]\\{4\\}'") 1 font-lock-string-face)
-     (,(rust-re-grab "'\\\\U[[:xdigit:]]\\{8\\}'") 1 font-lock-string-face)
-
-     ;; CamelCase Means Type Or Constructor
-     (,(rust-re-grabword rust-re-CamelCase) 1 font-lock-type-face)
-     )
-
-   ;; Item definitions
-   (mapcar #'(lambda (x)
-               (list (rust-re-item-def (car x))
-                     1 (cdr x)))
-           '(("enum" . font-lock-type-face)
-             ("struct" . font-lock-type-face)
-             ("type" . font-lock-type-face)
-             ("mod" . font-lock-type-face)
-             ("use" . font-lock-type-face)
-             ("fn" . font-lock-function-name-face)
-             ("static" . font-lock-constant-face)))))
-
-(defun rust-fill-prefix-for-comment-start (line-start)
-  "Determine what to use for `fill-prefix' based on what is at the beginning of a line."
-  (let ((result
-         ;; Replace /* with same number of spaces
-         (replace-regexp-in-string
-          "\\(?:/\\*+\\)[!*]"
-          (lambda (s)
-            ;; We want the * to line up with the first * of the comment start
-            (concat (make-string (- (length s) 2) ?\x20) "*"))
-          line-start)))
-    ;; Make sure we've got at least one space at the end
-    (if (not (= (aref result (- (length result) 1)) ?\x20))
-        (setq result (concat result " ")))
-    result))
-
-(defun rust-in-comment-paragraph (body)
-  ;; We might move the point to fill the next comment, but we don't want it
-  ;; seeming to jump around on the user
-  (save-excursion
-    ;; If we're outside of a comment, with only whitespace and then a comment
-    ;; in front, jump to the comment and prepare to fill it.
-    (when (not (nth 4 (syntax-ppss)))
-      (beginning-of-line)
-      (when (looking-at (concat "[[:space:]\n]*" comment-start-skip))
-        (goto-char (match-end 0))))
-
-    ;; We need this when we're moving the point around and then checking syntax
-    ;; while doing paragraph fills, because the cache it uses isn't always
-    ;; invalidated during this.
-    (syntax-ppss-flush-cache 1)
-    ;; If we're at the beginning of a comment paragraph with nothing but
-    ;; whitespace til the next line, jump to the next line so that we use the
-    ;; existing prefix to figure out what the new prefix should be, rather than
-    ;; inferring it from the comment start.
-    (let ((next-bol (line-beginning-position 2)))
-      (while (save-excursion
-               (end-of-line)
-               (syntax-ppss-flush-cache 1)
-               (and (nth 4 (syntax-ppss))
-                    (save-excursion
-                      (beginning-of-line)
-                      (looking-at paragraph-start))
-                    (looking-at "[[:space:]]*$")
-                    (nth 4 (syntax-ppss next-bol))))
-        (goto-char next-bol)))
-
-    (syntax-ppss-flush-cache 1)
-    ;; If we're on the last line of a multiline-style comment that started
-    ;; above, back up one line so we don't mistake the * of the */ that ends
-    ;; the comment for a prefix.
-    (when (save-excursion
-            (and (nth 4 (syntax-ppss (line-beginning-position 1)))
-                 (looking-at "[[:space:]]*\\*/")))
-      (goto-char (line-end-position 0)))
-    (funcall body)))
-
-(defun rust-with-comment-fill-prefix (body)
-  (let*
-      ((line-string (buffer-substring-no-properties
-                     (line-beginning-position) (line-end-position)))
-       (line-comment-start
-        (when (nth 4 (syntax-ppss))
-          (cond
-           ;; If we're inside the comment and see a * prefix, use it
-           ((string-match "^\\([[:space:]]*\\*+[[:space:]]*\\)"
-                          line-string)
-            (match-string 1 line-string))
-           ;; If we're at the start of a comment, figure out what prefix
-           ;; to use for the subsequent lines after it
-           ((string-match (concat "[[:space:]]*" comment-start-skip) line-string)
-            (rust-fill-prefix-for-comment-start
-             (match-string 0 line-string))))))
-       (fill-prefix
-        (or line-comment-start
-            fill-prefix)))
-    (funcall body)))
-
-(defun rust-find-fill-prefix ()
-  (rust-with-comment-fill-prefix (lambda () fill-prefix)))
-
-(defun rust-fill-paragraph (&rest args)
-  "Special wrapping for `fill-paragraph' to handle multi-line comments with a * prefix on each line."
-  (rust-in-comment-paragraph
-   (lambda ()
-     (rust-with-comment-fill-prefix
-      (lambda ()
-        (let
-            ((fill-paragraph-function
-              (if (not (eq fill-paragraph-function 'rust-fill-paragraph))
-                  fill-paragraph-function))
-             (fill-paragraph-handle-comment t))
-          (apply 'fill-paragraph args)
-          t))))))
-
-(defun rust-do-auto-fill (&rest args)
-  "Special wrapping for `do-auto-fill' to handle multi-line comments with a * prefix on each line."
-  (rust-with-comment-fill-prefix
-   (lambda ()
-     (apply 'do-auto-fill args)
-     t)))
-
-(defun rust-fill-forward-paragraph (arg)
-  ;; This is to work around some funny behavior when a paragraph separator is
-  ;; at the very top of the file and there is a fill prefix.
-  (let ((fill-prefix nil)) (forward-paragraph arg)))
-
-(defun rust-comment-indent-new-line (&optional arg)
-  (rust-with-comment-fill-prefix
-   (lambda () (comment-indent-new-line arg))))
-
-;;; Imenu support
-(defvar rust-imenu-generic-expression
-  (append (mapcar #'(lambda (x)
-                      (list nil (rust-re-item-def x) 1))
-                  '("enum" "struct" "type" "mod" "fn" "trait"))
-          `(("Impl" ,(rust-re-item-def "impl") 1)))
-  "Value for `imenu-generic-expression' in Rust mode.
-
-Create a flat index of the item definitions in a Rust file.
-
-Imenu will show all the enums, structs, etc. at the same level.
-Implementations will be shown under the `Impl` subheading.  Use
-idomenu (imenu with `ido-mode') for best mileage.")
-
-;;; Defun Motions
-
-;;; Start of a Rust item
-(defvar rust-top-item-beg-re
-  (concat "^\\s-*\\(?:priv\\|pub\\)?\\s-*"
-          (regexp-opt
-           '("enum" "struct" "type" "mod" "use" "fn" "static" "impl"
-             "extern" "impl" "static" "trait"))))
-
-(defun rust-beginning-of-defun (&optional arg)
-  "Move backward to the beginning of the current defun.
-
-With ARG, move backward multiple defuns.  Negative ARG means
-move forward.
-
-This is written mainly to be used as `beginning-of-defun-function' for Rust.
-Don't move to the beginning of the line. `beginning-of-defun',
-which calls this, does that afterwards."
-  (interactive "p")
-  (re-search-backward (concat "^\\(" rust-top-item-beg-re "\\)\\_>")
-                      nil 'move (or arg 1)))
-
-(defun rust-end-of-defun ()
-  "Move forward to the next end of defun.
-
-With argument, do it that many times.
-Negative argument -N means move back to Nth preceding end of defun.
-
-Assume that this is called after beginning-of-defun. So point is
-at the beginning of the defun body.
-
-This is written mainly to be used as `end-of-defun-function' for Rust."
-  (interactive "p")
-  ;; Find the opening brace
-  (re-search-forward "[{]" nil t)
-  (goto-char (match-beginning 0))
-  ;; Go to the closing brace
-  (forward-sexp))
-
-;; For compatibility with Emacs < 24, derive conditionally
-(defalias 'rust-parent-mode
-  (if (fboundp 'prog-mode) 'prog-mode 'fundamental-mode))
-
-
-;;;###autoload
-(define-derived-mode rust-mode rust-parent-mode "Rust"
-  "Major mode for Rust code."
-  :group 'rust-mode
-  :syntax-table rust-mode-syntax-table
-
-  ;; Indentation
-  (setq-local indent-line-function 'rust-mode-indent-line)
-
-  ;; Fonts
-  (setq-local font-lock-defaults '(rust-mode-font-lock-keywords nil nil nil nil))
-
-  ;; Misc
-  (setq-local comment-start "// ")
-  (setq-local comment-end   "")
-  (setq-local indent-tabs-mode nil)
-
-  ;; Allow paragraph fills for comments
-  (setq-local comment-start-skip "\\(?://[/!]*\\|/\\*[*!]?\\)[[:space:]]*")
-  (setq-local paragraph-start
-       (concat "[[:space:]]*\\(?:" comment-start-skip "\\|\\*/?[[:space:]]*\\|\\)$"))
-  (setq-local paragraph-separate paragraph-start)
-  (setq-local normal-auto-fill-function 'rust-do-auto-fill)
-  (setq-local fill-paragraph-function 'rust-fill-paragraph)
-  (setq-local fill-forward-paragraph-function 'rust-fill-forward-paragraph)
-  (setq-local adaptive-fill-function 'rust-find-fill-prefix)
-  (setq-local comment-multi-line t)
-  (setq-local comment-line-break-function 'rust-comment-indent-new-line)
-  (setq-local imenu-generic-expression rust-imenu-generic-expression)
-  (setq-local beginning-of-defun-function 'rust-beginning-of-defun)
-  (setq-local end-of-defun-function 'rust-end-of-defun))
-
-;;;###autoload
-(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))
-
-(defun rust-mode-reload ()
-  (interactive)
-  (unload-feature 'rust-mode)
-  (require 'rust-mode)
-  (rust-mode))
-
-;; Issue #6887: Rather than inheriting the 'gnu compilation error
-;; regexp (which is broken on a few edge cases), add our own 'rust
-;; compilation error regexp and use it instead.
-(defvar rustc-compilation-regexps
-  (let ((file "\\([^\n]+\\)")
-        (start-line "\\([0-9]+\\)")
-        (start-col  "\\([0-9]+\\)")
-        (end-line   "\\([0-9]+\\)")
-        (end-col    "\\([0-9]+\\)")
-        (error-or-warning "\\(?:[Ee]rror\\|\\([Ww]arning\\)\\)"))
-    (let ((re (concat "^" file ":" start-line ":" start-col
-                      ": " end-line ":" end-col
-                      " \\(?:[Ee]rror\\|\\([Ww]arning\\)\\):")))
-      (cons re '(1 (2 . 4) (3 . 5) (6)))))
-  "Specifications for matching errors in rustc invocations.
-See `compilation-error-regexp-alist for help on their format.")
-
-(eval-after-load 'compile
-  '(progn
-     (add-to-list 'compilation-error-regexp-alist-alist
-                  (cons 'rustc rustc-compilation-regexps))
-     (add-to-list 'compilation-error-regexp-alist 'rustc)))
-
-(provide 'rust-mode)
-
-;;; rust-mode.el ends here
diff --git a/src/etc/gedit/readme.txt b/src/etc/gedit/readme.txt
deleted file mode 100644
index e394f191608..00000000000
--- a/src/etc/gedit/readme.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-Add syntax highlighting for Mozilla Rust in GtkSourceView (used by GEdit).
-
-
-Instructions for Ubuntu Linux 12.04+
-
-1) Close all instances of GEdit
-
-2) Copy the included "share" folder into "~/.local/"
-
-3) Open a shell in "~/.local/share/" and run "update-mime-database mime"
diff --git a/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang b/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang
deleted file mode 100644
index 8291b38a9bd..00000000000
--- a/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang
+++ /dev/null
@@ -1,340 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!-- Syntax highlighting for the under-development Mozilla Rust language -->
-
-<language id="rust" _name="Rust" version="2.0" _section="Sources">
-  <metadata>
-    <property name="mimetypes">text/x-rust</property>
-    <property name="globs">*.rs</property>
-    <property name="line-comment-start">//</property>
-    <property name="block-comment-start">/*</property>
-    <property name="block-comment-end">*/</property>
-  </metadata>
-
-  <styles>
-    <style id="comment" _name="Comment" map-to="def:comment"/>
-    <style id="string" _name="String" map-to="def:string"/>
-    <style id="char" _name="Character" map-to="def:character"/>
-    <style id="keyword" _name="Keyword" map-to="def:keyword"/>
-    <style id="type" _name="Data Type" map-to="def:type"/>
-    <style id="constant" _name="Constant" map-to="def:constant"/>
-    <style id="identifier" _name="Identifier" map-to="def:identifier"/>
-    <style id="number" _name="Number" map-to="def:number"/>
-    <style id="scope" _name="Scope" map-to="def:preprocessor"/>
-    <style id="attribute" _name="Attribute" map-to="def:preprocessor"/>
-    <style id="macro" _name="Macro" map-to="def:preprocessor"/>
-  </styles>
-
-  <definitions>
-
-    <context id="function" style-ref="keyword">
-		<keyword>fn</keyword>
-    </context>
-
-    <context id="type" style-ref="keyword">
-		<keyword>type</keyword>
-    </context>
-
-    <context id="keywords" style-ref="keyword">
-		<keyword>as</keyword>
-		<keyword>assert</keyword>
-		<keyword>break</keyword>
-		<keyword>box</keyword>
-		<keyword>const</keyword>
-		<keyword>continue</keyword>
-		<keyword>crate</keyword>
-		<keyword>do</keyword>
-		<keyword>drop</keyword>
-		<keyword>else</keyword>
-		<keyword>enum</keyword>
-		<keyword>export</keyword>
-		<keyword>extern</keyword>
-		<keyword>fail</keyword>
-		<keyword>for</keyword>
-		<keyword>if</keyword>
-		<keyword>impl</keyword>
-		<keyword>in</keyword>
-		<keyword>let</keyword>
-		<keyword>log</keyword>
-		<keyword>loop</keyword>
-		<keyword>match</keyword>
-		<keyword>mod</keyword>
-		<keyword>move</keyword>
-		<keyword>mut</keyword>
-		<keyword>priv</keyword>
-		<keyword>pub</keyword>
-		<keyword>pure</keyword>
-		<keyword>ref</keyword>
-		<keyword>return</keyword>
-		<keyword>static</keyword>
-		<keyword>struct</keyword>
-		<keyword>trait</keyword>
-		<keyword>unsafe</keyword>
-		<keyword>use</keyword>
-		<keyword>virtual</keyword>
-		<keyword>where</keyword>
-		<keyword>while</keyword>
-    </context>
-
-    <context id="types" style-ref="type">
-		<keyword>bool</keyword>
-		<keyword>int</keyword>
-		<keyword>isize</keyword>
-		<keyword>uint</keyword>
-		<keyword>usize</keyword>
-		<keyword>i8</keyword>
-		<keyword>i16</keyword>
-		<keyword>i32</keyword>
-		<keyword>i64</keyword>
-		<keyword>u8</keyword>
-		<keyword>u16</keyword>
-		<keyword>u32</keyword>
-		<keyword>u64</keyword>
-		<keyword>f32</keyword>
-		<keyword>f64</keyword>
-		<keyword>char</keyword>
-		<keyword>str</keyword>
-		<keyword>Option</keyword>
-		<keyword>Result</keyword>
-    </context>
-
-    <context id="ctypes" style-ref="type">
-		<keyword>c_float</keyword>
-		<keyword>c_double</keyword>
-		<keyword>c_void</keyword>
-		<keyword>FILE</keyword>
-		<keyword>fpos_t</keyword>
-		<keyword>DIR</keyword>
-		<keyword>dirent</keyword>
-		<keyword>c_char</keyword>
-		<keyword>c_schar</keyword>
-		<keyword>c_uchar</keyword>
-		<keyword>c_short</keyword>
-		<keyword>c_ushort</keyword>
-		<keyword>c_int</keyword>
-		<keyword>c_uint</keyword>
-		<keyword>c_long</keyword>
-		<keyword>c_ulong</keyword>
-		<keyword>size_t</keyword>
-		<keyword>ptrdiff_t</keyword>
-		<keyword>clock_t</keyword>
-		<keyword>time_t</keyword>
-		<keyword>c_longlong</keyword>
-		<keyword>c_ulonglong</keyword>
-		<keyword>intptr_t</keyword>
-		<keyword>uintptr_t</keyword>
-		<keyword>off_t</keyword>
-		<keyword>dev_t</keyword>
-		<keyword>ino_t</keyword>
-		<keyword>pid_t</keyword>
-		<keyword>mode_t</keyword>
-		<keyword>ssize_t</keyword>
-    </context>
-
-    <context id="self" style-ref="identifier">
-		<keyword>self</keyword>
-    </context>
-
-    <context id="constants" style-ref="constant">
-		<keyword>true</keyword>
-		<keyword>false</keyword>
-		<keyword>Some</keyword>
-		<keyword>None</keyword>
-		<keyword>Ok</keyword>
-		<keyword>Err</keyword>
-		<keyword>Success</keyword>
-		<keyword>Failure</keyword>
-		<keyword>Cons</keyword>
-		<keyword>Nil</keyword>
-    </context>
-
-    <context id="cconstants" style-ref="constant">
-		<keyword>EXIT_FAILURE</keyword>
-		<keyword>EXIT_SUCCESS</keyword>
-		<keyword>RAND_MAX</keyword>
-		<keyword>EOF</keyword>
-		<keyword>SEEK_SET</keyword>
-		<keyword>SEEK_CUR</keyword>
-		<keyword>SEEK_END</keyword>
-		<keyword>_IOFBF</keyword>
-		<keyword>_IONBF</keyword>
-		<keyword>_IOLBF</keyword>
-		<keyword>BUFSIZ</keyword>
-		<keyword>FOPEN_MAX</keyword>
-		<keyword>FILENAME_MAX</keyword>
-		<keyword>L_tmpnam</keyword>
-		<keyword>TMP_MAX</keyword>
-		<keyword>O_RDONLY</keyword>
-		<keyword>O_WRONLY</keyword>
-		<keyword>O_RDWR</keyword>
-		<keyword>O_APPEND</keyword>
-		<keyword>O_CREAT</keyword>
-		<keyword>O_EXCL</keyword>
-		<keyword>O_TRUNC</keyword>
-		<keyword>S_IFIFO</keyword>
-		<keyword>S_IFCHR</keyword>
-		<keyword>S_IFBLK</keyword>
-		<keyword>S_IFDIR</keyword>
-		<keyword>S_IFREG</keyword>
-		<keyword>S_IFMT</keyword>
-		<keyword>S_IEXEC</keyword>
-		<keyword>S_IWRITE</keyword>
-		<keyword>S_IREAD</keyword>
-		<keyword>S_IRWXU</keyword>
-		<keyword>S_IXUSR</keyword>
-		<keyword>S_IWUSR</keyword>
-		<keyword>S_IRUSR</keyword>
-		<keyword>F_OK</keyword>
-		<keyword>R_OK</keyword>
-		<keyword>W_OK</keyword>
-		<keyword>X_OK</keyword>
-		<keyword>STDIN_FILENO</keyword>
-		<keyword>STDOUT_FILENO</keyword>
-		<keyword>STDERR_FILENO</keyword>
-    </context>
-
-    <context id="line-comment" style-ref="comment" end-at-line-end="true" class="comment" class-disabled="no-spell-check">
-      <start>//</start>
-      <include>
-        <context ref="def:in-line-comment"/>
-      </include>
-    </context>
-
-    <context id="block-comment" style-ref="comment" class="comment" class-disabled="no-spell-check">
-      <start>/\*</start>
-      <end>\*/</end>
-      <include>
-        <context ref="def:in-comment"/>
-      </include>
-    </context>
-
-    <define-regex id="int_suffix" extended="true">
-      (i8|i16|i32|i64|i|u8|u16|u32|u64|u)
-    </define-regex>
-
-    <define-regex id="exponent" extended="true">
-      ([eE][+-]?[0-9_]+)
-    </define-regex>
-
-    <define-regex id="float_suffix" extended="true">
-      (\%{exponent}?(f32|f64)?)|(\.[0-9][0-9_]*\%{exponent}?)?(f32|f64)?|\.
-    </define-regex>
-
-    <define-regex id="num_suffix" extended="true">
-      \%{int_suffix}|\%{float_suffix}
-    </define-regex>
-
-    <define-regex id="hex_digit" extended="true">
-      [0-9a-fA-F]
-    </define-regex>
-
-    <define-regex id="oct_digit" extended="true">
-      [0-7]
-    </define-regex>
-
-    <context id="number" style-ref="number">
-      <match extended="true">
-        ((?&lt;=\.\.)|(?&lt;![\w\.]))
-        (
-        [1-9][0-9_]*\%{num_suffix}?|
-        0[0-9_]*\%{num_suffix}?|
-        0b[01_]+\%{int_suffix}?|
-        0o(\%{oct_digit}|_)+\%{int_suffix}?|
-        0x(\%{hex_digit}|_)+\%{int_suffix}?
-        )
-        ((?![\w\.].)|(?=\.\.))
-      </match>
-    </context>
-
-    <define-regex id="ident" extended="true">
-      ([^[:cntrl:][:space:][:punct:][:digit:]]|_)([^[:cntrl:][:punct:][:space:]]|_)*
-    </define-regex>
-
-    <context id="scope" style-ref="scope">
-      <match extended="true">
-        \%{ident}::
-      </match>
-    </context>
-
-    <context id="macro" style-ref="macro">
-      <match extended="true">
-        \%{ident}!
-      </match>
-    </context>
-
-    <context id="lifetime" style-ref="keyword">
-      <match extended="true">
-        '\%{ident}
-      </match>
-    </context>
-
-    <define-regex id="common_escape" extended="true">
-      '|"|
-      \\|n|r|t|0|
-      x\%{hex_digit}{2}|
-      u{\%{hex_digit}{1,6}}|
-      u\%{hex_digit}{4}|
-      U\%{hex_digit}{8}
-    </define-regex>
-
-    <context id="string_escape" style-ref="def:special-char">
-      <match>\\\%{common_escape}</match>
-    </context>
-
-    <context id="raw-string" style-ref="string" class="string" class-disabled="no-spell-check">
-      <start>r(#*)"</start>
-      <end>"\%{1@start}</end>
-      <include>
-        <context ref="def:line-continue"/>
-      </include>
-    </context>
-
-    <context id="string" style-ref="string" class="string" class-disabled="no-spell-check">
-      <start>"</start>
-      <end>"</end>
-      <include>
-        <context ref="string_escape"/>
-        <context ref="def:line-continue"/>
-      </include>
-    </context>
-
-    <context id="char" style-ref="char">
-      <match extended="true">'([^\\']|\\\%{common_escape})'</match>
-    </context>
-
-    <context id="attribute" style-ref="attribute" class="attribute">
-      <start extended="true">\#!?\[</start>
-      <end>\]</end>
-      <include>
-        <context ref="def:in-comment"/>
-        <context ref="string"/>
-        <context ref="raw-string"/>
-      </include>
-    </context>
-
-    <context id="rust" class="no-spell-check">
-      <include>
-        <context ref="function"/>
-        <context ref="type"/>
-        <context ref="keywords"/>
-        <context ref="types"/>
-        <context ref="ctypes"/>
-        <context ref="self"/>
-        <context ref="macro"/>
-        <context ref="constants"/>
-        <context ref="cconstants"/>
-        <context ref="line-comment"/>
-        <context ref="block-comment"/>
-        <context ref="number"/>
-        <context ref="scope"/>
-        <context ref="string"/>
-        <context ref="raw-string"/>
-        <context ref="char"/>
-        <context ref="lifetime"/>
-        <context ref="attribute"/>
-      </include>
-    </context>
-
-  </definitions>
-
-</language>
diff --git a/src/etc/gedit/share/mime/packages/rust.xml b/src/etc/gedit/share/mime/packages/rust.xml
deleted file mode 100644
index ede1c14907c..00000000000
--- a/src/etc/gedit/share/mime/packages/rust.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>
-  <mime-type type="text/x-rust">
-    <comment>Rust Source</comment>
-    <glob pattern="*.rs"/>
-  </mime-type>
-</mime-info>
diff --git a/src/etc/kate/rust.xml b/src/etc/kate/rust.xml
deleted file mode 100644
index 3ceec0f250a..00000000000
--- a/src/etc/kate/rust.xml
+++ /dev/null
@@ -1,304 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE language SYSTEM "language.dtd"
-[
-	<!-- FIXME: Kate's regex engine has very limited support for
-	predefined char classes, so making rustIdent consistent with actual
-	Rust identifiers will be a bit difficult -->
-	<!ENTITY rustIdent "[a-zA-Z_][a-zA-Z_0-9]*">
-	<!ENTITY rustIntSuf "([iu](8|16|32|64)?)?">
-]>
-<language name="Rust" version="1.0.0" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
-<highlighting>
-	<list name="fn">
-		<item> fn </item>
-	</list>
-	<list name="type">
-		<item> type </item>
-	</list>
-	<list name="reserved">
-		<item> abstract </item>
-		<item> alignof </item>
-		<item> be </item>
-		<item> do </item>
-		<item> final </item>
-		<item> offsetof </item>
-		<item> override </item>
-		<item> priv </item>
-		<item> pure </item>
-		<item> sizeof </item>
-		<item> typeof </item>
-		<item> unsized </item>
-		<item> yield </item>
-	</list>
-	<list name="keywords">
-		<item> as </item>
-		<item> box </item>
-		<item> break </item>
-		<item> const </item>
-		<item> continue </item>
-		<item> crate </item>
-		<item> else </item>
-		<item> enum </item>
-		<item> extern </item>
-		<item> for </item>
-		<item> if </item>
-		<item> impl </item>
-		<item> in </item>
-		<item> let </item>
-		<item> loop </item>
-		<item> match </item>
-		<item> mod </item>
-		<item> move </item>
-		<item> mut </item>
-		<item> pub </item>
-		<item> ref </item>
-		<item> return </item>
-		<item> static </item>
-		<item> struct </item>
-		<item> super </item>
-		<item> trait </item>
-		<item> unsafe </item>
-		<item> use </item>
-		<item> virtual </item>
-		<item> where </item>
-		<item> while </item>
-	</list>
-	<list name="traits">
-		<item> Const </item>
-		<item> Copy </item>
-		<item> Send </item>
-		<item> Owned </item>
-		<item> Sized </item>
-		<item> Eq </item>
-		<item> Ord </item>
-		<item> Num </item>
-		<item> Ptr </item>
-		<item> Drop </item>
-		<item> Add </item>
-		<item> Sub </item>
-		<item> Mul </item>
-		<item> Quot </item>
-		<item> Rem </item>
-		<item> Neg </item>
-		<item> BitAnd </item>
-		<item> BitOr </item>
-		<item> BitXor </item>
-		<item> Shl </item>
-		<item> Shr </item>
-		<item> Index </item>
-		<item> Not </item>
-	</list>
-	<list name="types">
-		<item> bool </item>
-		<item> int </item>
-		<item> isize </item>
-		<item> uint </item>
-		<item> usize </item>
-		<item> i8 </item>
-		<item> i16 </item>
-		<item> i32 </item>
-		<item> i64 </item>
-		<item> u8 </item>
-		<item> u16 </item>
-		<item> u32 </item>
-		<item> u64 </item>
-		<item> f32 </item>
-		<item> f64 </item>
-		<item> float </item>
-		<item> char </item>
-		<item> str </item>
-		<item> Option </item>
-		<item> Result </item>
-		<item> Self </item>
-	</list>
-	<list name="ctypes">
-		<item> c_float </item>
-		<item> c_double </item>
-		<item> c_void </item>
-		<item> FILE </item>
-		<item> fpos_t </item>
-		<item> DIR </item>
-		<item> dirent </item>
-		<item> c_char </item>
-		<item> c_schar </item>
-		<item> c_uchar </item>
-		<item> c_short </item>
-		<item> c_ushort </item>
-		<item> c_int </item>
-		<item> c_uint </item>
-		<item> c_long </item>
-		<item> c_ulong </item>
-		<item> size_t </item>
-		<item> ptrdiff_t </item>
-		<item> clock_t </item>
-		<item> time_t </item>
-		<item> c_longlong </item>
-		<item> c_ulonglong </item>
-		<item> intptr_t </item>
-		<item> uintptr_t </item>
-		<item> off_t </item>
-		<item> dev_t </item>
-		<item> ino_t </item>
-		<item> pid_t </item>
-		<item> mode_t </item>
-		<item> ssize_t </item>
-	</list>
-	<list name="self">
-		<item> self </item>
-	</list>
-	<list name="constants">
-		<item> true </item>
-		<item> false </item>
-		<item> Some </item>
-		<item> None </item>
-		<item> Ok </item>
-		<item> Err </item>
-		<item> Success </item>
-		<item> Failure </item>
-		<item> Cons </item>
-		<item> Nil </item>
-	</list>
-	<list name="cconstants">
-		<item> EXIT_FAILURE </item>
-		<item> EXIT_SUCCESS </item>
-		<item> RAND_MAX </item>
-		<item> EOF </item>
-		<item> SEEK_SET </item>
-		<item> SEEK_CUR </item>
-		<item> SEEK_END </item>
-		<item> _IOFBF </item>
-		<item> _IONBF </item>
-		<item> _IOLBF </item>
-		<item> BUFSIZ </item>
-		<item> FOPEN_MAX </item>
-		<item> FILENAME_MAX </item>
-		<item> L_tmpnam </item>
-		<item> TMP_MAX </item>
-		<item> O_RDONLY </item>
-		<item> O_WRONLY </item>
-		<item> O_RDWR </item>
-		<item> O_APPEND </item>
-		<item> O_CREAT </item>
-		<item> O_EXCL </item>
-		<item> O_TRUNC </item>
-		<item> S_IFIFO </item>
-		<item> S_IFCHR </item>
-		<item> S_IFBLK </item>
-		<item> S_IFDIR </item>
-		<item> S_IFREG </item>
-		<item> S_IFMT </item>
-		<item> S_IEXEC </item>
-		<item> S_IWRITE </item>
-		<item> S_IREAD </item>
-		<item> S_IRWXU </item>
-		<item> S_IXUSR </item>
-		<item> S_IWUSR </item>
-		<item> S_IRUSR </item>
-		<item> F_OK </item>
-		<item> R_OK </item>
-		<item> W_OK </item>
-		<item> X_OK </item>
-		<item> STDIN_FILENO </item>
-		<item> STDOUT_FILENO </item>
-		<item> STDERR_FILENO </item>
-	</list>
-	<contexts>
-		<context attribute="Normal Text" lineEndContext="#stay" name="Normal">
-			<DetectSpaces/>
-			<keyword String="fn" attribute="Keyword" context="Function"/>
-			<keyword String="type" attribute="Keyword" context="Type"/>
-			<keyword String="reserved" attribute="Keyword" context="#stay"/>
-			<keyword String="keywords" attribute="Keyword" context="#stay"/>
-			<keyword String="types" attribute="Type" context="#stay"/>
-			<keyword String="traits" attribute="Trait" context="#stay"/>
-			<keyword String="ctypes" attribute="CType" context="#stay"/>
-			<keyword String="self" attribute="Self" context="#stay"/>
-			<keyword String="constants" attribute="Constant" context="#stay"/>
-			<keyword String="cconstants" attribute="CConstant" context="#stay"/>
-			<Detect2Chars char="/" char1="/" attribute="Comment" context="Commentar 1"/>
-			<Detect2Chars char="/" char1="*" attribute="Comment" context="Commentar 2" beginRegion="Comment"/>
-			<RegExpr String="0x[0-9a-fA-F_]+&rustIntSuf;" attribute="Number" context="#stay"/>
-			<RegExpr String="0o[0-7_]+&rustIntSuf;" attribute="Number" context="#stay"/>
-			<RegExpr String="0b[0-1_]+&rustIntSuf;" attribute="Number" context="#stay"/>
-			<RegExpr String="[0-9][0-9_]*\.[0-9_]*([eE][+-]?[0-9_]+)?(f32|f64|f)?" attribute="Number" context="#stay"/>
-			<RegExpr String="[0-9][0-9_]*&rustIntSuf;" attribute="Number" context="#stay"/>
-			<Detect2Chars char="#" char1="[" attribute="Attribute" context="Attribute" beginRegion="Attribute"/>
-			<StringDetect String="#![" attribute="Attribute" context="Attribute" beginRegion="Attribute"/>
-			<RegExpr String="&rustIdent;::" attribute="Scope"/>
-			<RegExpr String="&rustIdent;!" attribute="Macro"/>
-			<RegExpr String="&apos;&rustIdent;(?!&apos;)" attribute="Lifetime"/>
-			<DetectChar char="{" attribute="Symbol" context="#stay" beginRegion="Brace" />
-			<DetectChar char="}" attribute="Symbol" context="#stay" endRegion="Brace" />
-			<DetectChar char="&quot;" attribute="String" context="String"/>
-			<DetectChar char="&apos;" attribute="Character" context="Character"/>
-			<DetectChar char="[" attribute="Symbol" context="#stay" beginRegion="Bracket" />
-			<DetectChar char="]" attribute="Symbol" context="#stay" endRegion="Bracket" />
-			<DetectIdentifier/>
-		</context>
-		<context attribute="Attribute" lineEndContext="#stay" name="Attribute">
-			<DetectChar char="]" attribute="Attribute" context="#pop" endRegion="Attribute"/>
-			<IncludeRules context="Normal"/>
-		</context>
-		<context attribute="Definition" lineEndContext="#stay" name="Function">
-			<DetectSpaces/>
-			<DetectChar char="(" attribute="Normal Text" context="#pop"/>
-			<DetectChar char="&lt;" attribute="Normal Text" context="#pop"/>
-		</context>
-		<context attribute="Definition" lineEndContext="#stay" name="Type">
-			<DetectSpaces/>
-			<DetectChar char="=" attribute="Normal Text" context="#pop"/>
-			<DetectChar char="&lt;" attribute="Normal Text" context="#pop"/>
-		</context>
-		<context attribute="String" lineEndContext="#pop" name="String">
-			<LineContinue attribute="String" context="#stay"/>
-			<DetectChar char="\" attribute="CharEscape" context="CharEscape"/>
-			<DetectChar attribute="String" context="#pop" char="&quot;"/>
-		</context>
-		<context attribute="Character" lineEndContext="#pop" name="Character">
-			<DetectChar char="\" attribute="CharEscape" context="CharEscape"/>
-			<DetectChar attribute="Character" context="#pop" char="&apos;"/>
-		</context>
-		<context attribute="CharEscape" lineEndContext="#pop" name="CharEscape">
-			<AnyChar String="nrt\&apos;&quot;" attribute="CharEscape" context="#pop"/>
-			<RegExpr String="x[0-9a-fA-F]{2}" attribute="CharEscape" context="#pop"/>
-			<RegExpr String="u\{[0-9a-fA-F]{1,6}\}" attribute="CharEscape" context="#pop"/>
-			<RegExpr String="u[0-9a-fA-F]{4}" attribute="CharEscape" context="#pop"/>
-			<RegExpr String="U[0-9a-fA-F]{8}" attribute="CharEscape" context="#pop"/>
-			<RegExpr String="." attribute="Error" context="#pop"/>
-		</context>
-		<context attribute="Comment" lineEndContext="#pop" name="Commentar 1"/>
-		<context attribute="Comment" lineEndContext="#stay" name="Commentar 2">
-			<DetectSpaces/>
-			<Detect2Chars char="*" char1="/" attribute="Comment" context="#pop" endRegion="Comment"/>
-		</context>
-	</contexts>
-	<itemDatas>
-		<itemData name="Normal Text"  defStyleNum="dsNormal"/>
-		<itemData name="Keyword"      defStyleNum="dsKeyword" color="#770088" bold="1"/>
-		<itemData name="Self"         defStyleNum="dsKeyword" color="#FF0000" bold="1"/>
-		<itemData name="Type"         defStyleNum="dsKeyword" color="#4e9a06" bold="1"/>
-		<itemData name="Trait"        defStyleNum="dsKeyword" color="#4e9a06" bold="1"/>
-		<itemData name="CType"        defStyleNum="dsNormal" color="#4e9a06"/>
-		<itemData name="Constant"     defStyleNum="dsKeyword" color="#116644"/>
-		<itemData name="CConstant"    defStyleNum="dsNormal" color="#116644"/>
-		<itemData name="Definition"   defStyleNum="dsNormal" color="#0000FF"/>
-		<itemData name="Comment"      defStyleNum="dsComment" color="#AA5500"/>
-		<itemData name="Scope"        defStyleNum="dsNormal" color="#0055AA"/>
-		<itemData name="Number"       defStyleNum="dsDecVal" color="#116644"/>
-		<itemData name="String"       defStyleNum="dsString" color="#FF0000"/>
-		<itemData name="CharEscape"   defStyleNum="dsChar" color="#FF0000" bold="1"/>
-		<itemData name="Character"    defStyleNum="dsChar" color="#FF0000"/>
-		<itemData name="Macro"        defStyleNum="dsOthers"/>
-		<itemData name="Attribute"    defStyleNum="dsOthers"/>
-		<itemData name="Lifetime"     defStyleNum="dsOthers" bold="1"/>
-		<itemData name="Error"        defStyleNum="dsError"/>
-	</itemDatas>
-</highlighting>
-<general>
-	<comments>
-		<comment name="singleLine" start="//" />
-		<comment name="multiLine" start="/*" end="*/" region="Comment"/>
-	</comments>
-	<keywords casesensitive="1" />
-</general>
-</language>
diff --git a/src/etc/nano/rust.nanorc b/src/etc/nano/rust.nanorc
deleted file mode 100644
index 1217769096d..00000000000
--- a/src/etc/nano/rust.nanorc
+++ /dev/null
@@ -1,35 +0,0 @@
-# Nano configuration for Rust
-# Copyright 2015 The Rust Project Developers.
-#
-# NOTE: Rules are applied in order: later rules re-colorize matching text.
-syntax "rust" "\.rs"
-
-# function definition
-color magenta "fn [a-z0-9_]+"
-
-# Reserved words
-color yellow "\<(abstract|alignof|as|be|box|break|const|continue|crate|do|else|enum|extern|false|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|offsetof|override|priv|pub|pure|ref|return|sizeof|static|self|struct|super|true|trait|type|typeof|unsafe|unsized|use|virtual|where|while|yield)\>"
-
-# macros
-color red "[a-z_]+!"
-
-# Constants
-color magenta "[A-Z][A-Z_]+"
-
-# Traits/Enums/Structs/Types/etc.
-color magenta "[A-Z][a-z]+"
-
-# Strings
-color green "\".*\""
-color green start="\".*\\$" end=".*\""
-# NOTE: This isn't accurate but matching "#{0,} for the end of the string is too liberal
-color green start="r#+\"" end="\"#+"
-
-# Comments
-color blue "//.*"
-
-# Attributes
-color magenta start="#!\[" end="\]"
-
-# Some common markers
-color brightcyan "(XXX|TODO|FIXME|\?\?\?)"
diff --git a/src/etc/vim/after/syntax/rust.vim b/src/etc/vim/after/syntax/rust.vim
deleted file mode 100644
index 735c1e153a6..00000000000
--- a/src/etc/vim/after/syntax/rust.vim
+++ /dev/null
@@ -1,31 +0,0 @@
-if !exists('g:rust_conceal') || !has('conceal') || &enc != 'utf-8'
-	finish
-endif
-
-" For those who don't want to see `::`...
-if exists('g:rust_conceal_mod_path')
-	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 exists('g:rust_conceal_pub')
-    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 !exists('g:rust_conceal_mod_path')
-    hi! link Conceal Operator
-endif
diff --git a/src/etc/vim/autoload/rust.vim b/src/etc/vim/autoload/rust.vim
deleted file mode 100644
index fe8e743e782..00000000000
--- a/src/etc/vim/autoload/rust.vim
+++ /dev/null
@@ -1,225 +0,0 @@
-" Author: Kevin Ballard
-" Description: Helper functions for Rust commands/mappings
-" Last Modified: May 27, 2014
-
-" Jump {{{1
-
-function! rust#Jump(mode, function) range
-	let cnt = v:count1
-	normal! m'
-	if a:mode ==# 'v'
-		norm! gv
-	endif
-	let foldenable = &foldenable
-	set nofoldenable
-	while cnt > 0
-		execute "call <SID>Jump_" . a:function . "()"
-		let cnt = cnt - 1
-	endwhile
-	let &foldenable = foldenable
-endfunction
-
-function! s:Jump_Back()
-	call search('{', 'b')
-	keepjumps normal! w99[{
-endfunction
-
-function! s:Jump_Forward()
-	normal! j0
-	call search('{', 'b')
-	keepjumps normal! w99[{%
-	call search('{')
-endfunction
-
-" Run {{{1
-
-function! rust#Run(bang, args)
-	if a:bang
-		let idx = index(a:args, '--')
-		if idx != -1
-			let rustc_args = idx == 0 ? [] : a:args[:idx-1]
-			let args = a:args[idx+1:]
-		else
-			let rustc_args = a:args
-			let args = []
-		endif
-	else
-		let rustc_args = []
-		let args = a:args
-	endif
-
-	let b:rust_last_rustc_args = rustc_args
-	let b:rust_last_args = args
-
-	call s:WithPath(function("s:Run"), rustc_args, args)
-endfunction
-
-function! s:Run(path, rustc_args, args)
-	try
-		let exepath = tempname()
-		if has('win32')
-			let exepath .= '.exe'
-		endif
-
-		let rustc_args = [a:path, '-o', exepath] + a:rustc_args
-
-		let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
-
-		let output = system(shellescape(rustc) . " " . join(map(rustc_args, 'shellescape(v:val)')))
-		if output != ''
-			echohl WarningMsg
-			echo output
-			echohl None
-		endif
-		if !v:shell_error
-			exe '!' . shellescape(exepath) . " " . join(map(a:args, 'shellescape(v:val)'))
-		endif
-	finally
-		if exists("exepath")
-			silent! call delete(exepath)
-		endif
-	endtry
-endfunction
-
-" Expand {{{1
-
-function! rust#Expand(bang, args)
-	if a:bang && !empty(a:args)
-		let pretty = a:args[0]
-		let args = a:args[1:]
-	else
-		let pretty = "expanded"
-		let args = a:args
-	endif
-	call s:WithPath(function("s:Expand"), pretty, args)
-endfunction
-
-function! s:Expand(path, pretty, args)
-	try
-		let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
-
-		let args = [a:path, '--pretty', a:pretty] + a:args
-		let output = system(shellescape(rustc) . " " . join(map(args, "shellescape(v:val)")))
-		if v:shell_error
-			echohl WarningMsg
-			echo output
-			echohl None
-		else
-			new
-			silent put =output
-			1
-			d
-			setl filetype=rust
-			setl buftype=nofile
-			setl bufhidden=hide
-			setl noswapfile
-		endif
-	endtry
-endfunction
-
-function! rust#CompleteExpand(lead, line, pos)
-	if a:line[: a:pos-1] =~ '^RustExpand!\s*\S*$'
-		" first argument and it has a !
-		let list = ["normal", "expanded", "typed", "expanded,identified", "flowgraph="]
-		if !empty(a:lead)
-			call filter(list, "v:val[:len(a:lead)-1] == a:lead")
-		endif
-		return list
-	endif
-
-	return glob(escape(a:lead, "*?[") . '*', 0, 1)
-endfunction
-
-" Emit {{{1
-
-function! rust#Emit(type, args)
-	call s:WithPath(function("s:Emit"), a:type, a:args)
-endfunction
-
-function! s:Emit(path, type, args)
-	try
-		let rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
-
-		let args = [a:path, '--emit', a:type, '-o', '-'] + a:args
-		let output = system(shellescape(rustc) . " " . join(map(args, "shellescape(v:val)")))
-		if v:shell_error
-			echohl WarningMsg
-			echo output
-			echohl None
-		else
-			new
-			silent put =output
-			1
-			d
-			if a:type == "ir"
-				setl filetype=llvm
-			elseif a:type == "asm"
-				setl filetype=asm
-			endif
-			setl buftype=nofile
-			setl bufhidden=hide
-			setl noswapfile
-		endif
-	endtry
-endfunction
-
-" Utility functions {{{1
-
-function! s:WithPath(func, ...)
-	try
-		let save_write = &write
-		set write
-		let path = expand('%')
-		let pathisempty = empty(path)
-		if pathisempty || !save_write
-			" use a temporary file named 'unnamed.rs' inside a temporary
-			" directory. This produces better error messages
-			let tmpdir = tempname()
-			call mkdir(tmpdir)
-
-			let save_cwd = getcwd()
-			silent exe 'lcd' fnameescape(tmpdir)
-
-			let path = 'unnamed.rs'
-
-			let save_mod = &mod
-			set nomod
-
-			silent exe 'keepalt write! ' . fnameescape(path)
-			if pathisempty
-				silent keepalt 0file
-			endif
-		else
-			update
-		endif
-
-		call call(a:func, [path] + a:000)
-	finally
-		if exists("save_mod")   | let &mod = save_mod                    | endif
-		if exists("save_write") | let &write = save_write                | endif
-		if exists("save_cwd")   | silent exe 'lcd' fnameescape(save_cwd) | endif
-		if exists("tmpdir")     | silent call s:RmDir(tmpdir)            | endif
-	endtry
-endfunction
-
-function! rust#AppendCmdLine(text)
-	call setcmdpos(getcmdpos())
-	let cmd = getcmdline() . a:text
-	return cmd
-endfunction
-
-function! s:RmDir(path)
-	" sanity check; make sure it's not empty, /, or $HOME
-	if empty(a:path)
-		echoerr 'Attempted to delete empty path'
-		return 0
-	elseif a:path == '/' || a:path == $HOME
-		echoerr 'Attempted to delete protected path: ' . a:path
-		return 0
-	endif
-	silent exe "!rm -rf " . shellescape(a:path)
-endfunction
-
-" }}}1
-
-" vim: set noet sw=4 ts=4:
diff --git a/src/etc/vim/compiler/cargo.vim b/src/etc/vim/compiler/cargo.vim
deleted file mode 100644
index ed487a308e1..00000000000
--- a/src/etc/vim/compiler/cargo.vim
+++ /dev/null
@@ -1,65 +0,0 @@
-" Vim compiler file
-" Compiler:         Cargo Compiler
-" Maintainer:       Damien Radtke <damienradtke@gmail.com>
-" Latest Revision:  2014 Sep 24
-
-if exists('current_compiler')
-  finish
-endif
-runtime compiler/rustc.vim
-let current_compiler = "cargo"
-
-if exists(':CompilerSet') != 2
-    command -nargs=* CompilerSet setlocal <args>
-endif
-
-if exists('g:cargo_makeprg_params')
-    execute 'CompilerSet makeprg=cargo\ '.escape(g:cargo_makeprg_params, ' \|"').'\ $*'
-else
-    CompilerSet makeprg=cargo\ $*
-endif
-
-" Allow a configurable global Cargo.toml name. This makes it easy to
-" support variations like 'cargo.toml'.
-let s:cargo_manifest_name = get(g:, 'cargo_manifest_name', 'Cargo.toml')
-
-function! s:is_absolute(path)
-    return a:path[0] == '/' || a:path =~ '[A-Z]\+:'
-endfunction
-
-let s:local_manifest = findfile(s:cargo_manifest_name, '.;')
-if s:local_manifest != ''
-    let s:local_manifest = fnamemodify(s:local_manifest, ':p:h').'/'
-    augroup cargo
-        au!
-        au QuickfixCmdPost make call s:FixPaths()
-    augroup END
-
-    " FixPaths() is run after Cargo, and is used to change the file paths
-    " to be relative to the current directory instead of Cargo.toml.
-    function! s:FixPaths()
-        let qflist = getqflist()
-        let manifest = s:local_manifest
-        for qf in qflist
-            if !qf.valid
-                let m = matchlist(qf.text, '(file://\(.*\))$')
-                if !empty(m)
-                    let manifest = m[1].'/'
-                    " Manually strip another slash if needed; usually just an
-                    " issue on Windows.
-                    if manifest =~ '^/[A-Z]\+:/'
-                        let manifest = manifest[1:]
-                    endif
-                endif
-                continue
-            endif
-            let filename = bufname(qf.bufnr)
-            if s:is_absolute(filename)
-                continue
-            endif
-            let qf.filename = simplify(manifest.filename)
-            call remove(qf, 'bufnr')
-        endfor
-        call setqflist(qflist, 'r')
-    endfunction
-endif
diff --git a/src/etc/vim/compiler/rustc.vim b/src/etc/vim/compiler/rustc.vim
deleted file mode 100644
index f9b854ed049..00000000000
--- a/src/etc/vim/compiler/rustc.vim
+++ /dev/null
@@ -1,33 +0,0 @@
-" Vim compiler file
-" Compiler:         Rust Compiler
-" Maintainer:       Chris Morgan <me@chrismorgan.info>
-" Latest Revision:  2013 Jul 12
-
-if exists("current_compiler")
-  finish
-endif
-let current_compiler = "rustc"
-
-let s:cpo_save = &cpo
-set cpo&vim
-
-if exists(":CompilerSet") != 2
-	command -nargs=* CompilerSet setlocal <args>
-endif
-
-if exists("g:rustc_makeprg_no_percent") && g:rustc_makeprg_no_percent == 1
-	CompilerSet makeprg=rustc
-else
-	CompilerSet makeprg=rustc\ \%
-endif
-
-CompilerSet errorformat=
-			\%f:%l:%c:\ %t%*[^:]:\ %m,
-			\%f:%l:%c:\ %*\\d:%*\\d\ %t%*[^:]:\ %m,
-			\%-G%f:%l\ %s,
-			\%-G%*[\ ]^,
-			\%-G%*[\ ]^%*[~],
-			\%-G%*[\ ]...
-
-let &cpo = s:cpo_save
-unlet s:cpo_save
diff --git a/src/etc/vim/doc/rust.txt b/src/etc/vim/doc/rust.txt
deleted file mode 100644
index e117b0c155b..00000000000
--- a/src/etc/vim/doc/rust.txt
+++ /dev/null
@@ -1,178 +0,0 @@
-*rust.txt*      Filetype plugin for Rust
-
-==============================================================================
-CONTENTS                                                      *rust* *ft-rust*
-
-1. Introduction                                                   |rust-intro|
-2. Settings                                                    |rust-settings|
-3. Commands                                                    |rust-commands|
-4. Mappings                                                    |rust-mappings|
-
-==============================================================================
-INTRODUCTION                                                      *rust-intro*
-
-This plugin provides syntax and supporting functionality for the Rust
-filetype.
-
-==============================================================================
-SETTINGS                                                       *rust-settings*
-
-This plugin has a few variables you can define in your vimrc that change the
-behavior of the plugin.
-
-                                                                *g:rustc_path*
-g:rustc_path~
-	Set this option to the path to rustc for use in the |:RustRun| and
-	|:RustExpand| commands. If unset, "rustc" will be located in $PATH: >
-	    let g:rustc_path = $HOME."/bin/rustc"
-<
-
-                                                  *g:rustc_makeprg_no_percent*
-g:rustc_makeprg_no_percent~
-	Set this option to 1 to have 'makeprg' default to "rustc" instead of
-	"rustc %": >
-	    let g:rustc_makeprg_no_percent = 1
-<
-
-                                                              *g:rust_conceal*
-g:rust_conceal~
-	Set this option to turn on the basic |conceal| support: >
-	    let g:rust_conceal = 1
-<
-
-                                                     *g:rust_conceal_mod_path*
-g:rust_conceal_mod_path~
-	Set this option to turn on |conceal| for the path connecting token
-	"::": >
-	    let g:rust_conceal_mod_path = 1
-<
-
-                                                          *g:rust_conceal_pub*
-g:rust_conceal_pub~
-	Set this option to turn on |conceal| for the "pub" token: >
-	    let g:rust_conceal_pub = 1
-<
-
-                                                     *g:rust_recommended_style*
-g:rust_recommended_style~
-        Set this option to enable vim indentation and textwidth settings to
-        conform to style conventions of the rust standard library (i.e. use 4
-        spaces for indents and sets 'textwidth' to 99). This option is enabled
-	by default. To disable it: >
-	    let g:rust_recommended_style = 0
-<
-
-                                                                 *g:rust_fold*
-g:rust_fold~
-	Set this option to turn on |folding|: >
-	    let g:rust_fold = 1
-<
-	Value		Effect ~
-	0		No folding
-	1		Braced blocks are folded. All folds are open by
-			default.
-	2		Braced blocks are folded. 'foldlevel' is left at the
-			global value (all folds are closed by default).
-
-                                                  *g:rust_bang_comment_leader*
-g:rust_bang_comment_leader~
-	Set this option to 1 to preserve the leader on multi-line doc comments
-	using the /*! syntax: >
-	    let g:rust_bang_comment_leader = 1
-<
-
-                                                 *g:ftplugin_rust_source_path*
-g:ftplugin_rust_source_path~
-	Set this option to a path that should be prepended to 'path' for Rust
-	source files: >
-	    let g:ftplugin_rust_source_path = $HOME.'/dev/rust'
-<
-
-                                                       *g:cargo_manifest_name*
-g:cargo_manifest_name~
-	Set this option to the name of the manifest file for your projects. If
-	not specified it defaults to 'Cargo.toml' : >
-	    let g:cargo_manifest_name = 'Cargo.toml'
-<
-
-==============================================================================
-COMMANDS                                                       *rust-commands*
-
-:RustRun  [args]                                                    *:RustRun*
-:RustRun! [rustc-args] [--] [args]
-		Compiles and runs the current file. If it has unsaved changes,
-		it will be saved first using |:update|. If the current file is
-		an unnamed buffer, it will be written to a temporary file
-		first. The compiled binary is always placed in a temporary
-		directory, but is run from the current directory.
-
-		The arguments given to |:RustRun| will be passed to the
-		compiled binary.
-
-		If ! is specified, the arguments are passed to rustc instead.
-		A "--" argument will separate the rustc arguments from the
-		arguments passed to the binary.
-
-		If |g:rustc_path| is defined, it is used as the path to rustc.
-		Otherwise it is assumed rustc can be found in $PATH.
-
-:RustExpand  [args]                                              *:RustExpand*
-:RustExpand! [TYPE] [args]
-		Expands the current file using --pretty and displays the
-		results in a new split. If the current file has unsaved
-		changes, it will be saved first using |:update|. If the
-		current file is an unnamed buffer, it will be written to a
-		temporary file first.
-
-		The arguments given to |:RustExpand| will be passed to rustc.
-		This is largely intended for specifying various --cfg
-		configurations.
-
-		If ! is specified, the first argument is the expansion type to
-		pass to rustc --pretty. Otherwise it will default to
-		"expanded".
-
-		If |g:rustc_path| is defined, it is used as the path to rustc.
-		Otherwise it is assumed rustc can be found in $PATH.
-
-:RustEmitIr [args]                                               *:RustEmitIr*
-		Compiles the current file to LLVM IR and displays the results
-		in a new split. If the current file has unsaved changes, it
-		will be saved first using |:update|. If the current file is an
-		unnamed buffer, it will be written to a temporary file first.
-
-		The arguments given to |:RustEmitIr| will be passed to rustc.
-
-		If |g:rustc_path| is defined, it is used as the path to rustc.
-		Otherwise it is assumed rustc can be found in $PATH.
-
-:RustEmitAsm [args]                                             *:RustEmitAsm*
-		Compiles the current file to assembly and displays the results
-		in a new split. If the current file has unsaved changes, it
-		will be saved first using |:update|. If the current file is an
-		unnamed buffer, it will be written to a temporary file first.
-
-		The arguments given to |:RustEmitAsm| will be passed to rustc.
-
-		If |g:rustc_path| is defined, it is used as the path to rustc.
-		Otherwise it is assumed rustc can be found in $PATH.
-
-==============================================================================
-MAPPINGS                                                       *rust-mappings*
-
-This plugin defines mappings for |[[| and |]]| to support hanging indents.
-
-It also has a few other mappings:
-
-							*rust_<D-r>*
-<D-r>			Executes |:RustRun| with no arguments.
-			Note: This binding is only available in MacVim.
-
-							*rust_<D-R>*
-<D-R>			Populates the command line with |:RustRun|! using the
-			arguments given to the last invocation, but does not
-			execute it.
-			Note: This binding is only available in MacVim.
-
-==============================================================================
- vim:tw=78:sw=4:noet:ts=8:ft=help:norl:
diff --git a/src/etc/vim/ftdetect/rust.vim b/src/etc/vim/ftdetect/rust.vim
deleted file mode 100644
index bf685d43243..00000000000
--- a/src/etc/vim/ftdetect/rust.vim
+++ /dev/null
@@ -1 +0,0 @@
-au BufRead,BufNewFile *.rs set filetype=rust
diff --git a/src/etc/vim/ftplugin/rust.vim b/src/etc/vim/ftplugin/rust.vim
deleted file mode 100644
index 5d5569945f5..00000000000
--- a/src/etc/vim/ftplugin/rust.vim
+++ /dev/null
@@ -1,150 +0,0 @@
-" Language:     Rust
-" Description:  Vim syntax file for Rust
-" Maintainer:   Chris Morgan <me@chrismorgan.info>
-" Maintainer:   Kevin Ballard <kevin@sb.org>
-" Last Change:  Jul 07, 2014
-
-if exists("b:did_ftplugin")
-	finish
-endif
-let b:did_ftplugin = 1
-
-let s:save_cpo = &cpo
-set cpo&vim
-
-" Variables {{{1
-
-" The rust source code at present seems to typically omit a leader on /*!
-" comments, so we'll use that as our default, but make it easy to switch.
-" This does not affect indentation at all (I tested it with and without
-" leader), merely whether a leader is inserted by default or not.
-if exists("g:rust_bang_comment_leader") && g:rust_bang_comment_leader == 1
-	" Why is the `,s0:/*,mb:\ ,ex:*/` there, you ask? I don't understand why,
-	" but without it, */ gets indented one space even if there were no
-	" leaders. I'm fairly sure that's a Vim bug.
-	setlocal comments=s1:/*,mb:*,ex:*/,s0:/*,mb:\ ,ex:*/,:///,://!,://
-else
-	setlocal comments=s0:/*!,m:\ ,ex:*/,s1:/*,mb:*,ex:*/,:///,://!,://
-endif
-setlocal commentstring=//%s
-setlocal formatoptions-=t formatoptions+=croqnl
-" j was only added in 7.3.541, so stop complaints about its nonexistence
-silent! setlocal formatoptions+=j
-
-" smartindent will be overridden by indentexpr if filetype indent is on, but
-" otherwise it's better than nothing.
-setlocal smartindent nocindent
-
-if !exists("g:rust_recommended_style") || g:rust_recommended_style == 1
-	setlocal tabstop=4 shiftwidth=4 softtabstop=4 expandtab
-	setlocal textwidth=99
-endif
-
-" This includeexpr isn't perfect, but it's a good start
-setlocal includeexpr=substitute(v:fname,'::','/','g')
-
-" NOT adding .rc as it's being phased out (0.7)
-setlocal suffixesadd=.rs
-
-if exists("g:ftplugin_rust_source_path")
-    let &l:path=g:ftplugin_rust_source_path . ',' . &l:path
-endif
-
-if exists("g:loaded_delimitMate")
-	if exists("b:delimitMate_excluded_regions")
-		let b:rust_original_delimitMate_excluded_regions = b:delimitMate_excluded_regions
-	endif
-	let b:delimitMate_excluded_regions = delimitMate#Get("excluded_regions") . ',rustLifetimeCandidate,rustGenericLifetimeCandidate'
-endif
-
-if has("folding") && exists('g:rust_fold') && g:rust_fold != 0
-	let b:rust_set_foldmethod=1
-	setlocal foldmethod=syntax
-	if g:rust_fold == 2
-		setlocal foldlevel<
-	else
-		setlocal foldlevel=99
-	endif
-endif
-
-if has('conceal') && exists('g:rust_conceal')
-	let b:rust_set_conceallevel=1
-	setlocal conceallevel=2
-endif
-
-" Motion Commands {{{1
-
-" Bind motion commands to support hanging indents
-nnoremap <silent> <buffer> [[ :call rust#Jump('n', 'Back')<CR>
-nnoremap <silent> <buffer> ]] :call rust#Jump('n', 'Forward')<CR>
-xnoremap <silent> <buffer> [[ :call rust#Jump('v', 'Back')<CR>
-xnoremap <silent> <buffer> ]] :call rust#Jump('v', 'Forward')<CR>
-onoremap <silent> <buffer> [[ :call rust#Jump('o', 'Back')<CR>
-onoremap <silent> <buffer> ]] :call rust#Jump('o', 'Forward')<CR>
-
-" Commands {{{1
-
-" See |:RustRun| for docs
-command! -nargs=* -complete=file -bang -bar -buffer RustRun call rust#Run(<bang>0, [<f-args>])
-
-" See |:RustExpand| for docs
-command! -nargs=* -complete=customlist,rust#CompleteExpand -bang -bar -buffer RustExpand call rust#Expand(<bang>0, [<f-args>])
-
-" See |:RustEmitIr| for docs
-command! -nargs=* -bar -buffer RustEmitIr call rust#Emit("ir", [<f-args>])
-
-" See |:RustEmitAsm| for docs
-command! -nargs=* -bar -buffer RustEmitAsm call rust#Emit("asm", [<f-args>])
-
-" Mappings {{{1
-
-" Bind ⌘R in MacVim to :RustRun
-nnoremap <silent> <buffer> <D-r> :RustRun<CR>
-" Bind ⌘⇧R in MacVim to :RustRun! pre-filled with the last args
-nnoremap <buffer> <D-R> :RustRun! <C-r>=join(b:rust_last_rustc_args)<CR><C-\>erust#AppendCmdLine(' -- ' . join(b:rust_last_args))<CR>
-
-if !exists("b:rust_last_rustc_args") || !exists("b:rust_last_args")
-	let b:rust_last_rustc_args = []
-	let b:rust_last_args = []
-endif
-
-" Cleanup {{{1
-
-let b:undo_ftplugin = "
-		\ setlocal formatoptions< comments< commentstring< includeexpr< suffixesadd<
-		\|setlocal tabstop< shiftwidth< softtabstop< expandtab< textwidth<
-		\|if exists('b:rust_original_delimitMate_excluded_regions')
-		  \|let b:delimitMate_excluded_regions = b:rust_original_delimitMate_excluded_regions
-		  \|unlet b:rust_original_delimitMate_excluded_regions
-		\|else
-		  \|unlet! b:delimitMate_excluded_regions
-		\|endif
-		\|if exists('b:rust_set_foldmethod')
-		  \|setlocal foldmethod< foldlevel<
-		  \|unlet b:rust_set_foldmethod
-		\|endif
-		\|if exists('b:rust_set_conceallevel')
-		  \|setlocal conceallevel<
-		  \|unlet b:rust_set_conceallevel
-		\|endif
-		\|unlet! b:rust_last_rustc_args b:rust_last_args
-		\|delcommand RustRun
-		\|delcommand RustExpand
-		\|delcommand RustEmitIr
-		\|delcommand RustEmitAsm
-		\|nunmap <buffer> <D-r>
-		\|nunmap <buffer> <D-R>
-		\|nunmap <buffer> [[
-		\|nunmap <buffer> ]]
-		\|xunmap <buffer> [[
-		\|xunmap <buffer> ]]
-		\|ounmap <buffer> [[
-		\|ounmap <buffer> ]]
-		\"
-
-" }}}1
-
-let &cpo = s:save_cpo
-unlet s:save_cpo
-
-" vim: set noet sw=4 ts=4:
diff --git a/src/etc/vim/indent/rust.vim b/src/etc/vim/indent/rust.vim
deleted file mode 100644
index 300d7dacfa9..00000000000
--- a/src/etc/vim/indent/rust.vim
+++ /dev/null
@@ -1,196 +0,0 @@
-" Vim indent file
-" Language:         Rust
-" Author:           Chris Morgan <me@chrismorgan.info>
-" Last Change:      2014 Sep 13
-
-" Only load this indent file when no other was loaded.
-if exists("b:did_indent")
-  finish
-endif
-let b:did_indent = 1
-
-setlocal cindent
-setlocal cinoptions=L0,(0,Ws,J1,j1
-setlocal cinkeys=0{,0},!^F,o,O,0[,0]
-" Don't think cinwords will actually do anything at all... never mind
-setlocal cinwords=for,if,else,while,loop,impl,mod,unsafe,trait,struct,enum,fn,extern
-
-" Some preliminary settings
-setlocal nolisp		" Make sure lisp indenting doesn't supersede us
-setlocal autoindent	" indentexpr isn't much help otherwise
-" Also do indentkeys, otherwise # gets shoved to column 0 :-/
-setlocal indentkeys=0{,0},!^F,o,O,0[,0]
-
-setlocal indentexpr=GetRustIndent(v:lnum)
-
-" Only define the function once.
-if exists("*GetRustIndent")
-  finish
-endif
-
-" Come here when loading the script the first time.
-
-function! s:get_line_trimmed(lnum)
-	" Get the line and remove a trailing comment.
-	" Use syntax highlighting attributes when possible.
-	" NOTE: this is not accurate; /* */ or a line continuation could trick it
-	let line = getline(a:lnum)
-	let line_len = strlen(line)
-	if has('syntax_items')
-		" If the last character in the line is a comment, do a binary search for
-		" the start of the comment.  synID() is slow, a linear search would take
-		" too long on a long line.
-		if synIDattr(synID(a:lnum, line_len, 1), "name") =~ 'Comment\|Todo'
-			let min = 1
-			let max = line_len
-			while min < max
-				let col = (min + max) / 2
-				if synIDattr(synID(a:lnum, col, 1), "name") =~ 'Comment\|Todo'
-					let max = col
-				else
-					let min = col + 1
-				endif
-			endwhile
-			let line = strpart(line, 0, min - 1)
-		endif
-		return substitute(line, "\s*$", "", "")
-	else
-		" Sorry, this is not complete, nor fully correct (e.g. string "//").
-		" Such is life.
-		return substitute(line, "\s*//.*$", "", "")
-	endif
-endfunction
-
-function! s:is_string_comment(lnum, col)
-	if has('syntax_items')
-		for id in synstack(a:lnum, a:col)
-			let synname = synIDattr(id, "name")
-			if synname == "rustString" || synname =~ "^rustComment"
-				return 1
-			endif
-		endfor
-	else
-		" without syntax, let's not even try
-		return 0
-	endif
-endfunction
-
-function GetRustIndent(lnum)
-
-	" Starting assumption: cindent (called at the end) will do it right
-	" normally. We just want to fix up a few cases.
-
-	let line = getline(a:lnum)
-
-	if has('syntax_items')
-		let synname = synIDattr(synID(a:lnum, 1, 1), "name")
-		if synname == "rustString"
-			" If the start of the line is in a string, don't change the indent
-			return -1
-		elseif synname =~ '\(Comment\|Todo\)'
-					\ && line !~ '^\s*/\*'  " not /* opening line
-			if synname =~ "CommentML" " multi-line
-				if line !~ '^\s*\*' && getline(a:lnum - 1) =~ '^\s*/\*'
-					" This is (hopefully) the line after a /*, and it has no
-					" leader, so the correct indentation is that of the
-					" previous line.
-					return GetRustIndent(a:lnum - 1)
-				endif
-			endif
-			" If it's in a comment, let cindent take care of it now. This is
-			" for cases like "/*" where the next line should start " * ", not
-			" "* " as the code below would otherwise cause for module scope
-			" Fun fact: "  /*\n*\n*/" takes two calls to get right!
-			return cindent(a:lnum)
-		endif
-	endif
-
-	" cindent gets second and subsequent match patterns/struct members wrong,
-	" as it treats the comma as indicating an unfinished statement::
-	"
-	" match a {
-	"     b => c,
-	"         d => e,
-	"         f => g,
-	" };
-
-	" Search backwards for the previous non-empty line.
-	let prevlinenum = prevnonblank(a:lnum - 1)
-	let prevline = s:get_line_trimmed(prevlinenum)
-	while prevlinenum > 1 && prevline !~ '[^[:blank:]]'
-		let prevlinenum = prevnonblank(prevlinenum - 1)
-		let prevline = s:get_line_trimmed(prevlinenum)
-	endwhile
-	if prevline[len(prevline) - 1] == ","
-				\ && s:get_line_trimmed(a:lnum) !~ '^\s*[\[\]{}]'
-				\ && prevline !~ '^\s*fn\s'
-				\ && prevline !~ '([^()]\+,$'
-		" Oh ho! The previous line ended in a comma! I bet cindent will try to
-		" take this too far... For now, let's normally use the previous line's
-		" indent.
-
-		" One case where this doesn't work out is where *this* line contains
-		" square or curly brackets; then we normally *do* want to be indenting
-		" further.
-		"
-		" Another case where we don't want to is one like a function
-		" definition with arguments spread over multiple lines:
-		"
-		" fn foo(baz: Baz,
-		"        baz: Baz) // <-- cindent gets this right by itself
-		"
-		" Another case is similar to the previous, except calling a function
-		" instead of defining it, or any conditional expression that leaves
-		" an open paren:
-		"
-		" foo(baz,
-		"     baz);
-		"
-		" if baz && (foo ||
-		"            bar) {
-		"
-		" There are probably other cases where we don't want to do this as
-		" well. Add them as needed.
-		return indent(prevlinenum)
-	endif
-
-	if !has("patch-7.4.355")
-		" cindent before 7.4.355 doesn't do the module scope well at all; e.g.::
-		"
-		" static FOO : &'static [bool] = [
-		" true,
-		"	 false,
-		"	 false,
-		"	 true,
-		"	 ];
-		"
-		"	 uh oh, next statement is indented further!
-
-		" Note that this does *not* apply the line continuation pattern properly;
-		" that's too hard to do correctly for my liking at present, so I'll just
-		" start with these two main cases (square brackets and not returning to
-		" column zero)
-
-		call cursor(a:lnum, 1)
-		if searchpair('{\|(', '', '}\|)', 'nbW',
-					\ 's:is_string_comment(line("."), col("."))') == 0
-			if searchpair('\[', '', '\]', 'nbW',
-						\ 's:is_string_comment(line("."), col("."))') == 0
-				" Global scope, should be zero
-				return 0
-			else
-				" At the module scope, inside square brackets only
-				"if getline(a:lnum)[0] == ']' || search('\[', '', '\]', 'nW') == a:lnum
-				if line =~ "^\\s*]"
-					" It's the closing line, dedent it
-					return 0
-				else
-					return &shiftwidth
-				endif
-			endif
-		endif
-	endif
-
-	" Fall back on cindent, which does it mostly right
-	return cindent(a:lnum)
-endfunction
diff --git a/src/etc/vim/plugin/rust.vim b/src/etc/vim/plugin/rust.vim
deleted file mode 100644
index 4ec4f33d545..00000000000
--- a/src/etc/vim/plugin/rust.vim
+++ /dev/null
@@ -1,22 +0,0 @@
-" Vim syntastic plugin helper
-" Language:     Rust
-" Maintainer:   Andrew Gallant <jamslam@gmail.com>
-
-if exists("g:loaded_syntastic_rust_filetype")
-  finish
-endif
-let g:loaded_syntastic_rust_filetype = 1
-let s:save_cpo = &cpo
-set cpo&vim
-
-" This is to let Syntastic know about the Rust filetype.
-" It enables tab completion for the 'SyntasticInfo' command.
-" (This does not actually register the syntax checker.)
-if exists('g:syntastic_extra_filetypes')
-    call add(g:syntastic_extra_filetypes, 'rust')
-else
-    let g:syntastic_extra_filetypes = ['rust']
-endif
-
-let &cpo = s:save_cpo
-unlet s:save_cpo
diff --git a/src/etc/vim/syntax/rust.vim b/src/etc/vim/syntax/rust.vim
deleted file mode 100644
index a37b7b6d57d..00000000000
--- a/src/etc/vim/syntax/rust.vim
+++ /dev/null
@@ -1,262 +0,0 @@
-" Vim syntax file
-" Language:     Rust
-" Maintainer:   Patrick Walton <pcwalton@mozilla.com>
-" Maintainer:   Ben Blum <bblum@cs.cmu.edu>
-" Maintainer:   Chris Morgan <me@chrismorgan.info>
-" Last Change:  January 5, 2015
-
-if version < 600
-  syntax clear
-elseif exists("b:current_syntax")
-  finish
-endif
-
-" Syntax definitions {{{1
-" Basic keywords {{{2
-syn keyword   rustConditional match if else
-syn keyword   rustOperator    as
-
-syn match     rustAssert      "\<assert\(\w\)*!" contained
-syn match     rustPanic       "\<panic\(\w\)*!" contained
-syn keyword   rustKeyword     break
-syn keyword   rustKeyword     box nextgroup=rustBoxPlacement skipwhite skipempty
-syn keyword   rustKeyword     continue
-syn keyword   rustKeyword     extern nextgroup=rustExternCrate,rustObsoleteExternMod skipwhite skipempty
-syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite skipempty
-syn keyword   rustKeyword     for in if impl let
-syn keyword   rustKeyword     loop once pub
-syn keyword   rustKeyword     return super
-syn keyword   rustKeyword     unsafe virtual where while
-syn keyword   rustKeyword     use nextgroup=rustModPath skipwhite skipempty
-" FIXME: Scoped impl's name is also fallen in this category
-syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty
-syn keyword   rustStorage     move mut ref static const
-
-syn keyword   rustInvalidBareKeyword crate
-
-syn keyword   rustExternCrate crate contained nextgroup=rustIdentifier,rustExternCrateString skipwhite skipempty
-" This is to get the `bar` part of `extern crate "foo" as bar;` highlighting.
-syn match   rustExternCrateString /".*"\_s*as/ contained nextgroup=rustIdentifier skipwhite transparent skipempty contains=rustString,rustOperator
-syn keyword   rustObsoleteExternMod mod contained nextgroup=rustIdentifier skipwhite skipempty
-
-syn match     rustIdentifier  contains=rustIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
-syn match     rustFuncName    "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
-
-syn region    rustBoxPlacement matchgroup=rustBoxPlacementParens start="(" end=")" contains=TOP contained
-syn keyword   rustBoxPlacementExpr GC containedin=rustBoxPlacement
-" Ideally we'd have syntax rules set up to match arbitrary expressions. Since
-" we don't, we'll just define temporary contained rules to handle balancing
-" delimiters.
-syn region    rustBoxPlacementBalance start="(" end=")" containedin=rustBoxPlacement transparent
-syn region    rustBoxPlacementBalance start="\[" end="\]" containedin=rustBoxPlacement transparent
-" {} are handled by rustFoldBraces
-
-syn region rustMacroRepeat matchgroup=rustMacroRepeatDelimiters start="$(" end=")" contains=TOP nextgroup=rustMacroRepeatCount
-syn match rustMacroRepeatCount ".\?[*+]" contained
-syn match rustMacroVariable "$\w\+"
-
-" Reserved (but not yet used) keywords {{{2
-syn keyword   rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield abstract final override macro
-
-" Built-in types {{{2
-syn keyword   rustType        isize usize float char bool u8 u16 u32 u64 f32
-syn keyword   rustType        f64 i8 i16 i32 i64 str Self
-
-" Things from the prelude (src/libstd/prelude.rs) {{{2
-" This section is just straight transformation of the contents of the prelude,
-" to make it easy to update.
-
-" Reexported core operators {{{3
-syn keyword   rustTrait       Copy Send Sized Sync
-syn keyword   rustTrait       Drop Fn FnMut FnOnce
-
-" Reexported functions {{{3
-syn keyword rustFunction drop
-
-" Reexported types and traits {{{3
-syn keyword rustTrait Box
-syn keyword rustTrait CharExt
-syn keyword rustTrait Clone
-syn keyword rustTrait PartialEq PartialOrd Eq Ord
-syn keyword rustTrait DoubleEndedIterator
-syn keyword rustTrait ExactSizeIterator
-syn keyword rustTrait Iterator IteratorExt Extend
-syn keyword rustEnum Option
-syn keyword rustEnumVariant Some None
-syn keyword rustTrait PtrExt MutPtrExt
-syn keyword rustEnum Result
-syn keyword rustEnumVariant Ok Err
-syn keyword rustTrait AsSlice
-syn keyword rustTrait SliceExt SliceConcatExt
-syn keyword rustTrait Str StrExt
-syn keyword rustTrait String ToString
-syn keyword rustTrait Vec
-" FIXME: remove when path reform lands
-syn keyword rustTrait Path GenericPath
-" FIXME: remove when I/O reform lands
-syn keyword rustTrait Buffer Writer Reader Seek BufferPrelude
-
-" Other syntax {{{2
-syn keyword   rustSelf        self
-syn keyword   rustBoolean     true false
-
-" If foo::bar changes to foo.bar, change this ("::" to "\.").
-" If foo::bar changes to Foo::bar, change this (first "\w" to "\u").
-syn match     rustModPath     "\w\(\w\)*::[^<]"he=e-3,me=e-3
-syn match     rustModPathSep  "::"
-
-syn match     rustFuncCall    "\w\(\w\)*("he=e-1,me=e-1
-syn match     rustFuncCall    "\w\(\w\)*::<"he=e-3,me=e-3 " foo::<T>();
-
-" This is merely a convention; note also the use of [A-Z], restricting it to
-" latin identifiers rather than the full Unicode uppercase. I have not used
-" [:upper:] as it depends upon 'noignorecase'
-"syn match     rustCapsIdent    display "[A-Z]\w\(\w\)*"
-
-syn match     rustOperator     display "\%(+\|-\|/\|*\|=\|\^\|&\||\|!\|>\|<\|%\)=\?"
-" This one isn't *quite* right, as we could have binary-& with a reference
-syn match     rustSigil        display /&\s\+[&~@*][^)= \t\r\n]/he=e-1,me=e-1
-syn match     rustSigil        display /[&~@*][^)= \t\r\n]/he=e-1,me=e-1
-" This isn't actually correct; a closure with no arguments can be `|| { }`.
-" Last, because the & in && isn't a sigil
-syn match     rustOperator     display "&&\|||"
-
-syn match     rustMacro       '\w\(\w\)*!' contains=rustAssert,rustPanic
-syn match     rustMacro       '#\w\(\w\)*' contains=rustAssert,rustPanic
-
-syn match     rustEscapeError   display contained /\\./
-syn match     rustEscape        display contained /\\\([nrt0\\'"]\|x\x\{2}\)/
-syn match     rustEscapeUnicode display contained /\\\(u\x\{4}\|U\x\{8}\)/
-syn match     rustEscapeUnicode display contained /\\u{\x\{1,6}}/
-syn match     rustStringContinuation display contained /\\\n\s*/
-syn region    rustString      start=+b"+ skip=+\\\\\|\\"+ end=+"+ contains=rustEscape,rustEscapeError,rustStringContinuation
-syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustEscape,rustEscapeUnicode,rustEscapeError,rustStringContinuation,@Spell
-syn region    rustString      start='b\?r\z(#*\)"' end='"\z1' contains=@Spell
-
-syn region    rustAttribute   start="#!\?\[" end="\]" contains=rustString,rustDerive
-syn region    rustDerive      start="derive(" end=")" contained contains=rustTrait
-
-" Number literals
-syn match     rustDecNumber   display "\<[0-9][0-9_]*\%([iu]\%(s\|8\|16\|32\|64\)\)\="
-syn match     rustHexNumber   display "\<0x[a-fA-F0-9_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
-syn match     rustOctNumber   display "\<0o[0-7_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
-syn match     rustBinNumber   display "\<0b[01_]\+\%([iu]\%(s\|8\|16\|32\|64\)\)\="
-
-" Special case for numbers of the form "1." which are float literals, unless followed by
-" an identifier, which makes them integer literals with a method call or field access,
-" or by another ".", which makes them integer literals followed by the ".." token.
-" (This must go first so the others take precedence.)
-syn match     rustFloat       display "\<[0-9][0-9_]*\.\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\|\.\)\@!"
-" To mark a number as a normal float, it must have at least one of the three things integral values don't have:
-" a decimal point and more numbers; an exponent; and a type suffix.
-syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)\="
-syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\(f32\|f64\)\="
-syn match     rustFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)"
-
-" For the benefit of delimitMate
-syn region rustLifetimeCandidate display start=/&'\%(\([^'\\]\|\\\(['nrt0\\\"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'\)\@!/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustSigil,rustLifetime
-syn region rustGenericRegion display start=/<\%('\|[^[cntrl:][:space:][:punct:]]\)\@=')\S\@=/ end=/>/ contains=rustGenericLifetimeCandidate
-syn region rustGenericLifetimeCandidate display start=/\%(<\|,\s*\)\@<='/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustSigil,rustLifetime
-
-"rustLifetime must appear before rustCharacter, or chars will get the lifetime highlighting
-syn match     rustLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*"
-syn match   rustCharacterInvalid   display contained /b\?'\zs[\n\r\t']\ze'/
-" The groups negated here add up to 0-255 but nothing else (they do not seem to go beyond ASCII).
-syn match   rustCharacterInvalidUnicode   display contained /b'\zs[^[:cntrl:][:graph:][:alnum:][:space:]]\ze'/
-syn match   rustCharacter   /b'\([^\\]\|\\\(.\|x\x\{2}\)\)'/ contains=rustEscape,rustEscapeError,rustCharacterInvalid,rustCharacterInvalidUnicode
-syn match   rustCharacter   /'\([^\\]\|\\\(.\|x\x\{2}\|u\x\{4}\|U\x\{8}\|u{\x\{1,6}}\)\)'/ contains=rustEscape,rustEscapeUnicode,rustEscapeError,rustCharacterInvalid
-
-syn region rustCommentLine                                        start="//"                      end="$"   contains=rustTodo,@Spell
-syn region rustCommentLineDoc                                     start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo,@Spell
-syn region rustCommentBlock    matchgroup=rustCommentBlock        start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,rustCommentBlockNest,@Spell
-syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc     start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,rustCommentBlockDocNest,@Spell
-syn region rustCommentBlockNest matchgroup=rustCommentBlock       start="/\*"                     end="\*/" contains=rustTodo,rustCommentBlockNest,@Spell contained transparent
-syn region rustCommentBlockDocNest matchgroup=rustCommentBlockDoc start="/\*"                     end="\*/" contains=rustTodo,rustCommentBlockDocNest,@Spell contained transparent
-" FIXME: this is a really ugly and not fully correct implementation. Most
-" importantly, a case like ``/* */*`` should have the final ``*`` not being in
-" a comment, but in practice at present it leaves comments open two levels
-" deep. But as long as you stay away from that particular case, I *believe*
-" the highlighting is correct. Due to the way Vim's syntax engine works
-" (greedy for start matches, unlike Rust's tokeniser which is searching for
-" the earliest-starting match, start or end), I believe this cannot be solved.
-" Oh you who would fix it, don't bother with things like duplicating the Block
-" rules and putting ``\*\@<!`` at the start of them; it makes it worse, as
-" then you must deal with cases like ``/*/**/*/``. And don't try making it
-" worse with ``\%(/\@<!\*\)\@<!``, either...
-
-syn keyword rustTodo contained TODO FIXME XXX NB NOTE
-
-" Folding rules {{{2
-" Trivial folding rules to begin with.
-" FIXME: use the AST to make really good folding
-syn region rustFoldBraces start="{" end="}" transparent fold
-
-" Default highlighting {{{1
-hi def link rustDecNumber       rustNumber
-hi def link rustHexNumber       rustNumber
-hi def link rustOctNumber       rustNumber
-hi def link rustBinNumber       rustNumber
-hi def link rustIdentifierPrime rustIdentifier
-hi def link rustTrait           rustType
-
-hi def link rustMacroRepeatCount   rustMacroRepeatDelimiters
-hi def link rustMacroRepeatDelimiters   Macro
-hi def link rustMacroVariable Define
-hi def link rustSigil         StorageClass
-hi def link rustEscape        Special
-hi def link rustEscapeUnicode rustEscape
-hi def link rustEscapeError   Error
-hi def link rustStringContinuation Special
-hi def link rustString        String
-hi def link rustCharacterInvalid Error
-hi def link rustCharacterInvalidUnicode rustCharacterInvalid
-hi def link rustCharacter     Character
-hi def link rustNumber        Number
-hi def link rustBoolean       Boolean
-hi def link rustEnum          rustType
-hi def link rustEnumVariant   rustConstant
-hi def link rustConstant      Constant
-hi def link rustSelf          Constant
-hi def link rustFloat         Float
-hi def link rustOperator      Operator
-hi def link rustKeyword       Keyword
-hi def link rustReservedKeyword Error
-hi def link rustConditional   Conditional
-hi def link rustIdentifier    Identifier
-hi def link rustCapsIdent     rustIdentifier
-hi def link rustModPath       Include
-hi def link rustModPathSep    Delimiter
-hi def link rustFunction      Function
-hi def link rustFuncName      Function
-hi def link rustFuncCall      Function
-hi def link rustCommentLine   Comment
-hi def link rustCommentLineDoc SpecialComment
-hi def link rustCommentBlock  rustCommentLine
-hi def link rustCommentBlockDoc rustCommentLineDoc
-hi def link rustAssert        PreCondit
-hi def link rustPanic         PreCondit
-hi def link rustMacro         Macro
-hi def link rustType          Type
-hi def link rustTodo          Todo
-hi def link rustAttribute     PreProc
-hi def link rustDerive        PreProc
-hi def link rustStorage       StorageClass
-hi def link rustObsoleteStorage Error
-hi def link rustLifetime      Special
-hi def link rustInvalidBareKeyword Error
-hi def link rustExternCrate   rustKeyword
-hi def link rustObsoleteExternMod Error
-hi def link rustBoxPlacementParens Delimiter
-hi def link rustBoxPlacementExpr rustKeyword
-
-" Other Suggestions:
-" hi rustAttribute ctermfg=cyan
-" hi rustDerive ctermfg=cyan
-" hi rustAssert ctermfg=yellow
-" hi rustPanic ctermfg=red
-" hi rustMacro ctermfg=magenta
-
-syn sync minlines=200
-syn sync maxlines=500
-
-let b:current_syntax = "rust"
diff --git a/src/etc/vim/syntax_checkers/rust/rustc.vim b/src/etc/vim/syntax_checkers/rust/rustc.vim
deleted file mode 100644
index 5d196086168..00000000000
--- a/src/etc/vim/syntax_checkers/rust/rustc.vim
+++ /dev/null
@@ -1,35 +0,0 @@
-" Vim syntastic plugin
-" Language:     Rust
-" Maintainer:   Andrew Gallant <jamslam@gmail.com>
-"
-" See for details on how to add an external Syntastic checker:
-" https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide#external
-
-if exists("g:loaded_syntastic_rust_rustc_checker")
-    finish
-endif
-let g:loaded_syntastic_rust_rustc_checker = 1
-
-let s:save_cpo = &cpo
-set cpo&vim
-
-function! SyntaxCheckers_rust_rustc_GetLocList() dict
-    let makeprg = self.makeprgBuild({ 'args': '-Zparse-only' })
-
-    let errorformat  =
-        \ '%E%f:%l:%c: %\d%#:%\d%# %.%\{-}error:%.%\{-} %m,'   .
-        \ '%W%f:%l:%c: %\d%#:%\d%# %.%\{-}warning:%.%\{-} %m,' .
-        \ '%C%f:%l %m,' .
-        \ '%-Z%.%#'
-
-    return SyntasticMake({
-        \ 'makeprg': makeprg,
-        \ 'errorformat': errorformat })
-endfunction
-
-call g:SyntasticRegistry.CreateAndRegisterChecker({
-    \ 'filetype': 'rust',
-    \ 'name': 'rustc'})
-
-let &cpo = s:save_cpo
-unlet s:save_cpo
diff --git a/src/etc/zsh/_rust b/src/etc/zsh/_rust
deleted file mode 100644
index 404f622f970..00000000000
--- a/src/etc/zsh/_rust
+++ /dev/null
@@ -1,215 +0,0 @@
-#compdef rustc
-
-local -a _rustc_opts_switches _rustc_opts_lint _rustc_opts_debug
-
-typeset -A opt_args
-
-_rustc_debuginfo_levels=(
-    "0[no debug info]"
-    "1[line-tables only (for stacktraces and breakpoints)]"
-    "2[full debug info with variable and type information (same as -g)]"
-)
-
-_rustc_crate_types=(
-    'bin'
-    'lib'
-    'rlib'
-    'dylib'
-    'staticlib'
-)
-
-_rustc_emit_types=(
-    'asm'
-    'llvm-bc'
-    'llvm-ir'
-    'obj'
-    'link'
-    'dep-info'
-)
-_rustc_pretty_types=(
-    'normal[un-annotated source]'
-    'expanded[crates expanded]'
-    'typed[crates  expanded,  with  type  annotations]'
-    'identified[fully parenthesized, AST nodes and blocks with IDs]'
-    'flowgraph[graphviz formatted flowgraph for node]:NODEID:'
-)
-_rustc_color_types=(
-    'auto[colorize, if output goes to a tty (default)]'
-    'always[always colorize output]'
-    'never[never colorize output]'
-)
-_rustc_info_types=(
-    'crate-name[Output the crate name and exit]'
-    'file-names[Output the file(s) that would be written if compilation continued and exited]'
-    'sysroot[Output the sysroot and exit]'
-)
-
-_rustc_opts_vals=(
-    --crate-name='[Specify the name of the crate being built]'
-    --crate-type='[Comma separated list of types of crates for the compiler to emit]:TYPES:_values -s "," "Crate types"  "$_rustc_crate_types[@]"'
-    --emit='[Comma separated list of types of output for the compiler to emit]:TYPES:_values -s "," "Emit Targets" "$_rustc_emit_types[@]"'
-    --cfg='[Configure the compilation environment]:SPEC:'
-    --out-dir='[Write output to compiler-chosen filename in <dir>.  Ignored  if  -o  is  specified. (default the current directory)]:DIR:_files -/'
-    -o'[Write output to <filename>. Ignored if more than one --emit is specified.]:FILENAME:_files'
-    --pretty='[Pretty-print the input instead of compiling]::TYPE:_values "TYPES" "$_rustc_pretty_types[@]"'
-    -L'[Add a directory to the library search path]:DIR:_files -/'
-    --target='[Target triple cpu-manufacturer-kernel\[-os\] to compile]:TRIPLE:'
-    --color='[Configure coloring of output]:CONF:_values "COLORS" "$_rustc_color_types[@]"'
-    {-v,--version}'[Print version info and exit]::VERBOSE:(verbose)'
-    --explain='[Provide a detailed explanation of an error message]:OPT:'
-    --extern'[Specify where an external rust library is located]:ARG:'
-    --print='[Comma separated list of compiler information to print on stdout]:TYPES:_values -s "," "Compiler Information" "$_rustc_info_types[@]"'
-)
-
-_rustc_opts_switches=(
-    -g'[Equivalent to -C debuginfo=2]'
-    {-h,--help}'[Display the help message]'
-    {-V,--verbose}'[use verbose output]'
-    -O'[Equivalent to -C opt-level=2]'
-    --test'[Build a test harness]'
-)
-
-
-_rustc_opts_link=(
-    'static[Path to the library to link statically]:PATH:_files -/'
-    'dylib[Path to the library to link dynamically]:PATH:_files -/'
-    'framework[Path to the library to link as a framework]:PATH:_files -/'
-)
-
-_rustc_opts_codegen=(
-    'ar[Path to the archive utility to use when assembling archives.]:BIN:_path_files'
-    'linker[Path to the linker utility to use when linking libraries, executables, and objects.]:BIN:_path_files'
-    'link-args[A space-separated list of extra arguments to pass to the linker when the linker is invoked.]:ARGS:'
-    'lto[Perform LLVM link-time optimizations]'
-    'target-cpu[Selects a target processor. If the value is "help", then a list of  available  CPUs is printed.]:CPU:'
-    'target-feature[A space-separated list of features to enable or disable for the target. A preceding "+" enables a feature while a preceding "-" disables it. Available features can be discovered through target-cpu=help.]:FEATURE:'
-    'passes[A space-separated list of extra LLVM passes to run. A value of "list" will cause rustc to print all known passes and exit. The passes specified are appended at the end of the normal pass manager.]:LIST:'
-    'llvm-args[A space-separated list of arguments to pass through to LLVM.]:ARGS:'
-    'save-temps[If specified, the compiler will save more files (.bc, .o, .no-opt.bc) generated throughout compilation in the output directory.]'
-    'rpath[If specified, then the rpath value for dynamic libraries will be set in either dynamic library or executable outputs.]'
-    'no-prepopulate-passes[Suppresses pre-population of the LLVM pass manager that is run over the module.]'
-    'no-vectorize-loops[Suppresses running the loop vectorization LLVM pass, regardless of optimization level.]'
-    'no-vectorize-slp[Suppresses running the LLVM SLP vectorization pass, regardless of optimization level.]'
-    'soft-float[Generates software floating point library calls instead of hardware instructions.]'
-    'prefer-dynamic[Prefers dynamic linking to static linking.]'
-    "no-integrated-as[Force usage of an external assembler rather than LLVM's integrated one.]"
-    'no-redzone[disable the use of the redzone]'
-    'relocation-model[The relocation model to use. (default: pic)]:MODEL:(pic static dynamic-no-pic)'
-    'code-model[choose the code model to use (llc -code-model for details)]:MODEL:'
-    'metadata[metadata to mangle symbol names with]:VAL:'
-    'extra-filenames[extra data to put in each output filename]:VAL:'
-    'codegen-units[divide crate into N units to optimize in parallel]:N:'
-    'remark[print remarks for these optimization passes (space separated, or "all")]:TYPE:'
-    'debuginfo[debug info emission level, 0 = no debug info, 1 = line tables only, 2 = full debug info with variable and type information]:LEVEL:_values "Debug Levels" "$_rustc_debuginfo_levels[@]"'
-    'opt-level[Optimize with possible levels 0-3]:LEVEL:(0 1 2 3)'
-    'help[Show all codegen options]'
-)
-
-_rustc_opts_lint=(
-    'help[Show a list of all lints]'
-    'box-pointers[(default: allow) use of owned (Box type) heap memory]'
-    'experimental[(default: allow) detects use of #\[experimental\] items]'
-    'fat-ptr-transmutes[(default: allow) detects transmutes of fat pointers]'
-    'missing-docs[(default: allow) detects missing documentation for public members]'
-    'unsafe-blocks[(default: allow) usage of an "unsafe" block]'
-    'unstable[(default: allow) detects use of #\[unstable\] items (incl. items with no stability attribute)]'
-    'unused-extern-crates[(default: allow) extern crates that are never used]'
-    'unused-import-braces[(default: allow) unnecessary braces around an imported item]'
-    'unused-qualifications[(default: allow) detects unnecessarily qualified names]'
-    'unused-results[(default: allow) unused result of an expression in a statement]'
-    'unused-typecasts[(default: allow) detects unnecessary type casts that can be removed]'
-    'variant-size-differences[(default: allow) detects enums with widely varying variant sizes]'
-    'dead-code[(default: warn) detect unused, unexported items]'
-    'deprecated[(default: warn) detects use of #\[deprecated\] items]'
-    'improper-ctypes[(default: warn) proper use of libc types in foreign modules]'
-    'missing-copy-implementations[(default: warn) detects potentially-forgotten implementations of "Copy"]'
-    'non-camel-case-types[(default: warn) types, variants, traits and type parameters should have camel case names]'
-    'non-shorthand-field-patterns[(default: warn) using "Struct { x: x }" instead of "Struct { x }"]'
-    'non-snake-case[(default: warn) methods, functions, lifetime parameters and modules should have snake case names]'
-    'non-upper-case-globals[(default: warn) static constants should have uppercase identifiers]'
-    'overflowing-literals[(default: warn) literal out of range for its type]'
-    'path-statements[(default: warn) path statements with no effect]'
-    'raw-pointer-deriving[(default: warn) uses of #\[derive\] with raw pointers are rarely correct]'
-    'unknown-lints[(default: warn) unrecognized lint attribute]'
-    'unreachable-code[(default: warn) detects unreachable code paths]'
-    'unsigned-negation[(default: warn) using an unary minus operator on unsigned type]'
-    'unused-allocation[(default: warn) detects unnecessary allocations that can be eliminated]'
-    'unused-assignments[(default: warn) detect assignments that will never be read]'
-    'unused-attributes[(default: warn) detects attributes that were not used by the compiler]'
-    'unused-comparisons[(default: warn) comparisons made useless by limits of the types involved]'
-    'unused-imports[(default: warn) imports that are never used]'
-    'unused-must-use[(default: warn) unused result of a type flagged as must_use]'
-    "unused-mut[(default: warn) detect mut variables which don't need to be mutable]"
-    'unused-parens[(default: warn) "if", "match", "while" and "return" do not need parentheses]'
-    'unused-unsafe[(default: warn) unnecessary use of an "unsafe" block]'
-    'unused-variables[(default: warn) detect variables which are not used in any way]'
-    'warnings[(default: warn) mass-change the level for lints which produce warnings]'
-    'while-true[(default: warn) suggest using "loop { }" instead of "while true { }"]'
-    "exceeding-bitshifts[(default: deny) shift exceeds the type's number of bits]"
-    'unknown-crate-types[(default: deny) unknown crate type found in #\[crate_type\] directive]'
-    'unknown-features[(default: deny) unknown features found in crate-level #\[feature\] directives]'
-    'bad-style[non-camel-case-types, non-snake-case, non-upper-case-globals]'
-    'unused[unused-imports, unused-variables, unused-assignments, dead-code, unused-mut, unreachable-code, unused-must-use, unused-unsafe, path-statements]'
-)
-
-_rustc_opts_debug=(
-    'verbose[in general, enable more debug printouts]'
-    'time-passes[measure time of each rustc pass]'
-    'count-llvm-insns[count where LLVM instrs originate]'
-    'time-llvm-passes[measure time of each LLVM pass]'
-    'trans-stats[gather trans statistics]'
-    'asm-comments[generate comments into the assembly (may change behavior)]'
-    'no-verify[skip LLVM verification]'
-    'borrowck-stats[gather borrowck statistics]'
-    'no-landing-pads[omit landing pads for unwinding]'
-    'debug-llvm[enable debug output from LLVM]'
-    'show-span[show spans for compiler debugging]'
-    'count-type-sizes[count the sizes of aggregate types]'
-    'meta-stats[gather metadata statistics]'
-    'print-link-args[Print the arguments passed to the linker]'
-    'gc[Garbage collect shared data (experimental)]'
-    'print-llvm-passes[Prints the llvm optimization passes being run]'
-    'ast-json[Print the AST as JSON and halt]'
-    'ast-json-noexpand[Print the pre-expansion AST as JSON and halt]'
-    'ls[List the symbols defined by a library crate]'
-    'save-analysis[Write syntax and type analysis information in addition to normal output]'
-    'flowgraph-print-loans[Include loan analysis data in --pretty flowgraph output]'
-    'flowgraph-print-moves[Include move analysis data in --pretty flowgraph output]'
-    'flowgraph-print-assigns[Include assignment analysis data in --pretty flowgraph output]'
-    'flowgraph-print-all[Include all dataflow analysis data in --pretty flowgraph output]'
-    'print-regiion-graph[Prints region inference graph. Use with RUST_REGION_GRAPH=help for more info]'
-    'parse-only[Parse only; do not compile, assemble, or link]'
-    'no-trans[Run all passes except translation; no output]'
-    'no-analysis[Parse and expand the source, but run no analysis]'
-    'unstable-options[Adds unstable command line options to rustc interface]'
-    'print-enum-sizes[Print the size of enums and their variants]'
-)
-
-_rustc_opts_fun_lint(){
-    _values -s , 'options' \
-        "$_rustc_opts_lint[@]"
-}
-
-_rustc_opts_fun_debug(){
-    _values 'options' "$_rustc_opts_debug[@]"
-}
-
-_rustc_opts_fun_codegen(){
-    _values 'options' "$_rustc_opts_codegen[@]"
-}
-
-_rustc_opts_fun_link(){
-    _values 'options' "$_rustc_opts_link[@]"
-}
-
-_arguments -s :  \
-    '(-W --warn)'{-W,--warn=}'[Set lint warnings]:lint options:_rustc_opts_fun_lint' \
-    '(-A --allow)'{-A,--allow=}'[Set lint allowed]:lint options:_rustc_opts_fun_lint' \
-    '(-D --deny)'{-D,--deny=}'[Set lint denied]:lint options:_rustc_opts_fun_lint' \
-    '(-F --forbid)'{-F,--forbid=}'[Set lint forbidden]:lint options:_rustc_opts_fun_lint' \
-    '*-Z[Set internal debugging options]:debug options:_rustc_opts_fun_debug' \
-    '(-C --codegen)'{-C,--codegen}'[Set internal Codegen options]:codegen options:_rustc_opts_fun_codegen' \
-    '*-l[Link the generated crates to the specified native library NAME. the optional KIND can be one of, static, dylib, or framework. If omitted, dylib is assumed.]:ARG:_rustc_opts_fun_link' \
-    "$_rustc_opts_switches[@]" \
-    "$_rustc_opts_vals[@]" \
-    '::files:_files -g "*.rs"'