fix(filter): validate package name on full graph (#9102)

### Description

Fixes #9096

The issue was that the validation was run against an already filtered
set of packages if another selector was provided i.e. `--filter
foo[commit]` the name filter `foo` would run against only packages that
were changed since `commit`. This meant that `foo` would be incorrectly
reported as not existing.

This PR changes so the package existence check is run against all
packages in the graph instead of an already filtered set.

### Testing Instructions

Added red->green unit test


Verify that this PR correctly handles the repro provided in #9096 
```
[1 olszewski@chriss-mbp] /tmp/turbo-filter-break $ turbo_dev --skip-infer run lint '--filter=...@repo/eslint-config[HEAD~1]' 
turbo 2.1.1

• Packages in scope: 
• Running lint in 0 packages
• Remote caching disabled

No tasks were executed as part of this run.

 Tasks:    0 successful, 0 total
Cached:    0 cached, 0 total
  Time:    75ms
```

Author: chris-olszewski

crates/turborepo-lib/src/run/scope/filter.rs

@@ -392,7 +392,7 @@ impl<'a, T: GitChangeDetector> FilterResolver<'a, T> {
 
         // if we have a filter, use it to filter the entry packages
         let filtered_entry_packages = if !selector.name_pattern.is_empty() {
-            match_package_names(&selector.name_pattern, entry_packages)?
+            match_package_names(&selector.name_pattern, &self.all_packages(), entry_packages)?
         } else {
             entry_packages
         };
@@ -520,17 +520,12 @@ impl<'a, T: GitChangeDetector> FilterResolver<'a, T> {
 
         if !selector.name_pattern.is_empty() {
             if !selector_valid {
-                entry_packages = self.match_package_names_to_vertices(
-                    &selector.name_pattern,
-                    self.pkg_graph
-                        .packages()
-                        .map(|(name, _)| name.to_owned())
-                        .collect(),
-                )?;
+                entry_packages = self.all_packages();
                 selector_valid = true;
-            } else {
-                entry_packages = match_package_names(&selector.name_pattern, entry_packages)?;
             }
+            let all_packages = self.all_packages();
+            entry_packages =
+                match_package_names(&selector.name_pattern, &all_packages, entry_packages)?;
         }
 
         // if neither a name pattern, parent dir, or from ref is provided, then
@@ -556,15 +551,14 @@ impl<'a, T: GitChangeDetector> FilterResolver<'a, T> {
         )
     }
 
-    fn match_package_names_to_vertices(
-        &self,
-        name_pattern: &str,
-        mut entry_packages: HashSet<PackageName>,
-    ) -> Result<HashSet<PackageName>, ResolutionError> {
-        // add the root package to the entry packages
-        entry_packages.insert(PackageName::Root);
-
-        match_package_names(name_pattern, entry_packages)
+    fn all_packages(&self) -> HashSet<PackageName> {
+        let mut packages = self
+            .pkg_graph
+            .packages()
+            .map(|(name, _)| name.to_owned())
+            .collect::<HashSet<_>>();
+        packages.insert(PackageName::Root);
+        packages
     }
 }
 
@@ -574,21 +568,26 @@ impl<'a, T: GitChangeDetector> FilterResolver<'a, T> {
 /// the pattern is normalized, replacing `\*` with `.*`
 fn match_package_names(
     name_pattern: &str,
-    mut entry_packages: HashSet<PackageName>,
+    all_packages: &HashSet<PackageName>,
+    mut packages: HashSet<PackageName>,
 ) -> Result<HashSet<PackageName>, ResolutionError> {
     let matcher = SimpleGlob::new(name_pattern)?;
-    let matched_packages = entry_packages
-        .extract_if(|e| matcher.is_match(e.as_ref()))
+    let matched_packages = all_packages
+        .iter()
+        .filter(|e| matcher.is_match(e.as_ref()))
+        .cloned()
         .collect::<HashSet<_>>();
 
     // If the pattern was an exact name and it matched no packages, then error
     if matcher.is_exact() && matched_packages.is_empty() {
-        Err(ResolutionError::NoPackagesMatchedWithName(
+        return Err(ResolutionError::NoPackagesMatchedWithName(
             name_pattern.to_owned(),
-        ))
-    } else {
-        Ok(matched_packages)
+        ));
     }
+
+    packages.retain(|pkg| matched_packages.contains(pkg));
+
+    Ok(packages)
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -628,6 +627,7 @@ pub enum ResolutionError {
 mod test {
     use std::collections::{HashMap, HashSet};
 
+    use pretty_assertions::assert_eq;
     use tempfile::TempDir;
     use test_case::test_case;
     use turbopath::{AbsoluteSystemPathBuf, AnchoredSystemPathBuf, RelativeUnixPathBuf};
@@ -1206,6 +1206,17 @@ mod test {
         &["package-1", "package-2"] ;
         "match dependency subtree"
     )]
+    #[test_case(
+        vec![
+            TargetSelector {
+                name_pattern: "package-3".to_string(),
+                git_range: Some(GitRange { from_ref: Some("HEAD~1".to_string()), to_ref: None, ..Default::default() }),
+                ..Default::default()
+            }
+        ],
+        &[] ;
+        "gh 9096"
+    )]
     fn scm(selectors: Vec<TargetSelector>, expected: &[&str]) {
         let scm_resolver = TestChangeDetector::new(&[
             ("HEAD~1", None, &["package-1", "package-2", ROOT_PKG_NAME]),

crates/turborepo-lib/src/run/scope/target_selector.rs

@@ -234,6 +234,7 @@ pub fn is_selector_by_location(
 mod test {
     use std::str::FromStr;
 
+    use pretty_assertions::assert_eq;
     use test_case::test_case;
     use turbopath::AnchoredSystemPathBuf;
 
@@ -263,6 +264,7 @@ mod test {
     #[test_case("foo...[master]", TargetSelector { raw: "foo...[master]".to_string(), git_range: Some(GitRange { from_ref: Some("master".to_string()), to_ref: None, include_uncommitted: true, ..Default::default() }), name_pattern: "foo".to_string(), match_dependencies: true, ..Default::default() }; "foo...[master]")]
     #[test_case("foo...[master]...", TargetSelector { raw: "foo...[master]...".to_string(), git_range: Some(GitRange { from_ref: Some("master".to_string()), to_ref: None, include_uncommitted: true, ..Default::default() }), name_pattern: "foo".to_string(), match_dependencies: true, include_dependencies: true, ..Default::default() }; "foo...[master] dot dot dot")]
     #[test_case("{foo}...[master]", TargetSelector { raw: "{foo}...[master]".to_string(), git_range: Some(GitRange { from_ref: Some("master".to_string()), to_ref: None, include_uncommitted: true, ..Default::default() }), parent_dir: Some(AnchoredSystemPathBuf::try_from("foo").unwrap()), match_dependencies: true, ..Default::default() }; " curly brackets foo...[master]")]
+    #[test_case("...@repo/pkg[master]", TargetSelector { raw: "...@repo/pkg[master]".to_string(), git_range: Some(GitRange { from_ref: Some("master".to_string()), to_ref: None, include_uncommitted: true, ..Default::default() }), name_pattern: "@repo/pkg".to_string(), include_dependents: true, ..Default::default() }; "gh 9096")]
     fn parse_target_selector(raw_selector: &str, want: TargetSelector) {
         let result = TargetSelector::from_str(raw_selector);