X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=tests%2Fcompiler.impure.lisp;h=9a8458c203d1867f9fa25356b6312db331005300;hb=09d7974601df2aaaa820ca576026b9b4f03e6ab1;hp=af77b04c514753774878fc3fb5e679ee18a29082;hpb=1fd80272bd0a0510113978a33066622e4fd506a7;p=sbcl.git

diff --git a/tests/compiler.impure.lisp b/tests/compiler.impure.lisp
index af77b04..9a8458c 100644
--- a/tests/compiler.impure.lisp
+++ b/tests/compiler.impure.lisp
@@ -160,10 +160,11 @@
    ;; a call to prevent the other arguments from being optimized away
    (logand a1 a2 a3 a4 a5 a6 a7 a8 a9)))
 
-;;; bug 192, reported by Einar Floystad Dorum: Compiling this in 0.7.6
-;;; caused the compiler to try to constant-fold DATA-VECTOR-REF, which
-;;; is OK, except that there was no non-VOP definition of
-;;; DATA-VECTOR-REF, so it would fail.
+;;; bug 192, reported by Einar Floystad Dorum sbcl-devel 2002-08-14,
+;;; fixed in sbcl-0.7.6.26: Compiling this function in 0.7.6 caused
+;;; the compiler to try to constant-fold DATA-VECTOR-REF, which is OK,
+;;; except that there was no non-VOP definition of DATA-VECTOR-REF, so
+;;; it would fail.
 (defun bug192 ()
       (funcall 
        (LAMBDA (TEXT I L )
@@ -196,6 +197,108 @@
                                   (WHEN T I))))))
                       INDEX)))
            (G908 I))) "abcdefg" 0 (length "abcdefg")))
+
+;;; bugs #65, #70, and #109, closed by APD's patch sbcl-devel 2002-08-17
+;;;
+;;; This was "YA code deletion bug" whose symptom was the failure of
+;;; the assertion
+;;;   (EQ (C::LAMBDA-TAIL-SET C::CALLER)
+;;;       (C::LAMBDA-TAIL-SET (C::LAMBDA-HOME C::CALLEE)))
+;;; at compile time.
+(defun bug65-1 (termx termy) ; from Carl Witty on submit bugs list, debian.org
+  (labels
+    ((alpha-equal-bound-term-lists (listx listy)
+       (or (and (null listx) (null listy))
+	   (and listx listy
+		(let ((bindings-x (bindings-of-bound-term (car listx)))
+		      (bindings-y (bindings-of-bound-term (car listy))))
+		  (if (and (null bindings-x) (null bindings-y))
+		      (alpha-equal-terms (term-of-bound-term (car listx))
+					 (term-of-bound-term (car listy)))
+		      (and (= (length bindings-x) (length bindings-y))
+			   (prog2
+			       (enter-binding-pairs (bindings-of-bound-term (car listx))
+						    (bindings-of-bound-term (car listy)))
+			       (alpha-equal-terms (term-of-bound-term (car listx))
+						  (term-of-bound-term (car listy)))
+			     (exit-binding-pairs (bindings-of-bound-term (car listx))
+						 (bindings-of-bound-term (car listy)))))))
+		(alpha-equal-bound-term-lists (cdr listx) (cdr listy)))))
+
+     (alpha-equal-terms (termx termy)
+       (if (and (variable-p termx)
+		(variable-p termy))
+	   (equal-bindings (id-of-variable-term termx)
+			   (id-of-variable-term termy))
+	   (and (equal-operators-p (operator-of-term termx) (operator-of-term termy))
+		(alpha-equal-bound-term-lists (bound-terms-of-term termx)
+					      (bound-terms-of-term termy))))))
+
+    (or (eq termx termy)
+	(and termx termy
+	     (with-variable-invocation (alpha-equal-terms termx termy))))))
+(defun bug65-2 () ; from Bob Rogers cmucl-imp 1999-07-28
+  ;; Given an FSSP alignment file named by the argument . . .
+  (labels ((get-fssp-char ()
+	     (get-fssp-char))
+	   (read-fssp-char ()
+	     (get-fssp-char)))
+    ;; Stub body, enough to tickle the bug.
+    (list (read-fssp-char)
+	  (read-fssp-char))))
+(defun bug70 ; from David Young cmucl-help 30 Nov 2000
+    (item sequence &key (test #'eql))
+  (labels ((find-item (obj seq test &optional (val nil))
+		      (let ((item (first seq)))
+			(cond ((null seq)
+			       (values nil nil))
+			      ((funcall test obj item)
+			       (values val seq))
+			      (t	
+			       (find-item obj
+					  (rest seq)
+					  test
+					  (nconc val `(,item))))))))
+    (find-item item sequence test)))
+(defun bug109 () ; originally from CMU CL bugs collection, reported as
+                 ; SBCL bug by MNA 2001-06-25
+  (labels 
+      ((eff (&key trouble)
+	    (eff)
+	    ;; nil
+	    ;; Uncomment and it works
+	    ))
+    (eff)))
+
+;;; bug 192a, fixed by APD "more strict type checking" patch
+;;; (sbcl-devel 2002-08-07)
+(defun bug192a (x)
+  (declare (optimize (speed 0) (safety 3)))
+  ;; Even with bug 192a, this declaration was checked as an assertion.
+  (declare (real x))
+  (+ x
+     (locally
+       ;; Because of bug 192a, this declaration was trusted without checking.
+       (declare (single-float x))
+       (sin x))))
+(assert (null (ignore-errors (bug192a nil))))
+(multiple-value-bind (result error) (ignore-errors (bug192a 100))
+  (assert (null result))
+  (assert (equal (type-error-expected-type error) 'single-float)))
+
+;;; bug 194, fixed in part by APD "more strict type checking" patch
+;;; (sbcl-devel 2002-08-07)
+(progn
+  #+nil ; FIXME: still broken in 0.7.7.19 (after patch)
+  (multiple-value-bind (result error)
+      (ignore-errors (multiple-value-prog1 (progn (the real '(1 2 3)))))
+    (assert (null result))
+    (assert (typep error 'type-error)))
+  #+nil ; FIXME: still broken in 0.7.7.19 (after patch)
+  (multiple-value-bind (result error)
+      (ignore-errors (the real '(1 2 3)))
+    (assert (null result))
+    (assert (typep error 'type-error))))
 
 ;;; BUG 48a. and b. (symbol-macrolet handling), fixed by Eric Marsden
 ;;; and Raymond Toy for CMUCL, fix ported for sbcl-0.7.6.18.
@@ -203,18 +306,335 @@
     (compile nil '(lambda () (symbol-macrolet ((t nil)) t)))
   (assert failure-p)
   (assert (raises-error? (funcall function) program-error)))
-
 (multiple-value-bind (function warnings-p failure-p)
-    (compile nil '(lambda () (symbol-macrolet ((*standard-input* nil)) *standard-input*)))
+    (compile nil
+	     '(lambda ()
+		(symbol-macrolet ((*standard-input* nil))
+		  *standard-input*)))
   (assert failure-p)
   (assert (raises-error? (funcall function) program-error)))
-#|
+#||
 BUG 48c, not yet fixed:
 (multiple-value-bind (function warnings-p failure-p)
     (compile nil '(lambda () (symbol-macrolet ((s nil)) (declare (special s)) s)))
   (assert failure-p)
   (assert (raises-error? (funcall function) program-error)))
-|#
+||#
+
+;;; bug 120a: Turned out to be constraining code looking like (if foo
+;;; <X> <X>) where <X> was optimized by the compiler to be the exact
+;;; same block in both cases, but not turned into (PROGN FOO <X>).
+;;; Fixed by APD in sbcl-0.7.7.2, who provided this test:
+(declaim (inline dont-constrain-if-too-much))
+(defun dont-constrain-if-too-much (frame up-frame)
+  (declare (optimize (speed 3) (safety 1) (debug 1)))
+  (if (or (not frame) t)
+      frame
+      "bar"))
+(defun dont-constrain-if-too-much-aux (x y)
+  (declare (optimize (speed 3) (safety 1) (debug 1)))
+  (if x t (if y t (dont-constrain-if-too-much x y))))
+
+(assert (null (dont-constrain-if-too-much-aux nil nil)))  
+
+;;; TYPE-ERROR confusion ca. sbcl-0.7.7.24, reported and fixed by
+;;; APD sbcl-devel 2002-09-14
+(defun exercise-0-7-7-24-bug (x)
+  (declare (integer x))
+  (let (y)
+    (setf y (the single-float (if (> x 0) x 3f0)))
+    (list y y)))
+(multiple-value-bind (v e) (ignore-errors (exercise-0-7-7-24-bug 4))
+  (assert (null v))
+  (assert (typep e 'type-error)))
+(assert (equal (exercise-0-7-7-24-bug -4) '(3f0 3f0)))
+
+;;; non-intersecting type declarations were DWIMing in a confusing
+;;; fashion until sbcl-0.7.7.28, when APD reported and fixed the
+;;; problem.
+(defun non-intersecting-the (x)
+  (let (y)
+    (setf y (the single-float (the integer x)))
+    (list y y)))
+
+(raises-error? (foo 3) type-error)
+(raises-error? (foo 3f0) type-error)
+
+;;; until 0.8.2 SBCL did not check THEs in arguments
+(defun the-in-arguments-aux (x)
+  x)
+(defun the-in-arguments-1 (x)
+  (list x (the-in-arguments-aux (the (single-float 0s0) x))))
+(defun the-in-arguments-2 (x)
+  (list x (the-in-arguments-aux (the single-float x))))
+
+(multiple-value-bind (result condition)
+    (ignore-errors (the-in-arguments-1 1))
+  (assert (null result))
+  (assert (typep condition 'type-error)))
+(multiple-value-bind (result condition)
+    (ignore-errors (the-in-arguments-2 1))
+  (assert (null result))
+  (assert (typep condition 'type-error)))
+
+;;; bug 153: a hole in a structure slot type checking
+(declaim (optimize safety))
+(defstruct foo153
+  (bla 0 :type fixnum))
+(defun bug153-1 ()
+  (let ((foo (make-foo153)))
+    (setf (foo153-bla foo) '(1 . 1))
+    (format t "Is ~a of type ~a a cons? => ~a~%"
+            (foo153-bla foo)
+            (type-of (foo153-bla foo))
+            (consp (foo153-bla foo)))))
+(defun bug153-2 (x)
+  (let ((foo (make-foo153)))
+    (setf (foo153-bla foo) x)
+    (format t "Is ~a of type ~a a cons? => ~a~%"
+            (foo153-bla foo)
+            (type-of (foo153-bla foo))
+            (consp (foo153-bla foo)))))
+
+(multiple-value-bind (result condition)
+    (ignore-errors (bug153-1))
+  (declare (ignore result))
+  (assert (typep condition 'type-error)))
+(multiple-value-bind (result condition)
+    (ignore-errors (bug153-2 '(1 . 1)))
+  (declare (ignore result))
+  (assert (typep condition 'type-error)))
+
+;;; bug 110: the compiler flushed the argument type test and the default
+;;; case in the cond.
+
+(defun bug110 (x)
+  (declare (optimize (safety 2) (speed 3)))
+  (declare (type (or string stream) x))
+  (cond ((typep x 'string) 'string)
+        ((typep x 'stream) 'stream)
+        (t
+         'none)))
+
+(multiple-value-bind (result condition)
+    (ignore-errors (bug110 0))
+  (declare (ignore result))
+  (assert (typep condition 'type-error)))
+
+;;; bug 202: the compiler failed to compile a function, which derived
+;;; type contradicted declared.
+(declaim (ftype (function () null) bug202))
+(defun bug202 ()
+  t)
+
+;;; bugs 178, 199: compiler failed to compile a call of a function
+;;; with a hairy type
+(defun bug178 (x)
+      (funcall (the function (the standard-object x))))
+
+(defun bug199-aux (f)
+  (eq nil (funcall f)))
+
+(defun bug199 (f x)
+  (declare (type (and function (satisfies bug199-aux)) f))
+  (funcall f x))
+
+;;; check non-toplevel DEFMACRO
+(defvar *defmacro-test-status* nil)
+
+(defun defmacro-test ()
+  (fmakunbound 'defmacro-test-aux)
+  (let* ((src "defmacro-test.lisp")
+         (obj (compile-file-pathname src)))
+    (unwind-protect
+         (progn
+           (compile-file src)
+           (assert (equal *defmacro-test-status* '(function a)))
+           (setq *defmacro-test-status* nil)
+           (load obj)
+           (assert (equal *defmacro-test-status* nil))
+           (macroexpand '(defmacro-test-aux 'a))
+           (assert (equal *defmacro-test-status* '(macro 'a z-value)))
+           (eval '(defmacro-test-aux 'a))
+           (assert (equal *defmacro-test-status* '(expanded 'a z-value))))
+      (ignore-errors (delete-file obj)))))
+
+(defmacro-test)
+
+;;; bug 204: EVAL-WHEN inside a local environment
+(defvar *bug204-test-status*)
+
+(defun bug204-test ()
+  (let* ((src "bug204-test.lisp")
+         (obj (compile-file-pathname src)))
+    (unwind-protect
+         (progn
+           (setq *bug204-test-status* nil)
+           (compile-file src)
+           (assert (equal *bug204-test-status* '((:expanded :load-toplevel)
+                                                 (:called :compile-toplevel)
+                                                 (:expanded :compile-toplevel))))
+           (setq *bug204-test-status* nil)
+           (load obj)
+           (assert (equal *bug204-test-status* '((:called :load-toplevel)))))
+      (ignore-errors (delete-file obj)))))
+
+(bug204-test)
+
+;;; toplevel SYMBOL-MACROLET
+(defvar *symbol-macrolet-test-status*)
+
+(defun symbol-macrolet-test ()
+  (let* ((src "symbol-macrolet-test.lisp")
+         (obj (compile-file-pathname src)))
+    (unwind-protect
+         (progn
+           (setq *symbol-macrolet-test-status* nil)
+           (compile-file src)
+           (assert (equal *symbol-macrolet-test-status*
+                          '(2 1)))
+           (setq *symbol-macrolet-test-status* nil)
+           (load obj)
+           (assert (equal *symbol-macrolet-test-status* '(2))))
+      (ignore-errors (delete-file obj)))))
+
+(symbol-macrolet-test)
+
+;;; On the x86, this code failed to compile until sbcl-0.7.8.37:
+(defun x86-assembler-failure (x)
+  (declare (optimize (speed 3) (safety 0)))
+  (eq (setf (car x) 'a) nil))
+
+;;; bug 211: :ALLOW-OTHER-KEYS
+(defun bug211d (&key (x :x x-p) ((:allow-other-keys y) :y y-p))
+  (list x x-p y y-p))
+
+(assert (equal (bug211d) '(:x nil :y nil)))
+(assert (equal (bug211d :x 1) '(1 t :y nil)))
+(assert (raises-error? (bug211d :y 2) program-error))
+(assert (equal (bug211d :y 2 :allow-other-keys t :allow-other-keys nil)
+               '(:x nil t t)))
+(assert (raises-error? (bug211d :y 2 :allow-other-keys nil) program-error))
+
+(let ((failure-p
+       (nth-value
+        3
+        (compile 'bug211b
+                 '(lambda ()
+                   (flet ((test (&key (x :x x-p) ((:allow-other-keys y) :y y-p))
+                            (list x x-p y y-p)))
+                     (assert (equal (test) '(:x nil :y nil)))
+                     (assert (equal (test :x 1) '(1 t :y nil)))
+                     (assert (equal (test :y 2 :allow-other-keys 11 :allow-other-keys nil)
+                                    '(:x nil 11 t)))))))))
+  (assert (not failure-p))
+  (bug211b))
+
+(let ((failure-p
+       (nth-value
+        3
+        (compile 'bug211c
+                 '(lambda ()
+                   (flet ((test (&key (x :x x-p))
+                            (list x x-p)))
+                     (assert (equal (test) '(:x nil)))
+                     (assert (equal (test :x 1) '(1 t)))
+                     (assert (equal (test :y 2 :allow-other-keys 11 :allow-other-keys nil)
+                                    '(:x nil)))))))))
+  (assert (not failure-p))
+  (bug211c))
+
+(dolist (form '((test :y 2)
+                (test :y 2 :allow-other-keys nil)
+                (test :y 2 :allow-other-keys nil :allow-other-keys t)))
+  (multiple-value-bind (result warnings-p failure-p)
+      (compile nil `(lambda ()
+                     (flet ((test (&key (x :x x-p) ((:allow-other-keys y) :y y-p))
+                              (list x x-p y y-p)))
+                       ,form)))
+    (assert failure-p)
+    (assert (raises-error? (funcall result) program-error))))
+
+;;; bug 217: wrong type inference
+(defun bug217-1 (x s)
+  (let ((f (etypecase x
+             (character #'write-char)
+             (integer #'write-byte))))
+    (funcall f x s)
+    (etypecase x
+      (character (write-char x s))
+      (integer (write-byte x s)))))
+(bug217-1 #\1 *standard-output*)
+
+
+;;; bug 221: tried and died on CSUBTYPEP (not VALUES-SUBTYPEP) of the
+;;; function return types when inferring the type of the IF expression
+(declaim (ftype (function (fixnum) (values package boolean)) bug221f1))
+(declaim (ftype (function (t) (values package boolean)) bug221f2))
+(defun bug221 (b x)
+  (funcall (if b #'bug221f1 #'bug221f2) x))
+
+;;; bug 172: macro lambda lists were too permissive until 0.7.9.28
+;;; (fix provided by Matthew Danish) on sbcl-devel
+(assert (null (ignore-errors
+		(defmacro bug172 (&rest rest foo) `(list ,rest ,foo)))))
+
+;;; embedded THEs
+(defun check-embedded-thes (policy1 policy2 x y)
+  (handler-case
+      (funcall (compile nil
+                        `(lambda (f)
+                           (declare (optimize (speed 2) (safety ,policy1)))
+                           (multiple-value-list
+                            (the (values (integer 2 3) t)
+                              (locally (declare (optimize (safety ,policy2)))
+                                (the (values t (single-float 2f0 3f0))
+                                  (funcall f)))))))
+               (lambda () (values x y)))
+    (type-error (error)
+      error)))
+
+(assert (equal (check-embedded-thes 0 0  :a :b) '(:a :b)))
+
+(assert (equal (check-embedded-thes 0 3  :a 2.5f0) '(:a 2.5f0)))
+(assert (typep (check-embedded-thes 0 3  2 3.5f0) 'type-error))
+
+(assert (equal (check-embedded-thes 0 1  :a 3.5f0) '(:a 3.5f0)))
+(assert (typep (check-embedded-thes 0 1  2 2.5d0) 'type-error))
+
+#+nil
+(assert (equal (check-embedded-thes 3 0  2 :a) '(2 :a)))
+(assert (typep (check-embedded-thes 3 0  4 2.5f0) 'type-error))
+
+(assert (equal (check-embedded-thes 1 0  4 :b) '(4 :b)))
+(assert (typep (check-embedded-thes 1 0  1.0 2.5f0) 'type-error))
+
+
+(assert (equal (check-embedded-thes 3 3  2 2.5f0) '(2 2.5f0)))
+(assert (typep (check-embedded-thes 3 3  0 2.5f0) 'type-error))
+(assert (typep (check-embedded-thes 3 3  2 3.5f0) 'type-error))
+
+
+;;; INLINE inside MACROLET
+(declaim (inline to-be-inlined))
+(macrolet ((def (x) `(defun ,x (y) (+ y 1))))
+  (def to-be-inlined))
+(defun call-inlined (z)
+  (to-be-inlined z))
+(assert (= (call-inlined 3) 4))
+(macrolet ((frob (x) `(+ ,x 3)))
+  (defun to-be-inlined (y)
+    (frob y)))
+(assert (= (call-inlined 3)
+	   ;; we should have inlined the previous definition, so the
+	   ;; new one won't show up yet.
+	   4))
+(defun call-inlined (z)
+  (to-be-inlined z))
+(assert (= (call-inlined 3) 6))
+(defun to-be-inlined (y)
+  (+ y 5))
+(assert (= (call-inlined 3) 6))
 
 ;;;; tests not in the problem domain, but of the consistency of the
 ;;;; compiler machinery itself