branch: elpa/magit
commit b377adb68c8d124d6d6ef1cba21ac7862c6cb1c3
Author: Jonas Bernoulli <[email protected]>
Commit: Jonas Bernoulli <[email protected]>
Use shorthand match-str instead of match-string-no-properties
Almost always would it be better to use `match-string-no-properties'
instead of `match-string', but because the name of the former is
excruciatingly long for a function that one often wants to use in
tight spaces and because it usually "does not really matter", I
usually went for the latter.
The problem is, it does matter. For example, even strings that are
usually only used by code may end up obfuscating debug statements.
So let's start doing the right thing, even though there surely will
be people frowning at the use of a shorthand.
The fake ("match-string" "match-string") shorthand is necessary to
protect literal `match-string' and `match-string-no-properties' from
being corrupted by interpreted as shorthand for the non-existent
`match-stringing' and `match-string-no-propertiesing'.
Unfortunately the shorthands have to be specified in each library
individually. Using "dir-locals.el" only works if the libraries
are compiled. At least this additional noise is neatly tucked away
at the end of the files.
It might turn out that out of the more than two hundred instances
where this replaces `match-string' with `match-string-no-properties'
we should have stuck with the former in an instance or two. That's
the price of progress and can be fixed once such regressions are
reported.
---
lisp/git-commit.el | 15 ++++---
lisp/git-rebase.el | 21 ++++++----
lisp/magit-apply.el | 15 ++++---
lisp/magit-autorevert.el | 5 +++
lisp/magit-base.el | 15 ++++---
lisp/magit-bisect.el | 9 +++-
lisp/magit-blame.el | 23 +++++++----
lisp/magit-bookmark.el | 5 +++
lisp/magit-branch.el | 15 ++++---
lisp/magit-bundle.el | 5 +++
lisp/magit-clone.el | 9 +++-
lisp/magit-commit.el | 7 +++-
lisp/magit-core.el | 5 +++
lisp/magit-diff.el | 95 +++++++++++++++++++++++--------------------
lisp/magit-dired.el | 5 +++
lisp/magit-ediff.el | 5 +++
lisp/magit-extras.el | 9 +++-
lisp/magit-fetch.el | 5 +++
lisp/magit-files.el | 5 +++
lisp/magit-git.el | 83 +++++++++++++++++++------------------
lisp/magit-gitignore.el | 5 +++
lisp/magit-log.el | 19 +++++----
lisp/magit-margin.el | 5 +++
lisp/magit-merge.el | 5 +++
lisp/magit-mode.el | 5 +++
lisp/magit-notes.el | 7 +++-
lisp/magit-patch.el | 5 +++
lisp/magit-process.el | 19 +++++----
lisp/magit-pull.el | 5 +++
lisp/magit-push.el | 5 +++
lisp/magit-reflog.el | 11 +++--
lisp/magit-refs.el | 17 +++++---
lisp/magit-remote.el | 9 +++-
lisp/magit-repos.el | 11 +++--
lisp/magit-reset.el | 5 +++
lisp/magit-section.el | 5 +++
lisp/magit-sequence.el | 7 +++-
lisp/magit-sparse-checkout.el | 5 +++
lisp/magit-stash.el | 5 +++
lisp/magit-status.el | 5 +++
lisp/magit-submodule.el | 15 ++++---
lisp/magit-subtree.el | 5 +++
lisp/magit-tag.el | 13 ++++--
lisp/magit-transient.el | 5 +++
lisp/magit-wip.el | 7 +++-
lisp/magit-worktree.el | 5 +++
lisp/magit.el | 7 +++-
test/magit-tests.el | 7 +++-
48 files changed, 409 insertions(+), 171 deletions(-)
diff --git a/lisp/git-commit.el b/lisp/git-commit.el
index 45b1eb82d4f..6c5975f5584 100644
--- a/lisp/git-commit.el
+++ b/lisp/git-commit.el
@@ -718,15 +718,15 @@ conventions are checked."
(save-excursion
(goto-char (point-min))
(re-search-forward (git-commit-summary-regexp) nil t)
- (if (equal (match-string 1) "")
+ (if (equal (match-str 1) "")
t ; Just try; we don't know whether --allow-empty-message was used.
(and (or (not (memq 'overlong-summary-line
git-commit-style-convention-checks))
- (equal (match-string 2) "")
+ (equal (match-str 2) "")
(y-or-n-p "Summary line is too long. Commit anyway? "))
(or (not (memq 'non-empty-second-line
git-commit-style-convention-checks))
- (not (match-string 3))
+ (not (match-str 3))
(y-or-n-p "Second line is not empty. Commit anyway?
")))))))
(defun git-commit-cancel-message ()
@@ -950,8 +950,8 @@ completion candidates. The input must have the form \"NAME
<EMAIL>\"."
nil nil nil 'git-commit-read-ident-history)))
(save-match-data
(if (string-match "\\`\\([^<]+\\) *<\\([^>]+\\)>\\'" str)
- (list (save-match-data (string-trim (match-string 1 str)))
- (string-trim (match-string 2 str)))
+ (list (save-match-data (string-trim (match-str 1 str)))
+ (string-trim (match-str 2 str)))
(user-error "Invalid input")))))
(defun git-commit--insert-ident-trailer (trailer name email)
@@ -1218,4 +1218,9 @@ Elisp doc-strings, including this one. Unlike in
doc-strings,
"git-commit 4.0.0")
(provide 'git-commit)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; git-commit.el ends here
diff --git a/lisp/git-rebase.el b/lisp/git-rebase.el
index dbcb8535d78..098a29e9d8c 100644
--- a/lisp/git-rebase.el
+++ b/lisp/git-rebase.el
@@ -372,13 +372,13 @@ BATCH also ignores commented lines."
git-rebase-line-regexps)))
(git-rebase-action
:action-type type
- :action (and-let* ((action (match-string-no-properties 1)))
+ :action (and-let* ((action (match-str 1)))
(or (cdr (assoc action git-rebase-short-options))
action))
- :action-options (match-string-no-properties 2)
- :target (match-string-no-properties 3)
- :trailer (match-string-no-properties 5)
- :comment-p (and (match-string 99) t))
+ :action-options (match-str 2)
+ :target (match-str 3)
+ :trailer (match-str 5)
+ :comment-p (and (match-str 99) t))
(and (not batch)
;; Use empty object rather than nil to ease handling.
(git-rebase-action)))))
@@ -591,7 +591,7 @@ remove the label on the current line, if any."
(save-excursion
(goto-char (point-min))
(while (re-search-forward "^\\(?:l\\|label\\) \\([^ \n]+\\)" nil t)
- (push (match-string-no-properties 1) labels)))
+ (push (match-str 1) labels)))
(nreverse labels)))
(defun git-rebase-reset (arg)
@@ -871,11 +871,11 @@ except for the \"pick\" command."
(line (concat git-rebase-comment-re "\\(?:\\( \\.? *\\)\\|"
"\\( +\\)\\([^\n,],\\) \\([^\n ]+\\) \\)")))
(while (re-search-forward line nil t)
- (if (match-string 1)
+ (if (match-str 1)
(if (assq cmd git-rebase-fixup-descriptions)
(delete-line)
(replace-match (make-string 10 ?\s) t t nil 1))
- (setq cmd (intern (concat "git-rebase-" (match-string 4))))
+ (setq cmd (intern (concat "git-rebase-" (match-str 4))))
(cond
((not (fboundp cmd))
(delete-line))
@@ -944,4 +944,9 @@ is used as a value for `imenu-extract-index-name-function'."
;;; _
(provide 'git-rebase)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; git-rebase.el ends here
diff --git a/lisp/magit-apply.el b/lisp/magit-apply.el
index 9a52cc46552..7728b27f6f4 100644
--- a/lisp/magit-apply.el
+++ b/lisp/magit-apply.el
@@ -161,15 +161,15 @@ and only the second and third are to be applied, they
would be
adjusted as \"@@ -10,6 +10,7 @@\" and \"@@ -18,6 +19,7 @@\"."
(let* ((first-hunk (car hunks))
(offset (if (string-match diff-hunk-header-re-unified first-hunk)
- (- (string-to-number (match-string 3 first-hunk))
- (string-to-number (match-string 1 first-hunk)))
+ (- (string-to-number (match-str 3 first-hunk))
+ (string-to-number (match-str 1 first-hunk)))
(error "Header hunks have to be applied individually"))))
(if (= offset 0)
hunks
(mapcar (lambda (hunk)
(if (string-match diff-hunk-header-re-unified hunk)
(replace-match (number-to-string
- (- (string-to-number (match-string 3 hunk))
+ (- (string-to-number (match-str 3 hunk))
offset))
t t hunk 3)
(error "Hunk does not have expected header")))
@@ -218,7 +218,7 @@ adjusted as \"@@ -10,6 +10,7 @@\" and \"@@ -18,6 +19,7
@@\"."
(mapcar (##oref % value) section:s)))
(command (symbol-name this-command))
(command (if (and command (string-match "^magit-\\([^-]+\\)" command))
- (match-string 1 command)
+ (match-str 1 command)
"apply"))
(context (magit-diff-get-context))
(ignore-context (magit-diff-ignore-any-space-p)))
@@ -637,7 +637,7 @@ of a side, then keep that side without prompting."
(?M (let ((temp (magit-git-string "checkout-index" "--temp" file)))
(string-match
(format "\\(.+?\\)\t%s" (regexp-quote file)) temp)
- (rename-file (match-string 1 temp)
+ (rename-file (match-str 1 temp)
(setq temp (concat file ".~{index}~")))
(delete-file temp t))
(magit-call-git "rm" "--cached" "--force" "--" file))
@@ -831,4 +831,9 @@ a separate commit. A typical workflow would be:
;;; _
(provide 'magit-apply)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-apply.el ends here
diff --git a/lisp/magit-autorevert.el b/lisp/magit-autorevert.el
index 3579bf2ead0..6d2f799a002 100644
--- a/lisp/magit-autorevert.el
+++ b/lisp/magit-autorevert.el
@@ -268,4 +268,9 @@ defaults to nil) for any BUFFER."
;;; _
(provide 'magit-autorevert)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-autorevert.el ends here
diff --git a/lisp/magit-base.el b/lisp/magit-base.el
index ed330387186..9c1f9a33527 100644
--- a/lisp/magit-base.el
+++ b/lisp/magit-base.el
@@ -899,7 +899,7 @@ as STRING."
(mapcan (lambda (sym)
(cl-incf i)
(and (not (eq (aref (symbol-name sym) 0) ?_))
- (list (list sym (list 'match-string i s)))))
+ (list (list sym (list 'match-str i s)))))
varlist))
,@body))))
@@ -948,8 +948,8 @@ Pad the left side of STRING so that it aligns with the text
area."
(delete-char 1))
;; Valid format spec.
((looking-at "\\([-0-9.]*\\)\\([a-zA-Z]\\)")
- (let* ((num (match-string 1))
- (spec (string-to-char (match-string 2)))
+ (let* ((num (match-str 1))
+ (spec (string-to-char (match-str 2)))
(val (assq spec specification)))
(unless val
(error "Invalid format character: `%%%c'" spec))
@@ -1087,9 +1087,9 @@ the value in the symbol's `saved-value' property if any,
or
(pcase magit-view-git-manual-method
('info (funcall fn fork))
('man (require 'man)
- (man (match-string 1 node)))
+ (man (match-str 1 node)))
('woman (require 'woman)
- (woman (match-string 1 node)))
+ (woman (match-str 1 node)))
(_ (user-error "Invalid value for `magit-view-git-manual-method'")))
(funcall fn fork))))
@@ -1193,4 +1193,9 @@ Like `message', except that `message-log-max' is bound to
nil."
;;; _
(provide 'magit-base)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-base.el ends here
diff --git a/lisp/magit-bisect.el b/lisp/magit-bisect.el
index 8c737c13c0a..baf1428c0ac 100644
--- a/lisp/magit-bisect.el
+++ b/lisp/magit-bisect.el
@@ -258,7 +258,7 @@ bisect run'."
(pop lines))
(seq-find (##string-match done-re %) lines))))
(magit-insert-section ((eval (if bad-line 'commit 'bisect-output))
- (and bad-line (match-string 1 bad-line)))
+ (and bad-line (match-str 1 bad-line)))
(magit-insert-heading
(propertize (or bad-line (pop lines))
'font-lock-face 'magit-section-heading))
@@ -291,7 +291,7 @@ bisect run'."
(while (progn (setq beg (point-marker))
(re-search-forward
"^\\(\\(?:git bisect\\|# status:\\) [^\n]+\n\\)" nil t))
- (if (string-prefix-p "# status:" (match-string 1))
+ (if (string-prefix-p "# status:" (match-str 1))
(magit-delete-match)
(magit-bind-match-strings (heading) nil
(magit-delete-match)
@@ -315,4 +315,9 @@ bisect run'."
;;; _
(provide 'magit-bisect)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-bisect.el ends here
diff --git a/lisp/magit-blame.el b/lisp/magit-blame.el
index f6a3e335d5f..aa0af7c46b6 100644
--- a/lisp/magit-blame.el
+++ b/lisp/magit-blame.el
@@ -495,22 +495,22 @@ modes is toggled, then this mode also gets toggled
automatically.
(buffer-substring-no-properties (point) (line-end-position))))
(with-slots (orig-rev orig-file prev-rev prev-file)
(setq chunk (magit-blame-chunk
- :orig-rev (match-string 1)
- :orig-line (string-to-number (match-string 2))
- :final-line (string-to-number (match-string 3))
- :num-lines (string-to-number (match-string 4))))
+ :orig-rev (match-str 1)
+ :orig-line (string-to-number (match-str 2))
+ :final-line (string-to-number (match-str 3))
+ :num-lines (string-to-number (match-str 4))))
(forward-line)
(let (done)
(while (not done)
(cond ((looking-at "^filename \\(.+\\)")
(setq done t)
- (setf orig-file (magit-decode-git-path (match-string 1))))
+ (setf orig-file (magit-decode-git-path (match-str 1))))
((looking-at "^previous \\(.\\{40,\\}\\) \\(.+\\)")
- (setf prev-rev (match-string 1))
- (setf prev-file (magit-decode-git-path (match-string 2))))
+ (setf prev-rev (match-str 1))
+ (setf prev-file (magit-decode-git-path (match-str 2))))
((looking-at "^\\([^ ]+\\) \\(.+\\)")
- (push (cons (match-string 1)
- (match-string 2))
+ (push (cons (match-str 1)
+ (match-str 2))
revinfo)))
(forward-line)))
(when (and (eq type 'removal) prev-rev)
@@ -996,4 +996,9 @@ instead of the hash, like `kill-ring-save' would."
;;; _
(provide 'magit-blame)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-blame.el ends here
diff --git a/lisp/magit-bookmark.el b/lisp/magit-bookmark.el
index bbb12151562..5bb1020679f 100644
--- a/lisp/magit-bookmark.el
+++ b/lisp/magit-bookmark.el
@@ -156,4 +156,9 @@
;;; _
(provide 'magit-bookmark)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-bookmark.el ends here
diff --git a/lisp/magit-branch.el b/lisp/magit-branch.el
index 2c84d4767de..ae4779a0407 100644
--- a/lisp/magit-branch.el
+++ b/lisp/magit-branch.el
@@ -263,12 +263,12 @@ changes.
(interactive (list (magit-read-other-branch-or-commit "Checkout")
(magit-branch-arguments)))
(when (string-match "\\`heads/\\(.+\\)" commit)
- (setq commit (match-string 1 commit)))
+ (setq commit (match-str 1 commit)))
(magit-run-git-async "checkout" args commit))
(defun magit--checkout (rev &optional args)
(when (string-match "\\`heads/\\(.+\\)" rev)
- (setq rev (match-string 1 rev)))
+ (setq rev (match-str 1 rev)))
(magit-call-git "checkout" args rev))
;;;###autoload
@@ -319,7 +319,7 @@ does."
(and (not (magit-commit-p arg))
(magit-read-starting-point "Create and checkout branch"
arg)))))
(when (string-match "\\`heads/\\(.+\\)" arg)
- (setq arg (match-string 1 arg)))
+ (setq arg (match-str 1 arg)))
(if start-point
(with-suppressed-warnings ((interactive-only magit-branch-and-checkout))
(magit-branch-and-checkout arg start-point))
@@ -622,7 +622,7 @@ prompt is confusing."
(format "%s of these names are" len))))))
(cond
((string-match "^refs/remotes/\\([^/]+\\)" (car refs))
- (let* ((remote (match-string 1 (car refs)))
+ (let* ((remote (match-str 1 (car refs)))
(offset (1+ (length remote))))
(cond
((magit-confirm 'delete-branch-on-remote
@@ -766,7 +766,7 @@ the remote."
nil 'magit-revision-history)
current-prefix-arg)))
(when (string-match "\\`heads/\\(.+\\)" old)
- (setq old (match-string 1 old)))
+ (setq old (match-str 1 old)))
(when (equal old new)
(user-error "Old and new branch names are the same"))
(magit-call-git "branch" (if force "-M" "-m") old new)
@@ -979,4 +979,9 @@ Also rename the respective reflog file."
;;; _
(provide 'magit-branch)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-branch.el ends here
diff --git a/lisp/magit-bundle.el b/lisp/magit-bundle.el
index 1cd98d5519c..6e0ae812fc1 100644
--- a/lisp/magit-bundle.el
+++ b/lisp/magit-bundle.el
@@ -136,4 +136,9 @@
;;; _
(provide 'magit-bundle)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-bundle.el ends here
diff --git a/lisp/magit-clone.el b/lisp/magit-clone.el
index 42187eb3c67..80ef7b0bbe3 100644
--- a/lisp/magit-clone.el
+++ b/lisp/magit-clone.el
@@ -314,13 +314,13 @@ Then show the status buffer for the new repository."
(defun magit-clone--url-to-name (url)
(and (string-match "\\([^/:]+?\\)\\(/?\\.git\\)?$" url)
- (match-string 1 url)))
+ (match-str 1 url)))
(defun magit-clone--name-to-url (name)
(or (seq-some
(pcase-lambda (`(,re ,host ,user))
(and (string-match re name)
- (let ((repo (match-string 1 name)))
+ (let ((repo (match-str 1 name)))
(magit-clone--format-url host user repo))))
magit-clone-name-alist)
(user-error "Not an url and no matching entry in `%s'"
@@ -348,4 +348,9 @@ Then show the status buffer for the new repository."
;;; _
(provide 'magit-clone)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-clone.el ends here
diff --git a/lisp/magit-commit.el b/lisp/magit-commit.el
index e8b84383f2f..7aab4f3eea5 100644
--- a/lisp/magit-commit.el
+++ b/lisp/magit-commit.el
@@ -784,7 +784,7 @@ actually insert the entry."
(narrow-to-region (point-min) (point))
(cond ((re-search-backward (format "* %s\\(?: (\\([^)]+\\))\\)?: " file)
nil t)
- (when (equal (match-string 1) defun)
+ (when (equal (match-str 1) defun)
(setq defun nil))
(re-search-forward ": "))
(t
@@ -813,4 +813,9 @@ actually insert the entry."
;;; _
(provide 'magit-commit)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-commit.el ends here
diff --git a/lisp/magit-core.el b/lisp/magit-core.el
index a7ff47e7579..dd952280dee 100644
--- a/lisp/magit-core.el
+++ b/lisp/magit-core.el
@@ -120,4 +120,9 @@ Each of these options falls into one or more of these
categories:
;;; _
(provide 'magit-core)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-core.el ends here
diff --git a/lisp/magit-diff.el b/lisp/magit-diff.el
index 72a2eede3ef..cda4d8ef21b 100644
--- a/lisp/magit-diff.el
+++ b/lisp/magit-diff.el
@@ -1482,7 +1482,7 @@ Change \"revA..revB\" to \"revA...revB\", or vice versa."
(derived-mode-p 'magit-diff-mode)
(string-match magit-range-re magit-buffer-range))
(setq magit-buffer-range
- (replace-match (if (string= (match-string 2 magit-buffer-range)
"..")
+ (replace-match (if (string= (match-str 2 magit-buffer-range) "..")
"..."
"..")
t t magit-buffer-range 2))
@@ -1498,9 +1498,9 @@ Change \"revA..revB\" to \"revB..revA\"."
(string-match magit-range-re magit-buffer-range))
(progn
(setq magit-buffer-range
- (concat (match-string 3 magit-buffer-range)
- (match-string 2 magit-buffer-range)
- (match-string 1 magit-buffer-range)))
+ (concat (match-str 3 magit-buffer-range)
+ (match-str 2 magit-buffer-range)
+ (match-str 1 magit-buffer-range)))
(magit-refresh))
(user-error "No range to swap")))
@@ -1553,7 +1553,7 @@ instead."
3))
(val magit-buffer-diff-args)
(arg (seq-find (##string-match "^-U\\([0-9]+\\)?$" %) val))
- (num (if-let ((str (and arg (match-string 1 arg))))
+ (num (if-let ((str (and arg (match-str 1 arg))))
(string-to-number str)
def))
(val (delete arg val))
@@ -1566,7 +1566,7 @@ instead."
(defun magit-diff-get-context ()
(string-to-number
(or (seq-some (##and (string-match "\\`-U\\([0-9]+\\)?\\'" %)
- (match-string 1 %))
+ (match-str 1 %))
magit-buffer-diff-args)
(magit-get "diff.context")
"3")))
@@ -1885,9 +1885,9 @@ the Magit-Status buffer for DIRECTORY."
(while (re-search-forward
"^@@ -\\([0-9]+\\),\\([0-9]+\\) \\+\\([0-9]+\\),\\([0-9]+\\)
@@.*\n"
nil t)
- (let ((from-beg (string-to-number (match-string 1)))
- (from-len (string-to-number (match-string 2)))
- ( to-len (string-to-number (match-string 4))))
+ (let ((from-beg (string-to-number (match-str 1)))
+ (from-len (string-to-number (match-str 2)))
+ ( to-len (string-to-number (match-str 4))))
(if (<= from-beg line)
(if (< (+ from-beg from-len) line)
(cl-incf offset (- to-len from-len))
@@ -2365,7 +2365,7 @@ keymap is the parent of their keymaps."
(defun magit-diff-wash-diffstat ()
(let (heading (beg (point)))
(when (re-search-forward "^ ?\\([0-9]+ +files? change[^\n]*\n\\)" nil t)
- (setq heading (match-string 1))
+ (setq heading (match-str 1))
(magit-delete-match)
(goto-char beg)
(magit-insert-section (diffstat)
@@ -2374,10 +2374,10 @@ keymap is the parent of their keymaps."
(let (files)
(while (looking-at "^[-0-9]+\t[-0-9]+\t\\(.+\\)$")
(push (magit-decode-git-path
- (let ((f (match-string 1)))
+ (let ((f (match-str 1)))
(cond
((string-match "{.* => \\(.*\\)}" f)
- (replace-match (match-string 1 f) nil t f))
+ (replace-match (match-str 1 f) nil t f))
((string-match " => " f)
(substring f (match-end 0)))
(t f))))
@@ -2388,7 +2388,7 @@ keymap is the parent of their keymaps."
(magit-bind-match-strings (file sep cnt add del) nil
(magit-delete-line)
(when (string-match " +$" file)
- (setq sep (concat (match-string 0 file) sep))
+ (setq sep (concat (match-str 0 file) sep))
(setq file (substring file 0 (match-beginning 0))))
(let ((le (length file)) ld)
(setq file (magit-decode-git-path file))
@@ -2415,7 +2415,7 @@ keymap is the parent of their keymaps."
((looking-at "^Submodule")
(magit-diff-wash-submodule))
((looking-at "^\\* Unmerged path \\(.*\\)")
- (let ((file (magit-decode-git-path (match-string 1))))
+ (let ((file (magit-decode-git-path (match-str 1))))
(magit-delete-line)
(unless (and (derived-mode-p 'magit-status-mode)
(not (member "--cached" args)))
@@ -2434,7 +2434,7 @@ keymap is the parent of their keymaps."
(insert ?\n))))
t)
((looking-at magit-diff-conflict-headline-re)
- (let ((long-status (match-string 0))
+ (let ((long-status (match-str 0))
(status "BUG")
file orig base)
(if (equal long-status "merged")
@@ -2467,11 +2467,11 @@ keymap is the parent of their keymaps."
((looking-at "^diff --\
\\(?:\\(?1:git\\) \\(?:\\(?2:.+?\\) \\2\\)?\
\\|\\(?:cc\\|combined\\) \\(?3:.+\\)\\)")
- (let ((status (cond ((equal (match-string 1) "git") "modified")
+ (let ((status (cond ((equal (match-str 1) "git") "modified")
((derived-mode-p 'magit-revision-mode) "resolved")
(t "unmerged")))
(orig nil)
- (file (or (match-string 2) (match-string 3)))
+ (file (or (match-str 2) (match-str 3)))
(header (list (buffer-substring-no-properties
(line-beginning-position) (1+ (line-end-position)))))
(modes nil)
@@ -2481,29 +2481,29 @@ keymap is the parent of their keymaps."
(while (not (or (eobp) (looking-at magit-diff-headline-re)))
(cond
((looking-at "old mode \\(?:[^\n]+\\)\nnew mode \\(?:[^\n]+\\)\n")
- (setq modes (match-string 0)))
+ (setq modes (match-str 0)))
((looking-at "deleted file .+\n")
(setq status "deleted"))
((looking-at "new file .+\n")
(setq status "new file"))
((looking-at "rename from \\(.+\\)\nrename to \\(.+\\)\n")
- (setq rename (match-string 0))
- (setq orig (match-string 1))
- (setq file (match-string 2))
+ (setq rename (match-str 0))
+ (setq orig (match-str 1))
+ (setq file (match-str 2))
(setq status "renamed"))
((looking-at "copy from \\(.+\\)\ncopy to \\(.+\\)\n")
- (setq orig (match-string 1))
- (setq file (match-string 2))
+ (setq orig (match-str 1))
+ (setq file (match-str 2))
(setq status "new file"))
((looking-at "similarity index .+\n"))
((looking-at "dissimilarity index .+\n"))
((looking-at "index .+\n"))
((looking-at "--- \\(.+?\\)\t?\n")
- (unless (equal (match-string 1) "/dev/null")
- (setq orig (match-string 1))))
+ (unless (equal (match-str 1) "/dev/null")
+ (setq orig (match-str 1))))
((looking-at "\\+\\+\\+ \\(.+?\\)\t?\n")
- (unless (equal (match-string 1) "/dev/null")
- (setq file (match-string 1))))
+ (unless (equal (match-str 1) "/dev/null")
+ (setq file (match-str 1))))
((looking-at "Binary files .+ and .+ differ\n")
(setq binary t))
((looking-at "Binary files differ\n")
@@ -2513,9 +2513,9 @@ keymap is the parent of their keymaps."
((error "BUG: Unknown extended header: %S"
(buffer-substring (point) (line-end-position)))))
;; These headers are treated as some sort of special hunk.
- (unless (or (string-prefix-p "old mode" (match-string 0))
- (string-prefix-p "rename" (match-string 0)))
- (push (match-string 0) header))
+ (unless (or (string-prefix-p "old mode" (match-str 0))
+ (string-prefix-p "rename" (match-str 0)))
+ (push (match-str 0) header))
(magit-delete-match))
(when orig
(setq orig (magit-decode-git-path orig)))
@@ -2531,7 +2531,7 @@ keymap is the parent of their keymaps."
(setq header (list (save-excursion
(string-match "diff [^ ]+" (car header))
(format "%s %s %s\n"
- (match-string 0 (car header))
+ (match-str 0 (car header))
(or orig file)
(or file orig)))
(format "--- %s\n" (or orig "/dev/null"))
@@ -2613,7 +2613,7 @@ function errors."
(defun magit-diff-wash-submodule ()
;; See `show_submodule_summary' in submodule.c and "this" commit.
(when (looking-at "^Submodule \\([^ ]+\\)")
- (let ((module (match-string 1))
+ (let ((module (match-str 1))
untracked modified)
(when (looking-at "^Submodule [^ ]+ contains untracked content$")
(magit-delete-line)
@@ -2623,7 +2623,7 @@ function errors."
(setq modified t))
(cond
((and (looking-at "^Submodule \\([^ ]+\\) \\([^ :]+\\)\\(
(rewind)\\)?:$")
- (equal (match-string 1) module))
+ (equal (match-str 1) module))
(magit-bind-match-strings (_module range rewind) nil
(magit-delete-line)
(while (looking-at "^ \\([<>]\\) \\(.*\\)$")
@@ -2654,7 +2654,7 @@ function errors."
"log" "--oneline" "--left-right" range)
(delete-char -1))))))
((and (looking-at "^Submodule \\([^ ]+\\) \\([^ ]+\\) (\\([^)]+\\))$")
- (equal (match-string 1) module))
+ (equal (match-str 1) module))
(magit-bind-match-strings (_module _range msg) nil
(magit-delete-line)
(magit-insert-section (module module)
@@ -2675,7 +2675,7 @@ function errors."
(defun magit-diff-wash-hunk ()
(when (looking-at "^@\\{2,\\} \\(.+?\\) @\\{2,\\}\\(?: \\(.*\\)\\)?")
- (let* ((heading (match-string 0))
+ (let* ((heading (match-str 0))
(ranges (mapcar
(lambda (str)
(let ((range
@@ -2685,8 +2685,8 @@ function errors."
(if (length= range 1)
(nconc range (list 1))
range)))
- (split-string (match-string 1))))
- (about (match-string 2))
+ (split-string (match-str 1))))
+ (about (match-str 2))
(combined (length= ranges 3))
(value (cons about ranges)))
(magit-delete-line)
@@ -2804,8 +2804,8 @@ or a ref which is not a branch, then it inserts nothing."
(delete-region beg (point)))
(looking-at "^tagger \\([^<]+\\) <\\([^>]+\\)")
(let ((heading (format "Tagger: %s <%s>"
- (match-string 1)
- (match-string 2))))
+ (match-str 1)
+ (match-str 2))))
(magit-delete-line)
(magit-insert-heading
(propertize heading 'font-lock-face
@@ -3051,7 +3051,7 @@ Refer to user option
`magit-revision-insert-related-refs-display-alist'."
(goto-char beg)
(when-let (((re-search-forward regexp nil t))
(window (get-buffer-window)))
- (let* ((column (length (match-string 0)))
+ (let* ((column (length (match-str 0)))
(font-obj (query-font (font-at (point) window)))
(size (* 2 (+ (aref font-obj 4)
(aref font-obj 5))))
@@ -3365,7 +3365,7 @@ actually a `diff' but a `diffstat' section."
(point) (1+ (line-end-position)) 'font-lock-face
(cond
((looking-at "^\\+\\+?\\([<=|>]\\)\\{7\\}")
- (setq stage (pcase (list (match-string 1) highlight)
+ (setq stage (pcase (list (match-str 1) highlight)
('("<" nil) 'magit-diff-our)
('("<" t) 'magit-diff-our-highlight)
('("|" nil) 'magit-diff-base)
@@ -3642,12 +3642,12 @@ last (visual) lines of the region."
(goto-char sbeg)
(while (< (point) send)
(looking-at "\\(.\\)\\([^\n]*\n\\)")
- (cond ((or (string-match-p "[@ ]" (match-string-no-properties 1))
+ (cond ((or (string-match-p "[@ ]" (match-str 1))
(and (>= (point) rbeg)
(<= (point) rend)))
- (push (match-string-no-properties 0) patch))
- ((equal op (match-string-no-properties 1))
- (push (concat " " (match-string-no-properties 2)) patch)))
+ (push (match-str 0) patch))
+ ((equal op (match-str 1))
+ (push (concat " " (match-str 2)) patch)))
(forward-line)))
(let ((buffer-list-update-hook nil)) ; #3759
(with-temp-buffer
@@ -3658,4 +3658,9 @@ last (visual) lines of the region."
;;; _
(provide 'magit-diff)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-diff.el ends here
diff --git a/lisp/magit-dired.el b/lisp/magit-dired.el
index 5e361ac9f3d..087499b4c53 100644
--- a/lisp/magit-dired.el
+++ b/lisp/magit-dired.el
@@ -106,4 +106,9 @@ Interactively, open the file at point."
;;; _
(provide 'magit-dired)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-dired.el ends here
diff --git a/lisp/magit-ediff.el b/lisp/magit-ediff.el
index 16e38b78ae5..10d632c1baa 100644
--- a/lisp/magit-ediff.el
+++ b/lisp/magit-ediff.el
@@ -602,4 +602,9 @@ stash that were staged."
;;; _
(provide 'magit-ediff)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-ediff.el ends here
diff --git a/lisp/magit-extras.el b/lisp/magit-extras.el
index b4dbcd050b6..d95661faf70 100644
--- a/lisp/magit-extras.el
+++ b/lisp/magit-extras.el
@@ -614,7 +614,7 @@ the minibuffer too."
(save-excursion
(if (re-search-backward idx-format nil t)
(number-to-string
- (1+ (string-to-number (match-string 1))))
+ (1+ (string-to-number (match-str 1))))
"1"))))
pnt-args eob-args)
(when (listp pnt-format)
@@ -743,7 +743,7 @@ abbreviated revision to the `kill-ring' and the
(magit-diff-mode
(if (string-match "\\.\\.\\.?\\(.+\\)"
magit-buffer-range)
- (match-string 1 magit-buffer-range)
+ (match-str 1 magit-buffer-range)
magit-buffer-range))
(magit-status-mode "HEAD")))))
(when (magit-commit-p rev)
@@ -832,4 +832,9 @@ In Magit diffs, also skip over - and + at the beginning of
the line."
;;; _
(provide 'magit-extras)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-extras.el ends here
diff --git a/lisp/magit-fetch.el b/lisp/magit-fetch.el
index 7ef4504b77d..7e56849a8e9 100644
--- a/lisp/magit-fetch.el
+++ b/lisp/magit-fetch.el
@@ -183,4 +183,9 @@ with a prefix argument."
;;; _
(provide 'magit-fetch)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-fetch.el ends here
diff --git a/lisp/magit-files.el b/lisp/magit-files.el
index 0ee5888f3ad..5d5fefc4c1d 100644
--- a/lisp/magit-files.el
+++ b/lisp/magit-files.el
@@ -611,4 +611,9 @@ If DEFAULT is non-nil, use this as the default value
instead of
'magit-file-unstage "Magit 4.3.2")
(provide 'magit-files)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-files.el ends here
diff --git a/lisp/magit-git.el b/lisp/magit-git.el
index baca51f662d..b7a642249ab 100644
--- a/lisp/magit-git.el
+++ b/lisp/magit-git.el
@@ -516,7 +516,7 @@ insert the run command and stderr into the process buffer."
(goto-char (point-max))
(and (run-hook-wrapped 'magit-process-error-message-regexps
(##re-search-backward % nil t))
- (match-string-no-properties 1)))
+ (match-str 1)))
(defun magit-git-string (&rest args)
"Execute Git with ARGS, returning the first line of its output.
@@ -652,7 +652,7 @@ using `magit-debug-git-executable'.")
output)))
((save-match-data
(and (string-match magit--git-version-regexp output)
- (let ((version (match-string 1 output)))
+ (let ((version (match-str 1 output)))
(push (cons host version)
magit--host-git-version-cache)
version))))
@@ -696,7 +696,7 @@ values of `magit-remote-git-executable' and
`exec-path'.\n"))
(cond ((not (zerop status)) output)
((save-match-data
(and (string-match magit--git-version-regexp output)
- (match-string 1 output))))
+ (match-str 1 output))))
(t output)))))
(defun magit-debug-git-executable ()
@@ -1135,7 +1135,7 @@ See also `magit-untracked-files'."
(defun magit-binary-files (&rest args)
(mapcan (##and (string-match "^-\t-\t\\(.+\\)" %)
- (list (match-string 1 %)))
+ (list (match-str 1 %)))
(apply #'magit-git-items
"diff" "-z" "--numstat" "--ignore-submodules"
args)))
@@ -1214,8 +1214,8 @@ or if no rename is detected."
(cl-sort (mapcar
(lambda (mount)
(if (string-match "^\\(.*\\) on \\(.*\\) type" mount)
- (cons (file-name-as-directory (match-string 2 mount))
- (file-name-as-directory (match-string 1 mount)))
+ (cons (file-name-as-directory (match-str 2 mount))
+ (file-name-as-directory (match-str 1 mount)))
(lwarn '(magit) :error
"Failed to parse Cygwin mount: %S" mount)))
;; If --exec-path is not a native Windows path,
@@ -1463,7 +1463,7 @@ Git."
(and (string-match "\\`\\(squash!\\|fixup!\\|amend!\\) \\(.+\\)" msg)
(magit-rev-format
"%h" (format "%s^{/^%s}" rev
- (magit--ext-regexp-quote (match-string 2 msg))))))))
+ (magit--ext-regexp-quote (match-str 2 msg))))))))
(defun magit-get-shortname (rev)
(let* ((fn (apply-partially #'magit-rev-name rev))
@@ -1473,9 +1473,9 @@ Git."
(cond ((not name)
(magit-rev-parse "--short" rev))
((string-match "^\\(?:tags\\|remotes\\)/\\(.+\\)" name)
- (if (magit-ref-ambiguous-p (match-string 1 name))
+ (if (magit-ref-ambiguous-p (match-str 1 name))
name
- (match-string 1 name)))
+ (match-str 1 name)))
((magit-ref-maybe-qualify name)))))
(defun magit-name-branch (rev &optional lax)
@@ -1513,7 +1513,7 @@ If REFNAME is ambiguous, return nil."
(defun magit-ref-ambiguous-p (refname)
(save-match-data
(if (string-match "\\`\\([^^~]+\\)\\(.*\\)" refname)
- (not (magit-ref-fullname (match-string 1 refname)))
+ (not (magit-ref-fullname (match-str 1 refname)))
(error "%S has an unrecognized format" refname))))
(defun magit-ref-maybe-qualify (refname &optional prefix)
@@ -1907,15 +1907,15 @@ the name of a remote and REF is the ref local to the
remote."
(seq-some (lambda (line)
(and (string-match "\
\\`remote\\.\\([^.]+\\)\\.fetch=\\+?\\([^:]+\\):\\(.+\\)" line)
- (let ((rmt (match-string 1 line))
- (src (match-string 2 line))
- (dst (match-string 3 line)))
+ (let ((rmt (match-str 1 line))
+ (src (match-str 2 line))
+ (dst (match-str 3 line)))
(and (string-match (format "\\`%s\\'"
(string-replace
"*" "\\(.+\\)" dst))
ref)
(cons rmt (string-replace
- "*" (match-string 1 ref) src))))))
+ "*" (match-str 1 ref) src))))))
(magit-git-lines "config" "--local" "--list")))))
(defun magit-split-branch-name (branch)
@@ -1926,8 +1926,8 @@ the name of a remote and REF is the ref local to the
remote."
(and (string-match
(format "\\`\\(%s\\)/\\(.+\\)\\'" remote)
branch)
- (cons (match-string 1 branch)
- (match-string 2 branch))))
+ (cons (match-str 1 branch)
+ (match-str 2 branch))))
(magit-list-remotes))
(error "Invalid branch name %s" branch)))))
@@ -1946,10 +1946,10 @@ uncommitted changes, nil otherwise."
(string-match
"\\(.+\\)-\\(?:0[0-9]*\\|\\([0-9]+\\)\\)-g[0-9a-z]+\\(-dirty\\)?$" str)
(if with-distance
- `(,(match-string 1 str)
- ,(string-to-number (or (match-string 2 str) "0"))
- ,@(and (match-string 3 str) (list t)))
- (match-string 1 str)))))
+ `(,(match-str 1 str)
+ ,(string-to-number (or (match-str 2 str) "0"))
+ ,@(and (match-str 3 str) (list t)))
+ (match-str 1 str)))))
(defun magit-get-next-tag (&optional rev with-distance)
"Return the closest tag from which REV is reachable.
@@ -1962,7 +1962,7 @@ where COMMITS is the number of commits in TAG but not in
REV."
(and-let* ((str (magit-git-str "describe" "--contains" (or rev "HEAD"))))
(save-match-data
(when (string-match "^[^^~]+" str)
- (setq str (match-string 0 str))
+ (setq str (match-str 0 str))
(unless (equal str (magit-get-current-tag rev))
(if with-distance
(list str (car (magit-rev-diff-count str rev)))
@@ -2034,7 +2034,7 @@ When nil, use `magit-list-refs-sortby'. If both are nil,
use
(let ((re (format "\\`%s refs/\\(heads\\|remotes\\)/\\(.*\\)\\'"
(magit-rev-verify rev))))
(seq-keep (##and (string-match re %)
- (let ((name (match-string 2 %)))
+ (let ((name (match-str 2 %)))
(and (not (string-suffix-p "HEAD" name))
name)))
(magit-git-lines "show-ref"))))
@@ -2062,7 +2062,7 @@ When nil, use `magit-list-refs-sortby'. If both are nil,
use
(if (and remote relative)
(let ((regexp (format "^refs/remotes/%s/\\(.+\\)" remote)))
(mapcan (##when (string-match regexp %)
- (list (match-string 1 %)))
+ (list (match-str 1 %)))
(magit-list-remote-branches remote)))
(magit-list-refnames (concat "refs/remotes/" remote))))
@@ -2112,17 +2112,17 @@ When nil, use `magit-list-refs-sortby'. If both are
nil, use
(##string-match
"\\`ref: refs/heads/\\([^\s\t]+\\)[\s\t]HEAD\\'" %)
(magit-git-lines "ls-remote" "--symref" remote "HEAD"))))
- (match-string 1 line)))
+ (match-str 1 line)))
(defun magit-list-modified-modules ()
(seq-keep (##and (string-match "\\`\\+\\([^ ]+\\) \\(.+\\) (.+)\\'" %)
- (match-string 2 %))
+ (match-str 2 %))
(magit-git-lines "submodule" "status")))
(defun magit-list-module-paths ()
(magit-with-toplevel
(mapcan (##and (string-match "^160000 [0-9a-z]\\{40,\\} 0\t\\(.+\\)$" %)
- (list (match-string 1 %)))
+ (list (match-str 1 %)))
(magit-git-items "ls-files" "-z" "--stage"))))
(defun magit-list-module-names ()
@@ -2374,7 +2374,7 @@ and this option only controls what face is used.")
(dolist (ref refs)
(let* ((face (cdr (seq-find (##string-match (car %) ref)
magit-ref-namespaces)))
- (name (match-string 1 ref))
+ (name (match-str 1 ref))
(name (if (and name
(not (string-prefix-p "refs/tags/" ref))
(magit-rev-verify (concat "refs/tags/" name)))
@@ -2394,8 +2394,8 @@ and this option only controls what face is used.")
(seq-keep
(lambda (name)
(if (string-match "\\`\\([^/]*\\)/\\(.*\\)\\'" name)
- (let ((r (match-string 1 name))
- (b (match-string 2 name)))
+ (let ((r (match-str 1 name))
+ (b (match-str 2 name)))
(and (not (equal b "HEAD"))
(if (equal (concat "refs/remotes/" name)
(magit-git-string
@@ -2515,28 +2515,28 @@ and this option only controls what face is used.")
(and sep
(let ((beg (or beg "HEAD"))
(end (or end "HEAD")))
- (if (string-equal (match-string 2 range) "...")
+ (if (string-equal (match-str 2 range) "...")
(and-let* ((base (magit-git-string "merge-base" beg end)))
(cons base end))
(cons beg end))))))
(defun magit--split-range-raw (range)
(and (string-match magit-range-re range)
- (let ((beg (match-string 1 range))
- (end (match-string 3 range)))
+ (let ((beg (match-str 1 range))
+ (end (match-str 3 range)))
(and (or beg end)
- (list beg end (match-string 2 range))))))
+ (list beg end (match-str 2 range))))))
(defun magit-hash-range (range)
(if (string-match magit-range-re range)
- (let ((beg (match-string 1 range))
- (end (match-string 3 range)))
+ (let ((beg (match-str 1 range))
+ (end (match-str 3 range)))
(and (or beg end)
- (let ((beg-hash (and beg (magit-rev-hash (match-string 1 range))))
- (end-hash (and end (magit-rev-hash (match-string 3
range)))))
+ (let ((beg-hash (and beg (magit-rev-hash (match-str 1 range))))
+ (end-hash (and end (magit-rev-hash (match-str 3 range)))))
(and (or (not beg) beg-hash)
(or (not end) end-hash)
- (concat beg-hash (match-string 2 range) end-hash)))))
+ (concat beg-hash (match-str 2 range) end-hash)))))
(magit-rev-hash range)))
(defvar magit-revision-faces
@@ -2855,7 +2855,7 @@ out. Only existing branches can be selected."
(car choices))))
(and choice
(string-match "^\\([^ ]+\\) \\(.+\\)" choice)
- (substring-no-properties (match-string 1 choice)))))
+ (substring-no-properties (match-str 1 choice)))))
(defun magit-read-remote (prompt &optional default use-only)
(let ((remotes (magit-list-remotes)))
@@ -2907,4 +2907,9 @@ out. Only existing branches can be selected."
;;; _
(provide 'magit-git)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-git.el ends here
diff --git a/lisp/magit-gitignore.el b/lisp/magit-gitignore.el
index 0ee63df0e21..4f8baf95d8d 100644
--- a/lisp/magit-gitignore.el
+++ b/lisp/magit-gitignore.el
@@ -192,4 +192,9 @@ Rules that are defined in that file affect all local
repositories."
;;; _
(provide 'magit-gitignore)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-gitignore.el ends here
diff --git a/lisp/magit-log.el b/lisp/magit-log.el
index c4cb1de6707..66b30a366b4 100644
--- a/lisp/magit-log.el
+++ b/lisp/magit-log.el
@@ -893,7 +893,7 @@ limit. Otherwise set it to 256."
(defun magit-log-set-commit-limit (fn)
(let* ((val magit-buffer-log-args)
(arg (seq-find (##string-match "^-n\\([0-9]+\\)?$" %) val))
- (num (and arg (string-to-number (match-string 1 arg))))
+ (num (and arg (string-to-number (match-str 1 arg))))
(num (if num (funcall fn num 2) 256)))
(setq val (remove arg val))
(setq magit-buffer-log-args
@@ -905,7 +905,7 @@ limit. Otherwise set it to 256."
(defun magit-log-get-commit-limit (&optional args)
(and-let* ((str (seq-find (##string-match "^-n\\([0-9]+\\)?$" %)
(or args magit-buffer-log-args))))
- (string-to-number (match-string 1 str))))
+ (string-to-number (match-str 1 str))))
;;;; Mode Commands
@@ -1249,7 +1249,7 @@ Do not add this to a hook variable."
(progn
(when-let ((order (seq-find (##string-match "^\\+\\+order=\\(.+\\)$" %)
args)))
- (setq args (cons (format "--%s-order" (match-string 1 order))
+ (setq args (cons (format "--%s-order" (match-str 1 order))
(remove order args))))
(when (member "--decorate" args)
(setq args (cons "--decorate=full" (remove "--decorate" args))))
@@ -1456,9 +1456,9 @@ Do not add this to a hook variable."
(goto-char (line-beginning-position))
(when (and refsub
(string-match "\\`\\([^ ]\\) \\+\\(..\\)\\(..\\)" date))
- (setq date (+ (string-to-number (match-string 1 date))
- (* (string-to-number (match-string 2 date)) 60 60)
- (* (string-to-number (match-string 3 date)) 60))))
+ (setq date (+ (string-to-number (match-str 1 date))
+ (* (string-to-number (match-str 2 date)) 60 60)
+ (* (string-to-number (match-str 3 date)) 60))))
(magit-log-format-margin hash author date))
(when (and (eq style 'cherry)
(magit-buffer-margin-p))
@@ -1502,7 +1502,7 @@ Do not add this to a hook variable."
(save-excursion
(forward-line -1)
(looking-at "[-_/|\\*o<>. ]*"))
- (setq graph (match-string 0))
+ (setq graph (match-str 0))
(unless (string-match-p "[/\\.]" graph)
(insert graph ?\n))))))))
t)
@@ -2055,4 +2055,9 @@ all others with \"-\"."
;;; _
(provide 'magit-log)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-log.el ends here
diff --git a/lisp/magit-margin.el b/lisp/magit-margin.el
index b710fbddd39..eff1a9874e9 100644
--- a/lisp/magit-margin.el
+++ b/lisp/magit-margin.el
@@ -250,4 +250,9 @@ English.")
;;; _
(provide 'magit-margin)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-margin.el ends here
diff --git a/lisp/magit-merge.el b/lisp/magit-merge.el
index 4dc003ff628..28a702c00af 100644
--- a/lisp/magit-merge.el
+++ b/lisp/magit-merge.el
@@ -312,4 +312,9 @@ If no merge is in progress, do nothing."
;;; _
(provide 'magit-merge)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-merge.el ends here
diff --git a/lisp/magit-mode.el b/lisp/magit-mode.el
index d5ebee78e3c..e6b2aadedd8 100644
--- a/lisp/magit-mode.el
+++ b/lisp/magit-mode.el
@@ -1583,4 +1583,9 @@ line. Avoid including the line after the end of the
file."
;;; _
(provide 'magit-mode)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-mode.el ends here
diff --git a/lisp/magit-notes.el b/lisp/magit-notes.el
index 0b262158e71..b53e7cbe5f9 100644
--- a/lisp/magit-notes.el
+++ b/lisp/magit-notes.el
@@ -194,8 +194,13 @@ Also see `magit-notes-merge'."
(list (magit-read-branch-or-commit prompt (magit-stash-at-point))
(and-let* ((str (seq-find (##string-match "^--ref=\\(.+\\)" %)
(transient-args 'magit-notes))))
- (match-string 1 str))))
+ (match-str 1 str))))
;;; _
(provide 'magit-notes)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-notes.el ends here
diff --git a/lisp/magit-patch.el b/lisp/magit-patch.el
index 88641d51478..8b5529910bc 100644
--- a/lisp/magit-patch.el
+++ b/lisp/magit-patch.el
@@ -325,4 +325,9 @@ is asked to pull. START has to be reachable from that
commit."
;;; _
(provide 'magit-patch)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-patch.el ends here
diff --git a/lisp/magit-process.el b/lisp/magit-process.el
index 9b54b5292b4..637db3a86ab 100644
--- a/lisp/magit-process.el
+++ b/lisp/magit-process.el
@@ -947,8 +947,8 @@ PARENT is used as the parent of the returned keymap."
(y-or-n-p-map
(magit-process-make-keymap process y-or-n-p-map)))
(yes-or-no-p (substring string 0 beg))))
- (concat (downcase (match-string 1 string)) "\n")
- (concat (downcase (match-string 2 string)) "\n")))))
+ (concat (downcase (match-str 1 string)) "\n")
+ (concat (downcase (match-str 2 string)) "\n")))))
(defun magit-process-password-auth-source (key)
"Use `auth-source-search' to get a password.
@@ -990,8 +990,8 @@ be translated on the fly by doing this once
(require 'auth-source)
(and (fboundp 'auth-source-search)
(string-match "\\`\\(.+\\)@\\([^@]+\\)\\'" key)
- (let* ((user (match-string 1 key))
- (host (match-string 2 key))
+ (let* ((user (match-str 1 key))
+ (host (match-str 2 key))
(secret
(plist-get
(car (or (auth-source-search :max 1 :host host :user user)
@@ -1026,7 +1026,7 @@ from the user."
magit-process-password-prompt-regexps string)))
(process-send-string
process
- (concat (or (and-let* ((key (match-string 99 string)))
+ (concat (or (and-let* ((key (match-str 99 string)))
(run-hook-with-args-until-success
'magit-process-find-password-functions key))
(let ((read-passwd-map
@@ -1048,7 +1048,7 @@ from the user."
"Match STRING against PROMPTS and set match data.
Return the matched string, appending \": \" if needed."
(when (seq-some (##string-match % string) prompts)
- (let ((prompt (match-string 0 string)))
+ (let ((prompt (match-str 0 string)))
(cond ((string-suffix-p ": " prompt) prompt)
((string-suffix-p ":" prompt) (concat prompt " "))
(t (concat prompt ": "))))))
@@ -1209,7 +1209,7 @@ If STR is supplied, it replaces the `mode-line-process'
text."
(lambda (re)
(save-excursion
(and (re-search-backward re (oref section start) t)
- (match-string-no-properties 1))))))))))
+ (match-str 1))))))))))
(defun magit-process-error-tooltip (process-buf section)
"Returns the text from SECTION of the PROCESS-BUF buffer.
@@ -1344,4 +1344,9 @@ Limited by `magit-process-error-tooltip-max-lines'."
;;; _
(provide 'magit-process)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-process.el ends here
diff --git a/lisp/magit-pull.el b/lisp/magit-pull.el
index 7116c29d3e7..23b10586335 100644
--- a/lisp/magit-pull.el
+++ b/lisp/magit-pull.el
@@ -163,4 +163,9 @@ the upstream."
;;; _
(provide 'magit-pull)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-pull.el ends here
diff --git a/lisp/magit-push.el b/lisp/magit-push.el
index 1b8acb4265b..e4338391560 100644
--- a/lisp/magit-push.el
+++ b/lisp/magit-push.el
@@ -370,4 +370,9 @@ You can add this command as a suffix using something like:
;;; _
(provide 'magit-push)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-push.el ends here
diff --git a/lisp/magit-reflog.el b/lisp/magit-reflog.el
index 7ffce3e0fc9..51636867f03 100644
--- a/lisp/magit-reflog.el
+++ b/lisp/magit-reflog.el
@@ -189,9 +189,9 @@ Type \\[magit-reset] to reset `HEAD' to the commit at point.
(defun magit-reflog-format-subject (subject)
(let* ((match (string-match magit-reflog-subject-re subject))
- (command (and match (match-string 1 subject)))
- (option (and match (match-string 2 subject)))
- (type (and match (match-string 3 subject)))
+ (command (and match (match-str 1 subject)))
+ (option (and match (match-str 2 subject)))
+ (type (and match (match-str 3 subject)))
(label (if (string= command "commit")
(or type command)
command))
@@ -205,4 +205,9 @@ Type \\[magit-reset] to reset `HEAD' to the commit at point.
;;; _
(provide 'magit-reflog)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-reflog.el ends here
diff --git a/lisp/magit-refs.el b/lisp/magit-refs.el
index a26981a5b63..6ae65c4fe6b 100644
--- a/lisp/magit-refs.el
+++ b/lisp/magit-refs.el
@@ -547,8 +547,8 @@ line is inserted at all."
(magit-insert-heading (length tags) "Tags")
(dolist (tag tags)
(string-match "^\\([^ \t]+\\)[ \t]+\\([^ \t\n].*\\)?" tag)
- (let ((tag (match-string 1 tag))
- (msg (match-string 2 tag)))
+ (let ((tag (match-str 1 tag))
+ (msg (match-str 2 tag)))
(when (magit-refs--insert-refname-p tag)
(magit-insert-section (tag tag t)
(magit-insert-heading
@@ -709,20 +709,20 @@ line is inserted at all."
(string-match "ahead \\([0-9]+\\)" u:track)
(magit--propertize-face
(concat (and magit-refs-pad-commit-counts " ")
- (match-string 1 u:track)
+ (match-str 1 u:track)
">")
'magit-dimmed)))
(u:behind (and u:track
(string-match "behind \\([0-9]+\\)" u:track)
(magit--propertize-face
(concat "<"
- (match-string 1 u:track)
+ (match-str 1 u:track)
(and magit-refs-pad-commit-counts " "))
'magit-dimmed)))
(p:ahead (and pushp p:track
(string-match "ahead \\([0-9]+\\)" p:track)
(magit--propertize-face
- (concat (match-string 1 p:track)
+ (concat (match-str 1 p:track)
">"
(and magit-refs-pad-commit-counts " "))
'magit-branch-remote)))
@@ -730,7 +730,7 @@ line is inserted at all."
(string-match "behind \\([0-9]+\\)" p:track)
(magit--propertize-face
(concat "<"
- (match-string 1 p:track)
+ (match-str 1 p:track)
(and magit-refs-pad-commit-counts " "))
'magit-dimmed))))
(list (1+ (length (concat branch-pretty u:ahead p:ahead u:behind)))
@@ -811,4 +811,9 @@ line is inserted at all."
;;; _
(provide 'magit-refs)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-refs.el ends here
diff --git a/lisp/magit-remote.el b/lisp/magit-remote.el
index e4cdab797d2..6822fac0f01 100644
--- a/lisp/magit-remote.el
+++ b/lisp/magit-remote.el
@@ -175,8 +175,8 @@ the now stale refspecs. Other stale branches are not
removed."
stale)
(dolist (refspec refspecs)
(when (string-match magit--refspec-re refspec)
- (let ((theirs (match-string 2 refspec))
- (ours (match-string 3 refspec)))
+ (let ((theirs (match-str 2 refspec))
+ (ours (match-str 3 refspec)))
(unless (if (string-match "\\*" theirs)
(let ((re (replace-match ".*" t t theirs)))
(seq-some (##string-match-p re %) remote-refs))
@@ -393,4 +393,9 @@ refspec."
;;; _
(provide 'magit-remote)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-remote.el ends here
diff --git a/lisp/magit-repos.el b/lisp/magit-repos.el
index b815757c00a..87a4422797d 100644
--- a/lisp/magit-repos.el
+++ b/lisp/magit-repos.el
@@ -384,7 +384,7 @@ Usually this is just its basename."
(when (match-end 4)
(magit--put-face (or (match-beginning 3) (match-beginning 4))
(match-end 4) 'error v))
- (when (and (equal (match-string 2 v) "1")
+ (when (and (equal (match-str 2 v) "1")
(string-match-p magit-repolist-column-version-resume-regexp
(magit-rev-format "%s")))
(setq v (replace-match (propertize "+" 'face 'shadow) t t v 1))))
@@ -397,8 +397,8 @@ Usually this is just its basename."
(defun magit-repolist-version< (a b)
(save-match-data
(let ((re "[0-9]+\\(\\.[0-9]*\\)*"))
- (setq a (and (string-match re a) (match-string 0 a)))
- (setq b (and (string-match re b) (match-string 0 b)))
+ (setq a (and (string-match re a) (match-str 0 a)))
+ (setq b (and (string-match re b) (match-str 0 b)))
(cond ((and a b) (version< a b))
(b nil)
(t t)))))
@@ -544,4 +544,9 @@ instead."
;;; _
(provide 'magit-repos)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-repos.el ends here
diff --git a/lisp/magit-reset.el b/lisp/magit-reset.el
index a166dd93ca1..5b099fc8926 100644
--- a/lisp/magit-reset.el
+++ b/lisp/magit-reset.el
@@ -134,4 +134,9 @@ or \"detached head\" will be substituted for %s."
;;; _
(provide 'magit-reset)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-reset.el ends here
diff --git a/lisp/magit-section.el b/lisp/magit-section.el
index 6f8e2c454b9..0c0b31dfc7b 100644
--- a/lisp/magit-section.el
+++ b/lisp/magit-section.el
@@ -2604,4 +2604,9 @@ with the variables' values as arguments, which were
recorded by
;;; _
(provide 'magit-section)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-section.el ends here
diff --git a/lisp/magit-sequence.el b/lisp/magit-sequence.el
index 757bd5965b3..3680229782f 100644
--- a/lisp/magit-sequence.el
+++ b/lisp/magit-sequence.el
@@ -1010,7 +1010,7 @@ status buffer (i.e., the reverse of how they will be
applied)."
(if (eq (oref obj action-type) 'merge)
(let ((options (oref obj action-options)))
(and (string-match "-[cC] \\([^ ]+\\)"
options)
- (match-string 1 options)))
+ (match-str 1 options)))
(oref obj target)))
commits)))))
(cl-assert (equal (length commits) (length abbrevs)))
@@ -1141,4 +1141,9 @@ status buffer (i.e., the reverse of how they will be
applied)."
;;; _
(provide 'magit-sequence)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-sequence.el ends here
diff --git a/lisp/magit-sparse-checkout.el b/lisp/magit-sparse-checkout.el
index 1df657a784b..e4fb663a9c7 100644
--- a/lisp/magit-sparse-checkout.el
+++ b/lisp/magit-sparse-checkout.el
@@ -155,4 +155,9 @@ This header is not inserted by default. To enable it, add
it to
;;; _
(provide 'magit-sparse-checkout)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-sparse-checkout.el ends here
diff --git a/lisp/magit-stash.el b/lisp/magit-stash.el
index 84fbebdbb2d..0296528e494 100644
--- a/lisp/magit-stash.el
+++ b/lisp/magit-stash.el
@@ -681,4 +681,9 @@ that make up the stash."
;;; _
(provide 'magit-stash)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-stash.el ends here
diff --git a/lisp/magit-status.el b/lisp/magit-status.el
index 66ee907382d..9f84e95e612 100644
--- a/lisp/magit-status.el
+++ b/lisp/magit-status.el
@@ -817,4 +817,9 @@ Honor the buffer's file filter, which can be set using \"D
- -\"."
;;; _
(provide 'magit-status)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-status.el ends here
diff --git a/lisp/magit-submodule.el b/lisp/magit-submodule.el
index 9d2b3368b6d..503a1f4bffd 100644
--- a/lisp/magit-submodule.el
+++ b/lisp/magit-submodule.el
@@ -230,7 +230,7 @@ it is nil, then PATH also becomes the name."
(file-relative-name
(read-directory-name prompt nil nil nil
(and (string-match "\\([^./]+\\)\\(\\.git\\)?$" url)
- (match-string 1 url))))))
+ (match-str 1 url))))))
(defun magit-submodule-add-1 (url &optional path name args)
(magit-with-toplevel
@@ -592,10 +592,10 @@ These sections can be expanded to show the respective
commits."
(magit-insert-section ((eval type) nil t)
(string-match "\\`\\(.+\\) \\([^ ]+\\)\\'" heading)
(magit-insert-heading
- (propertize (match-string 1 heading)
+ (propertize (match-str 1 heading)
'font-lock-face 'magit-section-heading)
" "
- (propertize (match-string 2 heading)
+ (propertize (match-str 2 heading)
'font-lock-face 'magit-branch-remote)
":")
(dolist (module modules)
@@ -612,8 +612,8 @@ These sections can be expanded to show the respective
commits."
(propertize module 'font-lock-face 'magit-diff-file-heading))
(dolist (line lines)
(string-match magit-log-module-re line)
- (let ((rev (match-string 1 line))
- (msg (match-string 2 line)))
+ (let ((rev (match-str 1 line))
+ (msg (match-str 2 line)))
(magit-insert-section (module-commit rev t)
(insert (propertize rev 'font-lock-face 'magit-hash) " "
(magit-log--wash-summary msg) "\n")))))))
@@ -713,4 +713,9 @@ These sections can be expanded to show the respective
commits."
;;; _
(provide 'magit-submodule)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-submodule.el ends here
diff --git a/lisp/magit-subtree.el b/lisp/magit-subtree.el
index b771a23e454..0ad655a2613 100644
--- a/lisp/magit-subtree.el
+++ b/lisp/magit-subtree.el
@@ -184,4 +184,9 @@
;;; _
(provide 'magit-subtree)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-subtree.el ends here
diff --git a/lisp/magit-tag.el b/lisp/magit-tag.el
index 94f28028f66..a6966868bf0 100644
--- a/lisp/magit-tag.el
+++ b/lisp/magit-tag.el
@@ -167,7 +167,7 @@ that is not the case, propose a message using a reasonable
format."
(`(,pver ,ptag ,pmsg) (car (magit--list-releases)))
(msg (magit-rev-format "%s"))
(ver (and (string-match magit-release-commit-regexp msg)
- (match-string 1 msg)))
+ (match-str 1 msg)))
(_ (and (not ver)
(require (quote sisyphus) nil t)
(string-match magit-release-commit-regexp
@@ -185,14 +185,14 @@ that is not the case, propose a message using a
reasonable format."
ver)))
(ver
(concat (and (string-match magit-release-tag-regexp ptag)
- (match-string 1 ptag))
+ (match-str 1 ptag))
ver))
(t
(read-string
(format "Create release tag (previous was %s): " ptag)
ptag))))
(ver (and (string-match magit-release-tag-regexp tag)
- (match-string 2 tag))))
+ (match-str 2 tag))))
(list tag
(and (seq-some (apply-partially
#'string-match-p
@@ -232,7 +232,7 @@ a tag qualifies as a release tag."
(let ((tag (substring line 0 (match-beginning 0)))
(msg (substring line (match-end 0))))
(and (string-match magit-release-tag-regexp tag)
- (let ((ver (match-string 2 tag))
+ (let ((ver (match-str 2 tag))
(version-regexp-alist
magit-tag-version-regexp-alist))
(list (list (version-to-list ver)
@@ -245,4 +245,9 @@ a tag qualifies as a release tag."
;;; _
(provide 'magit-tag)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-tag.el ends here
diff --git a/lisp/magit-transient.el b/lisp/magit-transient.el
index 7ebd10cd3c8..55dc374c041 100644
--- a/lisp/magit-transient.el
+++ b/lisp/magit-transient.el
@@ -240,4 +240,9 @@ The value derives from that returned by
`transient-get-value'."
;;; _
(provide 'magit-transient)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-transient.el ends here
diff --git a/lisp/magit-wip.el b/lisp/magit-wip.el
index 712b7845275..117d79e2b79 100644
--- a/lisp/magit-wip.el
+++ b/lisp/magit-wip.el
@@ -430,7 +430,7 @@ many \"branches\" of each wip ref are shown."
reflog :test #'string-match-p))
(when (and (cadr reflog)
(string-match "^[^ ]+ \\([^:]+\\)" (cadr reflog)))
- (push (match-string 1 (cadr reflog)) tips))
+ (push (match-str 1 (cadr reflog)) tips))
(setq reflog (cddr reflog))
(cl-decf count))
(cons wipref (nreverse tips)))))
@@ -458,4 +458,9 @@ many \"branches\" of each wip ref are shown."
;;; _
(provide 'magit-wip)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-wip.el ends here
diff --git a/lisp/magit-worktree.el b/lisp/magit-worktree.el
index 0ea53920b0f..80b3a0fec9a 100644
--- a/lisp/magit-worktree.el
+++ b/lisp/magit-worktree.el
@@ -293,4 +293,9 @@ with padding for alignment."
;;; _
(provide 'magit-worktree)
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit-worktree.el ends here
diff --git a/lisp/magit.el b/lisp/magit.el
index 7c41eecad6d..0251aaae159 100644
--- a/lisp/magit.el
+++ b/lisp/magit.el
@@ -651,7 +651,7 @@ the output in the kill ring.
(let ((dirname (file-name-nondirectory
(directory-file-name topdir))))
(when (string-match "\\`magit-\\([0-9].*\\)" dirname)
- (setq magit-version (match-string 1 dirname)))))
+ (setq magit-version (match-str 1 dirname)))))
;; If all else fails, just report the commit hash. It's
;; better than nothing and we cannot do better in the case
;; of e.g., a shallow clone.
@@ -796,4 +796,9 @@ For X11 something like ~/.xinitrc should work.\n"
(add-hook 'after-init-hook #'magit-startup-asserts t)
(add-hook 'after-init-hook #'magit-version t)))
+;; Local Variables:
+;; read-symbol-shorthands: (
+;; ("match-string" . "match-string")
+;; ("match-str" . "match-string-no-properties"))
+;; End:
;;; magit.el ends here
diff --git a/test/magit-tests.el b/test/magit-tests.el
index dcf796d90c4..d8e98ae4e11 100644
--- a/test/magit-tests.el
+++ b/test/magit-tests.el
@@ -271,13 +271,13 @@
(let* ((prompts '("^foo '\\(?99:.*\\)': ?$"))
(prompt (magit-process-match-prompt prompts "foo 'bar':")))
(should (equal prompt "foo 'bar': "))
- (should (equal (match-string 99 "foo 'bar':") "bar"))))
+ (should (equal (matched 99 "foo 'bar':") "bar"))))
(ert-deftest magit-process:password-prompt-regexps ()
(cl-flet ((m (prompt)
(and (magit-process-match-prompt
magit-process-password-prompt-regexps prompt)
- (or (match-string 99 prompt) t))))
+ (or (matched 99 prompt) t))))
;; History of `magit-process-password-prompt-regexps':
;; a36a801cc2 Initial noisy version.
;; 2a3bbc3c53 First cleanup.
@@ -537,4 +537,7 @@ Recent commits\n[[:xdigit:]]\\{7,\\} master dummy\\'"
;;; _
(provide 'magit-tests)
+;; Local Variables:
+;; read-symbol-shorthands: (("matched" . "match-string-no-properties"))
+;; End:
;;; magit-tests.el ends here
