refactor(prof): remove unnecessary pub, remove dead code

Author: morrisonlevi

profiling/src/internal/profile/fuzz_tests.rs

@@ -6,23 +6,22 @@ use bolero::generator::TypeGenerator;
 use core::cmp::Ordering;
 use core::hash::Hasher;
 use core::ops::Deref;
-use std::collections::HashSet;
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Hash, TypeGenerator)]
-pub struct Function {
+struct Function {
     /// Name of the function, in human-readable form if available.
-    pub name: Box<str>,
+    name: Box<str>,
 
     /// Name of the function, as identified by the system.
     /// For instance, it can be a C++ mangled name.
-    pub system_name: Box<str>,
+    system_name: Box<str>,
 
     /// Source file containing the function.
-    pub filename: Box<str>,
+    filename: Box<str>,
 }
 
 impl Function {
-    pub fn new(name: Box<str>, system_name: Box<str>, filename: Box<str>) -> Self {
+    fn new(name: Box<str>, system_name: Box<str>, filename: Box<str>) -> Self {
         Self {
             name,
             system_name,
@@ -42,7 +41,7 @@ impl<'a> From<&'a Function> for api::Function<'a> {
 }
 
 #[derive(Clone, Debug, TypeGenerator)]
-pub enum LabelValue {
+enum LabelValue {
     Str(Box<str>),
     Num { num: i64, num_unit: Box<str> },
 }
@@ -53,10 +52,18 @@ impl Default for LabelValue {
     }
 }
 
+// Note that Hash, Eq, Ord, etc. are implemented manually by converting the
+// Label into an api::Label calling its hash, eq, cmp, etc. functions. This
+// is a convenient way to have a consistent implementation while also taking
+// into account that these should be considered the same:
+//      LabelValue::Num {                   LabelValue::Str(Box::from(""))
+//          num: 0,
+//          num_unit: Box::from(""),
+//      }
 #[derive(Clone, Debug, Default, TypeGenerator)]
-pub struct Label {
-    pub key: Box<str>,
-    pub value: LabelValue,
+struct Label {
+    key: Box<str>,
+    value: LabelValue,
 }
 
 impl From<(Box<str>, LabelValue)> for Label {
@@ -119,12 +126,12 @@ impl core::hash::Hash for Label {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, TypeGenerator)]
-pub struct Line {
+struct Line {
     /// The corresponding profile.Function for this line.
-    pub function: Function,
+    function: Function,
 
     /// Line number in source code.
-    pub line: i64,
+    line: i64,
 }
 
 impl<'a> From<&'a Line> for api::Line<'a> {
@@ -137,21 +144,21 @@ impl<'a> From<&'a Line> for api::Line<'a> {
 }
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Hash, TypeGenerator)]
-pub struct Location {
-    pub mapping: Mapping,
-    pub function: Function,
+struct Location {
+    mapping: Mapping,
+    function: Function,
 
     /// The instruction address for this location, if available.  It
     /// should be within [Mapping.memory_start...Mapping.memory_limit]
     /// for the corresponding mapping. A non-leaf address may be in the
     /// middle of a call instruction. It is up to display tools to find
     /// the beginning of the instruction if necessary.
-    pub address: u64,
-    pub line: i64,
+    address: u64,
+    line: i64,
 }
 
 impl Location {
-    pub fn new(mapping: Mapping, function: Function, address: u64, line: i64) -> Self {
+    fn new(mapping: Mapping, function: Function, address: u64, line: i64) -> Self {
         Self {
             mapping,
             function,
@@ -173,29 +180,29 @@ impl<'a> From<&'a Location> for api::Location<'a> {
 }
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Hash, TypeGenerator)]
-pub struct Mapping {
+struct Mapping {
     /// Address at which the binary (or DLL) is loaded into memory.
-    pub memory_start: u64,
+    memory_start: u64,
 
     /// The limit of the address range occupied by this mapping.
-    pub memory_limit: u64,
+    memory_limit: u64,
 
     /// Offset in the binary that corresponds to the first mapped address.
-    pub file_offset: u64,
+    file_offset: u64,
 
     /// The object this entry is loaded from.  This can be a filename on
     /// disk for the main binary and shared libraries, or virtual
     /// abstractions like "[vdso]".
-    pub filename: Box<str>,
+    filename: Box<str>,
 
     /// A string that uniquely identifies a particular program version
     /// with high probability. E.g., for binaries generated by GNU tools,
     /// it could be the contents of the .note.gnu.build-id field.
-    pub build_id: Box<str>,
+    build_id: Box<str>,
 }
 
 impl Mapping {
-    pub fn new(
+    fn new(
         memory_start: u64,
         memory_limit: u64,
         file_offset: u64,
@@ -225,30 +232,30 @@ impl<'a> From<&'a Mapping> for api::Mapping<'a> {
 }
 
 #[derive(Clone, Debug)]
-pub struct Sample {
+struct Sample {
     /// The leaf is at locations[0].
-    pub locations: Vec<Location>,
+    locations: Vec<Location>,
 
     /// The type and unit of each value is defined by the corresponding
     /// entry in Profile.sample_type. All samples must have the same
     /// number of values, the same as the length of Profile.sample_type.
     /// When aggregating multiple samples into a single sample, the
     /// result has a list of values that is the element-wise sum of the
     /// lists of the originals.
-    pub values: Vec<i64>,
+    values: Vec<i64>,
 
     /// label includes additional context for this sample. It can include
     /// things like a thread id, allocation size, etc
-    pub labels: Vec<Label>,
+    labels: Vec<Label>,
 }
 
 /// Since [Sample] needs a Vec<Label> which have unique keys, we generate
 /// samples using this parallel struct, and then map it to the [Sample].
 #[derive(Clone, Debug, TypeGenerator)]
 struct FuzzSample {
-    pub locations: Vec<Location>,
-    pub values: Vec<i64>,
-    pub labels: HashMap<Box<str>, LabelValue>,
+    locations: Vec<Location>,
+    values: Vec<i64>,
+    labels: HashMap<Box<str>, LabelValue>,
 }
 
 impl From<FuzzSample> for Sample {
@@ -271,18 +278,6 @@ impl From<&FuzzSample> for Sample {
     }
 }
 
-#[cfg(test)]
-impl Sample {
-    /// Checks if the sample is well-formed.  Useful in testing.
-    pub fn is_well_formed(&self) -> bool {
-        let labels_are_unique = {
-            let mut uniq = HashSet::new();
-            self.labels.iter().map(|l| &l.key).all(|x| uniq.insert(x))
-        };
-        labels_are_unique
-    }
-}
-
 impl<'a> From<&'a Sample> for api::Sample<'a> {
     fn from(value: &'a Sample) -> Self {
         Self {