FILTER-DOLIST-DECLARATIONS braindamaged

What do you mean "don't bind 's' in the result form"? The standard explicitly states "At the time result-form is processed, var is bound to nil."

Also, it is never incorrect to delete declarations, other than (optimize
safety) and (special ...), because in all other cases implementations
are allowed to ignore them.

I'd be fine with not removing the declarations; that will mean that all
user code which tries to declare the type of a dolist iteration variable
would instead have to do e.g.

  (dolist (s list 'foo)
    (let ((s s))
      (declare (string s))
      ...))

which strictly speaking is necessary for actual conforming code.

Christophe

Or declare it (or null string)

How about just removing all but OPTIMIZE, SPECIAL, and MUFFLE-CONDITIONS?

Nikodemus Siivola <email address hidden> writes:

> How about just removing all but OPTIMIZE, SPECIAL, and MUFFLE-
> CONDITIONS?

Users of cltl2-style environments can define their own declarations,
which can be introspected later in the environment arguments of macros.
We should probably not remove those...

Since the code that the reporter is using to illustrate "braindamage" is
nonconforming, I think it's totally fine to close this with wontfix; the
only other resolution I think is acceptable is to touch no declarations
and require those who wish to declare iteration variable types in DOLIST
to jump through an extra hoop.

Good point re. user declarations.

I'm mostly thinking about how to minimize the impact for user code that has happily been doing

  (dolist (x list res)
    (declare (type string x))
    ...)

... as I'd rather not break it unless we really have to.

What about amending type declarations with (or null original-declaration)?

Stas Boukarev <email address hidden> writes:

> What about amending type declarations with (or null original-
> declaration)?

That potentially makes the loop less efficient (more typechecking,
possible extra dispatches / lack of inlining). Also, we can't a priori
tell what is a type declaration of a user-defined type (in the short
form) and what is a magical declaration in the cltl2 sense.

The Right Thing is that the user code is broken. The fact that this has
caused a user to raise a bug asserting that our implementation is broken
suggests that we either need to perfect the illusion of doing what the
user meant in all cases, or aggressively assert that the user code is
broken -- and I don't think that we can perfect the illusion.

>That potentially makes the loop less efficient
Not in the loop, in the result form.

Well...

we could add a declaration along the lines of

  (let ((s nil))
    (declare (string s))
    (declare (sb-c::aggressively-ignorable s))
    ...)

which would mean that the compiler should silently ignore conflicting declarations if the variable is lexical and unused except for the initial binding to a constant value...

But I'm not sure that such a good idea. :)

Point taken.

Actually, you know what would /almost/ work?

   (defknown unknown-nil () t (flushable))

   (defun unknown-nil () nil)

and expanding the DOLIST in

   (defun foo (strings)
     (let ((n 0))
       (dolist (s strings n)
        (declare (string s))
        (incf n (length s)))))

to

   (BLOCK NIL
     (LET ((#:N-LIST957 STRINGS))
      (TAGBODY
       #:START958
         (UNLESS (ENDP #:N-LIST957)
           (LET* ((S (CAR #:N-LIST957)))
             (DECLARE (STRING S))
             (SETQ #:N-LIST957 (CDR #:N-LIST957))
             (TAGBODY (INCF N (LENGTH S))))
           (GO #:START958))))
     (LET ((S (UNKNOWN-NIL)))
       (DECLARE (IGNORABLE S))
       (DECLARE (STRING S))
       N))

...only issue being that the compiler isn't brave enough to delete S as unused because there's a cast.

you've convinced me of the invalidity of the original complaint