Can compiler macros make use of type declarations?

[Antoniotti Marco]

> On Nov 9, 2017, at 10:17 , Chaitanya Gupta <mail at chaitanyagupta.com> wrote:
> 
> I tried this on SBCL:
> 
> (defun bar (x)
>  x)
> 
> (define-compiler-macro bar (&whole form x &environment env)
>  (when (symbolp x)
>    (print (multiple-value-list (clast:variable-information x env))))
>  form)
> 
> The form below, with the declaration, prints type information correctly:
> 
> (compile nil
>         (lambda ()
>           (let ((y 10)) (declare (fixnum y)) (bar y))))
>>> (:LEXICAL T ((TYPE . FIXNUM)))
> 
> However, the one below with no declarations, doesn't give any info:
> 
> (compile nil
>         (lambda ()
>           (let ((y 10)) (bar y))
>           (let ((y '(1 2 3))) (bar y))
>           (let ((y 'foo)) (bar y))))
>>> (:LEXICAL T NIL)
>>> (:LEXICAL T NIL)
>>> (:LEXICAL T NIL)
> 
> So I guess that, at least on SBCL, this is not possible.

Seems plausible.   I am not an expert on CMUCL/SBCL type inference, but I’d wager that it does not propagate types as we expect.
BTW.  LW behaves in the same way (plus: thank you; I discovered a shortcoming of CLAST LW wrapping that I just fixed).

Marco









> 
> Chaitanya
> 
> 
> On 9 November 2017 at 14:09, Antoniotti Marco
> <antoniotti.marco at disco.unimib.it> wrote:
>> CMUCL and SBCL have the Environment API somewhat available (*)
>> 
>> You can see whether they store the inferred values in there.
>> 
>> Marco
>> 
>> (*) Again, you can have a look at CLAST to see how to access it; I know: it is a shameless plug.
>> 
>> 
>> 
>>> On Nov 9, 2017, at 09:18 , Chaitanya Gupta <mail at chaitanyagupta.com> wrote:
>>> 
>>> So thanks to the replies on this I now know that most of the popular
>>> Lisps do support inspecting the environment to figure out declared
>>> types.
>>> 
>>> But what about inferred types (e.g. in CMUCL, SBCL)? Do these Lisps
>>> provide a way to know the inferred type of a variable if no
>>> declaration was made explicitly?
>>> 
>>> Chaitanya
>>> 
>>> On 7 November 2017 at 02:13, Chaitanya Gupta <mail at 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
>>> 
>> 
>> --
>> Marco Antoniotti, Associate Professor           tel.    +39 - 02 64 48 79 01
>> DISCo, Università Milano Bicocca U14 2043               http://bimib.disco.unimib.it
>> Viale Sarca 336
>> I-20126 Milan (MI) ITALY
>> 
>> Please check: http://troncopackage.org
>> 
>> Please note that I am not checking my Spam-box anymore.
>> Please do not forward this email without asking me first (cum grano salis).
>> 
>> 
>> 
>> 
>> 
> 

--
Marco Antoniotti, Associate Professor		tel.	+39 - 02 64 48 79 01
DISCo, Università Milano Bicocca U14 2043		http://bimib.disco.unimib.it
Viale Sarca 336
I-20126 Milan (MI) ITALY

Please check: http://troncopackage.org

Please note that I am not checking my Spam-box anymore.
Please do not forward this email without asking me first (cum grano salis).