Use `derived-mode-add-parents` in remaining uses of `derived-mode-parent`

Until now multiple inheritance wasn't really used, but some ad-hoc
code went a bit beyond the normal uses of the mode hierarchy.
Use the new multiple inheritance code to replace that ad-hoc code,
thereby eliminating basically all remaining direct uses of the
`derived-mode-parent` property.

CEDET had its own notion of mode hierrchy using `derived-mode-parent`
as well as its own `mode-local-parent` property set via
`define-child-mode`.
`derived-mode-add-parents` lets us reimplement `define-child-mode`
such that CEDET can now use the normal API functions.

* lisp/locate.el (locate-mode): Use `derived-mode-add-parents`.

* lisp/cedet/mode-local.el (get-mode-local-parent): Declare obsolete.
(mode-local-equivalent-mode-p, mode-local-use-bindings-p): Make them
obsolete aliases.
(mode-local--set-parent): Rewrite to use `derived-mode-add-parents`.
Declare as obsolete.
(mode-local-map-mode-buffers): Use `derived-mode-p`.
(mode-local-symbol, mode-local--activate-bindings)
(mode-local--deactivate-bindings, mode-local-describe-bindings-2):
Use `derived-mode-all-parents`.

* lisp/cedet/srecode/table.el (srecode-get-mode-table):
* lisp/cedet/srecode/find.el (srecode-table, srecode-load-tables-for-mode)
(srecode-all-template-hash): Use `derived-mode-all-parents`.

* lisp/cedet/srecode/map.el (srecode-map-entries-for-mode):
* lisp/cedet/semantic/db.el (semanticdb-equivalent-mode):
Use `provided-mode-derived-p` now that it obeys `define-child-mode`.

3 files changed, 50 insertions, 67 deletions

diff --git a/lisp/cedet/srecode/find.el b/lisp/cedet/srecode/find.el
index cfd64edfc98..6d64a26e46c 100644
--- a/lisp/cedet/srecode/find.el
+++ b/lisp/cedet/srecode/find.el
@@ -34,12 +34,12 @@
 (defun srecode-table (&optional mode)
   "Return the currently active Semantic Recoder table for this buffer.
 Optional argument MODE specifies the mode table to use."
-  (let* ((modeq (or mode major-mode))
-         (table (srecode-get-mode-table modeq)))
+  (let ((modes (derived-mode-all-parents (or mode major-mode)))
+        (table nil))
 
     ;; If there isn't one, keep searching backwards for a table.
-    (while (and (not table) (setq modeq (get-mode-local-parent modeq)))
-      (setq table (srecode-get-mode-table modeq)))
+    (while (and modes (not (setq table (srecode-get-mode-table (car modes)))))
+      (setq modes (cdr modes)))
 
     ;; Last ditch effort.
     (when (not table)
@@ -57,35 +57,23 @@ Templates are found in the SRecode Template Map.
 See `srecode-get-maps' for more.
 APPNAME is the name of an application.  In this case,
 all template files for that application will be loaded."
-  (let ((files
-         (apply #'append
-                (mapcar
-                 (if appname
+  (dolist (mmode (cons 'default (reverse (derived-mode-all-parents mmode))))
+    (let ((files
+           (apply #'append
+                  (mapcar
+                   (if appname
+                       (lambda (map)
+                         (srecode-map-entries-for-app-and-mode map appname mmode))
                      (lambda (map)
-                       (srecode-map-entries-for-app-and-mode map appname mmode))
-                   (lambda (map)
-                     (srecode-map-entries-for-mode map mmode)))
-                 (srecode-get-maps))))
-        )
-    ;; Don't recurse if we are already the 'default state.
-    (when (not (eq mmode 'default))
-      ;; Are we a derived mode?  If so, get the parent mode's
-      ;; templates loaded too.
-      (if (get-mode-local-parent mmode)
-          (srecode-load-tables-for-mode (get-mode-local-parent mmode)
-                                        appname)
-        ;; No parent mode, all templates depend on the defaults being
-        ;; loaded in, so get that in instead.
-        (srecode-load-tables-for-mode 'default appname)))
+                       (srecode-map-entries-for-mode map mmode)))
+                   (srecode-get-maps)))))
 
-    ;; Load in templates for our major mode.
-    (dolist (f files)
-      (let ((mt (srecode-get-mode-table mmode))
-            )
-          (when (or (not mt) (not (srecode-mode-table-find mt (car f))))
-            (srecode-compile-file (car f)))
-        ))
-    ))
+      ;; Load in templates for our major mode.
+      (when files
+        (let ((mt (srecode-get-mode-table mmode)))
+          (dolist (f files)
+            (when (not (and mt (srecode-mode-table-find mt (car f))))
+              (srecode-compile-file (car f)))))))))
 
 ;;; PROJECT
 ;;
@@ -227,12 +215,12 @@ Optional argument MODE is the major mode to look for.
 Optional argument HASH is the hash table to fill in.
 Optional argument PREDICATE can be used to filter the returned
 templates."
-  (let* ((mhash       (or hash (make-hash-table :test 'equal)))
-         (mmode       (or mode major-mode))
-         (parent-mode (get-mode-local-parent mmode)))
-    ;; Get the parent hash table filled into our current hash.
-    (unless (eq mode 'default)
-      (srecode-all-template-hash (or parent-mode 'default) mhash))
+  (let* ((mhash       (or hash (make-hash-table :test 'equal))))
+    (dolist (mmode (cons 'default
+                         ;; Get the parent hash table filled into our
+                         ;; current hash.
+                         (reverse (derived-mode-all-parents
+                                   (or mode major-mode)))))
 
     ;; Load up the hash table for our current mode.
     (let* ((mt   (srecode-get-mode-table mmode))
@@ -246,7 +234,7 @@ templates."
                                (funcall predicate temp))
                        (puthash key temp mhash)))
                    (oref tab namehash))))
-      mhash)))
+      mhash))))
 
 (defun srecode-calculate-default-template-string (hash)
   "Calculate the name of the template to use as a DEFAULT.
diff --git a/lisp/cedet/srecode/map.el b/lisp/cedet/srecode/map.el
index 004bb7adddb..44e465c69b1 100644
--- a/lisp/cedet/srecode/map.el
+++ b/lisp/cedet/srecode/map.el
@@ -76,7 +76,7 @@ Each app keys to an alist of files and modes (as above.)")
   "Return the entries in MAP for major MODE."
   (let ((ans nil))
     (dolist (f (oref map files))
-      (when (mode-local-use-bindings-p mode (cdr f))
+      (when (provided-mode-derived-p mode (cdr f))
         (setq ans (cons f ans))))
     ans))
 
diff --git a/lisp/cedet/srecode/table.el b/lisp/cedet/srecode/table.el
index de151049f7f..e5ab53dd253 100644
--- a/lisp/cedet/srecode/table.el
+++ b/lisp/cedet/srecode/table.el
@@ -137,41 +137,36 @@ Tracks all the template-tables for a specific major mode.")
   "Get the SRecoder mode table for the major mode MODE.
 This will find the mode table specific to MODE, and then
 calculate all inherited templates from parent modes."
-  (let ((table nil)
-        (tmptable nil))
-    (while mode
-      (setq tmptable (eieio-instance-tracker-find
-                      mode 'major-mode 'srecode-mode-table-list)
-            mode (get-mode-local-parent mode))
-      (when tmptable
-        (if (not table)
-            (progn
-              ;; If this is the first, update tables to have
-              ;; all the mode specific tables in it.
-              (setq table tmptable)
-              (oset table tables (oref table modetables)))
-          ;; If there already is a table, then reset the tables
-          ;; slot to include all the tables belonging to this new child node.
-          (oset table tables (append (oref table modetables)
-                                     (oref tmptable modetables)))))
-      )
+  (let ((table nil))
+    (dolist (mode (derived-mode-all-parents mode))
+      (let ((tmptable (eieio-instance-tracker-find
+                       mode 'major-mode 'srecode-mode-table-list)))
+        (when tmptable
+          (if (not table)
+              (progn
+                ;; If this is the first, update tables to have
+                ;; all the mode specific tables in it.
+                (setq table tmptable)
+                (oset table tables (oref table modetables)))
+            ;; If there already is a table, then reset the tables
+            ;; slot to include all the tables belonging to this new child node.
+            (oset table tables (append (oref table modetables)
+                                       (oref tmptable modetables)))))
+        ))
     table))
 
 (defun srecode-make-mode-table (mode)
   "Get the SRecoder mode table for the major mode MODE."
   (let ((old (eieio-instance-tracker-find
               mode 'major-mode 'srecode-mode-table-list)))
-    (if old
-        old
-      (let* ((ms (if (stringp mode) mode (symbol-name mode)))
-             (new (srecode-mode-table ms
-                                      :major-mode mode
-                                      :modetables nil
-                                      :tables nil)))
-        ;; Save this new mode table in that mode's variable.
-        (eval `(setq-mode-local ,mode srecode-table ,new) t)
+    (or old
+        (let* ((new (srecode-mode-table :major-mode mode
+                                        :modetables nil
+                                        :tables nil)))
+          ;; Save this new mode table in that mode's variable.
+          (eval `(setq-mode-local ,mode srecode-table ,new) t)
 
-        new))))
+          new))))
 
 (cl-defmethod srecode-mode-table-find ((mt srecode-mode-table) file)
   "Look in the mode table MT for a template table from FILE.