cargo-rail: fixing the features/configs in unify... I think we've done it!

loadingalias · loadingalias · commit 06d01d2d8122 · 2025-11-22T02:42:17.000-05:00
diff --git a/src/cargo/manifest.rs b/src/cargo/manifest.rs
@@ -290,6 +290,23 @@ impl CargoTransform {
     // Write each unified dependency
     // Group by target (None for regular deps, Some(target) for platform-specific)
     for unified in unified_deps {
+      if unified.name == "reqwest" {
+        use std::io::Write;
+        let _ = std::fs::OpenOptions::new()
+          .create(true)
+          .write(true)
+          .truncate(true)
+          .open("/tmp/rail-write-ws.log")
+          .and_then(|mut f| {
+            writeln!(
+              f,
+              "[write_workspace_dependencies] Processing reqwest with {} features: {:?}",
+              unified.features.len(),
+              unified.features
+            )
+          });
+      }
+
       // Determine which table to write to based on target
       let deps_table = if let Some(ref target) = unified.target {
         // Platform-specific dependency: write to [workspace.target.'<target>'.dependencies]
@@ -363,6 +380,21 @@ impl CargoTransform {
 
         // Add features if any (inline arrays for <10 features)
         if !unified.features.is_empty() {
+          if unified.name == "reqwest" {
+            use std::io::Write;
+            let _ = std::fs::OpenOptions::new()
+              .create(true)
+              .write(true)
+              .truncate(true)
+              .open("/tmp/rail-manifest.log")
+              .and_then(|mut f| {
+                writeln!(
+                  f,
+                  "[manifest write] reqwest features being written: {:?}",
+                  unified.features
+                )
+              });
+          }
           let mut features_array = Array::new();
           for feature in &unified.features {
             features_array.push(feature.as_str());
@@ -389,6 +421,22 @@ impl CargoTransform {
         // Complex dependency with features - use regular table format
         let mut dep_table = table();
 
+        if unified.name == "reqwest" {
+          use std::io::Write;
+          let _ = std::fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open("/tmp/rail-manifest.log")
+            .and_then(|mut f| {
+              writeln!(
+                f,
+                "[manifest write REGULAR TABLE] reqwest features being written: {:?}",
+                unified.features
+              )
+            });
+        }
+
         // INVISIBLE FEATURE: Support workspace member path dependencies
         if let Some(ref path) = unified.path {
           dep_table["path"] = toml_edit::value(path.to_string());
diff --git a/src/cargo/metadata.rs b/src/cargo/metadata.rs
@@ -138,20 +138,123 @@ impl WorkspaceMetadata {
   /// For external packages that appear in multiple versions, returns features
   /// for the first resolved version found.
   pub fn get_resolved_features_for_package(&self, pkg_name: &str) -> Option<HashSet<String>> {
+    if pkg_name == "reqwest" {
+      println!("\n\n=== REQWEST DEBUG START ===");
+      println!("[ENTRY] get_resolved_features_for_package called for reqwest");
+    }
+
     let resolve = self.resolve()?;
 
+    if pkg_name == "reqwest" {
+      println!("[RESOLVE] Got resolve graph with {} nodes", resolve.nodes.len());
+    }
+
     // Find all resolved nodes for this package name
     for node in &resolve.nodes {
-      if let Some(pkg) = self.find_package_by_id(&node.id) {
+      // Debug log to see if we're iterating nodes for reqwest
+      if pkg_name == "reqwest" && node.id.repr.contains("reqwest") {
+        use std::io::Write;
+        let _ = std::fs::OpenOptions::new()
+          .create(true)
+          .append(true)
+          .open("/tmp/rail-get-resolved.log")
+          .and_then(|mut f| writeln!(f, "[LOOP] Found node with id: {}", node.id.repr));
+      }
+
+      let found_pkg = self.find_package_by_id(&node.id);
+      if pkg_name == "reqwest" && node.id.repr.contains("reqwest") {
+        use std::io::Write;
+        let _ = std::fs::OpenOptions::new()
+          .create(true)
+          .append(true)
+          .open("/tmp/rail-get-resolved.log")
+          .and_then(|mut f| {
+            writeln!(
+              f,
+              "[FIND] find_package_by_id for {} returned: {}",
+              node.id.repr,
+              found_pkg.is_some()
+            )
+          });
+      }
+
+      if let Some(pkg) = found_pkg {
         // Skip workspace members - we only want external packages
         if self.get_package(&pkg.name).is_some() {
+          if pkg_name == "reqwest" {
+            use std::io::Write;
+            let _ = std::fs::OpenOptions::new()
+              .create(true)
+              .append(true)
+              .open("/tmp/rail-get-resolved.log")
+              .and_then(|mut f| writeln!(f, "[SKIP] Skipping workspace member: {}", pkg.name));
+          }
           continue;
         }
 
         // Check if this is the package we're looking for
         if pkg.name == pkg_name {
-          // Return the resolved features for this package
-          return Some(node.features.iter().map(|f| f.to_string()).collect());
+          // IMPORTANT: Filter node.features to only include features that actually exist
+          // in the package's features table. Cargo's resolve graph includes activated
+          // optional dependencies in node.features, but these aren't always user-facing
+          // features (especially with the new "dep:" syntax in Cargo features).
+          //
+          // For example, reqwest 0.12 has `__rustls = ["dep:hyper-rustls", ...]`
+          // Cargo will list "hyper-rustls" in node.features when that dep is activated,
+          // but "hyper-rustls" is NOT in reqwest's features table, so it can't be
+          // specified in a Cargo.toml features array.
+
+          if pkg_name == "reqwest" {
+            use std::io::Write;
+            let _ = std::fs::OpenOptions::new()
+              .create(true)
+              .append(true)
+              .open("/tmp/rail-get-resolved.log")
+              .and_then(|mut f| {
+                writeln!(f, "\n[get_resolved_features_for_package] Processing reqwest")?;
+                writeln!(f, "  node.features (raw): {:?}", node.features)?;
+                writeln!(
+                  f,
+                  "  pkg.features.keys(): {:?}",
+                  pkg.features.keys().collect::<Vec<_>>()
+                )
+              });
+          }
+
+          let valid_features: HashSet<String> = node
+            .features
+            .iter()
+            .filter(|feature_name| {
+              let is_valid = pkg.features.contains_key(feature_name.as_str());
+              if pkg_name == "reqwest" {
+                use std::io::Write;
+                let _ = std::fs::OpenOptions::new()
+                  .create(true)
+                  .append(true)
+                  .open("/tmp/rail-get-resolved.log")
+                  .and_then(|mut file| {
+                    if !is_valid {
+                      writeln!(file, "  [FILTER] Removing '{}' - not in features table", feature_name)
+                    } else {
+                      writeln!(file, "  [KEEP] '{}' - in features table", feature_name)
+                    }
+                  });
+              }
+              is_valid
+            })
+            .map(|f| f.to_string())
+            .collect();
+
+          if pkg_name == "reqwest" {
+            use std::io::Write;
+            let _ = std::fs::OpenOptions::new()
+              .create(true)
+              .append(true)
+              .open("/tmp/rail-get-resolved.log")
+              .and_then(|mut f| writeln!(f, "  valid_features (after filter): {:?}\n", valid_features));
+          }
+
+          return Some(valid_features);
         }
       }
     }
diff --git a/src/cargo/unify/collector.rs b/src/cargo/unify/collector.rs
@@ -3,7 +3,7 @@
 use super::path_handling::is_workspace_member_path;
 use super::types::{DependencyInstance, FeatureSource};
 use crate::cargo::WorkspaceMetadata;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 /// Collect all dependency instances from workspace members
 ///
@@ -17,14 +17,7 @@ pub fn collect_dependencies(metadata: &WorkspaceMetadata, use_all_features: bool
   let mut instances = Vec::new();
 
   for pkg in metadata.list_crates() {
-    // Check which dependencies in this member use workspace = true
-    let workspace_inherited = get_member_workspace_deps(&pkg.manifest_path);
-
     for dep in &pkg.dependencies {
-      // Skip dependencies that are already using workspace inheritance in THIS member
-      if workspace_inherited.contains(&dep.name) {
-        continue;
-      }
       // Get RESOLVED features if available, fallback to declared features
       // Resolved features include:
       // 1. Features declared in this member's Cargo.toml
@@ -92,37 +85,6 @@ pub fn group_by_name(
   grouped
 }
 
-/// Get dependencies that use workspace = true in a member's Cargo.toml
-fn get_member_workspace_deps(manifest_path: &cargo_metadata::camino::Utf8Path) -> HashSet<String> {
-  let mut workspace_deps = HashSet::new();
-
-  if let Ok(content) = std::fs::read_to_string(manifest_path.as_std_path())
-    && let Ok(doc) = content.parse::<toml_edit::DocumentMut>()
-  {
-    // Check all dependency sections
-    for section in &["dependencies", "dev-dependencies", "build-dependencies"] {
-      if let Some(deps) = doc.get(section).and_then(|d| d.as_table()) {
-        for (key, value) in deps.iter() {
-          // Check if this dep uses workspace = true
-          let uses_workspace = if let Some(inline_table) = value.as_inline_table() {
-            inline_table.get("workspace").and_then(|w| w.as_bool()) == Some(true)
-          } else if let Some(table) = value.as_table() {
-            table.get("workspace").and_then(|w| w.as_bool()) == Some(true)
-          } else {
-            false
-          };
-
-          if uses_workspace {
-            workspace_deps.insert(key.to_string());
-          }
-        }
-      }
-    }
-  }
-
-  workspace_deps
-}
-
 /// Determine WHY each feature is enabled for a dependency
 ///
 /// This is the key to showing users Cargo.toml-level information about their dependencies.
diff --git a/src/cargo/unify/unifier.rs b/src/cargo/unify/unifier.rs
@@ -20,7 +20,55 @@ pub fn unify_instances(
   for instance in instances {
     all_features.extend(instance.features.iter().cloned());
   }
-  let mut features: Vec<_> = all_features.into_iter().collect();
+
+  if dep_name == "reqwest" {
+    println!("\n==== REQWEST DEBUG ====");
+    println!("all_features from instances: {:?}", all_features);
+  }
+
+  // Get package info to determine which features are explicitly defined
+  let pkg_info = metadata
+    .metadata_json()
+    .packages
+    .iter()
+    .find(|pkg| pkg.name == dep_name);
+
+  let (explicit_features, optional_deps): (HashSet<String>, HashSet<String>) = if let Some(pkg) = pkg_info {
+    let explicit = pkg.features.keys().cloned().collect();
+    let optional = pkg
+      .dependencies
+      .iter()
+      .filter(|dep| dep.optional)
+      .map(|dep| dep.name.clone())
+      .collect();
+    (explicit, optional)
+  } else {
+    (HashSet::new(), HashSet::new())
+  };
+
+  if dep_name == "reqwest" {
+    println!("explicit_features: {:?}", explicit_features);
+    println!("optional_deps: {:?}", optional_deps);
+  }
+
+  // Filter out:
+  // 1. Internal/private features (starting with __)
+  // 2. Names that are ONLY optional dependencies (not explicitly defined as features)
+  //    Example: "hyper-rustls" is an optional dep without a matching feature
+  //    Counter-example: "tokio" is both an optional dep AND an explicit feature (keep it)
+  let mut features: Vec<_> = all_features
+    .into_iter()
+    .filter(|f| {
+      if f.starts_with("__") {
+        return false; // Filter out internal features
+      }
+      // If it's an optional dependency name, only keep it if it's also an explicit feature
+      if optional_deps.contains(f) {
+        return explicit_features.contains(f);
+      }
+      true // Keep all other features
+    })
+    .collect();
   features.sort();
 
   // Feature provenance: collect ALL sources for each feature across instances
