[analysis_server] Don't treat non-existent files the same as empty files when checking if didOpen changes content

This code assumed `driver?.fsState.getExistingFromPath(path)?.content` would be null for files that didn't exist, but actually we can get a `FileState` with `exists=false` and an empty string for `content`. We should not consider this equal to an empty file that was just opened.

Fixes Dart-Code/Dart-Code#5269
Fixes #55318

Change-Id: I4334a002ef0fb9ff3a9423568faa6e0735369022
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/392142
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Brian Wilkerson <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: DanTup

pkg/analysis_server/lib/src/lsp/lsp_analysis_server.dart

@@ -649,8 +649,13 @@ class LspAnalysisServer extends AnalysisServer {
     // dependencies (so the optimization works for them) but below we use
     // `contextManager.driverFor` so we only add to the specific driver.
     var driver = getAnalysisDriver(path);
+    var state = driver?.fsState.getExistingFromPath(path);
+    // Content is updated if we have no state, we have state that does not exist
+    // or the content differs. For a file with state that does not exist, the
+    // content will be an empty string, so we must check exists to cover files
+    // that are newly created with empty contents.
     var contentIsUpdated =
-        driver?.fsState.getExistingFromPath(path)?.content != content;
+        state == null || !state.exists || state.content != content;
 
     if (contentIsUpdated) {
       _afterOverlayChanged(path, plugin.AddContentOverlay(content));

pkg/analysis_server/test/lsp/diagnostic_test.dart

@@ -192,6 +192,29 @@ void f() {
     expect(diagnostic.message, contains('\nTry'));
   }
 
+  /// Verify that if a nonexistant file is imported, creating that file causes
+  /// the uri_does_not_exist error to go away.
+  ///
+  /// https://github.com/dart-lang/sdk/issues/55318
+  Future<void> test_createAfterImport() async {
+    var fooFilePath = join(projectFolderPath, 'lib', 'foo.dart');
+
+    await initialize();
+    await openFile(mainFileUri, "import 'foo.dart';");
+    await pumpEventQueue(times: 5000);
+
+    expect(diagnostics[mainFileUri]!.single.code, 'uri_does_not_exist');
+
+    // Create the file.
+    await openFile(toUri(fooFilePath), '');
+
+    // Allow server to catch up.
+    await pumpEventQueue(times: 5000);
+
+    // Expect the diagnostic is now for an unused import instead.
+    expect(diagnostics[mainFileUri]!.single.code, 'unused_import');
+  }
+
   Future<void> test_deletedFile() async {
     newFile(mainFilePath, 'String a = 1;');
 
@@ -568,6 +591,40 @@ void f(dynamic a) => a.foo();
     }
   }
 
+  /// Verify that when a file is renamed, if references to the new file are
+  /// written into the documents before the new file is "created", it does not
+  /// result in uri_does_not_exist errors that hang around.
+  ///
+  /// https://github.com/Dart-Code/Dart-Code/issues/5269
+  Future<void> test_rename_updatedImportsBeforeCreated() async {
+    var oldFilePath = join(projectFolderPath, 'lib', 'old.dart');
+    var newFilePath = join(projectFolderPath, 'lib', 'new.dart');
+    newFile(oldFilePath, '');
+    newFile(mainFilePath, '');
+
+    await initialize();
+    await pumpEventQueue(times: 5000);
+
+    // Create a valid reference to the old file.
+    await openFile(mainFileUri, "import 'old.dart';");
+    await openFile(toUri(oldFilePath), '');
+    await pumpEventQueue(times: 5000);
+
+    // Update the reference to the new file, update the overlays, and update
+    // the disk.
+    await replaceFile(2, mainFileUri, "import 'new.dart';");
+    await closeFile(toUri(oldFilePath));
+    await openFile(toUri(newFilePath), '');
+    deleteFile(oldFilePath);
+    newFile(newFilePath, '');
+
+    // Allow server to catch up.
+    await waitForAnalysisComplete();
+
+    // Expect unused_import, not uri_does_not_exist.
+    expect(diagnostics[mainFileUri]!.single.code, 'unused_import');
+  }
+
   /// Tests that diagnostic ordering is stable when minor changes are made to
   /// the file that does not alter the diagnostics besides extending their
   /// range and adding to their messages.