(loop for (fun warns-p) in
'(((lambda (&optional *x*) *x*) t)
((lambda (&optional *x* &rest y) (values *x* y)) t)
- ((lambda (&optional *print-base*) (values *print-base*)) nil)
- ((lambda (&optional *print-base* &rest y) (values *print-base* y)) nil)
+ ((lambda (&optional *print-length*) (values *print-length*)) nil)
+ ((lambda (&optional *print-length* &rest y) (values *print-length* y)) nil)
((lambda (&optional *x*) (declare (special *x*)) (values *x*)) nil)
((lambda (&optional *x* &rest y) (declare (special *x*)) (values *x* y)) nil))
for real-warns-p = (nth-value 1 (compile nil fun))
(assert (typep (eval `(the arithmetic-error
',(make-condition 'arithmetic-error)))
'arithmetic-error))
+
+(assert (not (nth-value
+ 2 (compile nil '(lambda ()
+ (make-array nil :initial-element 11))))))
+
+(assert (raises-error? (funcall (eval #'open) "assertoid.lisp"
+ :external-format '#:nonsense)))
+(assert (raises-error? (funcall (eval #'load) "assertoid.lisp"
+ :external-format '#:nonsense)))
+
+(assert (= (the (values integer symbol) (values 1 'foo 13)) 1))
+
+(let ((f (compile nil
+ '(lambda (v)
+ (declare (optimize (safety 3)))
+ (list (the fixnum (the (real 0) (eval v))))))))
+ (assert (raises-error? (funcall f 0.1) type-error))
+ (assert (raises-error? (funcall f -1) type-error)))
+
+;;; the implicit block does not enclose lambda list
+(let ((forms '((defmacro #1=#:foo (&optional (x (return-from #1#))))
+ #+nil(macrolet ((#2=#:foo (&optional (x (return-from #2#))))))
+ (define-compiler-macro #3=#:foo (&optional (x (return-from #3#))))
+ (deftype #4=#:foo (&optional (x (return-from #4#))))
+ (define-setf-expander #5=#:foo (&optional (x (return-from #5#))))
+ (defsetf #6=#:foo (&optional (x (return-from #6#))) ()))))
+ (dolist (form forms)
+ (assert (nth-value 2 (compile nil `(lambda () ,form))))))
+
+(assert (nth-value 2 (compile nil
+ '(lambda ()
+ (svref (make-array '(8 9) :adjustable t) 1)))))