2018-11-11 20:27:00 +01:00
|
|
|
//! Validation of char literals
|
|
|
|
|
2018-11-08 15:42:00 +01:00
|
|
|
use std::u32;
|
|
|
|
|
|
|
|
use arrayvec::ArrayString;
|
|
|
|
|
|
|
|
use crate::{
|
2019-01-08 10:23:10 +01:00
|
|
|
ast::{self, AstNode, AstToken},
|
2018-12-27 12:42:46 +01:00
|
|
|
string_lexing::{self, StringComponentKind},
|
2018-11-08 15:42:00 +01:00
|
|
|
TextRange,
|
|
|
|
yellow::{
|
|
|
|
SyntaxError,
|
|
|
|
SyntaxErrorKind::*,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2019-01-07 14:15:47 +01:00
|
|
|
pub(super) fn validate_char_node(node: &ast::Char, errors: &mut Vec<SyntaxError>) {
|
2018-11-08 15:42:00 +01:00
|
|
|
let literal_text = node.text();
|
|
|
|
let literal_range = node.syntax().range();
|
|
|
|
let mut components = string_lexing::parse_char_literal(literal_text);
|
|
|
|
let mut len = 0;
|
|
|
|
for component in &mut components {
|
|
|
|
len += 1;
|
|
|
|
let text = &literal_text[component.range];
|
|
|
|
let range = component.range + literal_range.start();
|
|
|
|
validate_char_component(text, component.kind, range, errors);
|
|
|
|
}
|
|
|
|
|
|
|
|
if !components.has_closing_quote {
|
|
|
|
errors.push(SyntaxError::new(UnclosedChar, literal_range));
|
|
|
|
}
|
|
|
|
|
2018-12-27 13:03:18 +01:00
|
|
|
if let Some(range) = components.suffix {
|
2018-12-27 13:10:30 +01:00
|
|
|
errors.push(SyntaxError::new(
|
|
|
|
InvalidSuffix,
|
|
|
|
range + literal_range.start(),
|
|
|
|
));
|
2018-12-27 13:03:18 +01:00
|
|
|
}
|
|
|
|
|
2018-11-08 15:42:00 +01:00
|
|
|
if len == 0 {
|
|
|
|
errors.push(SyntaxError::new(EmptyChar, literal_range));
|
|
|
|
}
|
|
|
|
|
|
|
|
if len > 1 {
|
|
|
|
errors.push(SyntaxError::new(OverlongChar, literal_range));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-11 20:27:00 +01:00
|
|
|
pub(super) fn validate_char_component(
|
2018-11-08 15:42:00 +01:00
|
|
|
text: &str,
|
2018-12-27 12:42:46 +01:00
|
|
|
kind: StringComponentKind,
|
2018-11-08 15:42:00 +01:00
|
|
|
range: TextRange,
|
|
|
|
errors: &mut Vec<SyntaxError>,
|
|
|
|
) {
|
|
|
|
// Validate escapes
|
2018-12-27 12:42:46 +01:00
|
|
|
use self::StringComponentKind::*;
|
2018-11-08 15:42:00 +01:00
|
|
|
match kind {
|
2018-11-11 20:27:00 +01:00
|
|
|
AsciiEscape => validate_ascii_escape(text, range, errors),
|
|
|
|
AsciiCodeEscape => validate_ascii_code_escape(text, range, errors),
|
|
|
|
UnicodeEscape => validate_unicode_escape(text, range, errors),
|
|
|
|
CodePoint => {
|
|
|
|
// These code points must always be escaped
|
|
|
|
if text == "\t" || text == "\r" || text == "\n" {
|
|
|
|
errors.push(SyntaxError::new(UnescapedCodepoint, range));
|
2018-11-08 15:42:00 +01:00
|
|
|
}
|
|
|
|
}
|
2018-12-27 12:42:46 +01:00
|
|
|
StringComponentKind::IgnoreNewline => { /* always valid */ }
|
2018-11-11 20:27:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn validate_ascii_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
|
|
|
|
if text.len() == 1 {
|
2018-12-29 13:40:08 +01:00
|
|
|
// Escape sequence consists only of leading `\` (only occurs at EOF, otherwise e.g. '\' is treated as an unclosed char containing a single quote `'`)
|
2018-11-11 20:27:00 +01:00
|
|
|
errors.push(SyntaxError::new(EmptyAsciiEscape, range));
|
|
|
|
} else {
|
|
|
|
let escape_code = text.chars().skip(1).next().unwrap();
|
|
|
|
if !is_ascii_escape(escape_code) {
|
|
|
|
errors.push(SyntaxError::new(InvalidAsciiEscape, range));
|
2018-11-08 15:42:00 +01:00
|
|
|
}
|
2018-11-11 20:27:00 +01:00
|
|
|
}
|
|
|
|
}
|
2018-11-08 15:42:00 +01:00
|
|
|
|
2018-11-11 20:27:00 +01:00
|
|
|
pub(super) fn is_ascii_escape(code: char) -> bool {
|
|
|
|
match code {
|
|
|
|
'\\' | '\'' | '"' | 'n' | 'r' | 't' | '0' => true,
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
2018-11-08 15:42:00 +01:00
|
|
|
|
2018-11-11 20:27:00 +01:00
|
|
|
fn validate_ascii_code_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
|
|
|
|
// An AsciiCodeEscape has 4 chars, example: `\xDD`
|
2019-01-01 00:02:04 +01:00
|
|
|
if !text.is_ascii() {
|
|
|
|
// TODO: Give a more precise error message (say what the invalid character was)
|
|
|
|
errors.push(SyntaxError::new(AsciiCodeEscapeOutOfRange, range));
|
2019-01-01 12:10:08 +01:00
|
|
|
} else if text.chars().count() < 4 {
|
2018-11-11 20:27:00 +01:00
|
|
|
errors.push(SyntaxError::new(TooShortAsciiCodeEscape, range));
|
|
|
|
} else {
|
2019-01-01 00:02:04 +01:00
|
|
|
assert_eq!(
|
2019-01-01 12:10:08 +01:00
|
|
|
text.chars().count(),
|
2019-01-01 00:02:04 +01:00
|
|
|
4,
|
|
|
|
"AsciiCodeEscape cannot be longer than 4 chars, but text '{}' is",
|
|
|
|
text,
|
2018-11-11 20:27:00 +01:00
|
|
|
);
|
2018-11-08 15:42:00 +01:00
|
|
|
|
2018-11-11 20:27:00 +01:00
|
|
|
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)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-11-08 15:42:00 +01:00
|
|
|
|
2018-11-11 20:27:00 +01:00
|
|
|
fn validate_unicode_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
|
|
|
|
assert!(&text[..2] == "\\u", "UnicodeEscape always starts with \\u");
|
2018-11-08 15:42:00 +01:00
|
|
|
|
2018-11-11 20:27:00 +01:00
|
|
|
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 = ArrayString::<[_; 6]>::new();
|
|
|
|
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));
|
2018-11-08 15:42:00 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-11-11 20:27:00 +01:00
|
|
|
code.push(c);
|
|
|
|
} else if c == '_' {
|
|
|
|
// Reject leading _
|
|
|
|
if code.len() == 0 {
|
|
|
|
errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
|
|
|
|
return;
|
2018-11-08 15:42:00 +01:00
|
|
|
}
|
2018-11-11 20:27:00 +01:00
|
|
|
} else if c == '}' {
|
|
|
|
closed = true;
|
|
|
|
} else {
|
|
|
|
errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
|
|
|
|
return;
|
2018-11-08 15:42:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-11 20:27:00 +01:00
|
|
|
if !closed {
|
|
|
|
errors.push(SyntaxError::new(UnclosedUnicodeEscape, range))
|
|
|
|
}
|
|
|
|
|
|
|
|
if code.len() == 0 {
|
|
|
|
errors.push(SyntaxError::new(EmptyUnicodeEcape, range));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
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));
|
|
|
|
}
|
2018-11-08 15:42:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
2019-01-11 17:59:06 +01:00
|
|
|
use crate::{SourceFile, TreeArc};
|
2018-11-08 15:42:00 +01:00
|
|
|
|
2019-01-11 17:59:06 +01:00
|
|
|
fn build_file(literal: &str) -> TreeArc<SourceFile> {
|
2018-11-08 15:42:00 +01:00
|
|
|
let src = format!("const C: char = '{}';", literal);
|
2019-01-07 14:15:47 +01:00
|
|
|
SourceFile::parse(&src)
|
2018-11-08 15:42:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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) {
|
|
|
|
let file = build_file(literal);
|
|
|
|
assert!(file.errors().len() > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[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() {
|
2018-11-11 21:00:31 +01:00
|
|
|
let valid = [r"\'", "\"", "\\\\", "\\\"", r"\n", r"\r", r"\t", r"\0"];
|
2018-11-08 15:42:00 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|