[analyzer] Don't calculate add-late assists for other files

The "add late" assist was broadened in
https://dart-review.googlesource.com/c/sdk/+/176900 with a link to
#44440 where the example is
adding `late` to a field in the same class the user is currently editing
the constructor for.

That makes sense.

The code could also add the `late` keyword to other files which is - I
think - bad for at least two reasons:

  1) It's confusing being given the option to "add late" to something,
     then when trying it nothing seemingly happen, except something does
     happen: another - possibly not open - file has changed.
  2) It requests the resolved unit for another - possibly not open -
     file, which is slow. This means that, at least in VSCode, just
     moving the cursor over something can send requests that takes a
     long time. In practise I've experienced up to ~1.5 seconds, and in
     benchmarks I can make this arbitrarily large by increasing the
     size of the file. Shown below, having 16,000 small classes takes
     around 4 seconds (vs less than 10 ms with this CL).

This CL restricts this to the same file, adds a few tests and updates
a few existing tests.

Note that the existing tests that verified the behavior of adding `late`
to other files was added in
https://dart-review.googlesource.com/c/sdk/+/180087 with a link to
#44534
where the issue discusses a bug where it is applied in the wrong file
and says that it should either be applied to the right file or be
disallowed. The option of allowing it was picked in that instance,
but now at least there's data to show that it comes at a cost.

For an ad-hoc test where I programmatically asks for assists at every
position in `pkg/front_end/lib/src/kernel/body_builder.dart` I go from
1875 positions that takes >= 100 ms to answer to 0 such positions.

For the added benchmark I get this data:

Before this CL:

```
size 1000:
Initial analysis: 0.188291
Action call on 4:11 : 0.308514
Action call on 4:12 : 0.319540
Action call on 4:13 : 0.274678
peak virtual memory size: 2363 MB
total program size (virtual): 2292 MB
peak resident set size ("high water mark"): 258 MB
size of memory portions (rss): 244 MB

size 2000:
Initial analysis: 0.387643
Action call on 4:11 : 0.649877
Action call on 4:12 : 0.550778
Action call on 4:13 : 0.474030
peak virtual memory size: 2325 MB
total program size (virtual): 2325 MB
peak resident set size ("high water mark"): 279 MB
size of memory portions (rss): 277 MB

size 4000:
Initial analysis: 0.753913
Action call on 4:11 : 1.086648
Action call on 4:12 : 1.015921
Action call on 4:13 : 0.915511
peak virtual memory size: 2335 MB
total program size (virtual): 2304 MB
peak resident set size ("high water mark"): 363 MB
size of memory portions (rss): 334 MB

size 8000:
Initial analysis: 1.235531
Action call on 4:11 : 1.880335
Action call on 4:12 : 1.824658
Action call on 4:13 : 1.771081
peak virtual memory size: 2414 MB
total program size (virtual): 2386 MB
peak resident set size ("high water mark"): 436 MB
size of memory portions (rss): 411 MB

size 16000:
Initial analysis: 2.618666
Action call on 4:11 : 3.991542
Action call on 4:12 : 3.775863
Action call on 4:13 : 4.094692
peak virtual memory size: 2576 MB
total program size (virtual): 2516 MB
peak resident set size ("high water mark"): 667 MB
size of memory portions (rss): 611 MB
```

With this CL:

```
size 1000:
Initial analysis: 0.202665
Action call on 4:11 : 0.005730
Action call on 4:12 : 0.003086
Action call on 4:13 : 0.002743
peak virtual memory size: 2174 MB
total program size (virtual): 2170 MB
peak resident set size ("high water mark"): 256 MB
size of memory portions (rss): 247 MB

size 2000:
Initial analysis: 0.433420
Action call on 4:11 : 0.005353
Action call on 4:12 : 0.002116
Action call on 4:13 : 0.002156
peak virtual memory size: 2226 MB
total program size (virtual): 2226 MB
peak resident set size ("high water mark"): 290 MB
size of memory portions (rss): 240 MB

size 4000:
Initial analysis: 0.674376
Action call on 4:11 : 0.004219
Action call on 4:12 : 0.002138
Action call on 4:13 : 0.001625
peak virtual memory size: 2392 MB
total program size (virtual): 2328 MB
peak resident set size ("high water mark"): 306 MB
size of memory portions (rss): 286 MB

size 8000:
Initial analysis: 1.244688
Action call on 4:11 : 0.005225
Action call on 4:12 : 0.002104
Action call on 4:13 : 0.002729
peak virtual memory size: 2349 MB
total program size (virtual): 2338 MB
peak resident set size ("high water mark"): 385 MB
size of memory portions (rss): 366 MB

size 16000:
Initial analysis: 2.776680
Action call on 4:11 : 0.008848
Action call on 4:12 : 0.002854
Action call on 4:13 : 0.002327
peak virtual memory size: 2423 MB
total program size (virtual): 2405 MB
peak resident set size ("high water mark"): 505 MB
size of memory portions (rss): 489 MB
```

It's interesting how the action calls for sizes >= 4000 was slower than
the initial analysis, but I haven't looked into it.

Change-Id: Icefe02073cdf1ad442a37de2030fd7e53f5013b9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/436280
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Jens Johansen <[email protected]>

Author: jensjoha

pkg/analysis_server/lib/src/services/correction/dart/add_late.dart

@@ -71,7 +71,13 @@ class AddLate extends ResolvedCorrectionProducer {
         if (variableElement != null &&
             !variableElement.isSynthetic &&
             !variableElement.isLate &&
-            variableElement.setter2 == null) {
+            variableElement.setter2 == null &&
+            // It is currently too expensive to do a `getFragmentDeclaration`
+            // call if we don't already have the resolved library ready.
+            // If it becomes desirable to allow such edits we'll likely need
+            // to do something else to not regress performance.
+            variableElement.firstFragment.libraryFragment.source.fullName ==
+                file) {
           var variableFragment = variableElement.firstFragment;
           var declarationResult = await sessionHelper.getFragmentDeclaration(
             variableFragment,

pkg/analysis_server/test/src/services/correction/assist/add_late_test.dart

@@ -55,6 +55,48 @@ class C {
 ''');
   }
 
+  Future<void> test_field_finalType_in_other_file() async {
+    late var test2FilePath = '$testPackageLibPath/test2.dart';
+    var test2File = getFile(test2FilePath);
+    newFile(test2File.path, '''
+class C {
+  final String s;
+  C(this.s);
+}
+''');
+    await resolveTestCode('''
+import 'test2.dart';
+
+void foo() {
+  C c = C('42');
+  c.s^;
+}
+''');
+
+    // Don't give assists for another file.
+    await assertNoAssist();
+  }
+
+  Future<void> test_field_finalType_when_in_constructor() async {
+    verifyNoTestUnitErrors = false;
+    await resolveTestCode('''
+class C {
+  final String s;
+  C() {
+    s^ = '';
+  }
+}
+''');
+    await assertHasAssist('''
+class C {
+  late final String s;
+  C() {
+    s = '';
+  }
+}
+''');
+  }
+
   Future<void> test_field_type() async {
     await resolveTestCode('''
 class C {

pkg/analysis_server/test/src/services/correction/assist/assist_processor.dart

@@ -86,6 +86,7 @@ abstract class AssistProcessorTest extends AbstractSingleUnitTest {
     var fileEdits = _change.edits;
     if (additionallyChangedFiles == null) {
       expect(fileEdits, hasLength(1));
+      expect(_change.edits[0].file, testFilePath);
       _resultCode = SourceEdit.applySequence(testCode, _change.edits[0].edits);
       expect(_resultCode, expected);
     } else {

pkg/analysis_server/test/src/services/correction/fix/add_late_test.dart

@@ -33,11 +33,7 @@ void f(C c) {
   c.s = '';
 }
 ''');
-    await assertHasFix('''
-class C {
-  late final String s;
-}
-''', target: '$testPackageLibPath/a.dart');
+    await assertNoFix();
   }
 
   Future<void> test_changeInPart() async {
@@ -55,13 +51,7 @@ void f(C c) {
   c.s = '';
 }
 ''');
-    await assertHasFix('''
-part 'test.dart';
-
-class C {
-  late final String s;
-}
-''', target: '$testPackageLibPath/a.dart');
+    await assertNoFix();
   }
 
   Future<void> test_final_implicitThis() async {

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

@@ -0,0 +1,142 @@
+// 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';
+
+/// Small file imports big file. Asking for assists in possitions in the small
+/// file should not be expensive (i.e. should not require loading more of the
+/// big file).
+/// Previously the "add late" assist would load the big file and make this slow.
+Future<void> main(List<String> args) async {
+  await runHelper(
+    args,
+    LspAssistLate.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 libUri = libDirUri.resolve('lib.dart');
+    var libContent = StringBuffer();
+    for (int i = 0; i < size; i++) {
+      var className = 'Class$i';
+      libContent.write('''
+class $className {
+  final int foo;
+  $className(this.foo) {
+    print("Hello from class $className");
+    print("$className.foo = \$foo");
+  }
+}
+''');
+    }
+    var libContentString = libContent.toString();
+    File.fromUri(libUri).writeAsStringSync(libContentString);
+  }
+
+  var mainFileUri = libDirUri.resolve('main.dart');
+  var mainFileContentString = '''
+import 'lib.dart';
+
+void main() {
+  var c1 = Class1(42);
+  print(c1.foo);
+}
+''';
+  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 LspAssistLate extends DartLanguageServerBenchmark {
+  @override
+  final Uri rootUri;
+  @override
+  final Uri cacheFolder;
+
+  final RunDetails runDetails;
+
+  LspAssistLate(super.args, this.rootUri, this.cacheFolder, this.runDetails)
+    : super(useLspProtocol: true);
+
+  @override
+  LaunchFrom get launchFrom => LaunchFrom.Dart;
+
+  @override
+  Future<void> afterInitialization() async {
+    var lines = runDetails.mainFile.content.split('\n');
+    await send(
+      LspMessages.open(runDetails.mainFile.uri, 1, runDetails.mainFile.content),
+    );
+
+    Future<Duration> timeAssist(int lineNumber, int column) async {
+      var codeActionStopwatch = Stopwatch()..start();
+      var codeActionFuture = (await send(
+        LspMessages.codeAction(
+          largestIdSeen + 1,
+          runDetails.mainFile.uri,
+          line: lineNumber,
+          character: column,
+        ),
+      ))!.completer.future.then((result) {
+        codeActionStopwatch.stop();
+        return result;
+      });
+      await codeActionFuture;
+      return codeActionStopwatch.elapsed;
+    }
+
+    const lineNumber = 4;
+    String line = lines[lineNumber];
+    if (line != '  print(c1.foo);') {
+      throw 'Unexpected change in benchmark.';
+    }
+
+    // Warmup.
+    for (int i = 0; i < 10; i++) {
+      await timeAssist(lineNumber, 0);
+    }
+
+    for (int column = 11; column < 14; column++) {
+      var duration = await timeAssist(lineNumber, column);
+      durationInfo.add(
+        DurationInfo('Action call on $lineNumber:$column ', duration),
+      );
+    }
+  }
+}
+
+class RunDetails {
+  final FileContentPair mainFile;
+
+  RunDetails({required this.mainFile});
+}