loop accumulation var does not have type declaration.

[SATO shinichi]

Actually, this is not a bug, just wishes.

(compile nil (lambda ()
               (declare (optimize speed))
               (loop :for c :across "foo"
                     :collect c :into l
                     :finally (return (coerce l 'string)))))

; in: LAMBDA ()
; (COERCE CL-USER::L 'STRING)
;
; note: unable to
; optimize
; due to type uncertainty:
; The first argument is a (OR CONS NULL
; (AND (NOT (VECTOR CHARACTER)) (NOT BASE-STRING)
; VECTOR)
; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
;
; compilation unit finished
; printed 1 note
#<FUNCTION (LAMBDA ()) {5372198B}>
NIL
NIL

To muffle this note, currently, we need to wrap var (l in this case) with THE special form.

(compile nil (lambda ()
               (declare (optimize speed))
               (loop :for c :across "foo"
                     :collect c :into l
                     :finally (return (coerce
                                        (the list l) ;;;
                                        'string)))))
#<FUNCTION (LAMBDA ()) {5372198B}>
NIL
NIL

Ideally, user-head-var declared type automatically because
list-accumulation var is always the type of LIST.

Probably with-loop-list-collection-head may the ground zero.

(sb-xc:defmacro with-loop-list-collection-head
    ((head-var tail-var &optional user-head-var) &body body)
  (let ((l (and user-head-var (list (list user-head-var nil)))))
    `(let* ((,head-var (list nil)) (,tail-var ,head-var) ,@l)
       (declare (truly-dynamic-extent ,head-var)
  ,@(and user-head-var `((type list ,user-head-var)))) ;;;
       ,@body)))

Sorry, not tested.