From a4a1e08ab81193112a2e14413d084916241c3fca Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 20 Feb 2019 16:16:14 +0300 Subject: flatten modules --- crates/ra_syntax/src/lib.rs | 6 +- crates/ra_syntax/src/parsing.rs | 3 +- crates/ra_syntax/src/parsing/builder.rs | 5 +- crates/ra_syntax/src/parsing/parser_impl.rs | 15 +-- crates/ra_syntax/src/parsing/parser_impl/event.rs | 2 +- crates/ra_syntax/src/parsing/reparsing.rs | 3 +- crates/ra_syntax/src/syntax_error.rs | 146 ++++++++++++++++++++++ crates/ra_syntax/src/syntax_node.rs | 11 +- crates/ra_syntax/src/syntax_node/syntax_error.rs | 146 ---------------------- crates/ra_syntax/src/syntax_node/syntax_text.rs | 144 --------------------- crates/ra_syntax/src/syntax_text.rs | 144 +++++++++++++++++++++ crates/ra_syntax/src/validation.rs | 2 +- crates/ra_syntax/src/validation/block.rs | 6 +- crates/ra_syntax/src/validation/byte.rs | 6 +- crates/ra_syntax/src/validation/byte_string.rs | 6 +- crates/ra_syntax/src/validation/char.rs | 6 +- crates/ra_syntax/src/validation/string.rs | 6 +- 17 files changed, 327 insertions(+), 330 deletions(-) create mode 100644 crates/ra_syntax/src/syntax_error.rs delete mode 100644 crates/ra_syntax/src/syntax_node/syntax_error.rs delete mode 100644 crates/ra_syntax/src/syntax_node/syntax_text.rs create mode 100644 crates/ra_syntax/src/syntax_text.rs (limited to 'crates/ra_syntax/src') diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs index 755ccd8e0..edd5b4a28 100644 --- a/crates/ra_syntax/src/lib.rs +++ b/crates/ra_syntax/src/lib.rs @@ -26,12 +26,16 @@ pub mod utils; mod validation; mod syntax_node; mod ptr; +mod syntax_error; +mod syntax_text; pub use rowan::{SmolStr, TextRange, TextUnit}; pub use crate::{ ast::AstNode, syntax_kinds::SyntaxKind, - syntax_node::{Direction, SyntaxError, SyntaxNode, WalkEvent, Location, TreeArc}, + syntax_error::{SyntaxError, SyntaxErrorKind, Location}, + syntax_text::SyntaxText, + syntax_node::{Direction, SyntaxNode, WalkEvent, TreeArc}, ptr::{SyntaxNodePtr, AstPtr}, parsing::{tokenize, Token}, }; diff --git a/crates/ra_syntax/src/parsing.rs b/crates/ra_syntax/src/parsing.rs index 2c92d554e..023e1031c 100644 --- a/crates/ra_syntax/src/parsing.rs +++ b/crates/ra_syntax/src/parsing.rs @@ -8,8 +8,9 @@ mod reparsing; mod grammar; use crate::{ + SyntaxError, parsing::builder::GreenBuilder, - syntax_node::{GreenNode, SyntaxError}, + syntax_node::GreenNode, }; pub use self::lexer::{tokenize, Token}; diff --git a/crates/ra_syntax/src/parsing/builder.rs b/crates/ra_syntax/src/parsing/builder.rs index 9d7ad06fe..9090c60c2 100644 --- a/crates/ra_syntax/src/parsing/builder.rs +++ b/crates/ra_syntax/src/parsing/builder.rs @@ -1,8 +1,9 @@ use crate::{ parsing::parser_impl::Sink, - syntax_node::{GreenNode, RaTypes, SyntaxError}, - SmolStr, SyntaxKind, + syntax_node::{GreenNode, RaTypes}, + SmolStr, SyntaxKind, SyntaxError, }; + use rowan::GreenNodeBuilder; pub(crate) struct GreenBuilder { diff --git a/crates/ra_syntax/src/parsing/parser_impl.rs b/crates/ra_syntax/src/parsing/parser_impl.rs index b710e9d5d..8cce1ab01 100644 --- a/crates/ra_syntax/src/parsing/parser_impl.rs +++ b/crates/ra_syntax/src/parsing/parser_impl.rs @@ -5,15 +5,16 @@ use std::cell::Cell; use crate::{ SmolStr, - syntax_node::syntax_error::{ParseError, SyntaxError}, + syntax_error::{ParseError, SyntaxError}, parsing::{ - lexer::Token, - parser_api::Parser, - parser_impl::{ - event::{Event, EventProcessor}, - input::{InputPosition, ParserInput}, + lexer::Token, + parser_api::Parser, + parser_impl::{ + event::{Event, EventProcessor}, + input::{InputPosition, ParserInput}, + }, }, -}}; +}; use crate::SyntaxKind::{self, EOF, TOMBSTONE}; diff --git a/crates/ra_syntax/src/parsing/parser_impl/event.rs b/crates/ra_syntax/src/parsing/parser_impl/event.rs index fb43e19cc..2ddbdd34d 100644 --- a/crates/ra_syntax/src/parsing/parser_impl/event.rs +++ b/crates/ra_syntax/src/parsing/parser_impl/event.rs @@ -13,7 +13,7 @@ use crate::{ SmolStr, SyntaxKind::{self, *}, TextRange, TextUnit, - syntax_node::syntax_error::{ + syntax_error::{ ParseError, SyntaxError, SyntaxErrorKind, diff --git a/crates/ra_syntax/src/parsing/reparsing.rs b/crates/ra_syntax/src/parsing/reparsing.rs index 0a24dae0e..a88f53dae 100644 --- a/crates/ra_syntax/src/parsing/reparsing.rs +++ b/crates/ra_syntax/src/parsing/reparsing.rs @@ -1,7 +1,8 @@ use crate::{ SyntaxKind::*, TextRange, TextUnit, algo, - syntax_node::{GreenNode, SyntaxError, SyntaxNode}, + syntax_node::{GreenNode, SyntaxNode}, + syntax_error::SyntaxError, parsing::{ grammar, parser_impl, diff --git a/crates/ra_syntax/src/syntax_error.rs b/crates/ra_syntax/src/syntax_error.rs new file mode 100644 index 000000000..4ff998090 --- /dev/null +++ b/crates/ra_syntax/src/syntax_error.rs @@ -0,0 +1,146 @@ +use std::fmt; + +use crate::{TextRange, TextUnit}; + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SyntaxError { + kind: SyntaxErrorKind, + location: Location, +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum Location { + Offset(TextUnit), + Range(TextRange), +} + +impl Into for TextUnit { + fn into(self) -> Location { + Location::Offset(self) + } +} + +impl Into for TextRange { + fn into(self) -> Location { + Location::Range(self) + } +} + +impl SyntaxError { + pub fn new>(kind: SyntaxErrorKind, loc: L) -> SyntaxError { + SyntaxError { kind, location: loc.into() } + } + + pub fn kind(&self) -> SyntaxErrorKind { + self.kind.clone() + } + + pub fn location(&self) -> Location { + self.location.clone() + } + + pub fn offset(&self) -> TextUnit { + match self.location { + Location::Offset(offset) => offset, + Location::Range(range) => range.start(), + } + } + + pub fn add_offset(mut self, plus_offset: TextUnit) -> SyntaxError { + self.location = match self.location { + Location::Range(range) => Location::Range(range + plus_offset), + Location::Offset(offset) => Location::Offset(offset + plus_offset), + }; + + self + } +} + +impl fmt::Display for SyntaxError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + self.kind.fmt(f) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum SyntaxErrorKind { + ParseError(ParseError), + UnescapedCodepoint, + EmptyChar, + UnclosedChar, + OverlongChar, + EmptyByte, + UnclosedByte, + OverlongByte, + ByteOutOfRange, + UnescapedByte, + EmptyByteEscape, + InvalidByteEscape, + TooShortByteCodeEscape, + MalformedByteCodeEscape, + UnicodeEscapeForbidden, + EmptyAsciiEscape, + InvalidAsciiEscape, + TooShortAsciiCodeEscape, + AsciiCodeEscapeOutOfRange, + MalformedAsciiCodeEscape, + UnclosedUnicodeEscape, + MalformedUnicodeEscape, + EmptyUnicodeEcape, + OverlongUnicodeEscape, + UnicodeEscapeOutOfRange, + UnclosedString, + InvalidSuffix, + InvalidBlockAttr, + InvalidMatchInnerAttr, +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParseError(pub String); + +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"), + UnclosedChar => write!(f, "Unclosed char literal"), + OverlongChar => write!(f, "Char literal should be one character long"), + EmptyByte => write!(f, "Empty byte literal"), + UnclosedByte => write!(f, "Unclosed byte literal"), + OverlongByte => write!(f, "Byte literal should be one character long"), + ByteOutOfRange => write!(f, "Byte should be a valid ASCII character"), + UnescapedByte => write!(f, "This byte should always be escaped"), + EmptyByteEscape => write!(f, "Empty escape sequence"), + InvalidByteEscape => write!(f, "Invalid escape sequence"), + TooShortByteCodeEscape => write!(f, "Escape sequence should have two digits"), + MalformedByteCodeEscape => write!(f, "Escape sequence should be a hexadecimal number"), + UnicodeEscapeForbidden => { + write!(f, "Unicode escapes are not allowed in byte literals or byte strings") + } + 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"), + UnclosedString => write!(f, "Unclosed string literal"), + InvalidSuffix => write!(f, "Invalid literal suffix"), + InvalidBlockAttr => { + write!(f, "A block in this position cannot accept inner attributes") + } + InvalidMatchInnerAttr => { + write!(f, "Inner attributes are only allowed directly after the opening brace of the match expression") + } + ParseError(msg) => write!(f, "{}", msg.0), + } + } +} diff --git a/crates/ra_syntax/src/syntax_node.rs b/crates/ra_syntax/src/syntax_node.rs index a0d7c32ec..aa627398d 100644 --- a/crates/ra_syntax/src/syntax_node.rs +++ b/crates/ra_syntax/src/syntax_node.rs @@ -1,13 +1,12 @@ -pub mod syntax_error; -mod syntax_text; - use std::{fmt, borrow::Borrow}; -use self::syntax_text::SyntaxText; -use crate::{SmolStr, SyntaxKind, TextRange}; use rowan::{Types, TransparentNewType}; -pub use self::syntax_error::{SyntaxError, SyntaxErrorKind, Location}; +use crate::{ + SmolStr, SyntaxKind, TextRange, SyntaxText, + syntax_error::SyntaxError, +}; + pub use rowan::WalkEvent; #[derive(Debug, Clone, Copy)] diff --git a/crates/ra_syntax/src/syntax_node/syntax_error.rs b/crates/ra_syntax/src/syntax_node/syntax_error.rs deleted file mode 100644 index 4ff998090..000000000 --- a/crates/ra_syntax/src/syntax_node/syntax_error.rs +++ /dev/null @@ -1,146 +0,0 @@ -use std::fmt; - -use crate::{TextRange, TextUnit}; - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SyntaxError { - kind: SyntaxErrorKind, - location: Location, -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Location { - Offset(TextUnit), - Range(TextRange), -} - -impl Into for TextUnit { - fn into(self) -> Location { - Location::Offset(self) - } -} - -impl Into for TextRange { - fn into(self) -> Location { - Location::Range(self) - } -} - -impl SyntaxError { - pub fn new>(kind: SyntaxErrorKind, loc: L) -> SyntaxError { - SyntaxError { kind, location: loc.into() } - } - - pub fn kind(&self) -> SyntaxErrorKind { - self.kind.clone() - } - - pub fn location(&self) -> Location { - self.location.clone() - } - - pub fn offset(&self) -> TextUnit { - match self.location { - Location::Offset(offset) => offset, - Location::Range(range) => range.start(), - } - } - - pub fn add_offset(mut self, plus_offset: TextUnit) -> SyntaxError { - self.location = match self.location { - Location::Range(range) => Location::Range(range + plus_offset), - Location::Offset(offset) => Location::Offset(offset + plus_offset), - }; - - self - } -} - -impl fmt::Display for SyntaxError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.kind.fmt(f) - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum SyntaxErrorKind { - ParseError(ParseError), - UnescapedCodepoint, - EmptyChar, - UnclosedChar, - OverlongChar, - EmptyByte, - UnclosedByte, - OverlongByte, - ByteOutOfRange, - UnescapedByte, - EmptyByteEscape, - InvalidByteEscape, - TooShortByteCodeEscape, - MalformedByteCodeEscape, - UnicodeEscapeForbidden, - EmptyAsciiEscape, - InvalidAsciiEscape, - TooShortAsciiCodeEscape, - AsciiCodeEscapeOutOfRange, - MalformedAsciiCodeEscape, - UnclosedUnicodeEscape, - MalformedUnicodeEscape, - EmptyUnicodeEcape, - OverlongUnicodeEscape, - UnicodeEscapeOutOfRange, - UnclosedString, - InvalidSuffix, - InvalidBlockAttr, - InvalidMatchInnerAttr, -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParseError(pub String); - -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"), - UnclosedChar => write!(f, "Unclosed char literal"), - OverlongChar => write!(f, "Char literal should be one character long"), - EmptyByte => write!(f, "Empty byte literal"), - UnclosedByte => write!(f, "Unclosed byte literal"), - OverlongByte => write!(f, "Byte literal should be one character long"), - ByteOutOfRange => write!(f, "Byte should be a valid ASCII character"), - UnescapedByte => write!(f, "This byte should always be escaped"), - EmptyByteEscape => write!(f, "Empty escape sequence"), - InvalidByteEscape => write!(f, "Invalid escape sequence"), - TooShortByteCodeEscape => write!(f, "Escape sequence should have two digits"), - MalformedByteCodeEscape => write!(f, "Escape sequence should be a hexadecimal number"), - UnicodeEscapeForbidden => { - write!(f, "Unicode escapes are not allowed in byte literals or byte strings") - } - 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"), - UnclosedString => write!(f, "Unclosed string literal"), - InvalidSuffix => write!(f, "Invalid literal suffix"), - InvalidBlockAttr => { - write!(f, "A block in this position cannot accept inner attributes") - } - InvalidMatchInnerAttr => { - write!(f, "Inner attributes are only allowed directly after the opening brace of the match expression") - } - ParseError(msg) => write!(f, "{}", msg.0), - } - } -} diff --git a/crates/ra_syntax/src/syntax_node/syntax_text.rs b/crates/ra_syntax/src/syntax_node/syntax_text.rs deleted file mode 100644 index 84e5b231a..000000000 --- a/crates/ra_syntax/src/syntax_node/syntax_text.rs +++ /dev/null @@ -1,144 +0,0 @@ -use std::{fmt, ops}; - -use crate::{SyntaxNode, TextRange, TextUnit}; - -#[derive(Clone)] -pub struct SyntaxText<'a> { - node: &'a SyntaxNode, - range: TextRange, -} - -impl<'a> SyntaxText<'a> { - pub(crate) fn new(node: &'a SyntaxNode) -> SyntaxText<'a> { - SyntaxText { node, range: node.range() } - } - - pub fn chunks(&self) -> impl Iterator { - let range = self.range; - self.node.descendants().filter_map(move |node| { - let text = node.leaf_text()?; - let range = range.intersection(&node.range())?; - let range = range - node.range().start(); - Some(&text[range]) - }) - } - - pub fn push_to(&self, buf: &mut String) { - self.chunks().for_each(|it| buf.push_str(it)); - } - - pub fn to_string(&self) -> String { - self.chunks().collect() - } - - pub fn contains(&self, c: char) -> bool { - self.chunks().any(|it| it.contains(c)) - } - - pub fn find(&self, c: char) -> Option { - let mut acc: TextUnit = 0.into(); - for chunk in self.chunks() { - if let Some(pos) = chunk.find(c) { - let pos: TextUnit = (pos as u32).into(); - return Some(acc + pos); - } - acc += TextUnit::of_str(chunk); - } - None - } - - pub fn len(&self) -> TextUnit { - self.range.len() - } - - pub fn slice(&self, range: impl SyntaxTextSlice) -> SyntaxText<'a> { - let range = range.restrict(self.range).unwrap_or_else(|| { - panic!("invalid slice, range: {:?}, slice: {:?}", self.range, range) - }); - SyntaxText { node: self.node, range } - } - - pub fn char_at(&self, offset: impl Into) -> Option { - let mut start: TextUnit = 0.into(); - let offset = offset.into(); - for chunk in self.chunks() { - let end = start + TextUnit::of_str(chunk); - if start <= offset && offset < end { - let off: usize = u32::from(offset - start) as usize; - return Some(chunk[off..].chars().next().unwrap()); - } - start = end; - } - None - } -} - -impl<'a> fmt::Debug for SyntaxText<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&self.to_string(), f) - } -} - -impl<'a> fmt::Display for SyntaxText<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&self.to_string(), f) - } -} - -pub trait SyntaxTextSlice: fmt::Debug { - fn restrict(&self, range: TextRange) -> Option; -} - -impl SyntaxTextSlice for TextRange { - fn restrict(&self, range: TextRange) -> Option { - self.intersection(&range) - } -} - -impl SyntaxTextSlice for ops::RangeTo { - fn restrict(&self, range: TextRange) -> Option { - if !range.contains_inclusive(self.end) { - return None; - } - Some(TextRange::from_to(range.start(), self.end)) - } -} - -impl SyntaxTextSlice for ops::RangeFrom { - fn restrict(&self, range: TextRange) -> Option { - if !range.contains_inclusive(self.start) { - return None; - } - Some(TextRange::from_to(self.start, range.end())) - } -} - -impl SyntaxTextSlice for ops::Range { - fn restrict(&self, range: TextRange) -> Option { - TextRange::from_to(self.start, self.end).restrict(range) - } -} - -impl From> for String { - fn from(text: SyntaxText) -> String { - text.to_string() - } -} - -impl PartialEq for SyntaxText<'_> { - fn eq(&self, mut rhs: &str) -> bool { - for chunk in self.chunks() { - if !rhs.starts_with(chunk) { - return false; - } - rhs = &rhs[chunk.len()..]; - } - rhs.is_empty() - } -} - -impl PartialEq<&'_ str> for SyntaxText<'_> { - fn eq(&self, rhs: &&str) -> bool { - self == *rhs - } -} diff --git a/crates/ra_syntax/src/syntax_text.rs b/crates/ra_syntax/src/syntax_text.rs new file mode 100644 index 000000000..84e5b231a --- /dev/null +++ b/crates/ra_syntax/src/syntax_text.rs @@ -0,0 +1,144 @@ +use std::{fmt, ops}; + +use crate::{SyntaxNode, TextRange, TextUnit}; + +#[derive(Clone)] +pub struct SyntaxText<'a> { + node: &'a SyntaxNode, + range: TextRange, +} + +impl<'a> SyntaxText<'a> { + pub(crate) fn new(node: &'a SyntaxNode) -> SyntaxText<'a> { + SyntaxText { node, range: node.range() } + } + + pub fn chunks(&self) -> impl Iterator { + let range = self.range; + self.node.descendants().filter_map(move |node| { + let text = node.leaf_text()?; + let range = range.intersection(&node.range())?; + let range = range - node.range().start(); + Some(&text[range]) + }) + } + + pub fn push_to(&self, buf: &mut String) { + self.chunks().for_each(|it| buf.push_str(it)); + } + + pub fn to_string(&self) -> String { + self.chunks().collect() + } + + pub fn contains(&self, c: char) -> bool { + self.chunks().any(|it| it.contains(c)) + } + + pub fn find(&self, c: char) -> Option { + let mut acc: TextUnit = 0.into(); + for chunk in self.chunks() { + if let Some(pos) = chunk.find(c) { + let pos: TextUnit = (pos as u32).into(); + return Some(acc + pos); + } + acc += TextUnit::of_str(chunk); + } + None + } + + pub fn len(&self) -> TextUnit { + self.range.len() + } + + pub fn slice(&self, range: impl SyntaxTextSlice) -> SyntaxText<'a> { + let range = range.restrict(self.range).unwrap_or_else(|| { + panic!("invalid slice, range: {:?}, slice: {:?}", self.range, range) + }); + SyntaxText { node: self.node, range } + } + + pub fn char_at(&self, offset: impl Into) -> Option { + let mut start: TextUnit = 0.into(); + let offset = offset.into(); + for chunk in self.chunks() { + let end = start + TextUnit::of_str(chunk); + if start <= offset && offset < end { + let off: usize = u32::from(offset - start) as usize; + return Some(chunk[off..].chars().next().unwrap()); + } + start = end; + } + None + } +} + +impl<'a> fmt::Debug for SyntaxText<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.to_string(), f) + } +} + +impl<'a> fmt::Display for SyntaxText<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Display::fmt(&self.to_string(), f) + } +} + +pub trait SyntaxTextSlice: fmt::Debug { + fn restrict(&self, range: TextRange) -> Option; +} + +impl SyntaxTextSlice for TextRange { + fn restrict(&self, range: TextRange) -> Option { + self.intersection(&range) + } +} + +impl SyntaxTextSlice for ops::RangeTo { + fn restrict(&self, range: TextRange) -> Option { + if !range.contains_inclusive(self.end) { + return None; + } + Some(TextRange::from_to(range.start(), self.end)) + } +} + +impl SyntaxTextSlice for ops::RangeFrom { + fn restrict(&self, range: TextRange) -> Option { + if !range.contains_inclusive(self.start) { + return None; + } + Some(TextRange::from_to(self.start, range.end())) + } +} + +impl SyntaxTextSlice for ops::Range { + fn restrict(&self, range: TextRange) -> Option { + TextRange::from_to(self.start, self.end).restrict(range) + } +} + +impl From> for String { + fn from(text: SyntaxText) -> String { + text.to_string() + } +} + +impl PartialEq for SyntaxText<'_> { + fn eq(&self, mut rhs: &str) -> bool { + for chunk in self.chunks() { + if !rhs.starts_with(chunk) { + return false; + } + rhs = &rhs[chunk.len()..]; + } + rhs.is_empty() + } +} + +impl PartialEq<&'_ str> for SyntaxText<'_> { + fn eq(&self, rhs: &&str) -> bool { + self == *rhs + } +} diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs index 10672d6bf..69958f0d7 100644 --- a/crates/ra_syntax/src/validation.rs +++ b/crates/ra_syntax/src/validation.rs @@ -5,7 +5,7 @@ mod string; mod block; use crate::{ - SourceFile, syntax_node::SyntaxError, AstNode, + SourceFile, SyntaxError, AstNode, ast, algo::visit::{visitor_ctx, VisitorCtx}, }; diff --git a/crates/ra_syntax/src/validation/block.rs b/crates/ra_syntax/src/validation/block.rs index de949d967..f2cf3cbbd 100644 --- a/crates/ra_syntax/src/validation/block.rs +++ b/crates/ra_syntax/src/validation/block.rs @@ -1,9 +1,7 @@ use crate::{SyntaxKind::*, ast::{self, AttrsOwner, AstNode}, - syntax_node::{ - SyntaxError, - SyntaxErrorKind::*, - }, + SyntaxError, + SyntaxErrorKind::*, }; pub(crate) fn validate_block_node(node: &ast::Block, errors: &mut Vec) { diff --git a/crates/ra_syntax/src/validation/byte.rs b/crates/ra_syntax/src/validation/byte.rs index acdc12552..838e7a65f 100644 --- a/crates/ra_syntax/src/validation/byte.rs +++ b/crates/ra_syntax/src/validation/byte.rs @@ -5,10 +5,8 @@ use crate::{ string_lexing::{self, StringComponentKind}, TextRange, validation::char, - syntax_node::{ - SyntaxError, - SyntaxErrorKind::*, - }, + SyntaxError, + SyntaxErrorKind::*, }; pub(super) fn validate_byte_node(node: &ast::Byte, errors: &mut Vec) { diff --git a/crates/ra_syntax/src/validation/byte_string.rs b/crates/ra_syntax/src/validation/byte_string.rs index 69a98b640..64c7054a1 100644 --- a/crates/ra_syntax/src/validation/byte_string.rs +++ b/crates/ra_syntax/src/validation/byte_string.rs @@ -1,10 +1,8 @@ use crate::{ ast::{self, AstNode, AstToken}, string_lexing::{self, StringComponentKind}, - syntax_node::{ - SyntaxError, - SyntaxErrorKind::*, - }, + SyntaxError, + SyntaxErrorKind::*, }; use super::byte; diff --git a/crates/ra_syntax/src/validation/char.rs b/crates/ra_syntax/src/validation/char.rs index 26c15e36d..3169ed590 100644 --- a/crates/ra_syntax/src/validation/char.rs +++ b/crates/ra_syntax/src/validation/char.rs @@ -8,10 +8,8 @@ use crate::{ ast::{self, AstNode, AstToken}, string_lexing::{self, StringComponentKind}, TextRange, - syntax_node::{ - SyntaxError, - SyntaxErrorKind::*, - }, + SyntaxError, + SyntaxErrorKind::*, }; pub(super) fn validate_char_node(node: &ast::Char, errors: &mut Vec) { diff --git a/crates/ra_syntax/src/validation/string.rs b/crates/ra_syntax/src/validation/string.rs index 2f7f9c7c4..d857d088c 100644 --- a/crates/ra_syntax/src/validation/string.rs +++ b/crates/ra_syntax/src/validation/string.rs @@ -1,10 +1,8 @@ use crate::{ ast::{self, AstNode, AstToken}, string_lexing, - syntax_node::{ - SyntaxError, - SyntaxErrorKind::*, - }, + SyntaxError, + SyntaxErrorKind::*, }; use super::char; -- cgit v1.2.3