(:export "ALLOCATION-INFORMATION"
"FUNCTION-ARGLIST"
"FUNCTION-LAMBDA-LIST"
+ "FUNCTION-TYPE"
"DEFTYPE-LAMBDA-LIST"
"VALID-FUNCTION-NAME-P"
"FIND-DEFINITION-SOURCE"
((or condition standard-object structure-object)
(find-definition-source (class-of object)))
(t
- (error "Don't know how to retrieve source location for a ~S~%"
+ (error "Don't know how to retrieve source location for a ~S"
(type-of object)))))
(defun find-function-definition-source (function)
"Returns the lambda list of TYPESPEC-OPERATOR as first return
value, and a flag whether the arglist could be found as second
value."
- (sb-int:info :type :lambda-list typespec-operator))
+ (check-type typespec-operator symbol)
+ (case (sb-int:info :type :kind typespec-operator)
+ (:defined
+ (sb-int:info :type :lambda-list typespec-operator))
+ (:primitive
+ (let ((translator-fun (sb-int:info :type :translator typespec-operator)))
+ (if translator-fun
+ (values (sb-kernel:%fun-lambda-list translator-fun) t)
+ ;; Some builtin types (e.g. STRING) do not have a
+ ;; translator, but they were actually defined via DEFTYPE
+ ;; in src/code/deftypes-for-target.lisp.
+ (sb-int:info :type :lambda-list typespec-operator))))
+ (t (values nil nil))))
+
+(defun function-type (function-designator)
+ "Returns the ftype of FUNCTION-DESIGNATOR, or NIL."
+ (flet ((ftype-of (function-designator)
+ (sb-kernel:type-specifier
+ (sb-int:info :function :type function-designator))))
+ (etypecase function-designator
+ (symbol
+ (when (and (fboundp function-designator)
+ (not (macro-function function-designator))
+ (not (special-operator-p function-designator)))
+ (ftype-of function-designator)))
+ (cons
+ (when (and (sb-int:legal-fun-name-p function-designator)
+ (fboundp function-designator))
+ (ftype-of function-designator)))
+ (generic-function
+ (function-type (sb-pcl:generic-function-name function-designator)))
+ (function
+ ;; Give declared type in globaldb priority over derived type
+ ;; because it contains more accurate information e.g. for
+ ;; struct-accessors.
+ (let ((type (function-type (sb-kernel:%fun-name
+ (sb-impl::%fun-fun function-designator)))))
+ (if type
+ type
+ (sb-impl::%fun-type function-designator)))))))
(defun struct-accessor-structure-class (function)
(let ((self (sb-vm::%simple-fun-self function)))
Experimental.
"
(let ((class (canonicalize-class-designator class-designator)))
+ (unless class
+ (return-from who-specializes-directly nil))
(let ((result (collect-specializing-methods
#'(lambda (specl)
;; Does SPECL specialize on CLASS directly?
Experimental.
"
(let ((class (canonicalize-class-designator class-designator)))
+ (unless class
+ (return-from who-specializes-generally nil))
(let ((result (collect-specializing-methods
#'(lambda (specl)
;; Does SPECL specialize on CLASS or a subclass
result))))
(defun canonicalize-class-designator (class-designator)
- (etypecase class-designator
- (symbol (find-class class-designator))
- (class class-designator)))
+ (typecase class-designator
+ (symbol (find-class class-designator nil))
+ (class class-designator)
+ (t nil)))
(defun method-generic-function-name (method)
(sb-mop:generic-function-name (sb-mop:method-generic-function method)))