;;;; miscellaneous compiler tests with side effects (e.g. DEFUN
;;;; changing FDEFINITIONs and globaldb stuff)

;;;; This software is part of the SBCL system. See the README file for
;;;; more information.
;;;;
;;;; While most of SBCL is derived from the CMU CL system, the test
;;;; files (like this one) were written from scratch after the fork
;;;; from CMU CL.
;;;; 
;;;; This software is in the public domain and is provided with
;;;; absolutely no warranty. See the COPYING and CREDITS files for
;;;; more information.

(cl:in-package :cl-user)

(eval-when (:compile-toplevel :load-toplevel :execute)
  (load "assertoid")
  (use-package "ASSERTOID"))

(declaim (optimize (debug 3) (speed 2) (space 1)))

;;; Until version 0.6.9 or so, SBCL's version of Python couldn't do
;;; this correctly, due to the bug patched by Rob MacLachlan on the
;;; cmucl-imp list 2000-06-21, and applied to SBCL by Martin Atzmueller.
;;; (The effectiveness of the test also depends on the implicit
;;; function typing of Python (where DEFUN is like DECLAIM FTYPE),
;;; which violates the ANSI spec, and should be fixed. Once that
;;; unrelated bug is fixed, this code will no longer test the type
;;; inference behavior it's intended to test.)
(defun emptyvalues (&rest rest) (declare (ignore rest)) (values))
(defstruct foo x y)
(defun bar ()
  (let ((res (emptyvalues)))
    (unless (typep res 'foo)
      'expected-value)))
(assert (eq (bar) 'expected-value))

(declaim (ftype (function (real) (values integer single-float)) valuesify))
(defun valuesify (x)
  (values (round x)
	  (coerce x 'single-float)))
(defun exercise-valuesify (x)
  (multiple-value-bind (i f) (valuesify x)
    (declare (type integer i))
    (declare (type single-float f))
    (+ i f)))
(assert (= (exercise-valuesify 1.25) 2.25))

;;; An early version (sbcl-0.6.11.33) of code to check FTYPEs from DEFUN
;;; against DECLAIMed FTYPEs blew up when an FTYPE was DECLAIMed
;;; to be pure FUNCTION, because the internal representation of
;;; FUNCTION itself (as opposed to subtypes of FUNCTION, such as
;;; (FUNCTION () T)) is a BUILT-IN-CLASS object, not a FUN-TYPE
;;; object.
(declaim (ftype function i-am-just-a-function))
(defun i-am-just-a-function (x y) (+ x y 1))

;;; Stig E Sandoe reported in cclan-Bugs-431263 that SBCL couldn't
;;; compile this. sbcl-0.6.12.26 died in CIRCULAR-LIST-P with "The
;;; value \"EST\" is not of type LIST." Dan Barlow fixed it.
(defvar +time-zones+
  '((5 "EDT" . "EST") (6 "CDT" . "CST") (7 "MDT" .
"MST") (8 "PDT" . "PST")
    (0 "GMT" . "GDT") (-2 "MET" . "MET DST"))
  "*The string representations of the time zones.")

(declaim (optimize (debug 1) (speed 1) (space 1)))

;;; The old CMU CL Python compiler assumed that it was safe to infer
;;; function types (including return types) from function definitions
;;; and then use them to optimize code later [and it was almost
;;; right!]. This is of course bad when functions are redefined. The
;;; problem was fixed in sbcl-0.6.12.57.
(defun foo (x)
          (if (plusp x)
              1.0
              0))
(eval '(locally
        (defun bar (x)
          (typecase (foo x)
            (fixnum :fixnum)
            (real :real)
            (string :string)
            (t :t)))
        (compile 'bar)))
(assert (eql (bar 11) :real))
(assert (eql (bar -11) :fixnum))
(setf (symbol-function 'foo) #'identity)
(assert (eql (bar 11) :fixnum))
(assert (eql (bar -11.0) :real))
(assert (eql (bar "this is a test") :string))
(assert (eql (bar (make-hash-table)) :t))

;;; bug reported by Brian Spilsbury sbcl-devel 2001-09-30, fixed by
;;; Alexey Dejneka patch sbcl-devel 2001-10-02
(defun pixarray-element-size (pixarray)
  (let ((eltype (array-element-type pixarray)))
    (cond ((eq eltype 'bit) 1)
          ((and (listp eltype)
                (eq (first eltype) 'unsigned-byte))
           (second eltype))
          (t
           (error "Invalid pixarray: ~S." pixarray)))))
(assert (eql 1 (pixarray-element-size #*110)))

;;; bug 31 turned out to be a manifestation of non-ANSI array type
;;; handling, fixed by CSR in sbcl-0.7.3.8.
(defun array-element-type-handling (x)
  (declare (optimize safety))
  (declare (type (vector cons) x))
  (when (consp (aref x 0))
    (aref x 0)))
(assert (raises-error?
	 (array-element-type-handling
	  (make-array 3 :element-type t :initial-element 0))
	 type-error))

;;; bug 220: type check inserted after all arguments in MV-CALL caused
;;; failure of stack analysis
(defun bug220-helper ()
  13)
(assert (equal (multiple-value-call #'list
                 (the integer (bug220-helper))
                 nil)
               '(13 nil)))

;;; bug 221: sbcl 0.7.9.13 failed to compile the following function
(declaim (ftype (function (fixnum) (values package boolean)) bug221-f1))
(declaim (ftype (function (t) (values package boolean)) bug221-f2))
(defun bug221 (b x)
  (funcall (if b #'bug221-f1 #'bug221-f2) x))

;;; bug 166: compiler failure
(defstruct bug166s)
(defmethod permanentize ((uustk bug166s))
  (flet ((frob (hash-table test-for-deletion)
           )
         (obj-entry.stale? (oe)
           (destructuring-bind (key . datum) oe
             (declare (type simple-vector key))
             (deny0 (void? datum))
             (some #'stale? key))))
    (declare (inline frob obj-entry.stale?))
    (frob (uustk.args-hash->obj-alist uustk)
          #'obj-entry.stale?)
    (frob (uustk.hash->memoized-objs-list uustk)
          #'objs.stale?))
  (call-next-method))

;;; bugs 115, 226: compiler failure in lifetime analysis
(defun bug115-1 ()
  (declare (optimize (speed 2) (debug 3)))
  (flet ((m1 ()
           (unwind-protect nil)))
    (if (catch nil)
        (m1)
        (m1))))

(defun bug115-2 ()
  (declare (optimize (speed 2) (debug 3)))
  (flet ((m1 ()
           (bar (if (foo) 1 2))
           (let ((x (foo)))
             (bar x (list x)))))
    (if (catch nil)
        (m1)
        (m1))))

(defun bug226 ()
  (declare (optimize (speed 0) (safety 3) (debug 3)))
  (flet ((safe-format (stream string &rest r)
           (unless (ignore-errors (progn
                                    (apply #'format stream string r)
                                    t))
             (format stream "~&foo ~S" string))))
    (cond
      ((eq my-result :ERROR)
       (cond
         ((ignore-errors (typep condition result))
          (safe-format t "~&bar ~S" result))
         (t
          (safe-format t "~&baz ~S (~A) ~S" condition condition result)))))))

;;; bug 231: SETQ did not check the type of the variable being set
(defun bug231a-1 (x)
  (declare (optimize safety) (type (integer 0 8) x))
  (incf x))
(assert (raises-error? (bug231a-1 8) type-error))

(defun bug231a-2 (x)
  (declare (optimize safety) (type (integer 0 8) x))
  (list (lambda (y) (setq x y))
        (lambda () x)))
(destructuring-bind (set get) (bug231a-2 0)
  (funcall set 8)
  (assert (eql (funcall get) 8))
  (assert (raises-error? (funcall set 9) type-error))
  (assert (eql (funcall get) 8)))

(defun bug231b (x z)
  (declare (optimize safety) (type integer x))
  (locally
      (declare (type (real 1) x))
    (setq x z))
  (list x z))
(assert (raises-error? (bug231b nil 1) type-error))
(assert (raises-error? (bug231b 0 1.5) type-error))
(assert (raises-error? (bug231b 0 0) type-error))

;;; A bug appeared in flaky7_branch. Python got lost in unconverting
;;; embedded tail calls during let-convertion.
(defun bug239 (bit-array-2 &optional result-bit-array)
  (declare (type (array bit) bit-array-2)
           (type (or (array bit) (member t nil)) result-bit-array))
  (unless (simple-bit-vector-p bit-array-2)
    (multiple-value-call
        (lambda (data1 start1)
          (multiple-value-call
              (lambda (data2 start2)
                (multiple-value-call
                    (lambda (data3 start3)
                      (declare (ignore start3))
                      (print (list data1 data2)))
                  (values 0 0)))
            (values bit-array-2 0)))
      (values 444 0))))
(assert (equal (bug239 (make-array 4 :element-type 'bit
                                   :adjustable t
                                   :initial-element 0)
                       nil)
               '(444 #*0000)))

(defstruct some-structure a)
(eval-when (:compile-toplevel)
  ;; in the big CLASS reorganization in pre8, this would fail with
  ;; SOME-STRUCTURE-A is not FBOUNDP.  Fixed in 0.pre8.64
  (find-class 'some-structure nil))
(eval-when (:load-toplevel)
  (assert (typep (find-class 'some-structure) 'class)))

(sb-ext:quit :unix-status 104) ; success