refactor: Simplify resolve_base_entries in mapper and cache

- Rename cache_member_output_line to compute_member_output_line
- Collapse any_has_range if-else into single loop with conditional line
- Collapse no_range len==1 / all_same_name into single all_same_name check
- Remove separate zero_zero/no_range vectors; pre-compute aggregates
  in a single pass and use one emission loop over base_entries

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

Author: romtsn

src/cache/mod.rs

@@ -1059,7 +1059,7 @@ fn map_member_without_lines<'a>(
 }
 
 /// Computes the default output line for a cache member's original_startline.
-fn cache_member_output_line(member: &raw::Member) -> Option<usize> {
+fn compute_member_output_line(member: &raw::Member) -> Option<usize> {
     match member.original_startline {
         0 | u32::MAX => None,
         value => Some(value as usize),
@@ -1073,7 +1073,7 @@ fn iterate_without_lines<'a>(
     outer_source_file: Option<&str>,
 ) -> Option<StackFrame<'a>> {
     let member = members.next()?;
-    let output_line = cache_member_output_line(member);
+    let output_line = compute_member_output_line(member);
     map_member_without_lines(cache, frame, member, outer_source_file, output_line)
 }
 
@@ -1137,76 +1137,65 @@ fn resolve_base_entries<'a>(
     base_entries: &[&raw::Member],
     outer_source_file: Option<&str>,
 ) -> Vec<StackFrame<'a>> {
-    let zero_zero: Vec<&&raw::Member> = base_entries
-        .iter()
-        .filter(|m| m.has_minified_range())
-        .collect();
-    let no_range: Vec<&&raw::Member> = base_entries
-        .iter()
-        .filter(|m| !m.has_minified_range())
-        .collect();
-
-    let mut frames = Vec::new();
-
-    // Process 0:0 entries.
-    if !zero_zero.is_empty() {
-        let any_has_range = zero_zero
-            .iter()
-            .any(|m| m.original_endline != u32::MAX && m.original_endline != m.original_startline);
-        if any_has_range {
-            for member in &zero_zero {
-                if let Some(f) =
-                    map_member_without_lines(cache, frame, member, outer_source_file, Some(0))
-                {
-                    frames.push(f);
-                }
+    // Pre-compute aggregates in a single pass.
+    let mut any_zero_zero_has_range = false;
+    let mut no_range_count = 0usize;
+    let mut first_no_range_offset: Option<u32> = None;
+    let mut all_no_range_same_name = true;
+    for member in base_entries {
+        if member.has_minified_range() {
+            if member.original_endline != u32::MAX
+                && member.original_endline != member.original_startline
+            {
+                any_zero_zero_has_range = true;
             }
         } else {
-            for member in &zero_zero {
-                let line = cache_member_output_line(member);
-                if let Some(f) =
-                    map_member_without_lines(cache, frame, member, outer_source_file, line)
-                {
-                    frames.push(f);
+            no_range_count += 1;
+            match first_no_range_offset {
+                None => first_no_range_offset = Some(member.original_name_offset),
+                Some(first) if member.original_name_offset != first => {
+                    all_no_range_same_name = false
                 }
+                _ => {}
             }
         }
     }
 
-    // Process no-range entries.
-    if !no_range.is_empty() {
-        if no_range.len() == 1 {
-            let member = no_range[0];
-            let line = if member.original_startline > 0 && member.original_startline != u32::MAX {
-                Some(member.original_startline as usize)
-            } else if !member.has_line_mapping() {
+    let mut frames = Vec::new();
+    let mut no_range_emitted = false;
+    for member in base_entries {
+        if member.has_minified_range() {
+            let line = if any_zero_zero_has_range {
                 Some(0)
             } else {
-                None
+                compute_member_output_line(member)
             };
             if let Some(f) = map_member_without_lines(cache, frame, member, outer_source_file, line)
             {
                 frames.push(f);
             }
-        } else {
-            let all_same_name = no_range
-                .iter()
-                .all(|m| m.original_name_offset == no_range[0].original_name_offset);
-            if all_same_name {
+        } else if all_no_range_same_name {
+            if !no_range_emitted {
+                no_range_emitted = true;
+                let line = if no_range_count > 1 {
+                    Some(0)
+                } else {
+                    compute_member_output_line(member).or(if !member.has_line_mapping() {
+                        Some(0)
+                    } else {
+                        None
+                    })
+                };
                 if let Some(f) =
-                    map_member_without_lines(cache, frame, no_range[0], outer_source_file, Some(0))
+                    map_member_without_lines(cache, frame, member, outer_source_file, line)
                 {
                     frames.push(f);
                 }
-            } else {
-                for member in &no_range {
-                    if let Some(f) =
-                        map_member_without_lines(cache, frame, member, outer_source_file, Some(0))
-                    {
-                        frames.push(f);
-                    }
-                }
             }
+        } else if let Some(f) =
+            map_member_without_lines(cache, frame, member, outer_source_file, Some(0))
+        {
+            frames.push(f);
         }
     }
 

src/mapper.rs

@@ -345,75 +345,65 @@ fn resolve_base_entries<'s>(
     base_entries: &[&'s MemberMapping<'s>],
     collected: &mut CollectedFrames<'s>,
 ) {
-    let zero_zero: Vec<&&MemberMapping<'s>> = base_entries
-        .iter()
-        .filter(|m| m.has_minified_range)
-        .collect();
-    let no_range: Vec<&&MemberMapping<'s>> = base_entries
-        .iter()
-        .filter(|m| !m.has_minified_range)
-        .collect();
-
-    // Process 0:0 entries.
-    if !zero_zero.is_empty() {
-        let any_has_range = zero_zero.iter().any(|m| {
-            m.original_endline
-                .is_some_and(|oe| oe != m.original_startline)
-        });
-        if any_has_range {
-            for member in &zero_zero {
-                collected
-                    .frames
-                    .push(map_member_without_lines(frame, member, Some(0)));
-                collected.rewrite_rules.extend(member.rewrite_rules.iter());
+    // Pre-compute aggregates in a single pass.
+    let mut any_zero_zero_has_range = false;
+    let mut no_range_count = 0usize;
+    let mut first_no_range_name: Option<&str> = None;
+    let mut all_no_range_same_name = true;
+    for member in base_entries {
+        if member.has_minified_range {
+            if member
+                .original_endline
+                .is_some_and(|oe| oe != member.original_startline)
+            {
+                any_zero_zero_has_range = true;
             }
         } else {
-            for member in &zero_zero {
-                let line = if member.original_startline > 0 {
-                    Some(member.original_startline)
-                } else {
-                    None
-                };
-                collected
-                    .frames
-                    .push(map_member_without_lines(frame, member, line));
-                collected.rewrite_rules.extend(member.rewrite_rules.iter());
+            no_range_count += 1;
+            match first_no_range_name {
+                None => first_no_range_name = Some(member.original),
+                Some(first) if member.original != first => all_no_range_same_name = false,
+                _ => {}
             }
         }
     }
 
-    // Process no-range entries.
-    if !no_range.is_empty() {
-        if no_range.len() == 1 {
-            let member = no_range[0];
-            let line = if member.original_startline > 0 {
-                Some(member.original_startline)
-            } else if !member.has_line_mapping {
+    let mut no_range_emitted = false;
+    for member in base_entries {
+        if member.has_minified_range {
+            let line = if any_zero_zero_has_range {
                 Some(0)
+            } else if member.original_startline > 0 {
+                Some(member.original_startline)
             } else {
                 None
             };
             collected
                 .frames
                 .push(map_member_without_lines(frame, member, line));
             collected.rewrite_rules.extend(member.rewrite_rules.iter());
-        } else {
-            let all_same_name = no_range.iter().all(|m| m.original == no_range[0].original);
-            if all_same_name {
+        } else if all_no_range_same_name {
+            if !no_range_emitted {
+                no_range_emitted = true;
+                let line = if no_range_count > 1 {
+                    Some(0)
+                } else if member.original_startline > 0 {
+                    Some(member.original_startline)
+                } else if !member.has_line_mapping {
+                    Some(0)
+                } else {
+                    None
+                };
                 collected
                     .frames
-                    .push(map_member_without_lines(frame, no_range[0], Some(0)));
-                collected
-                    .rewrite_rules
-                    .extend(no_range[0].rewrite_rules.iter());
-            } else {
-                for member in &no_range {
-                    collected
-                        .frames
-                        .push(map_member_without_lines(frame, member, Some(0)));
-                    collected.rewrite_rules.extend(member.rewrite_rules.iter());
-                }
+                    .push(map_member_without_lines(frame, member, line));
+                collected.rewrite_rules.extend(member.rewrite_rules.iter());
             }
+        } else {
+            collected
+                .frames
+                .push(map_member_without_lines(frame, member, Some(0)));
+            collected.rewrite_rules.extend(member.rewrite_rules.iter());
         }
     }
 }