From a4a1e08ab81193112a2e14413d084916241c3fca Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 20 Feb 2019 16:16:14 +0300
Subject: flatten modules
---
crates/ra_syntax/src/syntax_node/syntax_error.rs | 146 -----------------------
crates/ra_syntax/src/syntax_node/syntax_text.rs | 144 ----------------------
2 files changed, 290 deletions(-)
delete mode 100644 crates/ra_syntax/src/syntax_node/syntax_error.rs
delete mode 100644 crates/ra_syntax/src/syntax_node/syntax_text.rs
(limited to 'crates/ra_syntax/src/syntax_node')
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<Location> for TextUnit {
- fn into(self) -> Location {
- Location::Offset(self)
- }
-}
-
-impl Into<Location> for TextRange {
- fn into(self) -> Location {
- Location::Range(self)
- }
-}
-
-impl SyntaxError {
- pub fn new<L: Into<Location>>(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<Item = &'a str> {
- 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<TextUnit> {
- 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<TextUnit>) -> Option<char> {
- 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<TextRange>;
-}
-
-impl SyntaxTextSlice for TextRange {
- fn restrict(&self, range: TextRange) -> Option<TextRange> {
- self.intersection(&range)
- }
-}
-
-impl SyntaxTextSlice for ops::RangeTo<TextUnit> {
- fn restrict(&self, range: TextRange) -> Option<TextRange> {
- if !range.contains_inclusive(self.end) {
- return None;
- }
- Some(TextRange::from_to(range.start(), self.end))
- }
-}
-
-impl SyntaxTextSlice for ops::RangeFrom<TextUnit> {
- fn restrict(&self, range: TextRange) -> Option<TextRange> {
- if !range.contains_inclusive(self.start) {
- return None;
- }
- Some(TextRange::from_to(self.start, range.end()))
- }
-}
-
-impl SyntaxTextSlice for ops::Range<TextUnit> {
- fn restrict(&self, range: TextRange) -> Option<TextRange> {
- TextRange::from_to(self.start, self.end).restrict(range)
- }
-}
-
-impl From<SyntaxText<'_>> for String {
- fn from(text: SyntaxText) -> String {
- text.to_string()
- }
-}
-
-impl PartialEq<str> 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
- }
-}
--
cgit v1.2.3