procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge from origin/emacs-29

Browse source 
8b6a0de964 Improve docstring of treesit-parent-while (bug#62301)
35648a8673 ; Delete accidental leftover '()' Eglot function
47d8e4b0d3 Eglot: report window/workDoneProgress capability to langu...
4a7a0c9a9f * lisp/emacs-lisp/comp.el (comp-emit-set-call-subr): Impr...
4a6eefb93a Expand defvar-keymap documentation
7a1272168a * lisp/treesit.el (treesit-end-of-defun): Guard arg again...
263d6c3853 Comp fix calls to redefined primtives with op-bytecode (b...
6bf441ff11 Warn package authors away from keymap-unset with REMOVE
786de66ec3 Comment out jobs on EMBA
eed240bc02 Improve defvar-keymap docstring.
This commit is contained in:
Stefan Kangas 2023-03-22 06:30:12 +01:00
commit 2d0de86361
8 changed files with 169 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
doc/lispref/keymaps.texi
View file

@ -451,9 +451,70 @@ Here's an example:
@lisp
(defvar-keymap eww-textarea-map
:parent text-mode-map
:doc "Keymap for the eww text area."
"RET" #'forward-line
"TAB" #'shr-next-link)
@end lisp
@kindex :repeat
@kindex repeat-mode
@cindex repeatable key bindings
Each command in the keymap can be marked as `repeatable', i.e. usable
in @code{repeat-mode}, by putting a @code{repeat-map} property on it,
e.g.
@lisp
(put 'undo 'repeat-map 'undo-repeat-map)
@end lisp
where the value of the property is the map to be used by
@code{repeat-mode}.
To avoid repetitive invocations of @code{put}, @code{defvar-keymap}
also has a @code{:repeat} keyword, which can be used to specify which
commands in the keymap are usable by @code{repeat-mode}. The
following values are available:
@table @code
@item t
This means all the commands in the keymap are repeatable, and is the
most common usage.
@item (:enter (commands ...) :exit (commands ...))
This specifies that the commands in the @code{:enter} list enter
@code{repeat-mode}, and the commands in the @code{:exit} list exit
repeat mode.
If the @code{:enter} list is empty, then all commands in the map enter
@code{repeat-mode}. Specifying one or more commands in this list is
useful if there is a command which doesn't exist in the map being
defined, but which should have the @code{repeat-map} property.
If the @code{:exit} list is empty then no commands in the map exit
@code{repeat-mode}. Specifying one ore more commands in this list is
useful if the keymap being defined contains a command that should not
have the @code{repeat-map} property.
@end table
In order to make e.g.@: @kbd{u} repeat the @code{undo} command, the
following two stanzas are equivalent:
@lisp
(defvar-keymap undo-repeat-map
"u" #'undo)
(put 'undo 'repeat-map 'undo-repeat-map)
@end lisp
and
@lisp
(defvar-keymap undo-repeat-map
:repeat t
"u" #'undo)
@end lisp
The latter is preferred when there are many commands in the map, all
of which should be repeatable.
@end defmac
@defun copy-keymap keymap
@ -1452,6 +1513,12 @@ keymap; using @var{remove} instead will allow the key in the parent keymap
to be used.
@end defun
Note: using @code{keymap-unset} with @var{remove} non-@code{nil} is
intended for users to put in their init file; Emacs packages should
avoid using it if possible, since they have complete control over
their own keymaps anyway, and they should not be altering other
packages' keymaps.
This example creates a sparse keymap and makes a number of
bindings in it:

22
doc/lispref/parsing.texi
View file

@ -859,18 +859,24 @@ return non-@code{nil} to indicate that the node should be kept. If
nodes.
@end defun
@defun treesit-parent-until node predicate
@defun treesit-parent-until node predicate &optional include-node
This function repeatedly finds the parents of @var{node}, and returns
the parent that satisfies @var{predicate}, a function that takes a
node as the argument. If no parent satisfies @var{predicate}, this
function returns @code{nil}.
the parent that satisfies @var{pred}, a function that takes a node as
the argument and returns a boolean that indicates a match. If no
parent satisfies @var{pred}, this function returns @code{nil}.
Normally this function only looks at the parents of @var{node} but not
@var{node} itself. But if @var{include-node} is non-@var{nil}, this
function returns @var{node} if @var{node} satisfies @var{pred}.
@end defun
@defun treesit-parent-while node predicate
This function repeatedly finds the parent of @var{node}, and keeps
doing so as long as the nodes satisfy @var{predicate}, a function that
@defun treesit-parent-while node pred
This function goes up the tree starting from @var{node}, and keeps
doing so as long as the nodes satisfy @var{pred}, a function that
takes a node as the argument. That is, this function returns the
farthest parent that still satisfies @var{predicate}.
highest parent of @var{node} that still satisfies @var{pred}. Note
that if @var{node} satisfies @var{pred} but its immediate parent
doesn't, @var{node} itself is returned.
@end defun
@defun treesit-node-top-level node &optional type

30
lisp/emacs-lisp/comp.el
View file

@ -1773,17 +1773,25 @@ SP-DELTA is the stack adjustment."
(maxarg (cdr arity)))
(when (eq maxarg 'unevalled)
(signal 'native-ice (list "subr contains unevalled args" subr-name)))
(if (eq maxarg 'many)
;; callref case.
(comp-emit-set-call (comp-callref subr-name nargs (comp-sp)))
;; Normal call.
(unless (and (>= maxarg nargs) (<= minarg nargs))
(signal 'native-ice
(list "incoherent stack adjustment" nargs maxarg minarg)))
(let* ((subr-name subr-name)
(slots (cl-loop for i from 0 below maxarg
collect (comp-slot-n (+ i (comp-sp))))))
(comp-emit-set-call (apply #'comp-call (cons subr-name slots))))))))
(if (not (subr-primitive-p subr-name))
;; The primitive got redefined before the compiler is
;; invoked! (bug#61917)
(comp-emit-set-call `(callref funcall
,(make-comp-mvar :constant subr-name)
,@(cl-loop repeat nargs
for sp from (comp-sp)
collect (comp-slot-n sp))))
(if (eq maxarg 'many)
;; callref case.
(comp-emit-set-call (comp-callref subr-name nargs (comp-sp)))
;; Normal call.
(unless (and (>= maxarg nargs) (<= minarg nargs))
(signal 'native-ice
(list "incoherent stack adjustment" nargs maxarg minarg)))
(let* ((subr-name subr-name)
(slots (cl-loop for i from 0 below maxarg
collect (comp-slot-n (+ i (comp-sp))))))
(comp-emit-set-call (apply #'comp-call (cons subr-name slots)))))))))
(eval-when-compile
(defun comp-op-to-fun (x)

19
lisp/keymap.el
View file

@ -579,14 +579,17 @@ value can also be a property list with properties `:enter' and
:repeat (:enter (commands ...) :exit (commands ...))
`:enter' specifies the list of additional commands that only
enter `repeat-mode'. When the list is empty, then by default all
commands in the map enter `repeat-mode'. This is useful when
there is a command that has the `repeat-map' symbol property, but
doesn't exist in this specific map. `:exit' is a list of
commands that exit `repeat-mode'. When the list is empty, no
commands in the map exit `repeat-mode'. This is useful when a
command exists in this specific map, but it doesn't have the
`repeat-map' symbol property on its symbol.
enter `repeat-mode'. When the list is empty, then only the
commands defined in the map enter `repeat-mode'. Specifying a
list of commands is useful when there are commands that have the
`repeat-map' symbol property, but don't exist in this specific
map.
`:exit' is a list of commands that exit `repeat-mode'. When the
list is empty, no commands in the map exit `repeat-mode'.
Specifying a list of commands is useful when those commands exist
in this specific map, but should not have the `repeat-map' symbol
property.
\(fn VARIABLE-NAME &key DOC FULL PARENT SUPPRESS NAME PREFIX KEYMAP REPEAT &rest [KEY DEFINITION]...)"
(declare (indent 1))

3
lisp/progmodes/eglot.el
View file

@ -820,6 +820,7 @@ treated as in `eglot--dbind'."
`(:valueSet
[,@(mapcar
#'car eglot--tag-faces)])))
:window `(:workDoneProgress t)
:general (list :positionEncodings ["utf-32" "utf-8" "utf-16"])
:experimental eglot--{})))
@ -2484,7 +2485,7 @@ use the root of SERVER's `eglot--project'."
;; Set the major mode to be the first of the managed
;; modes. This is the one the user started eglot in.
(setq major-mode (car (eglot--major-modes server)))
(hack-dir-local-variables-non-file-buffer)()
(hack-dir-local-variables-non-file-buffer)
(if (functionp eglot-workspace-configuration)
(funcall eglot-workspace-configuration server)
eglot-workspace-configuration))))

13
lisp/treesit.el
View file

@ -324,13 +324,13 @@ If INCLUDE-NODE is non-nil, return NODE if it satisfies PRED."
node))
(defun treesit-parent-while (node pred)
"Return the furthest parent of NODE that satisfies PRED.
"Return the furthest parent of NODE (including NODE) that satisfies PRED.
This function successively examines the parent of NODE, then
the parent of the parent, etc., until it finds an ancestor node
which no longer satisfies the predicate PRED; it returns the last
examined ancestor that satisfies PRED. It returns nil if no
ancestor node was found that satisfies PRED.
This function successively examines NODE, the parent of NODE,
then the parent of the parent, etc., until it finds a node which
no longer satisfies the predicate PRED; it returns the last
examined node that satisfies PRED. If no node satisfies PRED, it
returns nil.
PRED should be a function that takes one argument, the node to
examine, and returns a boolean value indicating whether that
@ -1923,6 +1923,7 @@ this function depends on `treesit-defun-type-regexp' and
`treesit-defun-skipper'."
(interactive "^p\nd")
(let ((orig-point (point)))
(if (or (null arg) (= arg 0)) (setq arg 1))
(catch 'done
(dotimes (_ 2) ; Not making progress is better than infloop.

65
test/infra/gitlab-ci.yml
View file

@ -229,22 +229,27 @@ test-filenotify-gio:
# This is needed in order to get a JUnit test report.
make_params: '-k -C test check-expensive LOGFILES="lisp/autorevert-tests.log lisp/filenotify-tests.log"'
build-image-gnustep:
stage: platform-images
extends: [.job-template, .build-template, .gnustep-template]
variables:
target: emacs-gnustep
# The next two jobs are commented out due to bug#62210.
test-gnustep:
# This tests the GNUstep build process.
stage: platforms
extends: [.job-template, .gnustep-template]
needs:
- job: build-image-gnustep
optional: true
variables:
target: emacs-gnustep
make_params: install
# build-image-gnustep:
# stage: platform-images
# extends: [.job-template, .build-template, .gnustep-template]
# variables:
# target: emacs-gnustep
# test-gnustep:
# # This tests the GNUstep build process.
# stage: platforms
# extends: [.job-template, .gnustep-template]
# needs:
# - job: build-image-gnustep
# optional: true
# variables:
# target: emacs-gnustep
# make_params: install
# The next two jobs are commented out due to high workload on
# emba.gnu.org.
# build-native-comp-speed0:
# stage: native-comp-images
@ -258,21 +263,23 @@ test-gnustep:
# variables:
# target: emacs-native-comp-speed1
build-native-comp-speed2:
stage: native-comp-images
extends: [.job-template, .build-template, .native-comp-template]
variables:
target: emacs-native-comp-speed2
# The next two jobs are commented out due to bug#62211.
test-native-comp-speed2:
stage: native-comp
extends: [.job-template, .test-template, .native-comp-template]
needs:
- job: build-native-comp-speed2
optional: true
variables:
target: emacs-native-comp-speed2
make_params: "-k -C test check SELECTOR='(not (tag :unstable))'"
# build-native-comp-speed2:
# stage: native-comp-images
# extends: [.job-template, .build-template, .native-comp-template]
# variables:
# target: emacs-native-comp-speed2
# test-native-comp-speed2:
# stage: native-comp
# extends: [.job-template, .test-template, .native-comp-template]
# needs:
# - job: build-native-comp-speed2
# optional: true
# variables:
# target: emacs-native-comp-speed2
# make_params: "-k -C test check SELECTOR='(not (tag :unstable))'"
# Local Variables:
# add-log-current-defun-header-regexp: "^\\([-_.[:alnum:]]+\\)[ \t]*:"

13
test/src/comp-tests.el
View file

@ -532,6 +532,19 @@ https://lists.gnu.org/archive/html/bug-gnu-emacs/2020-03/msg00914.html."
(should (subr-native-elisp-p
(symbol-function 'comp-test-48029-nonascii-žžž-f))))
(comp-deftest 61917-1 ()
"Verify we can compile calls to redefined primitives with
dedicated byte-op code."
(let ((f (lambda (fn &rest args)
(apply fn args))))
(advice-add #'delete-region :around f)
(unwind-protect
(should (subr-native-elisp-p
(native-compile
'(lambda ()
(delete-region (point-min) (point-max))))))
(advice-remove #'delete-region f))))
;;;;;;;;;;;;;;;;;;;;;
;; Tromey's tests. ;;