+;;;--------------------------------------------------------------------------
+;;; Describing class inheritance paths in diagnostics.
+
+(export 'inheritance-path-reporter-state)
+(defclass inheritance-path-reporter-state ()
+ ((%class :type sod-class :initarg :class)
+ (paths :type list :initarg :paths)
+ (seen :type hash-table :initform (make-hash-table))))
+
+(export 'make-inheritance-path-reporter-state)
+(defun make-inheritance-path-reporter-state (class)
+ (make-instance 'inheritance-path-reporter-state :class class))
+
+(export 'report-inheritance-path)
+(defun report-inheritance-path (state super)
+ "Issue informational messages showing how CLASS inherits from SUPER."
+ (with-slots (paths (class %class) include-boundary seen) state
+ (unless (slot-boundp state 'paths)
+ (setf paths (distinguished-point-shortest-paths
+ class
+ (lambda (c)
+ (mapcar (lambda (super) (cons super 1))
+ (sod-class-direct-superclasses c))))))
+ (dolist (hop (mapcon (lambda (subpath)
+ (let ((super (car subpath))
+ (sub (and (cdr subpath)
+ (cadr subpath))))
+ (if (or (not sub) (gethash super seen))
+ nil
+ (progn
+ (setf (gethash super seen) t)
+ (list (cons super sub))))))
+ (cdr (find super paths :key #'cadr))))
+ (let ((super (car hop))
+ (sub (cdr hop)))
+ (info-with-location sub
+ "Class `~A' is a direct superclass ~
+ of `~A', defined here"
+ super sub)))))
+
+;;;--------------------------------------------------------------------------
+;;; Metaclass inference.
+
+(export 'select-minimal-class-property)
+(defun select-minimal-class-property (supers key order default what
+ &key (present (lambda (x)
+ (format nil "`~A'" x)))
+ allow-empty)
+ "Return the minimal partially-ordered key from the SUPERS.
+
+ KEY is a function of one argument which returns some interesting property
+ of a class. The keys are assumed to be partially ordered by ORDER, a
+ function of two arguments which returns non-nil if its first argument
+ precedes its second. If there is a unique minimal key then return it;
+ otherwise report a useful error and pick some candidate in an arbitrary
+ way; the DEFAULT may be chosen if no better choices are available. If
+ ALLOW-EMPTY is non-nil, then no error is reported if there are no SUPERS,
+ and the DEFAULT choice is returned immediately.
+
+ In an error message, the keys are described as WHAT, which should be a
+ noun phrase; keys are filtered through PRESENT, a function of one
+ argument, before presentation.
+
+ The function returns two values: the chosen value, and a flag which is
+ non-nil if it was chosen without errors."
+
+ (let ((candidates (partial-order-minima (mapcar key supers) order)))
+ (cond ((and (null candidates) allow-empty)
+ (values default t))
+ ((and candidates (null (cdr candidates)))
+ (values (car candidates) t))
+ (t
+ (cerror* "No obvious choice for implicit ~A: ~
+ ~{~#[root classes must specify explicitly~:;~
+ candidates are ~
+ ~#[~;~A~;~A and ~A~:;~@{~A, ~#[~;and ~A~]~}~]~]~:}"
+ what (mapcar present candidates))
+ (dolist (candidate candidates)
+ (let ((super (find candidate supers :key key)))
+ (info-with-location super
+ "Direct superclass `~A' defined here ~
+ has ~A ~A"
+ super what (funcall present candidate))))
+ (values (if candidates (car candidates) default) nil)))))
+