feat(cli): allow explicit extension names to override --baseline exclusion

When --extensions combines "all" with specific names (e.g.
--extensions all,GL_ARB_texture_compression), the named extensions
are treated as keep-alive pins that survive --baseline exclusion.

New `keep` field on ExtensionFilter captures names listed alongside
"all". The resolver checks this set before applying baseline
exclusion. The `-` prefix exclusion remains unconditional and
overrides keep.

Precedence: -Foo (always excluded) > Foo (keep, survives baseline)
> baseline (excluded unless kept).

Signed-off-by: Steven Noonan <steven@uplinklabs.net>

Author: tycho

src/cli.rs

@@ -138,10 +138,18 @@ impl Cli {
             }
         }
 
-        let include = if include_all { None } else { Some(includes) };
+        // When "all" is combined with explicit names, the explicit names act as
+        // baseline-override pins — they survive --baseline exclusion even though
+        // "all" means we don't use them for initial inclusion filtering.
+        let (include, keep) = if include_all {
+            (None, includes.into_iter().collect())
+        } else {
+            (Some(includes), HashSet::new())
+        };
         Ok(ExtensionFilter {
             include,
             exclude: excludes,
+            keep,
         })
     }
 
@@ -166,10 +174,14 @@ impl Cli {
 /// `exclude` is always a set of names to unconditionally remove — applied as a
 /// final veto after all selection passes (explicit, dependency, promoted,
 /// predecessor, baseline).
+/// `keep` is a set of names that override baseline exclusion — used when the
+/// user writes `--extensions all,GL_ARB_foo` to pin specific extensions even
+/// if they'd otherwise be excluded by --baseline.
 #[derive(Debug)]
 pub struct ExtensionFilter {
     pub include: Option<Vec<String>>,
     pub exclude: HashSet<String>,
+    pub keep: HashSet<String>,
 }
 
 impl ExtensionFilter {
@@ -178,6 +190,7 @@ impl ExtensionFilter {
         Self {
             include: None,
             exclude: HashSet::new(),
+            keep: HashSet::new(),
         }
     }
 }

src/resolve.rs

@@ -1134,14 +1134,40 @@ fn select_extensions<'a>(
     }
 
     // Build unified exclude set and apply.
-    let has_excludes = !explicit_excludes.is_empty() || !baseline_excludes.is_empty();
-    if has_excludes {
+    // Explicit includes override baseline exclusion — if you name an extension
+    // in --extensions (either as the sole include list, or alongside "all" as
+    // a keep-alive pin), you want it even if it's promoted into baseline.
+    // The `-` prefix exclusion is unconditional and overrides everything.
+    let explicit_keeps: HashSet<&str> = {
+        let mut keeps: HashSet<&str> = filter.keep.iter().map(String::as_str).collect();
+        // When include is Some (explicit list, no "all"), every listed name
+        // is an explicit request that should survive baseline exclusion.
+        if let Some(ref list) = filter.include {
+            keeps.extend(list.iter().map(String::as_str));
+        }
+        keeps
+    };
+
+    if !explicit_excludes.is_empty() || !baseline_excludes.is_empty() {
         selected.retain(|e| {
-            !explicit_excludes.contains(e.raw.name.as_str())
-                && !baseline_excludes.contains(&e.raw.name)
+            let name = e.raw.name.as_str();
+            // `-` prefix exclusions are unconditional.
+            if explicit_excludes.contains(name) {
+                return false;
+            }
+            // Baseline exclusions can be overridden by explicit inclusion.
+            if baseline_excludes.contains(&e.raw.name) && !explicit_keeps.contains(name) {
+                return false;
+            }
+            true
         });
     }
 
+    // Remove kept extensions from baseline_excludes for accurate reporting.
+    if !explicit_keeps.is_empty() {
+        baseline_excludes.retain(|name| !explicit_keeps.contains(name.as_str()));
+    }
+
     // Collect the names that were actually excluded (intersection of what was
     // selected before the veto with the exclude sets).
     let excluded_explicit: Vec<String> = filter.exclude.iter().cloned().collect();