XEPs, let conversion, and inlining

[Stas Boukarev]

From sbcl-bugs by cage:

((lambda ()
   (declare (optimize debug))
   (block nil
     (flet ((fun (x) (unless (funcall #'null x) (return))))
       (declare (inline fun))
       (map-into (vector 1) #'fun (coerce #(1) 'vector))))))
failed AVER:
    (NOT
     (SB-C::FUNCTIONAL-HAS-EXTERNAL-REFERENCES-P SB-C::CLAMBDA))
removing substitute-let-funargs from maybe-let-convert solves it. But a modified case still fails

(declaim (inline bar))
(defun bar (f)
  (funcall f))

(defun foo ()
  ((lambda ()
     (declare (optimize debug))
     (block nil
       (flet ((fun () (return)))
         (declare (inline fun))
         (bar #'fun))))))

with substitute-let-funargs
failed AVER: (NOT (SB-C::FUNCTIONAL-HAS-EXTERNAL-REFERENCES-P SB-C::CLAMBDA))

without:
failed AVER: (SUBSETP SB-C::END SB-C::END-STACK)

A test cases which fails the same either way:
(defun moo ())
(declaim (inline bar))
(defun bar (f)
  (multiple-value-call f (moo)))

(defun foo ()
  ((lambda ()
     (declare (optimize debug))
     (block nil
       (flet ((fun () (return)))
         (declare (inline fun))
         (bar #'fun))))))

The value NIL is not of type SB-C::NODE.

[Stas Boukarev (stassats)]

It is influenced by %coerce-callable-to-fun
(declaim (inline bar))
(defun bar (f)
  (%funcall f))

(defun foo ()
  ((lambda ()
     (declare (optimize debug))
     (block nil
       (flet ((fun () (return nil)))
         (declare (inline fun))
         (bar #'fun))))))

Doesn't fail

while
(defun bar (f)
  (%funcall (%coerce-callable-to-fun f)))
does with
    (NOT (FUNCTIONAL-HAS-EXTERNAL-REFERENCES-P CLAMBDA))

doing
(defknown x (t) t)
(deftransform x ((fun))
  'fun)

(defun bar (f)
  (%funcall (x f)))

gives failed AVER: (SUBSETP END END-STACK)

the difference is %coerce-callable-to-fun gives up once

[Stas Boukarev (stassats)]

BAR can go local actually
(defun foo ()
  ((lambda ()
     (declare (optimize debug))
     (block nil
       (flet ((fun () (return nil))
              (bar (f)
                (%funcall (x f))))
         (declare (inline fun bar))
         (bar #'fun))))))

Interestingly,
(defun foo ()
  ((lambda ()
     (declare (optimize debug))
     (block nil
       (flet ((fun () (return nil))
              (bar (f)
                (%funcall (x f))))
         (declare (inline fun bar))
         (bar #'fun))
       10))))

Fails with
failed AVER:
    (NOT (FUNCTIONAL-HAS-EXTERNAL-REFERENCES-P CLAMBDA))
not
failed AVER: (SUBSETP END END-STACK)

[Stas Boukarev (stassats)]

Another failure mode
(defun foo ()
  ((lambda ()
     (declare (optimize debug))
     (block nil
       (flet ((fun () (return nil))
              (bar (f)
                (funcall f)))
         (declare (inline fun bar))
         (print #'fun)
         (bar #'fun))))))

The value
  NIL
is not of type
  SB-C::IR2-LVAR

[Stas Boukarev (stassats)]

Smaller
(defun foo ()
  ((lambda ()
     (declare (optimize debug))
     (block nil
       (flet ((fun () (return nil)))
         (declare (inline fun))
         (print #'fun)
         (fun))))))

[Stas Boukarev (stassats)]

Another variation for
    (NOT
     (SB-C::FUNCTIONAL-HAS-EXTERNAL-REFERENCES-P SB-C::CLAMBDA))

(defun foo ()
  ((lambda ()
     (declare (optimize debug))
     (block nil
       (flet ((fun () (return nil)))
         (declare (inline fun))
         #'fun
         (fun))))))

[Stas Boukarev (stassats)]

These are not failing anymore, a new failing test case:
(defun foo ()
  (declare (optimize (debug 1) speed))
  (let ((z (block nil
             (labels ((f (x)
                        (return x)))
               (declare (inline f))
               (funcall (the function #'f) t)
               (funcall (the function #'f) t)))))

    (and z
         1)))

[Stas Boukarev (stassats)]

5cdc24d608bd7b482dfe8bf738aa6e22d146a7d8