ci: fix build error

Author: rizsotto

.github/workflows/build_rust.yml

@@ -40,7 +40,6 @@ jobs:
           - windows-latest
           - macOS-latest
         toolchain:
-          - stable 9 months ago
           - stable
           - nightly
     runs-on: ${{ matrix.os }}

bear/src/semantic/interpreters/filter.rs

@@ -113,7 +113,11 @@ impl Filter {
                 let mut should_filter_this_source = false;
                 for variant_path in path_variants {
                     for filter in source_filters {
-                        if variant_path.starts_with(&filter.path) {
+                        // Normalize both paths for comparison to handle platform differences
+                        let normalized_variant = self.normalize_path_for_comparison(&variant_path);
+                        let normalized_filter = self.normalize_path_for_comparison(&filter.path);
+
+                        if normalized_variant.starts_with(&normalized_filter) {
                             match filter.ignore {
                                 config::Ignore::Always => {
                                     should_filter_this_source = true;
@@ -173,6 +177,22 @@ impl Filter {
         variants
     }
 
+    /// Normalizes a path for cross-platform comparison by converting to absolute form
+    /// and using consistent separators.
+    fn normalize_path_for_comparison(&self, path: &Path) -> PathBuf {
+        // Try to get the absolute path first
+        match path.canonicalize() {
+            Ok(canonical) => canonical,
+            Err(_) => {
+                // If canonicalize fails (e.g., path doesn't exist), try absolute
+                match std::path::absolute(path) {
+                    Ok(abs) => abs,
+                    Err(_) => path.to_path_buf(),
+                }
+            }
+        }
+    }
+
     /// Validates the compiler configuration.
     fn validate_compiler_configuration(
         compilers: &[config::Compiler],
@@ -707,4 +727,53 @@ mod tests {
         assert!(result_with_access_nonexisting.is_some());
         assert!(result_without_access_nonexisting.is_some());
     }
+
+    #[test]
+    fn test_cross_platform_path_normalization() {
+        use std::fs;
+        use tempfile::tempdir;
+
+        let temp_dir = tempdir().unwrap();
+        let temp_path = temp_dir.path();
+
+        // Create an existing file
+        let existing_file = temp_path.join("test.c");
+        fs::write(&existing_file, "test content").unwrap();
+
+        let compilers = vec![];
+        let sources = SourceFilter {
+            only_existing_files: true,
+            paths: vec![DirectoryFilter {
+                path: temp_path.to_path_buf(),
+                ignore: Ignore::Always,
+            }],
+        };
+
+        let filter = Filter::try_from((compilers.as_slice(), &sources))
+            .expect("Failed to create filter");
+
+        // Test with various path formats that might occur cross-platform
+        let test_cases = vec![
+            // Relative path
+            "test.c",
+            // Path with current directory reference
+            "./test.c",
+        ];
+
+        for source_file in test_cases {
+            let cmd = CompilerCommand::from_strings(
+                temp_path.to_str().unwrap(),
+                "/usr/bin/gcc",
+                vec![(ArgumentKind::Source, vec![source_file])],
+            );
+
+            let result = filter.should_filter_sources(&cmd, &filter.source_filters);
+            assert!(
+                result.is_some(),
+                "Failed to filter source file: {} in temp dir: {:?}",
+                source_file,
+                temp_path
+            );
+        }
+    }
 }