feat(r8-tests): Add R8 method overloading tests

Author: romtsn

tests/r8-method-overloading.NOTES.md

@@ -0,0 +1,24 @@
+# R8 Method Overloading fixtures: failures & required behavior changes
+
+Ported from upstream R8 retrace fixtures/tests:
+- `src/test/java/com/android/tools/r8/retrace/stacktraces/OverloadedWithAndWithoutRangeStackTrace.java`
+- `src/test/java/com/android/tools/r8/retrace/stacktraces/OverloadSameLineTest.java`
+- `src/test/java/com/android/tools/r8/retrace/RetraceMappingWithOverloadsTest.java`
+
+This doc lists **only the failing tests** and explains, one-by-one, what would need to change in `rust-proguard` to match upstream R8 retrace behavior.
+
+## `test_retrace_mapping_with_overloads_api_has_3_candidates`
+
+- **Upstream behavior** (`RetraceMappingWithOverloadsTest`): `lookupMethod("a")` on class `A` yields **3** method elements for the residual name `a`:
+  - `select(java.util.List)` (no line info)
+  - `sync()` (line-mapped range)
+  - `cancel(java.lang.String[])` (no line info)
+- **Current crate behavior**: `ProguardMapper::remap_frame(StackFrame::new("A","a",0))` yields **2** candidates.
+- **Why it fails**:
+  - This crate treats `line = 0` as “no line information” and may be **filtering out** line-ranged candidates (like `sync()`) unless a concrete line is provided.
+  - Alternatively, it may be collapsing/choosing a subset when multiple candidates exist without a line.
+- **What needs fixing**:
+  - **API semantics**: align “method lookup with no line” behavior with R8 retrace’s `lookupMethod`, which includes both:
+    - base/no-line mappings, and
+    - line-ranged mappings (as candidates) even when the position is unknown.
+

tests/r8-method-overloading.rs

@@ -0,0 +1,107 @@
+//! Tests for R8 retrace "Method Overloading" fixtures.
+//!
+//! Ported from the upstream R8 retrace fixtures in:
+//! - `src/test/java/com/android/tools/r8/retrace/stacktraces/OverloadedWithAndWithoutRangeStackTrace.java`
+//! - `src/test/java/com/android/tools/r8/retrace/stacktraces/OverloadSameLineTest.java`
+//! - `src/test/java/com/android/tools/r8/retrace/RetraceMappingWithOverloadsTest.java`
+#![allow(clippy::unwrap_used)]
+
+use proguard::{ProguardCache, ProguardMapper, ProguardMapping, StackFrame};
+
+fn assert_remap_stacktrace(mapping: &str, input: &str, expected: &str) {
+    let mapper = ProguardMapper::from(mapping);
+    let actual = mapper.remap_stacktrace(input).unwrap();
+    assert_eq!(actual.trim_end(), expected.trim_end());
+
+    let mapping = ProguardMapping::new(mapping.as_bytes());
+    let mut buf = Vec::new();
+    ProguardCache::write(&mapping, &mut buf).unwrap();
+    let cache = ProguardCache::parse(&buf).unwrap();
+    cache.test();
+
+    let actual = cache.remap_stacktrace(input).unwrap();
+    assert_eq!(actual.trim_end(), expected.trim_end());
+}
+
+// =============================================================================
+// OverloadedWithAndWithoutRangeStackTrace
+// =============================================================================
+
+const OVERLOADED_WITH_AND_WITHOUT_RANGE_MAPPING: &str = r#"some.Class -> A:
+    java.util.List select(java.util.List) -> a
+    3:3:void sync():425:425 -> a
+    void cancel(java.lang.String[]) -> a
+"#;
+
+#[test]
+fn test_overloaded_with_and_without_range_stacktrace() {
+    let input = r#"  at A.a(SourceFile:3)
+"#;
+
+    // This crate normalizes indentation to 4 spaces for parsed frames.
+    let expected = r#"    at some.Class.sync(Class.java:425)
+"#;
+
+    assert_remap_stacktrace(OVERLOADED_WITH_AND_WITHOUT_RANGE_MAPPING, input, expected);
+}
+
+// =============================================================================
+// OverloadSameLineTest
+// =============================================================================
+
+const OVERLOAD_SAME_LINE_MAPPING: &str = r#"com.android.tools.r8.naming.retrace.Main -> foo.a:
+    1:1:void overload():7:7 -> overload
+    1:1:void overload(java.lang.String):13:13 -> overload
+    1:1:void overload(int):15:15 -> overload
+"#;
+
+#[test]
+fn test_overload_same_line_stacktrace() {
+    let input = r#"Exception in thread "main" java.lang.NullPointerException
+	at foo.a.overload(Main.java:1)
+"#;
+
+    // Upstream emits 3 alternatives (one per overload) for the same minified position.
+    // This crate emits alternatives as duplicate frames (no `<OR>` markers).
+    let expected = r#"Exception in thread "main" java.lang.NullPointerException
+    at com.android.tools.r8.naming.retrace.Main.overload(Main.java:7)
+    at com.android.tools.r8.naming.retrace.Main.overload(Main.java:13)
+    at com.android.tools.r8.naming.retrace.Main.overload(Main.java:15)
+"#;
+
+    assert_remap_stacktrace(OVERLOAD_SAME_LINE_MAPPING, input, expected);
+}
+
+// =============================================================================
+// RetraceMappingWithOverloadsTest (API-level behavior)
+// =============================================================================
+
+const RETRACE_MAPPING_WITH_OVERLOADS_MAPPING: &str = r#"some.Class -> A:
+    java.util.List select(java.util.List) -> a
+    3:3:void sync():425:425 -> a
+    4:5:void sync():427:428 -> a
+    void cancel(java.lang.String[]) -> a
+"#;
+
+#[test]
+fn test_retrace_mapping_with_overloads_api_has_3_candidates() {
+    let mapper = ProguardMapper::from(RETRACE_MAPPING_WITH_OVERLOADS_MAPPING);
+
+    // Equivalent to upstream's `retracer.retraceClass(A).lookupMethod("a")` size == 3:
+    // - select(java.util.List)
+    // - sync() (line-mapped range)
+    // - cancel(java.lang.String[])
+    let frame = StackFrame::new("A", "a", 0);
+    let remapped: Vec<_> = mapper.remap_frame(&frame).collect();
+    assert_eq!(remapped.len(), 3);
+}
+
+#[test]
+fn test_retrace_mapping_with_overloads_api_includes_sync_with_line() {
+    let mapper = ProguardMapper::from(RETRACE_MAPPING_WITH_OVERLOADS_MAPPING);
+
+    // When the minified line hits the `sync()` mapping range, it should produce a `sync` candidate.
+    let frame = StackFrame::new("A", "a", 3);
+    let remapped: Vec<_> = mapper.remap_frame(&frame).collect();
+    assert!(remapped.iter().any(|f| f.method() == "sync"));
+}