Drop use of `yas--version' in doc/yas-doc-helper.el

- No longer available since 0.14.3

.gitignore

@@ -9,3 +9,7 @@ extras/imported/**
 *.elc
 ert-x.*
 ert.*
+
+# ELPA-generated files
+/yasnippet-autoloads.el
+/yasnippet-pkg.el

.travis.yml

@@ -1,5 +1,7 @@
 language: generic
-sudo: false
+os: linux
+dist: xenial
+
 git:
   submodules: false
 
@@ -8,14 +10,15 @@ env:
     - Wlexical=t
     - Werror=t
     - tests_Werror=t # For yasnippet-tests.el
-  matrix:
+  jobs:
     - EMACS_VERSION=23.4
     # 24.3 gives a bunch of 'value returned from (car value-N) is
     # unused' warnings.
     - EMACS_VERSION=24.3 tests_Werror=nil
     - EMACS_VERSION=24.5
     - EMACS_VERSION=25.3
-    - EMACS_VERSION=26-prerelease
+    - EMACS_VERSION=26.3
+    - EMACS_VERSION=27-prerelease
 
 
 install:

Makefile

@@ -0,0 +1,46 @@
+### Makefile for Yasnippet (stolen from Eglot)
+# Variables
+#
+EMACS?=emacs
+SELECTOR?=t
+ERROR_ON_WARN=nil
+
+LOAD_PATH=-L .
+
+ELFILES := yasnippet.el yasnippet-tests.el
+ELCFILES := $(ELFILES:.el=.elc)
+
+BYTECOMP_ERROR_ON_WARN := \
+	--eval '(setq byte-compile-error-on-warn $(ERROR_ON_WARN))'
+
+all: compile
+
+%.elc: %.el
+	$(EMACS) -Q $(BYTECOMP_ERROR_ON_WARN) $(LOAD_PATH) \
+		--batch -f batch-byte-compile $<
+
+compile: $(ELCFILES)
+
+# Automated tests
+#
+yasnippet-check: compile
+	$(EMACS) -Q --batch						\
+		$(LOAD_PATH)						\
+		-l yasnippet						\
+		-l yasnippet-tests						\
+		--eval '(setq ert-batch-backtrace-right-margin 200)'	\
+		--eval '(ert-run-tests-batch-and-exit (quote $(SELECTOR)))'
+
+interactive: compile
+	$(EMACS) -Q							\
+		$(LOAD_PATH)						\
+		-l yasnippet						\
+		-l yasnippet-tests						\
+
+check: yasnippet-check
+
+# Cleanup
+#
+clean:
+	find . -iname '*.elc' -exec rm {} \;
+.PHONY: all compile clean check

NEWS

@@ -1,8 +1,91 @@
 Yasnippet NEWS -- history of user-visible changes.
 
-Copyright (C) 2017-2018 Free Software Foundation, Inc.
+Copyright (C) 2017-2025 Free Software Foundation, Inc.
 See the end of the file for license conditions.
 
+Changes since 0.14.0:
+
+- Silence warning about missing lexical-binding cookie.
+- Bug fixes and code cleanups.
+- Accept ${N} as another syntax for $N (issue #1012).
+- Understand the new AUCTeX modes hierarchy (issue #1193).
+- Try and use `major-mode-remap-alist` to find the right snippets for
+  Tree Sitter modes (issue #1169).
+
+* 0.14.0 (Dec 22, 2019)
+
+** Changes
+
+*** New 'yas-auto-next' macro, automatically moves to next field.
+See Github #937.
+
+*** Yasnippet now officially requires Emacs 23 or greater.
+See Github #940.
+
+*** Snippets for 'fundamental-mode' are available in all modes.
+See Github #949, and #936.
+
+*** New function for snippets, 'yas-completing-read'.
+See Github #934.
+
+*** New function 'yas-maybe-expand-abbrev-key-filter'.
+This can be used for making conditional keybindings for snippets.
+Promoted from 'yas--maybe-expand-key-filter'.  See Github #943.
+
+*** DEL can now be used to clear fields, similar <delete>.
+It is bound to the new conditional command 'yas-maybe-clear-field', which may
+be bound to other keys as well.  See Github #960 and #957.
+
+*** Snippet field movement commands may now trigger eldoc.
+See Github #952.
+
+*** New variable 'yas-keymap-disable-hook'.
+Can be used (e.g., for company-mode) to temporarily disable
+'yas-keymap' bindings, or any binding made by the new function
+'yas-filtered-definition'.  See Github #987.
+
+*** New variable 'yas-inhibit-overlay-modification-protection'.
+This allows a snippet to remain active, even if some commands make
+modifications outside the expected area (i.e., the active snippet
+field).
+
+*** 'yas-minor-mode' is no longer enabled in temp buffers.
+That is, buffers whose name starts with a space.  This setting may be
+undone by removing 'yas-temp-buffer-p' from
+'yas-dont-activate-functions'.  See Github #985.
+
+*** Accept unescaped '{', for LSP compatibility.
+See Github #979.
+
+** Fixed bugs
+
+*** 'yas-not-string-or-comment-condition' no longer relies on 'this-command'.
+This lets it work correctly with conditional key-bindings.  See Github
+#973, #991.
+
+*** Fix snippet expansion in org src buffers.
+Note that this still doesn't work in text-mode blocks.
+See Github #976, #989.
+
+*** Fix snippet insertion for keyless snippets.
+See Github #1014.
+
+*** Fix errors with company-mode completion within snippet fields.
+See Github #995.
+
+*** Fix errors with cc-mode.
+See Github #962.
+
+*** Fix problems with lsp-mode.
+**** Improve performance in overlay heavy buffers (Github #926).
+**** Fix double call of 'before/after-change-functions' (Github #966).
+
+*** Fix errors with nested snippet expansion.
+See Github #961, #1002.
+
+*** Stop yas-field-highlight-face inheriting from bogus 'quote' face.
+
+
 * 0.13.0 (May 13, 2018)
 
 ** Changes

README.mdown

@@ -15,7 +15,7 @@ YASnippet. Watch [a demo on YouTube][youtube-demo].
 
 # Installation
 
-## Install the most recent version
+## Manual install from Git
 
 Clone this repository somewhere
 
@@ -33,12 +33,16 @@ Add your own snippets to `~/.emacs.d/snippets` by placing files there or invokin
 
 ## Install with `package-install`
 
-In a recent emacs `M-x list-packages` is the recommended way to list and install packages.
+In a recent emacs `M-x list-packages` is the recommended way to list
-[MELPA][melpa] keeps a very recent snapshot of YASnippet, see http://melpa.org/#installing.
+and install packages.
+It's available from [GNU ELPA][gnuelpa].
+If you need a very recent snapshot, you can get it from
+[GNU-devel ELPA][gnudevel] as well as [MELPA][melpa]
+(see http://melpa.org/#installing).
 
 ## Install with el-get
 
-El-get is a nice way to get the most recent version, too. See
+El-get is another nice way to get the most recent version, too. See
 https://github.com/dimitri/el-get for instructions.
 
 ## Use `yas-minor-mode` on a per-buffer basis
@@ -61,7 +65,7 @@ get some!
 1. [yasnippet-snippets] - a snippet collection package maintained by
     [AndreaCrotti](https://github.com/AndreaCrotti).
 
-    It can be installed with `M-x install-package RET
+    It can be installed with `M-x package-install RET
     yasnippet-snippets` if you have added MELPA to your package
     sources.
 
@@ -71,10 +75,6 @@ get some!
     To use these snippets you have to run the tool first, so
     [see its doc][yasmate]), and then point the `yas-snippet-dirs`
     variable to the `.../yasmate/snippets` subdir.
-
-    If you have a working ruby environment, you can probably get lucky
-    directly with `rake convert-bundles`.
-
 3.  [textmate-to-yas.el]
 
     This is another textmate bundle converting tool using Elisp
@@ -103,8 +103,9 @@ common problems and practical snippet examples.
 
 The [Github issue tracker][issues] is where most YASnippet-related
 discussion happens.  Nevertheless, since YASnippet is a part of Emacs,
-you may alternatively report bugs to the main Emacs bug list,
+you may alternatively report bugs to Emacs via `M-x report-emacs-bug` or
-bug-gnu-emacs@gnu.org, putting "yasnippet" somewhere in the subject.
+sending an email to `bug-gnu-emacs@gnu.org`, putting "yasnippet"
+somewhere in the subject.
 
 ## Important note regarding bug reporting
 
@@ -160,6 +161,8 @@ Finally, thank you very much for using YASnippet!
 [googlecode tracker]: http://code.google.com/p/yasnippet/issues/list
 [forum]: http://groups.google.com/group/smart-snippet
 [melpa]: http://melpa.milkbox.net/
+[gnuelpa]: http://elpa.gnu.org/packages/yasnippet.html
+[gnudevel]: http://elpa.gnu.org/devel/yasnippet.html
 [yasmate]: http://github.com/joaotavora/yasmate
 [textmate-to-yas.el]: https://github.com/mattfidler/textmate-to-yas.el
 [yasnippet-snippets]: http://github.com/AndreaCrotti/yasnippet-snippets

Rakefile

@@ -1,130 +0,0 @@
-# -*- Ruby -*-
-
-require 'fileutils'
-
-$EMACS = ENV["EMACS"]
-if not $EMACS or $EMACS == 't'
-  $EMACS = "emacs"
-end
-
-def find_version
-  File.read("yasnippet.el", :encoding => "UTF-8") =~ /;; Package-version: *([0-9.]+?) *$/
-  $version = $1
-end
-find_version
-FileUtils.mkdir_p('pkg')
-
-desc "run tests in batch mode"
-task :tests do
-  sh "#{$EMACS} -Q -L . -l yasnippet-tests.el" +
-    " --batch -f ert-run-tests-batch-and-exit"
-end
-
-desc "run test in interactive mode"
-task :itests do
-  sh "#{$EMACS} -Q -L . -l yasnippet-tests.el" +
-     " --eval \"(call-interactively 'ert)\""
-end
-
-desc "create a release package"
-task :package do
-  release_dir = "pkg/yasnippet-#{$version}"
-  FileUtils.mkdir_p(release_dir)
-  files = ['snippets', 'yasnippet.el']
-  FileUtils.cp_r files, release_dir
-  File.open(File.join(release_dir,'yasnippet-pkg.el'), 'w') do |file|
-    file.puts <<END
-(define-package "yasnippet"
-                "#{$version}"
-                "A template system for Emacs")
-END
-  end
-  sh "git clean -f snippets"
-  FileUtils.cd 'pkg' do
-    sh "tar cf yasnippet-#{$version}.tar yasnippet-#{$version}"
-  end
-end
-
-desc "create a release package and upload it to google code"
-task :release => [:package, 'doc:archive'] do
-  raise "Not implemented for github yet!"
-end
-
-# rake doc[../htmlize]
-#
-# To do this interactively, load doc/yas-doc-helper, open one of the
-# org files, and do `C-c C-e P'.
-desc "Generate document"
-task :doc, [:htmlize] do |t, args|
-  load_path = '-L .'
-  if args[:htmlize]
-    load_path += " -L #{args[:htmlize]}"
-  end
-  sh "#{$EMACS} -Q #{load_path} --batch -l doc/yas-doc-helper.el" +
-    " -f yas--generate-html-batch"
-end
-
-namespace :doc do
-  task :archive do
-    release_dir = "pkg/yasnippet-#{$version}"
-    FileUtils.mkdir_p(release_dir)
-    sh "tar cjf pkg/yasnippet-doc-#{$version}.tar.bz2 " +
-      "--exclude=doc/.svn --exclude=doc/images/.svn doc/*.html doc/images"
-  end
-
-  task :upload do
-    if File.exists? 'doc/gh-pages'
-      Dir.chdir 'doc/gh-pages' do
-        sh "git checkout gh-pages"
-      end
-      Dir.glob("doc/*.{html,css}").each do |file|
-        FileUtils.cp file, 'doc/gh-pages'
-      end
-      Dir.glob("doc/images/*").each do |file|
-        FileUtils.cp file, 'doc/gh-pages/images'
-      end
-      Dir.glob("doc/stylesheets/*.css").each do |file|
-        FileUtils.cp file, 'doc/gh-pages/stylesheets'
-      end
-      curRev = `git describe`.chomp()
-      expRev = IO.read('doc/html-revision').chomp()
-      if curRev != expRev
-        raise ("The HTML rev: #{expRev},\n" +
-               "current  rev: #{curRev}!\n")
-      end
-      Dir.chdir 'doc/gh-pages' do
-        sh "git commit -a -m 'Automatic documentation update.\n\n" +
-          "From #{curRev.chomp()}'"
-        sh "git push"
-      end
-    end
-  end
-end
-
-desc "Compile yasnippet.el into yasnippet.elc"
-
-rule '.elc' => '.el' do |t|
-  cmdline = $EMACS + ' --batch -L .'
-  if ENV['warnings']
-    cmdline += " --eval \"(setq byte-compile-warnings #{ENV['warnings']})\""
-  end
-  if ENV['Werror']
-    cmdline += " --eval \"(setq byte-compile-error-on-warn #{ENV['Werror']})\""
-  end
-  if ENV['Wlexical']
-    cmdline += " --eval \"(setq byte-compile-force-lexical-warnings #{ENV['Wlexical']})\""
-  end
-  cmdline +=" -f batch-byte-compile #{t.source}"
-
-  sh cmdline
-end
-task :compile => FileList["yasnippet.el"].ext('elc')
-task :compile_all => FileList["*.el"].ext('elc')
-
-task :default => :doc
-
-desc "use yasmate to convert textmate bundles"
-task :convert_bundles do
-      cd "yasmate"
-      sh "rake convert_bundles"
-    end

doc/faq.org

@@ -7,6 +7,16 @@
   the Github issue tracker.  It might be more up-to-date than this
   list.
 
+* Why are my snippet abbrev keys triggering when I don't want them too?
+Expansion of abbrev keys is controlled by [[sym:yas-key-syntaxes][=yas-key-syntaxes=]].  Try
+removing entries which correspond to the abbrev key character syntax.
+For example, if you have a snippet with abbrev key "bar", that you
+don't want to trigger when point follows the text =foo_bar=, remove
+the ="w"= entry (since "bar" has only word syntax characters).
+
+* Why aren't my snippet abbrev keys triggering when I want them too?
+See previous question, but in reverse.
+
 * Why is there an extra newline?
 
 If there is a newline at the end of a snippet definition file,
@@ -20,58 +30,39 @@ final newline automatically.
 
 * Why doesn't TAB navigation work with flyspell
 
-A workaround is to inhibit flyspell overlays while the snippet is
+This is [[https://debbugs.gnu.org/26672][Emacs Bug#26672]], so you should upgrade to version 25.3 or
-active:
+better.  Otherwise, a workaround is to inhibit flyspell overlays while
+the snippet is active:
 
 #+BEGIN_SRC emacs-lisp
   (add-hook 'flyspell-incorrect-hook
-            #'(lambda (dummy1 dummy2 dymmy3)
+            #'(lambda (&rest _)
                 (and yas-active-field-overlay
                      (overlay-buffer yas-active-field-overlay))))
 #+END_SRC
 
-This is apparently related to overlay priorities. For some reason, the
-=keymap= property of flyspell's overlays always takes priority over the
-same property in YASnippet's overlays, even if one sets the latter's
-=priority= property to something big. If you know emacs-lisp and can
-solve this problem, drop a line in the
-[[http://groups.google.com/group/smart-snippet][discussion group]].
-
 * How do I use alternative keys, i.e. not TAB?
 
-Edit the keymaps [[sym:yas-minor-mode-map][=yas-minor-mode-map=]] and
+Edit the keymaps [[sym:yas-minor-mode-map][=yas-minor-mode-map=]] and [[sym:yas-keymap][=yas-keymap=]] as you would
-[[sym:yas-keymap][=yas-keymap=]] as you would any other keymap:
+any other keymap, but use [[sym:yas-filtered-definition][=yas-filtered-definition=]] on the definition
+if you want to respect [[sym:yas-keymap-disable-hook][=yas-keymap-disable-hook=]]:
 
 #+begin_src emacs-lisp :exports code
-   (define-key yas-minor-mode-map (kbd "<tab>") nil)
+  (define-key yas-minor-mode-map (kbd "<tab>") nil)
-   (define-key yas-minor-mode-map (kbd "TAB") nil)
+  (define-key yas-minor-mode-map (kbd "TAB") nil)
-   (define-key yas-minor-mode-map (kbd "<the new key>") yas-maybe-expand)
+  (define-key yas-minor-mode-map (kbd "<the new key>") yas-maybe-expand)
 
-   ;;keys for navigation
+  ;;keys for navigation
-   (define-key yas-keymap [(tab)]       nil)
+  (define-key yas-keymap [(tab)]       nil)
-   (define-key yas-keymap (kbd "TAB")   nil)
+  (define-key yas-keymap (kbd "TAB")   nil)
-   (define-key yas-keymap [(shift tab)] nil)
+  (define-key yas-keymap [(shift tab)] nil)
-   (define-key yas-keymap [backtab]     nil)
+  (define-key yas-keymap [backtab]     nil)
-   (define-key yas-keymap (kbd "<new-next-field-key>") 'yas-next-field-or-maybe-expand)
+  (define-key yas-keymap (kbd "<new-next-field-key>")
-   (define-key yas-keymap (kbd "<new-prev-field-key>") 'yas-prev)
+    (yas-filtered-definition 'yas-next-field-or-maybe-expand))
+  (define-key yas-keymap (kbd "<new-prev-field-key>")
+    (yas-filtered-definition 'yas-prev-field))
 #+end_src
 
-* How do I turn off the minor mode where in some buffers?
-
-The best way, since version 0.6.1c, is to set the default value of the
-variable [[sym:yas-dont-activate][=yas-dont-activate=]] to a lambda function like so:
-
-#+BEGIN_SRC emacs-lisp
-  (set-default 'yas-dont-activate
-               #'(lambda ()
-                   (and yas-root-directory
-                        (null (yas-get-snippet-tables)))))
-#+END_SRC
-
-This is also the default value starting for that version. It skips the
-minor mode in buffers where it is not applicable (no snippet tables),
-but only once you have setup your yas-root-directory.
-
 * How do I define an abbrev key containing characters not supported by the filesystem?
 
 -  *Note*: This question applies if you're still defining snippets

doc/snippet-development.org

@@ -8,7 +8,7 @@
 
 There are some ways you can quickly find a snippet file or create a new one:
 
--  =M-x yas-new-snippet=, key bindind: =C-c & C-n=
+-  =M-x yas-new-snippet=, key binding: =C-c & C-n=
 
    Creates a new buffer with a template for making a new snippet.  The
    buffer is in =snippet-mode= (see [[snippet-mode][below]]).  When you are done editing
@@ -62,7 +62,7 @@ expanded.
 Optionally, if the file contains a line of =# --=, the lines above it
 count as comments, some of which can be /directives/ (or meta data).
 Snippet directives look like =# property: value= and tweak certain
-snippets properties described below. If no =# --= is found, the whole
+snippet properties described below. If no =# --= is found, the whole
 file is considered the snippet template.
 
 Here's a typical example:
@@ -94,7 +94,7 @@ was loaded from.
 
 ** =# condition:= snippet condition
 
-This is a piece of Emacs-lisp code. If a snippet has a condition, then
+This is a piece of Emacs Lisp code. If a snippet has a condition, then
 it will only be expanded when the condition code evaluate to some
 non-nil value.
 
@@ -104,7 +104,7 @@ See also [[sym:yas-buffer-local-condition][=yas-buffer-local-condition=]] in
 ** =# group:= snippet menu grouping
 
 When expanding/visiting snippets from the menu-bar menu, snippets for a
-given mode can be grouped into sub-menus . This is useful if one has too
+given mode can be grouped into sub-menus. This is useful if one has too
 many snippets for a mode which will make the menu too long.
 
 The =# group:= property only affect menu construction (See
@@ -113,14 +113,14 @@ achieved by grouping snippets into sub-directories and using the
 =.yas-make-groups= special file (for this see
 [[./snippet-organization.org][Organizing Snippets]]
 
-Refer to the bundled snippets for =ruby-mode= for examples on the
+Refer to the bundled snippets for =ruby-mode= for examples of the
 =# group:= directive. Group can also be nested, e.g.
-=control structure.loops= tells that the snippet is under the =loops=
+=control structure.loops= indicates that the snippet is under the =loops=
 group which is under the =control structure= group.
 
 ** =# expand-env:= expand environment
 
-This is another piece of Emacs-lisp code in the form of a =let= /varlist
+This is another piece of Emacs Lisp code in the form of a =let= /varlist
 form/, i.e. a list of lists assigning values to variables. It can be
 used to override variable values while the snippet is being expanded.
 
@@ -154,9 +154,9 @@ You can use this directive to expand a snippet directly from a normal
 Emacs keybinding. The keybinding will be registered in the Emacs keymap
 named after the major mode the snippet is active for.
 
-Additionally a variable [[sym:yas-prefix][=yas-prefix=]] is set to to the prefix argument
+Additionally a variable [[sym:yas-prefix][=yas-prefix=]] is set to the prefix argument
 you normally use for a command. This allows for small variations on the
-same snippet, for example in this "html-mode" snippet.
+same snippet, for example in this =html-mode= snippet.
 
 #+BEGIN_SRC snippet
   # name: <p>...</p>
@@ -172,7 +172,7 @@ will expand the paragraph tag without newlines.
 ** =# type:= =snippet= or =command=
 
 If the =type= directive is set to =command=, the body of the snippet
-is interpreted as lisp code to be evaluated when the snippet is
+is interpreted as Lisp code to be evaluated when the snippet is
 triggered.
 
 If it's =snippet= (the default when there is no =type= directive), the
@@ -202,14 +202,14 @@ usually interpreted as plain text, except =$= and =`=. You need to
 use =\= to escape them: =\$= and =\`=. The =\= itself may also needed to be
 escaped as =\\= sometimes.
 
-** Embedded Emacs-lisp code
+** Embedded Emacs Lisp code
 
-Emacs-Lisp code can be embedded inside the template, written inside
+Emacs Lisp code can be embedded inside the template, written inside
-back-quotes (=`=). The lisp forms are evaluated when the snippet is
+back-quotes (=`=). The Lisp forms are evaluated when the snippet is
 being expanded. The evaluation is done in the same buffer as the
 snippet being expanded.
 
-Here's an example for c-mode to calculate the header file guard
+Here's an example for =c-mode= to calculate the header file guard
 dynamically:
 
 #+BEGIN_SRC snippet
@@ -221,8 +221,8 @@ dynamically:
   #endif /* $1 */
 #+END_SRC
 
-From version 0.6, snippets expansions are run with some special
+From version 0.6, snippet expansions are run with some special
-Emacs-lisp variables bound. One of this is [[sym:yas-selected-text][=yas-selected-text=]]. You can
+Emacs Lisp variables bound. One of these is [[sym:yas-selected-text][=yas-selected-text=]]. You can
 therefore define a snippet like:
 
 #+BEGIN_SRC snippet
@@ -237,7 +237,7 @@ Alternatively, you can also customize the variable
 
 *** Note: backquote expressions should not modify the buffer
 
-Please note that the lisp forms in backquotes should *not* modify the
+Please note that the Lisp forms in backquotes should *not* modify the
 buffer, doing so will trigger a warning.  For example, instead of
 doing
 
@@ -284,7 +284,7 @@ The number can be omitted if you don't want to create [[mirrors-fields][mirrors]
 
 ** Mirrors <<mirrors-fields>>
 
-We refer the tab stops with placeholders as a /field/.  A field can
+We refer to tab stops with placeholders as a /field/.  A field can
 have mirrors.  *All* mirrors get updated whenever you update any field
 text.  Here's an example:
 
@@ -299,15 +299,15 @@ also be inserted at =\end{$1}=. The best explanation is to see the
 screencast([[http://www.youtube.com/watch?v=vOj7btx3ATg][YouTube]] or [[http://yasnippet.googlecode.com/files/yasnippet.avi][avi video]]).
 
 The tab stops with the same number to the field act as its mirrors. If
-none of the tab stops has an initial value, the first one is selected as
+none of the tab stops have an initial value, the first one is selected as
-the field and others mirrors.
+the field and the others are its mirrors.
 
 ** Mirrors with transformations <<mirror-transformations>>
 
 If the value of an =${n:=-construct starts with and contains =$(=,
 then it is interpreted as a mirror for field =n= with a
 transformation. The mirror's text content is calculated according to
-this transformation, which is Emacs-lisp code that gets evaluated in
+this transformation, which is Emacs Lisp code that gets evaluated in
 an environment where the variable [[sym:yas-text][=yas-text=]] is bound to the text
 content (string) contained in the field =n=. Here's an example for
 Objective-C:
@@ -378,7 +378,7 @@ due to incomplete format codes.
 
 ** Fields with transformations
 
-From version 0.6 on, you can also have lisp transformation inside
+From version 0.6 on, you can also have Lisp transformation inside
 fields. These work mostly like mirror transformations. However, they
 are evaluated when you first enter the field, after each change you
 make to the field and also just before you exit the field.
@@ -412,25 +412,38 @@ the field, and with some useful variables bound, notably
 can place a transformation in the primary field that lets you select
 default values for it.
 
-The [[sym:yas-choose-value][=yas-choose-value=]] does this work for you. For example:
+For example, the [[sym:yas-choose-value][=yas-completing-read=]] function is version of
+=completing-read= which checks these variables.  For example, asking
+the user for the initial value of a field:
 
 #+BEGIN_SRC snippet
-  <div align="${2:$$(yas-choose-value '("right" "center" "left"))}">
+  <div align="${2:$$(yas-completing-read "Alignment? " '("right" "center" "left"))}">
     $0
   </div>
 #+END_SRC
 
-See the definition of [[sym:yas-choose-value][=yas-choose-value=]] to see how it was written using
+See the definition of [[sym:yas-choose-value][=yas-completing-read=]] to see how it was written
-the two variables.
+using the two variables. If you're really lazy :) and can't spare a
+tab keypress, you can automatically move to the next field (or exit)
+after choosing the value with [[sym:yas-auto-next][=yas-auto-next=]]. The snippet above
+becomes:
 
-Here's another use, for LaTeX-mode, which calls reftex-label just as you
+#+BEGIN_SRC snippet
+  <div align="${2:$$(yas-auto-next
+                      (yas-completing-read
+                        "Alignment? "
+                        '("right" "center" "left")))}">
+    $0
+  </div>
+#+END_SRC
+
+Here's another use, for =LaTeX-mode=, which calls reftex-label just as you
 enter snippet field 2. This one makes use of [[sym:yas-modified-p][=yas-modified-p=]] directly.
 
 #+BEGIN_SRC snippet
   \section{${1:"Titel der Tour"}}%
   \index{$1}%
-  \label{{2:"waiting for reftex-label call..."$(unless yas-modified-p (reftex-label nil 'dont-
+  \label{{2:"waiting for reftex-label call..."$(unless yas-modified-p (reftex-label nil 'dont-insert))}}%
-  insert))}}%
 #+END_SRC
 
 The function [[sym:yas-verify-value][=yas-verify-value=]] has another neat trick, and makes use

doc/snippet-expansion.org

@@ -141,7 +141,7 @@ See the internal documentation on [[sym:yas-expand-snippet][=yas-expand-snippet=
 
 * Controlling expansion
 
-** Eligible snippets
+** Eligible snippets<<eligible-snippets>>
 
 YASnippet does quite a bit of filtering to find out which snippets are
 eligible for expanding at the current cursor position.
@@ -161,11 +161,13 @@ In particular, the following things matter:
    =M-x describe-variable RET major-mode RET= to find out which major
    mode you are in currently.
 
--  Parent tables
+- Parent tables
 
-   Snippet tables defined as the parent of some other eligible table are
+  Snippet tables defined as the parent of some other eligible table
-   also considered. This works recursively, i.e. parents of parents of
+  are also considered.  This works recursively, i.e., parents of
-   eligible tables are also considered.
+  parents of eligible tables are also considered.  As a special case,
+  if a mode doesn't have a parent, then =fundamental-mode= is
+  considered to be its parent.
 
 -  Buffer-local list of extra modes
 
@@ -208,11 +210,12 @@ inside a comment?  Set [[sym:yas-buffer-local-condition][=yas-buffer-local-condi
 
 #+BEGIN_SRC emacs-lisp
   (add-hook 'python-mode-hook
-            (lambda ()
+	    (lambda ()
-              (setq yas-buffer-local-condition
+	      (setq yas-buffer-local-condition
-                    '(if (python-syntax-comment-or-string-p)
+	            (lambda ()
-                         '(require-snippet-condition . force-in-comment)
+		      (if (python-syntax-comment-or-string-p)
-                       t))))
+			  '(require-snippet-condition . force-in-comment)
+		        t)))))
 #+END_SRC
 
 ... and for a snippet that you want to expand in comments, specify a
@@ -225,7 +228,7 @@ For the full set of possible conditions, see the documentation for
 
 ** Multiples snippet with the same key
 
-The rules outlined [[Eligible%20snippets][above]] can return more than
+The rules outlined [[eligible-snippets][above]] can return more than
 one snippet to be expanded at point.
 
 When there are multiple candidates, YASnippet will let you select one.

doc/snippet-organization.org

@@ -33,7 +33,7 @@
    The default considers:
 
     - a personal collection that lives in =~/.emacs.d/snippets=
-    - the bundled collection, taken as a relative path to =yasnippet.el= localtion
+    - the bundled collection, taken as a relative path to =yasnippet.el= location
 
    When you come across other snippet collections, do the following to try them
    out:

doc/yas-doc-helper.el

@@ -1,6 +1,6 @@
-;;; yas-doc-helper.el --- Help generate documentation for YASnippet
+;;; yas-doc-helper.el --- Help generate documentation for YASnippet  -*- lexical-binding: t; -*-
 
-;; Copyright (C) 2012, 2013  Free Software Foundation, Inc.
+;; Copyright (C) 2012-2023  Free Software Foundation, Inc.
 
 ;; Author: João Távora <joaotavora@gmail.com>
 ;; Keywords: convenience
@@ -25,12 +25,17 @@
 ;;; Code:
 
 (eval-when-compile
-  (require 'cl))
+  (require 'cl-lib))
 (require 'org)
-(or (require 'org-publish nil t)
+(require 'ox-publish)
-    (require 'ox-publish))
 (require 'yasnippet) ; docstrings must be loaded
 
+;; Presumably one of org/ox-publish provided the following vars:
+(defvar org-publish-project-alist)
+(defvar org-publish-use-timestamps-flag)
+(defvar org-export-copy-to-kill-ring)
+(defvar org-html-htmlize-output-type)
+
 (defun yas--org-raw-html (tag content &optional attrs)
   ;; in version 8.0 org-mode changed the export syntax, see
   ;; http://orgmode.org/worg/org-8.0.html#sec-8-1
@@ -132,24 +137,24 @@
 (defun yas--document-symbols (level &rest names-and-predicates)
   (let ((sym-lists (make-vector (length names-and-predicates) nil))
         (stars (make-string level ?*)))
-    (loop for sym in yas--exported-syms
+    (cl-loop for sym in yas--exported-syms
-          do (loop for test in (mapcar #'cdr names-and-predicates)
+             do (cl-loop for test in (mapcar #'cdr names-and-predicates)
-                   for i from 0
+                         for i from 0
-                   do (when (funcall test sym)
+                         do (when (funcall test sym)
-                        (push sym (aref sym-lists i))
+                              (push sym (aref sym-lists i))
-                        (return))))
+                              (cl-return))))
-    (loop for slist across sym-lists
+    (cl-loop for slist across sym-lists
-          for name in (mapcar #'car names-and-predicates)
+             for name in (mapcar #'car names-and-predicates)
-          concat (format "\n%s %s\n" stars name)
+             concat (format "\n%s %s\n" stars name)
-          concat (mapconcat (lambda (sym)
+             concat (mapconcat (lambda (sym)
-                              (yas--document-symbol sym (1+ level)))
+                                 (yas--document-symbol sym (1+ level)))
-                            slist "\n\n"))))
+                               slist "\n\n"))))
 
 (defun yas--internal-link-snippet ()
   (interactive)
   (yas-expand-snippet "[[#$1][=${1:`yas/selected-text`}=]]"))
 
-(define-key org-mode-map [M-f8] 'yas--internal-link-snippet)
+(define-key org-mode-map [M-f8] #'yas--internal-link-snippet)
 
 ;; This lets all the org files be exported to HTML with
 ;; `org-publish-current-project' (C-c C-e P).
@@ -194,7 +199,7 @@ But replace link to \"current\" page with a span element."
           ;;:with-broken-links mark
           :html-postamble
           ,(concat "<hr><p class='creator'>Generated by %c from "
-                   (or rev yas--version) " " date "</p>\n"
+                   rev " " date "</p>\n"
                    "<p class='xhtml-validation'>%v</p>\n")))
        (project (assoc "yasnippet" org-publish-project-alist)))
   (when rev ;; Rakefile :doc:upload uses "html-revision".

yasnippet-debug.el

@@ -1,6 +1,6 @@
 ;;; yasnippet-debug.el --- debug functions for yasnippet -*- lexical-binding: t -*-
 
-;; Copyright (C) 2010, 2013-2014, 2017-2018  Free Software Foundation, Inc.
+;; Copyright (C) 2010-2025  Free Software Foundation, Inc.
 
 ;; Author: João Távora
 ;; Keywords: emulations, convenience
@@ -40,9 +40,6 @@
                         ;; Don't require '-L <path>' when debugging.
                         (expand-file-name "yasnippet" yas--loaddir)))
 (require 'cl-lib)
-(eval-when-compile
-  (unless (fboundp 'cl-flet)
-    (defalias 'cl-flet 'flet)))
 (require 'color nil t)
 (require 'edebug)
 (eval-when-compile
@@ -141,7 +138,9 @@
          (decorator-end (overlay-get ov 'after-string))
          (beg (yas-debug-ov-fom-start range))
          (end (yas-debug-ov-fom-end range)))
-    (if (and beg end (not (integerp beg)) (not (integerp end)))
+    (if (and beg end (or (overlayp range)
+                         (and (not (integerp beg))
+                              (not (integerp end)))))
         (propertize (format "from %d to %d" (+ beg) (+ end))
                     'cursor-sensor-functions
                     `(,(lambda (_window _oldpos dir)
@@ -155,7 +154,7 @@
       "<dead>")))
 
 (defmacro yas-debug-with-tracebuf (outbuf &rest body)
-  (declare (indent 1))
+  (declare (indent 1) (debug (sexp body)))
   (let ((tracebuf-var (make-symbol "tracebuf")))
     `(let ((,tracebuf-var (or ,outbuf (get-buffer-create "*YASnippet trace*"))))
        (unless (eq ,tracebuf-var (current-buffer))
@@ -222,13 +221,13 @@
   (setq yas-debug-undo value)
   (yas--message 3 "debug undo %sabled" (if yas-debug-undo "en" "dis")))
 
-(defadvice yas--snippet-parse-create (before yas-debug-target-snippet (snippet))
+(defun yas-debug--target-snippet (snippet)
   (add-to-list 'yas-debug-target-snippets snippet))
 
-(defadvice yas--commit-snippet (after yas-debug-untarget-snippet (snippet))
+(defun yas-debug--untarget-snippet (snippet)
   (setq yas-debug-target-snippets
         (remq snippet yas-debug-target-snippets))
-  (maphash (lambda (k color-ov)
+  (maphash (lambda (_k color-ov)
              (delete-overlay (cdr color-ov)))
            yas-debug-live-indicators)
   (clrhash yas-debug-live-indicators))
@@ -252,6 +251,8 @@ buffer-locally, otherwise install it globally.  If HOOK is
             (setq yas-debug-target-snippets
                   (cl-delete-if-not #'yas--snippet-p yas-debug-target-snippets)))
           (let ((yas-debug-recently-live-indicators nil))
+            (printf "(length yas--snippets-snippets) => %d\n"
+                    (length yas--active-snippets))
             (dolist (snippet (or yas-debug-target-snippets
                                  (yas-active-snippets)))
               (printf "snippet %d\n" (yas--snippet-id snippet))
@@ -267,10 +268,8 @@ buffer-locally, otherwise install it globally.  If HOOK is
                      do (printf "%S\n" undo-elem))))
         (when hook
           (setq yas-debug-target-buffer (current-buffer))
-          (ad-enable-advice 'yas--snippet-parse-create 'before 'yas-debug-target-snippet)
+          (advice-add 'yas--snippet-parse-create :before #'yas-debug--target-snippet)
-          (ad-activate 'yas--snippet-parse-create)
+          (advice-add 'yas--commit-snippet :after #'yas-debug--untarget-snippet)
-          (ad-enable-advice 'yas--commit-snippet 'after 'yas-debug-untarget-snippet)
-          (ad-activate 'yas--commit-snippet)
           (add-hook 'post-command-hook #'yas-debug-snippets
                     nil (eq hook 'snippet-navigation))
           ;; Window management is slapped together, it does what I

yasnippet-tests.el

@@ -1,8 +1,8 @@
 ;;; yasnippet-tests.el --- some yasnippet tests  -*- lexical-binding: t -*-
 
-;; Copyright (C) 2012-2015, 2017-2018  Free Software Foundation, Inc.
+;; Copyright (C) 2012-2025  Free Software Foundation, Inc.
 
-;; Author: João Távora <joaot@siscog.pt>
+;; Author: João Távora <joaot@siscog.pt>
 ;; Keywords: emulations, convenience
 
 ;; This program is free software; you can redistribute it and/or modify
@@ -121,7 +121,8 @@ This lets `yas--maybe-expand-from-keymap-filter' work as expected."
         (funcall fn)
       (cl-loop for var in vars
                for saved in saved-values
-               do (set var saved)))))
+               do (unless (eq (symbol-value var) saved) ;Beware read-only vars!
+                    (set var saved))))))
 
 (defun yas-call-with-snippet-dirs (dirs fn)
   (let* ((default-directory (make-temp-file "yasnippet-fixture" t))
@@ -136,20 +137,6 @@ This lets `yas--maybe-expand-from-keymap-filter' work as expected."
 
 ;;; Older emacsen
 ;;;
-(unless (fboundp 'special-mode)
-  ;; FIXME: Why provide this default definition here?!?
-  (defalias 'special-mode 'fundamental))
-
-(unless (fboundp 'string-suffix-p)
-  ;; introduced in Emacs 24.4
-  (defun string-suffix-p (suffix string &optional ignore-case)
-    "Return non-nil if SUFFIX is a suffix of STRING.
-If IGNORE-CASE is non-nil, the comparison is done without paying
-attention to case differences."
-    (let ((start-pos (- (length string) (length suffix))))
-      (and (>= start-pos 0)
-           (eq t (compare-strings suffix nil nil
-                                  string start-pos nil ignore-case))))))
 
 
 ;;; Snippet mechanics
@@ -193,6 +180,20 @@ attention to case differences."
     (should (string= (yas--buffer-contents)
                      "bla from another BLA"))))
 
+(ert-deftest yas-mirror-many-fields ()
+  (with-temp-buffer
+    (yas-minor-mode 1)
+    (yas-expand-snippet "${1:brother} and ${2:brother} are${1:$(if (string= (yas-field-value 1) (yas-field-value 2)) \" \" \" not \")}the same word")
+    (should (string= (yas--buffer-contents)
+                     "brother and brother are the same word"))
+    (yas-mock-insert "bla")
+    (should (string= (yas--buffer-contents)
+                     "bla and brother are not the same word"))
+    (ert-simulate-command '(yas-next-field-or-maybe-expand))
+    (yas-mock-insert "bla")
+    (should (string= (yas--buffer-contents)
+                     "bla and bla are the same word"))))
+
 (ert-deftest mirror-with-transformation-and-autofill ()
   "Test interaction of autofill with mirror transforms"
   (let ((words "one two three four five")
@@ -332,6 +333,31 @@ attention to case differences."
         (ert-simulate-command '(undo))  ; Redo (re-expand snippet).
         (should (string-match-p "\\`one,and done" (buffer-string)))))))
 
+(ert-deftest undo-revive-and-do-again ()
+  "Check undo-revived snippet is properly ended."
+  ;; See https://github.com/joaotavora/yasnippet/issues/1006.
+  (yas-with-snippet-dirs '((".emacs.d/snippets"
+                            ("emacs-lisp-mode" ("x" . "${1:one},and done"))))
+    (with-temp-buffer
+      (emacs-lisp-mode)
+      (yas-reload-all)
+      (yas-minor-mode 1)
+      (yas-expand-snippet "x$0")
+      (setq buffer-undo-list nil)
+      (ert-simulate-command '(yas-expand))
+      (push nil buffer-undo-list)
+      (ert-simulate-command '(yas-next-field)) ; $1 -> exit snippet.
+      (should (string-match-p "\\`one,and done" (buffer-string)))
+      (push nil buffer-undo-list)
+      (ert-simulate-command '(undo))    ; Revive snippet.
+      (yas-mock-insert "abc")
+      (ert-simulate-command '(yas-next-field)) ; $1 -> exit snippet again.
+      (should (string-match-p "\\`abc,and done" (buffer-string)))
+      ;; We should have exited snippet and cleaned up any overlays.
+      (should-not (cl-some (lambda (o) (overlay-get o 'yas--snippet))
+                           (overlays-in (point-min) (point-max)))))))
+
+
 (defun yas-test-expand-and-undo (mode snippet-entry initial-contents)
   (yas-with-snippet-dirs
    `((".emacs.d/snippets" (,(symbol-name mode) ,snippet-entry)))
@@ -517,16 +543,19 @@ XXXXX   ------------------------"))))
     (yas-mock-insert "foo bar")
     (ert-simulate-command '(yas-next-field))
     (goto-char (point-min))
-    (let ((expected (with-temp-buffer
+    ;; The default value of `org-adapt-indentation' changed between Org-mode 9.4
-                      (insert (format (concat "* Test foo bar\n"
+    ;; and 9.5, so force a specific value.
-                                              "  " org-property-format "\n"
+    (let* ((org-adapt-indentation nil)
-                                              "  " org-property-format "\n"
+           (expected (with-temp-buffer
-                                              "  " org-property-format)
+                       (insert (format (concat "* Test foo bar\n"
-                                      ":PROPERTIES:" ""
+                                               org-property-format "\n"
-                                      ":ID:" "foo bar-after"
+                                               org-property-format "\n"
-                                      ":END:" ""))
+                                               org-property-format)
-                      (delete-trailing-whitespace)
+                                       ":PROPERTIES:" ""
-                      (buffer-string))))
+                                       ":ID:" "foo bar-after"
+                                       ":END:" ""))
+                       (delete-trailing-whitespace)
+                       (buffer-string))))
       ;; Some org-mode versions leave trailing whitespace, some don't.
       (delete-trailing-whitespace)
       (should (equal expected (buffer-string))))))
@@ -556,6 +585,22 @@ int foo()
   }
 }" (buffer-string)))))
 
+(ert-deftest indent-cc-mode-2 ()
+  "Handling of cc-mode's preprocessor indentation."
+  (with-temp-buffer
+    (c-mode)
+    (yas-minor-mode +1)
+    (yas-expand-snippet "\
+#ifndef `\"FOO\"`
+#define FOO
+#endif
+")
+    (should (string= "\
+#ifndef FOO
+#define FOO
+#endif
+" (buffer-substring-no-properties (point-min) (point-max))))))
+
 (ert-deftest indent-snippet-mode ()
   "Handling of snippet-mode indentation."
   ;; This is an interesting case because newlines match [[:space:]] in
@@ -578,6 +623,28 @@ int foo()
     ;; Assuming 2 space indent.
     (should (string= "def xxx\n  xxx\nend" (buffer-string)))))
 
+(defun yas-test-delete-and-insert-command (beg end new)
+  "Simulate a completion command (similar to company-mode)."
+  (interactive "r\ns")
+  ;; Simulate a completion command (like what company-mode does)
+  ;; which deletes the "xxx" and then replaces it with something
+  ;; else.
+  (delete-region beg end)
+  (insert new))
+
+(ert-deftest indent-mirrors-on-complex-update ()
+  "Don't get messed up by command that deletes and then inserts."
+  (with-temp-buffer
+    (ruby-mode)
+    (yas-minor-mode 1)
+    (yas-expand-snippet "def foo\n  ${1:slice} = append($1)\nend")
+    (yas-mock-insert "xxx")
+    (ert-simulate-command `(yas-test-delete-and-insert-command
+                            ,(- (point) 3) ,(point) ,"yyy"))
+    ;; Assuming 2 space indent.
+    (should (string= "def foo\n  yyy = append(yyy)\nend" (buffer-string)))))
+
+
 
 (ert-deftest snippet-with-multiline-mirrors-issue-665 ()
   "In issue 665, a multi-line mirror is attempted."
@@ -603,9 +670,37 @@ mapconcat #'(lambda (arg)
       (ert-simulate-command '(yas-next-field))
       (should (looking-at (concat "blo" expected))))))
 
+(defmacro yas-saving-variables (&rest body)
+  (declare (debug t))
+  `(yas-call-with-saving-variables #'(lambda () ,@body)))
+
+(ert-deftest auto-next-field ()
+  "Automatically exit a field after evaluating its transform."
+  (with-temp-buffer
+    (yas-saving-variables
+     (yas-with-snippet-dirs
+      `((".emacs.d/snippets"
+         ("ruby-mode" ("snip" . ,(concat "foo ${1:$$"
+                                         (prin1-to-string '(yas-auto-next
+                                                            (yas-choose-value
+                                                             "bar" "foo")))
+                                         "} ${2:$$"
+                                         (prin1-to-string '(yas-auto-next
+                                                            (yas-choose-value
+                                                             "too" "foo")))
+                                         "} baz ${3:quinn} quinn")))))
+      (yas-reload-all)
+      (ruby-mode)
+      (yas-minor-mode 1)
+      (set (make-local-variable 'yas-prompt-functions) `(yas-no-prompt))
+      (yas-mock-insert "snip")
+      (ert-simulate-command '(yas-expand))
+      (yas-mock-insert "quux")
+      (should (equal "foo bar too baz quux quinn" (buffer-string)))))))
+
 
 ;;; Snippet expansion and character escaping
-;;; Thanks to @zw963 (Billy) for the testing
+;; Thanks to @zw963 (Billy) for the testing
 ;;;
 (ert-deftest escape-dollar ()
   (with-temp-buffer
@@ -676,6 +771,20 @@ mapconcat #'(lambda (arg)
       (yas-expand-snippet "Look ma! ${1:`(yas-selected-text)`} OK?")
       (should (string= (yas--buffer-contents) "Look ma! He)}o world! OK?")))))
 
+(ert-deftest escaping-for-lsp-style-snippet-syntax ()
+  "See Github #979."
+  (should
+   (string= (with-temp-buffer
+              (yas-minor-mode 1)
+              (yas-expand-snippet
+               "Printf(${1:format string}, ${2:args ...interface{\\}})${0}")
+              (yas--buffer-contents))
+            (with-temp-buffer
+              (yas-minor-mode 1)
+              (yas-expand-snippet
+               "Printf(${1:format string}, ${2:args ...interface\\{\\}})${0}")
+              (yas--buffer-contents)))))
+
 (ert-deftest insert-snippet-with-backslashes-in-active-field ()
   ;; This test case fails if `yas--inhibit-overlay-hooks' is not bound
   ;; in `yas-expand-snippet' (see Github #844).
@@ -728,7 +837,7 @@ mapconcat #'(lambda (arg)
   ;; See https://github.com/joaotavora/yasnippet/issues/800.
   (with-temp-buffer
     (yas-minor-mode 1)
-    (should-error (yas-expand-snippet "```foo\n\n```"))
+    (yas-expand-snippet "```foo\n\n```")
     (erase-buffer) ; Bad snippet may leave wrong text.
     ;; But expanding the corrected snippet should work fine.
     (yas-expand-snippet "\\`\\`\\`foo\n\n\\`\\`\\`")
@@ -736,6 +845,8 @@ mapconcat #'(lambda (arg)
 
 (defmacro yas--with-font-locked-temp-buffer (&rest body)
   "Like `with-temp-buffer', but ensure `font-lock-mode'."
+  ;; NOTE: Replace all uses of this with `font-lock-ensure' when we
+  ;; drop support for Emacs 24.
   (declare (indent 0) (debug t))
   (let ((temp-buffer (make-symbol "temp-buffer")))
     ;; NOTE: buffer name must not start with a space, otherwise
@@ -754,11 +865,9 @@ mapconcat #'(lambda (arg)
              (and (buffer-name ,temp-buffer)
                   (kill-buffer ,temp-buffer))))))))
 
-(defmacro yas-saving-variables (&rest body)
-  (declare (debug t))
-  `(yas-call-with-saving-variables #'(lambda () ,@body)))
-
 (ert-deftest example-for-issue-474 ()
+  ;; This issue only reproduces in Emacs 24.3, most likely due to some
+  ;; bug in the cc-mode included with that Emacs version.
   (yas--with-font-locked-temp-buffer
     (c-mode)
     (yas-minor-mode 1)
@@ -832,6 +941,18 @@ mapconcat #'(lambda (arg)
       (yas-mock-insert "baz")
       (should (string= (yas--buffer-contents) "foobaaarbazok")))))
 
+(ert-deftest yas-escaping-close-brace ()
+  "Close braces may be escaped with braces, reduction from eglot issue.
+See https://github.com/joaotavora/eglot/issues/336."
+  (with-temp-buffer
+    (yas-minor-mode +1)
+    ;; NOTE: put a period at the end to avoid the bug tested by
+    ;; `protection-overlay-no-cheating'.
+    (yas-expand-snippet "${1:one{\\}}, ${2:two{\\}}.")
+    (yas-next-field)
+    (yas-next-field)
+    (should (string= (buffer-string) "one{}, two{}."))))
+
 
 ;;; Misc tests
 ;;;
@@ -948,7 +1069,7 @@ hello ${1:$(when (stringp yas-text) (funcall func yas-text))} foo${1:$$(concat \
            ("'quote" . "OKquoteOK"))))
        (yas-reload-all)
        (emacs-lisp-mode)
-       (yas-minor-mode-on)
+       (yas-minor-mode +1)
        (let ((yas-key-syntaxes '("w" "w_")))
          (let ((yas--barbaz t))
            (yas-should-expand '(("foo-barbaz" . "foo-OKbarbazOK")
@@ -984,6 +1105,24 @@ hello ${1:$(when (stringp yas-text) (funcall func yas-text))} foo${1:$$(concat \
         (should (= (length (yas--snippet-fields (nth 0 snippets))) 2))
         (should (= (length (yas--snippet-fields (nth 1 snippets))) 1))))))
 
+(ert-deftest nested-snippet-expansion-depth-2 ()
+  (with-temp-buffer
+    (yas-with-snippet-dirs
+      '((".emacs.d/snippets"
+         ("text-mode"
+          ("nest" . "( $1"))))
+      (let ((yas-triggers-in-field t))
+        (yas-reload-all)
+        (text-mode)
+        (yas-minor-mode +1)
+        (dotimes (_ 3)
+          (yas-mock-insert "nest")
+          (ert-simulate-command '(yas-expand)))
+        (dotimes (_ 3)
+          (yas-mock-insert ")")
+          (ert-simulate-command '(yas-next-field-or-maybe-expand)))
+        ))))
+
 (ert-deftest nested-snippet-expansion-2 ()
   (let ((yas-triggers-in-field t))
     (yas-with-snippet-dirs
@@ -1030,20 +1169,64 @@ hello ${1:$(when (stringp yas-text) (funcall func yas-text))} foo${1:$$(concat \
       (ert-simulate-command '(yas-next-field-or-maybe-expand))
       (should (string= (buffer-string) "\\sqrt[3]{\\sqrt[5]{2}}")))))
 
+(ert-deftest nested-snippet-expansion-4 ()
+  "See Github #959."
+  (let ((yas-triggers-in-field t))
+    (yas-with-snippet-dirs
+     '((".emacs.d/snippets"
+        ("text-mode"
+         ("ch" . "<-${1:ch}"))))
+     (yas-reload-all)
+     (text-mode)
+     (yas-minor-mode +1)
+     (yas-expand-snippet "ch$0\n")
+     (ert-simulate-command '(yas-expand))
+     (ert-simulate-command '(forward-char 2))
+     (ert-simulate-command '(yas-expand))
+     (yas-mock-insert "abc")
+     (ert-simulate-command '(yas-next-field-or-maybe-expand))
+     (yas-mock-insert "def")
+     (ert-simulate-command '(yas-next-field-or-maybe-expand))
+     (should (string= (buffer-string) "<-<-abcdef\n")))))
+
+(ert-deftest nested-snippet-expansion-5-nested-delete ()
+  "See Github #996."
+  (let ((yas-triggers-in-field t))
+    (yas-with-snippet-dirs
+     '((".emacs.d/snippets"
+        ("text-mode"
+         ("sel" . "${1:ch}")
+         ("ch" . "<-${1:ch}"))))
+     (yas-reload-all)
+     (text-mode)
+     (yas-minor-mode +1)
+     (insert "sel")
+     (ert-simulate-command '(yas-expand))
+     (ert-simulate-command '(forward-word 1))
+     (ert-simulate-command '(yas-expand))
+     (ert-simulate-command '(forward-word 1))
+     ;; The (cl-assert (memq pfield (yas--snippet-fields psnippet)))
+     ;; in `yas--on-field-overlay-modification' failed here.
+     (ert-simulate-command '(delete-backward-char 1))
+     (should (string= (buffer-string) "<-c\n")))))
+
 
 ;;; Loading
 ;;;
 
 (defmacro yas-with-overriden-buffer-list (&rest body)
   (declare (debug t))
+  ;; FIXME: This macro was added by commit 185c771dedea as part of the
+  ;; fix for https://github.com/joaotavora/yasnippet/issues/253,
+  ;; but I don't know why it was/is needed.
   (let ((saved-sym (make-symbol "yas--buffer-list")))
     `(let ((,saved-sym (symbol-function 'buffer-list)))
        (cl-letf (((symbol-function 'buffer-list)
-                  (lambda ()
+                  (lambda (&rest args)
                     (cl-remove-if (lambda (buf)
                                     (with-current-buffer buf
                                       (eq major-mode 'lisp-interaction-mode)))
-                                  (funcall ,saved-sym)))))
+                                  (apply ,saved-sym args)))))
          ,@body))))
 
 
@@ -1122,7 +1305,7 @@ hello ${1:$(when (stringp yas-text) (funcall func yas-text))} foo${1:$$(concat \
      (yas-minor-mode +1)
      (should (equal (yas--template-content (yas-lookup-snippet "one"))
                     "one"))
-     (should (eq (yas--key-binding "\C-c1") 'yas-expand-from-keymap))
+     (should (eq (yas--key-binding "\C-c1") #'yas-expand-from-keymap))
      (yas-define-snippets
       'text-mode '(("_1" "one!" "won" nil nil nil nil nil "uuid-1")))
      (should (null (yas-lookup-snippet "one" nil 'noerror)))
@@ -1190,19 +1373,20 @@ hello ${1:$(when (stringp yas-text) (funcall func yas-text))} foo${1:$$(concat \
      (yas-reload-all)
      (with-temp-buffer
        (let* ((major-mode 'c-mode)
-              (expected `(c-mode
+              (expected `(fundamental-mode
+                          c-mode
                           cc-mode
                           yet-another-c-mode
                           and-also-this-one
                           and-that-one
-                          ;; prog-mode doesn't exist in emacs 23.4
+                          prog-mode
-                          ,@(if (fboundp 'prog-mode)
+                          ,@(if (fboundp 'lisp-data-mode) ;Emacs≥28
-                                '(prog-mode))
+                                '(lisp-data-mode))
                           emacs-lisp-mode
                           lisp-interaction-mode))
               (observed (yas--modes-to-activate)))
          (should (equal major-mode (car observed)))
-         (should (equal (sort expected #'string<) (sort observed #'string<))))))))
+         (should-not (cl-set-exclusive-or expected observed)))))))
 
 (ert-deftest extra-modes-parenthood ()
   "Test activation of parents of `yas--extra-modes'."
@@ -1219,39 +1403,44 @@ hello ${1:$(when (stringp yas-text) (funcall func yas-text))} foo${1:$$(concat \
        (yas-activate-extra-mode 'and-that-one)
        (let* ((expected-first `(and-that-one
                                 yet-another-c-mode
-                                c-mode
+                                c-mode))
-                                ,major-mode))
               (expected-rest `(cc-mode
-                               ;; prog-mode doesn't exist in emacs 23.4
+                               prog-mode
-                               ,@(if (fboundp 'prog-mode)
+                               ,@(if (fboundp 'lisp-data-mode) ;Emacs≥28
-                                     '(prog-mode))
+                                     '(lisp-data-mode))
                                emacs-lisp-mode
                                and-also-this-one
                                lisp-interaction-mode))
-              (observed (yas--modes-to-activate)))
+              (observed (remq 'fundamental-mode (yas--modes-to-activate))))
-         (should (equal expected-first
+         (should-not (cl-set-exclusive-or
-                        (cl-subseq observed 0 (length expected-first))))
+                      expected-first
-         (should (equal (sort expected-rest #'string<)
+                      (cl-subseq observed 0 (length expected-first))))
-                        (sort (cl-subseq observed (length expected-first)) #'string<))))))))
+         (should-not (cl-set-exclusive-or
+                      expected-rest
+                      (cl-subseq observed (length expected-first)))))))))
 
-(defalias 'yas--phony-c-mode 'c-mode)
+(defalias 'yas--phony-c-mode #'c-mode)
 
 (ert-deftest issue-492-and-494 ()
+  "Aliases like `yas--phony-c-mode' should be considered as \"derived\"."
   (define-derived-mode yas--test-mode yas--phony-c-mode "Just a test mode")
   (yas-with-snippet-dirs '((".emacs.d/snippets"
                             ("yas--test-mode")))
-                         (yas-reload-all)
+    (yas-reload-all)
-                         (with-temp-buffer
+    (with-temp-buffer
-                           (let* ((major-mode 'yas--test-mode)
+      (let* ((major-mode 'yas--test-mode)
-                                  (expected `(c-mode
+             (expected `(fundamental-mode
-                                              ,@(if (fboundp 'prog-mode)
+                         c-mode
-                                                    '(prog-mode))
+                         yas--phony-c-mode
-                                              yas--phony-c-mode
+                         yas--test-mode))
-                                              yas--test-mode))
+             ;; The set of mode depends on some external factors:
-                                  (observed (yas--modes-to-activate)))
+             ;; `prog-mode': if cc-mode.el has been loaded.
-                             (should (null (cl-set-exclusive-or expected observed)))
+             ;; `cc-mode': if we added `cc-mode' as yas--parent of `c-mode'.
-                             (should (= (length expected)
+             (observed (cl-set-difference (yas--modes-to-activate)
-                                        (length observed)))))))
+                                          '(prog-mode cc-mode))))
+        (should-not (cl-set-exclusive-or expected observed))
+        (should (= (length expected)
+                   (length observed)))))))
 
 (define-derived-mode yas--test-mode c-mode "Just a test mode")
 (define-derived-mode yas--another-test-mode c-mode "Another test mode")
@@ -1455,31 +1644,31 @@ TODO: be meaner"
     (with-temp-buffer
       (yas-minor-mode -1)
       (insert "foo")
-      (should (not (eq (key-binding (yas--read-keybinding "<tab>")) 'yas-expand)))
+      (should-not (eq (key-binding (kbd "TAB")) #'yas-expand))
       (yas-minor-mode 1)
-      (should (eq (key-binding (yas--read-keybinding "<tab>")) 'yas-expand))
+      (should (eq (key-binding (kbd "TAB")) #'yas-expand))
       (yas-expand-snippet "$1 $2 $3")
-      (should (eq (key-binding [(tab)]) 'yas-next-field-or-maybe-expand))
+      ;; (should (eq (key-binding [tab]) #'yas-next-field-or-maybe-expand))
-      (should (eq (key-binding (kbd "TAB")) 'yas-next-field-or-maybe-expand))
+      (should (eq (key-binding (kbd "TAB")) #'yas-next-field-or-maybe-expand))
-      (should (eq (key-binding [(shift tab)]) 'yas-prev-field))
+      (should (eq (key-binding [(shift tab)]) #'yas-prev-field))
-      (should (eq (key-binding [backtab]) 'yas-prev-field))))))
+      (should (eq (key-binding [backtab]) #'yas-prev-field))))))
 
 (ert-deftest test-rebindings ()
-  (let* ((yas-minor-mode-map (copy-keymap yas-minor-mode-map))
+  (let* ((test-map (make-composed-keymap nil yas-minor-mode-map))
          (minor-mode-map-alist
-          (cons `(yas-minor-mode . ,yas-minor-mode-map)
+          (cons `(yas-minor-mode . ,test-map)
                 (cl-remove 'yas-minor-mode minor-mode-map-alist
                            :test #'eq :key #'car))))
-    (define-key yas-minor-mode-map [tab] nil)
+    (define-key test-map [tab] nil)
-    (define-key yas-minor-mode-map (kbd "TAB") nil)
+    (define-key test-map (kbd "TAB") nil)
-    (define-key yas-minor-mode-map (kbd "SPC") 'yas-expand)
+    (define-key test-map (kbd "SPC") #'yas-expand)
     (with-temp-buffer
       (yas-minor-mode 1)
-      (should-not (eq (key-binding (kbd "TAB")) 'yas-expand))
+      (should-not (eq (key-binding (kbd "TAB")) #'yas-expand))
-      (should (eq (key-binding (kbd "SPC")) 'yas-expand))
+      (should (eq (key-binding (kbd "SPC")) #'yas-expand))
       (yas-reload-all)
-      (should-not (eq (key-binding (kbd "TAB")) 'yas-expand))
+      (should-not (eq (key-binding (kbd "TAB")) #'yas-expand))
-      (should (eq (key-binding (kbd "SPC")) 'yas-expand)))))
+      (should (eq (key-binding (kbd "SPC")) #'yas-expand)))))
 
 (ert-deftest test-yas-in-org ()
   (yas-saving-variables
@@ -1492,20 +1681,40 @@ TODO: be meaner"
       (org-mode)
       (yas-minor-mode 1)
       (insert "foo")
-      (should (eq (key-binding [(tab)]) 'yas-expand))
+      ;; (should (eq (key-binding [tab]) #'yas-expand))
-      (should (eq (key-binding (kbd "TAB")) 'yas-expand))))))
+      (should (eq (key-binding (kbd "TAB")) #'yas-expand))))))
 
-(ert-deftest yas-org-native-tab-in-source-block ()
+(ert-deftest yas-org-native-tab-in-source-block-text ()
   "Test expansion of snippets in org source blocks."
-  :expected-result (if (and (fboundp 'org-in-src-block-p) (version< (org-version) "9"))
+  ;; org 9+ no longer runs fontification for text-mode, so our hacks
+  ;; don't work.  Note that old ert doesn't have skipping, so we have
+  ;; to expect failure instead.  Starting with Org-mode 9.5 this seems
+  ;; to work again.
+  :expected-result (if (and (fboundp 'org-in-src-block-p)
+                            (or (version< (org-version) "9")
+                                (version<= "9.5" (org-version))))
                        :passed :failed)
+  (let ((text-mode-hook #'yas-minor-mode))
+    (do-yas-org-native-tab-in-source-block "text")))
+
+(ert-deftest yas-org-native-tab-in-source-block-emacs-lisp ()
+  "Test expansion of snippets in org source blocks."
+  :expected-result (if (fboundp 'org-in-src-block-p)
+                       :passed :failed)
+  (let ((emacs-lisp-mode-hook #'yas-minor-mode)
+        ;; This makes the test a bit less comprehensive, but it's
+        ;; needed to avoid bumping into Emacs Bug#35264.
+        (org-src-preserve-indentation t))
+    (do-yas-org-native-tab-in-source-block "emacs-lisp")))
+
+(defun do-yas-org-native-tab-in-source-block (mode)
   (yas-saving-variables
    (yas-with-snippet-dirs
-    '((".emacs.d/snippets"
+    `((".emacs.d/snippets"
-       ("text-mode"
+       (,(concat mode "-mode")
         ("T" . "${1:one} $1\n${2:two} $2\n<<$0>> done!"))))
-    (let ((text-mode-hook '(yas-minor-mode))
+    ;; Binding both text and prog mode hook should cover everything.
-          (org-src-tab-acts-natively t)
+    (let ((org-src-tab-acts-natively t)
           ;; Org 8.x requires this in order for
           ;; `org-src-tab-acts-natively' to have effect.
           (org-src-fontify-natively t))
@@ -1514,8 +1723,8 @@ TODO: be meaner"
       (yas--with-font-locked-temp-buffer
        (org-mode)
        (yas-minor-mode 1)
-       (insert "#+BEGIN_SRC text\nT\n#+END_SRC")
+       (insert "#+BEGIN_SRC " mode "\nT\n#+END_SRC")
-       (if (fboundp 'font-lock-ensure)
+       (if (fboundp 'font-lock-ensure)  ;Emacs≥25
            (font-lock-ensure)
          (jit-lock-fontify-now))
        (re-search-backward "^T$") (goto-char (match-end 0))
@@ -1530,9 +1739,9 @@ TODO: be meaner"
        ;; Check snippet expansion, ignore leading whitespace due to
        ;; `org-edit-src-content-indentation'.
        (should (looking-at "\
-[[:space:]]*one one
+\[[:space:]]*one one
-[[:space:]]*two two
+\[[:space:]]*two two
-[[:space:]]*<<>> done!")))))))
+\[[:space:]]*<<>> done!")))))))
 
 
 (ert-deftest test-yas-activate-extra-modes ()
@@ -1548,7 +1757,7 @@ add the snippets associated with the given mode."
            ("car" . "(car )"))))
        (yas-reload-all)
        (emacs-lisp-mode)
-       (yas-minor-mode-on)
+       (yas-minor-mode +1)
        (yas-activate-extra-mode 'markdown-mode)
        (should (eq 'markdown-mode (car yas--extra-modes)))
        (yas-should-expand '(("_" . "_Text_ ")))