schemurai 3.0.0 → 3.0.2

data/ext/schemurai_native/src/content.rs

@@ -1,5 +1,6 @@
 //! Content validation borrows Ruby string storage. Base64 decoding uses bounded
-//! stack scratch; JSON scanning never constructs a tree.
+//! stack scratch; native JSON scanning never constructs a tree. Other source
+//! encodings request Ruby parsing after Rust evaluation returns.
 use super::*;
 use std::mem::MaybeUninit;
 
@@ -14,23 +15,28 @@ pub(super) struct Content {
     pub(super) json: bool,
 }
 impl Content {
-    pub(super) fn eval_items(&self, required: i32, values: &[Value]) -> Verdict {
-        self.visit_invalid_items(required, values, |_, _| Invalid)
-    }
     pub(super) fn visit_invalid_items(
         &self,
+        caches: &runtime::Caches,
         required: i32,
         values: &[Value],
         invalid: impl FnMut(usize, Value) -> Verdict,
     ) -> Verdict {
         match (self.base64, self.json) {
-            (true, true) => Self::visit_items_impl::<true, true>(required, values, invalid),
-            (true, false) => Self::visit_items_impl::<true, false>(required, values, invalid),
-            (false, true) => Self::visit_items_impl::<false, true>(required, values, invalid),
-            (false, false) => Self::visit_items_impl::<false, false>(required, values, invalid),
+            (true, true) => Self::visit_items_impl::<true, true>(caches, required, values, invalid),
+            (true, false) => {
+                Self::visit_items_impl::<true, false>(caches, required, values, invalid)
+            }
+            (false, true) => {
+                Self::visit_items_impl::<false, true>(caches, required, values, invalid)
+            }
+            (false, false) => {
+                Self::visit_items_impl::<false, false>(caches, required, values, invalid)
+            }
         }
     }
     fn visit_items_impl<const BASE64: bool, const JSON: bool>(
+        caches: &runtime::Caches,
         required: i32,
         values: &[Value],
         mut invalid: impl FnMut(usize, Value) -> Verdict,
@@ -45,9 +51,15 @@ impl Content {
             } else {
                 unsafe { sn_format_item_view(value, data.as_mut_ptr(), len.as_mut_ptr()) }
             };
-            let result = if kind == -TYPE_UNSUPPORTED || (JSON && !BASE64 && kind == ENCODING_OTHER)
-            {
-                Unsupported
+            if kind == -TYPE_UNSUPPORTED {
+                let status = invalid(index, value);
+                if status != Valid {
+                    return status;
+                }
+                continue;
+            }
+            let result = if JSON && !BASE64 && kind == ENCODING_OTHER {
+                caches.json(value)
             } else if kind < 0 {
                 verdict(required == 0)
             } else {
@@ -55,12 +67,12 @@ impl Content {
                 let bytes = unsafe { byte_view(data.assume_init(), len.assume_init()) };
                 if JSON && !BASE64 {
                     if kind == ENCODING_ASCII && !bytes.is_ascii() {
-                        Unsupported
+                        caches.json(value)
                     } else {
                         json(bytes)
                     }
                 } else {
-                    Self::eval_impl::<true, BASE64, JSON>(value, bytes, 0)
+                    Self::eval_impl::<true, BASE64, JSON>(caches, value, bytes, 0)
                 }
             };
             match result {
@@ -76,26 +88,40 @@ impl Content {
         }
         Valid
     }
-    pub(super) fn eval(&self, value: Value) -> Verdict {
-        self.eval_selected::<false>(value, &[], 0)
+    pub(super) fn eval(&self, caches: &runtime::Caches, value: Value) -> Verdict {
+        self.eval_selected::<false>(caches, value, &[], 0)
     }
-    pub(super) fn eval_borrowed(&self, value: Value, bytes: &[u8], encoding: i32) -> Verdict {
-        self.eval_selected::<true>(value, bytes, encoding)
+    pub(super) fn eval_borrowed(
+        &self,
+        caches: &runtime::Caches,
+        value: Value,
+        bytes: &[u8],
+        encoding: i32,
+    ) -> Verdict {
+        self.eval_selected::<true>(caches, value, bytes, encoding)
     }
     fn eval_selected<const BORROWED: bool>(
         &self,
+        caches: &runtime::Caches,
         value: Value,
         bytes: &[u8],
         encoding: i32,
     ) -> Verdict {
         match (self.base64, self.json) {
-            (true, true) => Self::eval_impl::<BORROWED, true, true>(value, bytes, encoding),
-            (true, false) => Self::eval_impl::<BORROWED, true, false>(value, bytes, encoding),
-            (false, true) => Self::eval_impl::<BORROWED, false, true>(value, bytes, encoding),
-            (false, false) => Self::eval_impl::<BORROWED, false, false>(value, bytes, encoding),
+            (true, true) => Self::eval_impl::<BORROWED, true, true>(caches, value, bytes, encoding),
+            (true, false) => {
+                Self::eval_impl::<BORROWED, true, false>(caches, value, bytes, encoding)
+            }
+            (false, true) => {
+                Self::eval_impl::<BORROWED, false, true>(caches, value, bytes, encoding)
+            }
+            (false, false) => {
+                Self::eval_impl::<BORROWED, false, false>(caches, value, bytes, encoding)
+            }
         }
     }
     fn eval_impl<const BORROWED: bool, const BASE64: bool, const JSON: bool>(
+        caches: &runtime::Caches,
         value: Value,
         bytes: &[u8],
         encoding: i32,
@@ -142,7 +168,7 @@ impl Content {
                     _ => unsafe { sn_json_encoding(value) },
                 };
                 if encoding == ENCODING_OTHER || (encoding == ENCODING_ASCII && !bytes.is_ascii()) {
-                    return Unsupported;
+                    return caches.json(value);
                 }
             }
             if !JSON {
@@ -161,12 +187,24 @@ fn decode_json_medium(bytes: &[u8], length: usize) -> Verdict {
     decode_json_turbo(bytes, length, &mut scratch)
 }
 
+// Keep the 8 KiB scratch frame out of shorter decoded-content paths.
 #[inline(never)]
 fn decode_json_direct(bytes: &[u8], length: usize) -> Verdict {
     let mut scratch = [0; DIRECT_BYTES + 2];
     decode_json_turbo(bytes, length, &mut scratch)
 }
 
+#[cfg(target_arch = "aarch64")]
+fn decode_json_turbo(bytes: &[u8], length: usize, scratch: &mut [u8]) -> Verdict {
+    let capacity = base64_turbo::STANDARD.decoded_len_estimate(bytes.len());
+    if decode_groups(bytes, &mut scratch[..capacity], length) {
+        json(&scratch[..length])
+    } else {
+        Invalid
+    }
+}
+
+#[cfg(not(target_arch = "aarch64"))]
 fn decode_json_turbo(bytes: &[u8], length: usize, scratch: &mut [u8]) -> Verdict {
     // The slice API requires an initialized upper-bound buffer, including
     // up to two padding bytes beyond the exact decoded length. Only the
@@ -195,6 +233,13 @@ fn decode_json_stream(bytes: &[u8], length: usize) -> Verdict {
 
 // Decode borrowed bytes into the caller's fixed stack scratch. The STANDARD
 // variant also checks each chunk's alphabet, padding and unused trailing bits.
+#[cfg(target_arch = "aarch64")]
+fn decode_groups(bytes: &[u8], output: &mut [u8], expected: usize) -> bool {
+    use base64_simd::AsOut;
+    matches!(base64_simd::STANDARD.decode(bytes, output.as_out()), Ok(decoded) if decoded.len() == expected)
+}
+
+#[cfg(not(target_arch = "aarch64"))]
 fn decode_groups(bytes: &[u8], output: &mut [u8], expected: usize) -> bool {
     matches!(
         base64_turbo::STANDARD.decode_slice(bytes, output),
@@ -210,6 +255,9 @@ trait Input {
     }
 }
 impl Input for &[u8] {
+    // Retain byte/take/whitespace specialization together: removing their
+    // hints changed parser register/state handling and slowed numeric/literal
+    // and nested JSON controls. See benchmark/README.md's inline audit.
     #[inline(always)]
     fn byte(&self, at: usize) -> Option<u8> {
         self.get(at).copied()
@@ -309,7 +357,6 @@ impl Input for &[u8] {
                 .count()
     }
 }
-#[inline]
 fn string_special_word(bytes: [u8; 8]) -> u64 {
     let word = u64::from_le_bytes(bytes);
     let quote = word ^ 0x2222_2222_2222_2222;
@@ -380,11 +427,9 @@ impl BufferedBase64<'_> {
     }
 }
 impl Input for BufferedBase64<'_> {
-    #[inline(always)]
     fn byte(&self, _at: usize) -> Option<u8> {
         self.decoded[..self.len].get(self.at).copied()
     }
-    #[inline(always)]
     fn advance(&mut self) {
         self.at += 1;
         if self.at == self.len {
@@ -414,15 +459,14 @@ struct Parser<I> {
     at: usize,
 }
 impl<I: Input> Parser<I> {
-    #[inline(always)]
     fn peek(&self) -> Option<u8> {
         self.input.byte(self.at)
     }
-    #[inline(always)]
     fn advance(&mut self) {
         self.at += 1;
         self.input.advance();
     }
+    // Part of the measured byte/take/whitespace specialization above.
     #[inline(always)]
     fn take(&mut self, byte: u8) -> bool {
         if self.peek() == Some(byte) {
@@ -432,12 +476,15 @@ impl<I: Input> Parser<I> {
             false
         }
     }
+    // Keep whitespace state visible to value/container dispatch (inline audit).
     #[inline(always)]
     fn whitespace(&mut self) {
         while matches!(self.peek(), Some(b' ' | b'\t' | b'\r' | b'\n')) {
             self.advance();
         }
     }
+    // Paired JSON controls improved 5–6% with dispatch in the callers; see
+    // benchmark/README.md, "Full audit after JSON value dispatch inlining".
     #[inline(always)]
     fn value(&mut self, depth: usize) -> bool {
         self.whitespace();

data/ext/schemurai_native/src/diagnostics/array.rs

@@ -0,0 +1,392 @@
+//! Array report collection through C-owned handles, outside native schema frames.
+use super::*;
+
+/// # Safety
+/// Report is live, immutable and rooted by C; the returned clone is owned by C.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_clone(report: *const Report) -> *mut Report {
+    Box::into_raw(Box::new(unsafe { &*report }.clone()))
+}
+/// # Safety
+/// Report is the live callback collection, immutable and rooted by C.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_callback_seed(report: *const Report) -> *mut Report {
+    Box::into_raw(Box::new(unsafe { &*report }.continuation(true)))
+}
+/// # Safety
+/// Report is live and C-rooted. Keyword is a valid library-owned UTF-8 segment.
+/// The returned seed is owned by C and freed with sn_report_free.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_array_report_child(
+    report: *const Report,
+    index: usize,
+    keyword: *const u8,
+    len: usize,
+    child: usize,
+    trial: i32,
+) -> *mut Report {
+    let mut seed = if trial != 0 {
+        Report {
+            silent: true,
+            annotations: true,
+            ..Report::default()
+        }
+    } else {
+        unsafe { &*report }.continuation(false)
+    };
+    if trial == 0 {
+        seed.instance_path.index(index);
+        seed.schema_path.push_str("/");
+        seed.schema_path.push_str(
+            std::str::from_utf8(unsafe { byte_view(keyword, len) }).expect("array keyword"),
+        );
+        if child != usize::MAX {
+            seed.schema_path.index(child);
+        }
+    }
+    Box::into_raw(Box::new(seed))
+}
+/// # Safety
+/// Report/engine are live and rooted, node contains the current Array instruction,
+/// keyword is one of the library's array diagnostic IDs, and frame is C-rooted.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_array_report_error(
+    report: *const Report,
+    engine: *const Engine,
+    node: usize,
+    instance: Value,
+    keyword: i32,
+    frame: Value,
+) -> *mut Report {
+    let keyword = match keyword {
+        0 => "type",
+        1 => "maxItems",
+        2 => "minItems",
+        3 => "uniqueItems",
+        4 => "contains",
+        _ => unreachable!(),
+    };
+    let seed = unsafe { &*report }.container_error(
+        unsafe { &*engine },
+        node,
+        instance,
+        keyword,
+        frame,
+        false,
+    );
+    Box::into_raw(Box::new(seed))
+}
+/// # Safety
+/// Collector report is live and exclusively borrowed. C marks its immutable
+/// seed and all completed results instead while this mutation is in progress.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_array_report_adopt(
+    report: *mut Report,
+    completed: *const Report,
+) -> i32 {
+    unsafe { &mut *report }
+        .adopt(unsafe { &*completed }.clone())
+        .status as i32
+}
+/// # Safety
+/// Report is live and holds an active array accumulator; C uses the same mutation
+/// root guard as sn_array_report_adopt. Index is produced by library traversal.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_array_report_record(report: *mut Report, index: usize) {
+    unsafe { &mut *report }
+        .evaluation
+        .as_mut()
+        .expect("array locations")
+        .item(index);
+}
+/// # Safety
+/// Report is live and immutable during this call; index is a library index.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_array_report_contains(
+    report: *const Report,
+    index: usize,
+    prior: i32,
+) -> i32 {
+    let report = unsafe { &*report };
+    i32::from(
+        if prior != 0 {
+            &report.container_prior
+        } else {
+            &report.evaluation
+        }
+        .as_ref()
+        .is_some_and(|locations| locations.contains_item(index)),
+    )
+}
+/// # Safety
+/// Report is live and immutable during this call.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_silent(report: *const Report) -> i32 {
+    i32::from(unsafe { &*report }.silent)
+}
+/// # Safety
+/// Report is live, complete and immutable during this call.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_verdict(report: *const Report) -> i32 {
+    unsafe { &*report }
+        .evaluation
+        .as_ref()
+        .expect("completed report")
+        .status as i32
+}
+/// # Safety
+/// Report is live with an active array accumulator and C guards mutation as for
+/// sn_array_report_adopt. Only the library completes an array traversal.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_array_report_finish(report: *mut Report, valid: i32) {
+    let report = unsafe { &mut *report };
+    report.container_prior = None;
+    if valid == 0 {
+        report.failed = true;
+        report.evaluation = Some(Tracked::new(Invalid));
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn runtime_effects_keep_the_receiving_path_and_detect_silent_failure() {
+        let mut report = Report {
+            attempts: 2,
+            ..Report::default()
+        };
+        report.instance_path.index(7);
+        report.schema_path.push_str("/items");
+        let before = report.continuation(true);
+        assert!(before.effect_since(&before).is_none());
+        let mut completed = before.clone();
+        completed.reserve_error().unwrap();
+        completed.errors.push(Error {
+            keyword: "type",
+            instance_path: pointer::Rendered::Native("/7/0".into()),
+            schema_path: pointer::Rendered::Native("/items/items/type".into()),
+            opcode: OP_TYPE_INTEGER,
+            operand: 0,
+            instance: 0,
+            detail: 0,
+            message: 0,
+        });
+        let effect = completed.effect_since(&before).unwrap();
+        report.apply_effect(effect);
+        assert_eq!(report.attempts, 3);
+        assert!(report.failed);
+        assert_eq!(report.instance_path.text, "/7");
+        assert_eq!(report.schema_path.text, "/items");
+        assert_eq!(report.errors.len(), 1);
+        assert_eq!(report.errors[0].instance_path.bytes(), b"/7/0");
+        assert!(!report.annotations);
+        let silent = Report {
+            silent: true,
+            ..Report::default()
+        };
+        let mut completed = silent.clone();
+        completed.failed = true;
+        let effect = completed.effect_since(&silent).unwrap();
+        assert!(effect.failed);
+        assert_eq!(effect.attempts, 0);
+        assert!(effect.errors.is_empty());
+    }
+
+    #[test]
+    fn collection_reset_replaces_prior_errors_and_counts_without_exporting_trial_policy() {
+        let before = Report {
+            attempts: 2,
+            failed: true,
+            ..Report::default()
+        };
+        let mut completed = before.clone();
+        completed.instance_path.index(7);
+        completed.clear_collection(true);
+        assert_eq!(completed.attempts, 0);
+        assert!(!completed.failed);
+        assert!(completed.silent);
+        let effect = completed.effect_since(&before).unwrap();
+        let mut receiver = before.container_continuation(true, &Tracked::new(Valid));
+        receiver.instance_path.index(5);
+        receiver.apply_effect(effect);
+        assert!(receiver.annotations);
+        assert!(receiver.silent);
+        assert_eq!(receiver.attempts, 0);
+        assert!(!receiver.failed);
+        assert!(receiver.instance_path.text.is_empty());
+        assert_eq!(receiver.collection_reset, 1);
+        assert!(receiver.evaluation.is_some());
+        let mut outer = before.clone();
+        let trial = outer.continuation(true);
+        let mut trial_result = trial.clone();
+        trial_result.clear_collection(true);
+        assert!(!outer.same_collection_policy(&trial_result));
+        outer.apply_effect(Report {
+            attempts: 1,
+            failed: true,
+            ..Report::default()
+        });
+        assert_eq!(outer.attempts, 3);
+        assert!(!outer.silent);
+    }
+
+    #[test]
+    fn item_results_preserve_accumulators_paths_and_independent_trial_policy() {
+        let mut base = Report {
+            attempts: 1,
+            ..Report::default()
+        };
+        base.instance_path.text.push_str("/outer");
+        base.schema_path.text.push_str("/allOf/1");
+        let mut prior = Tracked::new(Valid);
+        prior.item(65);
+        let mut report = base.container_continuation(true, &prior);
+        unsafe {
+            sn_array_report_record(&mut report, 4);
+        }
+        assert_eq!(unsafe { sn_array_report_contains(&report, 65, 1) }, 1);
+        assert_eq!(unsafe { sn_array_report_contains(&report, 4, 0) }, 1);
+        assert_eq!(unsafe { sn_array_report_contains(&report, 4, 1) }, 0);
+        let keyword = b"prefixItems";
+        let mut completed = unsafe {
+            Box::from_raw(sn_array_report_child(
+                &report,
+                4,
+                keyword.as_ptr(),
+                keyword.len(),
+                4,
+                0,
+            ))
+        };
+        assert_eq!(completed.instance_path.text, "/outer/4");
+        assert_eq!(completed.schema_path.text, "/allOf/1/prefixItems/4");
+        completed.attempts = 2;
+        completed.failed = true;
+        completed.evaluation = Some(Tracked::new(Invalid));
+        assert_eq!(
+            unsafe { sn_array_report_adopt(&mut report, &*completed) },
+            VERDICT_INVALID
+        );
+        assert_eq!(report.instance_path.text, "/outer");
+        assert_eq!(report.schema_path.text, "/allOf/1");
+        assert_eq!(unsafe { sn_array_report_contains(&report, 65, 1) }, 1);
+        assert_eq!(unsafe { sn_array_report_contains(&report, 4, 0) }, 1);
+        assert_eq!(report.attempts, 2);
+        assert!(report.annotations);
+        let trial = unsafe {
+            Box::from_raw(sn_array_report_child(
+                &report,
+                0,
+                std::ptr::null(),
+                0,
+                usize::MAX,
+                1,
+            ))
+        };
+        assert!(trial.silent && trial.annotations);
+        assert_eq!(trial.attempts, 0);
+        assert!(trial.instance_path.text.is_empty());
+        assert!(trial.schema_path.text.is_empty());
+        unsafe {
+            sn_array_report_finish(&mut report, 1);
+        }
+        assert_eq!(unsafe { sn_report_verdict(&report) }, VERDICT_VALID);
+        assert!(report.failed);
+        assert!(report.container_prior.is_none());
+    }
+}
+
+/// # Safety
+/// Report is the current idle C-owned collection and C guards mutation as for adoption.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_clear_collection(report: *mut Report, paths_nil: i32) {
+    unsafe { &mut *report }.clear_collection(paths_nil != 0);
+}
+
+/// # Safety
+/// Path arguments are nil or library-owned Arrays rooted by C. No Ruby calls or
+/// allocation occur before the completed owned seed is returned to C.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_context(
+    silent: i32,
+    attempts: usize,
+    instance_path: Value,
+    schema_path: Value,
+) -> *mut Report {
+    let mut report = Report {
+        silent: silent != 0,
+        attempts,
+        annotations: true,
+        render_messages: true,
+        ..Report::default()
+    };
+    for (value, path) in [
+        (instance_path, &mut report.instance_path),
+        (schema_path, &mut report.schema_path),
+    ] {
+        if value == unsafe { sn_nil() } {
+            continue;
+        }
+        for i in 0..unsafe { sn_len(value) } {
+            path.text.push('/');
+            path.names
+                .push((path.text.len(), unsafe { sn_entry(value, i) }));
+        }
+    }
+    Box::into_raw(Box::new(report))
+}
+/// # Safety
+/// Report is live, idle and C-rooted. Baseline is its original collection count.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_context_count(report: *const Report, baseline: usize) -> usize {
+    let report = unsafe { &*report };
+    let count = if report.collection_reset == 0 {
+        report.attempts.saturating_sub(baseline)
+    } else {
+        report.attempts
+    };
+    if report.silent && report.failed {
+        count.max(1)
+    } else {
+        count
+    }
+}
+/// # Safety
+/// Report is live, idle and C-rooted.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_context_reset(report: *const Report) -> i32 {
+    let report = unsafe { &*report };
+    if report.collection_reset == 0 {
+        0
+    } else if report.reset_path_pops {
+        1
+    } else {
+        2
+    }
+}
+
+/// # Safety
+/// Report is live, immutable and rooted by C. C owns the partial result.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_partial(report: *const Report) -> *mut Report {
+    let mut report = unsafe { &*report }.clone();
+    report.complete_callback(false);
+    Box::into_raw(Box::new(report))
+}
+
+/// # Safety
+/// Report is live, immutable and C-rooted. Prior selects inherited locations.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_report_items_set(report: *const Report, prior: i32) -> Value {
+    let report = unsafe { &*report };
+    let locations = if prior != 0 {
+        &report.container_prior
+    } else {
+        &report.evaluation
+    };
+    locations
+        .as_ref()
+        .and_then(Tracked::items_set)
+        .unwrap_or_else(|| unsafe { sn_nil() })
+}