Squashed commit of the following:

commit e1ecf76585bef2eb87995f7a7f92cc12003a6f70
Author: Alan Mackenzie <acm@muc.de>
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 <acm@muc.de>
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

@@ -456,10 +456,20 @@ Return the compile-time value of FORM."
                               (byte-compile-recurse-toplevel
                                (macroexp-progn body)
                                (lambda (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))))))
+                                           (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.")
@@ -1504,7 +1519,8 @@ extra args."
       ;; from the truly unresolved ones.
       (dolist (f byte-compile-unresolved-functions)
         (setq f (car f))
-	(if (fboundp f) (push f noruntime) (push f unresolved)))
+        (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