grep tool: Warn when no file matches match include pattern

crates/assistant_tools/src/grep_tool.rs

@@ -173,7 +173,17 @@ impl Tool for GrepTool {
             let mut matches_found = 0;
             let mut has_more_matches = false;
 
-            'outer: while let Some(SearchResult::Buffer { buffer, ranges }) = results.next().await {
+            let mut any_file_matched_pattern = false;
+            'outer: while let Some(result) = results.next().await {
+                let (buffer, ranges) = match result {
+                    SearchResult::Buffer { buffer, ranges } => {
+                        (buffer,ranges)
+                    }
+                    SearchResult::Finished { any_file_matched_pattern: matched, .. } => {
+                        any_file_matched_pattern = matched;
+                        break 'outer;
+                    }
+                };
                 if ranges.is_empty() {
                     continue;
                 }
@@ -294,7 +304,10 @@ impl Tool for GrepTool {
                 }
             }
 
-            if matches_found == 0 {
+            if !any_file_matched_pattern && input.include_pattern.is_some() {
+                assert_eq!(matches_found, 0, "no matches must be found if any file didn't match");
+                Ok("No files found matching the include pattern".to_string().into())
+            } else if matches_found == 0 {
                 Ok("No matches found".to_string().into())
             } else if has_more_matches {
                 Ok(format!(

crates/collab/src/tests/integration_tests.rs

@@ -5185,10 +5185,15 @@ async fn test_project_search(
             SearchResult::Buffer { buffer, ranges } => {
                 results.entry(buffer).or_insert(ranges);
             }
-            SearchResult::LimitReached => {
-                panic!(
+            SearchResult::Finished {
+                limit_reached,
+                any_file_matched_pattern,
+            } => {
+                assert!(
+                    !limit_reached,
                     "Unexpectedly reached search limit in tests. If you do want to assert limit-reached, change this panic call."
-                )
+                );
+                assert!(any_file_matched_pattern);
             }
         };
     }

crates/project/src/project.rs

@@ -3841,6 +3841,7 @@ impl Project {
             let mut range_count = 0;
             let mut buffer_count = 0;
             let mut limit_reached = false;
+            let mut any_file_matched_pattern = false;
             let query = Arc::new(query);
             let chunks = matching_buffers_rx.ready_chunks(64);
 
@@ -3850,6 +3851,9 @@ impl Project {
             // ranges in the buffer matched by the query.
             let mut chunks = pin!(chunks);
             'outer: while let Some(matching_buffer_chunk) = chunks.next().await {
+                if !matching_buffer_chunk.is_empty() {
+                    any_file_matched_pattern = true;
+                }
                 let mut chunk_results = Vec::with_capacity(matching_buffer_chunk.len());
                 for buffer in matching_buffer_chunk {
                     let query = query.clone();
@@ -3886,9 +3890,12 @@ impl Project {
                 }
             }
 
-            if limit_reached {
-                result_tx.send(SearchResult::LimitReached).await?;
-            }
+            result_tx
+                .send(SearchResult::Finished {
+                    limit_reached,
+                    any_file_matched_pattern,
+                })
+                .await?;
 
             anyhow::Ok(())
         })

crates/project/src/project_tests.rs

@@ -8892,7 +8892,7 @@ async fn search(
             SearchResult::Buffer { buffer, ranges } => {
                 results.entry(buffer).or_insert(ranges);
             }
-            SearchResult::LimitReached => {}
+            SearchResult::Finished { .. } => {}
         }
     }
     Ok(results

crates/project/src/search.rs

@@ -21,7 +21,10 @@ pub enum SearchResult {
         buffer: Entity<Buffer>,
         ranges: Vec<Range<Anchor>>,
     },
-    LimitReached,
+    Finished {
+        limit_reached: bool,
+        any_file_matched_pattern: bool,
+    },
 }
 
 #[derive(Clone, Copy, PartialEq)]

crates/remote_server/src/remote_editing_tests.rs

@@ -222,6 +222,13 @@ async fn test_remote_project_search(cx: &mut TestAppContext, server_cx: &mut Tes
             )
         });
 
+        let SearchResult::Finished {
+            limit_reached: false,
+            any_file_matched_pattern: true,
+        } = receiver.recv().await.unwrap()
+        else {
+            panic!("invalid finisher");
+        };
         assert!(receiver.recv().await.is_err());
         buffer
     }

crates/search/src/project_search.rs

@@ -329,8 +329,11 @@ impl ProjectSearch {
                         project::search::SearchResult::Buffer { buffer, ranges } => {
                             buffers_with_ranges.push((buffer, ranges));
                         }
-                        project::search::SearchResult::LimitReached => {
-                            limit_reached = true;
+                        project::search::SearchResult::Finished {
+                            limit_reached: reached,
+                            ..
+                        } => {
+                            limit_reached = reached;
                         }
                     }
                 }