VectorCraft: An open-source, vector art tool written by scratch in pure Rust
perf(scriptcheck): lex each file once, fewer copies
vangel76f27b1e74e6b5
diff --git a/crates/scriptcheck/src/analyze.rs b/crates/scriptcheck/src/analyze.rsindex 965be88db..dffaae9bc 100644--- a/crates/scriptcheck/src/analyze.rs+++ b/crates/scriptcheck/src/analyze.rs@@ -19,6 +19,7 @@//! operand read so far at its depth, and a call on a File or Folder object in them (`(f).remove()`)//! is a call on the object. Nothing recurses.+use std::borrow::Cow;use std::collections::{HashMap, HashSet};use std::rc::Rc;@@ -76,14 +77,11 @@ pub(crate) struct Scan {pub known: Known,}-/// Scan `src`: the script itself (`file` none) or a file it includes (`file`: its path inside the-/// script's folder), with the `#includepath` folders `paths` in force at its start and its variables-/// holding what `known` says.-pub(crate) fn scan(src: &str, file: Option<&str>, paths: Rc<[String]>, known: &Known, acc: &mut Acc) -> Scan {- // A name written with `\u` escapes is read as the name it spells.- let unescaped = unescape_names(src, acc);- let src = unescaped.as_deref().unwrap_or(src);- let declared = declarations(src, acc);+/// Scan `src` (already through [`unescaped`]): the script itself (`file` none) or a file it includes+/// (`file`: its path inside the script's folder), with the names it declares (`declared`, from+/// [`declarations`] on the same `src`), the `#includepath` folders `paths` in force at its start and+/// its variables holding what `known` says.+pub(crate) fn scan<'s>(src: &'s str, declared: &Declared<'s>, file: Option<&str>, paths: Rc<[String]>, known: &Known, acc: &mut Acc) -> Scan {let mut lexer = Lexer::new(src, acc.limits.nesting);let mut a = Analyzer::new(acc, file, paths, known, declared);let mut nl = false;@@ -119,8 +117,15 @@ pub(crate) fn scan(src: &str, file: Option<&str>, paths: Rc<[String]>, known: &K}/// `src` with the `\uXXXX` escapes in its names written as the characters they stand for (ECMA-262-/// 3rd edition, section 7.6), or none when no name has one. An escape for a character no name may-/// hold stays as written. Line breaks don't change, so every line keeps its number.+/// 3rd edition, section 7.6), and `src` itself when no name has one. An escape for a character no+/// name may hold stays as written. Line breaks don't change, so every line keeps its number.+pub(crate) fn unescaped<'a>(src: Cow<'a, str>, acc: &mut Acc) -> Cow<'a, str> {+ match unescape_names(&src, acc) {+ Some(out) => Cow::Owned(out),+ None => src,+ }+}+fn unescape_names(src: &str, acc: &mut Acc) -> Option<String> {if !src.contains("\\u") {return None;@@ -654,7 +659,7 @@ impl Brackets {/// `var` statements are not read here. A function declaration inside a block, which ECMAScript 3/// does not allow (sections 12.1 and 14), makes its name the script's own from where it stands.#[derive(Default)]-struct Declared<'s> {+pub(crate) struct Declared<'s> {/// For each function body, by the offset of its `{` in the text, the names it declares, in the/// order the bodies start.bodies: Vec<(usize, Vec<&'s str>)>,@@ -695,7 +700,7 @@ struct Declarations<'s, 'a, 'l> {}/// What `src` declares ([`Declared`]), read in one pass over its tokens.-fn declarations<'s>(src: &'s str, acc: &mut Acc) -> Declared<'s> {+pub(crate) fn declarations<'s>(src: &'s str, acc: &mut Acc) -> Declared<'s> {let mut lexer = Lexer::new(src, acc.limits.nesting);let mut d = Declarations {acc,@@ -864,7 +869,7 @@ struct Analyzer<'s, 'a, 'l> {/// The function bodies being read, the innermost last, up to [`crate::Limits::nesting`].scopes: Vec<Scope>,/// The names each function body and the global code declare, read before the analysis.- declared: Declared<'s>,+ declared: &'a Declared<'s>,/// The first entry of `declared.bodies` whose body's `{` hasn't been read yet.next_body: usize,/// `function` was read at this bracket depth, and its body's `{` is still to come.@@ -912,7 +917,7 @@ struct Analyzer<'s, 'a, 'l> {}impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> {- fn new(acc: &'a mut Acc<'l>, file: Option<&'a str>, paths: Rc<[String]>, known: &Known, declared: Declared<'s>) -> Self {+ fn new(acc: &'a mut Acc<'l>, file: Option<&'a str>, paths: Rc<[String]>, known: &Known, declared: &'a Declared<'s>) -> Self {let global: Vec<&'s str> = declared.global.iter().copied().collect();let mut a = Analyzer {acc,@@ -1181,15 +1186,16 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> {}}- /// The names [`Declared`] has for the function body whose `{` starts at `start`, taken once.- fn declared_in(&mut self, start: usize) -> Vec<&'s str> {- let bodies = &mut self.declared.bodies;+ /// The names [`Declared`] has for the function body whose `{` starts at `start`.+ fn declared_in(&mut self, start: usize) -> &'a [&'s str] {+ let declared = self.declared;+ let bodies = &declared.bodies;while bodies.get(self.next_body).is_some_and(|(at, _)| *at < start) {self.next_body += 1;}- match bodies.get_mut(self.next_body) {- Some((at, names)) if *at == start => std::mem::take(names),- _ => vec![],+ match bodies.get(self.next_body) {+ Some((at, names)) if *at == start => names,+ _ => &[],}}@@ -1356,7 +1362,7 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> {self.keep_outer(&name);self.unbind(&name);}- for name in self.declared_in(t.start) {+ for &name in self.declared_in(t.start) {self.acc.steps = self.acc.steps.saturating_add(1);self.hoist(name);}@@ -1929,8 +1935,8 @@ impl<'s, 'a, 'l> Analyzer<'s, 'a, 'l> {"(" => self.call(line),// `Name.prototype["+"] = …` defines an operator."=" => {- let operator = h1.filter(|s| s.kind == T::Str).is_some_and(|s| catalog::OPERATORS.contains(&unquote(s.text, 4).as_str()));- if is(h0, "]") && operator && is(h2, "[") && word(h3, "prototype") {+ let operator = || h1.filter(|s| s.kind == T::Str).is_some_and(|s| catalog::OPERATORS.contains(&unquote(s.text, 4).as_str()));+ if is(h0, "]") && is(h2, "[") && word(h3, "prototype") && operator() {self.acc.feature("operatorOverloading", line);}}diff --git a/crates/scriptcheck/src/includes.rs b/crates/scriptcheck/src/includes.rsindex f47a83955..f6e9c82b0 100644--- a/crates/scriptcheck/src/includes.rs+++ b/crates/scriptcheck/src/includes.rs@@ -20,13 +20,11 @@ use crate::analyze::{self, IncludeRef, Known};use crate::directives::MAX_PATH;use crate::report::{Acc, IncludeStatus};-/// An included file that was read and is checked: its path inside the script's folder, its text-/// (and whether it held bytes that aren't UTF-8), and the `#includepath` folders in force at its-/// start.+/// An included file that was read and is checked: its path inside the script's folder, its bytes,+/// and the `#includepath` folders in force at its start.pub(crate) struct ReadFile {pub path: String,- pub text: String,- pub invalid: bool,+ pub bytes: Vec<u8>,pub paths: Rc<[String]>,}@@ -141,12 +139,14 @@ pub(crate) fn follow(files.push(path.clone());let file = files.len() - 1;read.insert(path.clone(), (status, Some(file)));- let (text, invalid) = crate::decode(&b);+ let (text, _) = crate::decode(&b);let mut tallies = Acc::new(limits);- let scan = analyze::scan(&text, Some(&path), Rc::clone(&inc.paths), known, &mut tallies);+ let text = analyze::unescaped(text, &mut tallies);+ let declared = analyze::declarations(&text, &mut tallies);+ let scan = analyze::scan(&text, &declared, Some(&path), Rc::clone(&inc.paths), known, &mut tallies);acc.steps = acc.steps.saturating_add(tallies.steps);known.add(scan.known, limits.entries);- checked.push(ReadFile { path: path.clone(), text: text.into_owned(), invalid, paths: Rc::clone(&inc.paths) });+ checked.push(ReadFile { path: path.clone(), bytes: b, paths: Rc::clone(&inc.paths) });work.push_back(Work { file, includes: scan.includes, depth: w.depth + 1 });(found, to) = (Some(path), Some(file));break;diff --git a/crates/scriptcheck/src/lib.rs b/crates/scriptcheck/src/lib.rsindex f44c5d759..818949f05 100644--- a/crates/scriptcheck/src/lib.rs+++ b/crates/scriptcheck/src/lib.rs@@ -165,11 +165,13 @@ pub fn check(name: &str, bytes: &[u8], loader: Option<&mut dyn Loader>, limits:if invalid {acc.problem(report::NOT_UTF8, None, None, None);}+ let text = analyze::unescaped(text, &mut acc);+ let declared = analyze::declarations(&text, &mut acc);let none = analyze::Known::default();// With a loader, this first scan finds the includes and what the script's variables hold; its// tallies are left out.let mut tallies = report::Acc::new(limits);- let scan = analyze::scan(&text, None, std::rc::Rc::from([]), &none, if loader.is_some() { &mut tallies } else { &mut acc });+ let scan = analyze::scan(&text, &declared, None, std::rc::Rc::from([]), &none, if loader.is_some() { &mut tallies } else { &mut acc });acc.steps = acc.steps.saturating_add(tallies.steps);if scan.module {// A module's report holds its kind and its lines, and none of what the scan found.@@ -184,15 +186,19 @@ pub fn check(name: &str, bytes: &[u8], loader: Option<&mut dyn Loader>, limits:};let mut known = scan.known;let read = includes::follow(&mut acc, scan.includes, loader, name, bytes.len(), &mut known);+ // Each file's text and the names it declares are worked out once for all the scans below.+ let decoded: Vec<_> = read.iter().map(|file| decode(&file.bytes)).collect();+ let texts: Vec<_> = decoded.into_iter().map(|(text, invalid)| (analyze::unescaped(text, &mut acc), invalid)).collect();+ let declarations: Vec<_> = texts.iter().map(|(text, _)| analyze::declarations(text, &mut acc)).collect();// A variable may get what it holds from another file's variable: the files are scanned again,// each with what is known so far, while that grows, at most three more times.for _ in 0..3 {let before = known.len();let mut tallies = report::Acc::new(limits);- let more = analyze::scan(&text, None, std::rc::Rc::from([]), &known, &mut tallies).known;+ let more = analyze::scan(&text, &declared, None, std::rc::Rc::from([]), &known, &mut tallies).known;known.add(more, limits.entries);- for file in &read {- let more = analyze::scan(&file.text, Some(&file.path), std::rc::Rc::clone(&file.paths), &known, &mut tallies).known;+ for ((file, (text, _)), declared) in read.iter().zip(&texts).zip(&declarations) {+ let more = analyze::scan(text, declared, Some(&file.path), std::rc::Rc::clone(&file.paths), &known, &mut tallies).known;known.add(more, limits.entries);}acc.steps = acc.steps.saturating_add(tallies.steps);@@ -201,12 +207,12 @@ pub fn check(name: &str, bytes: &[u8], loader: Option<&mut dyn Loader>, limits:}}// The scans for the report: every file starts with what any file's variables hold.- let lines = analyze::scan(&text, None, std::rc::Rc::from([]), &known, &mut acc).lines;- for file in read {- if file.invalid {+ let lines = analyze::scan(&text, &declared, None, std::rc::Rc::from([]), &known, &mut acc).lines;+ for ((file, (text, invalid)), declared) in read.iter().zip(&texts).zip(&declarations) {+ if *invalid {acc.problem(report::NOT_UTF8, None, Some(&file.path), None);}- analyze::scan(&file.text, Some(&file.path), file.paths, &known, &mut acc);+ analyze::scan(text, declared, Some(&file.path), std::rc::Rc::clone(&file.paths), &known, &mut acc);}acc.finish(Kind::Script, lines)}diff --git a/crates/scriptcheck/src/report.rs b/crates/scriptcheck/src/report.rsindex 1820db7cf..e24e12114 100644--- a/crates/scriptcheck/src/report.rs+++ b/crates/scriptcheck/src/report.rs@@ -1,5 +1,6 @@//! What a check finds ([`Report`]), and the tallies it is built from ([`Acc`]), each list capped.+use std::borrow::Cow;use std::collections::{BTreeMap, BTreeSet};use crate::{Kind, Limits, Need, catalog};@@ -265,6 +266,11 @@ impl<'l> Acc<'l> {echo(s, self.limits.echo)}+ /// [`Acc::echo`] without a copy when `s` isn't cut.+ fn echoed<'a>(&self, s: &'a str) -> Cow<'a, str> {+ echo_cow(s, self.limits.echo)+ }+/// Room for one more entry in a list of the report, or in a table of names the check keeps, of/// `len` entries: false (and the report marked truncated) when it is full.pub fn room(&mut self, len: usize) -> bool {@@ -290,12 +296,13 @@ impl<'l> Acc<'l> {}pub fn menu_string(&mut self, value: &str, line: Option<usize>) {- let key = self.echo(value);- if !self.menu.contains_key(&key) && !self.room(self.menu.len()) {- return;- }+ let key = self.echoed(value);let max = self.limits.lines;- self.menu.entry(key).or_default().add(line, max);+ if let Some(tally) = self.menu.get_mut(&*key) {+ tally.add(line, max);+ } else if self.room(self.menu.len()) {+ self.menu.entry(key.into_owned()).or_default().add(line, max);+ }}pub fn menu_dynamic(&mut self) {@@ -303,25 +310,28 @@ impl<'l> Acc<'l> {}pub fn member(&mut self, path: &str) {- if !self.members.contains_key(path) && !self.room(self.members.len()) {- return;+ if let Some(n) = self.members.get_mut(path) {+ *n = n.saturating_add(1);+ } else if self.room(self.members.len()) {+ self.members.insert(path.to_string(), 1);}- let n = self.members.entry(path.to_string()).or_default();- *n = n.saturating_add(1);}pub fn type_name(&mut self, name: &str) {- let key = self.echo(name);- if !self.types.contains_key(&key) && !self.room(self.types.len()) {- return;+ let key = self.echoed(name);+ if let Some(n) = self.types.get_mut(&*key) {+ *n = n.saturating_add(1);+ } else if self.room(self.types.len()) {+ self.types.insert(key.into_owned(), 1);}- let n = self.types.entry(key).or_default();- *n = n.saturating_add(1);}pub fn declared(&mut self, name: &str) {if self.declared.len() < self.limits.entries {- self.declared.insert(self.echo(name));+ let name = self.echoed(name);+ if !self.declared.contains(&*name) {+ self.declared.insert(name.into_owned());+ }}}@@ -405,13 +415,18 @@ impl<'l> Acc<'l> {/// `s` cut to at most `max` characters, the last one `…` when it was cut.pub(crate) fn echo(s: &str, max: usize) -> String {+ echo_cow(s, max).into_owned()+}++/// [`echo`], borrowing `s` when it isn't cut.+fn echo_cow(s: &str, max: usize) -> Cow<'_, str> {match s.char_indices().nth(max) {- None => s.to_string(),+ None => Cow::Borrowed(s),Some(_) => {let keep = s.char_indices().nth(max.saturating_sub(1)).map_or(0, |(i, _)| i);let mut out = s.get(..keep).unwrap_or_default().to_string();out.push('…');- out+ Cow::Owned(out)}}}diff --git a/crates/scriptcheck/src/tests.rs b/crates/scriptcheck/src/tests.rsindex 3884459d7..6934a9a9d 100644--- a/crates/scriptcheck/src/tests.rs+++ b/crates/scriptcheck/src/tests.rs@@ -1475,7 +1475,8 @@ fn include_lines_share_the_folders_of_the_include_path_before_them() {}let limits = Limits::default();let mut acc = report::Acc::new(&limits);- let scan = analyze::scan(&src, None, std::rc::Rc::from([]), &analyze::Known::default(), &mut acc);+ let declared = analyze::declarations(&src, &mut acc);+ let scan = analyze::scan(&src, &declared, None, std::rc::Rc::from([]), &analyze::Known::default(), &mut acc);let (first, rest) = scan.includes.split_first().unwrap();assert_eq!((first.paths.len(), rest.len()), (64, 999));assert!(rest.iter().all(|i| std::rc::Rc::ptr_eq(&i.paths, &first.paths)), "one list of folders, not a copy for each line");