Lookup the last inclusive descendant

Author: Joris-van-der-Wel

lib/SymbolTree.js

@@ -111,6 +111,23 @@ module.exports = class SymbolTree {
         }
 
         /**
+         * Find the inclusive descendant that is last in tree order of the given object.
+         *
+         * `O(n)` (worst case)
+         *
+         * @method lastInclusiveDescendant
+         * @param {Object} object
+         * @return {Object}
+         */
+        lastInclusiveDescendant(object) {
+                let last;
+
+                while ( (last = this._node(object).last) ) {
+                        object = last;
+                }
+
+                return object;
+        }
          * Find the preceding object (A) of the given object (B).
          * An object A is preceding an object B if A and B are in the same tree
          * and A comes before B in tree order.
@@ -126,15 +143,10 @@ module.exports = class SymbolTree {
                         return null;
                 }
 
-                // if we have a previous sibling, return the last child of the last child of the ...
-                if (this._node(object).prev) {
-                        object = this._node(object).prev;
+                const prev = this._node(object).prev;
 
-                        while (this._node(object).last) {
-                                object = this._node(object).last;
-                        }
-
-                        return object;
+                if (prev) {
+                        return this.lastInclusiveDescendant(prev);
                 }
 
                 // if there is no previous sibling return the parent (might be null)
@@ -154,17 +166,21 @@ module.exports = class SymbolTree {
          * @returns {?Object}
          */
         following(object, treeRoot, skipChildren) {
-                if (!skipChildren && this._node(object).first) {
-                        return this._node(object).first;
+                const first = !skipChildren && this._node(object).first;
+
+                if (first) {
+                        return first;
                 }
 
                 do {
                         if (object === treeRoot) {
                                 return null;
                         }
 
-                        if (this._node(object).next) {
-                                return this._node(object).next;
+                        const next = this._node(object).next;
+
+                        if (next) {
+                                return next;
                         }
 
                         object = this._node(object).parent;

test/SymbolTree.js

@@ -438,6 +438,26 @@ test('Multiple SymbolTree instances should not conflict', function(t) {
         t.end();
 });
 
+test('lastInclusiveDescendant', function(t) {
+        const tree = new SymbolTree();
+        const a = {};
+        const aa = {};
+        const ab = {};
+        const aba = {};
+        const abaa = {};
+        const b = {};
+
+        tree.insertLast(aa, a);
+        tree.insertLast(ab, a);
+        tree.insertLast(aba, ab);
+        tree.insertLast(abaa, aba);
+        tree.insertAfter(b, a);
+
+        t.equal(abaa, tree.lastInclusiveDescendant(a));
+
+        t.end();
+});
+
 test('look up preceding with a previous sibling', function(t) {
         const tree = new SymbolTree();
         const a = {};