Skip line if rewrite rules cleared all frames

Author: romtsn

src/mapper.rs

@@ -620,13 +620,19 @@ impl<'s> ProguardMapper<'s> {
                     self.prepare_frame_for_mapping(&frame, &mut carried_outline_pos);
 
                 let mut collected = self.collect_remapped_frames(&effective_frame);
+                let had_frames = !collected.frames.is_empty();
                 if next_frame_can_rewrite {
                     apply_rewrite_rules(&mut collected, current_exception_descriptor.as_deref());
                 }
 
                 next_frame_can_rewrite = false;
                 current_exception_descriptor = None;
 
+                // If rewrite rules cleared all frames, skip entirely
+                if had_frames && collected.frames.is_empty() {
+                    continue;
+                }
+
                 format_frames(&mut stacktrace, line, collected.frames.into_iter())?;
                 continue;
             }
@@ -678,11 +684,17 @@ impl<'s> ProguardMapper<'s> {
 
             let effective = self.prepare_frame_for_mapping(f, &mut carried_outline_pos);
             let mut collected = self.collect_remapped_frames(&effective);
+            let had_frames = !collected.frames.is_empty();
             if next_frame_can_rewrite {
                 apply_rewrite_rules(&mut collected, exception_descriptor.as_deref());
             }
             next_frame_can_rewrite = false;
 
+            // If rewrite rules cleared all frames, skip entirely
+            if had_frames && collected.frames.is_empty() {
+                continue;
+            }
+
             if collected.frames.is_empty() {
                 frames_out.push(f.clone());
             } else {
@@ -977,4 +989,85 @@ java.lang.RuntimeException: boom
 
         assert_eq!(mapper.remap_stacktrace(input).unwrap(), expected);
     }
+
+    #[test]
+    fn rewrite_frame_removes_all_frames_skips_line() {
+        // When rewrite rules remove ALL frames, the line should be skipped entirely
+        // (not fall back to original obfuscated frame)
+        let mapping = "\
+some.Class -> a:
+    4:4:void inlined():10:10 -> call
+    4:4:void outer():20 -> call
+    # {\"id\":\"com.android.tools.r8.rewriteFrame\",\"conditions\":[\"throws(Ljava/lang/NullPointerException;)\"],\"actions\":[\"removeInnerFrames(2)\"]}
+some.Other -> b:
+    5:5:void method():30 -> run
+";
+        let mapper = ProguardMapper::from(mapping);
+
+        let input = "\
+java.lang.NullPointerException: Boom
+    at a.call(SourceFile:4)
+    at b.run(SourceFile:5)
+";
+
+        // The first frame (a.call) should be completely removed by rewrite rules,
+        // not replaced with the original "at a.call(SourceFile:4)"
+        let expected = "\
+java.lang.NullPointerException: Boom
+    at some.Other.method(SourceFile:30)
+";
+
+        let actual = mapper.remap_stacktrace(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn rewrite_frame_removes_all_frames_skips_line_typed() {
+        // When rewrite rules remove ALL frames, the frame should be skipped entirely
+        // (not fall back to original obfuscated frame)
+        let mapping = "\
+some.Class -> a:
+    4:4:void inlined():10:10 -> call
+    4:4:void outer():20 -> call
+    # {\"id\":\"com.android.tools.r8.rewriteFrame\",\"conditions\":[\"throws(Ljava/lang/NullPointerException;)\"],\"actions\":[\"removeInnerFrames(2)\"]}
+some.Other -> b:
+    5:5:void method():30 -> run
+";
+        let mapper = ProguardMapper::from(mapping);
+
+        let trace = StackTrace {
+            exception: Some(Throwable {
+                class: "java.lang.NullPointerException",
+                message: Some("Boom"),
+            }),
+            frames: vec![
+                StackFrame {
+                    class: "a",
+                    method: "call",
+                    line: 4,
+                    file: Some("SourceFile"),
+                    parameters: None,
+                    method_synthesized: false,
+                },
+                StackFrame {
+                    class: "b",
+                    method: "run",
+                    line: 5,
+                    file: Some("SourceFile"),
+                    parameters: None,
+                    method_synthesized: false,
+                },
+            ],
+            cause: None,
+        };
+
+        let remapped = mapper.remap_stacktrace_typed(&trace);
+
+        // The first frame should be completely removed by rewrite rules,
+        // leaving only the second frame
+        assert_eq!(remapped.frames.len(), 1);
+        assert_eq!(remapped.frames[0].class, "some.Other");
+        assert_eq!(remapped.frames[0].method, "method");
+        assert_eq!(remapped.frames[0].line, 30);
+    }
 }