+ vfs.file_id(&path).and_then(|(file_id, excluded)| {

+ (excluded == vfs::FileExcluded::No).then_some(file_id)

+ })

+ /// These paths (file/directories) will be ignored by rust-analyzer. They are

+ files_exclude | files_excludeDirs: Vec<Utf8PathBuf> = vec![],

+ self.files_exclude().iter().map(|p| self.root_path.join(p)).collect();

+ exclude: self.excluded().collect(),

+ pub fn excluded(&self) -> impl Iterator<Item = AbsPathBuf> + use<'_> {

+ self.files_exclude().iter().map(|it| self.root_path.join(it))

+ }

+

+ /// Returns `None` if the file was excluded.

+ pub(crate) fn url_to_file_id(&self, url: &Url) -> anyhow::Result<Option<FileId>> {

+ /// Returns `None` if the file was excluded.

+ pub(crate) fn vfs_path_to_file_id(&self, vfs_path: &VfsPath) -> anyhow::Result<Option<FileId>> {

+/// Returns `None` if the file was excluded.

+pub(crate) fn url_to_file_id(vfs: &vfs::Vfs, url: &Url) -> anyhow::Result<Option<FileId>> {

+ vfs_path_to_file_id(vfs, &path)

+/// Returns `None` if the file was excluded.

+pub(crate) fn vfs_path_to_file_id(

+ vfs: &vfs::Vfs,

+ vfs_path: &VfsPath,

+) -> anyhow::Result<Option<FileId>> {

+ let (file_id, excluded) =

+ match excluded {

+ vfs::FileExcluded::Yes => Ok(None),

+ vfs::FileExcluded::No => Ok(Some(file_id)),

+ }

+ try_default,

+ if let Some(abs_path) = path.as_path() {

+ if state.config.excluded().any(|excluded| abs_path.starts_with(&excluded)) {

+ tracing::trace!("opened excluded file {abs_path}");

+ state.vfs.write().0.insert_excluded_file(path);

+ return Ok(());

+ }

+ }

+

+ // Clear diagnostics also for excluded files, just in case.

+ if let Some((file_id, _)) = state.vfs.read().0.file_id(&path) {

+ let file_id = try_default!(snap.vfs_path_to_file_id(&vfs_path)?);

+ if let Some((file_id, vfs::FileExcluded::No)) = file_id {

+ try_default,

+ Ok(Some(it)) => file_id = Some(it),

+ Ok(None) => {}

+ let id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let position = try_default!(from_proto::file_position(&snap, params)?);

+ let position = try_default!(from_proto::file_position(&snap, params)?);

+ let position = try_default!(from_proto::file_position(&snap, params)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.uri)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let position = try_default!(from_proto::file_position(&snap, params)?);

+ let mut position =

+ try_default!(from_proto::file_position(&snap, params.text_document_position)?);

+pub(crate) fn empty_diagnostic_report() -> lsp_types::DocumentDiagnosticReportResult {

+ lsp_types::DocumentDiagnosticReportResult::Report(lsp_types::DocumentDiagnosticReport::Full(

+ lsp_types::RelatedFullDocumentDiagnosticReport {

+ related_documents: None,

+ full_document_diagnostic_report: lsp_types::FullDocumentDiagnosticReport {

+ result_id: Some("rust-analyzer".to_owned()),

+ items: vec![],

+ },

+ },

+ ))

+}

+

+ let file_id = match from_proto::file_id(&snap, &params.text_document.uri)? {

+ Some(it) => it,

+ None => return Ok(empty_diagnostic_report()),

+ return Ok(empty_diagnostic_report());

+ return Ok(empty_diagnostic_report());

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ snap.analysis.will_rename_file(file_id?, &new_name).ok()?

+ let position =

+ try_default!(from_proto::file_position(&snap, params.text_document_position_params)?);

+ let position = try_default!(from_proto::file_position(

+ &snap,

+ params.text_document_position_params.clone()

+ )?);

+ let position =

+ try_default!(from_proto::file_position(&snap, params.text_document_position_params)?);

+ let position =

+ try_default!(from_proto::file_position(&snap, params.text_document_position_params)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let position = try_default!(from_proto::file_position(&snap, params)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let position = try_default!(from_proto::file_position(&snap, params)?);

+ let mut position =

+ try_default!(from_proto::file_position(&snap, text_document_position.clone())?);

+ let file_id = from_proto::file_id(&snap, &resolve_data.position.text_document.uri)?

+ .expect("we never provide completions for excluded files");

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let position =

+ try_default!(from_proto::file_position(&snap, params.text_document_position_params)?);

+ let file_range = try_default!(from_proto::file_range(&snap, &params.text_document, range)?);

+ let position = try_default!(from_proto::file_position(&snap, params)?);

+ let position = try_default!(from_proto::file_position(&snap, params.text_document_position)?);

+ let position = try_default!(from_proto::file_position(&snap, params.text_document_position)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let frange = try_default!(from_proto::file_range(&snap, &params.text_document, params.range)?);

+ let file_id = from_proto::file_id(&snap, &params.code_action_params.text_document.uri)?

+ .expect("we never provide code actions for excluded files");

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let position =

+ try_default!(from_proto::file_position(&snap, params.text_document_position_params)?);

+ let selections = try_default!(params

+ .collect::<Result<Option<Vec<_>>, _>>()?);

+ let position = try_default!(from_proto::file_position(&snap, params.position)?);

+ let FileRange { file_id, range } = try_default!(from_proto::file_range(

+ )?);

+ let position =

+ try_default!(from_proto::file_position(&snap, params.text_document_position_params)?);

+ let frange = try_default!(from_proto::file_range(&snap, &doc, item.selection_range)?);

+ let frange = try_default!(from_proto::file_range(&snap, &doc, item.selection_range)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let frange = try_default!(from_proto::file_range(&snap, &params.text_document, params.range)?);

+ let position = try_default!(from_proto::file_position(&snap, params)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let range = try_default!(from_proto::file_range(&snap, &params.text_document, params.range)?);

+ let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

+ let file_id = try_default!(from_proto::file_id(snap, &text_document.uri)?);

+ let frange = try_default!(from_proto::file_range(snap, &text_document, range)?);

+ let source_root = match params.text_document {

+ Some(it) => Some(

+ .source_root_id(try_default!(from_proto::file_id(&state, &it.uri)?))

+ .map_err(anyhow::Error::from)?,

+ ),

+ None => None,

+ };

+#[track_caller]

+fn file_id(vfs: &vfs::Vfs, path: &VfsPath) -> vfs::FileId {

+ match vfs.file_id(path) {

+ Some((file_id, vfs::FileExcluded::No)) => file_id,

+ None | Some((_, vfs::FileExcluded::Yes)) => panic!("can't find virtual file for {path}"),

+ }

+}

+

+ file_id(&vfs, &path)

+ file_id(&vfs, &path)

+ file_id(&vfs, &path)

+

+#[doc(hidden)]

+macro_rules! try_default_ {

+ ($it:expr $(,)?) => {

+ match $it {

+ Some(it) => it,

+ None => return Ok(Default::default()),

+ }

+ };

+}

+pub(crate) use try_default_ as try_default;

+ lsp_ext, try_default,

+/// Returns `None` if the file was excluded.

+pub(crate) fn file_id(

+ snap: &GlobalStateSnapshot,

+ url: &lsp_types::Url,

+) -> anyhow::Result<Option<FileId>> {

+/// Returns `None` if the file was excluded.

+) -> anyhow::Result<Option<FilePosition>> {

+ let file_id = try_default!(file_id(snap, &tdpp.text_document.uri)?);

+ Ok(Some(FilePosition { file_id, offset }))

+/// Returns `None` if the file was excluded.

+) -> anyhow::Result<Option<FileRange>> {

+/// Returns `None` if the file was excluded.

+) -> anyhow::Result<Option<FileRange>> {

+ let file_id = try_default!(file_id(snap, document)?);

+ Ok(Some(FileRange { file_id, range }))

+/// Returns `None` if the file was excluded.

+ try_default!(file_position(snap, params.text_document_position_params)?);

+ let pos @ FilePosition { file_id, .. } = try_default!(file_position(snap, params)?);

+ handlers::{

+ dispatch::{NotificationDispatcher, RequestDispatcher},

+ request::empty_diagnostic_report,

+ },

+ .filter_map(|(file_id, excluded)| {

+ (excluded == vfs::FileExcluded::No).then_some(file_id)

+ })

+ .filter_map(|(file_id, excluded)| {

+ (excluded == vfs::FileExcluded::No).then_some(file_id)

+ })

+ let Some(id) = from_proto::file_id(&snap, &uri).expect("unable to get FileId")

+ else {

+ return;

+ };

+ Ok(Some(file_id)) => self.diagnostics.add_check_diagnostic(

+ Ok(None) => {}

+ .on_with_vfs_default::<lsp_request::DocumentDiagnosticRequest>(handlers::handle_document_diagnostics, empty_diagnostic_report, || lsp_server::ResponseError {

+ vfs.file_id(&vfs_path).and_then(|(file_id, excluded)| {

+ (excluded == vfs::FileExcluded::No).then_some(file_id)

+ })

+[dependencies]

+foo = { path = "../foo" }

+

+//- /bar/src/lib.rs

+"#,

+ )

+ .root("foo")

+ .root("bar")

+ .root("baz")

+ .with_config(json!({

+ "files": {

+ "exclude": ["foo"]

+ }

+ }))

+ .server()

+ .wait_until_workspace_is_loaded();

+

+ server.request::<WorkspaceSymbolRequest>(Default::default(), json!([]));

+

+ let server = Project::with_fixture(

+ r#"

+//- /foo/Cargo.toml

+[package]

+name = "foo"

+version = "0.0.0"

+

+//- /foo/src/lib.rs

+pub fn foo() {}

+

+//- /bar/Cargo.toml

+[package]

+name = "bar"

+version = "0.0.0"

+

+ "exclude": ["foo", "bar"]

+ // We want to filter out subdirectories that are roots themselves, because they will be visited separately.

+ dirs.exclude.iter().all(|it| it != path)

+ && (root == path || dirs.include.iter().all(|it| it != path))

+ /// The file was specifically excluded by the user. We still include excluded files

+ /// when they're opened (without their contents).

+ Excluded,

+#[derive(Debug, Clone, Copy, PartialEq, Eq)]

+pub enum FileExcluded {

+ Yes,

+ No,

+}

+

+ pub fn file_id(&self, path: &VfsPath) -> Option<(FileId, FileExcluded)> {

+ let file_id = self.interner.get(path)?;

+ let file_state = self.get(file_id);

+ match file_state {

+ FileState::Exists(_) => Some((file_id, FileExcluded::No)),

+ FileState::Deleted => None,

+ FileState::Excluded => Some((file_id, FileExcluded::Yes)),

+ }

+ (FileState::Excluded, _) => return false,

+

+ /// We cannot ignore excluded files, because this will lead to errors when the client

+ /// requests semantic information for them, so we instead mark them specially.

+ pub fn insert_excluded_file(&mut self, path: VfsPath) {

+ let file_id = self.alloc_file_id(path);

+ self.data[file_id.0 as usize] = FileState::Excluded;

+ }

+**rust-analyzer.files.exclude** (default: [])

+ These paths (file/directories) will be ignored by rust-analyzer. They are

+ "rust-analyzer.files.exclude": {

+ "markdownDescription": "These paths (file/directories) will be ignored by rust-analyzer. They are\nrelative to the workspace root, and globs are not supported. You may\nalso need to add the folders to Code's `files.watcherExclude`.",