bug#6750: Byte compiler: spurious message "cl used at runtime"

bug#6750: Byte compiler: spurious message "cl used at runtime"

[Alan Mackenzie]

Hi, Emacs,

In this macro declaration:

    (defmacro c-declare-lang-variables ()
      `(progn
         ,@(mapcan (lambda (init)
                     `(,(if (elt init 2)
                            `(defvar ,(car init) nil ,(elt init 2))
                          `(defvar ,(car init) nil))
                       (make-variable-buffer-local ',(car init))))
                   (cdr c-lang-variable-inits))))

, (from cc-engine.el), the byte-compiler gives this warning:

    "Function `mapcan' from cl package called at runtime".

It is clear that the mapcan, being within a ,@ construct, does its work
at macro-expansion time, i.e. compile time.

Thus the warning message is wrong.  This is a bug.

-- 
Alan Mackenzie (Nuremberg, Germany).

bug#6750: Byte compiler: spurious message "cl used at runtime"

[Stefan Monnier]

> In this macro declaration:

>     (defmacro c-declare-lang-variables ()
>       `(progn
>          ,@(mapcan (lambda (init)
>                      `(,(if (elt init 2)
>                             `(defvar ,(car init) nil ,(elt init 2))
>                           `(defvar ,(car init) nil))
>                        (make-variable-buffer-local ',(car init))))
>                    (cdr c-lang-variable-inits))))

> , (from cc-engine.el), the byte-compiler gives this warning:

>     "Function `mapcan' from cl package called at runtime".

> It is clear that the mapcan, being within a ,@ construct, does its work
> at macro-expansion time, i.e. compile time.

> Thus the warning message is wrong.  This is a bug.

This macro will be in the .elc.  This means it can be called "at run
time" (e.g. if you do M-: (c-declare-lang-variables ...) RET).


        Stefan

bug#6750: Byte compiler: spurious message "cl used at runtime"

[Alan Mackenzie]

Hi, Stefan,

On Thu, Jul 29, 2010 at 01:01:46AM +0200, Stefan Monnier wrote:
> > In this macro declaration:

> >     (defmacro c-declare-lang-variables ()
> >       `(progn
> >          ,@(mapcan (lambda (init)
> >                      `(,(if (elt init 2)
> >                             `(defvar ,(car init) nil ,(elt init 2))
> >                           `(defvar ,(car init) nil))
> >                        (make-variable-buffer-local ',(car init))))
> >                    (cdr c-lang-variable-inits))))

> > , (from cc-engine.el), the byte-compiler gives this warning:

> >     "Function `mapcan' from cl package called at runtime".

> > It is clear that the mapcan, being within a ,@ construct, does its work
> > at macro-expansion time, i.e. compile time.

> > Thus the warning message is wrong.  This is a bug.

> This macro will be in the .elc.  This means it can be called "at run
> time" (e.g. if you do M-: (c-declare-lang-variables ...) RET).

That brought a smile to my face.  It's pure sophistry. :-)  With no more
creativity than you've just shown, ANY use of mapcan could be "shown" to
be "use at runtime".  So why not shorten the warning message to

    "Function `mapcan' from cl package was used"
    
?  ;-)

Or, perhaps you could indulge me a little, and show an example of mapcan
(or some other cl function) which isn't "use at runtime".  You know as
well as I do, that there's no rigid separation of Lisp into compilation
and running phases.

I put it to you that that error message is not, in general, helpful.  I
think it should be restricted to uses of mapcan at runtime (in a defun)
or when it's in the form generated by a macro.

I'm trying to get rid of warnings messages in CC Mode.

>         Stefan

-- 
Alan Mackenzie (Nuremberg, Germany).

bug#6750: Byte compiler: spurious message "cl used at runtime"

[Juanma Barranquero]

On Thu, Jul 29, 2010 at 21:03, Alan Mackenzie <acm@muc.de> wrote:

> Or, perhaps you could indulge me a little, and show an example of mapcan
> (or some other cl function) which isn't "use at runtime".

;; at top level
(eval-when-compile
   (mapcan ...))

> I put it to you that that error message is not, in general, helpful.  I
> think it should be restricted to uses of mapcan at runtime (in a defun)
> or when it's in the form generated by a macro.

But the point is that the macro could be called at runtime and
`mapcan' would not be defined.

Try byte-compiling test.el:
--------------------------------------------------------------------------------
(eval-when-compile (require 'cl))

(defmacro mapcan-at-runtime ()
  `(setq sample ',(mapcan 'identity '((a) (b) (c)))))
--------------------------------------------------------------------------------

(which produces the warning), and then

emacs -Q -l test.elc
M-: (mapcan-at-runtime) <RET>

    Juanma

bug#6750: Byte compiler: spurious message "cl used at runtime"

[Stefan Monnier]

>> This macro will be in the .elc.  This means it can be called "at run
>> time" (e.g. if you do M-: (c-declare-lang-variables ...) RET).
> That brought a smile to my face.  It's pure sophistry. :-)

Except that this is not the reason I put the warning, but the reason why
the byte-compiler's code thinks the warning is warranted.
The byte-compiler is fairly stupid and doesn't know that this macro is
not intended to be used at runtime.

I agree it's not great, and it leads to "spurious" warnings like that.
Suggestions (and patches even better) welcome to try and resolve
the problem.


        Stefan

bug#6750: Byte compiler: spurious message "cl used at runtime"

[Lars Magne Ingebrigtsen]

Stefan Monnier <monnier@iro.umontreal.ca> writes:

> The byte-compiler is fairly stupid and doesn't know that this macro is
> not intended to be used at runtime.

The macro, however, is in the .elc file, so I don't think this is a
bug.  (Although the warning could be changed to, perhaps, "cl in the
.elc file" or something.)

Anyway, I'm closing the report.

-- 
(domestic pets only, the antidote for overdose, milk.)
  bloggy blog http://lars.ingebrigtsen.no/