Rephrase to use binarySearchKey

Author: weswigham

src/compiler/core.ts

@@ -1195,7 +1195,7 @@ namespace ts {
      * @param keyComparer A callback used to compare two keys in a sorted array.
      * @param offset An offset into `array` at which to start the search.
      */
-    export function binarySearchKey<T, U>(array: readonly T[], key: U, keySelector: (v: T) => U, keyComparer: Comparer<U>, offset?: number): number {
+    export function binarySearchKey<T, U>(array: readonly T[], key: U, keySelector: (v: T, i: number) => U, keyComparer: Comparer<U>, offset?: number): number {
         if (!some(array)) {
             return -1;
         }
@@ -1204,7 +1204,7 @@ namespace ts {
         let high = array.length - 1;
         while (low <= high) {
             const middle = low + ((high - low) >> 1);
-            const midKey = keySelector(array[middle]);
+            const midKey = keySelector(array[middle], middle);
             switch (keyComparer(midKey, key)) {
                 case Comparison.LessThan:
                     low = middle + 1;

src/services/utilities.ts

@@ -1158,35 +1158,6 @@ namespace ts {
         }
     }
 
-    /**
-     * Psuedo-binary searches the list of children for the first element whose end position exceeds the input position
-     * Returns `undefined` if no element satisfies the condition, or the index of the satisfying element otherwise.
-     * This could probably be written using our `binarySeach` helper, but the `keyComparator` would be hairy enough
-     * that it's probably worth just writing out the algorithm in full.
-     * @param {number} start - Start search index, inclusive
-     * @param {number} end - End search index, inclusive
-     */
-    function searchChildrenSlice(position: number, children: Node[], start = 0, end = children.length - 1): number | undefined {
-        const pivot = Math.floor((end - start)/2) + start;
-        if (!children[pivot]) {
-            return undefined;
-        }
-        if (position < children[pivot].end) {
-            // first element whose end position is greater than the input position
-            if (!children[pivot - 1] || position >= children[pivot - 1].end) {
-                return pivot;
-            }
-            if (pivot === start) {
-                return undefined;
-            }
-            return searchChildrenSlice(position, children, start, pivot - 1);
-        }
-        if (pivot === end) {
-            return undefined;
-        }
-        return searchChildrenSlice(position, children, pivot + 1, end);
-    }
-
     /**
      * Finds the rightmost token satisfying `token.end <= position`,
      * excluding `JsxText` tokens containing only whitespace.
@@ -1202,8 +1173,17 @@ namespace ts {
             }
 
             const children = n.getChildren(sourceFile);
-            const i = searchChildrenSlice(position, children);
-            if (typeof i !== "undefined") {
+            const i = binarySearchKey(children, position, (_, i) => i, (middle, _) => {
+                if (position < children[middle].end) {
+                    // first element whose end position is greater than the input position
+                    if (!children[middle - 1] || position >= children[middle - 1].end) {
+                        return Comparison.EqualTo;
+                    }
+                    return Comparison.GreaterThan;
+                }
+                return Comparison.LessThan;
+            });
+            if (i >= 0 && children[i]) {
                 const child = children[i];
                 // Note that the span of a node's tokens is [node.getStart(...), node.end).
                 // Given that `position < child.end` and child has constituent tokens, we distinguish these cases: