A compiler-macro, just like a regular macro, receives an &environment argument which is supposed to contain (amongst other things) the lexical and global properties of bindings in the environment in which the macro is expanded. In the original language definition proposed by CLtL there was an environment access interface with functions like variablle-information which could return (for instance) what is known about the type of A in the lexical environment in which FOO is expanded. Unfortunately, the environment access system in CLtL was underspecified, there were no existing implementations, and no one was sure an implementation was even possible without imposing large efficiency hits at compile time. So we of X3J13 removed it from the standard. Duane Rettig of Franz later implemented a portable open-source sane environment module inspired by the original CLtL specification. This can be used to write a portable CL code walker of any kind, but it won't do you any good unless the code walker that is your favorite implementation's compiler happens to use it. But fortunately, several implementations provide documented environment access interfaces built into their compilers. Unfortunately, these interfaces are not defined by the standard, so their use generally makes code nonportable. BTW, a plain INTEGER type declaration is often not as effective as you'd expect because INTEGER type is the union of FIXNUM and BIGNUM. Arithmetic on the former can generally be inlined in a few machine instructions (particularly if the integer range can be narrowed further) but if any arguments or the result could be bignums, further runtime type tests and/or callouts will be generated. On Mon, Nov 6, 2017 at 12:43 PM, Chaitanya Gupta <mail@chaitanyagupta.com> wrote:
Let's say I have created a function called `FOO`:
(defun foo (x) ...)
To optimize this function, I write a compiler macro. Can I make use of type declarations that users of `FOO` might have made for the argument `X` that is passed in to it?
That is, let's say `FOO` is used like this:
(let ((a (something-that-returns-an-integer))) (declare (integer a)) (foo a))
The compiler macro for `FOO` cannot make any optimizations on the value of `A`, but can it take advantage of the fact that `A` is declared as in `INTEGER` here?
Chaitanya