RE: [Bug] (defun foo) during compilation defines `foo' as 0-arg ` igno re'

RE: [Bug] (defun foo) during compilation defines `foo' as 0-arg ` igno re'

[Wedler, Christoph]

 >> If you evaluate (defun foo), you get the error
 >> (wrong-number-of-arguments #<subr defun> 1)

 > There has been talk about making (defun foo) behave analogously to
 > (defvar foo), but at the moment this is not so, AFAIK.

Hm, maybe my message was a bit unclear.  The point of my bug report
(otherwise, it would be a feature request) was that (defun foo) does NOT
SIGNAL an ERROR when used inside `eval-when-compile'.

 > You can require the package where foo is defined.

Then it would be as bad as (defun foo) inside `eval-when-compile'...

 > In Tramp, I have the problem with compatibility code, and there I
 > fool the Lisp interpreter by doing (funcall 'foo ...), but that's
 > probably not the right approach.

At least the XEmacs byte compile would still warn about `foo' not being
defined...

- Christoph

[Bug] (defun foo) during compilation defines `foo' as 0-arg `igno re'

[Wedler, Christoph]

[Test using Emacs-21.2.95.1.]

If you evaluate (defun foo), you get the error
   (wrong-number-of-arguments #<subr defun> 1)

If you like to have your .el files compiled without warnings, you might
want to use above form just like you could use (defvar foo).  OK, let's
write the file bar.el:

    (eval-when-compile
      (defun foo))

    (defun bar ()
      (if (fboundp 'foo) (foo))  ; or more complicated 
      (message "bar"))

Using M-x byte-compile-file RET bar.el RET now doesn't produce any
warnings.  At first, you think, "hey, this is great", but then you
realize, it's not so:

 1. If you call (foo 2) instead (foo), you get the warning

    While compiling bar:
      ** foo called with 1 argument, but accepts only 0

 2. After the compilation, evaluating (fboundp 'foo) returns t, and
    `foo' is defined as a 0-arg function which returns nil.

While 1 is just annoying, 2 is really bad: if a package uses (defun
foo), it must now mention in INSTALL s/th like "exit and restart Emacs
after any compilation of the .el files".  If (defun foo) would simply
signal an error, we could use (ignore-errors (defun foo)) in the hope
that a future Emacs would define a useful semantics for (defun foo),
i.e., just like for (defvar foo).

- Christoph

Re: [Bug] (defun foo) during compilation defines `foo' as 0-arg `igno re'

[Kai Großjohann]

"Wedler, Christoph" <christoph.wedler@sap.com> writes:

> [Test using Emacs-21.2.95.1.]
>
> If you evaluate (defun foo), you get the error
>    (wrong-number-of-arguments #<subr defun> 1)

There has been talk about making (defun foo) behave analogously to
(defvar foo), but at the moment this is not so, AFAIK.

You can require the package where foo is defined.

In Tramp, I have the problem with compatibility code, and there I
fool the Lisp interpreter by doing (funcall 'foo ...), but that's
probably not the right approach.
-- 
A preposition is not a good thing to end a sentence with.