[Emacs-diffs] emacs-25 acb96f2 1/2: Squashed commit of the following:

[Alan Mackenzie]

branch: emacs-25
commit acb96f2718ccb0d36af514ce63b5decf0f24a697
Author: Alan Mackenzie <address@hidden>
Commit: Alan Mackenzie <address@hidden>

    Squashed commit of the following:
    
    commit e1ecf76585bef2eb87995f7a7f92cc12003a6f70
    Author: Alan Mackenzie <address@hidden>
    Date:   Tue Nov 24 16:50:09 2015 +0000
    
        Byte compile: minor amendments.
    
        * lisp/emacs-lisp/bytecomp.el (byte-compile-initial-macro-environment):
        add a comment to explain the binding of variables around a subsidiary
        compilation.
        (byte-compile-new-defuns): Amend the doc string.
    
    commit c537bfed1dda1593d218956ff00c6105a3ff0316
    Author: Alan Mackenzie <address@hidden>
    Date:   Sat Nov 21 18:43:57 2015 +0000
    
        Byte compiler: fix spurious warnings "might not be defined at runtime".
    
        Also initialize byte-compile-noruntime-functions between runs.
    
        * lisp/emacs-lisp/bytecomp.el (byte-compile-new-defuns): New variable.
        (byte-compile-initial-macro-environment): For eval-when-compile: bind
        byte-compile-unresolved-functions and byte-compile-new-defuns around
        byte-compile-top-level, to prevent spurious entries being made.
        (byte-compile-warn-about-unresolved-functions): Check whether function 
is
        in byte-compile-new-defuns before emitting a warning about it.
        (byte-compile-from-buffer): Initialize new variable and
        byte-compile-noruntime-functions to nil.
        (byte-compile-file-form-require): record all new functions defined by a
        `require' in byte-compile-new-defuns.
        (byte-compile-file-form-defmumble): record the new alias in
        byte-compile-new-defuns.
---
 lisp/emacs-lisp/bytecomp.el |   46 ++++++++++++++++++++++++++++++++++++------
 1 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 5e6df28..58cce67 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -456,10 +456,20 @@ Return the compile-time value of FORM."
                               (byte-compile-recurse-toplevel
                                (macroexp-progn body)
                                (lambda (form)
-                                 (setf result
-                                       (byte-compile-eval
-                                        (byte-compile-top-level
-                                         (byte-compile-preprocess form))))))
+                                 ;; Insulate the following variables
+                                 ;; against changes made in the
+                                 ;; subsidiary compilation.  This
+                                 ;; prevents spurious warning
+                                 ;; messages: "not defined at runtime"
+                                 ;; etc.
+                                 (let ((byte-compile-unresolved-functions
+                                        byte-compile-unresolved-functions)
+                                       (byte-compile-new-defuns
+                                        byte-compile-new-defuns))
+                                   (setf result
+                                         (byte-compile-eval
+                                          (byte-compile-top-level
+                                           (byte-compile-preprocess form)))))))
                               (list 'quote result))))
     (eval-and-compile . ,(lambda (&rest body)
                            (byte-compile-recurse-toplevel
@@ -503,6 +513,11 @@ defined with incorrect args.")
 Used for warnings about calling a function that is defined during compilation
 but won't necessarily be defined when the compiled file is loaded.")
 
+(defvar byte-compile-new-defuns nil
+  "List of (runtime) functions defined in this compilation run.
+This variable is used to qualify `byte-compile-noruntime-functions' when
+outputting warnings about functions not being defined at runtime.")
+
 ;; Variables for lexical binding
 (defvar byte-compile--lexical-environment nil
   "The current lexical environment.")
@@ -1503,8 +1518,9 @@ extra args."
       ;; Separate the functions that will not be available at runtime
       ;; from the truly unresolved ones.
       (dolist (f byte-compile-unresolved-functions)
-       (setq f (car f))
-       (if (fboundp f) (push f noruntime) (push f unresolved)))
+        (setq f (car f))
+        (when (not (memq f byte-compile-new-defuns))
+          (if (fboundp f) (push f noruntime) (push f unresolved))))
       ;; Complain about the no-run-time functions
       (byte-compile-print-syms
        "the function `%s' might not be defined at runtime."
@@ -1961,6 +1977,8 @@ With argument ARG, insert value in current buffer after 
the form."
        ;; compiled.  A: Yes!  b-c-u-f might contain dross from a
        ;; previous byte-compile.
        (setq byte-compile-unresolved-functions nil)
+        (setq byte-compile-noruntime-functions nil)
+        (setq byte-compile-new-defuns nil)
 
        ;; Compile the forms from the input buffer.
        (while (progn
@@ -2345,8 +2363,21 @@ list that represents a doc string reference.
 (defun byte-compile-file-form-require (form)
   (let ((args (mapcar 'eval (cdr form)))
        (hist-orig load-history)
-       hist-new)
+       hist-new prov-cons)
     (apply 'require args)
+
+    ;; Record the functions defined by the require in 
`byte-compille-new-defuns'.
+    (setq hist-new load-history)
+    (setq prov-cons (cons 'provide (car args)))
+    (while (and hist-new
+                (not (member prov-cons (car hist-new))))
+      (setq hist-new (cdr hist-new)))
+    (when hist-new
+      (dolist (x (car hist-new))
+        (when (and (consp x)
+                   (memq (car x) '(defun t)))
+          (push (cdr x) byte-compile-new-defuns))))
+
     (when (byte-compile-warning-enabled-p 'cl-functions)
       ;; Detect (require 'cl) in a way that works even if cl is already loaded.
       (if (member (car args) '("cl" cl))
@@ -2402,6 +2433,7 @@ not to take responsibility for the actual compilation of 
the code."
          (byte-compile-current-form name)) ; For warnings.
 
     (byte-compile-set-symbol-position name)
+    (push name byte-compile-new-defuns)
     ;; When a function or macro is defined, add it to the call tree so that
     ;; we can tell when functions are not used.
     (if byte-compile-generate-call-tree