Autoload more carefully from Lisp. Follow aliases for function properties.

* lisp/subr.el (autoloadp): New function.
(symbol-file): Use it.
(function-get): New function.
* lisp/emacs-lisp/macroexp.el (macroexp--expand-all): Use function-get and
autoload-do-load.
* lisp/emacs-lisp/lisp-mode.el (lisp-font-lock-syntactic-face-function)
(lisp-indent-function):
* lisp/emacs-lisp/gv.el (gv-get):
* lisp/emacs-lisp/edebug.el (get-edebug-spec, edebug-basic-spec):
* lisp/emacs-lisp/byte-opt.el (byte-optimize-form):
* lisp/emacs-lisp/bytecomp.el (byte-compile-arglist-warn):
* lisp/emacs-lisp/autoload.el (make-autoload, autoload-print-form):
Use function-get.
* lisp/emacs-lisp/cl.el: Don't propagate function properties any more.

* src/eval.c (Fautoload_do_load): Rename from do_autoload, export to Lisp,
add argument, tune behavior, and adjust all callers.

* lisp/speedbar.el (speedbar-add-localized-speedbar-support):
* lisp/emacs-lisp/disass.el (disassemble-internal):
* lisp/desktop.el (desktop-load-file):
* lisp/help-fns.el (help-function-arglist, find-lisp-object-file-name)
(describe-function-1):
* lisp/emacs-lisp/find-func.el (find-function-noselect):
* lisp/emacs-lisp/elp.el (elp-instrument-function):
* lisp/emacs-lisp/advice.el (ad-has-proper-definition):
* lisp/apropos.el (apropos-safe-documentation, apropos-macrop):
* lisp/emacs-lisp/debug.el (debug-on-entry):
* lisp/emacs-lisp/cl-macs.el (cl-compiler-macroexpand):
* lisp/emacs-lisp/byte-opt.el (byte-compile-inline-expand):
* lisp/calc/calc.el (name): Use autoloadp & autoload-do-load.

6 files changed, 60 insertions, 48 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 88c90dd84d8..eb74f458942 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,8 @@
+2012-07-26  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (Fautoload_do_load): Rename from do_autoload, export to Lisp,
+        add argument, tune behavior, and adjust all callers.
+
 2012-07-25  Paul Eggert  <eggert@cs.ucla.edu>
 
         Use typedef for EMACS_INT, EMACS_UINT.
diff --git a/src/data.c b/src/data.c
index 110e8ae41ab..b23bcbe15b3 100644
--- a/src/data.c
+++ b/src/data.c
@@ -761,7 +761,7 @@ Value, if non-nil, is a list \(interactive SPEC).  */)
         {
           struct gcpro gcpro1;
           GCPRO1 (cmd);
-          do_autoload (fun, cmd);
+          Fautoload_do_load (fun, cmd, Qnil);
           UNGCPRO;
           return Finteractive_form (cmd);
         }
@@ -2059,7 +2059,7 @@ function chain of symbols.  */)
   return Qnil;
 }
 
-/* Extract and set vector and string elements */
+/* Extract and set vector and string elements.  */
 
 DEFUN ("aref", Faref, Saref, 2, 2, 0,
        doc: /* Return the element of ARRAY at index IDX.
diff --git a/src/eval.c b/src/eval.c
index a0143c372de..a0a05ebf0dc 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -988,26 +988,14 @@ definitions to shadow the loaded ones for use in file byte-compilation.  */)
         {
           /* SYM is not mentioned in ENVIRONMENT.
              Look at its function definition.  */
+          struct gcpro gcpro1;
+          GCPRO1 (form);
+          def = Fautoload_do_load (def, sym, Qmacro);
+          UNGCPRO;
           if (EQ (def, Qunbound) || !CONSP (def))
             /* Not defined or definition not suitable.  */
             break;
-          if (EQ (XCAR (def), Qautoload))
-            {
-              /* Autoloading function: will it be a macro when loaded?  */
-              tem = Fnth (make_number (4), def);
-              if (EQ (tem, Qt) || EQ (tem, Qmacro))
-                /* Yes, load it and try again.  */
-                {
-                  struct gcpro gcpro1;
-                  GCPRO1 (form);
-                  do_autoload (def, sym);
-                  UNGCPRO;
-                  continue;
-                }
-              else
-                break;
-            }
-          else if (!EQ (XCAR (def), Qmacro))
+          if (!EQ (XCAR (def), Qmacro))
             break;
           else expander = XCDR (def);
         }
@@ -1952,22 +1940,35 @@ un_autoload (Lisp_Object oldqueue)
    FUNNAME is the symbol which is the function's name.
    FUNDEF is the autoload definition (a list).  */
 
-void
-do_autoload (Lisp_Object fundef, Lisp_Object funname)
+DEFUN ("autoload-do-load", Fautoload_do_load, Sautoload_do_load, 1, 3, 0,
+       doc: /* Load FUNDEF which should be an autoload.
+If non-nil, FUNNAME should be the symbol whose function value is FUNDEF,
+in which case the function returns the new autoloaded function value.
+If equal to `macro', MACRO-ONLY specifies that FUNDEF should only be loaded if
+it is defines a macro.  */)
+  (Lisp_Object fundef, Lisp_Object funname, Lisp_Object macro_only)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
-  Lisp_Object fun;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
+  if (!CONSP (fundef) || !EQ (Qautoload, XCAR (fundef)))
+    return fundef;
+
+  if (EQ (macro_only, Qmacro))
+    {
+      Lisp_Object kind = Fnth (make_number (4), fundef);
+      if (! (EQ (kind, Qt) || EQ (kind, Qmacro)))
+        return fundef;
+    }
+
   /* This is to make sure that loadup.el gives a clear picture
      of what files are preloaded and when.  */
   if (! NILP (Vpurify_flag))
     error ("Attempt to autoload %s while preparing to dump",
            SDATA (SYMBOL_NAME (funname)));
 
-  fun = funname;
   CHECK_SYMBOL (funname);
-  GCPRO3 (fun, funname, fundef);
+  GCPRO3 (funname, fundef, macro_only);
 
   /* Preserve the match data.  */
   record_unwind_save_match_data ();
@@ -1982,18 +1983,28 @@ do_autoload (Lisp_Object fundef, Lisp_Object funname)
      The value saved here is to be restored into Vautoload_queue.  */
   record_unwind_protect (un_autoload, Vautoload_queue);
   Vautoload_queue = Qt;
-  Fload (Fcar (Fcdr (fundef)), Qnil, Qt, Qnil, Qt);
+  /* If `macro_only', assume this autoload to be a "best-effort",
+     so don't signal an error if autoloading fails.  */
+  Fload (Fcar (Fcdr (fundef)), macro_only, Qt, Qnil, Qt);
 
   /* Once loading finishes, don't undo it.  */
   Vautoload_queue = Qt;
   unbind_to (count, Qnil);
 
-  fun = Findirect_function (fun, Qnil);
-
-  if (!NILP (Fequal (fun, fundef)))
-    error ("Autoloading failed to define function %s",
-           SDATA (SYMBOL_NAME (funname)));
   UNGCPRO;
+
+  if (NILP (funname))
+    return Qnil;
+  else
+    {
+      Lisp_Object fun = Findirect_function (funname, Qnil);
+
+      if (!NILP (Fequal (fun, fundef)))
+        error ("Autoloading failed to define function %s",
+               SDATA (SYMBOL_NAME (funname)));
+      else
+        return fun;
+    }
 }
 
 
@@ -2200,7 +2211,7 @@ eval_sub (Lisp_Object form)
         xsignal1 (Qinvalid_function, original_fun);
       if (EQ (funcar, Qautoload))
         {
-          do_autoload (fun, original_fun);
+          Fautoload_do_load (fun, original_fun, Qnil);
           goto retry;
         }
       if (EQ (funcar, Qmacro))
@@ -2729,7 +2740,6 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   ptrdiff_t i;
 
   QUIT;
-  maybe_gc ();
 
   if (++lisp_eval_depth > max_lisp_eval_depth)
     {
@@ -2742,10 +2752,13 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   backtrace.next = backtrace_list;
   backtrace_list = &backtrace;
   backtrace.function = &args[0];
-  backtrace.args = &args[1];
+  backtrace.args = &args[1];    /* This also GCPROs them.  */
   backtrace.nargs = nargs - 1;
   backtrace.debug_on_exit = 0;
 
+  /* Call GC after setting up the backtrace, so the latter GCPROs the args.  */
+  maybe_gc ();
+
   if (debug_on_next_call)
     do_debug_on_call (Qlambda);
 
@@ -2857,7 +2870,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
         val = funcall_lambda (fun, numargs, args + 1);
       else if (EQ (funcar, Qautoload))
         {
-          do_autoload (fun, original_fun);
+          Fautoload_do_load (fun, original_fun, Qnil);
           CHECK_CONS_LIST ();
           goto retry;
         }
@@ -3582,6 +3595,7 @@ alist of active lexical bindings.  */);
   defsubr (&Scalled_interactively_p);
   defsubr (&Scommandp);
   defsubr (&Sautoload);
+  defsubr (&Sautoload_do_load);
   defsubr (&Seval);
   defsubr (&Sapply);
   defsubr (&Sfuncall);
diff --git a/src/keyboard.c b/src/keyboard.c
index 0c03a2143d8..1f6c47eaf79 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -8827,18 +8827,12 @@ access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
 
   next = access_keymap (map, key, 1, 0, 1);
 
-  /* Handle symbol with autoload definition.  */
-  if (SYMBOLP (next) && !NILP (Ffboundp (next))
-      && CONSP (XSYMBOL (next)->function)
-      && EQ (XCAR (XSYMBOL (next)->function), Qautoload))
-    do_autoload (XSYMBOL (next)->function, next);
-
   /* Handle a symbol whose function definition is a keymap
      or an array.  */
   if (SYMBOLP (next) && !NILP (Ffboundp (next))
       && (ARRAYP (XSYMBOL (next)->function)
           || KEYMAPP (XSYMBOL (next)->function)))
-    next = XSYMBOL (next)->function;
+    next = Fautoload_do_load (XSYMBOL (next)->function, next, Qnil);
 
   /* If the keymap gives a function, not an
      array, then call the function with one arg and use
@@ -10282,7 +10276,7 @@ a special event, so ignore the prefix argument and don't clear it.  */)
           struct gcpro gcpro1, gcpro2;
 
           GCPRO2 (cmd, prefixarg);
-          do_autoload (final, cmd);
+          Fautoload_do_load (final, cmd, Qnil);
           UNGCPRO;
         }
       else
diff --git a/src/keymap.c b/src/keymap.c
index 510c5ea7f3e..feaf0cfd961 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -225,7 +225,7 @@ when reading a key-sequence to be looked-up in this keymap.  */)
    Fdefine_key should cause keymaps to be autoloaded.
 
    This function can GC when AUTOLOAD is non-zero, because it calls
-   do_autoload which can GC.  */
+   Fautoload_do_load which can GC.  */
 
 Lisp_Object
 get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
@@ -259,7 +259,7 @@ get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
                   struct gcpro gcpro1, gcpro2;
 
                   GCPRO2 (tem, object);
-                  do_autoload (tem, object);
+                  Fautoload_do_load (tem, object, Qnil);
                   UNGCPRO;
 
                   goto autoload_retry;
diff --git a/src/lisp.h b/src/lisp.h
index e4eb8ce5084..d9305555778 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2822,7 +2822,6 @@ extern Lisp_Object unbind_to (ptrdiff_t, Lisp_Object);
 extern _Noreturn void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
 extern _Noreturn void verror (const char *, va_list)
   ATTRIBUTE_FORMAT_PRINTF (1, 0);
-extern void do_autoload (Lisp_Object, Lisp_Object);
 extern Lisp_Object un_autoload (Lisp_Object);
 extern void init_eval_once (void);
 extern Lisp_Object safe_call (ptrdiff_t, Lisp_Object *);
@@ -2834,7 +2833,7 @@ extern void mark_backtrace (void);
 #endif
 extern void syms_of_eval (void);
 
-/* Defined in editfns.c */
+/* Defined in editfns.c.  */
 extern Lisp_Object Qfield;
 extern void insert1 (Lisp_Object);
 extern Lisp_Object format2 (const char *, Lisp_Object, Lisp_Object);
@@ -2851,7 +2850,7 @@ const char *get_system_name (void);
 extern void syms_of_editfns (void);
 extern void set_time_zone_rule (const char *);
 
-/* Defined in buffer.c */
+/* Defined in buffer.c.  */
 extern int mouse_face_overlay_overlaps (Lisp_Object);
 extern _Noreturn void nsberror (Lisp_Object);
 extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
@@ -2870,7 +2869,7 @@ extern void init_buffer (void);
 extern void syms_of_buffer (void);
 extern void keys_of_buffer (void);
 
-/* Defined in marker.c */
+/* Defined in marker.c.  */
 
 extern ptrdiff_t marker_position (Lisp_Object);
 extern ptrdiff_t marker_byte_position (Lisp_Object);