Question about byte-compiler warning

Question about byte-compiler warning

[Vinicius Jose Latorre]

Hi,


Create a test file like:

test.el:
========
(cond
 ((featurep 'xemacs)
  (defun bar ()
    (message "bar XEmacs"))
  (defun foo ()
    (bar)))
 (t
  (defun bar ()
    (message "bar Emacs"))
  (defun foo ()
    (bar))))

(defun foobar ()
  (interactive)
  (foo))
========


Now byte-compile the file above.

The byte-compiler gives the following warning:

    In end of data:
    test.el:17:1:Warning: the following functions are not known to be 
defined:
        bar, foo


But aren't these functions (bar and foo) defined using cond construct?

Why does the byte-compiler give this warning?


Vinicius

Re: Question about byte-compiler warning

[Stefan Monnier]

> Create a test file like:

> test.el:
> ========
> (cond
> ((featurep 'xemacs)
>  (defun bar ()
>    (message "bar XEmacs"))
>  (defun foo ()
>    (bar)))
> (t
>  (defun bar ()
>    (message "bar Emacs"))
>  (defun foo ()
>    (bar))))

> (defun foobar ()
>  (interactive)
>  (foo))
> ========


> Now byte-compile the file above.

> The byte-compiler gives the following warning:

>    In end of data:
>    test.el:17:1:Warning: the following functions are not known to be
> defined:
>        bar, foo


> But aren't these functions (bar and foo) defined using cond construct?

> Why does the byte-compiler give this warning?

The byte-compiler only considers as defined a function which is trivially
obviously defined without having to do any kind of analysis.  I.e. it
doesn't look inside conditionals (or even inside `let's) to figure out what
might be defined in there.

A workaround I use sometimes is

   (defalias 'foo
     (if <toto>
         (lambda (bla) bli)
       (lambda (blo) blu)))

When the condition <toto> is used for several functions, this is a bit
inconvenient, tho.


        Stefan

Re: Question about byte-compiler warning

[Vinicius Jose Latorre]

Stefan Monnier wrote:
>> Create a test file like:
>>     
>
>   
>> test.el:
>> ========
>> (cond
>> ((featurep 'xemacs)
>>  (defun bar ()
>>    (message "bar XEmacs"))
>>  (defun foo ()
>>    (bar)))
>> (t
>>  (defun bar ()
>>    (message "bar Emacs"))
>>  (defun foo ()
>>    (bar))))
>>     
>
>   
>> (defun foobar ()
>>  (interactive)
>>  (foo))
>> ========
>>     
>
>
>   
>> Now byte-compile the file above.
>>     
>
>   
>> The byte-compiler gives the following warning:
>>     
>
>   
>>    In end of data:
>>    test.el:17:1:Warning: the following functions are not known to be
>> defined:
>>        bar, foo
>>     
>
>
>   
>> But aren't these functions (bar and foo) defined using cond construct?
>>     
>
>   
>> Why does the byte-compiler give this warning?
>>     
>
> The byte-compiler only considers as defined a function which is trivially
> obviously defined without having to do any kind of analysis.  I.e. it
> doesn't look inside conditionals (or even inside `let's) to figure out what
> might be defined in there.
>
> A workaround I use sometimes is
>
>    (defalias 'foo
>      (if <toto>
>          (lambda (bla) bli)
>        (lambda (blo) blu)))
>
> When the condition <toto> is used for several functions, this is a bit
> inconvenient, tho.
>   

Ok, but wasn't the construction:

(cond
   ((featurep 'xemacs)
     <xemacs-part> )
   (t
     <emacs-part> ))

recognized by the byte-compiler as a kind of conditional byte-compilation?


BTW, the byte-compiler gives no warning to the construction:

(eval-and-compile
   (cond
     ((featurep 'xemacs) <xemacs-part>)
     (t <emacs-part> ))))

It could also be used as an alternative construction.


Vinicius

Re: Question about byte-compiler warning

[Stefan Monnier]

> Ok, but wasn't the construction:

> (cond
>   ((featurep 'xemacs)
>     <xemacs-part> )
>   (t
>     <emacs-part> ))

> recognized by the byte-compiler as a kind of conditional byte-compilation?

It is, but that is not enough.  The same problem occurs with

  (let ((toto 1))
    (defun foo ()))

  (defun bar ()
    (foo))

In this case, the byte-compiler will also fail to see that `foo' is being
defined and will hence signal "Warning: the function `foo' is not known to
be defined".

> (eval-and-compile
>   (cond
>     ((featurep 'xemacs) <xemacs-part>)
>     (t <emacs-part> ))))

> It could also be used as an alternative construction.

eval-and-compile is ugly.


        Stefan

Re: Question about byte-compiler warning

[Vinicius Jose Latorre]

Stefan Monnier wrote:
>> (eval-and-compile
>>   (cond
>>     ((featurep 'xemacs) <xemacs-part>)
>>     (t <emacs-part> ))))
>>     
>> It could also be used as an alternative construction.
>>     
>
> eval-and-compile is ugly.
>   

Yep, it's ugly, but it works, that is, no warning.

Re: Question about byte-compiler warning

[Richard Stallman]

The compiler is not smart enough to deduce that this code

    (cond
     ((featurep 'xemacs)
      (defun bar ()
	(message "bar XEmacs"))
      (defun foo ()
	(bar)))
     (t
      (defun bar ()
	(message "bar Emacs"))
      (defun foo ()
	(bar))))

always defines bar.  And it is not smart enough to recognize that each
use of bar is in the same conditionals as some definition of bar.