Merge remote-tracking branch 'upstream/main' into length_ignore_ansi

# Conflicts:
#	pkgs/args/CHANGELOG.md

Author: timmaffett

.github/workflows/lints_version_bump.yaml

@@ -10,7 +10,7 @@ jobs:
   check-major-version:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Verify Major first in major version is X.0.0 or X.0.0-wip
         if: "!contains(github.event.pull_request.labels.*.name, 'skip-breaking-check')"

.github/workflows/no-response.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     if: ${{ github.repository_owner == 'dart-lang' }}
     steps:
-      - uses: actions/stale@997185467fa4f803885201cee163a9f38240193d
+      - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f
         with:
           # Don't automatically mark inactive issues+PRs as stale.
           days-before-stale: -1

pkgs/args/CHANGELOG.md

@@ -14,8 +14,7 @@
   (Fixes #103).
 * Remove sorting of the subcommands in usage output. Ordering will depend on the
   order that `addSubCommand` is called.
-  
-## 2.7.0
+
 
 * Remove sorting of the `allowedHelp` argument in usage output. Ordering will
   depend on key order for the passed `Map`.

pkgs/collection/CHANGELOG.md

@@ -9,6 +9,7 @@
 - Optimize equality and hash code for maps by using `update` and a `values`
   iterator to avoid extra lookups.
 - Add `PriorityQueue.of` constructor and optimize adding many elements.
+- Add `descending` argument to `sortedBy`.
 - Address diagnostics from `strict_top_level_inference`.
 - Run `dart format` with the new style.
 - Replace `quickSort` implementation with a more performant and robust

pkgs/collection/lib/src/iterable_extensions.dart

@@ -7,7 +7,6 @@ import 'dart:math' show Random;
 import '../collection.dart' show DelegatingIterable;
 import 'algorithms.dart';
 import 'functions.dart' as functions;
-import 'utils.dart';
 
 /// Extensions that apply to all iterables.
 ///
@@ -165,10 +164,17 @@ extension IterableExtension<T> on Iterable<T> {
   /// Creates a sorted list of the elements of the iterable.
   ///
   /// The elements are ordered by the natural ordering of the
-  /// property [keyOf] of the element.
-  List<T> sortedBy<K extends Comparable<K>>(K Function(T element) keyOf) {
+  /// [keyOf] property when [descending] is `false` (the default) or reverse
+  /// ordering when [descending] is `true`.
+  List<T> sortedBy<K extends Comparable<K>>(
+    K Function(T element) keyOf, {
+    bool descending = false,
+  }) {
+    final compare = descending
+        ? (K a, K b) => b.compareTo(a)
+        : (K a, K b) => a.compareTo(b);
     var elements = [...this];
-    mergeSortBy<T, K>(elements, keyOf, compareComparable);
+    mergeSortBy<T, K>(elements, keyOf, compare);
     return elements;
   }
 

pkgs/collection/test/extensions_test.dart

@@ -70,6 +70,16 @@ void main() {
         test('multiple', () {
           expect(iterable(<int>[3, 20, 100]).sortedBy(toString), [100, 20, 3]);
         });
+        test('multiple descending: false', () {
+          expect(
+              iterable(<int>[3, 20, 100]).sortedBy(toString, descending: false),
+              [100, 20, 3]);
+        });
+        test('multiple descending: true', () {
+          expect(
+              iterable(<int>[3, 20, 100]).sortedBy(toString, descending: true),
+              [3, 20, 100]);
+        });
       });
       group('.sortedByCompare', () {
         test('empty', () {

pkgs/path/CHANGELOG.md

@@ -8,6 +8,7 @@
   in/as the last segment when splitting.
 - Run `dart format` with the new style.
 - Centralize join logic in `Context` and eliminate redundant validation in `absolute()`.
+- Avoid list allocation in `join()` and `absolute()` argument validation for improved performance.
 
 ## 1.9.1
 

pkgs/path/benchmark/benchmark.dart

@@ -58,6 +58,16 @@ void main(List<String> args) {
     }
 
     benchmark('absolute', context.absolute);
+    runBenchmark('${style.name}-join', 100000, () {
+      for (var file in files) {
+        context.join(file, 'subdir', 'file.txt');
+      }
+    });
+    runBenchmark('${style.name}-join-many', 100000, () {
+      for (var file in files) {
+        context.join(file, 'a', 'b', 'c', 'd', 'e', 'f');
+      }
+    });
     benchmark('basename', context.basename);
     benchmark('basenameWithoutExtension', context.basenameWithoutExtension);
     benchmark('dirname', context.dirname);

pkgs/path/lib/src/context.dart

@@ -114,7 +114,8 @@ class Context {
       return part1;
     }
 
-    return _join('absolute', [
+    final args = _validateArgs(
+      'absolute',
       current,
       part1,
       part2,
@@ -131,7 +132,8 @@ class Context {
       part13,
       part14,
       part15,
-    ]);
+    );
+    return joinAll(args);
   }
 
   /// Gets the part of [path] after the last separator on the context's
@@ -279,30 +281,27 @@ class Context {
     String? part14,
     String? part15,
     String? part16,
-  ]) =>
-      _join('join', [
-        part1,
-        part2,
-        part3,
-        part4,
-        part5,
-        part6,
-        part7,
-        part8,
-        part9,
-        part10,
-        part11,
-        part12,
-        part13,
-        part14,
-        part15,
-        part16,
-      ]);
-
-  /// Joins the given path parts into a single path.
-  String _join(String method, List<String?> parts) {
-    _validateArgList(method, parts);
-    return joinAll(parts.whereType<String>());
+  ]) {
+    final args = _validateArgs(
+      'join',
+      part1,
+      part2,
+      part3,
+      part4,
+      part5,
+      part6,
+      part7,
+      part8,
+      part9,
+      part10,
+      part11,
+      part12,
+      part13,
+      part14,
+      part15,
+      part16,
+    );
+    return joinAll(args);
   }
 
   /// Joins the given path parts into a single path. Example:
@@ -1165,28 +1164,194 @@ Uri _parseUri(Object uri) {
 
 /// Validates that there are no non-null arguments following a null one and
 /// throws an appropriate [ArgumentError] on failure.
-void _validateArgList(String method, List<String?> args) {
-  for (var i = 1; i < args.length; i++) {
-    // Ignore nulls hanging off the end.
-    if (args[i] == null || args[i - 1] != null) continue;
-
-    int numArgs;
-    for (numArgs = args.length; numArgs >= 1; numArgs--) {
-      if (args[numArgs - 1] != null) break;
-    }
+///
+/// This function operates on individual arguments rather than a list for better
+/// performance by avoiding list allocation.
+///
+/// Returns a list of only the non-null arguments.
+List<String> _validateArgs(
+  String method,
+  String p0,
+  String? p1,
+  String? p2,
+  String? p3,
+  String? p4,
+  String? p5,
+  String? p6,
+  String? p7,
+  String? p8,
+  String? p9,
+  String? p10,
+  String? p11,
+  String? p12,
+  String? p13,
+  String? p14,
+  String? p15,
+) {
+  // Helper to create the list of args for error messages.
+  List<String?> allArgs() => [
+        p0,
+        p1,
+        p2,
+        p3,
+        p4,
+        p5,
+        p6,
+        p7,
+        p8,
+        p9,
+        p10,
+        p11,
+        p12,
+        p13,
+        p14,
+        p15,
+      ];
+
+  // p0 is always non-null (enforced by caller), so we start checking from p1.
+  // Once we see a null, all subsequent arguments must also be null.
+  var seenNull = false;
+  final args = <String>[p0];
+
+  if (p1 == null) {
+    seenNull = true;
+  } else {
+    args.add(p1);
+  }
 
-    // Show the arguments.
-    final message = StringBuffer();
-    message.write('$method(');
-    message.write(
-      args
-          .take(numArgs)
-          .map((arg) => arg == null ? 'null' : '"$arg"')
-          .join(', '),
-    );
-    message.write('): part ${i - 1} was null, but part $i was not.');
-    throw ArgumentError(message.toString());
+  if (p2 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 2, allArgs());
+  } else {
+    args.add(p2);
+  }
+
+  if (p3 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 3, allArgs());
+  } else {
+    args.add(p3);
   }
+
+  if (p4 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 4, allArgs());
+  } else {
+    args.add(p4);
+  }
+
+  if (p5 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 5, allArgs());
+  } else {
+    args.add(p5);
+  }
+
+  if (p6 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 6, allArgs());
+  } else {
+    args.add(p6);
+  }
+
+  if (p7 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 7, allArgs());
+  } else {
+    args.add(p7);
+  }
+
+  if (p8 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 8, allArgs());
+  } else {
+    args.add(p8);
+  }
+
+  if (p9 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 9, allArgs());
+  } else {
+    args.add(p9);
+  }
+
+  if (p10 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 10, allArgs());
+  } else {
+    args.add(p10);
+  }
+
+  if (p11 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 11, allArgs());
+  } else {
+    args.add(p11);
+  }
+
+  if (p12 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 12, allArgs());
+  } else {
+    args.add(p12);
+  }
+
+  if (p13 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 13, allArgs());
+  } else {
+    args.add(p13);
+  }
+
+  if (p14 == null) {
+    seenNull = true;
+  } else if (seenNull) {
+    _throwArgError(method, 14, allArgs());
+  } else {
+    args.add(p14);
+  }
+
+  if (p15 == null) {
+    // No more arguments to check after p15, so this is valid.
+  } else if (seenNull) {
+    _throwArgError(method, 15, allArgs());
+  } else {
+    args.add(p15);
+  }
+
+  return args;
+}
+
+/// Throws an [ArgumentError] for invalid argument ordering.
+///
+/// [nonNullIndex] is the index of the non-null argument that follows a null.
+Never _throwArgError(String method, int nonNullIndex, List<String?> args) {
+  int numArgs;
+  for (numArgs = args.length; numArgs >= 1; numArgs--) {
+    if (args[numArgs - 1] != null) break;
+  }
+
+  final message = StringBuffer();
+  message.write('$method(');
+  message.write(
+    args.take(numArgs).map((arg) => arg == null ? 'null' : '"$arg"').join(', '),
+  );
+  message.write(
+    '): part ${nonNullIndex - 1} was null, but part $nonNullIndex was not.',
+  );
+  throw ArgumentError(message.toString());
 }
 
 /// An enum of possible return values for [Context._pathDirection].