Merge d3ab9c3 into 1f41051

src/rust/engine/fs/src/lib.rs

@@ -322,7 +322,7 @@ impl GitignoreStyleExcludes {
   }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, Hash, PartialEq)]
 pub enum StrictGlobMatching {
   // NB: the Error and Warn variants store a description of the origin of the PathGlob
   // request so that we can make the error message more helpful to users when globs fail to match.
@@ -366,7 +366,7 @@ impl StrictGlobMatching {
   }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, Hash, PartialEq)]
 pub enum GlobExpansionConjunction {
   AllMatch,
   AnyMatch,
@@ -388,7 +388,7 @@ pub enum SymlinkBehavior {
   Oblivious,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct PathGlobs {
   globs: Vec<String>,
   strict_match_behavior: StrictGlobMatching,
@@ -417,6 +417,12 @@ impl PathGlobs {
   }
 }
 
+impl fmt::Display for PathGlobs {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    write!(f, "{}", self.globs.join(", "))
+  }
+}
+
 ///
 /// All Stats consumed or returned by this type are relative to the root.
 ///

src/rust/engine/src/externs/interface.rs

@@ -1326,7 +1326,7 @@ fn match_path_globs(
 ) -> CPyResult<Vec<String>> {
   let matches = py
     .allow_threads(|| {
-      let path_globs = nodes::Snapshot::lift_path_globs(&path_globs.into())?;
+      let path_globs = nodes::Snapshot::lift_prepared_path_globs(&path_globs.into())?;
 
       Ok(
         paths
@@ -1359,8 +1359,10 @@ fn capture_snapshots(
     .iter()
     .map(|value| {
       let root = PathBuf::from(externs::project_str(&value, "root"));
-      let path_globs =
-        nodes::Snapshot::lift_path_globs(&externs::project_ignoring_type(&value, "path_globs"));
+      let path_globs = nodes::Snapshot::lift_prepared_path_globs(&externs::project_ignoring_type(
+        &value,
+        "path_globs",
+      ));
       let digest_hint = {
         let maybe_digest = externs::project_ignoring_type(&value, "digest_hint");
         if maybe_digest == Value::from(externs::none()) {

src/rust/engine/src/intrinsics.rs

@@ -303,8 +303,10 @@ fn path_globs_to_digest(
 ) -> BoxFuture<'static, NodeResult<Value>> {
   let core = context.core.clone();
   async move {
-    let key = externs::acquire_key_for(args.pop().unwrap())?;
-    let digest = context.get(Snapshot(key)).await?;
+    let val = args.pop().unwrap();
+    let path_globs = Snapshot::lift_path_globs(&val)
+      .map_err(|e| throw(&format!("Failed to parse PathGlobs: {}", e)))?;
+    let digest = context.get(Snapshot::from_path_globs(path_globs)).await?;
     Ok(Snapshot::store_directory_digest(&core, &digest))
   }
   .boxed()
@@ -369,7 +371,7 @@ fn digest_subset_to_digest(
   let store = context.core.store();
 
   async move {
-    let path_globs = Snapshot::lift_path_globs(&globs).map_err(|e| throw(&e))?;
+    let path_globs = Snapshot::lift_prepared_path_globs(&globs).map_err(|e| throw(&e))?;
     let original_digest =
       lift_digest(&externs::project_ignoring_type(&args[0], "digest")).map_err(|e| throw(&e))?;
     let subset_params = SubsetParams { globs: path_globs };

src/rust/engine/src/nodes.rs

@@ -529,7 +529,7 @@ impl WrappedNode for Paths {
   type Item = Arc<Vec<PathStat>>;
 
   async fn run_wrapped_node(self, context: Context) -> NodeResult<Arc<Vec<PathStat>>> {
-    let path_globs = Snapshot::lift_path_globs(&externs::val_for(&self.0))
+    let path_globs = Snapshot::lift_prepared_path_globs(&externs::val_for(&self.0))
       .map_err(|e| throw(&format!("Failed to parse PathGlobs: {}", e)))?;
     let path_stats = Self::create(context, path_globs).await?;
     Ok(Arc::new(path_stats))
@@ -545,10 +545,15 @@ impl From<Paths> for NodeKey {
 ///
 /// A Node that captures an store::Snapshot for a PathGlobs subject.
 ///
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub struct Snapshot(pub Key);
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Snapshot {
+  path_globs: PathGlobs,
+}
 
 impl Snapshot {
+  pub fn from_path_globs(path_globs: PathGlobs) -> Snapshot {
+    Snapshot { path_globs }
+  }
   async fn create(context: Context, path_globs: PreparedPathGlobs) -> NodeResult<store::Snapshot> {
     // We rely on Context::expand_globs tracking dependencies for scandirs,
     // and store::Snapshot::from_path_stats tracking dependencies for file digests.
@@ -561,7 +566,7 @@ impl Snapshot {
       .await
   }
 
-  pub fn lift_path_globs(item: &Value) -> Result<PreparedPathGlobs, String> {
+  pub fn lift_path_globs(item: &Value) -> Result<PathGlobs, String> {
     let globs = externs::project_multi_strs(item, "globs");
 
     let description_of_origin_field = externs::project_str(item, "description_of_origin");
@@ -580,10 +585,14 @@ impl Snapshot {
     let conjunction_obj = externs::project_ignoring_type(item, "conjunction");
     let conjunction_string = externs::project_str(&conjunction_obj, "value");
     let conjunction = GlobExpansionConjunction::create(&conjunction_string)?;
+    Ok(PathGlobs::new(globs, strict_glob_matching, conjunction))
+  }
 
-    PathGlobs::new(globs.clone(), strict_glob_matching, conjunction)
+  pub fn lift_prepared_path_globs(item: &Value) -> Result<PreparedPathGlobs, String> {
+    let path_globs = Snapshot::lift_path_globs(item)?;
+    path_globs
       .parse()
-      .map_err(|e| format!("Failed to parse PathGlobs for globs({:?}): {}", globs, e))
+      .map_err(|e| format!("Failed to parse PathGlobs for globs({:?}): {}", item, e))
   }
 
   pub fn store_directory_digest(core: &Arc<Core>, item: &hashing::Digest) -> Value {
@@ -655,8 +664,7 @@ impl WrappedNode for Snapshot {
   type Item = Digest;
 
   async fn run_wrapped_node(self, context: Context) -> NodeResult<Digest> {
-    let path_globs = Self::lift_path_globs(&externs::val_for(&self.0))
-      .map_err(|e| throw(&format!("Failed to parse PathGlobs: {}", e)))?;
+    let path_globs = self.path_globs.parse().map_err(|e| throw(&e))?;
     let snapshot = Self::create(context, path_globs).await?;
     Ok(snapshot.digest)
   }
@@ -1113,7 +1121,7 @@ impl NodeKey {
   fn user_facing_name(&self) -> Option<String> {
     match self {
       NodeKey::Task(ref task) => task.task.display_info.desc.as_ref().map(|s| s.to_owned()),
-      NodeKey::Snapshot(ref s) => Some(format!("Snapshotting: {}", s.0)),
+      NodeKey::Snapshot(ref s) => Some(format!("Snapshotting: {}", s.path_globs)),
       NodeKey::Paths(ref s) => Some(format!("Finding files: {}", s.0)),
       NodeKey::MultiPlatformExecuteProcess(mp_epr) => Some(mp_epr.0.user_facing_name()),
       NodeKey::DigestFile(DigestFile(File { path, .. })) => {
@@ -1309,7 +1317,7 @@ impl Display for NodeKey {
         // could get gigantic.
         write!(f, "@rule({})", task.task.display_info.name)
       }
-      &NodeKey::Snapshot(ref s) => write!(f, "Snapshot({})", s.0),
+      &NodeKey::Snapshot(ref s) => write!(f, "Snapshot({})", s.path_globs),
       &NodeKey::Paths(ref s) => write!(f, "Paths({})", s.0),
     }
   }