leptris 1.9.306.0 → 1.9.308.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1bcc695e02ca89b9081d35ea441a4a720219633d0ce010f0d06727cb79bab15
-  data.tar.gz: 38ea48f33b444754fdc3e73dba84645e6d8c95c8178a819e7bae07ace867df5f
+  metadata.gz: 7ef02878e818136f9074d6bdeeb54a55db40d0d6287974a96c81979afe7ed525
+  data.tar.gz: 23468d7fdb2db0aae806d90c0d4d312a9190fe2c69f28333ef202a125c504675
 SHA512:
-  metadata.gz: 7bd7934e1bbc72620d14a66aa344ad786669772bfe4ce5541daa0ccd2a7cb668f271bd79ba4e8647e76ce50a178fc43ae3edeed24d7ef39ab1bee8f348e6af50
-  data.tar.gz: 98d8025f8aab98735ef23955b4ddeb2f474aa17c0f4aea23768292ca99205452b3d8f99f74c63373d405895925620f527aa29d70a549e0b1410592b8ae8ded00
+  metadata.gz: 25aa1f2055a658fbbafdf9031d765311c6a83de1bdbc61d4535a755ae103315e49c4cd99531faa5db5389c2c889175dde051747c86411e278999083c442d161f
+  data.tar.gz: 1a5b9875f8fb26486d82e19ad6f70d0a76ce8cb5128e2b7e1fffa5f6c3ac284085199e067e6dc97aa6d2ecbc67909df490d055dd8728b55bf4e8e4179d4073b3

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.9.307.0] - 2026-10-05
+
+### Fixed
+
+- **Cross-document LEAF adoption (libleptris 1.9.307, engine
+  #1534 — completing the #1528 fix)**: the #1528 adoption gate
+  covered ELEMENT splice arguments only — a TEXT/CDATA/COMMENT/PI
+  node from another document was still spliced raw, so appending
+  scratch-document leaves (the `add_child(String)` fragment path's
+  text children) and freeing the scratch left the tree pointing
+  into freed memory. The four splice seams now adopt non-element
+  arguments by copy too; same-document moves stay zero-copy.
+  Leaf-adoption specs pin the free-then-walk shape.
+
 ## 1.9.306.0 — 2026-10-05
 
 Rides libleptris v1.9.306 (pin 1.9.304 -> 1.9.306): the Lane 18

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.306"
+LIBLEPTRIS_VERSION = "1.9.308"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.306.0"
+  VERSION = "1.9.308.0"
 end

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.306
+- libleptris v1.9.308
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,102 @@
 ## [Unreleased]
 
+## [1.9.308] - 2026-10-05
+
+### Added
+
+- **XPath: `fn:avg` computes in the widest numeric type present
+  (F&O 15.2), 13 QT3 cases adopted (fn/avg 175→182, fn/sum 209→210,
+  fn/apply 5→10).** Every item converts to the common type before
+  summing: with `xs:float` present (no double) the result is
+  `xs:float` and every addend rounds through float32 — the lexical
+  of `xs:float("-3.4028235E38")` is *not* the float32's value
+  (fn-avg-mix-args-012..015); a new `O` typed-scalar mark
+  distinguishes `xs:double` from the N catch-all so float+double
+  promotes to `xs:double` (cbcl-avg-008); an all-integer sequence
+  sums exactly in int64 and divides by long division, spelling the
+  exact decimal where a double carrier loses digits past 2^53
+  (fn-avgintg2args-2/4: −84503251441487847.5). Untyped atomics
+  classify as double (K-SeqAVGFunc-26).
+
+- **XQuery: `typeswitch` accepts the full `case $v as TYPE` arm
+  form**, binding the variable to the operand inside its arm
+  (entries encode `VAR\x02TYPE`). Previously only the type-only
+  form parsed — the binding form was a parse failure.
+
+- **XQuery: `fn:apply` applies XDM function conversion.** An empty
+  array is a legal zero-arity argument list (`apply(true#0, array
+  {})`); node-valued members atomize to their string value
+  (`apply(lower-case#1, [<a>ABC</a>])` = `abc`, built-ins and
+  user-defined functions); a multi-item member of a literal square
+  array stays a SEQUENCE argument — fn:apply evaluates the member
+  expressions directly and the call paths expand the sub-carrier
+  (`fn-apply-03/07`).
+
+- **Rust: the shared descriptor-ABI crate `leptris-descriptor`
+  (ruby#294 topology step 1).** `bindings/rust` is now a Cargo
+  workspace: the `leptris` crate keeps its name and shape, and the
+  new `no_std` `#[repr(C)]` mirror of the descriptor-plan ABI
+  (descriptor.h) is the one record layout the per-engine crate
+  family targets (leptris XML, yeptris YAML, teptris TOML/JSON).
+  The `link` feature declares the engine FFI; the authoritative
+  layout gate compares Rust `size_of` against the engine's own
+  row-size introspection plus a build/walk round trip. `build.rs`
+  now re-runs on `LEPTRIS_LIB_PATH` changes (the link directives
+  were cached, silently linking a stale library).
+
+### Fixed
+
+- `fn:sum`'s duration zero answers the empty sequence in the
+  TYPE's canonical spelling: `PT0S` for `xs:duration` (fn-sum-8),
+  `P0M` kept for `xs:yearMonthDuration` (fn-sum-5).
+- MSVC link failure from `__builtin_add_overflow` (portable
+  int64 range check), and two LSan leaks in the new avg/apply
+  paths — both caught by CI legs that have no local equivalent.
+
+
+
+## [1.9.307] - 2026-10-05
+
+### Fixed
+
+- **DOM: cross-document leaf splices are adopted by copy (#1534,
+  follow-up to #1528).** The #1528 adoption gate covered ELEMENT
+  splice arguments only — a TEXT/CDATA/COMMENT/PI node arriving from
+  a different document was still spliced raw, so replacing an
+  element with a scratch-document leaf and then freeing the scratch
+  document (the `Document.parse` cleanup lifecycle) left the tree
+  pointing into freed memory; serialize → re-parse round trips
+  failed with "malformed input". `append_child` / `prepend_child` /
+  `insert_before` / `insert_after` now dispatch non-element
+  arguments through the #1320 owner-doc stamps and copy by kind;
+  same-document moves and unstamped detached chains keep their
+  zero-copy / link-only behavior, and the append fast path is
+  untouched (element arguments take the unchanged mut-block bail).
+
+- **DOM: `leptris_element_remove_child` walks and relinks the child
+  chain with type-safe accessors (#1534).** The element-filtered
+  getters it used skip non-element siblings, so removing `<a>` from
+  `[<a>, text]` read the next sibling as NULL and set `first_child`
+  to NULL — orphaning the leaf tail (the #1220 class; same-document
+  chains lose plain text too: `<r><a/>t</r>` minus `<a>` serialized
+  as `<r/>`). The walker now uses the node-form accessors, clears
+  the removed child's parent through the per-kind setter, and only
+  decrements `child_count` for element victims (issue #213
+  semantics: it counts element children only). Removing a
+  non-element child cast through the ABI-stable `LeptrisElement`
+  signature (same convention as `insert_before`) now works.
+
+### Tests
+
+- New `CrossDocumentLeafAdoption` suite: the exact issue pipeline —
+  scratch leaf splice → scratch free → serialize → RE-PARSE — for
+  text and the other leaf kinds, plus the append-only variant.
+- New `RemoveChildMixedChain` suite: every position of a removed
+  child against non-element siblings, direct text-child removal,
+  child_count semantics, and the non-child rejection.
+
+
+
 ## [1.9.306] - 2026-10-05
 
 <!-- Edit this section with the actual release notes. -->
@@ -10,6 +107,16 @@
 - (describe changes here)
 
 
+## [1.9.305] - 2026-10-05
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
 ## [1.9.305] - 2026-10-05
 
 ### Performance

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.306
+    VERSION 1.9.308
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/bindings/rust/Cargo.lock

@@ -5,3 +5,10 @@ version = 4
 [[package]]
 name = "leptris"
 version = "1.4.1"
+dependencies = [
+ "leptris-descriptor",
+]
+
+[[package]]
+name = "leptris-descriptor"
+version = "0.1.0"

data/vendor-src/libleptris/bindings/rust/Cargo.toml

@@ -1,3 +1,6 @@
+[workspace]
+members = ["descriptor"]
+
 [package]
 name = "leptris"
 version = "1.4.1"
@@ -13,3 +16,4 @@ build = "build.rs"
 [dependencies]
 
 [dev-dependencies]
+leptris-descriptor = { path = "descriptor", features = ["link"] }

data/vendor-src/libleptris/bindings/rust/README.md

@@ -59,3 +59,22 @@ Mirrors the Ruby (`leptris-ruby`) and Python (`pyleptris`) bindings:
 a hand-maintained FFI layer (`src/ffi.rs`) mirroring the public
 headers, with safe wrappers above it. The FFI drift gate keeps the
 mirror in sync with the C surface.
+
+## Workspace: the shared descriptor-ABI crate
+
+`bindings/rust` is a Cargo workspace. Besides the `leptris crate
+(unchanged name and shape — links-only, resolved via
+`LEPTRIS_LIB_PATH`), it contains the `descriptor` member, published
+as **`leptris-descriptor`**: the `no_std` `#[repr(C)]` mirror of the
+tree-shaped descriptor-plan ABI (`src/include/leptris/descriptor.h`).
+It is the one record layout the whole engine family targets — the
+per-engine crates (`leptris` XML, `yeptris` YAML, `teptris`
+TOML/JSON — topology decided 2026-10-03, leptris-ruby#294) — so
+hosts build plan rows once for every engine. The `link` feature
+declares the engine FFI for the descriptor surface; enable it on
+exactly one crate in the graph.
+
+The authoritative layout gate is `tests/descriptor_abi.rs` in the
+`leptris` crate: it compares Rust `size_of` against the engine's own
+`leptris_plan_*_struct_size` introspection and walks a plan built
+from the mirrored rows.

data/vendor-src/libleptris/bindings/rust/build.rs

@@ -10,6 +10,10 @@ use std::path::{Path, PathBuf};
 use std::{env, fs};
 
 fn main() {
+    // The lib path changes the emitted link directives; without
+    // this the build script output is cached across LEPTRIS_LIB_PATH
+    // changes and tests link a stale library.
+    println!("cargo:rerun-if-env-changed=LEPTRIS_LIB_PATH");
     // Windows: the DLL is libleptris.dll, so the import library is
     // libleptris.lib — link.exe resolves `-l <name>` as <name>.lib.
     // (TODO.concurrency/05 renamed the DLL from leptris.dll.)

data/vendor-src/libleptris/bindings/rust/descriptor/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "leptris-descriptor"
+version = "0.1.0"
+edition = "2021"
+description = "Shared descriptor-plan ABI for the leptris engine family (leptris, yeptris, teptris) — repr(C) mirrors of the tree-shaped descriptor plan records"
+license = "MIT"
+repository = "https://github.com/leptris/leptris"
+homepage = "https://www.leptris.org"
+
+[features]
+# Declares the engine FFI (extern "C") for the descriptor surface.
+# Enable on exactly one binding crate in the dependency graph —
+# the declarations carry no symbols of their own.
+link = []
+
+[dependencies]

data/vendor-src/libleptris/bindings/rust/descriptor/src/lib.rs

@@ -0,0 +1,214 @@
+//! Shared descriptor-plan ABI for the leptris engine family.
+//!
+//! One crate per engine (`leptris` XML, `yeptris` YAML, `teptris`
+//! TOML/JSON) targets this record layout, so hosts build plan rows
+//! once and every engine's compiled-descriptor walk speaks the same
+//! shape. The types mirror `src/include/leptris/descriptor.h` in the
+//! leptris engine — field order is the ABI; NEVER renumber or
+//! reorder. Additive trailing fields only, guarded by an ABI version
+//! bump.
+//!
+//! Layout is verified at runtime against the engine's own
+//! introspection (`leptris_plan_*_struct_size`) by the linking
+//! binding crate's tests.
+//!
+//! This crate is `no_std`: types and constants only, plus the FFI
+//! declarations behind the `link` feature.
+
+#![no_std]
+#![allow(non_camel_case_types, non_snake_case)]
+
+use core::ffi::c_char;
+
+/// Must equal `leptris_plan_abi_version()` reported by the engine.
+pub const PLAN_ABI_VERSION: u32 = 1;
+
+/// Child / attribute plan kinds. Append-only.
+pub type PlanKind = u8;
+pub const PLAN_KIND_SCALAR: PlanKind = 1;
+pub const PLAN_KIND_COLLECTION: PlanKind = 2;
+pub const PLAN_KIND_NESTED: PlanKind = 3;
+pub const PLAN_KIND_RAW: PlanKind = 4;
+pub const PLAN_KIND_CONTENT: PlanKind = 5;
+pub const PLAN_KIND_CALLBACK: PlanKind = 6;
+
+/// Element plan flags.
+pub const PLAN_FLAG_MIXED_CONTENT: u32 = 0x1;
+pub const PLAN_FLAG_ORDERED: u32 = 0x2;
+pub const PLAN_FLAG_CDATA: u32 = 0x4;
+pub const PLAN_FLAG_NS_LENIENT: u32 = 0x8;
+pub const PLAN_FLAG_EMIT_ORDER_SPINE: u32 = 0x10;
+
+/// Namespace matching form for binding an element or attribute.
+pub type PlanNsForm = u8;
+pub const PLAN_NS_NONE: PlanNsForm = 0;
+pub const PLAN_NS_EXACT: PlanNsForm = 1;
+pub const PLAN_NS_ANY: PlanNsForm = 2;
+
+/// Result node kinds (the value tree a walk returns).
+pub type PlanValueKind = i32;
+pub const PLAN_VALUE_ELEMENT: PlanValueKind = 0;
+pub const PLAN_VALUE_SCALAR: PlanValueKind = 1;
+pub const PLAN_VALUE_COLLECTION: PlanValueKind = 2;
+pub const PLAN_VALUE_RAW: PlanValueKind = 3;
+pub const PLAN_VALUE_CALLBACK: PlanValueKind = 4;
+
+/// Attribute-match row: requires every (name, expected value) pair.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct AttrPredicate {
+    /// XML attribute name as it appears on the wire.
+    pub wire_name: *const c_char,
+    /// String-equal match (non-null); host-owned.
+    pub expected_value: *const c_char,
+}
+
+/// Attribute binding row.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct AttrPlan {
+    /// XML attribute name as it appears on the wire.
+    pub wire_name: *const c_char,
+    /// `PlanKind`: SCALAR | COLLECTION | CALLBACK.
+    pub kind: u8,
+    /// Host-defined; echoed back verbatim.
+    pub type_tag: u8,
+    /// Number of `predicates` rows (0 = historical behavior).
+    pub predicate_count: u16,
+    pub pad_pred: u16,
+    pub predicates: *const AttrPredicate,
+    /// Attribute-level namespace form; `wire_name` is the LOCAL
+    /// name when set. NONE (0) keeps wire-name lookup.
+    pub ns_form: u8,
+    pub pad_ns: u8,
+    /// `PLAN_NS_EXACT` only.
+    pub ns_uri: *const c_char,
+}
+
+/// Child binding row.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ChildPlan {
+    /// XML element name as it appears on the wire: the prefixed
+    /// form ("w:b") binds that literal prefix+local pair; the bare
+    /// local form ("b") binds by local name and lets `ns_form` do
+    /// the namespace work.
+    pub wire_name: *const c_char,
+    pub kind: u8,
+    pub type_tag: u8,
+    /// NESTED: index into `PlanSpec::plans`; -1 otherwise.
+    pub child_plan_index: i32,
+    /// Rule-level namespace form, consulted at child-match time.
+    pub ns_form: u8,
+    pub pad0: u8,
+    /// `PLAN_NS_EXACT` only.
+    pub ns_uri: *const c_char,
+    /// Element-side predicates; same semantics as `AttrPredicate`.
+    pub predicate_count: u16,
+    pub pad_pred: u16,
+    pub predicates: *const AttrPredicate,
+}
+
+/// One element plan: the attribute and child rows bound to a name.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ElementPlan {
+    /// Local name this plan binds; matching uses the CHILD row's
+    /// `wire_name`.
+    pub element_name: *const c_char,
+    pub ns_form: u8,
+    pub pad0: u8,
+    /// `PLAN_NS_EXACT` only.
+    pub ns_uri: *const c_char,
+    pub attribute_count: u32,
+    pub child_count: u32,
+    pub attribute_plans: *const AttrPlan,
+    pub child_plans: *const ChildPlan,
+    /// `PLAN_FLAG_*`.
+    pub flags: u16,
+    pub pad1: u16,
+}
+
+/// Top-level plan specification handed to the engine.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct PlanSpec {
+    /// Must equal the engine's `leptris_plan_abi_version()`.
+    pub abi_version: u32,
+    /// `plans[0]` is the root plan applied to the walk context.
+    pub plan_count: u32,
+    pub plans: *const ElementPlan,
+}
+
+#[cfg(feature = "link")]
+pub mod ffi {
+    //! Engine FFI for the descriptor surface. Enable this feature on
+    //! exactly one crate in the graph (the binding that links an
+    //! engine).
+
+    use super::PlanSpec;
+    use core::ffi::{c_char, c_void};
+
+    /// Opaque engine document handle (leptris: `LeptrisDocument`).
+    pub type DocumentHandle = *mut c_void;
+    /// Opaque engine element handle (leptris: `LeptrisElement`).
+    pub type ElementHandle = *mut c_void;
+    /// Status out-parameter (leptris: `LeptrisStatus*`).
+    pub type StatusPtr = *mut i32;
+    /// Opaque compiled plan.
+    pub type Plan = *mut c_void;
+    /// Opaque walk result value.
+    pub type PlanResult = *const c_void;
+
+    extern "C" {
+        pub fn leptris_plan_abi_version() -> u32;
+        pub fn leptris_plan_spec_struct_size() -> usize;
+        pub fn leptris_plan_element_row_size() -> usize;
+        pub fn leptris_plan_child_row_size() -> usize;
+        pub fn leptris_plan_attr_row_size() -> usize;
+        pub fn leptris_plan_predicate_row_size() -> usize;
+
+        pub fn leptris_plan_build(spec: *const PlanSpec, status: StatusPtr) -> Plan;
+        pub fn leptris_plan_free(plan: Plan);
+
+        pub fn leptris_plan_walk(
+            doc: DocumentHandle,
+            ctx: ElementHandle,
+            plan: Plan,
+            status: StatusPtr,
+        ) -> PlanResult;
+        pub fn leptris_plan_materialize(
+            source: *const c_char,
+            source_len: usize,
+            plan: Plan,
+            status: StatusPtr,
+        ) -> PlanResult;
+        pub fn leptris_plan_result_free(result: PlanResult);
+
+        pub fn leptris_plan_value_kind(v: PlanResult) -> i32;
+        pub fn leptris_plan_value_name(v: PlanResult) -> *const c_char;
+        pub fn leptris_plan_value_type_tag(v: PlanResult) -> u8;
+        pub fn leptris_plan_value_string(v: PlanResult) -> *const c_char;
+        pub fn leptris_plan_value_length(v: PlanResult) -> usize;
+        pub fn leptris_plan_value_position(v: PlanResult) -> usize;
+        pub fn leptris_plan_value_node_kind(v: PlanResult) -> u8;
+        pub fn leptris_plan_value_order_index(v: PlanResult) -> u32;
+        pub fn leptris_plan_value_count(v: PlanResult) -> usize;
+        pub fn leptris_plan_value_at(v: PlanResult, i: usize) -> PlanResult;
+        pub fn leptris_plan_value_children_snapshot(
+            v: PlanResult,
+            names_blob: *mut c_char,
+            blob_cap: usize,
+            name_offsets: *mut usize,
+            type_tags: *mut u8,
+            child_handles: *mut PlanResult,
+        ) -> usize;
+        pub fn leptris_plan_value_attribute(
+            v: PlanResult,
+            wire_name: *const c_char,
+        ) -> *const c_char;
+        pub fn leptris_plan_value_int(v: PlanResult, out: *mut i64) -> i32;
+        pub fn leptris_plan_value_float(v: PlanResult, out: *mut f64) -> i32;
+        pub fn leptris_plan_value_bool(v: PlanResult, out: *mut i32) -> i32;
+    }
+}

data/vendor-src/libleptris/bindings/rust/descriptor/tests/layout.rs

@@ -0,0 +1,50 @@
+//! Compile-time layout invariants for the descriptor ABI mirror.
+//!
+//! These check the crate's internal consistency (trailing-field
+//! discipline, alignment) — the BINDING crate's integration test
+//! verifies the sizes against the engine's own introspection, which
+//! is the authoritative gate.
+
+use leptris_descriptor::*;
+use std::mem::{align_of, size_of};
+
+#[test]
+fn trailing_field_discipline() {
+    // Trailing additive fields must not change the size when zeroed:
+    // zero-extended aggregate initializers stay valid across ABI
+    // additions. repr(C) + these sizes are the contract.
+    assert_eq!(size_of::<PlanSpec>(), 4 + 4 + size_of::<*const u8>());
+    assert_eq!(align_of::<PlanSpec>(), align_of::<*const u8>());
+}
+
+#[test]
+fn kind_and_flag_constants_match_engine_headers() {
+    assert_eq!(PLAN_ABI_VERSION, 1);
+    assert_eq!(PLAN_KIND_SCALAR, 1);
+    assert_eq!(PLAN_KIND_COLLECTION, 2);
+    assert_eq!(PLAN_KIND_NESTED, 3);
+    assert_eq!(PLAN_KIND_RAW, 4);
+    assert_eq!(PLAN_KIND_CONTENT, 5);
+    assert_eq!(PLAN_KIND_CALLBACK, 6);
+    assert_eq!(PLAN_FLAG_MIXED_CONTENT, 0x1);
+    assert_eq!(PLAN_FLAG_ORDERED, 0x2);
+    assert_eq!(PLAN_FLAG_CDATA, 0x4);
+    assert_eq!(PLAN_FLAG_NS_LENIENT, 0x8);
+    assert_eq!(PLAN_FLAG_EMIT_ORDER_SPINE, 0x10);
+    assert_eq!(PLAN_NS_NONE, 0);
+    assert_eq!(PLAN_NS_EXACT, 1);
+    assert_eq!(PLAN_NS_ANY, 2);
+    assert_eq!(PLAN_VALUE_ELEMENT, 0);
+    assert_eq!(PLAN_VALUE_SCALAR, 1);
+    assert_eq!(PLAN_VALUE_COLLECTION, 2);
+    assert_eq!(PLAN_VALUE_RAW, 3);
+    assert_eq!(PLAN_VALUE_CALLBACK, 4);
+}
+
+#[test]
+fn row_layouts_are_pointer_sized_aligned() {
+    assert_eq!(align_of::<AttrPredicate>(), align_of::<*const u8>());
+    assert_eq!(align_of::<AttrPlan>(), align_of::<*const u8>());
+    assert_eq!(align_of::<ChildPlan>(), align_of::<*const u8>());
+    assert_eq!(align_of::<ElementPlan>(), align_of::<*const u8>());
+}