chore: rename "effect info" to "target states info" for clarity (#1725)

Author: georgeh0

rust/core/src/engine/execution.rs

@@ -420,24 +420,24 @@ impl<'a, Prof: EngineProfile> Committer<'a, Prof> {
     fn commit(
         &mut self,
         child_path_set: Option<ChildStablePathSet>,
-        effect_info_key: &db_schema::DbEntryKey,
+        target_state_info_key: &db_schema::DbEntryKey,
         all_memo_fps: &HashSet<Fingerprint>,
         memos_without_mounts_to_store: Vec<(Fingerprint, FnCallMemo<Prof>)>,
         curr_version: Option<u64>,
     ) -> Result<()> {
-        let encoded_effect_info_key = effect_info_key.encode()?;
+        let encoded_target_state_info_key = target_state_info_key.encode()?;
         let db_env = self.component_ctx.app_ctx().env().db_env();
         {
             let mut wtxn = db_env.write_txn()?;
             if self.component_ctx.mode() == ComponentProcessingMode::Delete {
                 self.db
-                    .delete(&mut wtxn, encoded_effect_info_key.as_ref())?;
+                    .delete(&mut wtxn, encoded_target_state_info_key.as_ref())?;
             } else {
                 let curr_version = curr_version
                     .ok_or_else(|| internal_error!("curr_version is required for Build mode"))?;
                 let mut tracking_info: db_schema::StablePathEntryTrackingInfo = self
                     .db
-                    .get(&wtxn, encoded_effect_info_key.as_ref())?
+                    .get(&wtxn, encoded_target_state_info_key.as_ref())?
                     .map(|data| from_msgpack_slice(&data))
                     .transpose()?
                     .ok_or_else(|| internal_error!("tracking info not found for commit"))?;
@@ -467,7 +467,7 @@ impl<'a, Prof: EngineProfile> Committer<'a, Prof> {
                 let data_bytes = rmp_serde::to_vec_named(&tracking_info)?;
                 self.db.put(
                     &mut wtxn,
-                    encoded_effect_info_key.as_ref(),
+                    encoded_target_state_info_key.as_ref(),
                     data_bytes.as_slice(),
                 )?;
             }
@@ -820,7 +820,7 @@ pub(crate) async fn submit<Prof: EngineProfile>(
     let db_env = comp_ctx.app_ctx().env().db_env();
     let db = comp_ctx.app_ctx().db();
 
-    let effect_info_key = db_schema::DbEntryKey::StablePath(
+    let target_state_info_key = db_schema::DbEntryKey::StablePath(
         comp_ctx.stable_path().clone(),
         db_schema::StablePathEntryKey::TrackingInfo,
     );
@@ -866,7 +866,7 @@ pub(crate) async fn submit<Prof: EngineProfile>(
         }
 
         let mut tracking_info: Option<db_schema::StablePathEntryTrackingInfo> = db
-            .get(&wtxn, effect_info_key.encode()?.as_ref())?
+            .get(&wtxn, target_state_info_key.encode()?.as_ref())?
             .map(|data| from_msgpack_slice(&data))
             .transpose()?;
         let previously_exists = tracking_info.is_some();
@@ -962,9 +962,9 @@ pub(crate) async fn submit<Prof: EngineProfile>(
                             .transpose()?
                         {
                             Some(s) => {
-                                db_schema::EffectInfoItemState::Existing(Cow::Owned(s.into()))
+                                db_schema::TargetStateInfoItemState::Existing(Cow::Owned(s.into()))
                             }
-                            None => db_schema::EffectInfoItemState::Deleted,
+                            None => db_schema::TargetStateInfoItemState::Deleted,
                         },
                     ));
                 } else {
@@ -1008,13 +1008,13 @@ pub(crate) async fn submit<Prof: EngineProfile>(
                 else {
                     continue;
                 };
-                let item = db_schema::EffectInfoItem {
+                let item = db_schema::TargetStateInfoItem {
                     key: Cow::Owned(effect_key_bytes.into()),
                     states: vec![
-                        (0, db_schema::EffectInfoItemState::Deleted),
+                        (0, db_schema::TargetStateInfoItemState::Deleted),
                         (
                             curr_version,
-                            db_schema::EffectInfoItemState::Existing(new_state),
+                            db_schema::TargetStateInfoItemState::Existing(new_state),
                         ),
                     ],
                 };
@@ -1024,7 +1024,7 @@ pub(crate) async fn submit<Prof: EngineProfile>(
             let data_bytes = rmp_serde::to_vec_named(&tracking_info)?;
             db.put(
                 &mut wtxn,
-                effect_info_key.encode()?.as_ref(),
+                target_state_info_key.encode()?.as_ref(),
                 data_bytes.as_slice(),
             )?;
             Some(curr_version)
@@ -1066,7 +1066,7 @@ pub(crate) async fn submit<Prof: EngineProfile>(
     let mut committer = Committer::new(comp_ctx, &target_states_providers, demote_component_only)?;
     committer.commit(
         child_path_set,
-        &effect_info_key,
+        &target_state_info_key,
         &finalized_fn_call_memos.all_memos_fps,
         finalized_fn_call_memos.memos_without_mounts_to_store,
         curr_version,

rust/core/src/state/db_schema.rs

@@ -26,7 +26,7 @@ pub enum StablePathEntryKey {
     FunctionMemoization(Fingerprint),
 
     /// Required.
-    /// Value type: StablePathEntryEffectInfo
+    /// Value type: StablePathEntryTargetStateInfo
     TrackingInfo,
 
     ChildExistencePrefix,
@@ -205,7 +205,7 @@ pub struct FunctionMemoizationEntry<'a> {
 
 #[serde_as]
 #[derive(Serialize, Deserialize, Debug)]
-pub enum EffectInfoItemState<'a> {
+pub enum TargetStateInfoItemState<'a> {
     #[serde(rename = "D")]
     Deleted,
     #[serde(untagged)]
@@ -216,27 +216,27 @@ pub enum EffectInfoItemState<'a> {
     ),
 }
 
-impl<'a> EffectInfoItemState<'a> {
+impl<'a> TargetStateInfoItemState<'a> {
     pub fn is_deleted(&self) -> bool {
-        matches!(self, EffectInfoItemState::Deleted)
+        matches!(self, TargetStateInfoItemState::Deleted)
     }
 
     pub fn as_ref(&self) -> Option<&[u8]> {
         match self {
-            EffectInfoItemState::Deleted => None,
-            EffectInfoItemState::Existing(s) => Some(s.as_ref()),
+            TargetStateInfoItemState::Deleted => None,
+            TargetStateInfoItemState::Existing(s) => Some(s.as_ref()),
         }
     }
 }
 
 #[serde_as]
 #[derive(Serialize, Deserialize, Debug)]
-pub struct EffectInfoItem<'a> {
+pub struct TargetStateInfoItem<'a> {
     #[serde_as(as = "Bytes")]
     #[serde(rename = "P", borrow)]
     pub key: Cow<'a, [u8]>,
     #[serde(rename = "S", borrow, default, skip_serializing_if = "Vec::is_empty")]
-    pub states: Vec<(/*version*/ u64, EffectInfoItemState<'a>)>,
+    pub states: Vec<(/*version*/ u64, TargetStateInfoItemState<'a>)>,
 }
 
 pub const UNKNOWN_PROCESSOR_NAME: &'static str = "<unknown>";
@@ -250,7 +250,7 @@ pub struct StablePathEntryTrackingInfo<'a> {
     #[serde(rename = "V")]
     pub version: u64,
     #[serde(rename = "I", borrow)]
-    pub effect_items: BTreeMap<TargetStatePath, EffectInfoItem<'a>>,
+    pub effect_items: BTreeMap<TargetStatePath, TargetStateInfoItem<'a>>,
     #[serde(rename = "N", borrow, default = "unknown_processor_name")]
     pub processor_name: Cow<'a, str>,
 }