Filter out hidden and extensionless files from watching

[vipentti]

Relates to discussion in rust-lang/rust-analyzer#869

I'm not sure if this is the appropriate place to do the filtering.

[matklad]

Yeah, I think we probably want to put the logic here to Root:

ra_vfs/src/roots.rs

Lines 72 to 102 in 31eec52

	impl RootData {
	fn new(path: PathBuf, excluded_dirs: Vec<RelativePathBuf>) -> RootData {
	let mut canonical_path = path.canonicalize().ok();
	if Some(&path) == canonical_path.as_ref() {
	canonical_path = None;
	}
	RootData { path, canonical_path, excluded_dirs }
	}
	fn is_excluded(&self, path: &RelativePath) -> bool {
	if self.excluded_dirs.iter().any(|it| it == path) {
	return true;
	}
	// Ignore some common directories.
	//
	// FIXME: don't hard-code, specify at source-root creation time using
	// gitignore
	for (i, c) in path.components().enumerate() {
	if let relative_path::Component::Normal(c) = c {
	if (i == 0 && c == "target") || c == ".git" || c == "node_modules" {
	return true;
	}
	}
	}
	match path.extension() {
	None | Some("rs") => false,
	_ => true,
	}
	}
	}

Root is effectively a predicate which checks if a particular file belongs to it. The existing is_excluded function can't be used here: it purpusfully has access only to RelativePath, and so it can't do a syscall required to figure out if the path is file or directory. I think it's fine to add is_excluded_dir_entry alongside the is_excluded, which would do IO.

[vipentti]

Where should the is_excluded_dir_entry be called from ? Roots::contains ? Do we have to worry about the IO performance or should it not matter since the files are only loaded once and then watched for changes ?

[vipentti]

Couldn't we also run the check in is_excluded ?

fn is_excluded(&self, path: &RelativePath) -> bool {
    ///...

    let full_path = path.to_path(&self.path);

    /// use full_path for checking via metadata
}

In the case where we have a file without extension

[matklad]

@vipentti oh, right... Yeah, I think that'll work fine. I worry a tiny bit about making syscall there, from performance and purity point of view, but I guess we can always optimize later.

[bjorn3]

What about #[path=".abc.rs"] mod abc; or include!("abc.my_funky_ext");. I believe those will be incorrectly ignored.

[matklad]

@bjorn3 this is an intended limitation at the moment. A long term plan would be to allow the user to explicitly whitelist weird files for inclusion.

[bjorn3]

Got it.

[vipentti]

I think .abc.rs should work if path.extension() reports its extension as rs, we filter only extension-less or hidden files after checking if they are rust files

        match path.extension() {
            Some("rs") => false,
            Some(_) => true,
            // Exclude extension-less and hidden files
            None => is_extensionless_or_hidden_file(&self.path, path),
        }

[matklad]

bors r+

[bors]

Build succeeded

• rust-analyzer.ra_vfs