Merge branch 'master' into rz/feat/r8-tests-inline

Author: romtsn

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 5.9.0
+
+### New Features ✨
+
+#### R8
+
+- feat(r8): Support `rewriteFrames` annotation in ProguardCache by @romtsn in [#67](https://github.com/getsentry/rust-proguard/pull/67)
+- feat(r8): Support `rewriteFrames` annotation in ProguardMapper by @romtsn in [#66](https://github.com/getsentry/rust-proguard/pull/66)
+
+### Bug Fixes 🐛
+
+- fix: Correctly remap entries with 0 line info by @romtsn in [#68](https://github.com/getsentry/rust-proguard/pull/68)
+
 ## 5.8.1
 
 - build: Update dependencies and set MSRV 1.83.0 by @loewenheim in [#65](https://github.com/getsentry/rust-proguard/pull/65)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "proguard"
-version = "5.8.1"
+version = "5.9.0"
 authors = ["Sentry <oss@sentry.io>"]
 keywords = ["proguard", "retrace", "android", "r8"]
 description = "Basic proguard mapping file handling for Rust"

src/cache/mod.rs

@@ -321,6 +321,148 @@ impl<'data> ProguardCache<'data> {
         rules
     }
 
+    /// Finds member entries for a frame and collects rewrite rules without building frames.
+    /// Returns (member_slice, prepared_frame, rewrite_rules, had_mappings).
+    fn find_members_and_rules(
+        &'data self,
+        frame: &StackFrame<'data>,
+    ) -> Option<(
+        &'data [raw::Member],
+        StackFrame<'data>,
+        Vec<RewriteRule<'data>>,
+        bool,
+    )> {
+        let class = self.get_class(frame.class)?;
+        let original_class = self
+            .read_string(class.original_name_offset)
+            .unwrap_or(frame.class);
+
+        let mut prepared_frame = frame.clone();
+        prepared_frame.class = original_class;
+
+        let method_name = prepared_frame.method;
+        let mapping_entries: &[raw::Member] = if let Some(parameters) = prepared_frame.parameters {
+            let members = self.get_class_members_by_params(class)?;
+            Self::find_range_by_binary_search(members, |m| {
+                let Ok(obfuscated_name) = self.read_string(m.obfuscated_name_offset) else {
+                    return Ordering::Greater;
+                };
+                let params = if m.params_offset != u32::MAX {
+                    self.read_string(m.params_offset).unwrap_or_default()
+                } else {
+                    ""
+                };
+                (obfuscated_name, params).cmp(&(method_name, parameters))
+            })?
+        } else {
+            let members = self.get_class_members(class)?;
+            Self::find_range_by_binary_search(members, |m| {
+                let Ok(obfuscated_name) = self.read_string(m.obfuscated_name_offset) else {
+                    return Ordering::Greater;
+                };
+                obfuscated_name.cmp(method_name)
+            })?
+        };
+
+        // Collect rewrite rules and check had_mappings by iterating members
+        let mut rewrite_rules = Vec::new();
+        let mut had_mappings = false;
+
+        if prepared_frame.parameters.is_none() {
+            for member in mapping_entries {
+                // Check if this member would produce a frame (line matching)
+                if member.endline == 0
+                    || (prepared_frame.line >= member.startline as usize
+                        && prepared_frame.line <= member.endline as usize)
+                {
+                    had_mappings = true;
+                    rewrite_rules.extend(self.decode_rewrite_rules(member));
+                }
+            }
+        } else {
+            // With parameters, all members match
+            had_mappings = !mapping_entries.is_empty();
+            for member in mapping_entries {
+                rewrite_rules.extend(self.decode_rewrite_rules(member));
+            }
+        }
+
+        Some((mapping_entries, prepared_frame, rewrite_rules, had_mappings))
+    }
+
+    /// Remaps a single Stackframe.
+    ///
+    /// Returns zero or more [`StackFrame`]s, based on the information in
+    /// the proguard mapping. This can return more than one frame in the case
+    /// of inlined functions. In that case, frames are sorted top to bottom.
+    pub fn remap_frame<'r: 'data>(
+        &'r self,
+        frame: &StackFrame<'data>,
+    ) -> RemappedFrameIter<'r, 'data> {
+        let Some(class) = self.get_class(frame.class) else {
+            return RemappedFrameIter::empty();
+        };
+
+        for entry in entries {
+            let mut conditions = Vec::new();
+            if let Some(condition_components) = self.rewrite_rule_components.get(
+                entry.conditions_offset as usize
+                    ..entry.conditions_offset.saturating_add(entry.conditions_len) as usize,
+            ) {
+                for component in condition_components {
+                    match component.kind {
+                        raw::REWRITE_CONDITION_THROWS => {
+                            if let Ok(descriptor) = self.read_string(component.value) {
+                                conditions.push(RewriteCondition::Throws(descriptor));
+                            }
+                        }
+                        raw::REWRITE_CONDITION_UNKNOWN => {
+                            if let Ok(value) = self.read_string(component.value) {
+                                conditions.push(RewriteCondition::Unknown(value));
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+
+            let mut actions = Vec::new();
+            if let Some(action_components) = self.rewrite_rule_components.get(
+                entry.actions_offset as usize
+                    ..entry.actions_offset.saturating_add(entry.actions_len) as usize,
+            ) {
+                for component in action_components {
+                    match component.kind {
+                        raw::REWRITE_ACTION_REMOVE_INNER_FRAMES => {
+                            actions
+                                .push(RewriteAction::RemoveInnerFrames(component.value as usize));
+                        }
+                        raw::REWRITE_ACTION_UNKNOWN => {
+                            if let Ok(value) = self.read_string(component.value) {
+                                actions.push(RewriteAction::Unknown(value));
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+
+            // Only add rules with at least one condition and one action,
+            // matching the validation in parse_rewrite_rule.
+            // This guards against corrupt cache data where read_string fails,
+            // which would otherwise result in empty conditions that match
+            // any exception due to vacuous truth in iter().all().
+            if !conditions.is_empty() && !actions.is_empty() {
+                rules.push(RewriteRule {
+                    conditions,
+                    actions,
+                });
+            }
+        }
+
+        rules
+    }
+
     /// Finds member entries for a frame and collects rewrite rules without building frames.
     fn find_members_and_rules(
         &'data self,
@@ -450,6 +592,62 @@ impl<'data> ProguardCache<'data> {
         ))
     }
 
+    /// Remaps a single stack frame through the complete processing pipeline.
+    ///
+    /// This method combines:
+    /// - Outline frame detection via [`is_outline_frame`](Self::is_outline_frame)
+    /// - Frame preparation via [`prepare_frame_for_mapping`](Self::prepare_frame_for_mapping)
+    /// - Lazy frame remapping with rewrite rules applied via skip_count
+    ///
+    /// # Arguments
+    /// * `frame` - The frame to remap
+    /// * `exception_descriptor` - Optional exception descriptor for rewrite rules (e.g., `Ljava/lang/NullPointerException;`)
+    /// * `apply_rewrite` - Whether to apply rewrite rules (typically true only for the first frame after an exception)
+    /// * `carried_outline_pos` - Mutable reference to track outline position across frames
+    ///
+    /// # Returns
+    /// - `None` if this is an outline frame (caller should skip, `carried_outline_pos` is updated internally)
+    /// - `Some(iterator)` with remapped frames. Use [`RemappedFrameIter::had_mappings`] after collecting
+    ///   to detect if rewrite rules cleared all frames (skip if `had_mappings() && collected.is_empty()`)
+    pub fn remap_frame_with_context<'r>(
+        &'r self,
+        frame: &StackFrame<'data>,
+        exception_descriptor: Option<&str>,
+        apply_rewrite: bool,
+        carried_outline_pos: &mut Option<usize>,
+    ) -> Option<RemappedFrameIter<'r, 'data>>
+    where
+        'r: 'data,
+    {
+        if self.is_outline_frame(frame.class, frame.method) {
+            *carried_outline_pos = Some(frame.line);
+            return None;
+        }
+
+        let effective = self.prepare_frame_for_mapping(frame, carried_outline_pos);
+
+        let Some((members, prepared_frame, rewrite_rules, had_mappings)) =
+            self.find_members_and_rules(&effective)
+        else {
+            return Some(RemappedFrameIter::empty());
+        };
+
+        // Compute skip_count from rewrite rules
+        let skip_count = if apply_rewrite {
+            compute_skip_count(&rewrite_rules, exception_descriptor)
+        } else {
+            0
+        };
+
+        Some(RemappedFrameIter::new(
+            self,
+            prepared_frame,
+            members.iter(),
+            skip_count,
+            had_mappings,
+        ))
+    }
+
     /// Finds the range of elements of `members` for which `f(m) == Ordering::Equal`.
     ///
     /// This works by first binary searching for any element fitting the criteria
@@ -634,15 +832,13 @@ impl<'data> ProguardCache<'data> {
             }
 
             if let Some(frame) = stacktrace::parse_frame(line) {
-                let Some(iter) = self.remap_frame(
+                let Some(iter) = self.remap_frame_with_context(
                     &frame,
                     current_exception_descriptor.as_deref(),
                     next_frame_can_rewrite,
                     &mut carried_outline_pos,
                 ) else {
-                    // Outline frame, skip
-                    next_frame_can_rewrite = false;
-                    current_exception_descriptor = None;
+                    // Outline frame, skip (preserve next_frame_can_rewrite for the next real frame)
                     continue;
                 };
 
@@ -701,14 +897,13 @@ impl<'data> ProguardCache<'data> {
         let mut frames = Vec::with_capacity(trace.frames.len());
         let mut next_frame_can_rewrite = exception_descriptor.is_some();
         for f in trace.frames.iter() {
-            let Some(iter) = self.remap_frame(
+            let Some(iter) = self.remap_frame_with_context(
                 f,
                 exception_descriptor.as_deref(),
                 next_frame_can_rewrite,
                 &mut carried_outline_pos,
             ) else {
-                // Outline frame, skip
-                next_frame_can_rewrite = false;
+                // Outline frame, skip (preserve next_frame_can_rewrite for the next real frame)
                 continue;
             };
             next_frame_can_rewrite = false;
@@ -775,7 +970,7 @@ impl<'r, 'data> RemappedFrameIter<'r, 'data> {
         }
     }
 
-    fn new(
+    fn members(
         cache: &'r ProguardCache<'data>,
         frame: StackFrame<'data>,
         members: std::slice::Iter<'data, raw::Member>,
@@ -807,6 +1002,29 @@ impl<'r, 'data> RemappedFrameIter<'r, 'data> {
             iterate_without_lines(cache, frame, members, self.outer_source_file)
         }
     }
+
+    fn new(
+        cache: &'r ProguardCache<'data>,
+        frame: StackFrame<'data>,
+        members: std::slice::Iter<'data, raw::Member>,
+        skip_count: usize,
+        had_mappings: bool,
+    ) -> Self {
+        Self {
+            inner: Some((cache, frame, members)),
+            skip_count,
+            had_mappings,
+        }
+    }
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // Lazily skip rewrite-removed frames
+        while self.skip_count > 0 {
+            self.skip_count -= 1;
+            self.next_inner()?;
+        }
+        self.next_inner()
+    }
 }
 
 impl<'data> Iterator for RemappedFrameIter<'_, 'data> {