VectorCraft: An open-source, vector art tool written by scratch in pure Rust
fix(scriptcheck): settle what variables hold without a loader too
vangel76aa8adf089131
diff --git a/crates/scriptcheck/src/lib.rs b/crates/scriptcheck/src/lib.rsindex b9d9173fc..0c62419f1 100644--- a/crates/scriptcheck/src/lib.rs+++ b/crates/scriptcheck/src/lib.rs@@ -15,8 +15,10 @@//!//! The checker never recurses: it reads each file once, and each scan of a file goes through its//! tokens front to back, first for the names its functions and its global code declare and then-//! for the analysis. When it follows includes, it scans each file for the includes and what the-//! variables hold, again while that grows (at most three more times), and then for the report. It+//! for the analysis. It scans the script for the includes and what the variables hold, and each+//! file it includes when it follows them, again while that grows (at most three more times), and+//! then for the report; a scan that finds nothing more is the report scan of a script read without+//! its included files. It//! keeps open brackets and the levels of an XML literal on capped stacks. Its work is linear in the//! input's size, and no input can overflow the stack.#![forbid(unsafe_code)]@@ -146,7 +148,8 @@ pub use report::PROBLEMS;/// `loader`, the files its `#include` lines name are read through it and checked too; without one/// they are listed as [`IncludeStatus::NotRead`]. When the script or one of those files assigns a/// member chain or a File object to a variable, the check treats the variable as holding it in-/// every file. Nothing in the script runs.+/// every file, also in code before the assignment. A script that includes nothing gets the same+/// report with a loader and without one. Nothing in the script runs.pub fn check(name: &str, bytes: &[u8], loader: Option<&mut dyn Loader>, limits: &Limits) -> Report {let mut acc = report::Acc::new(limits);if bytes.len() > limits.file_bytes {@@ -169,6 +172,7 @@ pub fn check(name: &str, bytes: &[u8], loader: Option<&mut dyn Loader>, limits:// 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 pre = acc.clone();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 {@@ -179,6 +183,7 @@ pub fn check(name: &str, bytes: &[u8], loader: Option<&mut dyn Loader>, limits:return acc.finish(Kind::Module, scan.lines);}let Some(loader) = loader else {+ let mut acc = settle(acc, pre, &text, &declared, scan.known);includes::not_read(&mut acc, scan.includes);return acc.finish(Kind::Script, scan.lines);};@@ -215,6 +220,40 @@ pub fn check(name: &str, bytes: &[u8], loader: Option<&mut dyn Loader>, limits:acc.finish(Kind::Script, lines)}+/// The report of a script read without its included files: what the scans above find for a script+/// that includes nothing, so a variable a function uses before the global code assigns it holds+/// what it is assigned. `first` holds the scan made with nothing known, which found `known`, and+/// `pre` what came before it. A scan made with what the scans before it found, and that finds+/// nothing more, is the report scan; no other scan is repeated.+fn settle<'l>(+ first: report::Acc<'l>,+ pre: report::Acc<'l>,+ text: &str,+ declared: &analyze::Declared<'_>,+ mut known: analyze::Known,+) -> report::Acc<'l> {+ if known.len() == 0 {+ return first;+ }+ let entries = pre.limits.entries;+ let mut spent = first.steps.saturating_sub(pre.steps);+ for _ in 0..3 {+ let before = known.len();+ let mut acc = pre.clone();+ let more = analyze::scan(text, declared, None, std::rc::Rc::from([]), &known, &mut acc).known;+ known.add(more, entries);+ if known.len() == before {+ acc.steps = acc.steps.saturating_add(spent);+ return acc;+ }+ spent = spent.saturating_add(acc.steps.saturating_sub(pre.steps));+ }+ let mut acc = pre;+ analyze::scan(text, declared, None, std::rc::Rc::from([]), &known, &mut acc);+ acc.steps = acc.steps.saturating_add(spent);+ acc+}+/// The last part of a path (`lib/Tidy.jsx` → `Tidy.jsx`), whichever separator it uses.pub(crate) fn base_name(name: &str) -> &str {name.rsplit(['/', '\\']).next().unwrap_or(name)diff --git a/crates/scriptcheck/src/report.rs b/crates/scriptcheck/src/report.rsindex 975ef4118..1c55ce1b4 100644--- a/crates/scriptcheck/src/report.rs+++ b/crates/scriptcheck/src/report.rs@@ -253,6 +253,7 @@ impl Tally {}/// What a check has found so far, across the script and its included files.+#[derive(Clone)]pub(crate) struct Acc<'l> {pub limits: &'l Limits,pub steps: usize,diff --git a/crates/scriptcheck/src/tests.rs b/crates/scriptcheck/src/tests.rsindex 9f08b94ea..21025a6e9 100644--- a/crates/scriptcheck/src/tests.rs+++ b/crates/scriptcheck/src/tests.rs@@ -1757,3 +1757,63 @@ proptest! {prop_assert!(r.includes.iter().all(|i| i.status != IncludeStatus::NotRead));}}++/// A function that writes to a variable the global code assigns a File object after it: the+/// variable declaration is hoisted, so the function writes a file, with a loader and without one.+#[test]+fn a_variable_assigned_after_the_function_using_it_holds_its_value() {+ let src = "function g(){ f.write('x'); } var f = new File('a');";+ let without = report(src);+ let with = check("test.jsx", src.as_bytes(), Some(&mut mem(&[])), &Limits::default());+ assert!(feature(&without, "file.write").is_some(), "{:?}", without.features);+ assert!(feature(&with, "file.write").is_some(), "{:?}", with.features);+}++/// Script-like text with functions that use variables the code after them assigns, a chain of them+/// taking more than one scan to settle.+fn hoisting_text() -> impl Strategy<Value = String> {+ let pieces = prop::sample::select(vec![+ "function g(){ ",+ "function h(){ ",+ "}",+ "f.write('x'); ",+ "b.remove(); ",+ "e.acmeItems.add(); ",+ "b = a; ",+ "var a = f; ",+ "var f = new File('a'); ",+ "var d = app.activeDocument; ",+ "var e = d; ",+ "e = d.acmeLayers; ",+ "f = d; ",+ ]);+ (prop::collection::vec(pieces, 0..30), script_text()).prop_map(|(v, tail)| v.concat() + &tail)+}++proptest! {+ #![proptest_config(ProptestConfig::with_cases(512))]++ /// A script that includes nothing gets the same report with a loader and without one.+ #[test]+ fn a_script_without_includes_reports_the_same_with_and_without_a_loader(text in hoisting_text()) {+ let mut without = report(&text);+ prop_assume!(without.includes.is_empty());+ let mut with = check("test.jsx", text.as_bytes(), Some(&mut mem(&[])), &Limits::default());+ without.steps = 0;+ with.steps = 0;+ prop_assert_eq!(without, with);+ }+}++/// Chains of variables a function assigns before the code after it assigns their source take a+/// scan each to settle: the script is read at most seven times.+#[test]+fn variables_that_settle_over_several_scans_stay_linear() {+ let mut src = String::new();+ for i in 0..150 {+ src += &format!("function a{i}(){{ e{i} = d{i}; }} function b{i}(){{ d{i} = c{i}; }} function c{i}(){{ c{i} = b{i}; }} ");+ src += &format!("function d{i}(){{ b{i} = a{i}; }} var a{i} = new File('x');\n");+ }+ let r = report(&src);+ assert!(r.steps <= 9 * src.len() + 16, "{} steps for {} bytes", r.steps, src.len());+}