Conside include, extend-include for the native server

crates/ruff_server/Cargo.toml

@@ -28,7 +28,6 @@ ruff_workspace = { workspace = true }
 
 anyhow = { workspace = true }
 crossbeam = { workspace = true }
-globset = { workspace = true }
 jod-thread = { workspace = true }
 lsp-server = { workspace = true }
 lsp-types = { workspace = true }

crates/ruff_server/src/fix.rs

@@ -48,6 +48,20 @@ pub(crate) fn fix_all(
             return Ok(Fixes::default());
         }
 
+        if let Some(inclusion) = match_any_inclusion(
+            &document_path,
+            &file_resolver_settings.include,
+            &file_resolver_settings.extend_include,
+        ) {
+            tracing::debug!(
+                "Included path via `{}`: {}",
+                inclusion,
+                document_path.display()
+            );
+        } else {
+            return Ok(Fixes::default());
+        }
+
         detect_package_root(
             document_path
                 .parent()

crates/ruff_server/src/lint.rs

@@ -87,6 +87,20 @@ pub(crate) fn check(
             return DiagnosticsMap::default();
         }
 
+        if let Some(inclusion) = match_any_inclusion(
+            &document_path,
+            &file_resolver_settings.include,
+            &file_resolver_settings.extend_include,
+        ) {
+            tracing::debug!(
+                "Included path via `{}`: {}",
+                inclusion,
+                document_path.display()
+            );
+        } else {
+            return DiagnosticsMap::default();
+        }
+
         detect_package_root(
             document_path
                 .parent()

crates/ruff_server/src/server/api/requests/format.rs

@@ -2,7 +2,7 @@ use lsp_types::{self as types, request as req};
 use types::TextEdit;
 
 use ruff_source_file::LineIndex;
-use ruff_workspace::resolver::match_any_exclusion;
+use ruff_workspace::resolver::{match_any_exclusion, match_any_inclusion};
 
 use crate::edit::{Replacement, ToRangeExt};
 use crate::fix::Fixes;
@@ -95,6 +95,16 @@ fn format_text_document(
             tracing::debug!("Ignored path via `{}`: {}", exclusion, file_path.display());
             return Ok(None);
         }
+
+        if let Some(inclusion) = match_any_inclusion(
+            &file_path,
+            &file_resolver_settings.include,
+            &file_resolver_settings.extend_include,
+        ) {
+            tracing::debug!("Included path via `{}`: {}", inclusion, file_path.display());
+        } else {
+            return Ok(None);
+        }
     }
 
     let source = text_document.contents();

crates/ruff_server/src/server/api/requests/format_range.rs

@@ -60,6 +60,16 @@ fn format_text_document_range(
             tracing::debug!("Ignored path via `{}`: {}", exclusion, file_path.display());
             return Ok(None);
         }
+
+        if let Some(inclusion) = match_any_inclusion(
+            &file_path,
+            &file_resolver_settings.include,
+            &file_resolver_settings.extend_include,
+        ) {
+            tracing::debug!("Included path via `{}`: {}", inclusion, file_path.display());
+        } else {
+            return Ok(None);
+        }
     }
 
     let text = text_document.contents();

crates/ruff_server/src/session/index/ruff_settings.rs

@@ -1,9 +1,8 @@
-use globset::Candidate;
 use ruff_linter::{
     display_settings, fs::normalize_path_to, settings::types::FilePattern,
     settings::types::PreviewMode,
 };
-use ruff_workspace::resolver::match_candidate_exclusion;
+use ruff_workspace::resolver::match_exclusion;
 use ruff_workspace::{
     configuration::{Configuration, FormatConfiguration, LintConfiguration, RuleSelection},
     pyproject::{find_user_settings_toml, settings_toml},
@@ -41,6 +40,7 @@ impl std::fmt::Display for RuffSettings {
         display_settings! {
             formatter = f,
             fields = [
+                self.file_resolver,
                 self.linter,
                 self.formatter
             ]
@@ -146,20 +146,14 @@ impl RuffSettingsIndex {
                     .range(..directory.clone())
                     .rfind(|(path, _)| directory.starts_with(path))
                 {
-                    let candidate = Candidate::new(&directory);
-                    let basename = Candidate::new(file_name);
-                    if match_candidate_exclusion(
-                        &candidate,
-                        &basename,
-                        &settings.file_resolver.exclude,
-                    ) {
+                    if match_exclusion(&directory, file_name, &settings.file_resolver.exclude) {
                         tracing::debug!("Ignored path via `exclude`: {}", directory.display());
 
                         walker.skip_current_dir();
                         continue;
-                    } else if match_candidate_exclusion(
-                        &candidate,
-                        &basename,
+                    } else if match_exclusion(
+                        &directory,
+                        file_name,
                         &settings.file_resolver.extend_exclude,
                     ) {
                         tracing::debug!(

crates/ruff_workspace/src/resolver.rs

@@ -683,6 +683,39 @@ pub fn match_any_exclusion(
     None
 }
 
+#[derive(Debug, Copy, Clone)]
+pub enum InclusionKind {
+    /// The inclusion came from the `include` setting.
+    Include,
+    /// The inclusion came from the `extend-include` setting.
+    ExtendInclude,
+}
+
+impl std::fmt::Display for InclusionKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InclusionKind::Include => write!(f, "include"),
+            InclusionKind::ExtendInclude => write!(f, "extend-include"),
+        }
+    }
+}
+
+/// Return the [`InclusionKind`] for a given [`Path`], if the path match any of the inclusion
+/// criteria.
+pub fn match_any_inclusion(
+    path: &Path,
+    include: &GlobSet,
+    extend_include: &GlobSet,
+) -> Option<InclusionKind> {
+    if include.is_match(path) {
+        Some(InclusionKind::Include)
+    } else if extend_include.is_match(path) {
+        Some(InclusionKind::ExtendInclude)
+    } else {
+        None
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::fs::{create_dir, File};