Add support for parsing Rust-style string continuation escapes (#617)

Author: thurn

CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Format Changes
+
+- Add support for parsing Rust-style string continuation escapes ([#585](https://github.com/ron-rs/ron/issues/585))
+
 ## [0.12.2] - 2026-06-22
 
 ### Format Changes

docs/grammar.md

@@ -81,15 +81,24 @@ float_suffix = "f", ("32", "64");
 ```ebnf
 string = string_std | string_raw;
 string_std = "\"", { no_double_quotation_marks | string_escape }, "\"";
-string_escape = "\\", (escape_ascii | escape_byte | escape_unicode);
+string_escape = "\\", (escape_ascii | escape_byte | escape_unicode | escape_line);
 string_raw = "r", string_raw_content;
 string_raw_content = ("#", string_raw_content, "#") | "\"", { unicode_non_greedy }, "\"";
 
 escape_ascii = "'" | "\"" | "\\" | "n" | "r" | "t" | "0";
 escape_byte = "x", digit_hexadecimal, digit_hexadecimal;
 escape_unicode = "u", digit_hexadecimal, [digit_hexadecimal, [digit_hexadecimal, [digit_hexadecimal, [digit_hexadecimal, [digit_hexadecimal]]]]];
+escape_line = ("\n" | "\r\n"), { "\t" | "\n" | "\r" | " " };
 ```
 
+> Note: RON supports [Rust-style string continuation escapes]. A backslash
+  immediately before LF removes that LF and all subsequent spaces, tabs,
+  carriage returns, and line feeds. RON also accepts CRLF at the continuation
+  site, treating it as LF. String continuation escapes are supported in both
+  standard strings and standard byte strings. Raw strings and raw byte strings
+  keep string continuation escapes as-is. Rust warns when a continuation skips
+  additional lines; RON accepts them without a warning.
+
 > Note: Raw strings start with an `r`, followed by n `#`s and a quotation mark
   `"`. They may contain any characters or escapes (except the end sequence).
   A raw string ends with a quotation mark (`"`), followed by n `#`s. n may be
@@ -103,6 +112,7 @@ Raw strings cannot be written in EBNF, as they are context-sensitive.
 Also see [the Rust document] about context-sensitivity of raw strings.
 
 [the Rust document]: https://github.com/rust-lang/rust/blob/d046ffddc4bd50e04ffc3ff9f766e2ac71f74d50/src/grammar/raw-string-literal-ambiguity.md
+[Rust-style string continuation escapes]: https://doc.rust-lang.org/reference/expressions/literal-expr.html#string-continuation-escapes
 
 ## Byte String
 
@@ -208,4 +218,4 @@ ident_raw = "r", "#", ident_raw_rest, { ident_raw_rest };
 ident_raw_rest = ident_std_rest | "." | "+" | "-";
 ```
 
-> Note: [XID_Start](http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Start%3A%5D&abb=on&g=&i=) and [XID_Continue](http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Continue%3A%5D&abb=on&g=&i=) refer to Unicode character sets.
+> Note: [XID_Start](http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Start%3A%5D&abb=on&g=&i=) and [XID_Continue](http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Continue%3A%5D&abb=on&g=&i=) refer to Unicode character sets.

src/parse.rs

@@ -50,6 +50,10 @@ pub const fn is_whitespace_char(c: char) -> bool {
     )
 }
 
+const fn is_string_continuation_whitespace(c: char) -> bool {
+    matches!(c, ' ' | '\t' | '\n' | '\r')
+}
+
 #[cfg(feature = "integer128")]
 pub(crate) type LargeUInt = u128;
 #[cfg(not(feature = "integer128"))]
@@ -1215,16 +1219,18 @@ impl<'a> Parser<'a> {
             loop {
                 self.advance_bytes(i + 1);
 
-                match self.parse_escape(encoding, false)? {
-                    EscapeCharacter::Ascii(c) => s.push(c),
-                    EscapeCharacter::Utf8(c) => match c.len_utf8() {
-                        1 => s.push(c as u8),
-                        len => {
-                            let start = s.len();
-                            s.extend(core::iter::repeat(0).take(len));
-                            c.encode_utf8(&mut s[start..]);
-                        }
-                    },
+                if !self.consume_string_continuation() {
+                    match self.parse_escape(encoding, false)? {
+                        EscapeCharacter::Ascii(c) => s.push(c),
+                        EscapeCharacter::Utf8(c) => match c.len_utf8() {
+                            1 => s.push(c as u8),
+                            len => {
+                                let start = s.len();
+                                s.extend(core::iter::repeat(0).take(len));
+                                c.encode_utf8(&mut s[start..]);
+                            }
+                        },
+                    }
                 }
 
                 // Unlike the non-escaped case above, searching for '"' and '\\'
@@ -1255,6 +1261,27 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Consumes a string continuation after its leading `\`.
+    ///
+    /// Rust [normalizes CRLF before lexing](https://doc.rust-lang.org/reference/input-format.html#crlf-normalization),
+    /// so RON accepts CRLF directly too.
+    fn consume_string_continuation(&mut self) -> bool {
+        let line_ending_len = if self.check_str("\r\n") {
+            2
+        } else if self.check_char('\n') {
+            1
+        } else {
+            return false;
+        };
+
+        self.advance_bytes(line_ending_len);
+
+        let whitespace = self.next_chars_while_len(is_string_continuation_whitespace);
+        self.advance_bytes(whitespace);
+
+        true
+    }
+
     fn raw_byte_buf(&mut self) -> Result<(ParsedByteStr<'a>, usize)> {
         let num_hashes = self.next_chars_while_len(|c| c == '#');
         let hashes = &self.src()[..num_hashes];

tests/escape.rs

@@ -98,3 +98,71 @@ fn test_nul_in_string() {
     check_same("Hello\x00World!".to_owned());
     check_same("Hello\u{0}World!".to_owned());
 }
+
+#[test]
+fn test_string_continuation_escape() {
+    let cases = [
+        (concat!("\"foo\\", "\n    bar\""), "foobar"),
+        (concat!("\"foo\\", "\n\n    \\nbar\""), "foo\nbar"),
+        (concat!("\"foo\\", "\r\n \tbar\""), "foobar"),
+        (concat!("\"foo\\", "\n\r \tbar\""), "foobar"),
+        (concat!("\"foo\\", "\n\""), "foo"),
+    ];
+
+    for (source, expected) in cases {
+        assert_eq!(from_str::<String>(source).unwrap(), expected);
+    }
+
+    for source in [
+        concat!("b\"foo\\", "\n    bar\""),
+        concat!("b\"foo\\", "\r\n    bar\""),
+    ] {
+        let bytes = from_str::<bytes::Bytes>(source).unwrap();
+        assert_eq!(&*bytes, b"foobar");
+    }
+}
+
+#[test]
+fn test_string_continuation_whitespace_boundary() {
+    let retained = "\u{a0}\u{b}\u{c}\u{85}\u{200e}\u{200f}\u{2028}\u{2029}";
+    let source = ["\"foo\\\n", retained, "bar\""].concat();
+    let expected = ["foo", retained, "bar"].concat();
+
+    assert_eq!(from_str::<String>(&source).unwrap(), expected);
+}
+
+#[test]
+fn test_string_continuation_rejected_outside_strings() {
+    for error in [
+        from_str::<char>(concat!("'\\", "\n'")).unwrap_err().code,
+        from_str::<u8>(concat!("b'\\", "\n'")).unwrap_err().code,
+    ] {
+        assert_eq!(error, ron::Error::InvalidEscape("Unknown escape character"));
+    }
+}
+
+#[test]
+fn test_string_continuation_raw_strings_are_unchanged() {
+    let raw = from_str::<String>(concat!("r\"foo\\", "\n  bar\"")).unwrap();
+    assert_eq!(raw, concat!("foo\\", "\n  bar"));
+
+    let raw_bytes = from_str::<bytes::Bytes>(concat!("br\"foo\\", "\n  bar\"")).unwrap();
+    assert_eq!(&*raw_bytes, concat!("foo\\", "\n  bar").as_bytes());
+}
+
+#[test]
+fn test_string_continuation_errors() {
+    assert_eq!(
+        from_str::<String>(concat!("\"foo\\", "\rbar\""))
+            .unwrap_err()
+            .code,
+        ron::Error::InvalidEscape("Unknown escape character")
+    );
+
+    assert_eq!(
+        from_str::<String>(concat!("\"foo\\", "\n"))
+            .unwrap_err()
+            .code,
+        ron::Error::ExpectedStringEnd
+    );
+}