(try-type-intersections (vars) (res) where))))
-;;; Check that Type doesn't specify any funny args, and do the
+;;; Check that TYPE doesn't specify any funny args, and do the
;;; intersection.
(defun find-lambda-types (lambda type where)
(declare (type clambda lambda) (type fun-type type) (string where))
((not really-assert) t)
(t
(when atype
- (assert-continuation-type (return-result return) atype))
+ (assert-continuation-type (return-result return) atype
+ (lexenv-policy (functional-lexenv functional))))
(loop for var in vars and type in types do
(cond ((basic-var-sets var)
(when (and unwinnage-fun
(dolist (ref (leaf-refs var))
(derive-node-type ref type)))))
t))))))
+
+(defun assert-global-function-definition-type (name fun)
+ (declare (type functional fun))
+ (let ((type (info :function :type name))
+ (where (info :function :where-from name)))
+ (when (eq where :declared)
+ (setf (leaf-type fun) type)
+ (assert-definition-type fun type
+ :unwinnage-fun #'compiler-note
+ :where "proclamation"))))
+\f
+;;;; FIXME: Move to some other file.
+(defun check-catch-tag-type (tag)
+ (declare (type continuation tag))
+ (let ((ctype (continuation-type tag)))
+ (when (csubtypep ctype (specifier-type '(or number character)))
+ (compiler-style-warn "~@<using ~S of type ~S as a catch tag (which ~
+ tends to be unportable because THROW and CATCH ~
+ use EQ comparison)~@:>"
+ (continuation-source tag)
+ (type-specifier (continuation-type tag))))))