Merge #1253

1253: Share literal validation logic with compiler r=matklad a=matklad

This is neat: the unescape module is literary what compiler is using right now:

https://github.com/rust-lang/rust/blob/c6ac57564852cb6e2d0db60f7b46d9eb98d4b449/src/libsyntax/parse/unescape.rs

So, yeah, code sharing via copy-paste!



Co-authored-by: Aleksey Kladov <[email protected]>

1 files changed, 0 insertions, 169 deletions

diff --git a/crates/ra_syntax/src/validation/byte_string.rs b/crates/ra_syntax/src/validation/byte_string.rs
deleted file mode 100644
index 1d48c2d9b..000000000
--- a/crates/ra_syntax/src/validation/byte_string.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-use crate::{
-    string_lexing::{self, StringComponentKind},
-    SyntaxError,
-    SyntaxErrorKind::*,
-    SyntaxToken,
-};
-
-use super::byte;
-
-pub(crate) fn validate_byte_string_node(node: SyntaxToken, errors: &mut Vec<SyntaxError>) {
-    let literal_text = node.text();
-    let literal_range = node.range();
-    let mut components = string_lexing::parse_quoted_literal(Some('b'), '"', literal_text);
-    for component in &mut components {
-        let range = component.range + literal_range.start();
-
-        match component.kind {
-            StringComponentKind::IgnoreNewline => { /* always valid */ }
-            _ => {
-                // Chars must escape \t, \n and \r codepoints, but strings don't
-                let text = &literal_text[component.range];
-                match text {
-                    "\t" | "\n" | "\r" => { /* always valid */ }
-                    _ => byte::validate_byte_component(text, component.kind, range, errors),
-                }
-            }
-        }
-    }
-
-    if !components.has_closing_quote {
-        errors.push(SyntaxError::new(UnclosedString, literal_range));
-    }
-
-    if let Some(range) = components.suffix {
-        errors.push(SyntaxError::new(InvalidSuffix, range + literal_range.start()));
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::{SourceFile, TreeArc};
-
-    fn build_file(literal: &str) -> TreeArc<SourceFile> {
-        let src = format!(r#"const S: &'static [u8] = b"{}";"#, literal);
-        println!("Source: {}", src);
-        SourceFile::parse(&src)
-    }
-
-    fn assert_valid_str(literal: &str) {
-        let file = build_file(literal);
-        assert!(file.errors().len() == 0, "Errors for literal '{}': {:?}", literal, file.errors());
-    }
-
-    fn assert_invalid_str(literal: &str) {
-        let file = build_file(literal);
-        assert!(file.errors().len() > 0);
-    }
-
-    #[test]
-    fn test_ansi_codepoints() {
-        for byte in 0..128 {
-            match byte {
-                b'\"' | b'\\' => { /* Ignore string close and backslash */ }
-                _ => assert_valid_str(&(byte as char).to_string()),
-            }
-        }
-
-        for byte in 128..=255u8 {
-            assert_invalid_str(&(byte as char).to_string());
-        }
-    }
-
-    #[test]
-    fn test_unicode_codepoints() {
-        let invalid = ["Ƒ", "バ", "メ", "﷽"];
-        for c in &invalid {
-            assert_invalid_str(c);
-        }
-    }
-
-    #[test]
-    fn test_unicode_multiple_codepoints() {
-        let invalid = ["नी", "👨‍👨‍"];
-        for c in &invalid {
-            assert_invalid_str(c);
-        }
-    }
-
-    #[test]
-    fn test_valid_ascii_escape() {
-        let valid = [r"\'", r#"\""#, r"\\", r"\n", r"\r", r"\t", r"\0", "a", "b"];
-        for c in &valid {
-            assert_valid_str(c);
-        }
-    }
-
-    #[test]
-    fn test_invalid_ascii_escape() {
-        let invalid = [r"\a", r"\?", r"\"];
-        for c in &invalid {
-            assert_invalid_str(c);
-        }
-    }
-
-    #[test]
-    fn test_valid_ascii_code_escape() {
-        let valid = [r"\x00", r"\x7F", r"\x55", r"\xF0"];
-        for c in &valid {
-            assert_valid_str(c);
-        }
-    }
-
-    #[test]
-    fn test_invalid_ascii_code_escape() {
-        let invalid = [r"\x", r"\x7"];
-        for c in &invalid {
-            assert_invalid_str(c);
-        }
-    }
-
-    #[test]
-    fn test_invalid_unicode_escape() {
-        let well_formed = [r"\u{FF}", r"\u{0}", r"\u{F}", r"\u{10FFFF}", r"\u{1_0__FF___FF_____}"];
-        for c in &well_formed {
-            assert_invalid_str(c);
-        }
-
-        let invalid = [
-            r"\u",
-            r"\u{}",
-            r"\u{",
-            r"\u{FF",
-            r"\u{FFFFFF}",
-            r"\u{_F}",
-            r"\u{00FFFFF}",
-            r"\u{110000}",
-        ];
-        for c in &invalid {
-            assert_invalid_str(c);
-        }
-    }
-
-    #[test]
-    fn test_mixed_invalid() {
-        assert_invalid_str(
-            r"This is the tale of a string
-with a newline in between, some emoji (👨‍👨‍) here and there,
-unicode escapes like this: \u{1FFBB} and weird stuff like
-this ﷽",
-        );
-    }
-
-    #[test]
-    fn test_mixed_valid() {
-        assert_valid_str(
-            r"This is the tale of a string
-with a newline in between, no emoji at all,
-nor unicode escapes or weird stuff",
-        );
-    }
-
-    #[test]
-    fn test_ignore_newline() {
-        assert_valid_str(
-            "Hello \
-             World",
-        );
-    }
-}