Improve std.sort.binarySearch's return type, fix std.sort functions to adhere to their documentation

lib/compiler/aro/aro/Preprocessor.zig

@@ -270,13 +270,14 @@ fn clearBuffers(pp: *Preprocessor) void {
 
 pub fn expansionSlice(pp: *Preprocessor, tok: Tree.TokenIndex) []Source.Location {
     const S = struct {
-        fn orderTokenIndex(context: Tree.TokenIndex, item: Tree.TokenIndex) std.math.Order {
-            return std.math.order(context, item);
+        fn order(probed: Tree.TokenIndex, context: Tree.TokenIndex) std.math.Order {
+            return std.math.order(probed, context);
         }
     };
 
     const indices = pp.expansion_entries.items(.idx);
-    const idx = std.sort.binarySearch(Tree.TokenIndex, indices, tok, S.orderTokenIndex) orelse return &.{};
+    const idx, const found = std.sort.binarySearch(Tree.TokenIndex, indices, tok, S.order);
+    if (!found) return &.{};
     const locs = pp.expansion_entries.items(.locs)[idx];
     var i: usize = 0;
     while (locs[i].id != .unused) : (i += 1) {}

lib/std/debug/Coverage.zig

@@ -195,8 +195,8 @@ pub fn resolveAddressesDwarf(
             const slc = &cu.src_loc_cache.?;
             const table_addrs = slc.line_table.keys();
             line_table_i = std.sort.upperBound(u64, table_addrs, pc, struct {
-                fn order(context: u64, item: u64) std.math.Order {
-                    return std.math.order(context, item);
+                fn order(probed: u64, context: u64) std.math.Order {
+                    return std.math.order(probed, context);
                 }
             }.order);
         }

lib/std/debug/Dwarf.zig

@@ -183,8 +183,8 @@ pub const CompileUnit = struct {
 
         pub fn findSource(slc: *const SrcLocCache, address: u64) !LineEntry {
             const index = std.sort.upperBound(u64, slc.line_table.keys(), address, struct {
-                fn order(context: u64, item: u64) std.math.Order {
-                    return std.math.order(context, item);
+                fn order(probed: u64, context: u64) std.math.Order {
+                    return std.math.order(probed, context);
                 }
             }.order);
             if (index == 0) return missing();

lib/std/debug/SelfInfo.zig

@@ -1651,18 +1651,19 @@ pub fn unwindFrameDwarf(
             break :blk .{ cie, fde };
         }
 
-        const index = std.sort.binarySearch(Dwarf.FrameDescriptionEntry, di.fde_list.items, context.pc, struct {
-            pub fn compareFn(pc: usize, item: Dwarf.FrameDescriptionEntry) std.math.Order {
-                if (pc < item.pc_begin) return .lt;
-
-                const range_end = item.pc_begin + item.pc_range;
-                if (pc < range_end) return .eq;
-
-                return .gt;
+        const index, const found = std.sort.binarySearch(Dwarf.FrameDescriptionEntry, di.fde_list.items, context.pc, struct {
+            pub fn order(probed: Dwarf.FrameDescriptionEntry, pc: usize) std.math.Order {
+                return if (probed.pc_begin > pc) // start of range too great
+                    .gt
+                else if (probed.pc_begin + probed.pc_range > pc) // target within range
+                    .eq
+                else // end of range too little
+                    .lt;
             }
-        }.compareFn);
+        }.order);
 
-        const fde = if (index) |i| di.fde_list.items[i] else return error.MissingFDE;
+        if (!found) return error.MissingFDE;
+        const fde = di.fde_list.items[index];
         const cie = di.cie_map.get(fde.cie_length_offset) orelse return error.MissingCIE;
 
         break :blk .{ cie, fde };