          (let ((elength (length ending)))
            (string= (substring s (- 0 elength)) ending)))
         (t nil)))
+
 
 (defun racer-find-definition ()
   "Run the racer find-definition command and process the results."

	  (forward-char (string-to-number charnum))
	  )))))

(add-hook 'rust-mode-hook
	  '(lambda ()
	     (company-mode)
	     (set (make-local-variable 'company-backends) '(racer-company-complete))
	     (local-set-key "\t" 'racer--complete-or-indent)
	     (local-set-key "\M-." 'racer-find-definition)
	     (setq-local company-idle-delay nil)
	     )
	  nil)

(provide 'racer)
;;; racer.el ends here

    (setq racer-line-number (racer-get-line-number))
    (setq racer-column-number (current-column))
    (setq racer-completion-results `())
    (write-region nil nil tmp-file-name nil -1))

(defun racer--candidates ()
  "Run the racer complete command and process the results."
  (setq racer-tmp-file-name (concat (buffer-file-name) ".racertmp"))
  (racer--write-tmp-file racer-tmp-file-name)
  (setenv "RUST_SRC_PATH" (expand-file-name racer-rust-src-path))
  (let ((lines (process-lines racer-cmd
                              "complete"
                              (number-to-string racer-line-number)
                              (number-to-string racer-column-number)
                              racer-tmp-file-name)))
    (delete-file racer-tmp-file-name)
    (dolist (line lines)
      (when (string-match "^MATCH \\([^,]+\\),\\([^,]+\\),\\([^,]+\\),\\([^,]+\\),\\([^,]+\\),\\(.+\\)$" line)
        (let ((completion (match-string 1 line))
              (linenum (match-string 2 line))
              (colnum (match-string 3 line))
              (fname (match-string 4 line))
              (matchtype (match-string 5 line))
              (contextstr (match-string 6 line)))
          (put-text-property 0 1 'contextstr contextstr completion)
          (put-text-property 0 1 'matchtype matchtype completion)
          (put-text-property 0 1 'fname fname completion)
          (put-text-property 0 1 'linenum linenum completion)
          (push completion racer-completion-results))))
    racer-completion-results))

(defun racer--company-prefix ()
  "Returns the symbol to complete. If racer-begin-after-member-access is t,
begins completion automatically if the cursor is followed by a dot or ::."
  (if racer-begin-after-member-access
    (company-grab-symbol-cons "\\.\\|::" 2)
    (company-grab-symbol)))

(defun racer--company-annotation (arg)
  "Gets and formats annotation data from the arg match."
  (let ((meta (get-text-property 0 'contextstr arg)))
    (format "%10s : %s"
            (or (save-match-data
                  (and (string-match "\\(.+\\) {" meta)
                       (match-string 1 meta)))
                meta)
            (get-text-property 0 'matchtype arg))))

(defun racer--company-location (arg)
  (let ((fname (get-text-property 0 'fname arg))
        (linenum (get-text-property 0 'linenum arg)))
    (cons fname (string-to-number linenum))))


(defun string/ends-with (s ending)
  "Return non-nil if string S ends with ENDING."
