//! FIXME: write short doc here mod block; use crate::{ ast, match_ast, AstNode, SyntaxError, SyntaxKind::{BYTE, BYTE_STRING, CHAR, CONST, FN, INT_NUMBER, STRING, TYPE_ALIAS}, SyntaxNode, SyntaxToken, TextSize, T, }; use rustc_lexer::unescape::{ self, unescape_byte, unescape_byte_literal, unescape_char, unescape_literal, Mode, }; use std::convert::TryFrom; fn rustc_unescape_error_to_string(err: unescape::EscapeError) -> &'static str { use unescape::EscapeError as EE; #[rustfmt::skip] let err_message = match err { EE::ZeroChars => { "Literal must not be empty" } EE::MoreThanOneChar => { "Literal must be one character long" } EE::LoneSlash => { "Character must be escaped: `\\`" } EE::InvalidEscape => { "Invalid escape" } EE::BareCarriageReturn | EE::BareCarriageReturnInRawString => { "Character must be escaped: `\r`" } EE::EscapeOnlyChar => { "Escape character `\\` must be escaped itself" } EE::TooShortHexEscape => { "ASCII hex escape code must have exactly two digits" } EE::InvalidCharInHexEscape => { "ASCII hex escape code must contain only hex characters" } EE::OutOfRangeHexEscape => { "ASCII hex escape code must be at most 0x7F" } EE::NoBraceInUnicodeEscape => { "Missing `{` to begin the unicode escape" } EE::InvalidCharInUnicodeEscape => { "Unicode escape must contain only hex characters and underscores" } EE::EmptyUnicodeEscape => { "Unicode escape must not be empty" } EE::UnclosedUnicodeEscape => { "Missing `}` to terminate the unicode escape" } EE::LeadingUnderscoreUnicodeEscape => { "Unicode escape code must not begin with an underscore" } EE::OverlongUnicodeEscape => { "Unicode escape code must have at most 6 digits" } EE::LoneSurrogateUnicodeEscape => { "Unicode escape code must not be a surrogate" } EE::OutOfRangeUnicodeEscape => { "Unicode escape code must be at most 0x10FFFF" } EE::UnicodeEscapeInByte => { "Byte literals must not contain unicode escapes" } EE::NonAsciiCharInByte | EE::NonAsciiCharInByteString => { "Byte literals must not contain non-ASCII characters" } }; err_message } pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> { // FIXME: // * Add unescape validation of raw string literals and raw byte string literals // * Add validation of doc comments are being attached to nodes let mut errors = Vec::new(); for node in root.descendants() { match_ast! { match node { ast::Literal(it) => validate_literal(it, &mut errors), ast::BlockExpr(it) => block::validate_block_expr(it, &mut errors), ast::FieldExpr(it) => validate_numeric_name(it.name_ref(), &mut errors), ast::RecordExprField(it) => validate_numeric_name(it.name_ref(), &mut errors), ast::Visibility(it) => validate_visibility(it, &mut errors), ast::RangeExpr(it) => validate_range_expr(it, &mut errors), ast::PathSegment(it) => validate_path_keywords(it, &mut errors), _ => (), } } } errors } fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) { // FIXME: move this function to outer scope (https://github.com/rust-analyzer/rust-analyzer/pull/2834#discussion_r366196658) fn unquote(text: &str, prefix_len: usize, end_delimiter: char) -> Option<&str> { text.rfind(end_delimiter).and_then(|end| text.get(prefix_len..end)) } let token = literal.token(); let text = token.text().as_str(); // FIXME: lift this lambda refactor to `fn` (https://github.com/rust-analyzer/rust-analyzer/pull/2834#discussion_r366199205) let mut push_err = |prefix_len, (off, err): (usize, unescape::EscapeError)| { let off = token.text_range().start() + TextSize::try_from(off + prefix_len).unwrap(); acc.push(SyntaxError::new_at_offset(rustc_unescape_error_to_string(err), off)); }; match token.kind() { BYTE => { if let Some(Err(e)) = unquote(text, 2, '\'').map(unescape_byte) { push_err(2, e); } } CHAR => { if let Some(Err(e)) = unquote(text, 1, '\'').map(unescape_char) { push_err(1, e); } } BYTE_STRING => { if let Some(without_quotes) = unquote(text, 2, '"') { unescape_byte_literal(without_quotes, Mode::ByteStr, &mut |range, char| { if let Err(err) = char { push_err(2, (range.start, err)); } }) } } STRING => { if let Some(without_quotes) = unquote(text, 1, '"') { unescape_literal(without_quotes, Mode::Str, &mut |range, char| { if let Err(err) = char { push_err(1, (range.start, err)); } }) } } _ => (), } } pub(crate) fn validate_block_structure(root: &SyntaxNode) { let mut stack = Vec::new(); for node in root.descendants() { match node.kind() { T!['{'] => stack.push(node), T!['}'] => { if let Some(pair) = stack.pop() { assert_eq!( node.parent(), pair.parent(), "\nunpaired curleys:\n{}\n{:#?}\n", root.text(), root, ); assert!( node.next_sibling().is_none() && pair.prev_sibling().is_none(), "\nfloating curlys at {:?}\nfile:\n{}\nerror:\n{}\n", node, root.text(), node.text(), ); } } _ => (), } } } fn validate_numeric_name(name_ref: Option<ast::NameRef>, errors: &mut Vec<SyntaxError>) { if let Some(int_token) = int_token(name_ref) { if int_token.text().chars().any(|c| !c.is_digit(10)) { errors.push(SyntaxError::new( "Tuple (struct) field access is only allowed through \ decimal integers with no underscores or suffix", int_token.text_range(), )); } } fn int_token(name_ref: Option<ast::NameRef>) -> Option<SyntaxToken> { name_ref?.syntax().first_child_or_token()?.into_token().filter(|it| it.kind() == INT_NUMBER) } } fn validate_visibility(vis: ast::Visibility, errors: &mut Vec<SyntaxError>) { let parent = match vis.syntax().parent() { Some(it) => it, None => return, }; match parent.kind() { FN | CONST | TYPE_ALIAS => (), _ => return, } let impl_def = match parent.parent().and_then(|it| it.parent()).and_then(ast::Impl::cast) { Some(it) => it, None => return, }; if impl_def.trait_().is_some() { errors.push(SyntaxError::new("Unnecessary visibility qualifier", vis.syntax.text_range())); } } fn validate_range_expr(expr: ast::RangeExpr, errors: &mut Vec<SyntaxError>) { if expr.op_kind() == Some(ast::RangeOp::Inclusive) && expr.end().is_none() { errors.push(SyntaxError::new( "An inclusive range must have an end expression", expr.syntax().text_range(), )); } } fn validate_path_keywords(segment: ast::PathSegment, errors: &mut Vec<SyntaxError>) { use ast::PathSegmentKind; let path = segment.parent_path(); let is_path_start = segment.coloncolon_token().is_none() && path.qualifier().is_none(); if let Some(token) = segment.self_token() { if !is_path_start { errors.push(SyntaxError::new( "The `self` keyword is only allowed as the first segment of a path", token.text_range(), )); } } else if let Some(token) = segment.crate_token() { if !is_path_start || use_prefix(path).is_some() { errors.push(SyntaxError::new( "The `crate` keyword is only allowed as the first segment of a path", token.text_range(), )); } } else if let Some(token) = segment.super_token() { if !all_supers(&path) { errors.push(SyntaxError::new( "The `super` keyword may only be preceded by other `super`s", token.text_range(), )); return; } let mut curr_path = path; while let Some(prefix) = use_prefix(curr_path) { if !all_supers(&prefix) { errors.push(SyntaxError::new( "The `super` keyword may only be preceded by other `super`s", token.text_range(), )); return; } curr_path = prefix; } } fn use_prefix(mut path: ast::Path) -> Option<ast::Path> { for node in path.syntax().ancestors().skip(1) { match_ast! { match node { ast::UseTree(it) => if let Some(tree_path) = it.path() { // Even a top-level path exists within a `UseTree` so we must explicitly // allow our path but disallow anything else if tree_path != path { return Some(tree_path); } }, ast::UseTreeList(_it) => continue, ast::Path(parent) => path = parent, _ => return None, } }; } return None; } fn all_supers(path: &ast::Path) -> bool { let segment = match path.segment() { Some(it) => it, None => return false, }; if segment.kind() != Some(PathSegmentKind::SuperKw) { return false; } if let Some(ref subpath) = path.qualifier() { return all_supers(subpath); } return true; } }