From c56db92d1f9b1a24de24cefd996c43c7b988b4c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adolfo=20Ochagav=C3=ADa?= Date: Tue, 6 Nov 2018 17:05:06 +0100 Subject: [PATCH 1/6] Finish implementing char validation --- crates/ra_syntax/src/string_lexing/mod.rs | 2 +- crates/ra_syntax/src/validation.rs | 83 +++++++++++++++++++-- crates/ra_syntax/src/yellow/syntax_error.rs | 16 ++++ 3 files changed, 93 insertions(+), 8 deletions(-) diff --git a/crates/ra_syntax/src/string_lexing/mod.rs b/crates/ra_syntax/src/string_lexing/mod.rs index f0812ff289..cc53e0abac 100644 --- a/crates/ra_syntax/src/string_lexing/mod.rs +++ b/crates/ra_syntax/src/string_lexing/mod.rs @@ -219,7 +219,7 @@ mod tests { #[test] fn test_unicode_escapes() { - let unicode_escapes = &[r"{DEAD}", "{BEEF}", "{FF}", ""]; + let unicode_escapes = &[r"{DEAD}", "{BEEF}", "{FF}", "{}", ""]; for escape in unicode_escapes { let escape_sequence = format!(r"'\u{}'", escape); let component = closed_char_component(&escape_sequence); diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs index 009f5052f9..a550ce0ab1 100644 --- a/crates/ra_syntax/src/validation.rs +++ b/crates/ra_syntax/src/validation.rs @@ -1,3 +1,5 @@ +use std::u32; + use crate::{ algo::visit::{visitor_ctx, VisitorCtx}, ast::{self, AstNode}, @@ -42,15 +44,82 @@ fn validate_char(node: ast::Char, errors: &mut Vec) { } } AsciiCodeEscape => { - // TODO: - // * First digit is octal - // * Second digit is hex + // An AsciiCodeEscape has 4 chars, example: `\xDD` + if text.len() < 4 { + errors.push(SyntaxError::new(TooShortAsciiCodeEscape, range)); + } else { + assert!(text.chars().count() == 4, "AsciiCodeEscape cannot be longer than 4 chars"); + + match u8::from_str_radix(&text[2..], 16) { + Ok(code) if code < 128 => { /* Escape code is valid */ }, + Ok(_) => errors.push(SyntaxError::new(AsciiCodeEscapeOutOfRange, range)), + Err(_) => errors.push(SyntaxError::new(MalformedAsciiCodeEscape, range)), + } + + } } UnicodeEscape => { - // TODO: - // * Only hex digits or underscores allowed - // * Max 6 chars - // * Within allowed range (must be at most 10FFFF) + assert!(&text[..2] == "\\u", "UnicodeEscape always starts with \\u"); + + if text.len() == 2 { + // No starting `{` + errors.push(SyntaxError::new(MalformedUnicodeEscape, range)); + return; + } + + if text.len() == 3 { + // Only starting `{` + errors.push(SyntaxError::new(UnclosedUnicodeEscape, range)); + return; + } + + let mut code = String::new(); + let mut closed = false; + for c in text[3..].chars() { + assert!(!closed, "no characters after escape is closed"); + + if c.is_digit(16) { + code.push(c); + } else if c == '_' { + // Reject leading _ + if code.len() == 0 { + errors.push(SyntaxError::new(MalformedUnicodeEscape, range)); + return; + } + } else if c == '}' { + closed = true; + } else { + errors.push(SyntaxError::new(MalformedUnicodeEscape, range)); + return; + } + } + + if !closed { + errors.push(SyntaxError::new(UnclosedUnicodeEscape, range)) + } + + if code.len() == 0 { + errors.push(SyntaxError::new(EmptyUnicodeEcape, range)); + return; + } + + if code.len() > 6 { + errors.push(SyntaxError::new(OverlongUnicodeEscape, range)); + } + + match u32::from_str_radix(&code, 16) { + Ok(code_u32) if code_u32 > 0x10FFFF => { + errors.push(SyntaxError::new(UnicodeEscapeOutOfRange, range)); + } + Ok(_) => { + // Valid escape code + } + Err(_) => { + errors.push(SyntaxError::new(MalformedUnicodeEscape, range)); + } + } + + // FIXME: we really need tests for this } // Code points are always valid CodePoint => (), diff --git a/crates/ra_syntax/src/yellow/syntax_error.rs b/crates/ra_syntax/src/yellow/syntax_error.rs index f3df6bc153..9aed9e81ea 100644 --- a/crates/ra_syntax/src/yellow/syntax_error.rs +++ b/crates/ra_syntax/src/yellow/syntax_error.rs @@ -69,6 +69,14 @@ pub enum SyntaxErrorKind { LongChar, EmptyAsciiEscape, InvalidAsciiEscape, + TooShortAsciiCodeEscape, + AsciiCodeEscapeOutOfRange, + MalformedAsciiCodeEscape, + UnclosedUnicodeEscape, + MalformedUnicodeEscape, + EmptyUnicodeEcape, + OverlongUnicodeEscape, + UnicodeEscapeOutOfRange, } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -83,6 +91,14 @@ impl fmt::Display for SyntaxErrorKind { EmptyChar => write!(f, "Empty char literal"), UnclosedChar => write!(f, "Unclosed char literal"), LongChar => write!(f, "Char literal should be one character long"), + TooShortAsciiCodeEscape => write!(f, "Escape sequence should have two digits"), + AsciiCodeEscapeOutOfRange => write!(f, "Escape sequence should be between \\x00 and \\x7F"), + MalformedAsciiCodeEscape => write!(f, "Escape sequence should be a hexadecimal number"), + UnclosedUnicodeEscape => write!(f, "Missing `}}`"), + MalformedUnicodeEscape => write!(f, "Malformed unicode escape sequence"), + EmptyUnicodeEcape => write!(f, "Empty unicode escape sequence"), + OverlongUnicodeEscape => write!(f, "Unicode escape sequence should have at most 6 digits"), + UnicodeEscapeOutOfRange => write!(f, "Unicode escape code should be at most 0x10FFFF"), ParseError(msg) => write!(f, "{}", msg.0), } } From fdb9f06880ddcf29513a8c2855c3c576cc461014 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adolfo=20Ochagav=C3=ADa?= Date: Wed, 7 Nov 2018 10:40:58 +0100 Subject: [PATCH 2/6] Store hex digits in a stack-allocated buffer --- crates/ra_syntax/src/utils.rs | 37 ++++++++++++++++++++++++++++++ crates/ra_syntax/src/validation.rs | 13 +++++++---- 2 files changed, 45 insertions(+), 5 deletions(-) diff --git a/crates/ra_syntax/src/utils.rs b/crates/ra_syntax/src/utils.rs index 288d7edd4e..5bef4a6393 100644 --- a/crates/ra_syntax/src/utils.rs +++ b/crates/ra_syntax/src/utils.rs @@ -1,5 +1,7 @@ use crate::{File, SyntaxKind, SyntaxNodeRef, WalkEvent}; use std::fmt::Write; +use std::ops::Deref; +use std::str; /// Parse a file and create a string representation of the resulting parse tree. pub fn dump_tree(syntax: SyntaxNodeRef) -> String { @@ -78,3 +80,38 @@ pub(crate) fn validate_block_structure(root: SyntaxNodeRef) { } } } + +#[derive(Debug)] +pub struct MutAsciiString<'a> { + buf: &'a mut [u8], + len: usize, +} + +impl<'a> MutAsciiString<'a> { + pub fn new(buf: &'a mut [u8]) -> MutAsciiString<'a> { + MutAsciiString { buf, len: 0 } + } + + pub fn as_str(&self) -> &str { + str::from_utf8(&self.buf[..self.len]).unwrap() + } + + pub fn len(&self) -> usize { + self.len + } + + pub fn push(&mut self, c: char) { + assert!(self.len() < self.buf.len()); + assert!(c.is_ascii()); + + self.buf[self.len] = c as u8; + self.len += 1; + } +} + +impl<'a> Deref for MutAsciiString<'a> { + type Target = str; + fn deref(&self) -> &str { + self.as_str() + } +} diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs index a550ce0ab1..b560e5e855 100644 --- a/crates/ra_syntax/src/validation.rs +++ b/crates/ra_syntax/src/validation.rs @@ -5,6 +5,7 @@ use crate::{ ast::{self, AstNode}, File, string_lexing::{self, CharComponentKind}, + utils::MutAsciiString, yellow::{ SyntaxError, SyntaxErrorKind::*, @@ -73,12 +74,18 @@ fn validate_char(node: ast::Char, errors: &mut Vec) { return; } - let mut code = String::new(); + let mut buf = &mut [0; 6]; + let mut code = MutAsciiString::new(buf); let mut closed = false; for c in text[3..].chars() { assert!(!closed, "no characters after escape is closed"); if c.is_digit(16) { + if code.len() == 6 { + errors.push(SyntaxError::new(OverlongUnicodeEscape, range)); + return; + } + code.push(c); } else if c == '_' { // Reject leading _ @@ -103,10 +110,6 @@ fn validate_char(node: ast::Char, errors: &mut Vec) { return; } - if code.len() > 6 { - errors.push(SyntaxError::new(OverlongUnicodeEscape, range)); - } - match u32::from_str_radix(&code, 16) { Ok(code_u32) if code_u32 > 0x10FFFF => { errors.push(SyntaxError::new(UnicodeEscapeOutOfRange, range)); From 94796e6447c8af9d7444164c2175ca5dae4a563e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adolfo=20Ochagav=C3=ADa?= Date: Wed, 7 Nov 2018 11:35:33 +0100 Subject: [PATCH 3/6] Add lots of tests --- crates/ra_syntax/src/lexer/ptr.rs | 3 +- crates/ra_syntax/src/validation.rs | 122 +++++++++++++++++++- crates/ra_syntax/src/yellow/syntax_error.rs | 6 + 3 files changed, 125 insertions(+), 6 deletions(-) diff --git a/crates/ra_syntax/src/lexer/ptr.rs b/crates/ra_syntax/src/lexer/ptr.rs index 4c291b9c4d..7e4df51aa8 100644 --- a/crates/ra_syntax/src/lexer/ptr.rs +++ b/crates/ra_syntax/src/lexer/ptr.rs @@ -30,8 +30,7 @@ impl<'s> Ptr<'s> { /// Gets the nth character from the current. /// For example, 0 will return the current token, 1 will return the next, etc. pub fn nth(&self, n: u32) -> Option { - let mut chars = self.chars().peekable(); - chars.by_ref().nth(n as usize) + self.chars().nth(n as usize) } /// Checks whether the current character is `c`. diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs index b560e5e855..1778f4b886 100644 --- a/crates/ra_syntax/src/validation.rs +++ b/crates/ra_syntax/src/validation.rs @@ -121,11 +121,13 @@ fn validate_char(node: ast::Char, errors: &mut Vec) { errors.push(SyntaxError::new(MalformedUnicodeEscape, range)); } } - - // FIXME: we really need tests for this } - // Code points are always valid - CodePoint => (), + CodePoint => { + // These code points must always be escaped + if text == "\t" || text == "\r" { + errors.push(SyntaxError::new(UnescapedCodepoint, range)); + } + }, } } @@ -148,3 +150,115 @@ fn is_ascii_escape(code: char) -> bool { _ => false, } } + +#[cfg(test)] +mod test { + use crate::File; + + fn build_file(literal: &str) -> File { + let src = format!("const C: char = '{}';", literal); + File::parse(&src) + } + + fn assert_valid_char(literal: &str) { + let file = build_file(literal); + assert!(file.errors().len() == 0, "Errors for literal '{}': {:?}", literal, file.errors()); + } + + fn assert_invalid_char(literal: &str) { //, expected_errors: HashSet) { + let file = build_file(literal); + assert!(file.errors().len() > 0); + //let found_errors = file.errors().iter().map(|e| e.kind()).collect(); + } + + #[test] + fn test_ansi_codepoints() { + for byte in 0..=255u8 { + match byte { + b'\n' | b'\r' | b'\t' => assert_invalid_char(&(byte as char).to_string()), + b'\'' | b'\\' => { /* Ignore character close and backslash */ } + _ => assert_valid_char(&(byte as char).to_string()), + } + } + } + + #[test] + fn test_unicode_codepoints() { + let valid = [ + "Ƒ", "バ", "メ", "﷽" + ]; + for c in &valid { + assert_valid_char(c); + } + } + + #[test] + fn test_unicode_multiple_codepoints() { + let invalid = [ + "नी", "👨‍👨‍" + ]; + for c in &invalid { + assert_invalid_char(c); + } + } + + #[test] + fn test_valid_ascii_escape() { + let valid = [ + r"\'", "\"", "\\\"", r"\n", r"\r", r"\t", r"\0", "a", "b" + ]; + for c in &valid { + assert_valid_char(c); + } + } + + #[test] + fn test_invalid_ascii_escape() { + let invalid = [ + r"\a", r"\?", r"\" + ]; + for c in &invalid { + assert_invalid_char(c); + } + } + + #[test] + fn test_valid_ascii_code_escape() { + let valid = [ + r"\x00", r"\x7F", r"\x55" + ]; + for c in &valid { + assert_valid_char(c); + } + } + + #[test] + fn test_invalid_ascii_code_escape() { + let invalid = [ + r"\x", r"\x7", r"\xF0" + ]; + for c in &invalid { + assert_invalid_char(c); + } + } + + #[test] + fn test_valid_unicode_escape() { + let valid = [ + r"\u{FF}", r"\u{0}", r"\u{F}", r"\u{10FFFF}", r"\u{1_0__FF___FF_____}" + ]; + for c in &valid { + assert_valid_char(c); + } + } + + #[test] + fn test_invalid_unicode_escape() { + 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_char(c); + } + } +} diff --git a/crates/ra_syntax/src/yellow/syntax_error.rs b/crates/ra_syntax/src/yellow/syntax_error.rs index 9aed9e81ea..e2e660975b 100644 --- a/crates/ra_syntax/src/yellow/syntax_error.rs +++ b/crates/ra_syntax/src/yellow/syntax_error.rs @@ -34,6 +34,10 @@ impl SyntaxError { } } + pub fn kind(&self) -> SyntaxErrorKind { + self.kind.clone() + } + pub fn location(&self) -> Location { self.location.clone() } @@ -64,6 +68,7 @@ impl fmt::Display for SyntaxError { #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum SyntaxErrorKind { ParseError(ParseError), + UnescapedCodepoint, EmptyChar, UnclosedChar, LongChar, @@ -86,6 +91,7 @@ impl fmt::Display for SyntaxErrorKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use self::SyntaxErrorKind::*; match self { + UnescapedCodepoint => write!(f, "This codepoint should always be escaped"), EmptyAsciiEscape => write!(f, "Empty escape sequence"), InvalidAsciiEscape => write!(f, "Invalid escape sequence"), EmptyChar => write!(f, "Empty char literal"), From e37ba706ccc435346c35042c2b6c4b483494268b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adolfo=20Ochagav=C3=ADa?= Date: Wed, 7 Nov 2018 11:41:42 +0100 Subject: [PATCH 4/6] cargo format --- crates/ra_syntax/src/validation.rs | 61 +++++++++++---------- crates/ra_syntax/src/yellow/syntax_error.rs | 8 ++- 2 files changed, 39 insertions(+), 30 deletions(-) diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs index 1778f4b886..a2509dc907 100644 --- a/crates/ra_syntax/src/validation.rs +++ b/crates/ra_syntax/src/validation.rs @@ -49,14 +49,16 @@ fn validate_char(node: ast::Char, errors: &mut Vec) { if text.len() < 4 { errors.push(SyntaxError::new(TooShortAsciiCodeEscape, range)); } else { - assert!(text.chars().count() == 4, "AsciiCodeEscape cannot be longer than 4 chars"); + assert!( + text.chars().count() == 4, + "AsciiCodeEscape cannot be longer than 4 chars" + ); match u8::from_str_radix(&text[2..], 16) { - Ok(code) if code < 128 => { /* Escape code is valid */ }, + Ok(code) if code < 128 => { /* Escape code is valid */ } Ok(_) => errors.push(SyntaxError::new(AsciiCodeEscapeOutOfRange, range)), Err(_) => errors.push(SyntaxError::new(MalformedAsciiCodeEscape, range)), } - } } UnicodeEscape => { @@ -127,7 +129,7 @@ fn validate_char(node: ast::Char, errors: &mut Vec) { if text == "\t" || text == "\r" { errors.push(SyntaxError::new(UnescapedCodepoint, range)); } - }, + } } } @@ -162,13 +164,17 @@ mod test { fn assert_valid_char(literal: &str) { let file = build_file(literal); - assert!(file.errors().len() == 0, "Errors for literal '{}': {:?}", literal, file.errors()); + assert!( + file.errors().len() == 0, + "Errors for literal '{}': {:?}", + literal, + file.errors() + ); } - fn assert_invalid_char(literal: &str) { //, expected_errors: HashSet) { + fn assert_invalid_char(literal: &str) { let file = build_file(literal); assert!(file.errors().len() > 0); - //let found_errors = file.errors().iter().map(|e| e.kind()).collect(); } #[test] @@ -184,9 +190,7 @@ mod test { #[test] fn test_unicode_codepoints() { - let valid = [ - "Ƒ", "バ", "メ", "﷽" - ]; + let valid = ["Ƒ", "バ", "メ", "﷽"]; for c in &valid { assert_valid_char(c); } @@ -194,9 +198,7 @@ mod test { #[test] fn test_unicode_multiple_codepoints() { - let invalid = [ - "नी", "👨‍👨‍" - ]; + let invalid = ["नी", "👨‍👨‍"]; for c in &invalid { assert_invalid_char(c); } @@ -204,9 +206,7 @@ mod test { #[test] fn test_valid_ascii_escape() { - let valid = [ - r"\'", "\"", "\\\"", r"\n", r"\r", r"\t", r"\0", "a", "b" - ]; + let valid = [r"\'", "\"", "\\\"", r"\n", r"\r", r"\t", r"\0", "a", "b"]; for c in &valid { assert_valid_char(c); } @@ -214,9 +214,7 @@ mod test { #[test] fn test_invalid_ascii_escape() { - let invalid = [ - r"\a", r"\?", r"\" - ]; + let invalid = [r"\a", r"\?", r"\"]; for c in &invalid { assert_invalid_char(c); } @@ -224,9 +222,7 @@ mod test { #[test] fn test_valid_ascii_code_escape() { - let valid = [ - r"\x00", r"\x7F", r"\x55" - ]; + let valid = [r"\x00", r"\x7F", r"\x55"]; for c in &valid { assert_valid_char(c); } @@ -234,18 +230,20 @@ mod test { #[test] fn test_invalid_ascii_code_escape() { - let invalid = [ - r"\x", r"\x7", r"\xF0" - ]; + let invalid = [r"\x", r"\x7", r"\xF0"]; for c in &invalid { assert_invalid_char(c); } } - #[test] + #[test] fn test_valid_unicode_escape() { let valid = [ - r"\u{FF}", r"\u{0}", r"\u{F}", r"\u{10FFFF}", r"\u{1_0__FF___FF_____}" + r"\u{FF}", + r"\u{0}", + r"\u{F}", + r"\u{10FFFF}", + r"\u{1_0__FF___FF_____}", ]; for c in &valid { assert_valid_char(c); @@ -255,7 +253,14 @@ mod test { #[test] fn test_invalid_unicode_escape() { let invalid = [ - r"\u", r"\u{}", r"\u{", r"\u{FF", r"\u{FFFFFF}", r"\u{_F}", r"\u{00FFFFF}", r"\u{110000}" + 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_char(c); diff --git a/crates/ra_syntax/src/yellow/syntax_error.rs b/crates/ra_syntax/src/yellow/syntax_error.rs index e2e660975b..c524adf395 100644 --- a/crates/ra_syntax/src/yellow/syntax_error.rs +++ b/crates/ra_syntax/src/yellow/syntax_error.rs @@ -98,12 +98,16 @@ impl fmt::Display for SyntaxErrorKind { UnclosedChar => write!(f, "Unclosed char literal"), LongChar => write!(f, "Char literal should be one character long"), TooShortAsciiCodeEscape => write!(f, "Escape sequence should have two digits"), - AsciiCodeEscapeOutOfRange => write!(f, "Escape sequence should be between \\x00 and \\x7F"), + AsciiCodeEscapeOutOfRange => { + write!(f, "Escape sequence should be between \\x00 and \\x7F") + } MalformedAsciiCodeEscape => write!(f, "Escape sequence should be a hexadecimal number"), UnclosedUnicodeEscape => write!(f, "Missing `}}`"), MalformedUnicodeEscape => write!(f, "Malformed unicode escape sequence"), EmptyUnicodeEcape => write!(f, "Empty unicode escape sequence"), - OverlongUnicodeEscape => write!(f, "Unicode escape sequence should have at most 6 digits"), + OverlongUnicodeEscape => { + write!(f, "Unicode escape sequence should have at most 6 digits") + } UnicodeEscapeOutOfRange => write!(f, "Unicode escape code should be at most 0x10FFFF"), ParseError(msg) => write!(f, "{}", msg.0), } From 3b2ba59526f8e524aa3c1526dda2828a93653ed2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adolfo=20Ochagav=C3=ADa?= Date: Wed, 7 Nov 2018 11:58:34 +0100 Subject: [PATCH 5/6] Use ArrayString instead of hand rolled data structure --- Cargo.lock | 1 + crates/ra_syntax/Cargo.toml | 1 + crates/ra_syntax/src/lib.rs | 1 + crates/ra_syntax/src/utils.rs | 36 ------------------------------ crates/ra_syntax/src/validation.rs | 6 ++--- 5 files changed, 6 insertions(+), 39 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index fd1fb5ea5a..555efdfb91 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -671,6 +671,7 @@ dependencies = [ name = "ra_syntax" version = "0.1.0" dependencies = [ + "arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)", "drop_bomb 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)", "itertools 0.7.8 (registry+https://github.com/rust-lang/crates.io-index)", "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml index de4b25e673..0f709026f4 100644 --- a/crates/ra_syntax/Cargo.toml +++ b/crates/ra_syntax/Cargo.toml @@ -8,6 +8,7 @@ description = "Comment and whitespace preserving parser for the Rust langauge" repository = "https://github.com/rust-analyzer/rust-analyzer" [dependencies] +arrayvec = "0.4.7" unicode-xid = "0.1.0" itertools = "0.7.8" drop_bomb = "0.1.4" diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs index 1230028257..319fb947d3 100644 --- a/crates/ra_syntax/src/lib.rs +++ b/crates/ra_syntax/src/lib.rs @@ -20,6 +20,7 @@ #![allow(missing_docs)] //#![warn(unreachable_pub)] // rust-lang/rust#47816 +extern crate arrayvec; extern crate drop_bomb; extern crate itertools; extern crate parking_lot; diff --git a/crates/ra_syntax/src/utils.rs b/crates/ra_syntax/src/utils.rs index 5bef4a6393..cad9544bef 100644 --- a/crates/ra_syntax/src/utils.rs +++ b/crates/ra_syntax/src/utils.rs @@ -1,6 +1,5 @@ use crate::{File, SyntaxKind, SyntaxNodeRef, WalkEvent}; use std::fmt::Write; -use std::ops::Deref; use std::str; /// Parse a file and create a string representation of the resulting parse tree. @@ -80,38 +79,3 @@ pub(crate) fn validate_block_structure(root: SyntaxNodeRef) { } } } - -#[derive(Debug)] -pub struct MutAsciiString<'a> { - buf: &'a mut [u8], - len: usize, -} - -impl<'a> MutAsciiString<'a> { - pub fn new(buf: &'a mut [u8]) -> MutAsciiString<'a> { - MutAsciiString { buf, len: 0 } - } - - pub fn as_str(&self) -> &str { - str::from_utf8(&self.buf[..self.len]).unwrap() - } - - pub fn len(&self) -> usize { - self.len - } - - pub fn push(&mut self, c: char) { - assert!(self.len() < self.buf.len()); - assert!(c.is_ascii()); - - self.buf[self.len] = c as u8; - self.len += 1; - } -} - -impl<'a> Deref for MutAsciiString<'a> { - type Target = str; - fn deref(&self) -> &str { - self.as_str() - } -} diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs index a2509dc907..61cf83c846 100644 --- a/crates/ra_syntax/src/validation.rs +++ b/crates/ra_syntax/src/validation.rs @@ -1,11 +1,12 @@ use std::u32; +use arrayvec::ArrayString; + use crate::{ algo::visit::{visitor_ctx, VisitorCtx}, ast::{self, AstNode}, File, string_lexing::{self, CharComponentKind}, - utils::MutAsciiString, yellow::{ SyntaxError, SyntaxErrorKind::*, @@ -76,8 +77,7 @@ fn validate_char(node: ast::Char, errors: &mut Vec) { return; } - let mut buf = &mut [0; 6]; - let mut code = MutAsciiString::new(buf); + let mut code = ArrayString::<[_; 6]>::new(); let mut closed = false; for c in text[3..].chars() { assert!(!closed, "no characters after escape is closed"); From 433a8061910a388f777b839eb67f2582f91b6c7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adolfo=20Ochagav=C3=ADa?= Date: Wed, 7 Nov 2018 12:03:02 +0100 Subject: [PATCH 6/6] Fix backslash escape --- crates/ra_syntax/src/validation.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs index 61cf83c846..9cb9ccc411 100644 --- a/crates/ra_syntax/src/validation.rs +++ b/crates/ra_syntax/src/validation.rs @@ -148,7 +148,7 @@ fn validate_char(node: ast::Char, errors: &mut Vec) { fn is_ascii_escape(code: char) -> bool { match code { - '\'' | '"' | 'n' | 'r' | 't' | '0' => true, + '\\' | '\'' | '"' | 'n' | 'r' | 't' | '0' => true, _ => false, } } @@ -206,7 +206,9 @@ mod test { #[test] fn test_valid_ascii_escape() { - let valid = [r"\'", "\"", "\\\"", r"\n", r"\r", r"\t", r"\0", "a", "b"]; + let valid = [ + r"\'", "\"", "\\\\", "\\\"", r"\n", r"\r", r"\t", r"\0", "a", "b", + ]; for c in &valid { assert_valid_char(c); }