A New World

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);
         }};
     }