summaryrefslogtreecommitdiff
path: root/src/parse
diff options
context:
space:
mode:
Diffstat (limited to 'src/parse')
-rw-r--r--src/parse/incremental.rs22
-rw-r--r--src/parse/mod.rs24
-rw-r--r--src/parse/parser.rs8
-rw-r--r--src/parse/resolve.rs4
-rw-r--r--src/parse/tokens.rs24
5 files changed, 41 insertions, 41 deletions
diff --git a/src/parse/incremental.rs b/src/parse/incremental.rs
index 60f780b4..9272dcfc 100644
--- a/src/parse/incremental.rs
+++ b/src/parse/incremental.rs
@@ -15,21 +15,21 @@ use super::{
/// Returns the range in the new source that was ultimately reparsed.
pub fn reparse(
root: &mut SyntaxNode,
- src: &str,
+ text: &str,
replaced: Range<usize>,
replacement_len: usize,
) -> Range<usize> {
if let SyntaxNode::Inner(inner) = root {
- let change = Change { src, replaced, replacement_len };
+ let change = Change { text, replaced, replacement_len };
if let Some(range) = try_reparse(&change, Arc::make_mut(inner), 0, true, true) {
return range;
}
}
let id = root.span().source();
- *root = parse(src);
+ *root = parse(text);
root.numberize(id, Span::FULL).unwrap();
- 0 .. src.len()
+ 0 .. text.len()
}
/// Try to reparse inside the given node.
@@ -228,27 +228,27 @@ fn replace(
let newborn_span = superseded_span.start .. newborn_end;
let mut prefix = "";
- for (i, c) in change.src[.. newborn_span.start].char_indices().rev() {
+ for (i, c) in change.text[.. newborn_span.start].char_indices().rev() {
if is_newline(c) {
break;
}
- prefix = &change.src[i .. newborn_span.start];
+ prefix = &change.text[i .. newborn_span.start];
}
let (newborns, terminated, amount) = match mode {
ReparseMode::Code => reparse_code_block(
&prefix,
- &change.src[newborn_span.start ..],
+ &change.text[newborn_span.start ..],
newborn_span.len(),
),
ReparseMode::Content => reparse_content_block(
&prefix,
- &change.src[newborn_span.start ..],
+ &change.text[newborn_span.start ..],
newborn_span.len(),
),
ReparseMode::MarkupElements { at_start, min_indent } => reparse_markup_elements(
&prefix,
- &change.src[newborn_span.start ..],
+ &change.text[newborn_span.start ..],
newborn_span.len(),
differential,
&node.children().as_slice()[superseded_start ..],
@@ -272,7 +272,7 @@ fn replace(
/// A description of a change.
struct Change<'a> {
/// The new source code, with the change applied.
- src: &'a str,
+ text: &'a str,
/// Which range in the old source file was changed.
replaced: Range<usize>,
/// How many characters replaced the text in `replaced`.
@@ -396,7 +396,7 @@ mod tests {
fn test(prev: &str, range: Range<usize>, with: &str, goal: Range<usize>) {
let mut source = Source::detached(prev);
let range = source.edit(range, with);
- check(source.src(), source.root(), &parse(source.src()));
+ check(source.text(), source.root(), &parse(source.text()));
assert_eq!(range, goal);
}
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index 0737d4ca..a8dee7f3 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -16,15 +16,15 @@ use crate::syntax::{NodeKind, SpanPos, SyntaxNode};
use crate::util::EcoString;
/// Parse a source file.
-pub fn parse(src: &str) -> SyntaxNode {
- let mut p = Parser::new(src, TokenMode::Markup);
+pub fn parse(text: &str) -> SyntaxNode {
+ let mut p = Parser::new(text, TokenMode::Markup);
markup(&mut p, true);
p.finish().into_iter().next().unwrap()
}
/// Parse code directly, only used for syntax highlighting.
-pub fn parse_code(src: &str) -> Vec<SyntaxNode> {
- let mut p = Parser::new(src, TokenMode::Code);
+pub fn parse_code(text: &str) -> Vec<SyntaxNode> {
+ let mut p = Parser::new(text, TokenMode::Code);
code(&mut p);
p.finish()
}
@@ -34,10 +34,10 @@ pub fn parse_code(src: &str) -> Vec<SyntaxNode> {
/// Returns `Some` if all of the input was consumed.
fn reparse_code_block(
prefix: &str,
- src: &str,
+ text: &str,
end_pos: usize,
) -> Option<(Vec<SyntaxNode>, bool, usize)> {
- let mut p = Parser::with_prefix(prefix, src, TokenMode::Code);
+ let mut p = Parser::with_prefix(prefix, text, TokenMode::Code);
if !p.at(NodeKind::LeftBrace) {
return None;
}
@@ -58,10 +58,10 @@ fn reparse_code_block(
/// Returns `Some` if all of the input was consumed.
fn reparse_content_block(
prefix: &str,
- src: &str,
+ text: &str,
end_pos: usize,
) -> Option<(Vec<SyntaxNode>, bool, usize)> {
- let mut p = Parser::with_prefix(prefix, src, TokenMode::Code);
+ let mut p = Parser::with_prefix(prefix, text, TokenMode::Code);
if !p.at(NodeKind::LeftBracket) {
return None;
}
@@ -82,14 +82,14 @@ fn reparse_content_block(
/// Returns `Some` if all of the input was consumed.
fn reparse_markup_elements(
prefix: &str,
- src: &str,
+ text: &str,
end_pos: usize,
differential: isize,
reference: &[SyntaxNode],
mut at_start: bool,
min_indent: usize,
) -> Option<(Vec<SyntaxNode>, bool, usize)> {
- let mut p = Parser::with_prefix(prefix, src, TokenMode::Markup);
+ let mut p = Parser::with_prefix(prefix, text, TokenMode::Markup);
let mut node: Option<&SyntaxNode> = None;
let mut iter = reference.iter();
@@ -996,12 +996,12 @@ mod tests {
use std::fmt::Debug;
#[track_caller]
- pub fn check<T>(src: &str, found: T, expected: T)
+ pub fn check<T>(text: &str, found: T, expected: T)
where
T: Debug + PartialEq,
{
if found != expected {
- println!("source: {src:?}");
+ println!("source: {text:?}");
println!("expected: {expected:#?}");
println!("found: {found:#?}");
panic!("test failed");
diff --git a/src/parse/parser.rs b/src/parse/parser.rs
index 685f1e69..90b6e610 100644
--- a/src/parse/parser.rs
+++ b/src/parse/parser.rs
@@ -30,15 +30,15 @@ pub struct Parser<'s> {
impl<'s> Parser<'s> {
/// Create a new parser for the source string.
- pub fn new(src: &'s str, mode: TokenMode) -> Self {
- Self::with_prefix("", src, mode)
+ pub fn new(text: &'s str, mode: TokenMode) -> Self {
+ Self::with_prefix("", text, mode)
}
/// Create a new parser for the source string that is prefixed by some text
/// that does not need to be parsed but taken into account for column
/// calculation.
- pub fn with_prefix(prefix: &str, src: &'s str, mode: TokenMode) -> Self {
- let mut tokens = Tokens::with_prefix(prefix, src, mode);
+ pub fn with_prefix(prefix: &str, text: &'s str, mode: TokenMode) -> Self {
+ let mut tokens = Tokens::with_prefix(prefix, text, mode);
let current = tokens.next();
Self {
tokens,
diff --git a/src/parse/resolve.rs b/src/parse/resolve.rs
index 6fab9f21..bce2da3c 100644
--- a/src/parse/resolve.rs
+++ b/src/parse/resolve.rs
@@ -23,7 +23,7 @@ pub fn resolve_string(string: &str) -> EcoString {
Some('r') => out.push('\r'),
Some('t') => out.push('\t'),
Some('u') if s.eat_if('{') => {
- // TODO: Feedback if closing brace is missing.
+ // TODO: Error if closing brace is missing.
let sequence = s.eat_while(char::is_ascii_hexdigit);
let _terminated = s.eat_if('}');
@@ -33,7 +33,7 @@ pub fn resolve_string(string: &str) -> EcoString {
}
}
- // TODO: Feedback about invalid escape sequence.
+ // TODO: Error for invalid escape sequence.
_ => out.push_str(s.from(start)),
}
}
diff --git a/src/parse/tokens.rs b/src/parse/tokens.rs
index 67d413fd..84a63ba1 100644
--- a/src/parse/tokens.rs
+++ b/src/parse/tokens.rs
@@ -34,16 +34,16 @@ pub enum TokenMode {
impl<'s> Tokens<'s> {
/// Create a new token iterator with the given mode.
#[inline]
- pub fn new(src: &'s str, mode: TokenMode) -> Self {
- Self::with_prefix("", src, mode)
+ pub fn new(text: &'s str, mode: TokenMode) -> Self {
+ Self::with_prefix("", text, mode)
}
/// Create a new token iterator with the given mode and a prefix to offset
/// column calculations.
#[inline]
- pub fn with_prefix(prefix: &str, src: &'s str, mode: TokenMode) -> Self {
+ pub fn with_prefix(prefix: &str, text: &'s str, mode: TokenMode) -> Self {
Self {
- s: Scanner::new(src),
+ s: Scanner::new(text),
mode,
terminated: true,
column_offset: column(prefix, prefix.len(), 0),
@@ -770,9 +770,9 @@ mod tests {
t!(Markup $($tts)*);
t!(Code $($tts)*);
};
- ($mode:ident $([$blocks:literal])?: $src:expr => $($token:expr),*) => {{
+ ($mode:ident $([$blocks:literal])?: $text:expr => $($token:expr),*) => {{
// Test without suffix.
- t!(@$mode: $src => $($token),*);
+ t!(@$mode: $text => $($token),*);
// Suffixes described by four-tuples of:
//
@@ -810,21 +810,21 @@ mod tests {
// Test with each applicable suffix.
for &(block, mode, suffix, ref token) in suffixes {
- let src = $src;
+ let text = $text;
#[allow(unused_variables)]
let blocks = BLOCKS;
$(let blocks = $blocks;)?
assert!(!blocks.contains(|c| !BLOCKS.contains(c)));
if (mode.is_none() || mode == Some($mode)) && blocks.contains(block) {
- t!(@$mode: format!("{}{}", src, suffix) => $($token,)* token);
+ t!(@$mode: format!("{}{}", text, suffix) => $($token,)* token);
}
}
}};
- (@$mode:ident: $src:expr => $($token:expr),*) => {{
- let src = $src;
- let found = Tokens::new(&src, $mode).collect::<Vec<_>>();
+ (@$mode:ident: $text:expr => $($token:expr),*) => {{
+ let text = $text;
+ let found = Tokens::new(&text, $mode).collect::<Vec<_>>();
let expected = vec![$($token.clone()),*];
- check(&src, found, expected);
+ check(&text, found, expected);
}};
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-15 22:43:21 +0000