🚀 go-pugleaf

Not an actual bug, but...

Consider

     (funcall (calculate foo) arg1 arg2)

This is produced by the           
current byte-compiler:            As far as I can tell, 
                                  this is entirely equivalent: 
0   constant funcall              
1   constant calculate            0   constant calculate  
2   varref   foo                  1   varref   foo        
3   call     1                    2   call     1          
4   varref   arg1                 3   varref   arg1       
5   varref   arg2                 4   varref   arg2       
6   call     3                    5   call     2          
7   return                        6   return              

If there's no reason the byte-compiler should not be 
producing the code on the right (which should be 
faster depending on the expense of function calls),
the following could be added to bytecomp.el:

(put 'funcall 'byte-compile 'byte-compile-funcall)

(defun byte-compile-funcall (form)
  (let ((args (cdr form)))
    (while args (byte-compile-form (car args)) (setq args (cdr args))))
  (byte-compile-out 'byte-call (length (nthcdr 2 form)))
  (setq byte-compile-depth (- byte-compile-depth (length (nthcdr 2 form)))))


Emacs-version: 18.55

--
Roger Crew                                        ``I kill Optimax...''
Usenet:    {arpa gateways, decwrl, uunet, rutgers}!cs.stanford.edu!crew
Internet:  crew@CS.Stanford.EDU