Re: Solving some specific warnings (was: Fixing compilation and byte-compilation warnings before 25.1)

[Artur Malabarba <bruce.connor.am@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 2661 bytes --]

On 14 Nov 2015 6:49 pm, "daniel sutton" <danielsutton01@gmail.com> wrote:
>
> Thank you so much for the response Artur. I actually saw someone post a
link to a blog post of yours about the using # before lambdas today as well
(just saying that your contributions are passed around the community and
are much appreciated).

That's nice to know. ☺

> I can add (with-no-warnings (recursive-call-to-deprecated-args-list
...)...) calls to the warnings of this type. However, do you have any
thoughts about trying to modify the declare statements? I wasn't sure if we
could have the compiler check if it was being called from within the actual
original definition of a function and therefore be smart enough to not
issue a warning,

Should be possible, and I almost agree with it. The problem is that there
are (unfortunately) some pretty long functions in core, so I can perfectly
imagine someone editing a signature and forgetting to change a function
call inside the same function.

Besides, recursive calls like this one are sparse enough that it should be
OK to just suppress warnings on them when the sig changes.

> if we could add some type of declaration that this is the core so the
warnings are not for us.
> My hesitation are that some of these might be heavy handed and might make
the core more brittle as time goes on and no warnings are issued when
things change more.

Precisely. The core is large, it is managed by lots of people and it is
edited by even more people. So this warning does very much apply to core on
many cases. There are no warnings that we can safely disable as a whole in
core.

> I see that with-no-warnings is defined like this:
>...
> I see nothing that obviously suppresses warnings, so it seems like the
interpreter checks to see if it is inside of this environment.

No. The compiler checks. The interpreter doesn't throw warnings. That's why
the definition is so trivial. This function is treated specially by the
compiler.

> Could we change the [compiler] to check if its running inside of a
function with a (declare (advertised-calling-convention (signature)
"version")) and issue no warnings about advertised-calling-convention
violations?

Probably. I'm not against this, but I wouldn't go through the effort
either. I'm also not sure if it's a good idea because we have some really
large functions running around.

> Lots of rambling and words there but mundane problems can have
interesting solutions. Thanks so much and I hope you're having a great
weekend.

No problem. The weekend was nice enough that I forgot to reply to you
yesterday. 😀

Best,

[-- Attachment #2: Type: text/html, Size: 3017 bytes --]