Rename context_for_key to string_tag

Summary:
Next diff writes these to error_tags and not just category keys so giving them a better name.

Using a struct with a String and not just a bare String in order to potentially add TagMetadata for string tags later.

Reviewed By: iguridi

Differential Revision: D71156098

fbshipit-source-id: eeca8f7c24f8958c74f580e119a74266785187fd

Author: christolliday

app/buck2_client_ctx/src/subscribers/classify_server_stderr.rs

@@ -41,7 +41,7 @@ pub(crate) fn classify_server_stderr(
 
     let error = if let Some(trace) = extract_trace(stderr) {
         if tag != ErrorTag::ServerSigterm {
-            error.context_for_key(&format!("crash({})", trace.trace_key()))
+            error.string_tag(&format!("crash({})", trace.trace_key()))
         } else if let Some(signal_line) = trace.signal_line {
             // Keep this because the PID that (might have) sent it could be useful.
             // *** Signal 15 (SIGTERM) (0x2b08100000ab5) received by PID 1762297 (pthread TID 0x7f6650339640) (linux TID 1762297) (maybe from PID 2741, UID 176257) (code: 0), stack trace: ***

app/buck2_error/src/context_value.rs

@@ -19,9 +19,13 @@ pub enum ContextValue {
     Dyn(Arc<str>),
     Tags(SmallVec<[crate::ErrorTag; 1]>),
     Typed(Arc<dyn TypedContext>),
-    // Stable value for category key
-    Key(Arc<str>),
     StarlarkError(StarlarkContext),
+    StringTag(StringTag),
+}
+
+#[derive(allocative::Allocative, Debug, Clone, Eq, PartialEq)]
+pub struct StringTag {
+    pub tag: String,
 }
 
 impl ContextValue {
@@ -31,7 +35,7 @@ impl ContextValue {
             Self::Dyn(..) => true,
             Self::Typed(e) => e.should_display(),
             Self::Tags(_) => false,
-            Self::Key(..) => false,
+            Self::StringTag(..) => false,
             Self::StarlarkError(..) => false,
         }
     }
@@ -48,7 +52,7 @@ impl ContextValue {
             (ContextValue::Typed(left), ContextValue::Typed(right)) => {
                 assert!(left.eq(&**right))
             }
-            (ContextValue::Key(a), ContextValue::Key(b)) => {
+            (ContextValue::StringTag(a), ContextValue::StringTag(b)) => {
                 assert_eq!(a, b);
             }
             (ContextValue::StarlarkError(a), ContextValue::StarlarkError(b)) => {
@@ -65,7 +69,7 @@ impl std::fmt::Display for ContextValue {
             Self::Dyn(v) => f.write_str(v),
             Self::Tags(tags) => write!(f, "{:?}", tags),
             Self::Typed(v) => std::fmt::Display::fmt(v, f),
-            Self::Key(v) => f.write_str(v),
+            Self::StringTag(v) => f.write_str(&v.tag),
             Self::StarlarkError(v) => write!(f, "{}", v),
         }
     }

app/buck2_error/src/error.rs

@@ -19,6 +19,7 @@ use crate::classify::tag_is_generic;
 use crate::classify::tag_is_hidden;
 use crate::context_value::ContextValue;
 use crate::context_value::StarlarkContext;
+use crate::context_value::StringTag;
 use crate::context_value::TypedContext;
 use crate::format::into_anyhow_for_format;
 use crate::root::ErrorRoot;
@@ -178,15 +179,12 @@ impl Error {
 
         let key_tags = key_tags.into_iter().map(|tag| tag.as_str_name().to_owned());
 
-        let context_key_values = self.iter_context().filter_map(|kind| match kind {
-            ContextValue::Key(val) => Some(val.to_string()),
-            _ => None,
-        });
+        let string_tags = self.string_tags();
 
         let values: Vec<String> = source_location
             .into_iter()
             .chain(key_tags)
-            .chain(context_key_values)
+            .chain(string_tags)
             .collect();
 
         values.join(":").to_owned()
@@ -200,9 +198,11 @@ impl Error {
         Self(Arc::new(ErrorKind::WithContext(context.into(), self)))
     }
 
-    pub fn context_for_key(self, context: &str) -> Self {
+    pub fn string_tag(self, context: &str) -> Self {
         Self(Arc::new(ErrorKind::WithContext(
-            ContextValue::Key(context.into()),
+            ContextValue::StringTag(StringTag {
+                tag: context.into(),
+            }),
             self,
         )))
     }
@@ -259,6 +259,15 @@ impl Error {
         })
     }
 
+    pub fn string_tags(&self) -> Vec<String> {
+        self.iter_context()
+            .filter_map(|kind| match kind {
+                ContextValue::StringTag(val) => Some(val.tag.clone()),
+                _ => None,
+            })
+            .collect()
+    }
+
     /// Get all the tags that have been added to this error
     pub fn tags(&self) -> Vec<crate::ErrorTag> {
         let mut tags: Vec<_> = self.tags_unsorted().collect();

app/buck2_error/src/starlark_error.rs

@@ -97,7 +97,7 @@ fn error_with_starlark_context(
                     ContextValue::StarlarkError(_) => {
                         return buck2_error.context_for_starlark_backtrace(starlark_context);
                     }
-                    ContextValue::Tags(_) | ContextValue::Key(_) => {
+                    ContextValue::Tags(_) | ContextValue::StringTag(_) => {
                         context_stack.push(context_value.clone())
                     }
                 }
@@ -313,7 +313,7 @@ mod tests {
         let e = crate::Error::from(FullMetadataError);
         let e = e.context(context_error);
         let e = e.tag([error_tag]);
-        let e = e.context_for_key(context_key);
+        let e = e.string_tag(context_key);
 
         let context_popped = error_with_starlark_context(&e, starlark_context);
 

app/buck2_execute/src/re/error.rs

@@ -78,7 +78,7 @@ fn re_error(
     };
     let buck2_error: buck2_error::Error = err.clone().into();
 
-    buck2_error.context(err).context_for_key(&group.to_string())
+    buck2_error.context(err).string_tag(&group.to_string())
 }
 
 pub(crate) async fn with_error_handler<T>(

app/buck2_server_commands/src/commands/install.rs

@@ -910,7 +910,7 @@ async fn send_file(
             error = error.tag([category_tag]);
 
             for tag in error_detail.tags {
-                error = error.context_for_key(&tag);
+                error = error.string_tag(&tag);
             }
             outcome = Err(error);
         }