Re: In the easter-egg department...

[Richard Stallman]

    C-h w ignore RET

I think this replacement definition fixes it.

(defun where-is (definition &optional insert)
  "Print message listing key sequences that invoke the command DEFINITION.
Argument is a command definition, usually a symbol with a function definition.
If INSERT (the prefix arg) is non-nil, insert the message in the buffer."
  (interactive
   (let ((fn (function-called-at-point))
         (enable-recursive-minibuffers t)
         val)
     (setq val (completing-read
                (if fn
                    (format "Where is command (default %s): " fn)
                  "Where is command: ")
                obarray 'commandp t))
     (list (if (equal val "") fn (intern val)) current-prefix-arg)))
  (let ((func (indirect-function definition))
        (defs nil)
        (standard-output (if insert (current-buffer) t)))
    ;; In DEFS, find all symbols that are aliases for DEFINITION.
    (mapatoms (lambda (symbol)
                (and (fboundp symbol)
                     (not (eq symbol definition))
                     (eq func (condition-case ()
                                  (indirect-function symbol)
                                (error symbol)))
                     (push symbol defs))))
    ;; Look at all the symbols--first DEFINITION,
    ;; then its aliases.
    (dolist (symbol (cons definition defs))
      (let* ((remapped (command-remapping symbol))
             (keys (where-is-internal
                    symbol overriding-local-map nil nil remapped))
             (keys (mapconcat 'key-description keys ", "))
             string)
        (setq string
              (if insert
                  (if (> (length keys) 0)
                      (if remapped
                          (format "%s (%s) (remapped from %s)"
                                  keys remapped symbol)
                        (format "%s (%s)" keys symbol))
                    (format "M-x %s RET" symbol))
                (if (> (length keys) 0)
                    (if remapped
                        (format "%s is remapped to %s which is on %s"
                                definition symbol keys)
                      (format "%s is on %s" symbol keys))
                  ;; If this is the command the user asked about,
                  ;; and it is not on any key, say so.
                  ;; For other symbols, its aliases, say nothing
                  ;; about them unless they are on keys.
                  (if (eq symbol definition)
                      (format "%s is not on any key" symbol)))))
        (when string
          (unless (eq symbol definition)
            (princ ";\n its alias "))
          (princ string)))))
  nil)