feat(r8): Add line span expansion and outside-range fallback

When a base entry maps to a span of original lines (e.g., `:42:44`),
expand into one frame per original line. When a frame's line falls
outside all mapped ranges, fall back to class-only remapping.

Fixes test_different_line_number_span_stacktrace and
test_outside_line_range_stacktrace.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: romtsn

src/cache/mod.rs

@@ -838,6 +838,8 @@ pub struct RemappedFrameIter<'r, 'data> {
     had_mappings: bool,
     /// Whether this method has any line-based mappings.
     has_line_info: bool,
+    /// Whether any frame was successfully matched by iterate_with_lines.
+    matched_any: bool,
     /// The source file of the outer class for synthesis.
     outer_source_file: Option<&'data str>,
 }
@@ -851,6 +853,7 @@ impl<'r, 'data> RemappedFrameIter<'r, 'data> {
             skip_count: 0,
             had_mappings: false,
             has_line_info: false,
+            matched_any: false,
             outer_source_file: None,
         }
     }
@@ -871,6 +874,7 @@ impl<'r, 'data> RemappedFrameIter<'r, 'data> {
             skip_count,
             had_mappings,
             has_line_info,
+            matched_any: false,
             outer_source_file,
         }
     }
@@ -883,6 +887,7 @@ impl<'r, 'data> RemappedFrameIter<'r, 'data> {
             skip_count: 0,
             had_mappings: false,
             has_line_info: false,
+            matched_any: false,
             outer_source_file: None,
         }
     }
@@ -932,9 +937,20 @@ impl<'r, 'data> RemappedFrameIter<'r, 'data> {
                 &mut members,
                 self.outer_source_file,
                 self.has_line_info,
+                &mut self.pending_frames,
             );
-            self.inner = Some((cache, frame, members));
-            mapped
+            if mapped.is_some() {
+                self.matched_any = true;
+                self.inner = Some((cache, frame, members));
+                mapped
+            } else if !self.matched_any && self.has_line_info {
+                // Outside-range fallback: no member matched the frame line.
+                // Remap only the class name, keeping the obfuscated method name
+                // and the original line.
+                Some(cache.remap_class_only(&frame, self.outer_source_file))
+            } else {
+                None
+            }
         } else {
             let mapped =
                 iterate_without_lines(cache, &mut frame, &mut members, self.outer_source_file);
@@ -965,6 +981,7 @@ fn iterate_with_lines<'a>(
     members: &mut std::slice::Iter<'_, raw::Member>,
     outer_source_file: Option<&str>,
     has_line_info: bool,
+    pending_frames: &mut Vec<StackFrame<'a>>,
 ) -> Option<StackFrame<'a>> {
     let frame_line = frame.line.unwrap_or(0);
     for member in members {
@@ -974,10 +991,44 @@ fn iterate_with_lines<'a>(
         }
         // If the mapping entry has no line range, determine output line.
         if member.endline().unwrap_or(0) == 0 {
-            let output_line = if member.original_startline().is_none() {
+            if member.original_startline().is_none() {
                 // Bare method mapping: pass through frame line.
-                frame.line
-            } else if member.original_startline().unwrap_or(0) > 0 {
+                return map_member_without_lines(
+                    cache,
+                    frame,
+                    member,
+                    outer_source_file,
+                    frame.line,
+                );
+            }
+            // Span expansion: if the original range spans multiple lines,
+            // emit one frame per original line.
+            if member.original_endline != u32::MAX
+                && member.original_endline > member.original_startline().unwrap_or(0)
+            {
+                let first_line = member.original_startline().unwrap_or(0) as usize;
+                let last_line = member.original_endline as usize;
+                let mut first_frame = None;
+                for line in first_line..=last_line {
+                    if let Some(f) = map_member_without_lines(
+                        cache,
+                        frame,
+                        member,
+                        outer_source_file,
+                        Some(line),
+                    ) {
+                        if first_frame.is_none() {
+                            first_frame = Some(f);
+                        } else {
+                            pending_frames.push(f);
+                        }
+                    }
+                }
+                // Reverse so pop() drains in ascending line order.
+                pending_frames.reverse();
+                return first_frame;
+            }
+            let output_line = if member.original_startline().unwrap_or(0) > 0 {
                 Some(member.original_startline().unwrap_or(0) as usize)
             } else {
                 None

src/mapper.rs

@@ -699,6 +699,22 @@ impl<'s> ProguardMapper<'s> {
                         collected.rewrite_rules.extend(member.rewrite_rules.iter());
                         continue;
                     }
+                    // Span expansion: if the original range spans multiple lines,
+                    // emit one frame per original line.
+                    if let Some(oe) = member.original_endline {
+                        let os = member.original_startline.unwrap_or(0);
+                        if oe > os {
+                            for line in os..=oe {
+                                collected.frames.push(map_member_without_lines(
+                                    &frame,
+                                    member,
+                                    Some(line),
+                                ));
+                            }
+                            collected.rewrite_rules.extend(member.rewrite_rules.iter());
+                            continue;
+                        }
+                    }
                     // Single-line: use original_startline if > 0, else None.
                     let output_line = if member.original_startline.unwrap_or(0) > 0 {
                         member.original_startline
@@ -714,6 +730,14 @@ impl<'s> ProguardMapper<'s> {
                     collected.rewrite_rules.extend(member.rewrite_rules.iter());
                 }
             }
+
+            // Outside-range fallback: if we had line mappings but nothing matched,
+            // remap only the class name, keeping the obfuscated method name and original line.
+            if collected.frames.is_empty() && has_line_info {
+                collected
+                    .frames
+                    .push(remap_class_only(&frame, frame.file()));
+            }
         } else {
             for member in mapping_entries {
                 // For parameter-based lookups, use original_startline if > 0, else None