+ (careful-call fun-name
+ args
+ call
+ ;; Note: CMU CL had COMPILER-WARN here, and that
+ ;; seems more natural, but it's probably not.
+ ;;
+ ;; It's especially not while bug 173 exists:
+ ;; Expressions like
+ ;; (COND (END
+ ;; (UNLESS (OR UNSAFE? (<= END SIZE)))
+ ;; ...))
+ ;; can cause constant-folding TYPE-ERRORs (in
+ ;; #'<=) when END can be proved to be NIL, even
+ ;; though the code is perfectly legal and safe
+ ;; because a NIL value of END means that the
+ ;; #'<= will never be executed.
+ ;;
+ ;; Moreover, even without bug 173,
+ ;; quite-possibly-valid code like
+ ;; (COND ((NONINLINED-PREDICATE END)
+ ;; (UNLESS (<= END SIZE))
+ ;; ...))
+ ;; (where NONINLINED-PREDICATE is something the
+ ;; compiler can't do at compile time, but which
+ ;; turns out to make the #'<= expression
+ ;; unreachable when END=NIL) could cause errors
+ ;; when the compiler tries to constant-fold (<=
+ ;; END SIZE).
+ ;;
+ ;; So, with or without bug 173, it'd be
+ ;; unnecessarily evil to do a full
+ ;; COMPILER-WARNING (and thus return FAILURE-P=T
+ ;; from COMPILE-FILE) for legal code, so we we
+ ;; use a wimpier COMPILE-STYLE-WARNING instead.
+ #'compiler-style-warn
+ "constant folding")
+ (cond ((not win)
+ (setf (combination-kind call) :error))
+ ((and (proper-list-of-length-p values 1)
+ (eq (continuation-kind (node-cont call)) :inside-block))
+ (with-ir1-environment-from-node call
+ (let* ((cont (node-cont call))
+ (next (continuation-next cont))
+ (prev (make-continuation)))
+ (delete-continuation-use call)
+ (add-continuation-use call prev)
+ (reference-constant prev cont (first values))
+ (setf (continuation-next cont) next)
+ ;; FIXME: type checking?
+ (reoptimize-continuation cont)
+ (reoptimize-continuation prev))))
+ (t (let ((dummies (make-gensym-list (length args))))
+ (transform-call
+ call
+ `(lambda ,dummies
+ (declare (ignore ,@dummies))
+ (values ,@(mapcar (lambda (x) `',x) values)))
+ fun-name))))))