Loop wong macroexpansion for (LOOP FOR I FROM 1 TO 5 by 1 FOR C FROM #C(0 1) by 1 COLLECT C)

Describe the problem here.

(LOOP FOR I FROM 1 TO 5 by 1 FOR C FROM #C(0 1) by 1 COLLECT C)
;;; Warning: The form #C(0 1) evaluated to #C(0 1), which was not of the anticipated type REAL.
Current LOOP context: FOR C FROM #C(0 1) BY 1 COLLECT.

(#C(0 1) #C(1 1) #C(2 1) #C(3 1) #C(4 1))
> (macroexpand '(LOOP FOR I FROM 1 TO 5 by 1 FOR C FROM #C(0 1) by 1 COLLECT C))
;;; Warning: The form #C(0 1) evaluated to #C(0 1), which was not of the anticipated type REAL.
Current LOOP context: FOR C FROM #C(0 1) BY 1 COLLECT.

(BLOCK NIL
  (LET ((I 1))
    (DECLARE (TYPE FIXNUM I))
    (LET ((C #C(0 1)))
      (DECLARE (TYPE (OR REAL (COMPLEX RATIONAL)) C))
      (SI::WITH-LOOP-LIST-COLLECTION-HEAD (#:LOOP-LIST-HEAD3 #:LOOP-LIST-TAIL4)
                                          (SI::LOOP-BODY NIL
                                                         (NIL NIL NIL NIL NIL
                                                          NIL NIL NIL)
                                                         ((SI::LOOP-COLLECT-RPLACD
                                                           (#:LOOP-LIST-HEAD3
                                                            #:LOOP-LIST-TAIL4)
                                                           (LIST C)))
                                                         (NIL
                                                          (SI::LOOP-REALLY-DESETQ
                                                           I
                                                           (SI::LOOP-UNSAFE
                                                            (1+ I)))
                                                          (WHEN (> I '5)
                                                            (GO SI::END-LOOP))
                                                          NIL NIL
                                                          (SI::LOOP-REALLY-DESETQ
                                                           C
                                                           (SI::LOOP-UNSAFE
                                                            (1+ C)))
                                                          NIL NIL)
                                                         ((RETURN-FROM NIL
                                                            (SI::LOOP-COLLECT-ANSWER
                                                             #:LOOP-LIST-HEAD3))))))))
T

Describe expected result and what provide the output you got. no warning about ;;; Warning: The form #C(0 1) evaluated to #C(0 1), which was not of the anticipated type REAL.

Provide details regarding ECL version (or preferably commit), operating system and if revelant the build options and versions of the build tools.

 (lisp-implementation-version)
(ext:lisp-implementation-vcs-id)`
(software-type)
(software-version)
(machine-type)
*features*
"20.4.24"
> 
"04aa7c539eceb03dd728c16af6726d0511badf4d"
> 
(SOFTWARE-TYPE)
> 
"18.7.0"
> 
"x86_64"
> 
(:WALKER :CDR-1 :CDR-5 :DARWIN :FORMATTER :CDR-7 :ECL-WEAK-HASH :LITTLE-ENDIAN
 :ECL-READ-WRITE-LOCK :LONG-LONG :UINT64-T :UINT32-T :UINT16-T :COMPLEX-FLOAT
 :LONG-FLOAT :UNICODE :DFFI :CLOS-STREAMS :CMU-FORMAT :UNIX :ECL-PDE :DLOPEN
 :CLOS :THREADS :BOEHM-GC :ANSI-CL :COMMON-LISP :FLOATING-POINT-EXCEPTIONS
 :IEEE-FLOATING-POINT :PACKAGE-LOCAL-NICKNAMES :CDR-14 :PREFIXED-API :FFI
 :X86_64 :COMMON :ECL)

Some additional notes. We had the same issue in clasp and it was fixed by this oneline change: https://github.com/clasp-developers/clasp/pull/968

Applying the same fix to ecl, results in a clean macroexpansion:

> (macroexpand '(LOOP FOR I FROM 1 TO 5 by 1 FOR C FROM #C(0 1) by 1 COLLECT C))

(BLOCK NIL
  (LET ((I 1))
    (DECLARE (TYPE FIXNUM I))
    (LET ((C #C(0 1)))
      (DECLARE (TYPE NUMBER C))
      (SI::WITH-LOOP-LIST-COLLECTION-HEAD (#:LOOP-LIST-HEAD1 #:LOOP-LIST-TAIL2)
                                          (SI::LOOP-BODY NIL
                                                         (NIL NIL NIL NIL NIL
                                                          NIL NIL NIL)
                                                         ((SI::LOOP-COLLECT-RPLACD
                                                           (#:LOOP-LIST-HEAD1
                                                            #:LOOP-LIST-TAIL2)
                                                           (LIST C)))
                                                         (NIL
                                                          (SI::LOOP-REALLY-DESETQ
                                                           I
                                                           (SI::LOOP-UNSAFE
                                                            (1+ I)))
                                                          (WHEN (> I '5)
                                                            (GO SI::END-LOOP))
                                                          NIL NIL
                                                          (SI::LOOP-REALLY-DESETQ
                                                           C
                                                           (SI::LOOP-UNSAFE
                                                            (1+ C)))
                                                          NIL NIL)
                                                         ((RETURN-FROM NIL
                                                            (SI::LOOP-COLLECT-ANSWER
                                                             #:LOOP-LIST-HEAD1))))))))
T
> (LOOP FOR I FROM 1 TO 5 by 1 FOR C FROM #C(0 1) by 1 COLLECT C)               

(#C(0 1) #C(1 1) #C(2 1) #C(3 1) #C(4 1))

There is one thing in don't understand though: without the fix the declaration for c is `(DECLARE (TYPE (OR REAL (COMPLEX RATIONAL)) C))``

This declaration is correct, but where is the (COMPLEX RATIONAL)generated?

will make a pr anyhow