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).
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? It seems like this declare should be for consumers of the function rather than inside of the function. 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, or 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. It also might be as tedious as wrapping each call with a with-no-warnings.
I see that with-no-warnings is defined like this:
(defun with-no-warnings (&rest body)
"Like `progn', but prevents compiler warnings in the body."
(declare (indent 0))
;; The implementation for the interpreter is basically trivial.
(car (last body)))
I see nothing that obviously suppresses warnings, so it seems like the interpreter checks to see if it is inside of this environment. Could we change the interpreter 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?
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.