merge master

13 files changed, 942 insertions, 124 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 674b26716a4..b7a38af9609 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,107 @@
+2015-01-15  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/eieio-core.el: Provide support for cl-generic.
+        (eieio--generic-tagcode): New function.
+        (cl-generic-tagcode-function): Use it.
+        (eieio--generic-tag-types): New function.
+        (cl-generic-tag-types-function): Use it.
+        (eieio-object-p): Tighten up the test.
+
+        * emacs-lisp/cl-generic.el (cl-generic-define-method): Fix paren typo.
+
+2015-01-14  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/cl-generic.el: New file.
+
+        * emacs-lisp/cl-macs.el (cl-flet): Allow (FUN EXP) forms.
+        (cl-load-time-value, cl-labels): Use closures rather than
+        backquoted lambdas.
+        (cl-macrolet): Use `eval' to create the function value, and support CL
+        style arguments in for the defined macros.
+
+2015-01-14  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * net/eww.el: Use lexical-binding.
+        (eww-links-at-point): Remove unused arg.
+        (eww-mode-map): Inherit from special-mode-map.
+        (eww-mode): Derive from special-mode.  Don't use `setq' on a hook.
+
+2015-01-13  Alan Mackenzie  <acm@muc.de>
+
+        Allow compilation during loading of Modes derived from a CC Mode mode.
+        Fixes debbugs#19206.
+
+        * progmodes/cc-bytecomp.el (cc-bytecomp-compiling-or-loading):
+        New function which walks the stack to discover whether we're compiling
+        or loading.
+        (cc-bytecomp-is-compiling): Reformulate, and move towards
+        beginning.
+        (cc-bytecomp-is-loading): New defsubst.
+        (cc-bytecomp-setup-environment, cc-bytecomp-restore-environment):
+        Use the above defsubsts.
+        (cc-require-when-compile, cc-bytecomp-defvar)
+        (cc-bytecomp-defun): Simplify conditionals.
+
+        * progmodes/cc-defs.el (cc-bytecomp-compiling-or-loading):
+        "Borrow" this function from cc-bytecomp.el.
+        (c-get-current-file): Reformulate using the above.
+        (c-lang-defconst): Prevent duplicate entries of file names in a
+        symbol's 'source property.
+        (c-lang-const): Use cc-bytecomp-is-compiling.
+
+        * progmodes/cc-langs.el (c-make-init-lang-vars-fun):
+        Use cc-bytecomp-is-compiling.
+
+2015-01-13  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/eieio-core.el (eieio-defclass): Fix call to `defclass'
+        (bug#19552).
+
+2015-01-13  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * menu-bar.el (menu-bar-goto-menu): Before calling
+        `xref-marker-stack-empty-p', first check that `xref' is loaded.
+        (Bug#19554)
+
+2015-01-12  Martin Rudalics  <rudalics@gmx.at>
+
+        * progmodes/xref.el (xref-marker-stack-empty-p): Add autoload
+        cookie (Bug#19554).
+
+        * frame.el (frame-notice-user-settings): Remove code dealing with
+        frame-initial-frame-tool-bar-height.  Turn off `tool-bar-mode'
+        only if `window-system-frame-alist' or `default-frame-alist' ask
+        for it.
+        (make-frame): Update frame-adjust-size-history if needed.
+
+2015-01-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Have 'make' output better GEN names
+        * Makefile.in (PHONY_EXTRAS): New macro.
+        (.PHONY): Depend on it, and on $(lisp)/loaddefs.el, so that the
+        relevant files' time stamps are ignored.
+        (custom-deps, $(lisp)/cus-load.el, finder-data)
+        ($(lisp)/finder-inf.el): Use PHONY_EXTRAS.
+        (custom-deps, $(lisp)/cus-load.el, finder-data)
+        ($(lisp)/finder-inf.el, autoloads, $(lisp)/loaddefs.el)
+        ($(lisp)/subdirs.el, update-subdirs):
+        Output more-accurate destination names with GEN.
+
+        Say "ELC foo.elc" instead of "GEN foo.elc"
+        * Makefile.in (AM_V_ELC, am__v_ELC_, am__v_ELC_0, am__v_ELC_1):
+        New macros.
+        ($(THEFILE)c, .el.elc): Use them.
+
+2015-01-11  Michael Albinus  <michael.albinus@gmx.de>
+
+        * files.el (directory-files-recursively): Do not include
+        superfluous remote file names.
+
+2015-01-11  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * net/eww.el (eww): Interpret anything that looks like a protocol
+        designator as a full URL.
+
 2015-01-10  Lars Magne Ingebrigtsen  <larsi@gnus.org>
 
         * net/shr.el (shr-urlify): Don't bother the user about
@@ -363,8 +467,8 @@
         to `pre-command-hook'.
         (xref--xref-buffer-mode-map): Don't remap `next-line' and
         `previous-line'.  Additionally bind `xref-next-line' and
-        `xref-prev-line' to `n' and `p' respectively.  Bind
-        `xref-show-location-at-point' to `C-o'.
+        `xref-prev-line' to `n' and `p' respectively.
+        Bind `xref-show-location-at-point' to `C-o'.
 
 2015-01-01  Eli Zaretskii  <eliz@gnu.org>
 
@@ -553,15 +657,15 @@
         Add argument MSG to display user-friendly message when no process
         is running.
         (python-shell-switch-to-shell): Call pop-to-buffer with NORECORD.
-        (python-shell-make-comint): Rename argument SHOW from POP.  Use
-        display-buffer instead of pop-to-buffer.
+        (python-shell-make-comint): Rename argument SHOW from POP.
+        Use display-buffer instead of pop-to-buffer.
         (run-python): Doc fix.  Return process.
         (python-shell-get-or-create-process): Make obsolete.
 
 2014-12-27  Fabián Ezequiel Gallina  <fgallina@gnu.org>
 
-        * progmodes/python.el (python-shell-buffer-substring): Handle
-        cornercase when region sent starts at point-min.
+        * progmodes/python.el (python-shell-buffer-substring):
+        Handle cornercase when region sent starts at point-min.
 
 2014-12-27  Eli Zaretskii  <eliz@gnu.org>
 
@@ -733,8 +837,8 @@
 
 2014-12-25  Filipp Gunbin  <fgunbin@fastmail.fm>
 
-        * dired-aux.el (dired-maybe-insert-subdir): Make
-        dired-maybe-insert-subdir always skip trivial files.
+        * dired-aux.el (dired-maybe-insert-subdir):
+        Make dired-maybe-insert-subdir always skip trivial files.
 
 2014-12-25  Helmut Eller  <eller.helmut@gmail.com>
             Dmitry Gutov  <dgutov@yandex.ru>
@@ -779,8 +883,8 @@
 
         * window.el (mouse-autoselect-window-position-1): New variable.
         (mouse-autoselect-window-cancel)
-        (mouse-autoselect-window-select, handle-select-window): With
-        delayed autoselection select window only if mouse moves after
+        (mouse-autoselect-window-select, handle-select-window):
+        With delayed autoselection select window only if mouse moves after
         selecting its frame.
 
 2014-12-24  Michael Albinus  <michael.albinus@gmx.de>
diff --git a/lisp/Makefile.in b/lisp/Makefile.in
index 565ca77de3b..7bf53861e71 100644
--- a/lisp/Makefile.in
+++ b/lisp/Makefile.in
@@ -31,6 +31,11 @@ XARGS_LIMIT = @XARGS_LIMIT@
 # 'make' verbosity.
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 
+AM_V_ELC = $(am__v_ELC_@AM_V@)
+am__v_ELC_ = $(am__v_ELC_@AM_DEFAULT_V@)
+am__v_ELC_0 = @echo "  ELC     " $@;
+am__v_ELC_1 =
+
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN     " $@;
@@ -145,7 +150,8 @@ setwins_for_subdirs=for file in `find ${srcdir} -type d -print`; do \
 # we add them here to make sure they get built.
 all: compile-main $(lisp)/cus-load.el $(lisp)/finder-inf.el
 
-.PHONY: all custom-deps finder-data autoloads update-subdirs
+PHONY_EXTRAS =
+.PHONY: all custom-deps finder-data autoloads update-subdirs $(PHONY_EXTRAS)
 
 # custom-deps and finder-data both used to scan _all_ the *.el files.
 # This could lead to problems in parallel builds if automatically
@@ -161,18 +167,19 @@ all: compile-main $(lisp)/cus-load.el $(lisp)/finder-inf.el
 # Nowadays these commands don't scan automatically generated files,
 # since they will never contain any useful information
 # (see finder-no-scan-regexp and custom-dependencies-no-scan-regexp).
-$(lisp)/cus-load.el:
-        $(MAKE) custom-deps
 custom-deps:
+        $(AM_V_at)$(MAKE) PHONY_EXTRAS=$(lisp)/cus-load.el $(lisp)/cus-load.el
+$(lisp)/cus-load.el:
         $(AM_V_GEN)$(setwins_almost); \
         echo Directories: $$wins; \
         $(emacs) -l cus-dep \
           --eval '(setq generated-custom-dependencies-file (unmsys--file-name "$(srcdir)/cus-load.el"))' \
           -f custom-make-dependencies $$wins
 
-$(lisp)/finder-inf.el:
-        $(MAKE) finder-data
 finder-data:
+        $(AM_V_at)$(MAKE) PHONY_EXTRAS=$(lisp)/finder-inf.el \
+          $(lisp)/finder-inf.el
+$(lisp)/finder-inf.el:
         $(AM_V_GEN)$(setwins_finder); \
         echo Directories: $$wins; \
         $(emacs) -l finder \
@@ -185,21 +192,22 @@ finder-data:
 # Note that we set no-update-autoloads in _generated_ leim files.
 # If you want to allow autoloads in such files, remove that,
 # and make this depend on leim.
-autoloads: $(LOADDEFS)
+autoloads .PHONY: $(lisp)/loaddefs.el
+$(lisp)/loaddefs.el: $(LOADDEFS)
         $(AM_V_GEN)$(setwins_almost); \
         echo Directories: $$wins; \
         $(emacs) -l autoload \
             --eval '(setq autoload-ensure-writable t)' \
             --eval '(setq autoload-builtin-package-versions t)' \
-            --eval '(setq generated-autoload-file (expand-file-name (unmsys--file-name "$(srcdir)/loaddefs.el")))' \
+            --eval '(setq generated-autoload-file (expand-file-name (unmsys--file-name "$@")))' \
             -f batch-update-autoloads $$wins
 
 # This is required by the bootstrap-emacs target in ../src/Makefile, so
 # we know that if we have an emacs executable, we also have a subdirs.el.
 $(lisp)/subdirs.el:
-        $(MAKE) update-subdirs
+        $(AM_V_GEN)$(MAKE) update-subdirs
 update-subdirs:
-        $(AM_V_GEN)$(setwins_for_subdirs); \
+        $(AM_V_at)$(setwins_for_subdirs); \
         for file in $$wins; do \
            $(srcdir)/../build-aux/update-subdirs $$file; \
         done;
@@ -260,7 +268,7 @@ TAGS: $(lisptagsfiles1) $(lisptagsfiles2) $(lisptagsfiles3) $(lisptagsfiles4)
 THEFILE = no-such-file
 .PHONY: $(THEFILE)c
 $(THEFILE)c:
-        $(AM_V_GEN)$(emacs) $(BYTE_COMPILE_FLAGS) \
+        $(AM_V_ELC)$(emacs) $(BYTE_COMPILE_FLAGS) \
                 -l bytecomp -f byte-compile-refresh-preloaded \
                 -f batch-byte-compile $(THEFILE)
 
@@ -276,7 +284,7 @@ $(THEFILE)c:
 # An old-fashioned suffix rule, which, according to the GNU Make manual,
 # cannot have prerequisites.
 .el.elc:
-        $(AM_V_GEN)$(emacs) $(BYTE_COMPILE_FLAGS) -f batch-byte-compile $<
+        $(AM_V_ELC)$(emacs) $(BYTE_COMPILE_FLAGS) -f batch-byte-compile $<
 
 .PHONY: compile-first compile-main compile compile-always
 
diff --git a/lisp/emacs-lisp/cl-generic.el b/lisp/emacs-lisp/cl-generic.el
new file mode 100644
index 00000000000..41a419a3c4a
--- /dev/null
+++ b/lisp/emacs-lisp/cl-generic.el
@@ -0,0 +1,607 @@
+;;; cl-generic.el --- CLOS-style generic functions for Elisp  -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2015 Free Software Foundation, Inc.
+
+;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This implements the most of CLOS's multiple-dispatch generic functions.
+;; To use it you need either (require 'cl-generic) or (require 'cl-lib).
+;; The main entry points are: `cl-defgeneric' and `cl-defmethod'.
+
+;; Missing elements:
+;; - We don't support next-method-p, make-method, call-method,
+;;   define-method-combination.
+;; - Method and generic function objects: CLOS defines methods as objects
+;;   (same for generic functions), whereas we don't offer such an abstraction.
+;; - `no-next-method' should receive the "calling method" object, but since we
+;;   don't have such a thing, we pass nil instead.
+;; - In defgeneric we don't support the options:
+;;   declare, :method-combination, :generic-function-class, :method-class,
+;;   :method.
+;; Added elements:
+;; - We support aliases to generic functions.
+;; - The kind of thing on which to dispatch can be extended.
+;;   There is support in this file for (eql <val>) dispatch as well as dispatch
+;;   on the type of CL structs, and eieio-core.el adds support for EIEIO
+;;   defclass objects.
+
+;;; Code:
+
+;; Note: For generic functions that dispatch on several arguments (i.e. those
+;; which use the multiple-dispatch feature), we always use the same "tagcodes"
+;; and the same set of arguments on which to dispatch.  This works, but is
+;; often suboptimal since after one dispatch, the remaining dispatches can
+;; usually be simplified, or even completely skipped.
+
+(eval-when-compile (require 'cl-lib))
+(eval-when-compile (require 'pcase))
+
+(defvar cl-generic-tagcode-function
+  (lambda (type _name)
+    (if (eq type t) '(0 . 'cl--generic-type)
+      (error "Unknown specializer %S" type)))
+  "Function to get the Elisp code to extract the tag on which we dispatch.
+Takes a \"parameter-specializer-name\" and a variable name, and returns
+a pair (PRIORITY . CODE) where CODE is an Elisp expression that should be
+used to extract the \"tag\" (from the object held in the named variable)
+that should uniquely determine if we have a match
+\(i.e. the \"tag\" is the value that will be used to dispatch to the proper
+method(s)).
+Such \"tagcodes\" will be or'd together.
+PRIORITY is an integer from 0 to 100 which is used to sort the tagcodes
+in the `or'.  The higher the priority, the more specific the tag should be.
+More specifically, if PRIORITY is N and we have two objects X and Y
+whose tag (according to TAGCODE) is `eql', then it should be the case
+that for all other (PRIORITY . TAGCODE) where PRIORITY ≤ N, then
+\(eval TAGCODE) for X is `eql' to (eval TAGCODE) for Y.")
+
+(defvar cl-generic-tag-types-function
+  (lambda (tag) (if (eq tag 'cl--generic-type) '(t)))
+  "Function to get the list of types that a given \"tag\" matches.
+They should be sorted from most specific to least specific.")
+
+(cl-defstruct (cl--generic
+               (:constructor nil)
+               (:constructor cl--generic-make
+                (name &optional dispatches method-table))
+               (:predicate nil))
+  (name nil :read-only t)               ;Pointer back to the symbol.
+  ;; `dispatches' holds a list of (ARGNUM . TAGCODES) where ARGNUM is the index
+  ;; of the corresponding argument and TAGCODES is a list of (PRIORITY . EXP)
+  ;; where the EXPs are expressions (to be `or'd together) to compute the tag
+  ;; on which to dispatch and PRIORITY is the priority of each expression to
+  ;; decide in which order to sort them.
+  ;; The most important dispatch is last in the list (and the least is first).
+  dispatches
+  ;; `method-table' is a list of
+  ;; ((SPECIALIZERS . QUALIFIER) USES-CNM . FUNCTION), where
+  ;; USES-CNM is a boolean indicating if FUNCTION calls `cl-call-next-method'
+  ;; (and hence expects an extra argument holding the next-method).
+  method-table)
+
+(defmacro cl--generic (name)
+  `(get ,name 'cl--generic))
+
+(defun cl-generic-ensure-function (name)
+  (let (generic
+        (origname name))
+    (while (and (null (setq generic (cl--generic name)))
+                (fboundp name)
+                (symbolp (symbol-function name)))
+      (setq name (symbol-function name)))
+    (unless (or (not (fboundp name))
+                (and (functionp name) generic))
+      (error "%s is already defined as something else than a generic function"
+             origname))
+    (if generic
+        (cl-assert (eq name (cl--generic-name generic)))
+      (setf (cl--generic name) (setq generic (cl--generic-make name)))
+      (defalias name (cl--generic-make-function generic)))
+    generic))
+
+(defun cl--generic-setf-rewrite (name)
+  (let ((setter (intern (format "cl-generic-setter--%s" name))))
+    (cons setter
+          `(eval-and-compile
+             (unless (eq ',setter (get ',name 'cl-generic-setter))
+               ;; (when (get ',name 'gv-expander)
+               ;;   (error "gv-expander conflicts with (setf %S)" ',name))
+               (setf (get ',name 'cl-generic-setter) ',setter)
+               (gv-define-setter ,name (val &rest args)
+                 (cons ',setter (cons val args))))))))
+
+;;;###autoload
+(defmacro cl-defgeneric (name args &rest options-and-methods)
+  "Create a generic function NAME.
+DOC-STRING is the base documentation for this class.  A generic
+function has no body, as its purpose is to decide which method body
+is appropriate to use.  Specific methods are defined with `defmethod'.
+With this implementation the ARGS are currently ignored.
+OPTIONS-AND-METHODS is currently only used to specify the docstring,
+via (:documentation DOCSTRING)."
+  (declare (indent 2) (doc-string 3))
+  (let* ((docprop (assq :documentation options-and-methods))
+         (doc (cond ((stringp (car-safe options-and-methods))
+                     (pop options-and-methods))
+                    (docprop
+                     (prog1
+                         (cadr docprop)
+                       (setq options-and-methods
+                             (delq docprop options-and-methods)))))))
+    `(progn
+       ,(when (eq 'setf (car-safe name))
+          (pcase-let ((`(,setter . ,code) (cl--generic-setf-rewrite
+                                           (cadr name))))
+            (setq name setter)
+            code))
+       (defalias ',name
+         (cl-generic-define ',name ',args ',options-and-methods)
+         ,doc))))
+
+(defun cl--generic-mandatory-args (args)
+  (let ((res ()))
+    (while (not (memq (car args) '(nil &rest &optional &key)))
+      (push (pop args) res))
+    (nreverse res)))
+
+;;;###autoload
+(defun cl-generic-define (name args options-and-methods)
+  (let ((generic (cl-generic-ensure-function name))
+        (mandatory (cl--generic-mandatory-args args))
+        (apo (assq :argument-precedence-order options-and-methods)))
+    (setf (cl--generic-dispatches generic) nil)
+    (when apo
+      (dolist (arg (cdr apo))
+        (let ((pos (memq arg mandatory)))
+          (unless pos (error "%S is not a mandatory argument" arg))
+          (push (list (- (length mandatory) (length pos)))
+                (cl--generic-dispatches generic)))))
+    (setf (cl--generic-method-table generic) nil)
+    (cl--generic-make-function generic)))
+
+(defvar cl-generic-current-method-specializers nil
+  ;; This is let-bound during macro-expansion of method bodies, so that those
+  ;; bodies can be optimized knowing that the specializers have matched.
+  ;; FIXME: This presumes the formal arguments aren't modified via `setq' and
+  ;; aren't shadowed either ;-(
+  ;; FIXME: This might leak outside the scope of the method if, during
+  ;; macroexpansion of the method, something causes some other macroexpansion
+  ;; (e.g. an autoload).
+  "List of (VAR . TYPE) where TYPE is var's specializer.")
+
+(eval-and-compile         ;Needed while compiling the cl-defmethod calls below!
+  (defun cl--generic-fgrep (vars sexp)    ;Copied from pcase.el.
+    "Check which of the symbols VARS appear in SEXP."
+    (let ((res '()))
+      (while (consp sexp)
+        (dolist (var (cl--generic-fgrep vars (pop sexp)))
+          (unless (memq var res) (push var res))))
+      (and (memq sexp vars) (not (memq sexp res)) (push sexp res))
+      res))
+
+  (defun cl--generic-lambda (args body with-cnm)
+    "Make the lambda expression for a method with ARGS and BODY."
+    (let ((plain-args ())
+          (cl-generic-current-method-specializers nil)
+          (doc-string (if (stringp (car-safe body)) (pop body)))
+          (mandatory t))
+      (dolist (arg args)
+        (push (pcase arg
+                ((or '&optional '&rest '&key) (setq mandatory nil) arg)
+                ((and `(,name . ,type) (guard mandatory))
+                 (push (cons name (car type))
+                       cl-generic-current-method-specializers)
+                 name)
+                (_ arg))
+              plain-args))
+      (setq plain-args (nreverse plain-args))
+      (let ((fun `(cl-function (lambda ,plain-args
+                                 ,@(if doc-string (list doc-string))
+                                 ,@body))))
+        (if (not with-cnm)
+            (cons nil fun)
+          ;; First macroexpand away the cl-function stuff (e.g. &key and
+          ;; destructuring args, `declare' and whatnot).
+          (pcase (macroexpand fun macroexpand-all-environment)
+            (`#'(lambda ,args . ,body)
+             (require 'cl-lib)          ;Needed to expand `cl-flet'.
+             (let* ((doc-string (and doc-string (stringp (car body))
+                                     (pop body)))
+                    (cnm (make-symbol "cl--cnm"))
+                    (nbody (macroexpand-all
+                            `(cl-flet ((cl-call-next-method ,cnm))
+                               ,@body)
+                            macroexpand-all-environment))
+                    ;; FIXME: Rather than `grep' after the fact, the
+                    ;; macroexpansion should directly set some flag when cnm
+                    ;; is used.
+                    ;; FIXME: Also, optimize the case where call-next-method is
+                    ;; only called with explicit arguments.
+                    (uses-cnm (cl--generic-fgrep (list cnm) nbody)))
+               (cons (not (not uses-cnm))
+                     `#'(lambda (,@(if uses-cnm (list cnm)) ,@args)
+                          ,@(if doc-string (list doc-string))
+                          ,nbody))))
+            (f (error "Unexpected macroexpansion result: %S" f))))))))
+
+
+;;;###autoload
+(defmacro cl-defmethod (name args &rest body)
+  "Define a new method for generic function NAME.
+I.e. it defines the implementation of NAME to use for invocations where the
+value of the dispatch argument matches the specified TYPE.
+The dispatch argument has to be one of the mandatory arguments, and
+all methods of NAME have to use the same argument for dispatch.
+The dispatch argument and TYPE are specified in ARGS where the corresponding
+formal argument appears as (VAR TYPE) rather than just VAR.
+
+The optional second argument QUALIFIER is a specifier that
+modifies how the method is combined with other methods, including:
+   :before  - Method will be called before the primary
+   :after   - Method will be called after the primary
+   :around  - Method will be called around everything else
+The absence of QUALIFIER means this is a \"primary\" method.
+
+Other than a type, TYPE can also be of the form `(eql VAL)' in
+which case this method will be invoked when the argument is `eql' to VAL.
+
+\(fn NAME [QUALIFIER] ARGS &rest [DOCSTRING] BODY)"
+  (declare (doc-string 3) (indent 2))
+  (let ((qualifiers nil))
+    (while (keywordp args)
+      (push args qualifiers)
+      (setq args (pop body)))
+    (pcase-let* ((with-cnm (not (memq (car qualifiers) '(:before :after))))
+                 (`(,uses-cnm . ,fun) (cl--generic-lambda args body with-cnm)))
+      `(progn
+         ,(when (eq 'setf (car-safe name))
+            (pcase-let ((`(,setter . ,code) (cl--generic-setf-rewrite
+                                             (cadr name))))
+              (setq name setter)
+              code))
+         (cl-generic-define-method ',name ',qualifiers ',args
+                                   ,uses-cnm ,fun)))))
+
+;;;###autoload
+(defun cl-generic-define-method (name qualifiers args uses-cnm function)
+  (when (> (length qualifiers) 1)
+    (error "We only support a single qualifier per method: %S" qualifiers))
+  (unless (memq (car qualifiers) '(nil :primary :around :after :before))
+    (error "Unsupported qualifier in: %S" qualifiers))
+  (let* ((generic (cl-generic-ensure-function name))
+         (mandatory (cl--generic-mandatory-args args))
+         (specializers
+          (mapcar (lambda (arg) (if (consp arg) (cadr arg) t)) mandatory))
+         (key (cons specializers (or (car qualifiers) ':primary)))
+         (mt (cl--generic-method-table generic))
+         (me (assoc key mt))
+         (dispatches (cl--generic-dispatches generic))
+         (i 0))
+    (dolist (specializer specializers)
+      (let* ((tagcode (funcall cl-generic-tagcode-function specializer 'arg))
+             (x (assq i dispatches)))
+        (if (not x)
+            (setf (cl--generic-dispatches generic)
+                  (setq dispatches (cons (list i tagcode) dispatches)))
+          (unless (member tagcode (cdr x))
+            (setf (cdr x)
+                  (nreverse (sort (cons tagcode (cdr x))
+                                  #'car-less-than-car)))))
+        (setq i (1+ i))))
+    (if me (setcdr me (cons uses-cnm function))
+      (setf (cl--generic-method-table generic)
+            (cons `(,key ,uses-cnm . ,function) mt)))
+    ;; For aliases, cl--generic-name gives us the actual name.
+    (defalias (cl--generic-name generic)
+      (cl--generic-make-function generic))))
+
+(defmacro cl--generic-with-memoization (place &rest code)
+  (declare (indent 1) (debug t))
+  (gv-letplace (getter setter) place
+    `(or ,getter
+         ,(macroexp-let2 nil val (macroexp-progn code)
+            `(progn
+               ,(funcall setter val)
+               ,val)))))
+
+(defvar cl--generic-dispatchers (make-hash-table :test #'equal))
+
+(defun cl--generic-get-dispatcher (tagcodes dispatch-arg)
+  (cl--generic-with-memoization
+      (gethash (cons dispatch-arg tagcodes) cl--generic-dispatchers)
+    (let ((lexical-binding t)
+          (extraargs ()))
+      (dotimes (_ dispatch-arg)
+        (push (make-symbol "arg") extraargs))
+      (byte-compile
+       `(lambda (generic dispatches-left)
+          (let ((method-cache (make-hash-table :test #'eql)))
+            (lambda (,@extraargs arg &rest args)
+              (apply (cl--generic-with-memoization
+                         (gethash (or ,@(mapcar #'cdr tagcodes)) method-cache)
+                       (cl--generic-cache-miss
+                        generic ',dispatch-arg dispatches-left
+                        (list ,@(mapcar #'cdr tagcodes))))
+                     ,@extraargs arg args))))))))
+
+(defun cl--generic-make-function (generic)
+  (let* ((dispatches (cl--generic-dispatches generic))
+         (dispatch
+          (progn
+            (while (and dispatches
+                        (member (cdar dispatches)
+                                '(nil ((0 . 'cl--generic-type)))))
+              (setq dispatches (cdr dispatches)))
+            (pop dispatches))))
+    (if (null dispatch)
+        (cl--generic-build-combined-method
+         (cl--generic-name generic)
+         (cl--generic-method-table generic))
+      (let ((dispatcher (cl--generic-get-dispatcher
+                         (cdr dispatch) (car dispatch))))
+        (funcall dispatcher generic dispatches)))))
+
+(defun cl--generic-nest (fun methods)
+  (pcase-dolist (`(,uses-cnm . ,method) methods)
+    (setq fun
+          (if (not uses-cnm) method
+            (let ((next fun))
+              (lambda (&rest args)
+                (apply method
+                       ;; FIXME: This sucks: passing just `next' would
+                       ;; be a lot more efficient than the lambda+apply
+                       ;; quasi-η, but we need this to implement the
+                       ;; "if call-next-method is called with no
+                       ;; arguments, then use the previous arguments".
+                       (lambda (&rest cnm-args)
+                         (apply next (or cnm-args args)))
+                       args))))))
+  fun)
+
+(defvar cl--generic-combined-method-memoization
+  (make-hash-table :test #'equal :weakness 'value)
+  "Table storing previously built combined-methods.
+This is particularly useful when many different tags select the same set
+of methods, since this table then allows us to share a single combined-method
+for all those different tags in the method-cache.")
+
+(defun cl--generic-build-combined-method (generic-name methods)
+  (let ((mets-by-qual ()))
+    (dolist (qm methods)
+      (push (cdr qm) (alist-get (cdar qm) mets-by-qual)))
+    (cl--generic-with-memoization
+        (gethash (cons generic-name mets-by-qual)
+                 cl--generic-combined-method-memoization)
+      (cond
+       ((null mets-by-qual) (lambda (&rest args)
+                             (cl-no-applicable-method generic-name args)))
+       (t
+        (let* ((fun (lambda (&rest args)
+                      ;; FIXME: CLOS passes as second arg the "calling method".
+                      ;; We don't currently have "method objects" like CLOS
+                      ;; does so we can't really do it the CLOS way.
+                      ;; The closest would be to pass the lambda corresponding
+                      ;; to the method, but the caller wouldn't be able to do
+                      ;; much with it anyway.  So we pass nil for now.
+                      (apply #'cl-no-next-method generic-name nil args)))
+               ;; We use `cdr' to drop the `uses-cnm' annotations.
+               (before
+                (mapcar #'cdr (reverse (alist-get :before mets-by-qual))))
+               (after (mapcar #'cdr (alist-get :after mets-by-qual))))
+          (setq fun (cl--generic-nest fun (alist-get :primary mets-by-qual)))
+          (when (or after before)
+            (let ((next fun))
+              (setq fun (lambda (&rest args)
+                          (dolist (bf before)
+                            (apply bf args))
+                          (apply next args)
+                          (dolist (af after)
+                            (apply af args))))))
+          (cl--generic-nest fun (alist-get :around mets-by-qual))))))))
+
+(defun cl--generic-cache-miss (generic dispatch-arg dispatches-left tags)
+  (let ((types (apply #'append (mapcar cl-generic-tag-types-function tags)))
+        (methods '()))
+    (dolist (method-desc (cl--generic-method-table generic))
+      (let ((m (member (nth dispatch-arg (caar method-desc)) types)))
+        (when m
+          (push (cons (length m) method-desc) methods))))
+    ;; Sort the methods, most specific first.
+    ;; It would be tempting to sort them once and for all in the method-table
+    ;; rather than here, but the order might depend on the actual argument
+    ;; (e.g. for multiple inheritance with defclass).
+    (setq methods (nreverse (mapcar #'cdr (sort methods #'car-less-than-car))))
+    (cl--generic-make-function (cl--generic-make (cl--generic-name generic)
+                                                 dispatches-left methods))))
+
+;;; Define some pre-defined generic functions, used internally.
+
+(define-error 'cl-no-method "No method for %S")
+(define-error 'cl-no-next-method "No next method for %S" 'cl-no-method)
+(define-error 'cl-no-applicable-method "No applicable method for %S"
+  'cl-no-method)
+
+(cl-defgeneric cl-no-next-method (generic method &rest args)
+  "Function called when `cl-call-next-method' finds no next method.")
+(cl-defmethod cl-no-next-method ((generic t) method &rest args)
+  (signal 'cl-no-next-method `(,generic ,method ,@args)))
+
+(cl-defgeneric cl-no-applicable-method (generic &rest args)
+  "Function called when a method call finds no applicable method.")
+(cl-defmethod cl-no-applicable-method ((generic t) &rest args)
+  (signal 'cl-no-applicable-method `(,generic ,@args)))
+
+(defun cl-call-next-method (&rest _args)
+  "Function to call the next applicable method.
+Can only be used from within the lexical body of a primary or around method."
+  (error "cl-call-next-method only allowed inside primary and around methods"))
+
+;;; Add support for describe-function
+
+(add-hook 'help-fns-describe-function-functions 'cl--generic-describe)
+(defun cl--generic-describe (function)
+  ;; FIXME: Fix up the main "in `<file>'" hyperlink, and add such hyperlinks
+  ;; for each method.
+  (let ((generic (if (symbolp function) (cl--generic function))))
+    (when generic
+      (save-excursion
+        (insert "\n\nThis is a generic function.\n\n")
+        (insert (propertize "Implementations:\n\n" 'face 'bold))
+        ;; Loop over fanciful generics
+        (pcase-dolist (`((,type . ,qualifier) . ,method)
+                       (cl--generic-method-table generic))
+          (insert "`")
+          (if (symbolp type)
+              ;; FIXME: Add support for cl-structs in help-variable.
+              (help-insert-xref-button (symbol-name type)
+                                       'help-variable type)
+            (insert (format "%S" type)))
+          (insert (format "' %S %S\n"
+                          (car qualifier)
+                          (let ((args (help-function-arglist method)))
+                            ;; Drop cl--generic-next arg if present.
+                            (if (memq (car qualifier) '(:after :before))
+                                args (cdr args)))))
+          (insert (or (documentation method) "Undocumented") "\n\n"))))))
+
+;;; Support for (eql <val>) specializers.
+
+(defvar cl--generic-eql-used (make-hash-table :test #'eql))
+
+(add-function :before-until cl-generic-tagcode-function
+              #'cl--generic-eql-tagcode)
+(defun cl--generic-eql-tagcode (type name)
+  (when (eq (car-safe type) 'eql)
+    (puthash (cadr type) type cl--generic-eql-used)
+    `(100 . (gethash ,name cl--generic-eql-used))))
+
+(add-function :before-until cl-generic-tag-types-function
+              #'cl--generic-eql-tag-types)
+(defun cl--generic-eql-tag-types (tag)
+  (if (eq (car-safe tag) 'eql) (list tag)))
+
+;;; Support for cl-defstructs specializers.
+
+(add-function :before-until cl-generic-tagcode-function
+              #'cl--generic-struct-tagcode)
+(defun cl--generic-struct-tagcode (type name)
+  (and (symbolp type)
+       (get type 'cl-struct-type)
+       (or (eq 'vector (car (get type 'cl-struct-type)))
+           (error "Can't dispatch on cl-struct %S: type is %S"
+                  type (car (get type 'cl-struct-type))))
+       (or (equal '(cl-tag-slot) (car (get type 'cl-struct-slots)))
+           (error "Can't dispatch on cl-struct %S: no tag in slot 0"
+                  type))
+       ;; We could/should check the vector has length >0,
+       ;; but really, mixing vectors and structs is a bad idea,
+       ;; so let's not waste time trying to handle the case
+       ;; of an empty vector.
+       ;; BEWARE: this returns a bogus tag for non-struct vectors.
+       `(50 . (and (vectorp ,name) (aref ,name 0)))))
+
+(add-function :before-until cl-generic-tag-types-function
+              #'cl--generic-struct-tag-types)
+(defun cl--generic-struct-tag-types (tag)
+  ;; FIXME: cl-defstruct doesn't make it easy for us.
+  (and (symbolp tag)
+       ;; A method call shouldn't itself mess with the match-data.
+       (string-match-p "\\`cl-struct-\\(.*\\)" (symbol-name tag))
+       (let ((types (list (intern (substring (symbol-name tag) 10)))))
+         (while (get (car types) 'cl-struct-include)
+           (push (get (car types) 'cl-struct-include) types))
+         (push 'cl-struct types)        ;The "parent type" of all cl-structs.
+         (nreverse types))))
+
+;;; Dispatch on "old-style types".
+
+(defconst cl--generic-typeof-types
+  ;; Hand made from the source code of `type-of'.
+  '((integer number) (symbol) (string array) (cons list)
+    ;; Markers aren't `numberp', yet they are accepted wherever integers are
+    ;; accepted, pretty much.
+    (marker) (overlay) (float number) (window-configuration)
+    (process) (window) (subr) (compiled-function) (buffer) (char-table array)
+    (bool-vector array)
+    (frame) (hash-table) (font-spec) (font-entity) (font-object)
+    (vector array)
+    ;; Plus, hand made:
+    (null list symbol)
+    (list)
+    (array)
+    (number)))
+
+(add-function :before-until cl-generic-tagcode-function
+              #'cl--generic-typeof-tagcode)
+(defun cl--generic-typeof-tagcode (type name)
+  ;; FIXME: Add support for other types accepted by `cl-typep' such
+  ;; as `character', `atom', `face', `function', ...
+  (and (assq type cl--generic-typeof-types)
+       (progn
+         (if (memq type '(vector array))
+             (message "`%S' also matches CL structs and EIEIO classes" type))
+         ;; FIXME: We could also change `type-of' to return `null' for nil.
+         `(10 . (if ,name (type-of ,name) 'null)))))
+
+(add-function :before-until cl-generic-tag-types-function
+              #'cl--generic-typeof-types)
+(defun cl--generic-typeof-types (tag)
+  (and (symbolp tag)
+       (assq tag cl--generic-typeof-types)))
+
+;;; Just for kicks: dispatch on major-mode
+;;
+;; Here's how you'd use it:
+;;   (cl-defmethod foo ((x (major-mode text-mode)) y z) ...)
+;; And then
+;;     (foo 'major-mode toto titi)
+;;
+;; FIXME: Better would be to do that via dispatch on an "implicit argument".
+
+;; (defvar cl--generic-major-modes (make-hash-table :test #'eq))
+;;
+;; (add-function :before-until cl-generic-tagcode-function
+;;               #'cl--generic-major-mode-tagcode)
+;; (defun cl--generic-major-mode-tagcode (type name)
+;;   (if (eq 'major-mode (car-safe type))
+;;       `(50 . (if (eq ,name 'major-mode)
+;;                  (cl--generic-with-memoization
+;;                      (gethash major-mode cl--generic-major-modes)
+;;                    `(cl--generic-major-mode . ,major-mode))))))
+;;
+;; (add-function :before-until cl-generic-tag-types-function
+;;               #'cl--generic-major-mode-types)
+;; (defun cl--generic-major-mode-types (tag)
+;;   (when (eq (car-safe tag) 'cl--generic-major-mode)
+;;     (if (eq tag 'fundamental-mode) '(fundamental-mode t)
+;;       (let ((types `((major-mode ,(cdr tag)))))
+;;         (while (get (car types) 'derived-mode-parent)
+;;           (push (list 'major-mode (get (car types) 'derived-mode-parent))
+;;                 types))
+;;         (unless (eq 'fundamental-mode (car types))
+;;           (push '(major-mode fundamental-mode) types))
+;;         (nreverse types)))))
+
+;; Local variables:
+;; generated-autoload-file: "cl-loaddefs.el"
+;; End:
+
+(provide 'cl-generic)
+;;; cl-generic.el ends here
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index fff5b27315c..0070599af6f 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -625,14 +625,20 @@ The result of the body appears to the compiler as a quoted constant."
              (set `(setq ,temp ,form)))
         (if (and (fboundp 'byte-compile-file-form-defmumble)
                  (boundp 'this-kind) (boundp 'that-one))
-            (fset 'byte-compile-file-form
-                  `(lambda (form)
-                     (fset 'byte-compile-file-form
-                           ',(symbol-function 'byte-compile-file-form))
-                     (byte-compile-file-form ',set)
-                     (byte-compile-file-form form)))
-          (print set (symbol-value 'byte-compile--outbuffer)))
-        `(symbol-value ',temp))
+            ;; Else, we can't output right away, so we have to delay it to the
+            ;; next time we're at the top-level.
+            ;; FIXME: Use advice-add/remove.
+            (fset 'byte-compile-file-form
+                  (let ((old (symbol-function 'byte-compile-file-form)))
+                    (lambda (form)
+                      (fset 'byte-compile-file-form old)
+                      (byte-compile-file-form set)
+                      (byte-compile-file-form form))))
+          ;; If we're not in the middle of compiling something, we can
+          ;; output directly to byte-compile-outbuffer, to make sure
+          ;; temp is set before we use it.
+          (print set byte-compile--outbuffer))
+        temp)
     `',(eval form)))
 
 
@@ -1824,18 +1830,30 @@ a `let' form, except that the list of symbols can be computed at run-time."
 (defmacro cl-flet (bindings &rest body)
   "Make local function definitions.
 Like `cl-labels' but the definitions are not recursive.
+Each binding can take the form (FUNC EXP) where
+FUNC is the function name, and EXP is an expression that returns the
+function value to which it should be bound, or it can take the more common
+form \(FUNC ARGLIST BODY...) which is a shorthand
+for (FUNC (lambda ARGLIST BODY)).
 
 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)"
   (declare (indent 1) (debug ((&rest (cl-defun)) cl-declarations body)))
   (let ((binds ()) (newenv macroexpand-all-environment))
     (dolist (binding bindings)
-      (let ((var (make-symbol (format "--cl-%s--" (car binding)))))
-        (push (list var `(cl-function (lambda . ,(cdr binding)))) binds)
+      (let ((var (make-symbol (format "--cl-%s--" (car binding))))
+            (args-and-body (cdr binding)))
+        (if (and (= (length args-and-body) 1) (symbolp (car args-and-body)))
+            ;; Optimize (cl-flet ((fun var)) body).
+            (setq var (car args-and-body))
+          (push (list var (if (= (length args-and-body) 1)
+                              (car args-and-body)
+                            `(cl-function (lambda . ,args-and-body))))
+                binds))
         (push (cons (car binding)
-                    `(lambda (&rest cl-labels-args)
-                       (cl-list* 'funcall ',var
-                                 cl-labels-args)))
+                    (lambda (&rest cl-labels-args)
+                      (cl-list* 'funcall var cl-labels-args)))
               newenv)))
+    ;; FIXME: Eliminate those functions which aren't referenced.
     `(let ,(nreverse binds)
        ,@(macroexp-unprogn
           (macroexpand-all
@@ -1869,9 +1887,8 @@ in closures will only work if `lexical-binding' is in use.
       (let ((var (make-symbol (format "--cl-%s--" (car binding)))))
         (push (list var `(cl-function (lambda . ,(cdr binding)))) binds)
         (push (cons (car binding)
-                    `(lambda (&rest cl-labels-args)
-                       (cl-list* 'funcall ',var
-                                 cl-labels-args)))
+                    (lambda (&rest cl-labels-args)
+                      (cl-list* 'funcall var cl-labels-args)))
               newenv)))
     (macroexpand-all `(letrec ,(nreverse binds) ,@body)
                      ;; Don't override lexical-let's macro-expander.
@@ -1898,7 +1915,8 @@ This is like `cl-flet', but for macros instead of functions.
              (res (cl--transform-lambda (cdar bindings) name)))
         (eval (car res))
         (macroexpand-all (macroexp-progn body)
-                         (cons (cons name `(lambda ,@(cdr res)))
+                         (cons (cons name
+                                     (eval `(cl-function (lambda ,@(cdr res))) t))
                                macroexpand-all-environment))))))
 
 (defconst cl--old-macroexpand
diff --git a/lisp/emacs-lisp/eieio-core.el b/lisp/emacs-lisp/eieio-core.el
index dc2c873eb42..bfa922bade6 100644
--- a/lisp/emacs-lisp/eieio-core.el
+++ b/lisp/emacs-lisp/eieio-core.el
@@ -264,7 +264,7 @@ Return nil if that option doesn't exist."
 
 (defsubst eieio-object-p (obj)
   "Return non-nil if OBJ is an EIEIO object."
-  (and (arrayp obj)
+  (and (vectorp obj)
        (condition-case nil
            (eq (aref (eieio--object-class-object obj) 0) 'defclass)
          (error nil))))
@@ -1303,11 +1303,35 @@ method invocation orders of the involved classes."
 (define-error 'unbound-slot "Unbound slot")
 (define-error 'inconsistent-class-hierarchy "Inconsistent class hierarchy")
 
+;;; Hooking into cl-generic.
+
+(require 'cl-generic)
+
+(add-function :before-until cl-generic-tagcode-function
+              #'eieio--generic-tagcode)
+(defun eieio--generic-tagcode (type name)
+  ;; CLHS says:
+  ;;    A class must be defined before it can be used as a parameter
+  ;;    specializer in a defmethod form.
+  ;; So we can ignore types that are not known to denote classes.
+  (and (class-p type)
+       ;; Prefer (aref ,name 0) over (eieio--class-tag ,name) so that
+       ;; the tagcode is identical to the tagcode used for cl-struct.
+       `(50 . (and (vectorp ,name) (aref ,name 0)))))
+
+(add-function :before-until cl-generic-tag-types-function
+              #'eieio--generic-tag-types)
+(defun eieio--generic-tag-types (tag)
+  (and (symbolp tag) (boundp tag) (eieio--class-p (symbol-value tag))
+       (mapcar #'eieio--class-symbol
+               (eieio--class-precedence-list (symbol-value tag)))))
+
 ;;; Backward compatibility functions
 ;; To support .elc files compiled for older versions of EIEIO.
 
 (defun eieio-defclass (cname superclasses slots options)
-  (eval `(defclass ,cname ,superclasses ,slots ,options)))
+  (declare (obsolete eieio-defclass-internal "25.1"))
+  (eval `(defclass ,cname ,superclasses ,slots ,@options)))
 
 
 (provide 'eieio-core)
diff --git a/lisp/files.el b/lisp/files.el
index 1533c35e6ca..175f85b29d0 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -740,7 +740,10 @@ This function works recursively.  Files are returned in \"depth first\"
 and alphabetical order.
 If INCLUDE-DIRECTORIES, also include directories that have matching names."
   (let ((result nil)
-        (files nil))
+        (files nil)
+        ;; When DIR is "/", remote file names like "/method:" could
+        ;; also be offered.  We shall suppress them.
+        (tramp-mode (and tramp-mode (file-remote-p dir))))
     (dolist (file (sort (file-name-all-completions "" dir)
                         'string<))
       (unless (member file '("./" "../"))
diff --git a/lisp/frame.el b/lisp/frame.el
index 8b927309f0a..1d5bbf2317e 100644
--- a/lisp/frame.el
+++ b/lisp/frame.el
@@ -275,23 +275,22 @@ there (in decreasing order of priority)."
       ;; by the lines added in x-create-frame for the tool-bar and
       ;; switch `tool-bar-mode' off.
       (when (display-graphic-p)
-        (let ((tool-bar-lines
-               (or (assq 'tool-bar-lines initial-frame-alist)
-                   (assq 'tool-bar-lines window-system-frame-alist)
-                   (assq 'tool-bar-lines default-frame-alist))))
-          ;; Shrink frame by its initial tool bar height iff either zero
-          ;; tool bar lines have been requested in one of the frame's
-          ;; alists or tool bar mode has been turned off explicitly in
-          ;; the user's init file.
-          (when (and tool-bar-lines
-                     (> frame-initial-frame-tool-bar-height 0)
-                     (or (not tool-bar-mode)
-                         (null (cdr tool-bar-lines))
-                         (eq 0 (cdr tool-bar-lines))))
-            (set-frame-height
-             frame-initial-frame (- (frame-text-height frame-initial-frame)
-                                    frame-initial-frame-tool-bar-height)
-             nil t)
+        (let* ((init-lines
+                (assq 'tool-bar-lines initial-frame-alist))
+               (other-lines
+                (or (assq 'tool-bar-lines window-system-frame-alist)
+                    (assq 'tool-bar-lines default-frame-alist)))
+               (lines (or init-lines other-lines))
+               (height (tool-bar-height frame-initial-frame t)))
+          ;; Adjust frame top if either zero (nil) tool bar lines have
+          ;; been requested in the most relevant of the frame's alists
+          ;; or tool bar mode has been explicitly turned off in the
+          ;; user's init file.
+          (when (and (> height 0)
+                     (or (and lines
+                              (or (null (cdr lines))
+                                  (eq 0 (cdr lines))))
+                         (not tool-bar-mode)))
             (let* ((initial-top
                     (cdr (assq 'top frame-initial-geometry-arguments)))
                    (top (frame-parameter frame-initial-frame 'top)))
@@ -299,15 +298,19 @@ there (in decreasing order of priority)."
                 (let ((adjusted-top
                        (cond
                         ((and (consp top) (eq '+ (car top)))
-                         (list '+ (+ (cadr top)
-                                     frame-initial-frame-tool-bar-height)))
+                         (list '+ (+ (cadr top) height)))
                         ((and (consp top) (eq '- (car top)))
-                         (list '- (- (cadr top)
-                                     frame-initial-frame-tool-bar-height)))
-                        (t (+ top frame-initial-frame-tool-bar-height)))))
+                         (list '- (- (cadr top) height)))
+                        (t (+ top height)))))
                   (modify-frame-parameters
                    frame-initial-frame `((top . ,adjusted-top))))))
-            (tool-bar-mode -1))))
+            ;; Reset `tool-bar-mode' when zero tool bar lines have been
+            ;; requested for the window-system or default frame alists.
+            (when (and tool-bar-mode
+                       (and other-lines
+                            (or (null (cdr other-lines))
+                                (eq 0 (cdr other-lines)))))
+              (tool-bar-mode -1)))))
 
       ;; The initial frame we create above always has a minibuffer.
       ;; If the user wants to remove it, or make it a minibuffer-only
@@ -682,6 +685,9 @@ the new frame according to its own rules."
         (push p params)))
     ;; Now make the frame.
     (run-hooks 'before-make-frame-hook)
+
+;;     (setq frame-adjust-size-history '(t))
+
     (setq frame
           (funcall (gui-method frame-creation-function w) params))
     (normal-erase-is-backspace-setup-frame frame)
@@ -690,6 +696,12 @@ the new frame according to its own rules."
       (unless (assq param parameters)   ;Overridden by explicit parameters.
         (let ((val (frame-parameter oldframe param)))
           (when val (set-frame-parameter frame param val)))))
+
+    (when (eq (car frame-adjust-size-history) t)
+      (setq frame-adjust-size-history
+            (cons t (cons (list "Frame made")
+                          (cdr frame-adjust-size-history)))))
+
     (run-hook-with-args 'after-make-frame-functions frame)
     frame))
 
diff --git a/lisp/menu-bar.el b/lisp/menu-bar.el
index 67cb3273d23..cd1a4d05b55 100644
--- a/lisp/menu-bar.el
+++ b/lisp/menu-bar.el
@@ -381,7 +381,8 @@
 
     (bindings--define-key menu [xref-pop]
       '(menu-item "Back" xref-pop-marker-stack
-                  :visible (not (xref-marker-stack-empty-p))
+                  :visible (and (featurep 'xref)
+                                (not (xref-marker-stack-empty-p)))
                   :help "Back to the position of the last search"))
 
     (bindings--define-key menu [xref-apropos]
diff --git a/lisp/net/eww.el b/lisp/net/eww.el
index 6a6da17d1ce..879eb53115e 100644
--- a/lisp/net/eww.el
+++ b/lisp/net/eww.el
@@ -1,4 +1,4 @@
-;;; eww.el --- Emacs Web Wowser
+;;; eww.el --- Emacs Web Wowser  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2013-2015 Free Software Foundation, Inc.
 
@@ -255,7 +255,9 @@ word(s) will be searched for via `eww-search-prefix'."
         ((string-match-p "\\`ftp://" url)
          (user-error "FTP is not supported."))
         (t
-         (if (or (string-match "\\`https?:" url)
+         ;; Anything that starts with something that vaguely looks
+         ;; like a protocol designator is interpreted as a full URL.
+         (if (or (string-match "\\`[A-Za-z]+:" url)
                  ;; Also try to match "naked" URLs like
                  ;; en.wikipedia.org/wiki/Free software
                  (string-match "\\`[A-Za-z_]+\\.[A-Za-z._]+/" url)
@@ -550,7 +552,7 @@ See the `eww-search-prefix' variable for the search engine used."
   "Return URI of the Web page the current EWW buffer is visiting."
   (plist-get eww-data :url))
 
-(defun eww-links-at-point (&optional pt)
+(defun eww-links-at-point ()
   "Return list of URIs, if any, linked at point."
   (remq nil
         (list (get-text-property (point) 'shr-url)
@@ -629,17 +631,13 @@ the like."
 
 (defvar eww-mode-map
   (let ((map (make-sparse-keymap)))
-    (suppress-keymap map)
-    (define-key map "q" 'quit-window)
-    (define-key map "g" 'eww-reload)
+    (set-keymap-parent map special-mode-map)
+    (define-key map "g" 'eww-reload) ;FIXME: revert-buffer-function instead!
     (define-key map "G" 'eww)
     (define-key map [?\t] 'shr-next-link)
     (define-key map [?\M-\t] 'shr-previous-link)
     (define-key map [backtab] 'shr-previous-link)
     (define-key map [delete] 'scroll-down-command)
-    (define-key map [?\S-\ ] 'scroll-down-command)
-    (define-key map "\177" 'scroll-down-command)
-    (define-key map " " 'scroll-up-command)
     (define-key map "l" 'eww-back-url)
     (define-key map "r" 'eww-forward-url)
     (define-key map "n" 'eww-next-url)
@@ -697,21 +695,19 @@ the like."
     map)
   "Tool bar for `eww-mode'.")
 
-(define-derived-mode eww-mode nil "eww"
-  "Mode for browsing the web.
-
-\\{eww-mode-map}"
+(define-derived-mode eww-mode special-mode "eww"
+  "Mode for browsing the web."
   (setq-local eww-data (list :title ""))
-  (setq-local browse-url-browser-function 'eww-browse-url)
-  (setq-local after-change-functions 'eww-process-text-input)
+  (setq-local browse-url-browser-function #'eww-browse-url)
+  (add-hook 'after-change-functions #'eww-process-text-input nil t)
   (setq-local eww-history nil)
   (setq-local eww-history-position 0)
   (when (boundp 'tool-bar-map)
-   (setq-local tool-bar-map eww-tool-bar-map))
+    (setq-local tool-bar-map eww-tool-bar-map))
   ;; desktop support
-  (setq-local desktop-save-buffer 'eww-desktop-misc-data)
+  (setq-local desktop-save-buffer #'eww-desktop-misc-data)
   ;; multi-page isearch support
-  (setq-local multi-isearch-next-buffer-function 'eww-isearch-next-buffer)
+  (setq-local multi-isearch-next-buffer-function #'eww-isearch-next-buffer)
   (setq truncate-lines t)
   (buffer-disable-undo)
   (setq buffer-read-only t))
@@ -1054,7 +1050,7 @@ See URL `https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Input'.")
     (insert value)
     (shr-ensure-newline)
     (when (< (count-lines start (point)) lines)
-      (dotimes (i (- lines (count-lines start (point))))
+      (dotimes (_ (- lines (count-lines start (point))))
         (insert "\n")))
     (setq end (point-marker))
     (goto-char start)
@@ -1846,7 +1842,7 @@ Also used when saving `eww-history'.")
     ;; .
     r))
 
-(defun eww-desktop-misc-data (directory)
+(defun eww-desktop-misc-data (_directory)
   "Return a property list with data used to restore eww buffers.
 This list will contain, as :history, the list, whose first element is
 the value of `eww-data', and the tail is `eww-history'.
@@ -1894,7 +1890,7 @@ Otherwise, the restored buffer will contain a prompt to do so by using
 
 ;;; Isearch support
 
-(defun eww-isearch-next-buffer (&optional buffer wrap)
+(defun eww-isearch-next-buffer (&optional _buffer wrap)
   "Go to the next page to search using `rel' attribute for navigation."
   (if wrap
       (condition-case nil
diff --git a/lisp/progmodes/cc-bytecomp.el b/lisp/progmodes/cc-bytecomp.el
index bf7803c85ca..b63eeb4c7a6 100644
--- a/lisp/progmodes/cc-bytecomp.el
+++ b/lisp/progmodes/cc-bytecomp.el
@@ -89,13 +89,60 @@
   ;;`(message ,@args)
   )
 
+(defun cc-bytecomp-compiling-or-loading ()
+  ;; Determine whether byte-compilation or loading is currently active,
+  ;; returning 'compiling, 'loading or nil.
+  ;; If both are active, the "innermost" activity counts.  Note that
+  ;; compilation can trigger loading (various `require' type forms)
+  ;; and loading can trigger compilation (the package manager does
+  ;; this).  We walk the lisp stack if necessary.
+  (cond
+   ((and load-in-progress
+         (boundp 'byte-compile-dest-file)
+         (stringp byte-compile-dest-file))
+    (let ((n 0) elt)
+      (while (and
+              (setq elt (backtrace-frame n))
+              (not (and (car elt)
+                        (memq (cadr elt)
+                              '(load require
+                                byte-compile-file byte-recompile-directory
+                                batch-byte-compile)))))
+        (setq n (1+ n)))
+      (cond
+       ((memq (cadr elt) '(load require))
+        'loading)
+       ((memq (cadr elt) '(byte-compile-file
+                           byte-recompile-directory
+                           batch-byte-compile))
+        'compiling)
+       (t                               ; Can't happen.
+        (message "cc-bytecomp-compiling-or-loading: System flags spuriously set")
+        nil))))
+   (load-in-progress
+    ;; Being loaded.
+    'loading)
+   ((and (boundp 'byte-compile-dest-file)
+         (stringp byte-compile-dest-file))
+    ;; Being compiled.
+    'compiling)
+   (t
+    ;; Being evaluated interactively.
+    nil)))
+
+(defsubst cc-bytecomp-is-compiling ()
+  "Return non-nil if eval'ed during compilation."
+  (eq (cc-bytecomp-compiling-or-loading) 'compiling))
+
+(defsubst cc-bytecomp-is-loading ()
+  "Return non-nil if eval'ed during loading.
+Nil will be returned if we're in a compilation triggered by the loading."
+  (eq (cc-bytecomp-compiling-or-loading) 'loading))
+
 (defun cc-bytecomp-setup-environment ()
   ;; Eval'ed during compilation to setup variables, functions etc
   ;; declared with `cc-bytecomp-defvar' et al.
-  (if (not load-in-progress)
-      ;; Look at `load-in-progress' to tell whether we're called
-      ;; directly in the file being compiled or just from some file
-      ;; being loaded during compilation.
+  (if (not (cc-bytecomp-is-loading))
       (let (p)
         (if cc-bytecomp-environment-set
             (error "Byte compilation environment already set - \
@@ -143,7 +190,7 @@ perhaps a `cc-bytecomp-restore-environment' is forgotten somewhere"))
 (defun cc-bytecomp-restore-environment ()
   ;; Eval'ed during compilation to restore variables, functions etc
   ;; declared with `cc-bytecomp-defvar' et al.
-  (if (not load-in-progress)
+  (if (not (cc-bytecomp-is-loading))
       (let (p)
         (setq p cc-bytecomp-unbound-variables)
         (while p
@@ -287,8 +334,7 @@ use within `eval-when-compile'."
   `(eval-when-compile
      (if (and (fboundp 'cc-bytecomp-is-compiling)
               (cc-bytecomp-is-compiling))
-         (if (or (not load-in-progress)
-                 (not (featurep ,cc-part)))
+         (if (not (featurep ,cc-part))
              (cc-bytecomp-load (symbol-name ,cc-part)))
        (require ,cc-part))))
 
@@ -301,12 +347,6 @@ afterwards.  Don't use within `eval-when-compile'."
      (require ,feature)
      (eval-when-compile (cc-bytecomp-setup-environment))))
 
-(defun cc-bytecomp-is-compiling ()
-  "Return non-nil if eval'ed during compilation.  Don't use outside
-`eval-when-compile'."
-  (and (boundp 'byte-compile-dest-file)
-       (stringp byte-compile-dest-file)))
-
 (defmacro cc-bytecomp-defvar (var)
   "Binds the symbol as a variable during compilation of the file,
 to silence the byte compiler.  Don't use within `eval-when-compile'."
@@ -320,8 +360,7 @@ to silence the byte compiler.  Don't use within `eval-when-compile'."
               "cc-bytecomp-defvar: Saving %s (as unbound)" ',var)
              (setq cc-bytecomp-unbound-variables
                    (cons ',var cc-bytecomp-unbound-variables))))
-       (if (and (cc-bytecomp-is-compiling)
-                (not load-in-progress))
+       (if (cc-bytecomp-is-compiling)
            (progn
              (defvar ,var)
              (set ',var (intern (concat "cc-bytecomp-ignore-var:"
@@ -349,8 +388,7 @@ at compile time, e.g. for macros and inline functions."
              (setq cc-bytecomp-original-functions
                    (cons (list ',fun nil 'unbound)
                          cc-bytecomp-original-functions))))
-       (if (and (cc-bytecomp-is-compiling)
-                (not load-in-progress))
+       (if (cc-bytecomp-is-compiling)
            (progn
              (fset ',fun (intern (concat "cc-bytecomp-ignore-fun:"
                                          (symbol-name ',fun))))
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index 2ea566a7a25..d0beab1d485 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -1983,19 +1983,22 @@ system."
 
 (defvar c-lang-const-expansion nil)
 
+;; Ugly hack to pull in the definition of `cc-bytecomp-compiling-or-loading`
+;; from cc-bytecomp to make it available at loadtime.  This is the same
+;; mechanism used in cc-mode.el for `c-populate-syntax-table'.
+(defalias 'cc-bytecomp-compiling-or-loading
+  (cc-eval-when-compile
+    (let ((f (symbol-function 'cc-bytecomp-compiling-or-loading)))
+      (if (byte-code-function-p f) f (byte-compile f)))))
+
 (defsubst c-get-current-file ()
   ;; Return the base name of the current file.
-  (let ((file (cond
-               (load-in-progress
-                ;; Being loaded.
-                load-file-name)
-               ((and (boundp 'byte-compile-dest-file)
-                     (stringp byte-compile-dest-file))
-                ;; Being compiled.
-                byte-compile-dest-file)
-               (t
-                ;; Being evaluated interactively.
-                (buffer-file-name)))))
+  (let* ((c-or-l (cc-bytecomp-compiling-or-loading))
+         (file
+          (cond
+           ((eq c-or-l 'loading) load-file-name)
+           ((eq c-or-l 'compiling) byte-compile-dest-file)
+           ((null c-or-l) (buffer-file-name)))))
     (and file
          (file-name-sans-extension
           (file-name-nondirectory file)))))
@@ -2062,6 +2065,9 @@ constant.  A file is identified by its base name."
          ;; language constant source definitions.)
          (c-lang-const-expansion 'call)
          (c-langs-are-parametric t)
+         (file (intern
+                (or (c-get-current-file)
+                    (error "`c-lang-defconst' can only be used in a file"))))
          bindings
          pre-files)
 
@@ -2121,9 +2127,14 @@ constant.  A file is identified by its base name."
     ;; definitions for this symbol, to make sure the order in the
     ;; `source' property is correct even when files are loaded out of
     ;; order.
-    (setq pre-files (nreverse
-                     ;; Reverse to get the right load order.
-                     (mapcar 'car (get sym 'source))))
+    (setq pre-files (mapcar 'car (get sym 'source)))
+    (if (memq file pre-files)
+        ;; This can happen when the source file (e.g. cc-langs.el) is first
+        ;; loaded as source, setting a 'source property entry, and then itself
+        ;; being compiled.
+        (setq pre-files (cdr (memq file pre-files))))
+    ;; Reverse to get the right load order.
+    (setq pre-files (nreverse pre-files))
 
     `(eval-and-compile
        (c-define-lang-constant ',name ,bindings
@@ -2233,9 +2244,7 @@ quoted."
         (if (or (eq c-lang-const-expansion 'call)
                 (and (not c-lang-const-expansion)
                      (not mode))
-                load-in-progress
-                (not (boundp 'byte-compile-dest-file))
-                (not (stringp byte-compile-dest-file)))
+                (not (cc-bytecomp-is-compiling)))
             ;; Either a straight call is requested in the context, or
             ;; we're in an "uncontrolled" context and got no language,
             ;; or we're not being byte compiled so the compile time
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 17d717e740f..4d16a9b9d33 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -3260,10 +3260,7 @@ function it returns is byte compiled with all the evaluated results
 from the language constants.  Use the `c-init-language-vars' macro to
 accomplish that conveniently."
 
-  (if (and (not load-in-progress)
-           (boundp 'byte-compile-dest-file)
-           (stringp byte-compile-dest-file))
-
+  (if (cc-bytecomp-is-compiling)
       ;; No need to byte compile this lambda since the byte compiler is
       ;; smart enough to detect the `funcall' construct in the
       ;; `c-init-language-vars' macro below and compile it all straight
diff --git a/lisp/progmodes/xref.el b/lisp/progmodes/xref.el
index b822619f783..7f77d218a48 100644
--- a/lisp/progmodes/xref.el
+++ b/lisp/progmodes/xref.el
@@ -301,6 +301,7 @@ backward."
       (let ((marker (ring-remove ring)))
         (set-marker marker nil nil)))))
 
+;;;###autoload
 (defun xref-marker-stack-empty-p ()
   "Return t if the marker stack is empty; nil otherwise."
   (ring-empty-p xref--marker-ring))