-;;; names.el --- Namespaces for emacs-lisp. Avoid name clobbering without hiding symbols.
+;;; names.el --- Namespaces for emacs-lisp. Avoid name clobbering without hiding symbols. -*- lexical-binding:t -*-
-;; Copyright (C) 2014 Free Software Foundation, Inc.
+;; Copyright (C) 2014-2015 Free Software Foundation, Inc.
;; Author: Artur Malabarba <bruce.connor.am@gmail.com>
;; Maintainer: Artur Malabarba <bruce.connor.am@gmail.com>
;; If `C-x' is not a prefix.
(unless (consp (key-binding "\C-x"))
;; Disable the `C-xC-a' binds.
+ (defvar edebug-inhibit-emacs-lisp-mode-bindings)
(setq edebug-inhibit-emacs-lisp-mode-bindings t)
;; And the `C-xX' binds.
+ (defvar global-edebug-prefix)
(when (or (null (boundp 'global-edebug-prefix))
- (eq 24 (elt global-edebug-prefix 0)))
+ (eq ?\C-x (elt global-edebug-prefix 0)))
(setq global-edebug-prefix "")))
(require 'edebug)
(require 'bytecomp)
;;; Support
(declare-function names--autoload-do-load "names" 2)
-(if (fboundp 'function-get)
- (defalias 'names--function-get #'function-get)
- (defun names--function-get (f prop &rest _)
- "Return the value of property PROP of function F.
+(defalias 'names--function-get
+ (if (fboundp 'function-get) #'function-get
+
+ (defun names--autoload-do-load (def name)
+ "Load autoloaded definition DEF from function named NAME."
+ (unless (load (cadr def) 'noerror)
+ (error "Macro `%s' is autoloaded, but its file (%s) couldn't be loaded"
+ name (cadr def)))
+ (symbol-function name))
+
+ (lambda (f prop &rest _)
+ "Return the value of property PROP of function F.
If F is an autoloaded macro, try to autoload it in the hope that
it will set PROP."
- (let ((val nil))
- (while (and (symbolp f)
- (null (setq val (get f prop)))
- (fboundp f))
- (let ((fundef (symbol-function f)))
- (if (and (names--autoloadp fundef)
- (not (equal fundef (names--autoload-do-load fundef f))))
- nil ;Re-try `get' on the same `f'.
- (setq f fundef))))
- val))
- (defun names--autoload-do-load (def name)
- "Load autoloaded definition DEF from function named NAME."
- (unless (load (cadr def) 'noerror)
- (error "Macro `%s' is autoloaded, but its file (%s) couldn't be loaded"
- name (cadr def)))
- (symbol-function name)))
-
-(if (fboundp 'macrop)
- (defalias 'names--compat-macrop #'macrop)
- (defun names--compat-macrop (object)
- "Non-nil if and only if OBJECT is a macro."
- (let ((def (indirect-function object t)))
- (when (consp def)
- (or (eq 'macro (car def))
- (and (names--autoloadp def) (memq (nth 4 def) '(macro t))))))))
-
-(if (fboundp 'autoloadp)
- (defalias 'names--autoloadp #'autoloadp)
- (defsubst names--autoloadp (object)
- "Non-nil if OBJECT is an autoload."
- (eq 'autoload (car-safe object))))
+ (let ((val nil))
+ (while (and (symbolp f)
+ (null (setq val (get f prop)))
+ (fboundp f))
+ (let ((fundef (symbol-function f)))
+ (if (and (names--autoloadp fundef)
+ (not (equal fundef (names--autoload-do-load fundef f))))
+ nil ;Re-try `get' on the same `f'.
+ (setq f fundef))))
+ val))))
+
+(defalias 'names--compat-macrop
+ (if (fboundp 'macrop) #'macrop
+ (lambda (object)
+ "Non-nil if and only if OBJECT is a macro."
+ (let ((def (indirect-function object t)))
+ (when (consp def)
+ (or (eq 'macro (car def))
+ (and (names--autoloadp def) (memq (nth 4 def) '(macro t)))))))))
+
+(defalias 'names--autoloadp
+ (if (fboundp 'autoloadp) #'autoloadp
+ (lambda (object)
+ "Non-nil if OBJECT is an autoload."
+ (eq 'autoload (car-safe object)))))
(unless (get-edebug-spec 'cl-defun)
(def-edebug-spec cl-defun defun*))
`(when (boundp ',var)
(remove
nil
- (mapcar (lambda (x) (when (funcall (or ,pred 'identity) (or (car-safe x) x))
+ (mapcar (lambda (x) (when (funcall (or ,pred #'identity) (or (car-safe x) x))
(or (car-safe x) x)))
,var))))
(keywordp kar)
(setq n (assoc kar names--keyword-list))
(setq n (cadr n))
- (dotimes (it (1+ n) out)
+ (dotimes (_ (1+ n) out)
(push (pop ,body) out))
(nreverse out))))
(defun names--message (f &rest rest)
"If :verbose is on, pass F and REST to `message'."
(when (names--keyword :verbose)
- (apply 'message (concat "[names] " f) rest)))
+ (apply #'message (concat "[names] " f) rest)))
(defun names--warn (f &rest rest)
"Pass F and REST to `message', unless byte-compiling or non-interactive."
(unless (and (null (names--keyword :verbose))
(and (boundp 'byte-compile-function-environment)
byte-compile-function-environment))
- (apply 'message (concat "[names] " f) rest)))
+ (apply #'message (concat "[names] " f) rest)))
(defun names--error-if-using-vars ()
"Remind the developer that variables are not customizable."
"Return a concatenated un-namespaced version of LISTS.
Symbols in LISTS that aren't namespaced are removed, symbols that
are namespaced become un-namespaced."
- (delq nil (mapcar 'names--remove-namespace (apply 'append lists))))
+ (delq nil (mapcar 'names--remove-namespace (apply #'append lists))))
(defun names--remove-namespace (symbol)
"Return SYMBOL with namespace removed, or nil if it wasn't namespaced."
(and (names--keyword :global)
(boundp (names--prepend sbl))))))
-;;; This is calling edebug even on `when' and `unless'
+(defvar names--verbose nil
+ "If non-nil, verbose message are printed regardless of the :verbose keyword.
+Use this to easily turn on verbosity during tests.")
+
+;; This is calling edebug even on `when' and `unless'
(defun names--args-of-function-or-macro (function args macro)
"Namespace FUNCTION's arguments ARGS, with special treatment if MACRO is non-nil."
(if macro
(symbol-function 'message))
"Where names stores `message's definition while overriding it.")
-(defvar names--verbose nil
- "If non-nil, verbose message are printed regardless of the :verbose keyword.
-Use this to easily turn on verbosity during tests.")
-
-(defun names--edebug-message (&rest _)
+(defun names--edebug-message (&rest args)
(if (or (names--keyword :verbose) names--verbose)
- (apply names--message-backup _)
- (when _ (apply 'format _))))
+ (apply names--message-backup args)
+ (when args (apply #'format args))))
(defun names--edebug-make-enter-wrapper (forms)
(setq edebug-def-name
;; lines of the functions defined below. It will be automatically used
;; whenever that form is found.
-;;; Defun, defmacro, and defsubst macros are pretty predictable.
+;; Defun, defmacro, and defsubst macros are pretty predictable.
(defun names--convert-defmacro (form)
"Special treatment for `defmacro' FORM."
- (let* ((names--name-already-prefixed t)
+ (let* (;; (names--name-already-prefixed t) ;FIXME: Unused?!
(name (cadr form))
(spaced-name (names--prepend name))
decl)
(names--handle-symbol-as-function (pop copy))
(names--handle-symbol-as-function (pop copy)))
(mapcar #'names-convert-form copy)))))
-(defalias #'names--convert-define-global-minor-mode
+(defalias 'names--convert-define-global-minor-mode
#'names--convert-define-globalized-minor-mode)
-(defalias #'names--convert-easy-mmode-define-global-mode
+(defalias 'names--convert-easy-mmode-define-global-mode
#'names--convert-define-globalized-minor-mode)
(defun names--convert-quote (form)
When FORM is (function form), a symbol is namespaced as a
function name, a list is namespaced as a lambda form."
(let ((kadr (cadr form))
- (this-name (car form))
- func)
+ (this-name (car form)))
(if (and (eq this-name 'function)
(listp kadr))
(list this-name (names-convert-form kadr))
(names--warn "Found a `closure'! You should use `lambda's instead")
(let ((names--local-vars
(append (names--vars-from-arglist (cadr form))
- names--local-vars))
- (forms (cdr (cdr form))))
+ names--local-vars)))
(cons
(car form)
(names--convert-lambda (cdr form)))))