[analysis server] Don't allocate on each compare when sorting in semanticTokens/full

Upon a `textDocument/semanticTokens/full` request the analysis server
sorts the "tokens" via `sort` on List giving it a compare method.
The method, though, created a map literal for each comparison.
This CL "inlines" the map (it only had one entry anyway) and adds a
benchmark, where I note these changes:

```
1000:
Difference at 95.0% confidence
        -0.0274151 +/- 0.0135978
        -33.1981% +/- 16.4662%
        (Student's t, pooled s = 0.0181832)

2000:
Difference at 95.0% confidence
        -0.027344 +/- 0.0096196
        -20.9529% +/- 7.3712%
        (Student's t, pooled s = 0.0128635)

4000:
Difference at 95.0% confidence
        -0.108847 +/- 0.0196627
        -35.3172% +/- 6.37987%
        (Student's t, pooled s = 0.0262932)

8000:
Difference at 95.0% confidence
        -0.20647 +/- 0.0272577
        -34.4932% +/- 4.55371%
        (Student's t, pooled s = 0.0364494)

16000:
Difference at 95.0% confidence
        -0.384931 +/- 0.0401393
        -31.4809% +/- 3.28272%
        (Student's t, pooled s = 0.0536748)
```
Change-Id: Ibacce056cd3f154afc9377805bbccfd8c5ca9ea9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/456341
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Jens Johansen <[email protected]>

Author: jensjoha

pkg/analysis_server/lib/src/lsp/semantic_tokens/encoder.dart

@@ -204,11 +204,6 @@ class SemanticTokenInfo {
     SemanticTokenInfo t1,
     SemanticTokenInfo t2,
   ) {
-    var priorities = {
-      // Ensure boolean comes above keyword.
-      CustomSemanticTokenTypes.boolean: 1,
-    };
-
     // First sort by offset.
     if (t1.offset != t2.offset) {
       return t1.offset.compareTo(t2.offset);
@@ -219,9 +214,9 @@ class SemanticTokenInfo {
       return -t1.length.compareTo(t2.length);
     }
 
-    // Next sort by priority (if different).
-    var priority1 = priorities[t1.type] ?? 0;
-    var priority2 = priorities[t2.type] ?? 0;
+    // Next sort by priority (if different) (boolean comes above keyword).
+    var priority1 = t1.type == CustomSemanticTokenTypes.boolean ? 1 : 0;
+    var priority2 = t2.type == CustomSemanticTokenTypes.boolean ? 1 : 0;
     if (priority1 != priority2) {
       return priority1.compareTo(priority2);
     }

pkg/analysis_server/tool/benchmark_tools/lsp_messages.dart

@@ -244,4 +244,16 @@ class LspMessages {
       },
     };
   }
+
+  static Map<String, dynamic> semanticTokensFull(Uri uri, int id) {
+    return {
+      'jsonrpc': '2.0',
+      'id': id,
+      'method': 'textDocument/semanticTokens/full',
+      'params': {
+        'textDocument': {'uri': '$uri'},
+      },
+      'clientRequestTime': DateTime.now().millisecondsSinceEpoch,
+    };
+  }
 }

pkg/analysis_server/tool/benchmark_tools/single_benchmarks/lsp_semantic_token_full_in_big_file.dart

@@ -0,0 +1,122 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+
+import '../language_server_benchmark.dart';
+import '../lsp_messages.dart';
+import '../run_utils.dart';
+
+/// Request "semanticTokens/full" in a big file.
+Future<void> main(List<String> args) async {
+  await runHelper(
+    args,
+    LspRequestSemanticTokenFull.new,
+    createData,
+    sizeOptions: [1000, 2000, 4000, 8000, 16000],
+    extraIterations: (_) => [null],
+    runAsLsp: true,
+  );
+}
+
+RunDetails createData(
+  Uri packageDirUri,
+  Uri outerDirForAdditionalData,
+  int size,
+  dynamic unused,
+  List<String> args, {
+  // unused
+  required dynamic extraInformation,
+}) {
+  Uri libDirUri = packageDirUri.resolve('lib/');
+  Directory.fromUri(libDirUri).createSync();
+
+  var mainFileUri = libDirUri.resolve('main.dart');
+  var mainFileContent = StringBuffer();
+  for (int i = 0; i < size; i++) {
+    var className = 'Class$i';
+    mainFileContent.write('''
+class $className { // line 0 (in the first class)
+  final int foo; // line 1 (in the first class)
+  $className(this.foo) { // line 2 (in the first class)
+    print("Hello from class $className"); // line 3 (in the first class)
+    print("$className.foo = \$foo");
+  }
+}
+''');
+  }
+  var mainFileContentString = mainFileContent.toString();
+  File.fromUri(mainFileUri).writeAsStringSync(mainFileContentString);
+
+  return RunDetails(
+    mainFile: FileContentPair(mainFileUri, mainFileContentString),
+  );
+}
+
+class FileContentPair {
+  final Uri uri;
+  final String content;
+
+  FileContentPair(this.uri, this.content);
+}
+
+class LspRequestSemanticTokenFull extends DartLanguageServerBenchmark {
+  @override
+  final Uri rootUri;
+  @override
+  final Uri cacheFolder;
+
+  final RunDetails runDetails;
+
+  LspRequestSemanticTokenFull(
+    super.args,
+    this.rootUri,
+    this.cacheFolder,
+    this.runDetails,
+  ) : super(useLspProtocol: true);
+
+  @override
+  LaunchFrom get launchFrom => LaunchFrom.Dart;
+
+  @override
+  Future<void> afterInitialization() async {
+    await send(
+      LspMessages.open(runDetails.mainFile.uri, 1, runDetails.mainFile.content),
+    );
+
+    // Get colors just to make sure everything is analyzed.
+    await (await send(
+      LspMessages.documentColor(runDetails.mainFile.uri, largestIdSeen + 1),
+    ))!.completer.future;
+
+    for (int i = 0; i < 5; i++) {
+      // The below is a replay of a recorded actual IDE interaction.
+      var allStopwatch = Stopwatch()..start();
+
+      // Send semanticTokens/full request.
+      await (await send(
+        LspMessages.semanticTokensFull(
+          runDetails.mainFile.uri,
+          largestIdSeen + 1,
+        ),
+      ))!.completer.future;
+
+      var elapsedWholeThing = allStopwatch.elapsed;
+
+      if (latestIsAnalyzing) {
+        await waitWhileAnalyzing();
+        elapsedWholeThing = allStopwatch.elapsed;
+      }
+      durationInfo.add(
+        DurationInfo('Semantics tokens full request ($i)', elapsedWholeThing),
+      );
+    }
+  }
+}
+
+class RunDetails {
+  final FileContentPair mainFile;
+
+  RunDetails({required this.mainFile});
+}