check if a file is in a project when it opens

Summary:
ELP has an assumption that all the files belonging to a given project have some common root directory, and when using buck this is marked by an `.elp.toml` file.

Now that we are using buck to generate some files as part of the build process, this assumption is no longer valid, as the generated files end up in the `buck out` directory, which is outside the normal project.

Further, ELP can handle more than one project at a time. So when a new file is opened in the client, we check if it belongs to one of the existing projects, and if not we configure a new project for it.

This leads to a situation where if we open one of the generated files, ELP will try to make a new project for it.  This causes the ELP project-wide information to become invalid, as it is now spread over more than one. In particular this shows up as generated include files no longer being resolved.

## This diff

This diff addresses the issue by making use of the fact that every file in a buck project is explicitly enumerated, precisely because there it no simple directory enclosure mechanism to determine project owner.

So when a new file is opened, provided ELP is already in `Running` state and thus the internal database is valid, we check if the file is already known. If so we do not check for a possible new project.

Reviewed By: robertoaloi

Differential Revision: D85234832

fbshipit-source-id: 4858bbfa2d51d1e3f030f666f706a2ffb155e0f1

Author: alanz

crates/elp/src/server.rs

@@ -724,38 +724,45 @@ impl Server {
                 this.ct_diagnostics_requested = true;
                 this.native_diagnostics_requested = true;
                 if let Ok(path) = convert::abs_path(&params.text_document.uri) {
-                    this.fetch_projects_if_needed(&path);
-                    let path = VfsPath::from(path);
+                    let vfs_path = VfsPath::from(path.clone());
                     let already_exists = this
                         .mem_docs
                         .write()
                         .insert(
-                            path.clone(),
+                            vfs_path.clone(),
                             DocumentData::new(
                                 params.text_document.version,
                                 params.text_document.text.clone().into_bytes(),
                             ),
                         )
                         .is_err();
                     if already_exists {
-                        tracing::error!("duplicate DidOpenTextDocument: {}", path);
-                        log::error!("duplicate DidOpenTextDocument: {path}");
+                        tracing::error!("duplicate DidOpenTextDocument: {}", &vfs_path);
+                        log::error!("duplicate DidOpenTextDocument: {vfs_path}");
                     }
 
-                    let mut vfs = this.vfs.write();
-                    let bytes = params.text_document.text.into_bytes();
-                    vfs.set_file_contents(path.clone(), Some(bytes.clone()));
-
-                    // Until we bring over the full rust-analyzer
-                    // style change processing, make a list of files
-                    // that are freshly opened so diagnostics are
-                    // generated for them, despite no changes being
-                    // registered in vfs.
-                    let (file_id, _) = vfs.file_id(&path).unwrap();
-                    this.newly_opened_documents.push(ChangedFile {
-                        file_id,
-                        change: Change::Modify(bytes, params.text_document.version as u64),
-                    });
+                    let file_id = {
+                        let mut vfs = this.vfs.write();
+                        let bytes = params.text_document.text.into_bytes();
+                        vfs.set_file_contents(vfs_path.clone(), Some(bytes.clone()));
+
+                        // Until we bring over the full rust-analyzer
+                        // style change processing, make a list of files
+                        // that are freshly opened so diagnostics are
+                        // generated for them, despite no changes being
+                        // registered in vfs.
+                        let (file_id, _) = vfs.file_id(&vfs_path).unwrap();
+                        this.newly_opened_documents.push(ChangedFile {
+                            file_id,
+                            change: Change::Modify(bytes, params.text_document.version as u64),
+                        });
+                        file_id
+                    };
+
+                    if this.status != Status::Running || this.analysis_host.raw_database().file_app_data(file_id).is_none() {
+                        // We do not have a project associated with this file
+                        this.fetch_projects_if_needed(&path);
+                    }
                 } else {
                     log::error!(
                         "DidOpenTextDocument: could not get vfs path for {}",