bashrc: tell Python to not write bytecode files

Sponsored-by: author

3 files changed, 0 insertions, 976 deletions

diff --git a/emacs.d/elpa/racer-20191001.2344/racer-autoloads.el b/emacs.d/elpa/racer-20191001.2344/racer-autoloads.el
deleted file mode 100644
index 348592a..0000000
--- a/emacs.d/elpa/racer-20191001.2344/racer-autoloads.el
+++ /dev/null
@@ -1,42 +0,0 @@
-;;; racer-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-
-(add-to-list 'load-path (directory-file-name
-                         (or (file-name-directory #$) (car load-path))))
-
-
-;;;### (autoloads nil "racer" "racer.el" (0 0 0 0))
-;;; Generated autoloads from racer.el
-
-(autoload 'racer-find-definition "racer" "\
-Run the racer find-definition command and process the results.
-
-\(fn)" t nil)
-
-(autoload 'racer-find-definition-other-window "racer" "\
-Run the racer find-definition command and process the results.
-
-\(fn)" t nil)
-
-(autoload 'racer-find-definition-other-frame "racer" "\
-Run the racer find-definition command and process the results.
-
-\(fn)" t nil)
-
-(autoload 'racer-mode "racer" "\
-Minor mode for racer.
-
-\(fn &optional ARG)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "racer" '("racer-")))
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; coding: utf-8
-;; End:
-;;; racer-autoloads.el ends here
diff --git a/emacs.d/elpa/racer-20191001.2344/racer-pkg.el b/emacs.d/elpa/racer-20191001.2344/racer-pkg.el
deleted file mode 100644
index 9ffa2d8..0000000
--- a/emacs.d/elpa/racer-20191001.2344/racer-pkg.el
+++ /dev/null
@@ -1,2 +0,0 @@
-;;; -*- no-byte-compile: t -*-
-(define-package "racer" "20191001.2344" "code completion, goto-definition and docs browsing for Rust via racer" '((emacs "25.1") (rust-mode "0.2.0") (dash "2.13.0") (s "1.10.0") (f "0.18.2") (pos-tip "0.4.6")) :commit "a0bdf778f01e8c4b8a92591447257422ac0b455b" :keywords '("abbrev" "convenience" "matching" "rust" "tools") :authors '(("Phil Dawes")) :maintainer '("Phil Dawes") :url "https://github.com/racer-rust/emacs-racer")
diff --git a/emacs.d/elpa/racer-20191001.2344/racer.el b/emacs.d/elpa/racer-20191001.2344/racer.el
deleted file mode 100644
index 305e20b..0000000
--- a/emacs.d/elpa/racer-20191001.2344/racer.el
+++ /dev/null
@@ -1,932 +0,0 @@
-;;; racer.el --- code completion, goto-definition and docs browsing for Rust via racer  -*- lexical-binding: t -*-
-
-;; Copyright (c) 2014 Phil Dawes
-
-;; Author: Phil Dawes
-;; URL: https://github.com/racer-rust/emacs-racer
-;; Package-Version: 20191001.2344
-;; Package-Commit: a0bdf778f01e8c4b8a92591447257422ac0b455b
-;; Version: 1.3
-;; Package-Requires: ((emacs "25.1") (rust-mode "0.2.0") (dash "2.13.0") (s "1.10.0") (f "0.18.2") (pos-tip "0.4.6"))
-;; Keywords: abbrev, convenience, matching, rust, tools
-
-;; This file is not part of GNU Emacs.
-
-;; Permission is hereby granted, free of charge, to any
-;; person obtaining a copy of this software and associated
-;; documentation files (the "Software"), to deal in the
-;; Software without restriction, including without
-;; limitation the rights to use, copy, modify, merge,
-;; publish, distribute, sublicense, and/or sell copies of
-;; the Software, and to permit persons to whom the Software
-;; is furnished to do so, subject to the following
-;; conditions:
-
-;; The above copyright notice and this permission notice
-;; shall be included in all copies or substantial portions
-;; of the Software.
-
-;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-;; ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-;; TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-;; PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-;; SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-;; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-;; IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-;; DEALINGS IN THE SOFTWARE.
-
-;;; Commentary:
-
-;; Please see the readme for full documentation:
-;; https://github.com/racer-rust/emacs-racer
-
-;;; Quickstart:
-
-;; You will need to configure Emacs to find racer:
-;;
-;; (setq racer-rust-src-path "<path-to-rust-srcdir>/src/")
-;; (setq racer-cmd "<path-to-racer>/target/release/racer")
-;;
-;; To activate racer in Rust buffers, run:
-;;
-;; (add-hook 'rust-mode-hook #'racer-mode)
-;;
-;; You can also use racer to find definition at point via
-;; `racer-find-definition', bound to `M-.' by default.
-;;
-;; Finally, you can also use Racer to show the signature of the
-;; current function in the minibuffer:
-;;
-;; (add-hook 'racer-mode-hook #'eldoc-mode)
-
-;;; Code:
-
-(require 'dash)
-(require 'etags)
-(require 'rust-mode)
-(require 's)
-(require 'f)
-(require 'thingatpt)
-(require 'button)
-(require 'help-mode)
-(autoload 'pos-tip-show-no-propertize "pos-tip")
-
-(defgroup racer nil
-  "Code completion, goto-definition and docs browsing for Rust via racer."
-  :link '(url-link "https://github.com/racer-rust/emacs-racer/")
-  :group 'rust-mode)
-
-(defcustom racer-cmd
-  (or (executable-find "racer")
-      (f-expand "~/.cargo/bin/racer")
-      "/usr/local/bin/racer")
-  "Path to the racer binary."
-  :type 'file
-  :group 'racer)
-
-(defcustom racer-rust-src-path
-  (or
-   (getenv "RUST_SRC_PATH")
-   (when (executable-find "rustc")
-     (let* ((sysroot (s-trim-right
-                      (shell-command-to-string
-                       (format "%s --print sysroot" (executable-find "rustc")))))
-            (src-path (f-join sysroot "lib/rustlib/src/rust/src")))
-       (when (file-exists-p src-path)
-         src-path)
-       src-path))
-   "/usr/local/src/rust/src")
-
-  "Path to the rust source tree.
-If nil, we will query $RUST_SRC_PATH at runtime.
-If $RUST_SRC_PATH is not set, look for rust source in rustup's install directory."
-  :type 'file
-  :group 'racer)
-
-(defcustom racer-cargo-home
-  (or
-   (getenv "CARGO_HOME")
-   "~/.cargo")
-  "Path to your current cargo home. Usually `~/.cargo'.
-If nil, we will query $CARGO_HOME at runtime."
-  :type 'file
-  :group 'racer)
-
-(defun racer--cargo-project-root ()
-  "Find the root of the current Cargo project."
-  (let ((root (locate-dominating-file (or (buffer-file-name (buffer-base-buffer)) default-directory)
-                                      "Cargo.toml")))
-    (and root (file-truename root))))
-
-(defun racer--header (text)
-  "Helper function for adding text properties to TEXT."
-  (propertize text 'face 'racer-help-heading-face))
-
-(defvar racer--prev-state nil)
-
-(defun racer-debug ()
-  "Open a buffer describing the last racer command run.
-Helps users find configuration issues, or file bugs on
-racer or racer.el."
-  (interactive)
-  (unless racer--prev-state
-    (user-error "Must run a racer command before debugging"))
-  (let ((buf (get-buffer-create "*racer-debug*"))
-        (inhibit-read-only t))
-    (with-current-buffer buf
-      (erase-buffer)
-      (setq buffer-read-only t)
-      (let* ((process-environment
-              (plist-get racer--prev-state :process-environment))
-             (rust-src-path-used
-              (--first (s-prefix-p "RUST_SRC_PATH=" it) process-environment))
-             (cargo-home-used
-              (--first (s-prefix-p "CARGO_HOME=" it) process-environment))
-             (stdout (plist-get racer--prev-state :stdout))
-             (stderr (plist-get racer--prev-state :stderr)))
-        (insert
-         ;; Summarise the actual command that we run.
-         (racer--header "The last racer command was:\n\n")
-         (format "$ cd %s\n"
-                 (plist-get racer--prev-state :default-directory))
-         (format "$ export %s\n" cargo-home-used)
-         (format "$ export %s\n" rust-src-path-used)
-         (format "$ %s %s\n\n"
-                 (plist-get racer--prev-state :program)
-                 (s-join " " (plist-get racer--prev-state :args)))
-
-         ;; Describe the exit code and outputs.
-         (racer--header
-          (format "This command terminated with exit code %s.\n\n"
-                  (plist-get racer--prev-state :exit-code)))
-         (if (s-blank? stdout)
-             (racer--header "No output on stdout.\n\n")
-           (format "%s\n\n%s\n\n"
-                   (racer--header "stdout:")
-                   (s-trim-right stdout)))
-         (if (s-blank? stderr)
-             (racer--header "No output on stderr.\n\n")
-           (format "%s\n\n%s\n\n"
-                   (racer--header "stderr:")
-                   (s-trim-right stderr)))
-
-         ;; Give copy-paste instructions for reproducing any errors
-         ;; the user has seen.
-         (racer--header
-          (s-word-wrap 60 "The temporary file will have been deleted. You should be able to reproduce the same output from racer with the following command:\n\n"))
-         (format "$ %s %s %s %s\n\n" cargo-home-used rust-src-path-used
-                 (plist-get racer--prev-state :program)
-                 (s-join " "
-                         (-drop-last 1 (plist-get racer--prev-state :args))))
-
-         ;; Tell the user what to do next if they have problems.
-         (racer--header "Please report bugs ")
-         (racer--url-button "on GitHub" "https://github.com/racer-rust/emacs-racer/issues/new")
-         (racer--header "."))))
-    (switch-to-buffer buf)
-    (goto-char (point-min))))
-
-(defun racer--call (command &rest args)
-  "Call racer command COMMAND with args ARGS.
-Return stdout if COMMAND exits normally, otherwise show an
-error."
-  (let ((rust-src-path (or (when racer-rust-src-path (expand-file-name racer-rust-src-path))
-                           (getenv "RUST_SRC_PATH")))
-        (cargo-home (or (when racer-cargo-home (expand-file-name racer-cargo-home))
-                        (getenv "CARGO_HOME"))))
-    (when (null rust-src-path)
-      (user-error "You need to set `racer-rust-src-path' or `RUST_SRC_PATH'"))
-    (unless (file-exists-p rust-src-path)
-      (user-error "No such directory: %s. Please set `racer-rust-src-path' or `RUST_SRC_PATH'"
-                  rust-src-path))
-    (let ((default-directory (or (racer--cargo-project-root) default-directory))
-          (process-environment (append (list
-                                        (format "RUST_SRC_PATH=%s" rust-src-path)
-                                        (format "CARGO_HOME=%s" cargo-home))
-                                       process-environment)))
-      (-let [(exit-code stdout _stderr)
-             (racer--shell-command racer-cmd (cons command args))]
-        ;; Use `equal' instead of `zero' as exit-code can be a string
-        ;; "Aborted" if racer crashes.
-        (unless (equal 0 exit-code)
-          (user-error "%s exited with %s. `M-x racer-debug' for more info"
-                      racer-cmd exit-code))
-        stdout))))
-
-(defmacro racer--with-temporary-file (path-sym &rest body)
-  "Create a temporary file, and bind its path to PATH-SYM.
-Evaluate BODY, then delete the temporary file."
-  (declare (indent 1) (debug (symbolp body)))
-  `(let ((,path-sym (make-temp-file "racer")))
-     (unwind-protect
-         (progn ,@body)
-       (delete-file ,path-sym))))
-
-(defun racer--slurp (file)
-  "Return the contents of FILE as a string."
-  (with-temp-buffer
-    (insert-file-contents-literally file)
-    (buffer-string)))
-
-(defmacro racer--with-temp-buffers (stdout-sym stderr-sym &rest body)
-  (declare (indent 2) (debug (symbolp body)))
-  `(let ((kill-buffer-query-functions nil)
-         (,stdout-sym (generate-new-buffer " *racer-stdout*"))
-         (,stderr-sym (generate-new-buffer " *racer-stderr*")))
-     (unwind-protect
-         (progn ,@body)
-       (when (buffer-name ,stdout-sym)
-         (kill-buffer ,stdout-sym))
-       (when (buffer-name ,stderr-sym)
-         (kill-buffer ,stderr-sym)))))
-
-(defcustom racer-command-timeout nil
-  "Abandon completion if racer process fails to respond for that
-many seconds (maybe float). nil means wait indefinitely."
-  :type 'number
-  :group 'racer)
-
-(defun racer--shell-command (program args)
-  "Execute PROGRAM with ARGS. Return a list (exit-code stdout
-stderr)."
-  (racer--with-temp-buffers stdout stderr
-    (let (exit-code
-          stdout-result
-          stderr-result
-          (proc (make-process :name "*async-racer*"
-                              :buffer stdout
-                              :command (cons program args)
-                              :connection-type 'pipe
-                              :stderr stderr)))
-      (while
-          (and (process-live-p proc)
-               (with-local-quit
-                 (accept-process-output proc racer-command-timeout))))
-      (when (process-live-p proc) (kill-process proc))
-      (setq exit-code (process-exit-status proc)
-            stderr-result (with-current-buffer stderr (buffer-string))
-            stdout-result (with-current-buffer stdout (buffer-string)))
-      (setq racer--prev-state
-            (list
-             :program program
-             :args args
-             :exit-code exit-code
-             :stdout stdout-result
-             :stderr stderr-result
-             :default-directory default-directory
-             :process-environment process-environment))
-      (list exit-code stdout-result stderr-result))))
-
-
-(defun racer--call-at-point (command)
-  "Call racer command COMMAND at point of current buffer.
-Return a list of all the lines returned by the command."
-  (racer--with-temporary-file tmp-file
-    (write-region nil nil tmp-file nil 'silent)
-    (let ((racer-args (list
-                       command
-                       (number-to-string (line-number-at-pos))
-                       (number-to-string (racer--current-column)))))
-      ;; If this buffer is backed by a file, pass that to racer too.
-      (-when-let (file-name (buffer-file-name (buffer-base-buffer)))
-        (setq racer-args
-              (append racer-args (list file-name))))
-
-      (setq racer-args (append racer-args (list tmp-file)))
-      (s-lines
-       (s-trim-right
-        (apply #'racer--call racer-args))))))
-
-(defun racer--read-rust-string (string)
-  "Convert STRING, a rust string literal, to an elisp string."
-  (when string
-    ;; Remove outer double quotes.
-    (setq string (s-chop-prefix "\"" string))
-    (setq string (s-chop-suffix "\"" string))
-    ;; Translate escape sequences.
-    (replace-regexp-in-string
-     (rx "\\" (group anything))
-     (lambda (whole-match)
-       (let ((escaped-char (match-string 1 whole-match)))
-         (if (equal escaped-char "n")
-             "\n"
-           escaped-char)))
-     string
-     t t)))
-
-(defun racer--split-parts (raw-output)
-  "Given RAW-OUTPUT from racer, split on semicolons and doublequotes.
-Unescape strings as necessary."
-  (let ((parts nil)
-        (current "")
-        (i 0))
-    (while (< i (length raw-output))
-      (let ((char (elt raw-output i))
-            (prev-char (and (> i 0) (elt raw-output (1- i)))))
-        (cond
-         ;; A semicolon that wasn't escaped, start a new part.
-         ((and (equal char ?\;) (not (equal prev-char ?\\)))
-          (push current parts)
-          (setq current ""))
-         (t
-          (setq current (concat current (string char))))))
-      (setq i (1+ i)))
-    (push current parts)
-    (mapcar #'racer--read-rust-string (nreverse parts))))
-
-(defun racer--split-snippet-match (line)
-  "Given LINE, a string \"MATCH ...\" from complete-with-snippet,
-split it into its constituent parts."
-  (let* ((match-parts (racer--split-parts line))
-         (docstring (nth 7 match-parts)))
-    (when (and match-parts (equal (length match-parts) 8))
-      (list :name (s-chop-prefix "MATCH " (nth 0 match-parts))
-            :line (string-to-number (nth 2 match-parts))
-            :column (string-to-number (nth 3 match-parts))
-            :path (nth 4 match-parts)
-            ;; Struct or Function:
-            :kind (nth 5 match-parts)
-            :signature (nth 6 match-parts)
-            :docstring (if (> (length docstring) 0) docstring nil)))))
-
-(defun racer--order-descriptions (descriptions)
-  (sort descriptions
-        (lambda (a b)
-          (let ((a (or (plist-get a :docstring) ""))
-                (b (or (plist-get b :docstring) "")))
-            (> (length a) (length b))))))
-
-(defun racer--describe-at-point (name)
-  "Get a descriptions of the symbols matching symbol at point and
-NAME.  If there are multiple possibilities with this NAME, prompt
-the user to choose.  Return a list of all possibilities that
-start with the user's selection."
-  (let* ((output-lines (save-excursion
-                         ;; Move to the end of the current symbol, to
-                         ;; increase racer accuracy.
-                         (skip-syntax-forward "w_")
-                         (racer--call-at-point "complete-with-snippet")))
-         (all-matches (--map (when (s-starts-with-p "MATCH " it)
-                               (racer--split-snippet-match it))
-                             output-lines))
-         (relevant-matches (--filter (equal (plist-get it :name) name)
-                                     all-matches)))
-    (racer--order-descriptions
-     (if (> (length relevant-matches) 1)
-         ;; We might have multiple matches with the same name but
-         ;; different types. E.g. Vec::from.
-         (let ((signature
-                (completing-read "Multiple matches: "
-                                 (--map (plist-get it :signature) relevant-matches))))
-           (-filter
-            (lambda (x)
-              (let ((sig (plist-get x :signature)))
-                (equal (substring sig 0 (min (length sig) (length signature)))
-                       signature)))
-            relevant-matches))
-       relevant-matches))))
-
-(defun racer--help-buf (contents)
-  "Create a *Racer Help* buffer with CONTENTS."
-  (let ((buf (get-buffer-create "*Racer Help*"))
-        ;; If the buffer already existed, we need to be able to
-        ;; override `buffer-read-only'.
-        (inhibit-read-only t))
-    (with-current-buffer buf
-      (erase-buffer)
-      (insert contents)
-      (setq buffer-read-only t)
-      (goto-char (point-min))
-      (racer-help-mode))
-    buf))
-
-(defface racer-help-heading-face
-  '((t :weight bold))
-  "Face for markdown headings in *Racer Help* buffers.")
-
-(defun racer--url-p (target)
-  "Return t if TARGET looks like a fully qualified URL."
-  (not (null
-        (string-match-p (rx bol "http" (? "s") "://") target))))
-
-(defun racer--propertize-links (markdown)
-  "Propertize links in MARKDOWN."
-  (replace-regexp-in-string
-   ;; Text of the form [foo](http://example.com)
-   (rx "[" (group (+? (not (any "]")))) "](" (group (+? anything)) ")")
-   ;; For every match:
-   (lambda (whole-match)
-     ;; Extract link and target.
-     (let ((link-text (match-string 1 whole-match))
-           (link-target (match-string 2 whole-match)))
-       ;; If it's a web URL, use a clickable link.
-       (if (racer--url-p link-target)
-           (racer--url-button link-text link-target)
-         ;; Otherwise, just discard the target.
-         link-text)))
-   markdown
-   t t))
-
-(defun racer--propertize-all-inline-code (markdown)
-  "Given a single line MARKDOWN, replace all instances of `foo` or
-\[`foo`\] with a propertized string."
-  (let ((highlight-group
-         (lambda (whole-match)
-           (racer--syntax-highlight (match-string 1 whole-match)))))
-    (setq markdown
-          (replace-regexp-in-string
-           (rx "[`" (group (+? anything)) "`]")
-           highlight-group
-           markdown
-           t t))
-    (setq markdown
-          (replace-regexp-in-string
-           (rx "`" (group (+? anything)) "`")
-           highlight-group
-           markdown
-           t t))))
-
-(defun racer--indent-block (str)
-  "Indent every line in STR."
-  (s-join "\n" (--map (concat "    " it) (s-lines str))))
-
-(defun racer--trim-newlines (str)
-  "Remove newlines from the start and end of STR."
-  (->> str
-       (s-chop-prefix "\n")
-       (s-chop-suffix "\n")))
-
-(defun racer--remove-footnote-links (str)
-  "Remove footnote links from markdown STR."
-  (->> (s-lines str)
-       (--remove (string-match-p (rx bol "[`" (+? anything) "`]: ") it))
-       (s-join "\n")
-       ;; Collapse consecutive blank lines caused by removing footnotes.
-       (s-replace "\n\n\n" "\n\n")))
-
-(defun racer--docstring-sections (docstring)
-  "Split DOCSTRING into text, code and heading sections."
-  (let* ((sections nil)
-         (current-section-lines nil)
-         (section-type :text)
-         ;; Helper function.
-         (finish-current-section
-          (lambda ()
-            (when current-section-lines
-              (let ((current-section
-                     (s-join "\n" (nreverse current-section-lines))))
-                (unless (s-blank? current-section)
-                  (push (list section-type current-section) sections))
-                (setq current-section-lines nil))))))
-    (dolist (line (s-lines docstring))
-      (cond
-       ;; If this is a closing ```
-       ((and (s-starts-with-p "```" line) (eq section-type :code))
-        (push line current-section-lines)
-        (funcall finish-current-section)
-        (setq section-type :text))
-       ;; If this is an opening ```
-       ((s-starts-with-p "```" line)
-        (funcall finish-current-section)
-        (push line current-section-lines)
-        (setq section-type :code))
-       ;; Headings
-       ((and (not (eq section-type :code)) (s-starts-with-p "# " line))
-        (funcall finish-current-section)
-        (push (list :heading line) sections))
-       ;; Normal text.
-       (t
-        (push line current-section-lines))))
-    (funcall finish-current-section)
-    (nreverse sections)))
-
-(defun racer--clean-code-section (section)
-  "Given a SECTION, a markdown code block, remove
-fenced code delimiters and code annotations."
-  (->> (s-lines section)
-       (-drop 1)
-       (-drop-last 1)
-       ;; Ignore annotations like # #[allow(dead_code)]
-       (--remove (s-starts-with-p "# " it))
-       (s-join "\n")))
-
-(defun racer--propertize-docstring (docstring)
-  "Replace markdown syntax in DOCSTRING with text properties."
-  (let* ((sections (racer--docstring-sections docstring))
-         (propertized-sections
-          (--map (-let [(section-type section) it]
-                   ;; Remove trailing newlines, so we can ensure we
-                   ;; have consistent blank lines between sections.
-                   (racer--trim-newlines
-                    (pcase section-type
-                      (:text
-                       (racer--propertize-all-inline-code
-                        (racer--propertize-links
-                         (racer--remove-footnote-links
-                          section))))
-                      (:code
-                       (racer--indent-block
-                        (racer--syntax-highlight
-                         (racer--clean-code-section section))))
-                      (:heading
-                       (racer--header
-                        (s-chop-prefix "# " section))))))
-                 sections)))
-    (s-join "\n\n" propertized-sections)))
-
-(defun racer--find-file (path line column find-file-func)
-  "Open PATH and move point to LINE and COLUMN."
-  (funcall find-file-func path)
-  (goto-char (point-min))
-  (forward-line (1- line))
-  (forward-char column))
-
-(defun racer--button-go-to-src (button)
-  (racer--find-file
-   (button-get button 'path)
-   (button-get button 'line)
-   (button-get button 'column)
-   #'find-file))
-
-(define-button-type 'racer-src-button
-  'action 'racer--button-go-to-src
-  'follow-link t
-  'help-echo "Go to definition")
-
-(defun racer--url-button (text url)
-  "Return a button that opens a browser at URL."
-  (with-temp-buffer
-    (insert-text-button
-     text
-     :type 'help-url
-     'help-args (list url))
-    (buffer-string)))
-
-(defun racer--src-button (path line column)
-  "Return a button that navigates to PATH at LINE number and
-COLUMN number."
-  ;; Convert "/foo/bar/baz/foo.rs" to "baz/foo.rs"
-  (let* ((filename (f-filename path))
-         (parent-dir (f-filename (f-parent path)))
-         (short-path (f-join parent-dir filename)))
-    (with-temp-buffer
-      (insert-text-button
-       short-path
-       :type 'racer-src-button
-       'path path
-       'line line
-       'column column)
-      (buffer-string))))
-
-(defun racer--kind-description (raw-kind)
-  "Human friendly description of a rust kind.
-For example, 'EnumKind' -> 'an enum kind'."
-  (let* ((parts (s-split-words raw-kind))
-         (description (s-join " " (--map (downcase it) parts)))
-         (a (if (string-match-p (rx bos (or "a" "e" "i" "o" "u")) description)
-                "an" "a")))
-    (format "%s %s" a description)))
-
-(defun racer--describe (name)
-  "Return a *Racer Help* buffer for the function or type at point.
-If there are multiple candidates at point, use NAME to find the
-correct value."
-  (let ((descriptions (racer--describe-at-point name)))
-    (when descriptions
-      (racer--help-buf
-       (let ((output "")
-             (first-iteration t))
-         (dolist (description descriptions output)
-           (unless first-iteration
-             (setf output
-                   (concat output (format "\n---------------------------------------------------------------\n"))))
-           (setf output
-                 (concat
-                  output
-                  (let* ((name (plist-get description :name))
-                         (raw-docstring (plist-get description :docstring))
-                         (docstring (if raw-docstring
-                                        (racer--propertize-docstring raw-docstring)
-                                      "Not documented."))
-                         (kind (plist-get description :kind)))
-                    (setf first-iteration nil)
-                    (format
-                     "%s is %s defined in %s.\n\n%s%s"
-                     name
-                     (racer--kind-description kind)
-                     (racer--src-button
-                      (plist-get description :path)
-                      (plist-get description :line)
-                      (plist-get description :column))
-                     (if (equal kind "Module")
-                         ;; No point showing the 'signature' of modules, which is
-                         ;; just their full path.
-                         ""
-                       (format "    %s\n\n" (racer--syntax-highlight (plist-get description :signature))))
-                     docstring))))))))))
-
-(defun racer-describe ()
-  "Show a *Racer Help* buffer for the function or type at point."
-  (interactive)
-  (let ((buf (racer--describe (thing-at-point 'symbol))))
-    (if buf
-        (temp-buffer-window-show buf)
-      (user-error "No function or type found at point"))))
-
-(defface racer-tooltip
-  '((((min-colors 16777216))
-     :background "#292C33" :foreground "white")
-    (t
-     :background "black" :foreground "white"))
-  "Face used for the tooltip with `racer-describe-tooltip'")
-
-(defun racer-describe-tooltip ()
-  "Show the docstring in a tooltip.
-The tooltip's face is `racer-tooltip'
-See `racer-describe'."
-  (interactive)
-  (-some-> (symbol-at-point)
-           (symbol-name)
-           (racer--describe)
-           (with-current-buffer (concat "\n" (buffer-string) "\n\n"))
-           (pos-tip-show-no-propertize 'racer-tooltip nil nil 1000)))
-
-(defvar racer-help-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map (make-composed-keymap button-buffer-map
-                                                 special-mode-map))
-    map)
-  "Keymap for racer help mode.")
-
-(define-derived-mode racer-help-mode fundamental-mode
-  "Racer-Help"
-  "Major mode for *Racer Help* buffers.
-
-Commands:
-\\{racer-help-mode-map}")
-
-(defcustom racer-complete-in-comments
-  nil
-  "If non-nil, query racer for completions inside comments too."
-  :type 'boolean
-  :group 'racer)
-
-(defcustom racer-complete-insert-argument-placeholders
-  t
-  "If non-nil, insert argument placeholders after completion.
-Note that this feature is only available when `company-mode' is installed."
-  :type 'boolean
-  :group 'racer)
-
-(defun racer-complete-at-point ()
-  "Complete the symbol at point."
-  (let* ((ppss (syntax-ppss))
-         (in-string (nth 3 ppss))
-         (in-comment (nth 4 ppss)))
-    (when (and
-           (not in-string)
-           (or (not in-comment) racer-complete-in-comments))
-      (let* ((bounds (bounds-of-thing-at-point 'symbol))
-             (beg (or (car bounds) (point)))
-             (end (or (cdr bounds) (point))))
-        (list beg end
-              (completion-table-dynamic #'racer-complete)
-              :annotation-function #'racer-complete--annotation
-              :company-prefix-length (racer-complete--prefix-p beg end)
-              :company-docsig #'racer-complete--docsig
-              :company-doc-buffer #'racer--describe
-              :company-location #'racer-complete--location
-	      :exit-function #'racer-complete--insert-args)))))
-
-(declare-function company-template-c-like-templatify 'company-template)
-
-(defun racer-complete--insert-args (arg &optional _finished)
-  "If a ARG is the name of a completed function, try to find and insert its arguments."
-  (when (and racer-complete-insert-argument-placeholders
-             (require 'company-template nil t)
-             (equal "Function"
-                    (get-text-property 0 'matchtype arg))
-             ;; Don't add arguments if the user has already added
-             ;; some.
-             (not (eq (char-after) ?\()))
-    (let* ((ctx (get-text-property 0 'ctx arg))
-	   (arguments (racer-complete--extract-args ctx)))
-      (insert arguments)
-      (company-template-c-like-templatify arguments))))
-
-(defun racer-complete--extract-args (str)
-  "Extract function arguments from STR (excluding a possible self argument)."
-  (string-match
-   (rx
-    (or (seq "(" (zero-or-more (not (any ","))) "self)")
-	(seq "("
-	     (zero-or-more (seq (zero-or-more (not (any "(")))
-				"self"
-				(zero-or-more space)
-				","))
-	     (zero-or-more space)
-	     (group (zero-or-more (not (any ")"))))
-	     ")")))
-   str)
-  (let ((extract (match-string 1 str)))
-    (if extract
-	(format "(%s)" extract)
-      "()")))
-
-(defun racer--file-and-parent (path)
-  "Convert /foo/bar/baz/q.txt to baz/q.txt."
-  (let ((file (f-filename path))
-        (parent (f-filename (f-parent path))))
-    (f-join parent file)))
-
-(defun racer-complete (&optional _ignore)
-  "Completion candidates at point."
-  (->> (racer--call-at-point "complete")
-       (--filter (s-starts-with? "MATCH" it))
-       (--map (-let [(name line col file matchtype ctx)
-                     (s-split-up-to "," (s-chop-prefix "MATCH " it) 5)]
-                (put-text-property 0 1 'line (string-to-number line) name)
-                (put-text-property 0 1 'col (string-to-number col) name)
-                (put-text-property 0 1 'file file name)
-                (put-text-property 0 1 'matchtype matchtype name)
-                (put-text-property 0 1 'ctx ctx name)
-                name))))
-
-(defun racer--trim-up-to (needle s)
-  "Return content after the occurrence of NEEDLE in S."
-  (-if-let (idx (s-index-of needle s))
-      (substring s (+ idx (length needle)))
-    s))
-
-(defun racer-complete--prefix-p (beg _end)
-  "Return t if a completion should be triggered for a prefix between BEG and END."
-  (save-excursion
-    (goto-char beg)
-    ;; If we're at the beginning of the buffer, we can't look back 2
-    ;; characters.
-    (ignore-errors
-      (looking-back "\\.\\|::" 2))))
-
-(defun racer-complete--annotation (arg)
-  "Return an annotation for completion candidate ARG."
-  (let* ((ctx (get-text-property 0 'ctx arg))
-         (type (get-text-property 0 'matchtype arg))
-         (pretty-ctx
-          (pcase type
-            ("Module"
-             (if (string= arg ctx)
-                 ""
-               (concat " " (racer--file-and-parent ctx))))
-	    ("StructField"
-	     (concat " " ctx))
-            (_
-             (->> ctx
-                  (racer--trim-up-to arg)
-                  (s-chop-suffixes '(" {" "," ";")))))))
-    (format "%s : %s" pretty-ctx type)))
-
-(defun racer-complete--docsig (arg)
-  "Return a signature for completion candidate ARG."
-  (racer--syntax-highlight (format "%s" (get-text-property 0 'ctx arg))))
-
-(defun racer-complete--location (arg)
-  "Return location of completion candidate ARG."
-  (cons (get-text-property 0 'file arg)
-        (get-text-property 0 'line arg)))
-
-(defun racer--current-column ()
-  "Get the current column based on underlying character representation."
-  (length (buffer-substring-no-properties
-           (line-beginning-position) (point))))
-
-
-(defun racer--find-definition(find-file-func)
-  (-if-let (match (--first (s-starts-with? "MATCH" it)
-                           (racer--call-at-point "find-definition")))
-      (-let [(_name line col file _matchtype _ctx)
-             (s-split-up-to "," (s-chop-prefix "MATCH " match) 5)]
-        (if (fboundp 'xref-push-marker-stack)
-            (xref-push-marker-stack)
-          (with-no-warnings
-            (ring-insert find-tag-marker-ring (point-marker))))
-        (racer--find-file file (string-to-number line) (string-to-number col) find-file-func))
-    (error "No definition found")))
-
-;;;###autoload
-(defun racer-find-definition ()
-  "Run the racer find-definition command and process the results."
-  (interactive)
-  (racer--find-definition #'find-file))
-
-;;;###autoload
-(defun racer-find-definition-other-window ()
-  "Run the racer find-definition command and process the results."
-  (interactive)
-  (racer--find-definition #'find-file-other-window))
-
-;;;###autoload
-(defun racer-find-definition-other-frame ()
-  "Run the racer find-definition command and process the results."
-  (interactive)
-  (racer--find-definition #'find-file-other-frame))
-
-(defun racer--syntax-highlight (str)
-  "Apply font-lock properties to a string STR of Rust code."
-  (let (result)
-    ;; Load all of STR in a rust-mode buffer, and use its
-    ;; highlighting.
-    (with-temp-buffer
-      (insert str)
-      (delay-mode-hooks (rust-mode))
-      (if (fboundp 'font-lock-ensure)
-          (font-lock-ensure)
-        (with-no-warnings
-          (font-lock-fontify-buffer)))
-      (setq result (buffer-string)))
-
-    ;; If we haven't applied any text properties yet, apply some
-    ;; heuristics to try to find an appropriate colour.
-    (when (null (text-properties-at 0 result))
-      (cond
-       ;; If it's a standalone symbol, then assume it's a
-       ;; variable.
-       ((string-match-p (rx bos (+ (any lower "_")) eos) str)
-        (setq result (propertize str 'face 'font-lock-variable-name-face)))
-       ;; If it starts with a backslash, treat it as a string. See
-       ;; .lines() on strings.
-       ((string-match-p (rx bos "\\") str)
-        (setq result (propertize str 'face 'font-lock-string-face)))))
-
-    result))
-
-(defun racer--goto-func-name ()
-  "If point is inside a function call, move to the function name.
-
-foo(bar, |baz); -> foo|(bar, baz);"
-  (let ((last-paren-pos (nth 1 (syntax-ppss)))
-        (start-pos (point)))
-    (when last-paren-pos
-      ;; Move to just before the last paren.
-      (goto-char last-paren-pos)
-      ;; If we're inside a round paren, we're inside a function call.
-      (unless (looking-at "(")
-        ;; Otherwise, return to our start position, as point may have been on a
-        ;; function already:
-        ;; foo|(bar, baz);
-        (goto-char start-pos)))))
-
-(defun racer--relative (path &optional directory)
-  "Return PATH relative to DIRECTORY (`default-directory' by default).
-If PATH is not in DIRECTORY, just abbreviate it."
-  (unless directory
-    (setq directory default-directory))
-  (if (s-starts-with? directory path)
-      (concat "./" (f-relative path directory))
-    (f-abbrev path)))
-
-(defcustom racer-eldoc-timeout 0.5
-  "Abandon Eldoc hinting if racer process fails to respond for
-that many seconds (maybe float)."
-  :type 'number
-  :group 'racer)
-
-(defun racer-eldoc ()
-  "Show eldoc for context at point."
-  (save-excursion
-    (racer--goto-func-name)
-    ;; If there's a variable at point:
-    (-when-let* ((rust-sym (symbol-at-point))
-                 (comp-possibilities (let ((racer-command-timeout racer-eldoc-timeout))
-                                       (racer-complete)))
-                 (matching-possibility
-                  (--find (string= it (symbol-name rust-sym)) comp-possibilities))
-                 (prototype (get-text-property 0 'ctx matching-possibility))
-                 (matchtype (get-text-property 0 'matchtype matching-possibility)))
-      (if (equal matchtype "Module")
-          (racer--relative prototype)
-        ;; Syntax highlight function signatures.
-        (racer--syntax-highlight prototype)))))
-
-(defvar racer-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "M-.") #'racer-find-definition)
-    (define-key map (kbd "C-x 4 .") #'racer-find-definition-other-window)
-    (define-key map (kbd "C-x 5 .") #'racer-find-definition-other-frame)
-    (define-key map (kbd "M-,") #'pop-tag-mark)
-    map))
-
-;;;###autoload
-(define-minor-mode racer-mode
-  "Minor mode for racer."
-  :lighter " racer"
-  :keymap racer-mode-map
-  (setq-local eldoc-documentation-function #'racer-eldoc)
-  (set (make-local-variable 'completion-at-point-functions) nil)
-  (add-hook 'completion-at-point-functions #'racer-complete-at-point))
-
-(define-obsolete-function-alias 'racer-turn-on-eldoc 'eldoc-mode)
-(define-obsolete-function-alias 'racer-activate 'racer-mode)
-
-(provide 'racer)
-;;; racer.el ends here