ref: Robustly parse R8 headers

R8 headers have a different format from "normal" ProGuard headers. This
splits the parsing of the two header formats apart and uses `serde` for
R8 headers (they are specified to be in JSON format).

Author: loewenheim

Cargo.lock

@@ -15,6 +15,8 @@ uuid = ["dep:uuid", "lazy_static"]
 
 [dependencies]
 lazy_static = { version = "1.4.0", optional = true }
+serde = "1.0.219"
+serde_json = "1.0.140"
 thiserror = "1.0.61"
 uuid = { version = "1.0.0", features = ["v5"], optional = true }
 watto = { version = "0.1.0", features = ["writer", "strings"] }

Cargo.toml

@@ -3,6 +3,7 @@ use std::io::Write;
 
 use watto::{Pod, StringTable};
 
+use crate::mapping::R8Header;
 use crate::{ProguardMapping, ProguardRecord};
 
 use super::{CacheError, CacheErrorKind};
@@ -194,15 +195,11 @@ impl<'data> ProguardCache<'data> {
         let mut records = mapping.iter().filter_map(Result::ok).peekable();
         while let Some(record) = records.next() {
             match record {
-                ProguardRecord::Header {
-                    key,
-                    value: Some(file_name),
-                } => {
-                    if key == "sourceFile" {
-                        current_class.class.file_name_offset =
-                            string_table.insert(file_name) as u32;
-                    }
+                ProguardRecord::R8Header(R8Header::SourceFile { ref file_name }) => {
+                    current_class.class.file_name_offset = string_table.insert(file_name) as u32;
                 }
+                ProguardRecord::Header { .. } => {}
+                ProguardRecord::R8Header(R8Header::Other) => {}
                 ProguardRecord::Class {
                     original,
                     obfuscated,

src/cache/raw.rs

@@ -5,6 +5,7 @@ use std::fmt::{Error as FmtError, Write};
 use std::iter::FusedIterator;
 
 use crate::java;
+use crate::mapping::R8Header;
 use crate::mapping::{ProguardMapping, ProguardRecord};
 use crate::stacktrace::{self, StackFrame, StackTrace, Throwable};
 
@@ -236,11 +237,11 @@ impl<'s> ProguardMapper<'s> {
         let mut records = mapping.iter().filter_map(Result::ok).peekable();
         while let Some(record) = records.next() {
             match record {
-                ProguardRecord::Header { key, value } => {
-                    if key == "sourceFile" {
-                        class.file_name = value;
-                    }
+                ProguardRecord::R8Header(R8Header::SourceFile { file_name }) => {
+                    class.file_name = Some(file_name);
                 }
+                ProguardRecord::Header { .. } => {}
+                ProguardRecord::R8Header(R8Header::Other) => {}
                 ProguardRecord::Class {
                     original,
                     obfuscated,

src/mapper.rs

@@ -7,6 +7,8 @@ use std::fmt;
 use std::ops::Range;
 use std::str;
 
+use serde::Deserialize;
+
 #[cfg(feature = "uuid")]
 use uuid::Uuid;
 
@@ -282,7 +284,7 @@ impl<'s> Iterator for ProguardRecordIter<'s> {
 /// Maps start/end lines of a minified file to original start/end lines.
 ///
 /// All line mappings are 1-based and inclusive.
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct LineMapping {
     /// Start Line, 1-based.
     pub startline: usize,
@@ -294,8 +296,26 @@ pub struct LineMapping {
     pub original_endline: Option<usize>,
 }
 
+/// An R8 header, as described in
+/// <https://r8.googlesource.com/r8/+/refs/heads/main/doc/retrace.md#additional-information-appended-as-comments-to-the-file>.
+///
+/// The format is a line starting with `#` and followed by a JSON object.
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+#[serde(tag = "id", rename_all = "camelCase")]
+pub enum R8Header<'s> {
+    /// A source file header, stating what source file a class originated from.
+    ///
+    /// See <https://r8.googlesource.com/r8/+/refs/heads/main/doc/retrace.md#source-file>.
+    #[serde(rename_all = "camelCase")]
+    SourceFile { file_name: &'s str },
+
+    /// Catchall variant for headers we don't support.
+    #[serde(other)]
+    Other,
+}
+
 /// A Proguard Mapping Record.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ProguardRecord<'s> {
     /// A Proguard Header.
     Header {
@@ -304,6 +324,8 @@ pub enum ProguardRecord<'s> {
         /// Optional value if the Header is a KV pair.
         value: Option<&'s str>,
     },
+    /// An R8 Header.
+    R8Header(R8Header<'s>),
     /// A Class Mapping.
     Class {
         /// Original name of the class.
@@ -436,7 +458,9 @@ impl<'s> ProguardRecord<'s> {
 fn parse_proguard_record(bytes: &[u8]) -> (Result<ProguardRecord, ParseError>, &[u8]) {
     let bytes = consume_leading_newlines(bytes);
 
-    let result = if bytes.starts_with(b"#") {
+    let result = if bytes.starts_with(b"# {") {
+        parse_r8_header(bytes)
+    } else if bytes.starts_with(b"#") {
         parse_proguard_header(bytes)
     } else if bytes.starts_with(b"    ") {
         parse_proguard_field_or_method(bytes)
@@ -459,38 +483,35 @@ fn parse_proguard_record(bytes: &[u8]) -> (Result<ProguardRecord, ParseError>, &
     }
 }
 
-const SOURCE_FILE_PREFIX: &[u8; 32] = br#" {"id":"sourceFile","fileName":""#;
-
 /// Parses a single Proguard Header from a Proguard File.
 fn parse_proguard_header(bytes: &[u8]) -> Result<(ProguardRecord, &[u8]), ParseError> {
     let bytes = parse_prefix(bytes, b"#")?;
 
-    if let Ok(bytes) = parse_prefix(bytes, SOURCE_FILE_PREFIX) {
-        let (value, bytes) = parse_until(bytes, |c| *c == b'"')?;
-        let bytes = parse_prefix(bytes, br#""}"#)?;
+    // Existing logic for `key: value` format
+    let (key, bytes) = parse_until(bytes, |c| *c == b':' || is_newline(c))?;
 
-        let record = ProguardRecord::Header {
-            key: "sourceFile",
-            value: Some(value),
-        };
+    let (value, bytes) = match parse_prefix(bytes, b":") {
+        Ok(bytes) => parse_until(bytes, is_newline).map(|(v, bytes)| (Some(v), bytes)),
+        Err(_) => Ok((None, bytes)),
+    }?;
 
-        Ok((record, consume_leading_newlines(bytes)))
-    } else {
-        // Existing logic for `key: value` format
-        let (key, bytes) = parse_until(bytes, |c| *c == b':' || is_newline(c))?;
+    let record = ProguardRecord::Header {
+        key: key.trim(),
+        value: value.map(|v| v.trim()),
+    };
 
-        let (value, bytes) = match parse_prefix(bytes, b":") {
-            Ok(bytes) => parse_until(bytes, is_newline).map(|(v, bytes)| (Some(v), bytes)),
-            Err(_) => Ok((None, bytes)),
-        }?;
+    Ok((record, consume_leading_newlines(bytes)))
+}
 
-        let record = ProguardRecord::Header {
-            key: key.trim(),
-            value: value.map(|v| v.trim()),
-        };
+fn parse_r8_header(bytes: &[u8]) -> Result<(ProguardRecord, &[u8]), ParseError> {
+    let bytes = parse_prefix(bytes, b"#")?;
+    let (header, rest) = parse_until(bytes, is_newline)?;
 
-        Ok((record, consume_leading_newlines(bytes)))
-    }
+    let header = serde_json::from_str(header).unwrap();
+    Ok((
+        ProguardRecord::R8Header(header),
+        consume_leading_newlines(rest),
+    ))
 }
 
 /// Parses a single Proguard Field or Method from a Proguard File.
@@ -763,10 +784,9 @@ mod tests {
         let parsed = ProguardRecord::try_parse(bytes);
         assert_eq!(
             parsed,
-            Ok(ProguardRecord::Header {
-                key: "sourceFile",
-                value: Some("Foobar.kt")
-            })
+            Ok(ProguardRecord::R8Header(R8Header::SourceFile {
+                file_name: "Foobar.kt",
+            }))
         );
     }