* lisp/emacs-lisp/bytecomp.el: Use lexical-binding.

(byte-recompile-directory): Remove unused var `bytecomp-dest'.
(byte-recompile-file): Use derived-mode-p.
(byte-compile-from-buffer): Remove arg `bytecomp-filename'.
Use byte-compile-current-file instead.
(byte-compile-file): Adjust call accordingly.
(bytecomp-outbuffer): Move declaration before first use.
(for-effect): Declare dynamic.
(byte-compile-file-form-defmumble): Use byte-compile-current-file.
(byte-compile-top-level, byte-compile-out-toplevel, byte-compile-form):
Move dyn-binding of for-effect from function argument to let binding.
(byte-compile-out-toplevel): Don't both passing for-effect to
byte-optimize-lapcode.
(byte-compile-top-level-body, byte-compile-body):
Rename for-effect -> for-effect-arg so it's lexical.
* lisp/subr.el (functionp): Remove, now that it's in src/eval.c.

3 files changed, 99 insertions, 92 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 26661bf6df7..fd00cf70f40 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,6 +1,24 @@
 2011-03-10  Stefan Monnier  <monnier@iro.umontreal.ca>
 
-        * emacs-lisp/byte-opt.el: Use lexical binding.
+        * emacs-lisp/bytecomp.el: Use lexical-binding.
+        (byte-recompile-directory): Remove unused var `bytecomp-dest'.
+        (byte-recompile-file): Use derived-mode-p.
+        (byte-compile-from-buffer): Remove arg `bytecomp-filename'.
+        Use byte-compile-current-file instead.
+        (byte-compile-file): Adjust call accordingly.
+        (bytecomp-outbuffer): Move declaration before first use.
+        (for-effect): Declare dynamic.
+        (byte-compile-file-form-defmumble): Use byte-compile-current-file.
+        (byte-compile-top-level, byte-compile-out-toplevel, byte-compile-form):
+        Move dyn-binding of for-effect from function argument to let binding.
+        (byte-compile-out-toplevel): Don't both passing for-effect to
+        byte-optimize-lapcode.
+        (byte-compile-top-level-body, byte-compile-body):
+        Rename for-effect -> for-effect-arg so it's lexical.
+
+        * subr.el (functionp): Remove, now that it's in src/eval.c.
+
+        * emacs-lisp/byte-opt.el: Use lexical-binding.
         (for-effectm byte-compile-tag-number): Declare dynamic.
         (byte-optimize-form-code-walker, byte-optimize-form): Move dynamic
         binding of for-effect from function argument to let binding.
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 7b785c9ace6..77dd3408219 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -1,4 +1,4 @@
-;;; bytecomp.el --- compilation of Lisp code into byte code
+;;; bytecomp.el --- compilation of Lisp code into byte code -*- lexical-binding: t -*-
 
 ;; Copyright (C) 1985-1987, 1992, 1994, 1998, 2000-2011
 ;;   Free Software Foundation, Inc.
@@ -1063,7 +1063,7 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
 ;; This no-op function is used as the value of warning-series
 ;; to tell inner calls to displaying-byte-compile-warnings
 ;; not to bind warning-series.
-(defun byte-compile-warning-series (&rest ignore)
+(defun byte-compile-warning-series (&rest _ignore)
   nil)
 
 ;; (compile-mode) will cause this to be loaded.
@@ -1606,7 +1606,7 @@ that already has a `.elc' file."
          (setq bytecomp-directory (car bytecomp-directories))
          (message "Checking %s..." bytecomp-directory)
          (let ((bytecomp-files (directory-files bytecomp-directory))
-               bytecomp-source bytecomp-dest)
+               bytecomp-source)
            (dolist (bytecomp-file bytecomp-files)
              (setq bytecomp-source
                    (expand-file-name bytecomp-file bytecomp-directory))
@@ -1724,8 +1724,7 @@ The value is non-nil if there were no errors, nil if errors."
          (bytecomp-file-name nil)
          (bytecomp-file-dir nil))
      (and bytecomp-file
-          (eq (cdr (assq 'major-mode (buffer-local-variables)))
-              'emacs-lisp-mode)
+          (derived-mode-p 'emacs-lisp-mode)
           (setq bytecomp-file-name (file-name-nondirectory bytecomp-file)
                 bytecomp-file-dir (file-name-directory bytecomp-file)))
      (list (read-file-name (if current-prefix-arg
@@ -1803,7 +1802,7 @@ The value is non-nil if there were no errors, nil if errors."
       ;; within byte-compile-from-buffer lingers in that buffer.
       (setq output-buffer
             (save-current-buffer
-              (byte-compile-from-buffer input-buffer bytecomp-filename)))
+              (byte-compile-from-buffer input-buffer)))
       (if byte-compiler-error-flag
           nil
         (when byte-compile-verbose
@@ -1880,9 +1879,11 @@ With argument ARG, insert value in current buffer after the form."
              (insert "\n"))
             ((message "%s" (prin1-to-string value)))))))
 
+;; Dynamically bound in byte-compile-from-buffer.
+;; NB also used in cl.el and cl-macs.el.
+(defvar bytecomp-outbuffer)
 
-(defun byte-compile-from-buffer (bytecomp-inbuffer &optional bytecomp-filename)
-  ;; Filename is used for the loading-into-Emacs-18 error message.
+(defun byte-compile-from-buffer (bytecomp-inbuffer)
   (let (bytecomp-outbuffer
         (byte-compile-current-buffer bytecomp-inbuffer)
         (byte-compile-read-position nil)
@@ -1919,8 +1920,9 @@ With argument ARG, insert value in current buffer after the form."
        (setq case-fold-search nil))
      (displaying-byte-compile-warnings
       (with-current-buffer bytecomp-inbuffer
-        (and bytecomp-filename
-             (byte-compile-insert-header bytecomp-filename bytecomp-outbuffer))
+        (and byte-compile-current-file
+             (byte-compile-insert-header byte-compile-current-file
+                                         bytecomp-outbuffer))
         (goto-char (point-min))
         ;; Should we always do this?  When calling multiple files, it
         ;; would be useful to delay this warning until all have been
@@ -1952,9 +1954,9 @@ and will be removed soon.  See (elisp)Backquote in the manual."))
         (byte-compile-warn-about-unresolved-functions))
       ;; Fix up the header at the front of the output
       ;; if the buffer contains multibyte characters.
-      (and bytecomp-filename
+      (and byte-compile-current-file
            (with-current-buffer bytecomp-outbuffer
-             (byte-compile-fix-header bytecomp-filename)))))
+             (byte-compile-fix-header byte-compile-current-file)))))
     bytecomp-outbuffer))
 
 (defun byte-compile-fix-header (filename)
@@ -2043,10 +2045,6 @@ Call from the source buffer."
        ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n"
        ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n\n"))))
 
-;; Dynamically bound in byte-compile-from-buffer.
-;; NB also used in cl.el and cl-macs.el.
-(defvar bytecomp-outbuffer)
-
 (defun byte-compile-output-file-form (form)
   ;; writes the given form to the output buffer, being careful of docstrings
   ;; in defun, defmacro, defvar, defvaralias, defconst, autoload and
@@ -2073,6 +2071,7 @@ Call from the source buffer."
       nil)))
 
 (defvar print-gensym-alist)             ;Used before print-circle existed.
+(defvar for-effect)
 
 (defun byte-compile-output-docform (preface name info form specindex quoted)
   "Print a form with a doc string.  INFO is (prefix doc-index postfix).
@@ -2138,7 +2137,7 @@ list that represents a doc string reference.
                         ;; (for instance, gensyms in the arg list).
                         (let (non-nil)
                           (when (hash-table-p print-number-table)
-                            (maphash (lambda (k v) (if v (setq non-nil t)))
+                            (maphash (lambda (_k v) (if v (setq non-nil t)))
                                      print-number-table))
                           (not non-nil)))
                    ;; Output the byte code and constants specially
@@ -2393,8 +2392,8 @@ by side-effects."
     (if (byte-compile-warning-enabled-p 'redefine)
         (byte-compile-arglist-warn form macrop))
     (if byte-compile-verbose
-        ;; bytecomp-filename is from byte-compile-from-buffer.
-        (message "Compiling %s... (%s)" (or bytecomp-filename "") (nth 1 form)))
+        (message "Compiling %s... (%s)"
+                 (or byte-compile-current-file "") (nth 1 form)))
     (cond (bytecomp-that-one
            (if (and (byte-compile-warning-enabled-p 'redefine)
                     ;; don't warn when compiling the stubs in byte-run...
@@ -2815,14 +2814,15 @@ If FORM is a lambda or a macro, byte-compile it as a function."
 
 ;; Given an expression FORM, compile it and return an equivalent byte-code
 ;; expression (a call to the function byte-code).
-(defun byte-compile-top-level (form &optional for-effect output-type
+(defun byte-compile-top-level (form &optional for-effect-arg output-type
                                     lexenv reserved-csts)
   ;; OUTPUT-TYPE advises about how form is expected to be used:
   ;;    'eval or nil    -> a single form,
   ;;    'progn or t     -> a list of forms,
   ;;    'lambda         -> body of a lambda,
   ;;    'file           -> used at file-level.
-  (let ((byte-compile-constants nil)
+  (let ((for-effect for-effect-arg)
+        (byte-compile-constants nil)
         (byte-compile-variables nil)
         (byte-compile-tag-number 0)
         (byte-compile-depth 0)
@@ -2852,8 +2852,8 @@ If FORM is a lambda or a macro, byte-compile it as a function."
       (byte-compile-form form for-effect)
       (byte-compile-out-toplevel for-effect output-type))))
 
-(defun byte-compile-out-toplevel (&optional for-effect output-type)
-  (if for-effect
+(defun byte-compile-out-toplevel (&optional for-effect-arg output-type)
+  (if for-effect-arg
       ;; The stack is empty. Push a value to be returned from (byte-code ..).
       (if (eq (car (car byte-compile-output)) 'byte-discard)
           (setq byte-compile-output (cdr byte-compile-output))
@@ -2872,7 +2872,7 @@ If FORM is a lambda or a macro, byte-compile it as a function."
   (setq byte-compile-output (nreverse byte-compile-output))
   (if (memq byte-optimize '(t byte))
       (setq byte-compile-output
-            (byte-optimize-lapcode byte-compile-output for-effect)))
+            (byte-optimize-lapcode byte-compile-output)))
 
   ;; Decompile trivial functions:
   ;; only constants and variables, or a single funcall except in lambdas.
@@ -2889,6 +2889,7 @@ If FORM is a lambda or a macro, byte-compile it as a function."
   ;;    progn   -> as <<same-as-eval>> or (progn <<same-as-eval>> atom)
   ;;    file    -> as progn, but takes both quotes and atoms, and longer forms.
   (let (rest
+        (for-effect for-effect-arg)
         (maycall (not (eq output-type 'lambda))) ; t if we may make a funcall.
         tmp body)
     (cond
@@ -2938,9 +2939,9 @@ If FORM is a lambda or a macro, byte-compile it as a function."
      ((car body)))))
 
 ;; Given BYTECOMP-BODY, compile it and return a new body.
-(defun byte-compile-top-level-body (bytecomp-body &optional for-effect)
+(defun byte-compile-top-level-body (bytecomp-body &optional for-effect-arg)
   (setq bytecomp-body
-        (byte-compile-top-level (cons 'progn bytecomp-body) for-effect t))
+        (byte-compile-top-level (cons 'progn bytecomp-body) for-effect-arg t))
   (cond ((eq (car-safe bytecomp-body) 'progn)
          (cdr bytecomp-body))
         (bytecomp-body
@@ -2971,54 +2972,56 @@ If FORM is a lambda or a macro, byte-compile it as a function."
 ;; byte-compile-form, or take extreme care to handle for-effect correctly.
 ;; (Use byte-compile-form-do-effect to reset the for-effect flag too.)
 ;;
-(defun byte-compile-form (form &optional for-effect)
-  (cond ((not (consp form))
-         (cond ((or (not (symbolp form)) (byte-compile-const-symbol-p form))
-                (when (symbolp form)
-                  (byte-compile-set-symbol-position form))
-                (byte-compile-constant form))
-               ((and for-effect byte-compile-delete-errors)
-                (when (symbolp form)
-                  (byte-compile-set-symbol-position form))
-                (setq for-effect nil))
-               (t
-                (byte-compile-variable-ref form))))
-        ((symbolp (car form))
-         (let* ((bytecomp-fn (car form))
-                (bytecomp-handler (get bytecomp-fn 'byte-compile)))
-           (when (byte-compile-const-symbol-p bytecomp-fn)
-             (byte-compile-warn "`%s' called as a function" bytecomp-fn))
-           (and (byte-compile-warning-enabled-p 'interactive-only)
-                (memq bytecomp-fn byte-compile-interactive-only-functions)
-                (byte-compile-warn "`%s' used from Lisp code\n\
+(defun byte-compile-form (form &optional for-effect-arg)
+  (let ((for-effect for-effect-arg))
+    (cond
+     ((not (consp form))
+      (cond ((or (not (symbolp form)) (byte-compile-const-symbol-p form))
+             (when (symbolp form)
+               (byte-compile-set-symbol-position form))
+             (byte-compile-constant form))
+            ((and for-effect byte-compile-delete-errors)
+             (when (symbolp form)
+               (byte-compile-set-symbol-position form))
+             (setq for-effect nil))
+            (t
+             (byte-compile-variable-ref form))))
+     ((symbolp (car form))
+      (let* ((bytecomp-fn (car form))
+             (bytecomp-handler (get bytecomp-fn 'byte-compile)))
+        (when (byte-compile-const-symbol-p bytecomp-fn)
+          (byte-compile-warn "`%s' called as a function" bytecomp-fn))
+        (and (byte-compile-warning-enabled-p 'interactive-only)
+             (memq bytecomp-fn byte-compile-interactive-only-functions)
+             (byte-compile-warn "`%s' used from Lisp code\n\
 That command is designed for interactive use only" bytecomp-fn))
-           (if (and (fboundp (car form))
-                    (eq (car-safe (symbol-function (car form))) 'macro))
-               (byte-compile-report-error
-                (format "Forgot to expand macro %s" (car form))))
-           (if (and bytecomp-handler
-                    ;; Make sure that function exists.  This is important
-                    ;; for CL compiler macros since the symbol may be
-                    ;; `cl-byte-compile-compiler-macro' but if CL isn't
-                    ;; loaded, this function doesn't exist.
-                    (and (not (eq bytecomp-handler
-                                  ;; Already handled by macroexpand-all.
-                                  'cl-byte-compile-compiler-macro))
-                         (functionp bytecomp-handler)))
-               (funcall bytecomp-handler form)
-             (byte-compile-normal-call form))
-           (if (byte-compile-warning-enabled-p 'cl-functions)
-               (byte-compile-cl-warn form))))
-        ((and (or (byte-code-function-p (car form))
-                  (eq (car-safe (car form)) 'lambda))
-              ;; if the form comes out the same way it went in, that's
-              ;; because it was malformed, and we couldn't unfold it.
-              (not (eq form (setq form (byte-compile-unfold-lambda form)))))
-         (byte-compile-form form for-effect)
-         (setq for-effect nil))
-        ((byte-compile-normal-call form)))
-  (if for-effect
-      (byte-compile-discard)))
+        (if (and (fboundp (car form))
+                 (eq (car-safe (symbol-function (car form))) 'macro))
+            (byte-compile-report-error
+             (format "Forgot to expand macro %s" (car form))))
+        (if (and bytecomp-handler
+                 ;; Make sure that function exists.  This is important
+                 ;; for CL compiler macros since the symbol may be
+                 ;; `cl-byte-compile-compiler-macro' but if CL isn't
+                 ;; loaded, this function doesn't exist.
+                 (and (not (eq bytecomp-handler
+                               ;; Already handled by macroexpand-all.
+                               'cl-byte-compile-compiler-macro))
+                      (functionp bytecomp-handler)))
+            (funcall bytecomp-handler form)
+          (byte-compile-normal-call form))
+        (if (byte-compile-warning-enabled-p 'cl-functions)
+            (byte-compile-cl-warn form))))
+     ((and (or (byte-code-function-p (car form))
+               (eq (car-safe (car form)) 'lambda))
+           ;; if the form comes out the same way it went in, that's
+           ;; because it was malformed, and we couldn't unfold it.
+           (not (eq form (setq form (byte-compile-unfold-lambda form)))))
+      (byte-compile-form form for-effect)
+      (setq for-effect nil))
+     ((byte-compile-normal-call form)))
+    (if for-effect
+        (byte-compile-discard))))
 
 (defun byte-compile-normal-call (form)
   (when (and (byte-compile-warning-enabled-p 'callargs)
@@ -3326,7 +3329,7 @@ If it is nil, then the handler is \"byte-compile-SYMBOL.\""
           ((= len 4) (byte-compile-three-args form))
           (t (byte-compile-subr-wrong-args form "2-3")))))
 
-(defun byte-compile-noop (form)
+(defun byte-compile-noop (_form)
   (byte-compile-constant nil))
 
 (defun byte-compile-discard (&optional num preserve-tos)
@@ -3632,11 +3635,11 @@ discarding."
 
 ;;; control structures
 
-(defun byte-compile-body (bytecomp-body &optional for-effect)
+(defun byte-compile-body (bytecomp-body &optional for-effect-arg)
   (while (cdr bytecomp-body)
     (byte-compile-form (car bytecomp-body) t)
     (setq bytecomp-body (cdr bytecomp-body)))
-  (byte-compile-form (car bytecomp-body) for-effect))
+  (byte-compile-form (car bytecomp-body) for-effect-arg))
 
 (defsubst byte-compile-body-do-effect (bytecomp-body)
   (byte-compile-body bytecomp-body for-effect)
@@ -4190,7 +4193,7 @@ binding slots have been popped."
 
 ;; Lambdas in valid places are handled as special cases by various code.
 ;; The ones that remain are errors.
-(defun byte-compile-lambda-form (form)
+(defun byte-compile-lambda-form (_form)
   (byte-compile-set-symbol-position 'lambda)
   (error "`lambda' used as function name is invalid"))
 
diff --git a/lisp/subr.el b/lisp/subr.el
index a493c31b254..b7b5bec1249 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -249,20 +249,6 @@ Any list whose car is `frame-configuration' is assumed to be a frame
 configuration."
   (and (consp object)
        (eq (car object) 'frame-configuration)))
-
-(defun functionp (object)
-  "Non-nil if OBJECT is a function."
-  (or (and (symbolp object) (fboundp object)
-           (condition-case nil
-               (setq object (indirect-function object))
-             (error nil))
-           (eq (car-safe object) 'autoload)
-           (not (car-safe (cdr-safe (cdr-safe (cdr-safe (cdr-safe object)))))))
-      (and (subrp object)
-           ;; Filter out special forms.
-           (not (eq 'unevalled (cdr (subr-arity object)))))
-      (byte-code-function-p object)
-      (eq (car-safe object) 'lambda)))
 
 ;;;; List functions.