This is an automated email from the ASF dual-hosted git repository.
tqchen pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tvm-ffi.git
The following commit(s) were added to refs/heads/main by this push:
new 55b4fad0 [Rust] Index Array in place; add Array::from_vec; rename
Optional::is_some and UnchangedOr::value_or_unchanged (#929)
55b4fad0 is described below
commit 55b4fad05c39996f506c170985da2381134ef362
Author: Tianqi Chen <[email protected]>
AuthorDate: Thu Nov 5 09:13:46 2026 -0500
[Rust] Index Array in place; add Array::from_vec; rename Optional::is_some
and UnchangedOr::value_or_unchanged (#929)
Fixes one unsound API and aligns several names with Rust conventions.
- **`Array` indexing.** `Index<usize> for Array<T>` returned
`&AnyView<'static>`. Because `AnyView` is `Copy`, `arr[i]` could copy
out a view that outlives the array, in safe code. It now returns `&T`,
borrowed from the array's cell. Every cell of an `Array<T>` holds a `T`,
checked when the array is built, so indexing only debug-checks the type,
like `Vec`'s `[]` next to `get`. The hidden unsafe `RefFromAny` trait
(`ref_from_any(cell) -> &Self`) marks the types an FFI `Any` cell stores
in place: `Any`, `String`, `Bytes`, `i64`, `f64`, `Array`, `Map`,
`List`, and every `#[derive(ObjectRef)]` type. The derive asserts at
compile time that the reference type is exactly its `ObjectArc`.
- **`Array::new()` / `Array::from_vec`.** `Array::new()` creates an
empty array, like `List::new()` and `Map::new()`.
`Array::from_vec(items)` and `From<Vec<T>>` build one from items.
- **`Optional::is_some`.** Renamed from `has_value`, next to `is_none`.
- **`UnchangedOr::value_or_unchanged`.** Renamed from `value_or`,
matching C++ `ValueOrUnchanged`. `value_or_else` is removed; use
`into_option().unwrap_or_else(..)`.
- **`Tensor::data_as_slice_mut`.** Allows `clippy::mut_from_ref` on this
one function: returning `&mut` from `&self` is intentional and covered
by its documented safety contract.
- **`Map::contains_key`.** Returns `Result<bool>`: a lookup that fails
in the C++ runtime is reported as `Err`, like `Map::get`, instead of
panicking.
---
docs/guides/rust_lang_guide.rst | 30 ++--
rust/tvm-ffi-macros/src/object_macros.rs | 19 +++
rust/tvm-ffi/src/any.rs | 4 +-
rust/tvm-ffi/src/collections/array.rs | 64 +++++--
rust/tvm-ffi/src/collections/list.rs | 11 ++
rust/tvm-ffi/src/collections/map.rs | 31 ++--
rust/tvm-ffi/src/collections/tensor.rs | 2 +-
rust/tvm-ffi/src/extra/structural_map.rs | 20 +--
rust/tvm-ffi/src/extra/structural_mutate.rs | 76 ++++-----
rust/tvm-ffi/src/extra/structural_visit.rs | 68 ++++----
rust/tvm-ffi/src/extra/structural_walk.rs | 18 +-
rust/tvm-ffi/src/extra/unchanged.rs | 35 ++--
rust/tvm-ffi/src/lib.rs | 18 +-
rust/tvm-ffi/src/macros.rs | 4 +-
rust/tvm-ffi/src/object.rs | 2 +-
rust/tvm-ffi/src/optional.rs | 8 +-
rust/tvm-ffi/src/reflection/unsafe_init.rs | 2 +-
rust/tvm-ffi/src/type_traits.rs | 55 ++++++
rust/tvm-ffi/tests/test_array.rs | 22 +--
rust/tvm-ffi/tests/test_big_int.rs | 8 +-
rust/tvm-ffi/tests/test_cast.rs | 2 +-
rust/tvm-ffi/tests/test_error.rs | 2 +-
rust/tvm-ffi/tests/test_function.rs | 4 +-
rust/tvm-ffi/tests/test_list.rs | 8 +-
rust/tvm-ffi/tests/test_map.rs | 12 +-
rust/tvm-ffi/tests/test_match_any.rs | 8 +-
rust/tvm-ffi/tests/test_object.rs | 4 +-
rust/tvm-ffi/tests/test_object_reflection.rs | 2 +-
rust/tvm-ffi/tests/test_optional.rs | 8 +-
rust/tvm-ffi/tests/test_rs_object.rs | 4 +-
rust/tvm-ffi/tests/test_structural_mutate.rs | 184 ++++++++++++---------
rust/tvm-ffi/tests/test_structural_visit.rs | 123 ++++++++------
rust/tvm-ffi/tests/test_structural_visit_base.rs | 94 +++++------
.../tests/test_structural_visitor_alignment.rs | 4 +-
rust/tvm-ffi/tests/test_tensor_view.rs | 4 +-
35 files changed, 561 insertions(+), 399 deletions(-)
diff --git a/docs/guides/rust_lang_guide.rst b/docs/guides/rust_lang_guide.rst
index e780bf06..829d3b66 100644
--- a/docs/guides/rust_lang_guide.rst
+++ b/docs/guides/rust_lang_guide.rst
@@ -89,7 +89,7 @@ the value it borrows. A number and a built-in array
illustrate owning and borrow
let number = Any::from(3_i64);
assert_eq!(number.try_as::<i64>(), Some(3));
- let value = Any::from(Array::new(vec![1_i64, 2, 3]));
+ let value = Any::from(Array::from_vec(vec![1_i64, 2, 3]));
let view = AnyView::from(&value); // Borrow the value without a new
reference.
assert_eq!(view.downcast_ref::<ArrayObj>().unwrap().size, 3);
@@ -122,7 +122,7 @@ element type to ``T``. Named reference types implement
|rs-objectrefcore|_ for s
use tvm_ffi::collections::array::ArrayObj;
use tvm_ffi::{Array, ObjectRefCore};
- let array = Array::new(vec![1_i64, 2, 3]);
+ let array = Array::from_vec(vec![1_i64, 2, 3]);
assert_eq!(array.downcast_ref::<ArrayObj>().unwrap().size, 3);
assert_eq!(array.get(1).unwrap(), 2); // A method of the named type.
@@ -498,7 +498,7 @@ arm whose type matches the value runs:
for value in [
Any::from(42_i64),
Any::from(tvm_ffi::String::from("hi")),
- Any::from(Array::new(vec![1_i64, 2, 3])),
+ Any::from(Array::from_vec(vec![1_i64, 2, 3])),
Any::from(1.5_f64),
] {
println!("{}", kind(&value));
@@ -555,10 +555,10 @@ them. Let's describe nested arrays, with a separator
between items:
}
}
- let value = Any::from(Array::new(vec![
+ let value = Any::from(Array::from_vec(vec![
Any::from(1_i64),
Any::from(tvm_ffi::String::from("a")),
- Any::from(Array::new(vec![2_i64, 3])),
+ Any::from(Array::from_vec(vec![2_i64, 3])),
]));
let text = Describer.dispatch(AnyView::from(&value), ", ").unwrap();
println!("{text}");
@@ -661,7 +661,7 @@ Walk handlers may take an optional trailing
``DefRegionKind`` argument:
}
}
- let values = Array::new(vec![1_i64, 2, 3]);
+ let values = Array::from_vec(vec![1_i64, 2, 3]);
let mut probe = Probe::default();
structural_walk(&values, &mut probe, WalkOrder::PreOrder)?;
assert_eq!(probe.total, 6);
@@ -682,7 +682,7 @@ take a trailing ``DefRegionKind`` argument:
use tvm_ffi::{structural_walk, Array, DefRegionKind, Object, WalkOrder,
WalkResult};
- let values = Array::new(vec![1_i64, 2, 3]);
+ let values = Array::from_vec(vec![1_i64, 2, 3]);
let mut total = 0;
structural_walk(
@@ -725,7 +725,7 @@ propagate errors with ``?``:
use tvm_ffi::{structural_walk, Array, WalkOrder, WalkResult};
- let values = Array::new(vec![1_i64, 2, 3]);
+ let values = Array::from_vec(vec![1_i64, 2, 3]);
let found = structural_walk(
&values,
|value: i64| {
@@ -765,7 +765,7 @@ dispatchers and closures.
}
}
- let values = Array::new(vec![1_i64, 2]);
+ let values = Array::from_vec(vec![1_i64, 2]);
let mut visitor = Stats::default();
structural_visit(&values, &mut visitor)?;
assert_eq!(visitor.total, 3);
@@ -810,7 +810,7 @@ argument tuple and return type supply the engine signature
directly:
}
}
- let values = Array::new(vec![1_i64, 2]);
+ let values = Array::from_vec(vec![1_i64, 2]);
let mut depth = Depth::default();
structural_visit(&values, &mut depth)?;
assert_eq!(depth.max, 2);
@@ -868,7 +868,7 @@ catch-all and should therefore come last:
let mut increment = Increment::default();
let mapped = structural_map(
- Array::new(vec![1_i64, 2]),
+ Array::from_vec(vec![1_i64, 2]),
&mut increment,
WalkOrder::PostOrder,
)?;
@@ -958,7 +958,7 @@ Base implementations delegate to the corresponding
``StructuralVisitorObj`` or
}
let mut mutator = Stats::default();
- let mutated = structural_mutate(Array::new(vec![1_i64, 2]), &mut mutator)?;
+ let mutated = structural_mutate(Array::from_vec(vec![1_i64, 2]), &mut
mutator)?;
let mutated = Array::<i64>::try_from(mutated)?;
assert_eq!(mutated.iter().collect::<Vec<_>>(), vec![2, 3]);
assert_eq!(mutator.integers, 2);
@@ -967,7 +967,7 @@ Base implementations delegate to the corresponding
``StructuralVisitorObj`` or
``mutator.default_mutate(self, value)`` runs default descent. Both return
``Result<UnchangedOr<Any>>`` and preserve the capability's permission. For a
local owning
``Any``, pass ``&mut owned`` and resolve the returned change with
-``change.value_or(owned)`` after the borrow ends. These calls inherit the
definition
+``change.value_or_unchanged(owned)`` after the borrow ends. These calls
inherit the definition
region established by the defining node or reflected field; handlers query it
with ``mutator.def_region_kind()``. Reserve ``with_def_region_kind`` on either
view
for hooks that establish a definition region according to their node's
semantics.
@@ -1014,7 +1014,7 @@ other handler consumes it:
}
let mut increment = Increment::default();
- let mutated = structural_mutate(Array::new(vec![1_i64, 2]), &mut
increment)?;
+ let mutated = structural_mutate(Array::from_vec(vec![1_i64, 2]), &mut
increment)?;
let mutated = Array::<i64>::try_from(mutated)?;
assert_eq!(mutated.iter().collect::<Vec<_>>(), vec![2, 3]);
assert_eq!(increment.integers, 2);
@@ -1043,7 +1043,7 @@ while retaining typed scalar replacements:
}
}
- let mutated = structural_mutate(Array::new(vec![1_i64, 2]), Increment)?;
+ let mutated = structural_mutate(Array::from_vec(vec![1_i64, 2]),
Increment)?;
let mutated = Array::<i64>::try_from(mutated)?;
assert_eq!(mutated.iter().collect::<Vec<_>>(), vec![2, 3]);
diff --git a/rust/tvm-ffi-macros/src/object_macros.rs
b/rust/tvm-ffi-macros/src/object_macros.rs
index e51745dc..76cc3492 100644
--- a/rust/tvm-ffi-macros/src/object_macros.rs
+++ b/rust/tvm-ffi-macros/src/object_macros.rs
@@ -555,6 +555,25 @@ pub(crate) fn expand_object_ref(
}
}
+ // The handle is exactly its object pointer, which an FFI cell's
+ // payload word holds, so an `Array` cell can lend `&Self` in place.
+ const _: () = {
+ type ContainerType = <#struct_name as
#tvm_ffi_crate::object::ObjectRefCore>::ContainerType;
+ assert!(
+ ::core::mem::size_of::<#struct_name>()
+ ==
::core::mem::size_of::<#tvm_ffi_crate::object::ObjectArc<ContainerType>>()
+ && ::core::mem::offset_of!(#struct_name, #data_id) == 0,
+ "an ObjectRef must consist of its ObjectArc alone"
+ );
+ };
+
+ unsafe impl #tvm_ffi_crate::type_traits::RefFromAny for #struct_name {
+ #[inline(always)]
+ unsafe fn ref_from_any(cell:
&#tvm_ffi_crate::tvm_ffi_sys::TVMFFIAny) -> &Self {
+ &*(::core::ptr::addr_of!(cell.data_union) as *const Self)
+ }
+ }
+
impl ::std::convert::From<&#struct_name> for #struct_name {
#[inline]
fn from(value: &#struct_name) -> Self {
diff --git a/rust/tvm-ffi/src/any.rs b/rust/tvm-ffi/src/any.rs
index f9b24672..a853822f 100644
--- a/rust/tvm-ffi/src/any.rs
+++ b/rust/tvm-ffi/src/any.rs
@@ -34,7 +34,7 @@ use tvm_ffi_sys::{TVMFFIAny, TVMFFIAnyViewToOwnedAny};
/// ```
/// use tvm_ffi::{Any, AnyView, Array};
///
-/// let array = Array::new(vec![1_i64, 2, 3]);
+/// let array = Array::from_vec(vec![1_i64, 2, 3]);
/// let view = AnyView::from(&array);
/// assert_eq!(view.try_as::<Array<i64>>().unwrap().len(), 3);
///
@@ -327,7 +327,7 @@ impl Any {
///
/// ```
/// use tvm_ffi::{collections::array::ArrayObj, Any, Array};
- /// let value = Any::from(Array::new(vec![1_i64, 2]));
+ /// let value = Any::from(Array::from_vec(vec![1_i64, 2]));
/// assert_eq!(value.downcast_ref::<ArrayObj>().unwrap().size, 2);
/// ```
///
diff --git a/rust/tvm-ffi/src/collections/array.rs
b/rust/tvm-ffi/src/collections/array.rs
index f7fb613b..07249398 100644
--- a/rust/tvm-ffi/src/collections/array.rs
+++ b/rust/tvm-ffi/src/collections/array.rs
@@ -24,7 +24,7 @@ use crate::any::TryFromTemp;
use crate::collections::list::seq_cells;
use crate::derive::Object;
use crate::object::{Object, ObjectArc};
-use crate::type_traits::ContainerElement;
+use crate::type_traits::{ContainerElement, RefFromAny};
use crate::{Any, AnyCompatible, AnyView, ObjectCoreWithExtraItems,
ObjectRefCore};
use tvm_ffi_sys::TVMFFITypeIndex as TypeIndex;
use tvm_ffi_sys::{TVMFFIAny, TVMFFIObject};
@@ -63,7 +63,7 @@ unsafe impl ObjectCoreWithExtraItems for ArrayObj {
/// ```
/// use tvm_ffi::Array;
///
-/// let array = Array::new(vec![1_i64, 2, 3]);
+/// let array = Array::from_vec(vec![1_i64, 2, 3]);
/// assert_eq!(array.len(), 3);
/// assert_eq!(array.get(1)?, 2);
/// assert!(array.get(3).is_err());
@@ -89,7 +89,13 @@ impl<T: ContainerElement + Clone> Debug for Array<T> {
impl<T: ContainerElement + Clone> Default for Array<T> {
fn default() -> Self {
- Self::new(vec![])
+ Self::new()
+ }
+}
+
+impl<T: ContainerElement + Clone> From<Vec<T>> for Array<T> {
+ fn from(items: Vec<T>) -> Self {
+ Self::from_vec(items)
}
}
@@ -113,7 +119,18 @@ unsafe impl<T: ContainerElement + Clone> ObjectRefCore for
Array<T> {
}
impl<T: ContainerElement + Clone> Array<T> {
- /// Create an array holding `items`.
+ /// Create an empty array.
+ ///
+ /// # Returns
+ ///
+ /// The empty array.
+ ///
+ /// See also [`Array::from_vec`].
+ pub fn new() -> Self {
+ Self::from_vec(Vec::new())
+ }
+
+ /// Create an array holding `items`, like `Array::from(items)`.
///
/// # Arguments
///
@@ -122,7 +139,16 @@ impl<T: ContainerElement + Clone> Array<T> {
/// # Returns
///
/// The array.
- pub fn new(items: Vec<T>) -> Self {
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tvm_ffi::Array;
+ ///
+ /// let array = Array::from_vec(vec![1_i64, 2, 3]);
+ /// assert_eq!(array[1], 2);
+ /// ```
+ pub fn from_vec(items: Vec<T>) -> Self {
let capacity = items.len();
Self::new_with_capacity(items, capacity)
}
@@ -234,10 +260,12 @@ impl<T: ContainerElement + Clone> Array<T> {
// --- Index Implementation ---
-impl<T: ContainerElement + Clone> std::ops::Index<usize> for Array<T> {
- type Output = AnyView<'static>;
+/// Lends `&T` from the array's cell in place. Every cell of an `Array<T>`
+/// holds a `T` (checked when the array is built), so only a debug check runs.
+impl<T: ContainerElement + Clone + RefFromAny> std::ops::Index<usize> for
Array<T> {
+ type Output = T;
- fn index(&self, index: usize) -> &Self::Output {
+ fn index(&self, index: usize) -> &T {
let container = self.as_container();
let len = container.size as usize;
if index >= len {
@@ -247,8 +275,9 @@ impl<T: ContainerElement + Clone> std::ops::Index<usize>
for Array<T> {
);
}
unsafe {
- let ptr = (container.data as *const AnyView<'static>).add(index);
- &*ptr
+ let cell = &*(container.data as *const TVMFFIAny).add(index);
+ debug_assert!(T::container_check_any_strict(cell));
+ T::ref_from_any(cell)
}
}
}
@@ -287,7 +316,7 @@ impl<'a, T: ContainerElement + Clone> IntoIterator for &'a
Array<T> {
impl<T: ContainerElement + Clone> FromIterator<T> for Array<T> {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let items: Vec<T> = iter.into_iter().collect();
- Self::new(items)
+ Self::from_vec(items)
}
}
@@ -391,7 +420,18 @@ where
for cell in cells {
items.push(T::container_try_cast_from_any_view(cell)?);
}
- Ok(Array::new(items))
+ Ok(Array::from_vec(items))
+ }
+}
+
+// The cell's payload word is the single object pointer of the handle.
+unsafe impl<T> crate::type_traits::RefFromAny for Array<T>
+where
+ T: ContainerElement + Clone,
+{
+ #[inline(always)]
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self {
+ &*(core::ptr::addr_of!(cell.data_union) as *const Self)
}
}
diff --git a/rust/tvm-ffi/src/collections/list.rs
b/rust/tvm-ffi/src/collections/list.rs
index 40a0c8b4..dea75f18 100644
--- a/rust/tvm-ffi/src/collections/list.rs
+++ b/rust/tvm-ffi/src/collections/list.rs
@@ -656,6 +656,17 @@ unsafe impl<T: ContainerElement> AnyCompatible for List<T>
{
}
}
+// The cell's payload word is the single object pointer of the handle.
+unsafe impl<T> crate::type_traits::RefFromAny for List<T>
+where
+ T: ContainerElement,
+{
+ #[inline(always)]
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self {
+ &*(core::ptr::addr_of!(cell.data_union) as *const Self)
+ }
+}
+
impl<T: ContainerElement> TryFrom<Any> for List<T> {
type Error = Error;
diff --git a/rust/tvm-ffi/src/collections/map.rs
b/rust/tvm-ffi/src/collections/map.rs
index a82664fa..2c9b11c1 100644
--- a/rust/tvm-ffi/src/collections/map.rs
+++ b/rust/tvm-ffi/src/collections/map.rs
@@ -230,21 +230,18 @@ where
}
}
- /// Returns `true` if `key` is present in the map.
- ///
- /// Panics if the lookup fails in the C++ runtime (e.g. `key` is not
- /// hashable); use [`Map::get`] when such failures must be recovered from.
+ /// Returns `Ok(true)` if `key` is present in the map, or `Err` if the
lookup
+ /// fails in the C++ runtime (e.g. `key` is not hashable), like
+ /// [`Map::get`].
/// Passing a `key` whose *type* does not match the map's key type is
- /// **undefined** (currently reads as `false`; see [`Map::get`]); debug
builds
- /// assert against it.
- pub fn contains_key(&self, key: &K) -> bool {
- let present = self
- .try_contains_key(key)
- .expect("ffi.MapCount call failed");
+ /// **undefined** (currently reads as `Ok(false)`; see [`Map::get`]); debug
+ /// builds assert against it.
+ pub fn contains_key(&self, key: &K) -> Result<bool> {
+ let present = self.try_contains_key(key)?;
if !present {
self.debug_assert_key_type();
}
- present
+ Ok(present)
}
/// Looks up `key`, returning `Ok(None)` if absent, or `Err` if the lookup
@@ -574,6 +571,18 @@ where
}
}
+// The cell's payload word is the single object pointer of the handle.
+unsafe impl<K, V> crate::type_traits::RefFromAny for Map<K, V>
+where
+ K: ContainerElement,
+ V: ContainerElement,
+{
+ #[inline(always)]
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self {
+ &*(core::ptr::addr_of!(cell.data_union) as *const Self)
+ }
+}
+
impl<K, V> TryFrom<Any> for Map<K, V>
where
K: ContainerElement,
diff --git a/rust/tvm-ffi/src/collections/tensor.rs
b/rust/tvm-ffi/src/collections/tensor.rs
index 32cbf488..ae3003af 100644
--- a/rust/tvm-ffi/src/collections/tensor.rs
+++ b/rust/tvm-ffi/src/collections/tensor.rs
@@ -179,7 +179,7 @@ impl Tensor {
/// # Safety contract (caller responsibility)
/// If the `Tensor` has been cloned (via `ObjectArc`), the caller must
/// ensure no other clone is concurrently reading the data.
- #[allow(clippy::wrong_self_convention)]
+ #[allow(clippy::wrong_self_convention, clippy::mut_from_ref)]
pub fn data_as_slice_mut<T: AsDLDataType>(&self) -> Result<&mut [T]> {
let dtype = T::DL_DATA_TYPE;
if self.dtype() != dtype {
diff --git a/rust/tvm-ffi/src/extra/structural_map.rs
b/rust/tvm-ffi/src/extra/structural_map.rs
index 50fe8677..eb7cece9 100644
--- a/rust/tvm-ffi/src/extra/structural_map.rs
+++ b/rust/tvm-ffi/src/extra/structural_map.rs
@@ -21,12 +21,12 @@
use super::structural_common::raw_ffi_any_same_as;
use super::structural_mutate::{
- IntoMutateResult, MutationView, StructuralMutateEngine,
StructuralMutatorView,
- with_mutation_error_context,
+ with_mutation_error_context, IntoMutateResult, MutationView,
StructuralMutateEngine,
+ StructuralMutatorView,
};
use super::structural_visit::DefRegionKind;
use super::structural_walk::WalkOrder;
-use super::unchanged::{UnchangedOr, is_unchanged};
+use super::unchanged::{is_unchanged, UnchangedOr};
use crate::{Any, AnyView, Dispatcher, IntoDispatcher, Result};
use std::borrow::BorrowMut;
@@ -192,7 +192,7 @@ where
/// ```
/// use tvm_ffi::{structural_map, Array, WalkOrder};
///
-/// let root = Array::new(vec![1_i64, 2, 3]);
+/// let root = Array::from_vec(vec![1_i64, 2, 3]);
/// let mapped = structural_map(root.clone(), |value: i64| value + 1,
WalkOrder::PostOrder)?;
/// let mapped = Array::<i64>::try_from(mapped)?;
/// assert_eq!(mapped.iter().collect::<Vec<_>>(), vec![2, 3, 4]);
@@ -204,12 +204,12 @@ where
R: Into<Any>,
O: BorrowMut<D>,
for<'v> H: IntoDispatcher<
- (AnyView<'v>, DefRegionKind),
- Option<Result<UnchangedOr<Any>>>,
- M,
- Target = D,
- Output = O,
- >,
+ (AnyView<'v>, DefRegionKind),
+ Option<Result<UnchangedOr<Any>>>,
+ M,
+ Target = D,
+ Output = O,
+ >,
for<'s, 'v> &'s mut D:
Dispatcher<(AnyView<'v>, DefRegionKind),
Option<Result<UnchangedOr<Any>>>>,
{
diff --git a/rust/tvm-ffi/src/extra/structural_mutate.rs
b/rust/tvm-ffi/src/extra/structural_mutate.rs
index 3b3e4c18..5527531f 100644
--- a/rust/tvm-ffi/src/extra/structural_mutate.rs
+++ b/rust/tvm-ffi/src/extra/structural_mutate.rs
@@ -44,7 +44,7 @@
// Local Perf note comments explain individual implementation choices.
use std::cell::{RefCell, UnsafeCell};
-use std::collections::{HashMap, hash_map::Entry};
+use std::collections::{hash_map::Entry, HashMap};
use std::ffi::c_void;
use std::marker::PhantomData;
@@ -58,7 +58,7 @@ use std::rc::Rc;
pub use super::structural_map::*;
use super::dispatch::Dispatcher;
-use crate::any::{Any, AnyView, is_plain_inline};
+use crate::any::{is_plain_inline, Any, AnyView};
use crate::error::{Error, Result, TYPE_ERROR};
use crate::function::Function;
use crate::object::{self, Object, ObjectArc, ObjectCore};
@@ -79,7 +79,7 @@ use super::structural_common::{
with_structural_field_error_context, with_visit_error_context,
};
use super::structural_visit::{
- DefRegionKind, field_def_region, for_each_field_info,
free_var_child_region,
+ field_def_region, for_each_field_info, free_var_child_region,
DefRegionKind,
};
use super::unchanged::is_unchanged;
pub use super::unchanged::{Unchanged, UnchangedOr};
@@ -669,7 +669,7 @@ impl<T: object::ObjectRefCore> MutationView<'_, T> {
/// # Ok(second)
/// # }
/// # }
- /// # let pair = MyPairObj::new(Object::new(), Array::new(vec![1_i64]),
Array::new(vec![2_i64]));
+ /// # let pair = MyPairObj::new(Object::new(),
Array::from_vec(vec![1_i64]), Array::from_vec(vec![2_i64]));
/// # structural_mutate(MyPair::from(pair), Pass)?;
/// # Ok::<(), tvm_ffi::Error>(())
/// ```
@@ -931,16 +931,16 @@ impl<Base: StructuralMutatorBase>
StructuralMutateEngine<Base> {
R: Into<Any>,
O: BorrowMut<D>,
for<'v, 'c, 'r> H: IntoDispatcher<
- (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
- Option<Result<UnchangedOr<Any>>>,
- M,
- Target = D,
- Output = O,
- >,
+ (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
+ Option<Result<UnchangedOr<Any>>>,
+ M,
+ Target = D,
+ Output = O,
+ >,
for<'s, 'v, 'c, 'r> &'s mut D: crate::Dispatcher<
- (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
- Option<Result<UnchangedOr<Any>>>,
- >,
+ (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
+ Option<Result<UnchangedOr<Any>>>,
+ >,
{
let mut storage = dispatcher.into_dispatcher();
Self::run_mutator::<D, true>(root.into(), storage.borrow_mut())
@@ -1266,9 +1266,9 @@ impl<Base: StructuralMutatorBase>
StructuralMutateEngine<Base> {
fn vtable<D, const CALLBACK_CONTEXT: bool>() -> &'static
StructuralMutatorVTable
where
for<'s, 'v, 'c, 'r> &'s mut D: Dispatcher<
- (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
- Option<Result<UnchangedOr<Any>>>,
- >,
+ (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
+ Option<Result<UnchangedOr<Any>>>,
+ >,
{
&StructuralMutatorVTable {
mutate: Self::rust_vtable_mutate::<D, false, CALLBACK_CONTEXT>,
@@ -1291,9 +1291,9 @@ impl<Base: StructuralMutatorBase>
StructuralMutateEngine<Base> {
) -> TVMFFIAny
where
for<'s, 'v, 'c, 'r> &'s mut D: Dispatcher<
- (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
- Option<Result<UnchangedOr<Any>>>,
- >,
+ (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
+ Option<Result<UnchangedOr<Any>>>,
+ >,
{
let context = (*Self::from_handle(runtime)).dispatcher;
let raw = *value.as_raw_ffi_any();
@@ -1429,9 +1429,9 @@ impl<Base: StructuralMutatorBase>
StructuralMutateEngine<Base> {
) -> Result<Any>
where
for<'s, 'v, 'c, 'r> &'s mut D: Dispatcher<
- (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
- Option<Result<UnchangedOr<Any>>>,
- >,
+ (MutationView<'v>, &'c mut StructuralMutatorView<'r, D, Base>),
+ Option<Result<UnchangedOr<Any>>>,
+ >,
{
let mut base = Base::new()?;
let type_index = Base::type_index();
@@ -2054,7 +2054,7 @@ impl StructuralMutatorObj {
/// }
/// }
///
-/// let root = Array::new(vec![Array::new(vec![1_i64, 2]),
Array::new(vec![3_i64])]);
+/// let root = Array::from_vec(vec![Array::from_vec(vec![1_i64, 2]),
Array::from_vec(vec![3_i64])]);
/// let result = Array::<Array<i64>>::try_from(structural_mutate(root,
Double)?)?;
/// assert_eq!(result.get(0)?.iter().collect::<Vec<_>>(), vec![2, 4]);
/// # Ok::<(), tvm_ffi::Error>(())
@@ -2064,22 +2064,22 @@ where
R: Into<Any>,
O: BorrowMut<D>,
for<'v, 'c, 'r> H: IntoDispatcher<
- (
- MutationView<'v>,
- &'c mut StructuralMutatorView<'r, D, StructuralMutatorObj>,
- ),
- Option<Result<UnchangedOr<Any>>>,
- M,
- Target = D,
- Output = O,
- >,
+ (
+ MutationView<'v>,
+ &'c mut StructuralMutatorView<'r, D, StructuralMutatorObj>,
+ ),
+ Option<Result<UnchangedOr<Any>>>,
+ M,
+ Target = D,
+ Output = O,
+ >,
for<'s, 'v, 'c, 'r> &'s mut D: crate::Dispatcher<
- (
- MutationView<'v>,
- &'c mut StructuralMutatorView<'r, D, StructuralMutatorObj>,
- ),
- Option<Result<UnchangedOr<Any>>>,
- >,
+ (
+ MutationView<'v>,
+ &'c mut StructuralMutatorView<'r, D, StructuralMutatorObj>,
+ ),
+ Option<Result<UnchangedOr<Any>>>,
+ >,
{
StructuralMutateEngine::mutate_root(root, dispatcher)
}
diff --git a/rust/tvm-ffi/src/extra/structural_visit.rs
b/rust/tvm-ffi/src/extra/structural_visit.rs
index a1eed071..551873e5 100644
--- a/rust/tvm-ffi/src/extra/structural_visit.rs
+++ b/rust/tvm-ffi/src/extra/structural_visit.rs
@@ -487,16 +487,16 @@ impl<Base: StructuralVisitorBase>
StructuralVisitEngine<Base> {
R: Into<AnyView<'input>>,
O: BorrowMut<D>,
for<'v, 'c, 'r> H: IntoDispatcher<
- (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
- Option<Result<Option<VisitInterrupt>>>,
- M,
- Target = D,
- Output = O,
- >,
+ (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
+ Option<Result<Option<VisitInterrupt>>>,
+ M,
+ Target = D,
+ Output = O,
+ >,
for<'s, 'v, 'c, 'r> &'s mut D: crate::Dispatcher<
- (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
- Option<Result<Option<VisitInterrupt>>>,
- >,
+ (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
+ Option<Result<Option<VisitInterrupt>>>,
+ >,
{
let mut storage = dispatcher.into_dispatcher();
let root = root.into();
@@ -1061,9 +1061,9 @@ impl<Base: StructuralVisitorBase>
StructuralVisitEngine<Base> {
fn vtable<D>() -> &'static StructuralVisitorVTable
where
for<'s, 'v, 'c, 'r> &'s mut D: crate::Dispatcher<
- (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
- Option<Result<Option<VisitInterrupt>>>,
- >,
+ (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
+ Option<Result<Option<VisitInterrupt>>>,
+ >,
{
&StructuralVisitorVTable {
visit: Self::rust_vtable_visit_raw::<D>,
@@ -1083,9 +1083,9 @@ impl<Base: StructuralVisitorBase>
StructuralVisitEngine<Base> {
) -> TVMFFIAny
where
for<'s, 'v, 'c, 'r> &'s mut D: crate::Dispatcher<
- (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
- Option<Result<Option<VisitInterrupt>>>,
- >,
+ (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
+ Option<Result<Option<VisitInterrupt>>>,
+ >,
{
let context = (*Self::from_handle(runtime)).dispatcher;
let raw = *value.as_raw_ffi_any();
@@ -1154,9 +1154,9 @@ impl<Base: StructuralVisitorBase>
StructuralVisitEngine<Base> {
pub(super) fn run_visitor_raw<D>(root: TVMFFIAny, dispatch: &mut D) ->
TVMFFIAny
where
for<'s, 'v, 'c, 'r> &'s mut D: crate::Dispatcher<
- (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
- Option<Result<Option<VisitInterrupt>>>,
- >,
+ (AnyView<'v>, &'c mut StructuralVisitorView<'r, D, Base>),
+ Option<Result<Option<VisitInterrupt>>>,
+ >,
{
let base = match Base::new() {
Ok(base) => base,
@@ -1235,7 +1235,7 @@ impl<Base: StructuralVisitorBase>
StructuralVisitEngine<Base> {
/// }
/// }
///
-/// let root = Array::new(vec![1_i64, 2, 3]);
+/// let root = Array::from_vec(vec![1_i64, 2, 3]);
/// let mut sum = Sum(0);
/// assert!(structural_visit(&root, &mut sum)?.is_none());
/// assert_eq!(sum.0, 6);
@@ -1250,22 +1250,22 @@ where
R: Into<AnyView<'input>>,
O: BorrowMut<D>,
for<'v, 'c, 'r> H: IntoDispatcher<
- (
- AnyView<'v>,
- &'c mut StructuralVisitorView<'r, D, StructuralVisitorObj>,
- ),
- Option<Result<Option<VisitInterrupt>>>,
- M,
- Target = D,
- Output = O,
- >,
+ (
+ AnyView<'v>,
+ &'c mut StructuralVisitorView<'r, D, StructuralVisitorObj>,
+ ),
+ Option<Result<Option<VisitInterrupt>>>,
+ M,
+ Target = D,
+ Output = O,
+ >,
for<'s, 'v, 'c, 'r> &'s mut D: crate::Dispatcher<
- (
- AnyView<'v>,
- &'c mut StructuralVisitorView<'r, D, StructuralVisitorObj>,
- ),
- Option<Result<Option<VisitInterrupt>>>,
- >,
+ (
+ AnyView<'v>,
+ &'c mut StructuralVisitorView<'r, D, StructuralVisitorObj>,
+ ),
+ Option<Result<Option<VisitInterrupt>>>,
+ >,
{
StructuralVisitEngine::visit_root(root, dispatcher)
}
diff --git a/rust/tvm-ffi/src/extra/structural_walk.rs
b/rust/tvm-ffi/src/extra/structural_walk.rs
index 432bd70b..acbbf2ea 100644
--- a/rust/tvm-ffi/src/extra/structural_walk.rs
+++ b/rust/tvm-ffi/src/extra/structural_walk.rs
@@ -23,8 +23,8 @@
//! the non-unwinding native callback boundary aborts the process.
use super::structural_visit::{
- DefRegionKind, StructuralVisitEngine, StructuralVisitorView,
VisitInterrupt,
- visit_result_from_any,
+ visit_result_from_any, DefRegionKind, StructuralVisitEngine,
StructuralVisitorView,
+ VisitInterrupt,
};
use crate::{Any, AnyView, Dispatcher, IntoDispatcher, Result};
use std::borrow::BorrowMut;
@@ -245,7 +245,7 @@ where
/// ```
/// use tvm_ffi::{structural_walk, Array, WalkOrder, WalkResult};
///
-/// let root = Array::new(vec![1_i64, 2, 3]);
+/// let root = Array::from_vec(vec![1_i64, 2, 3]);
/// let mut integers = Vec::new();
/// structural_walk(&root, |value: i64| {
/// integers.push(value);
@@ -261,12 +261,12 @@ pub fn structural_walk<'input, R, M, H, D, O>(
) -> Result<Option<VisitInterrupt>>
where
for<'v> H: IntoDispatcher<
- (AnyView<'v>, DefRegionKind),
- Option<Result<WalkResult>>,
- M,
- Target = D,
- Output = O,
- >,
+ (AnyView<'v>, DefRegionKind),
+ Option<Result<WalkResult>>,
+ M,
+ Target = D,
+ Output = O,
+ >,
for<'s, 'v> &'s mut D: Dispatcher<(AnyView<'v>, DefRegionKind),
Option<Result<WalkResult>>>,
R: Into<AnyView<'input>>,
O: BorrowMut<D>,
diff --git a/rust/tvm-ffi/src/extra/unchanged.rs
b/rust/tvm-ffi/src/extra/unchanged.rs
index 94260680..4ee304e4 100644
--- a/rust/tvm-ffi/src/extra/unchanged.rs
+++ b/rust/tvm-ffi/src/extra/unchanged.rs
@@ -54,8 +54,8 @@ pub struct Unchanged;
/// one FFI value. `UnchangedOr<Any>` converts with `.into()` from
/// [`Unchanged`], from a managed reference or scalar, and from a typed
/// `UnchangedOr<T>`. `T` is an FFI value type or [`Any`]. Converting the
-/// wrapper into `Any` keeps the marker; use [`value_or`](Self::value_or) or
-/// [`value_or_else`](Self::value_or_else) when an actual value is needed.
+/// wrapper into `Any` keeps the marker; use
[`value_or_unchanged`](Self::value_or_unchanged) or
+/// [`into_option`](Self::into_option) when an actual value is needed.
///
/// # Examples
///
@@ -70,8 +70,8 @@ pub struct Unchanged;
/// }
/// }
///
-/// assert_eq!(double_even(4).value_or(4), 8);
-/// assert_eq!(double_even(3).value_or(3), 3);
+/// assert_eq!(double_even(4).value_or_unchanged(4), 8);
+/// assert_eq!(double_even(3).value_or_unchanged(3), 3);
/// ```
#[repr(transparent)]
pub struct UnchangedOr<T: ContainerElement = Any> {
@@ -141,7 +141,7 @@ impl<T: ContainerElement> UnchangedOr<T> {
///
/// ```
/// use tvm_ffi::{Array, UnchangedOr};
- /// let original = Array::new(vec![1_i64]);
+ /// let original = Array::from_vec(vec![1_i64]);
///
assert!(UnchangedOr::changed(original.clone()).unchanged_or_same_as(&original));
/// ```
///
@@ -178,34 +178,19 @@ impl<T: ContainerElement> UnchangedOr<T> {
/// Move out the replacement, or `original` when the result is unchanged.
///
- /// `original` is taken even when it is not returned; use
- /// [`value_or_else`](Self::value_or_else) to produce it only when needed.
+ /// `original` is the value the callback was given; to produce it only when
+ /// needed, use `into_option().unwrap_or_else(..)`.
///
/// # Arguments
///
- /// * `original` - The original value.
+ /// * `original` - The original value, kept when the result is unchanged.
///
/// # Returns
///
/// The replacement, or `original`.
#[inline]
- pub fn value_or(self, original: T) -> T {
- self.value_or_else(|| original)
- }
-
- /// Move out the replacement, or materialize the original only if this
result is
- /// unchanged.
- ///
- /// # Arguments
- ///
- /// * `original` - Produces the original value; called only when unchanged.
- ///
- /// # Returns
- ///
- /// The replacement, or the result of `original`.
- #[inline]
- pub fn value_or_else(self, original: impl FnOnce() -> T) -> T {
- self.into_option().unwrap_or_else(original)
+ pub fn value_or_unchanged(self, original: T) -> T {
+ self.into_option().unwrap_or(original)
}
/// Convert only the replacement, preserving an unchanged result.
diff --git a/rust/tvm-ffi/src/lib.rs b/rust/tvm-ffi/src/lib.rs
index a8d3544f..8394fe52 100644
--- a/rust/tvm-ffi/src/lib.rs
+++ b/rust/tvm-ffi/src/lib.rs
@@ -50,23 +50,23 @@ pub use crate::collections::shape::Shape;
pub use crate::collections::tensor::{CPUNDAlloc, NDAllocator, Tensor,
TensorView};
pub use crate::device::{current_stream, with_stream};
pub use crate::dtype::DLDataTypeExt;
+pub use crate::error::{Error, ErrorKind, Result};
pub use crate::error::{
ATTRIBUTE_ERROR, INDEX_ERROR, INTERNAL_ERROR, KEY_ERROR, OVERFLOW_ERROR,
RUNTIME_ERROR,
TYPE_ERROR, VALUE_ERROR, ZERO_DIVISION_ERROR,
};
-pub use crate::error::{Error, ErrorKind, Result};
pub use crate::extra::dispatch::{Dispatcher, IntoDispatcher};
pub use crate::extra::module::Module;
pub use crate::extra::structural_map::structural_map;
pub use crate::extra::structural_mutate::{
- InplaceMode, MutationView, StructuralMutateEngine, StructuralMutatorBase,
StructuralMutatorObj,
- StructuralMutatorView, StructuralVarRemap, structural_mutate,
+ structural_mutate, InplaceMode, MutationView, StructuralMutateEngine,
StructuralMutatorBase,
+ StructuralMutatorObj, StructuralMutatorView, StructuralVarRemap,
};
pub use crate::extra::structural_visit::{
- DefRegionKind, StructuralVisitEngine, StructuralVisitorBase,
StructuralVisitorObj,
- StructuralVisitorView, VisitInterrupt, VisitInterruptObj, structural_visit,
+ structural_visit, DefRegionKind, StructuralVisitEngine,
StructuralVisitorBase,
+ StructuralVisitorObj, StructuralVisitorView, VisitInterrupt,
VisitInterruptObj,
};
-pub use crate::extra::structural_walk::{IntoWalkResult, WalkOrder, WalkResult,
structural_walk};
+pub use crate::extra::structural_walk::{structural_walk, IntoWalkResult,
WalkOrder, WalkResult};
pub use crate::extra::unchanged::{Unchanged, UnchangedOr};
pub use crate::function::Function;
pub use crate::object::ObjectRefCast;
@@ -75,8 +75,8 @@ pub use crate::object::{
};
pub use crate::optional::{Optional, OptionalCompatible};
pub use crate::reflection::{
- FieldFlags, FieldGetter, ObjectDef, SEqHashKind, ShallowCopy,
TypeAttrColumn, UnsafeInit,
- get_type_attr,
+ get_type_attr, FieldFlags, FieldGetter, ObjectDef, SEqHashKind,
ShallowCopy, TypeAttrColumn,
+ UnsafeInit,
};
pub use crate::rvalue_ref::RValueRef;
pub use crate::static_init::run_static_init_blocks;
@@ -190,7 +190,7 @@ pub use tvm_ffi_macros::dispatch;
/// }
///
/// assert_eq!(kind(&Any::from(42_i64)), "integer 42");
-/// assert_eq!(kind(&Any::from(Array::new(vec![1_i64, 2, 3]))), "array of 3
items");
+/// assert_eq!(kind(&Any::from(Array::from_vec(vec![1_i64, 2, 3]))), "array of
3 items");
/// assert_eq!(kind(&Any::from(1.5_f64)), "something else");
/// ```
pub use tvm_ffi_macros::match_any;
diff --git a/rust/tvm-ffi/src/macros.rs b/rust/tvm-ffi/src/macros.rs
index 36bbe615..0c5d2ef6 100644
--- a/rust/tvm-ffi/src/macros.rs
+++ b/rust/tvm-ffi/src/macros.rs
@@ -252,7 +252,9 @@ macro_rules! attach_context {
line!(),
$crate::function_name!()
);
- Err($crate::error::Error::with_appended_backtrace(error,
&context))
+ Err($crate::error::Error::with_appended_backtrace(
+ error, &context,
+ ))
}
}
}};
diff --git a/rust/tvm-ffi/src/object.rs b/rust/tvm-ffi/src/object.rs
index 73086ed4..189275ab 100644
--- a/rust/tvm-ffi/src/object.rs
+++ b/rust/tvm-ffi/src/object.rs
@@ -303,7 +303,7 @@ pub trait ObjectRefCast: ObjectRefCore + AnyCompatible {
///
/// ```
/// use tvm_ffi::{object::ObjectRef, Array, ObjectRefCast};
- /// let object: ObjectRef = Array::new(vec![1_i64]).try_cast()?;
+ /// let object: ObjectRef = Array::from_vec(vec![1_i64]).try_cast()?;
/// let array: Array<i64> = object.try_cast()?;
/// assert_eq!(array.len(), 1);
/// # Ok::<(), tvm_ffi::Error>(())
diff --git a/rust/tvm-ffi/src/optional.rs b/rust/tvm-ffi/src/optional.rs
index 111eaace..41ff757f 100644
--- a/rust/tvm-ffi/src/optional.rs
+++ b/rust/tvm-ffi/src/optional.rs
@@ -130,14 +130,14 @@ impl<T: OptionalCompatible> Optional<T> {
/// Whether a value is present.
#[inline]
- pub fn has_value(&self) -> bool {
+ pub fn is_some(&self) -> bool {
self.data.type_index() != TypeIndex::kTVMFFINone as i32
}
/// Whether the optional is `nullopt`.
#[inline]
pub fn is_none(&self) -> bool {
- !self.has_value()
+ !self.is_some()
}
/// Decodes the value in place, cloning it out (ref-counted `inc_ref` for
@@ -150,7 +150,7 @@ impl<T: OptionalCompatible> Optional<T> {
/// Takes the value out, consuming self (moves the payload, no `inc_ref`).
#[inline]
pub fn into_option(self) -> Option<T> {
- if self.has_value() {
+ if self.is_some() {
// Move the value out of the owning `Any` without dropping it, then
// transfer ownership of the payload into `T` (no inc/dec ref).
let mut raw = unsafe { Any::into_raw_ffi_any(self.data) };
@@ -180,7 +180,7 @@ impl Optional<String> {
/// `&String`.
#[inline]
pub fn as_str(&self) -> Option<&str> {
- if self.has_value() {
+ if self.is_some() {
// SAFETY: an engaged `Optional<String>` cell is byte-identical to
a
// `String` (both are `#[repr(transparent)]` over the 16-byte
cell),
// and the borrow is tied to `&self`.
diff --git a/rust/tvm-ffi/src/reflection/unsafe_init.rs
b/rust/tvm-ffi/src/reflection/unsafe_init.rs
index 4a16ee19..10a04f6b 100644
--- a/rust/tvm-ffi/src/reflection/unsafe_init.rs
+++ b/rust/tvm-ffi/src/reflection/unsafe_init.rs
@@ -202,7 +202,7 @@ mod tests {
device_type: DLDeviceType::kDLCPU,
device_id: 0,
};
- assert!(!is_undefined(Array::<i64>::new(vec![])));
+ assert!(!is_undefined(Array::<i64>::new()));
assert!(!is_undefined(String::from("")));
assert!(!is_undefined(BigInt::from(0_i64)));
assert!(!is_undefined(cpu));
diff --git a/rust/tvm-ffi/src/type_traits.rs b/rust/tvm-ffi/src/type_traits.rs
index 7f6bef87..0d41244f 100644
--- a/rust/tvm-ffi/src/type_traits.rs
+++ b/rust/tvm-ffi/src/type_traits.rs
@@ -218,6 +218,61 @@ pub trait ContainerElement: container_element_ops::Ops {}
impl<T: AnyCompatible> ContainerElement for T {}
impl ContainerElement for Any {}
+/// Types whose value an FFI `Any` cell stores in place, so `&Self` can be
+/// borrowed from the cell, as [`crate::Array`] indexing does.
+///
+/// # Safety
+///
+/// For a cell that passes `container_check_any_strict` for `Self`,
+/// `ref_from_any` must return a reference into that cell that is a valid
+/// `Self` for as long as the cell is borrowed.
+#[doc(hidden)]
+pub unsafe trait RefFromAny: ContainerElement {
+ /// Borrow the value stored in `cell`.
+ ///
+ /// # Safety
+ ///
+ /// `cell` must hold a `Self`.
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self;
+}
+
+// The whole cell is the value.
+unsafe impl RefFromAny for Any {
+ #[inline(always)]
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self {
+ &*(cell as *const TVMFFIAny as *const Any)
+ }
+}
+
+unsafe impl RefFromAny for crate::String {
+ #[inline(always)]
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self {
+ &*(cell as *const TVMFFIAny as *const crate::String)
+ }
+}
+
+unsafe impl RefFromAny for crate::string::Bytes {
+ #[inline(always)]
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self {
+ &*(cell as *const TVMFFIAny as *const crate::string::Bytes)
+ }
+}
+
+// The payload word holds the value in its own representation.
+unsafe impl RefFromAny for i64 {
+ #[inline(always)]
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self {
+ &cell.data_union.v_int64
+ }
+}
+
+unsafe impl RefFromAny for f64 {
+ #[inline(always)]
+ unsafe fn ref_from_any(cell: &TVMFFIAny) -> &Self {
+ &cell.data_union.v_float64
+ }
+}
+
mod container_element_ops {
use super::{Any, AnyCompatible, AnyView, TVMFFIAny};
diff --git a/rust/tvm-ffi/tests/test_array.rs b/rust/tvm-ffi/tests/test_array.rs
index a76e8f13..d99e4339 100644
--- a/rust/tvm-ffi/tests/test_array.rs
+++ b/rust/tvm-ffi/tests/test_array.rs
@@ -41,16 +41,16 @@ fn test_array_core_and_iteration() {
let t1 = create_tensor(10.0, &[1, 2]);
let t2 = create_tensor(20.0, &[3, 4, 5]);
- let array = Array::new(vec![t1.clone(), t2.clone()]);
+ let array = Array::from_vec(vec![t1.clone(), t2.clone()]);
// Core Accessors
assert_eq!(array.len(), 2);
assert!(!array.is_empty());
// Value Integrity
- assert_eq!(get_val(&Tensor::try_from(array[0]).unwrap()), 10.0);
- assert_eq!(Tensor::try_from(array[0]).unwrap().ndim(), 2);
- assert_eq!(Tensor::try_from(array[1]).unwrap().ndim(), 3);
+ assert_eq!(get_val(&array[0]), 10.0);
+ assert_eq!(array[0].ndim(), 2);
+ assert_eq!(array[1].ndim(), 3);
// Iteration
let vals: Vec<f32> = array.iter().map(|t| get_val(&t)).collect();
@@ -59,7 +59,7 @@ fn test_array_core_and_iteration() {
#[test]
fn test_array_any_conversions() {
- let array = Array::new(vec![
+ let array = Array::from_vec(vec![
create_tensor(1.0, &[1]),
create_tensor(2.0, &[1]),
create_tensor(3.0, &[1]),
@@ -80,10 +80,10 @@ fn test_array_any_conversions() {
#[test]
fn test_array_with_any_elements() {
- let array = Array::new(vec![
+ let array = Array::from_vec(vec![
Any::from(7i64),
Any::from(String::from("value")),
- Any::from(Array::new(vec![1i64, 2])),
+ Any::from(Array::from_vec(vec![1i64, 2])),
]);
assert_eq!(i64::try_from(array.get(0).unwrap()).unwrap(), 7);
@@ -107,7 +107,7 @@ fn test_array_with_any_elements() {
let by_reference =
i64::try_from(array_size.call_tuple((&round_trip,)).unwrap()).unwrap();
assert_eq!((by_value, by_reference), (3, 3));
- let widened = Array::<Any>::try_from(Any::from(Array::new(vec![3i64,
4]))).unwrap();
+ let widened = Array::<Any>::try_from(Any::from(Array::from_vec(vec![3i64,
4]))).unwrap();
assert_eq!(
widened
.iter()
@@ -120,7 +120,7 @@ fn test_array_with_any_elements() {
#[test]
fn test_array_recursive_type_checking() {
// 1. Create an Array of Shapes
- let shape_array = Array::new(vec![Shape::from(vec![1, 2]),
Shape::from(vec![3])]);
+ let shape_array = Array::from_vec(vec![Shape::from(vec![1, 2]),
Shape::from(vec![3])]);
// 2. Wrap it in Any
let any_val = Any::from(shape_array);
@@ -144,11 +144,11 @@ fn test_array_recursive_type_checking() {
#[test]
fn test_array_parametric_heterogeneity() {
// Verify Array works with different ObjectRefCore types
- let shape_array = Array::new(vec![Shape::from(vec![1, 2, 3]),
Shape::from(vec![10])]);
+ let shape_array = Array::from_vec(vec![Shape::from(vec![1, 2, 3]),
Shape::from(vec![10])]);
assert_eq!(shape_array.get(0).unwrap().as_slice(), &[1, 2, 3]);
assert_eq!(shape_array.get(1).unwrap().as_slice(), &[10]);
- let function_array = Array::new(vec![
+ let function_array = Array::from_vec(vec![
Function::get_global("ffi.String").unwrap(),
Function::get_global("ffi.Bytes").unwrap(),
]);
diff --git a/rust/tvm-ffi/tests/test_big_int.rs
b/rust/tvm-ffi/tests/test_big_int.rs
index fcca28bf..3aa12994 100644
--- a/rust/tvm-ffi/tests/test_big_int.rs
+++ b/rust/tvm-ffi/tests/test_big_int.rs
@@ -457,7 +457,7 @@ fn test_big_int_function_round_trip() {
#[test]
fn test_big_int_containers() {
let values = vec![wide(), BigInt::from(-1i64), BigInt::from(u64::MAX)];
- let array = Array::new(values.clone());
+ let array = Array::from_vec(values.clone());
assert_eq!(array.len(), 3);
for (i, value) in values.iter().enumerate() {
assert_eq!(array.get(i).unwrap(), *value);
@@ -475,7 +475,7 @@ fn test_big_int_containers() {
.collect();
assert_eq!(map.len(), 3);
for (i, value) in values.iter().enumerate() {
- assert!(map.contains_key(value));
+ assert!(map.contains_key(value).unwrap());
assert_eq!(map.get(value).unwrap(), Some(i as i64));
}
assert_eq!(map.get(&BigInt::from(1u128 << 64)).unwrap(), None);
@@ -485,7 +485,7 @@ fn test_big_int_containers() {
fn test_big_int_optional() {
assert_eq!(std::mem::size_of::<Optional<BigInt>>(), 16);
let some = Optional::some(wide());
- assert!(some.has_value());
+ assert!(some.is_some());
assert_eq!(some.get(), Some(wide()));
let none = Optional::<BigInt>::none();
assert!(none.is_none());
@@ -505,7 +505,7 @@ fn test_big_int_optional() {
#[test]
fn test_big_int_structural_traversal() {
- let root = Array::new(vec![Any::from(1i64), Any::from(wide())]);
+ let root = Array::from_vec(vec![Any::from(1i64), Any::from(wide())]);
let wide_pointer = root
.get(1)
.unwrap()
diff --git a/rust/tvm-ffi/tests/test_cast.rs b/rust/tvm-ffi/tests/test_cast.rs
index 7717e07e..b53b57b1 100644
--- a/rust/tvm-ffi/tests/test_cast.rs
+++ b/rust/tvm-ffi/tests/test_cast.rs
@@ -202,7 +202,7 @@ fn test_generated_borrow_and_upcast_conversions() {
#[test]
fn test_cast_checks_parameterized_container_type() {
- assert!(Array::new(vec![1_i64, 2_i64])
+ assert!(Array::from_vec(vec![1_i64, 2_i64])
.try_cast::<Array<f32>>()
.is_err());
}
diff --git a/rust/tvm-ffi/tests/test_error.rs b/rust/tvm-ffi/tests/test_error.rs
index 1413340d..1ce3054a 100644
--- a/rust/tvm-ffi/tests/test_error.rs
+++ b/rust/tvm-ffi/tests/test_error.rs
@@ -60,7 +60,7 @@ fn test_error_with_context() {
let result = error_fn1(false).unwrap();
assert_eq!(result, 1);
- let payload =
object::ObjectRef::try_from(Any::from(Array::new(vec![7i64]))).unwrap();
+ let payload =
object::ObjectRef::try_from(Any::from(Array::from_vec(vec![7i64]))).unwrap();
for shared in [false, true] {
let error = Error::new_with_cause_and_extra_context(
RUNTIME_ERROR,
diff --git a/rust/tvm-ffi/tests/test_function.rs
b/rust/tvm-ffi/tests/test_function.rs
index 42e0dfab..c0baff4d 100644
--- a/rust/tvm-ffi/tests/test_function.rs
+++ b/rust/tvm-ffi/tests/test_function.rs
@@ -129,12 +129,12 @@ fn test_function_rvalue_ref_arguments() {
Ok(AnyView::from(&value).debug_strong_count().unwrap() as i64)
});
- let moved = Array::new(vec![1i64, 2]);
+ let moved = Array::from_vec(vec![1i64, 2]);
assert_eq!(AnyView::from(&moved).debug_strong_count(), Some(1));
let count =
i64::try_from(strong_count.call_tuple((RValueRef::new(moved),)).unwrap()).unwrap();
assert_eq!(count, 1);
- let borrowed = Array::new(vec![3i64, 4]);
+ let borrowed = Array::from_vec(vec![3i64, 4]);
assert_eq!(AnyView::from(&borrowed).debug_strong_count(), Some(1));
let count =
i64::try_from(strong_count.call_tuple((&borrowed,)).unwrap()).unwrap();
assert_eq!(count, 2);
diff --git a/rust/tvm-ffi/tests/test_list.rs b/rust/tvm-ffi/tests/test_list.rs
index b6b2765c..830c1b9c 100644
--- a/rust/tvm-ffi/tests/test_list.rs
+++ b/rust/tvm-ffi/tests/test_list.rs
@@ -122,7 +122,7 @@ fn test_list_growth_stays_with_runtime() {
#[test]
fn test_list_releases_elements() {
- let array = Array::new(vec![1i64]);
+ let array = Array::from_vec(vec![1i64]);
let probe = Any::from(array.clone());
let base = probe.debug_strong_count().unwrap();
@@ -132,7 +132,7 @@ fn test_list_releases_elements() {
list.insert(0, array.clone()).unwrap();
assert_eq!(probe.debug_strong_count().unwrap(), base + 3);
- list.set(0, Array::new(vec![2i64])).unwrap();
+ list.set(0, Array::from_vec(vec![2i64])).unwrap();
assert_eq!(probe.debug_strong_count().unwrap(), base + 2);
drop(list.remove(1).unwrap());
assert_eq!(probe.debug_strong_count().unwrap(), base + 1);
@@ -357,7 +357,7 @@ fn test_list_of_any_and_objects() {
let list: List<Any> = List::new();
list.push(Any::from(1i64)).unwrap();
list.push(Any::from(String::from("two"))).unwrap();
- list.push(Any::from(Array::new(vec![3i64]))).unwrap();
+ list.push(Any::from(Array::from_vec(vec![3i64]))).unwrap();
assert_eq!(list.len(), 3);
assert_eq!(i64::try_from(list.get(0).unwrap()).unwrap(), 1);
let nested: Array<i64> = list.get(2).unwrap().try_into().unwrap();
@@ -409,7 +409,7 @@ fn test_list_mismatched_element_is_reported() {
#[test]
fn test_list_conversion_copies() {
// An `ffi.Array` converts into a new list.
- let array = Array::new(vec![1i64, 2]);
+ let array = Array::from_vec(vec![1i64, 2]);
let list: List<i64> = Any::from(array.clone()).try_into().unwrap();
list.push(3).unwrap();
assert_eq!(list.len(), 3);
diff --git a/rust/tvm-ffi/tests/test_map.rs b/rust/tvm-ffi/tests/test_map.rs
index d163e00b..bc78b742 100644
--- a/rust/tvm-ffi/tests/test_map.rs
+++ b/rust/tvm-ffi/tests/test_map.rs
@@ -48,8 +48,8 @@ fn test_map_basic_lookup() {
assert_eq!(map.get(&3).unwrap(), Some(30));
assert_eq!(map.get(&99).unwrap(), None);
- assert!(map.contains_key(&1));
- assert!(!map.contains_key(&99));
+ assert!(map.contains_key(&1).unwrap());
+ assert!(!map.contains_key(&99).unwrap());
}
#[test]
@@ -110,7 +110,7 @@ fn test_map_string_keys() {
assert_eq!(map.get(&String::from("a")).unwrap(), Some(1));
assert_eq!(map.get(&String::from("c")).unwrap(), Some(3));
assert_eq!(map.get(&String::from("z")).unwrap(), None);
- assert!(map.contains_key(&String::from("b")));
+ assert!(map.contains_key(&String::from("b")).unwrap());
}
#[test]
@@ -131,7 +131,7 @@ fn test_map_with_any_values() {
let empty = Map::<String, Any>::default();
assert!(empty.is_empty());
- let array = Array::new(vec![1i64, 2, 3]);
+ let array = Array::from_vec(vec![1i64, 2, 3]);
let array_base_count = AnyView::from(&array).debug_strong_count().unwrap();
let map: Map<String, Any> = [
(String::from("number"), Any::from(7i64)),
@@ -142,8 +142,8 @@ fn test_map_with_any_values() {
.collect();
assert_eq!(map.len(), 3);
- assert!(map.contains_key(&String::from("number")));
- assert!(!map.contains_key(&String::from("missing")));
+ assert!(map.contains_key(&String::from("number")).unwrap());
+ assert!(!map.contains_key(&String::from("missing")).unwrap());
assert_eq!(format!("{map:?}"), "Map<String, Any>[3]");
assert_eq!(AnyView::from(&array).debug_strong_count().unwrap(), 2);
assert_eq!(
diff --git a/rust/tvm-ffi/tests/test_match_any.rs
b/rust/tvm-ffi/tests/test_match_any.rs
index 438accee..db9f3bc3 100644
--- a/rust/tvm-ffi/tests/test_match_any.rs
+++ b/rust/tvm-ffi/tests/test_match_any.rs
@@ -66,7 +66,7 @@ fn matches_concrete_object_containers_in_source_order() {
use tvm_ffi::collections::array::ArrayObj;
use tvm_ffi::{ObjectArc, ObjectRefCore};
- let source = Array::new(vec![1_i64, 2, 3]);
+ let source = Array::from_vec(vec![1_i64, 2, 3]);
let count = || ObjectArc::strong_count(<Array<i64> as
ObjectRefCore>::data(&source));
let size = match_any! {
&source {
@@ -336,16 +336,16 @@ fn
parameterized_containers_use_complete_conversion_semantics() {
assert_eq!(selected, "float array");
use tvm_ffi::{List, MutationView};
- let values = Array::new(vec![257_i64]);
+ let values = Array::from_vec(vec![257_i64]);
assert_eq!(
match_any!(&values { Array<u8>(_) => 0, Array<i64>(_) => 1, _ => 2 }),
1
);
- assert!(!match_any!(Array::new(vec![true]) { Array<i64>(_) => true, _ =>
false }));
+ assert!(!match_any!(Array::from_vec(vec![true]) { Array<i64>(_) => true, _
=> false }));
assert!(!match_any!(&values { List<i64>(_) => true, _ => false }));
let list = [257_i64].into_iter().collect::<List<i64>>();
assert!(!match_any!(&list { Array<i64>(_) => true, List<u8>(_) => true, _
=> false }));
- let nested = Array::new(vec![Array::new(vec![Some(257_i64)])]);
+ let nested = Array::from_vec(vec![Array::from_vec(vec![Some(257_i64)])]);
assert_eq!(
match_any!(&nested {
Array<Array<Option<u8>>>(_) => 0,
diff --git a/rust/tvm-ffi/tests/test_object.rs
b/rust/tvm-ffi/tests/test_object.rs
index cc95d975..2a87493a 100644
--- a/rust/tvm-ffi/tests/test_object.rs
+++ b/rust/tvm-ffi/tests/test_object.rs
@@ -280,9 +280,9 @@ fn test_object_arc_option_size() {
fn test_object_reference_identity() {
fn assert_hash<T: Hash>(_value: &T) {}
- let first = Array::new(vec![1i64]);
+ let first = Array::from_vec(vec![1i64]);
let alias = first.clone();
- let second = Array::new(vec![1i64]);
+ let second = Array::from_vec(vec![1i64]);
assert!(first.same_as(&alias));
assert!(!first.same_as(&second));
diff --git a/rust/tvm-ffi/tests/test_object_reflection.rs
b/rust/tvm-ffi/tests/test_object_reflection.rs
index b431d5b7..34612517 100644
--- a/rust/tvm-ffi/tests/test_object_reflection.rs
+++ b/rust/tvm-ffi/tests/test_object_reflection.rs
@@ -122,7 +122,7 @@ fn point3(x: i64, z: i64) -> Point3 {
data: ObjectArc::new(Point3Obj {
base: point_obj(x, 0.5, "p3"),
z,
- tags: Array::new(vec!["a".into(), "b".into()]),
+ tags: Array::from_vec(vec!["a".into(), "b".into()]),
r#type: Some(point(1, 2.0, "inner")),
}),
}
diff --git a/rust/tvm-ffi/tests/test_optional.rs
b/rust/tvm-ffi/tests/test_optional.rs
index d69e7d4e..51dbc0a7 100644
--- a/rust/tvm-ffi/tests/test_optional.rs
+++ b/rust/tvm-ffi/tests/test_optional.rs
@@ -56,7 +56,7 @@ fn object_option_uses_nullable_pointer_layout() {
);
let none: Option<Array<i64>> = None;
assert!(none.is_none());
- let some = Some(Array::new(vec![1i64, 2, 3]));
+ let some = Some(Array::from_vec(vec![1i64, 2, 3]));
assert_eq!(some.as_ref().expect("engaged").len(), 3);
}
@@ -91,7 +91,7 @@ fn pod_roundtrip_all_supported_types() {
fn check<T: OptionalCompatible + PartialEq + Copy + std::fmt::Debug>(val:
T) {
let ty = std::any::type_name::<T>();
let some = Optional::<T>::some(val);
- assert!(some.has_value(), "engaged has_value for {ty}");
+ assert!(some.is_some(), "engaged is_some for {ty}");
assert_eq!(some.get(), Some(val), "engaged roundtrip for {ty}");
let none = Optional::<T>::none();
@@ -115,7 +115,7 @@ fn pod_roundtrip_all_supported_types() {
fn roundtrip_get_set() {
let mut o = Optional::<i32>::some(42);
assert_eq!(o.get(), Some(42));
- assert!(o.has_value());
+ assert!(o.is_some());
o.set(None);
assert_eq!(o.get(), None);
@@ -182,7 +182,7 @@ fn string_byte_image_matches_ffi_any() {
fn string_roundtrip_and_as_str() {
// small (inline) string
let s = Optional::<String>::some(String::from("hi"));
- assert!(s.has_value());
+ assert!(s.is_some());
assert_eq!(s.as_str(), Some("hi"));
assert_eq!(s.get().as_deref(), Some("hi"));
diff --git a/rust/tvm-ffi/tests/test_rs_object.rs
b/rust/tvm-ffi/tests/test_rs_object.rs
index 4f2e5775..b8c50ef2 100644
--- a/rust/tvm-ffi/tests/test_rs_object.rs
+++ b/rust/tvm-ffi/tests/test_rs_object.rs
@@ -206,7 +206,7 @@ fn point(x: i64, label: &str) -> RsPoint {
}
fn point3(x: i64, z: i64) -> RsPoint3 {
- let tags = Array::new(vec!["a".into(), "b".into()]);
+ let tags = Array::from_vec(vec!["a".into(), "b".into()]);
RsPoint3Obj::new(RsPointObj::new(Object::new(), x, "p3"), z, tags,
7).into()
}
@@ -484,7 +484,7 @@ fn test_init_constructs_the_type_from_its_fields() {
// The fields of the parent come first, as for a C++ type.
let init = type_attr_function(RsPoint3Obj::type_index(), "__ffi_init__");
let label = || tvm_ffi::String::from("l");
- let tags = Array::<tvm_ffi::String>::new(vec!["a".into()]);
+ let tags = Array::<tvm_ffi::String>::from_vec(vec!["a".into()]);
let p3 = init
.call_tuple((1_i64, label(), 2_i64, tags.clone(), 3_i64))
.unwrap();
diff --git a/rust/tvm-ffi/tests/test_structural_mutate.rs
b/rust/tvm-ffi/tests/test_structural_mutate.rs
index 503fe295..22ab5ad4 100644
--- a/rust/tvm-ffi/tests/test_structural_mutate.rs
+++ b/rust/tvm-ffi/tests/test_structural_mutate.rs
@@ -103,7 +103,7 @@ impl<'s, 'v, 'c, 'r>
let result =
mutator.mutate(self,
MutationView::borrowed(AnyView::from(&key)))?;
assert_eq!(
- RemapNode::try_from(result.value_or_else(||
key.clone()))?
+
RemapNode::try_from(result.into_option().unwrap_or_else(|| key.clone()))?
.data
.value,
8
@@ -152,11 +152,11 @@ impl RecursiveEntryMutator {
) -> Result<UnchangedOr<Any>> {
if value.as_any_view().type_index() == TypeIndex::kTVMFFINone as i32 {
if self.use_owned_value {
- let value = Array::new(vec![1i64]);
+ let value = Array::from_vec(vec![1i64]);
self.owned_value_pointer = Some(array_pointer(&value) as
usize);
let mut owner: Any = value.into();
let change = mutator.mutate(self, &mut owner)?;
- Ok(UnchangedOr::changed(change.value_or(owner)))
+ Ok(UnchangedOr::changed(change.value_or_unchanged(owner)))
} else {
mutator.mutate(self,
MutationView::borrowed(AnyView::from(&1i64)))
}
@@ -284,7 +284,7 @@ fn dict_item(dict: &Any, key: i64) -> i64 {
#[test]
fn unique_array_is_reused_while_shared_array_uses_copy_on_write() {
- let unique = Array::new(vec![1i64, 2, 3]);
+ let unique = Array::from_vec(vec![1i64, 2, 3]);
let unique_pointer = array_pointer(&unique);
let mapped = structural_map(unique, &mut IncrementIntegers,
WalkOrder::PostOrder)
.and_then(Array::<i64>::try_from)
@@ -292,7 +292,7 @@ fn
unique_array_is_reused_while_shared_array_uses_copy_on_write() {
assert_eq!(array_pointer(&mapped), unique_pointer);
assert_eq!(mapped.iter().collect::<Vec<_>>(), vec![2, 3, 4]);
- let source = Array::new(vec![4i64, 5]);
+ let source = Array::from_vec(vec![4i64, 5]);
let source_pointer = array_pointer(&source);
let mapped = structural_map(source.clone(), &mut IncrementIntegers,
WalkOrder::PostOrder)
.and_then(Array::<i64>::try_from)
@@ -304,7 +304,7 @@ fn
unique_array_is_reused_while_shared_array_uses_copy_on_write() {
#[test]
fn user_driven_mutator_controls_default_recursion_and_in_place_opt_in() {
- let unique = Array::new(vec![1i64, 2]);
+ let unique = Array::from_vec(vec![1i64, 2]);
let unique_pointer = array_pointer(&unique);
let mutated = structural_mutate::<Array<i64>, _, _, _, _>(unique,
ManualIncrement::default())
.and_then(Array::<i64>::try_from)
@@ -312,7 +312,7 @@ fn
user_driven_mutator_controls_default_recursion_and_in_place_opt_in() {
assert_eq!(array_pointer(&mutated), unique_pointer);
assert_eq!(mutated.iter().collect::<Vec<_>>(), vec![2, 3]);
- let source = Array::new(vec![3i64]);
+ let source = Array::from_vec(vec![3i64]);
let source_pointer = array_pointer(&source);
let mutated = structural_mutate(source.clone(), ManualIncrement::default())
.and_then(Array::<i64>::try_from)
@@ -342,9 +342,12 @@ fn
user_driven_mutator_controls_default_recursion_and_in_place_opt_in() {
}),
});
let mut dispatch = ManualIncrement::default();
- let first = structural_mutate(Array::new(vec![key.clone(), key.clone()]),
&mut dispatch)
- .and_then(Array::<Any>::try_from)
- .unwrap();
+ let first = structural_mutate(
+ Array::from_vec(vec![key.clone(), key.clone()]),
+ &mut dispatch,
+ )
+ .and_then(Array::<Any>::try_from)
+ .unwrap();
let first_node = first.get(0).unwrap();
assert_eq!(
any_object_pointer(&first_node),
@@ -359,7 +362,7 @@ fn
user_driven_mutator_controls_default_recursion_and_in_place_opt_in() {
assert_eq!(RemapNode::try_from(second).unwrap().data.value, 8);
for order in [WalkOrder::PreOrder, WalkOrder::PostOrder] {
let first = structural_map(
- Array::new(vec![key.clone(), key.clone()]),
+ Array::from_vec(vec![key.clone(), key.clone()]),
&mut dispatch,
order,
)
@@ -529,7 +532,7 @@ fn
default_mutation_mode_preserves_ownership_and_unchanged_results() {
}
for mode in [InplaceMode::Disallow, InplaceMode::Allow] {
for increment in [false, true] {
- let root = Array::new(vec![1_i64]);
+ let root = Array::from_vec(vec![1_i64]);
let pointer = array_pointer(&root);
let result = structural_mutate(root, &mut Controlled { mode,
increment })
.and_then(Array::<i64>::try_from)
@@ -557,7 +560,7 @@ fn
borrowed_capabilities_cannot_enable_low_level_default_reuse() {
return Ok((integer + 1).into());
}
assert_eq!(value.as_any_view().try_as::<bool>(), Some(true));
- let source = Array::new(vec![1_i64]);
+ let source = Array::from_vec(vec![1_i64]);
let pointer = array_pointer(&source);
let value = MutationView::borrowed(AnyView::from(&source));
assert_eq!(value.inplace_mode(), InplaceMode::Disallow);
@@ -568,7 +571,11 @@ fn
borrowed_capabilities_cannot_enable_low_level_default_reuse() {
let value = value.with_inplace_mode(InplaceMode::Allow);
assert_eq!(value.inplace_mode(), InplaceMode::Disallow);
let result = mutator.default_mutate(self, value)?;
- let result = Array::<i64>::try_from(result.value_or_else(||
source.clone().into()))?;
+ let result = Array::<i64>::try_from(
+ result
+ .into_option()
+ .unwrap_or_else(|| source.clone().into()),
+ )?;
assert_ne!(array_pointer(&result), pointer);
assert_eq!(source.get(0).unwrap(), 1);
assert_eq!(result.get(0).unwrap(), 2);
@@ -612,7 +619,7 @@ fn
borrowed_capabilities_keep_their_mode_in_dispatch_adapters() {
Unchanged.into_mutate_result()
}
}
- let source = Array::new(vec![1_i64]);
+ let source = Array::from_vec(vec![1_i64]);
let mut inspect = Inspect {
source: &source,
result: None,
@@ -643,7 +650,7 @@ fn owned_entry_mode_is_forwarded_by_generated_callbacks() {
_: bool,
mutator: &mut StructuralMutatorView<'_, Self>,
) -> Result<UnchangedOr<Any>> {
- let child = Array::new(vec![1_i64]);
+ let child = Array::from_vec(vec![1_i64]);
self.pointer = array_pointer(&child) as usize;
mutator.with_def_region_kind(DefRegionKind::Pattern, |mutator| {
let mut owner: Any = child.into();
@@ -667,7 +674,7 @@ fn owned_entry_mode_is_forwarded_by_generated_callbacks() {
assert!(change.is_unchanged());
}
assert_eq!(owner.debug_strong_count(), Some(count));
- let result = change.value_or(owner);
+ let result = change.value_or_unchanged(owner);
if let Some(alias) = alias {
assert_eq!(Array::<i64>::try_from(alias)?.get(0)?, 1);
}
@@ -783,9 +790,9 @@ fn
consuming_callbacks_forward_permissions_without_temporary_owners() {
(Allow, true, false),
(Allow, false, true),
] {
- let child = Array::new(vec![1_i64]);
+ let child = Array::from_vec(vec![1_i64]);
let child_ptr = array_pointer(&child);
- let root = Array::new(vec![child]);
+ let root = Array::from_vec(vec![child]);
let root_ptr = array_pointer(&root);
let original = shared.then(|| root.clone());
let mut state = Forward {
@@ -816,8 +823,8 @@ fn
consuming_callbacks_forward_permissions_without_temporary_owners() {
let mut owner: Any = FieldNode {
data: ObjectArc::new(FieldNodeObj {
base: Object::new(),
- a: Array::new(vec![1_i64]),
- b: Array::new(vec![2_i64]).into(),
+ a: Array::from_vec(vec![1_i64]),
+ b: Array::from_vec(vec![2_i64]).into(),
}),
}
.into();
@@ -894,7 +901,7 @@ fn
consuming_default_descent_transfers_between_contexts_without_node_borrows() {
for retain in [false, true] {
for borrowed in [false, true] {
- let root = Array::new(vec![1_i64]);
+ let root = Array::from_vec(vec![1_i64]);
let pointer = array_pointer(&root);
let result = if borrowed {
structural_mutate(root, &mut Outer { retain })
@@ -932,7 +939,7 @@ fn
consuming_default_descent_preserves_unchanged_and_propagates_errors() {
}
}
for fail in [false, true] {
- let root = Array::new(vec![1_i64]);
+ let root = Array::from_vec(vec![1_i64]);
let pointer = array_pointer(&root);
let result = structural_mutate(root, Preserve(fail));
if fail {
@@ -1061,7 +1068,7 @@ fn
callback_errors_preserve_message_and_add_object_context() {
child.clone(),
],
);
- let payload =
ObjectRef::try_from(Any::from(Array::new(vec![7i64]))).unwrap();
+ let payload =
ObjectRef::try_from(Any::from(Array::from_vec(vec![7i64]))).unwrap();
let records = call_global("ffi.List", &[Any::new()]);
let context = call_global(
"ffi.MakeObjectFromPackedArgs",
@@ -1200,14 +1207,14 @@ fn
callback_errors_preserve_message_and_add_object_context() {
// The failing node may be a pre-order replacement or a post-order rebuilt
parent.
for order in [WalkOrder::PreOrder, WalkOrder::PostOrder] {
- let root = Array::new(vec![0i64]);
+ let root = Array::from_vec(vec![0i64]);
let mut failed_node = None;
let error = structural_map(
root.clone(),
(
|value: Array<i64>| -> Result<Any> {
let value = if order == WalkOrder::PreOrder {
- Array::new(vec![1i64])
+ Array::from_vec(vec![1i64])
} else {
value
};
@@ -1250,7 +1257,7 @@ fn
callback_errors_preserve_message_and_add_object_context() {
#[test]
fn unique_map_reuses_nested_unique_value_storage() {
- let child = Array::new(vec![1i64, 2]);
+ let child = Array::from_vec(vec![1i64, 2]);
let child_pointer = array_pointer(&child);
let source: Map<i64, Array<i64>> = [(1, child)].into_iter().collect();
let source_pointer = map_pointer(&source);
@@ -1375,9 +1382,13 @@ impl GeneratedMapper {
#[test]
fn generated_map_dispatch_supports_kind_and_ordered_catch_all() {
let mut mapper = GeneratedMapper::default();
- let mapped = structural_map(Array::new(vec![1i64, 2]), &mut mapper,
WalkOrder::PostOrder)
- .and_then(Array::<i64>::try_from)
- .unwrap();
+ let mapped = structural_map(
+ Array::from_vec(vec![1i64, 2]),
+ &mut mapper,
+ WalkOrder::PostOrder,
+ )
+ .and_then(Array::<i64>::try_from)
+ .unwrap();
assert_eq!(mapped.iter().collect::<Vec<_>>(), vec![2, 3]);
assert_eq!(
@@ -1430,7 +1441,7 @@ fn
generated_stateless_mutate_dispatch_is_a_direct_callback() {
#[test]
fn
generated_mutate_dispatch_defaults_unmatched_values_and_preserves_inplace_permit()
{
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let root_pointer = array_pointer(&root);
let mut mutator = GeneratedLeafDispatch::default();
let mutated = structural_mutate(root, &mut mutator)
@@ -1465,10 +1476,11 @@ impl GeneratedRecursiveDispatch {
mutated.push(i64::try_from(
mutator
.mutate(self,
MutationView::borrowed(AnyView::from(&value)))?
- .value_or_else(|| value.into()),
+ .into_option()
+ .unwrap_or_else(|| value.into()),
)?);
}
- Ok(Array::new(mutated).into())
+ Ok(Array::from_vec(mutated).into())
}
fn mutate_integer(
@@ -1485,7 +1497,7 @@ impl GeneratedRecursiveDispatch {
#[test]
fn generated_mutate_dispatch_recurses_through_context() {
let mut mutator = GeneratedRecursiveDispatch::default();
- let mutated = structural_mutate(Array::new(vec![1i64, 2]), &mut mutator)
+ let mutated = structural_mutate(Array::from_vec(vec![1i64, 2]), &mut
mutator)
.and_then(Array::<i64>::try_from)
.unwrap();
@@ -1523,7 +1535,7 @@ impl GeneratedDefaultingDispatch {
#[test]
fn generated_mutate_dispatch_can_default_recurse_from_a_typed_handler() {
let mut mutator = GeneratedDefaultingDispatch::default();
- let mutated = structural_mutate(Array::new(vec![1i64, 2]), &mut mutator)
+ let mutated = structural_mutate(Array::from_vec(vec![1i64, 2]), &mut
mutator)
.and_then(Array::<i64>::try_from)
.unwrap();
@@ -1538,7 +1550,7 @@ fn pre_order_mapping_preserves_inplace_permission() {
let root = match case {
"inline" => Any::from(true),
"retained" => call_global("ffi.List", &[Any::from(1_i64)]),
- _ => Any::from(Array::new(vec![true])),
+ _ => Any::from(Array::from_vec(vec![true])),
};
let root_pointer = (case == "retained").then(||
any_object_pointer(&root));
let alias = (case == "shared").then(|| root.clone());
@@ -1552,7 +1564,7 @@ fn pre_order_mapping_preserves_inplace_permission() {
retained = Some(Any::from(value));
Any::from(value)
} else {
- Array::new(vec![1_i64]).into()
+ Array::from_vec(vec![1_i64]).into()
};
pointer = any_object_pointer(&mapped);
mapped
@@ -1581,7 +1593,7 @@ fn pre_order_mapping_preserves_inplace_permission() {
#[test]
fn closures_and_tuples_use_ordered_first_match() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mapped = structural_map(
root,
|integer: i64| Any::from(integer + 10),
@@ -1594,7 +1606,7 @@ fn closures_and_tuples_use_ordered_first_match() {
let mut first_calls = 0;
let mut later_calls = 0;
let mapped = structural_map(
- Array::new(vec![3i64]),
+ Array::from_vec(vec![3i64]),
(
|integer: i64| {
first_calls += 1;
@@ -1617,7 +1629,7 @@ fn closures_and_tuples_use_ordered_first_match() {
#[test]
fn callbacks_return_values_convertible_into_any() {
let mapped = structural_map(
- Array::new(vec![1i64, 2]),
+ Array::from_vec(vec![1i64, 2]),
|integer: i64| integer + 10,
WalkOrder::PostOrder,
)
@@ -1626,7 +1638,7 @@ fn callbacks_return_values_convertible_into_any() {
assert_eq!(mapped.iter().collect::<Vec<_>>(), vec![11, 12]);
let mapped = structural_map(
- Array::new(vec![1i64, 2]),
+ Array::from_vec(vec![1i64, 2]),
|integer: i64| -> Result<i64> { Ok(integer + 20) },
WalkOrder::PostOrder,
)
@@ -1645,7 +1657,7 @@ fn callbacks_return_values_convertible_into_any() {
(integer * 2).into_mutate_result()
}
}
- let mutated = structural_mutate(Array::new(vec![1i64, 2]), Double)
+ let mutated = structural_mutate(Array::from_vec(vec![1i64, 2]), Double)
.and_then(Array::<i64>::try_from)
.unwrap();
assert_eq!(mutated.iter().collect::<Vec<_>>(), vec![2, 4]);
@@ -1674,7 +1686,7 @@ fn recursive_mutate_returns_unchanged_or_a_replacement() {
}
// No rewrite: the public entry resolves unchanged to the original array.
- let source = Array::new(vec![1i64, 2]);
+ let source = Array::from_vec(vec![1i64, 2]);
let result = structural_mutate(source.clone(), ClampNegativeIntegers)
.and_then(Array::<i64>::try_from)
.unwrap();
@@ -1682,7 +1694,7 @@ fn recursive_mutate_returns_unchanged_or_a_replacement() {
assert_eq!(array_pointer(&result), array_pointer(&source));
// One rewrite: replace only the negative integer and keep the source
intact.
- let source = Array::new(vec![-1i64, 2]);
+ let source = Array::from_vec(vec![-1i64, 2]);
let result = structural_mutate(source.clone(), ClampNegativeIntegers)
.and_then(Array::<i64>::try_from)
.unwrap();
@@ -1693,9 +1705,9 @@ fn recursive_mutate_returns_unchanged_or_a_replacement() {
#[test]
fn pre_order_unchanged_reuses_unmodified_subtrees() {
- let unchanged = Array::new(vec![1i64, 2]);
- let changed = Array::new(vec![-1i64, 2]);
- let source = Array::new(vec![unchanged.clone(), changed.clone()]);
+ let unchanged = Array::from_vec(vec![1i64, 2]);
+ let changed = Array::from_vec(vec![-1i64, 2]);
+ let source = Array::from_vec(vec![unchanged.clone(), changed.clone()]);
let mapped = structural_map(
source.clone(),
@@ -1734,7 +1746,7 @@ fn pre_order_unchanged_reuses_unmodified_subtrees() {
fn post_order_unchanged_preserves_descendant_rewrites() {
for borrowed in [false, true] {
for shared in [false, true] {
- let root = Array::new(vec![1_i64]);
+ let root = Array::from_vec(vec![1_i64]);
let pointer = array_pointer(&root);
let alias = shared.then(|| root.clone());
let callbacks = (
@@ -1796,7 +1808,7 @@ fn twelve_link_tuple_reaches_final_map_dispatch() {
#[test]
fn nested_tuple_chain_exceeds_flat_arity() {
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let mut catch_all = 0;
let mapped = structural_map(
root,
@@ -1836,7 +1848,7 @@ fn nested_tuple_chain_exceeds_flat_arity() {
#[test]
fn callbacks_run_in_the_configured_order() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut pre = Vec::new();
structural_map(
root.clone(),
@@ -1913,7 +1925,7 @@ fn map_keys_are_anchors_and_object_leaves_are_preserved()
{
#[test]
fn callback_mutate_defaults_unmatched_values_and_preserves_root_permit() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let root_pointer = array_pointer(&root);
let mutated = structural_mutate(root, GeneratedStatelessDispatch)
.and_then(Array::<i64>::try_from)
@@ -1948,14 +1960,14 @@ impl CallbackMutateStats {
fn callback_mutator_carries_reusable_mutable_state() {
let mut mutator = CallbackMutateStats::default();
- let first = structural_mutate(Array::new(vec![1i64, 2]), &mut mutator)
+ let first = structural_mutate(Array::from_vec(vec![1i64, 2]), &mut mutator)
.and_then(Array::<i64>::try_from)
.unwrap();
assert_eq!(first.iter().collect::<Vec<_>>(), vec![2, 3]);
assert_eq!(mutator.integers, vec![1, 2]);
assert_eq!(mutator.defaults, 1);
- let second = structural_mutate(Array::new(vec![3i64]), &mut mutator)
+ let second = structural_mutate(Array::from_vec(vec![3i64]), &mut mutator)
.and_then(Array::<i64>::try_from)
.unwrap();
assert_eq!(second.iter().collect::<Vec<_>>(), vec![4]);
@@ -1990,7 +2002,7 @@ impl CallbackMutateDepth {
#[test]
fn callback_mutator_state_can_change_around_recursive_reborrows() {
- let root = Array::new(vec![Array::new(vec![1i64, 2])]);
+ let root = Array::from_vec(vec![Array::from_vec(vec![1i64, 2])]);
let mut mutator = CallbackMutateDepth::default();
let mutated = structural_mutate(root, &mut mutator)
.and_then(Array::<Array<i64>>::try_from)
@@ -2007,7 +2019,7 @@ fn
callback_mutator_state_can_change_around_recursive_reborrows() {
#[test]
fn callback_mutate_explicit_default_is_repeatable_copy_path() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let root_pointer = array_pointer(&root);
let defaults = Cell::new(0);
struct Repeat<'a>(&'a Cell<i32>);
@@ -2024,10 +2036,12 @@ fn
callback_mutate_explicit_default_is_repeatable_copy_path() {
self.0.set(self.0.get() + 1);
let first = mutator
.default_mutate(self, MutationView::borrowed(value))?
- .value_or_else(|| value.into());
+ .into_option()
+ .unwrap_or_else(|| value.into());
let second = mutator
.default_mutate(self, MutationView::borrowed(value))?
- .value_or_else(|| value.into());
+ .into_option()
+ .unwrap_or_else(|| value.into());
assert_ne!(any_object_pointer(&first),
any_object_pointer(&second));
Ok(UnchangedOr::changed(first))
}
@@ -2051,14 +2065,14 @@ fn
callback_mutate_match_is_final_and_same_fn_can_reenter() {
_: Array<i64>,
_: &mut StructuralMutatorView<'_, Self>,
) -> Result<UnchangedOr<Any>> {
- Ok(Array::new(vec![10i64]).into())
+ Ok(Array::from_vec(vec![10i64]).into())
}
fn mutate_integer(&mut self, value: i64) -> Result<UnchangedOr<Any>> {
self.0.set(self.0.get() + 1);
Ok((value + 1).into())
}
}
- let mutated = structural_mutate(Array::new(vec![1i64]),
First(&integer_calls))
+ let mutated = structural_mutate(Array::from_vec(vec![1i64]),
First(&integer_calls))
.and_then(Array::<i64>::try_from)
.unwrap();
assert_eq!(mutated.iter().collect::<Vec<_>>(), vec![10]);
@@ -2077,7 +2091,7 @@ fn
callback_mutate_match_is_final_and_same_fn_can_reenter() {
mutator.default_mutate(self, MutationView::borrowed(value))
}
}
- let mutated = structural_mutate(Array::new(vec![1i64, 2]), Reenter(&calls))
+ let mutated = structural_mutate(Array::from_vec(vec![1i64, 2]),
Reenter(&calls))
.and_then(Array::<i64>::try_from)
.unwrap();
assert_eq!(mutated.iter().collect::<Vec<_>>(), vec![1, 2]);
@@ -2127,7 +2141,7 @@ fn
callback_mutate_supports_node_links_nested_tuples_and_reflection() {
#[test]
fn callback_mutate_distinguishes_borrowed_and_owned_children() {
- let borrowed_child = Array::new(vec![1i64]);
+ let borrowed_child = Array::from_vec(vec![1i64]);
let borrowed_pointer = array_pointer(&borrowed_child);
struct Borrowed<'a>(&'a Array<i64>);
#[dispatch(mutate, (MutationView<'_>, &mut StructuralMutatorView<'_,
Self>), Result<UnchangedOr<Any>>)]
@@ -2160,11 +2174,11 @@ fn
callback_mutate_distinguishes_borrowed_and_owned_children() {
_: bool,
mutator: &mut StructuralMutatorView<'_, Self>,
) -> Result<UnchangedOr<Any>> {
- let child = Array::new(vec![1i64]);
+ let child = Array::from_vec(vec![1i64]);
self.0.set(array_pointer(&child) as usize);
let mut owner: Any = child.into();
let change = mutator.mutate(self, MutationView::from(&mut owner))?;
- Ok(UnchangedOr::changed(change.value_or(owner)))
+ Ok(UnchangedOr::changed(change.value_or_unchanged(owner)))
}
fn mutate_integer(&mut self, value: i64) -> Result<UnchangedOr<Any>> {
Ok((value + 1).into())
@@ -2208,7 +2222,7 @@ fn
nested_callback_mutate_restores_the_outer_active_mutator() {
mutator.mutate(self, MutationView::borrowed(AnyView::from(&3i64)))
}
}
- let mutated = structural_mutate(Array::new(vec![1i64]), Outer)
+ let mutated = structural_mutate(Array::from_vec(vec![1i64]), Outer)
.and_then(Array::<i64>::try_from)
.unwrap();
assert_eq!(mutated.get(0).unwrap(), 4);
@@ -2216,7 +2230,7 @@ fn
nested_callback_mutate_restores_the_outer_active_mutator() {
#[test]
fn map_entries_preserve_descent_and_callback_composition() {
- let root = || Array::new(vec![1_i64]);
+ let root = || Array::from_vec(vec![1_i64]);
let first = |value: Any|
Array::<i64>::try_from(value).unwrap().get(0).unwrap();
for order in [WalkOrder::PreOrder, WalkOrder::PostOrder] {
let mut dispatch = IncrementIntegers;
@@ -2279,7 +2293,7 @@ fn mutation_descent_preserves_ownership_and_markers() {
for case in 0..4 {
// Unique, shared, retained alias, explicit copy descent.
for increment in [false, true] {
- let root = Array::new(vec![1_i64]);
+ let root = Array::from_vec(vec![1_i64]);
let pointer = array_pointer(&root);
let alias = (case == 1).then(|| root.clone());
let state = Ownership {
@@ -2378,11 +2392,13 @@ fn mutation_regions_retargeting_and_error_restore() {
assert_eq!(mutator.def_region_kind(), Pattern);
self.0.push((100, mutator.def_region_kind()));
{
- let array = Array::new(vec![5_i64]);
+ let array = Array::from_vec(vec![5_i64]);
mutator
.default_mutate(self,
MutationView::borrowed(AnyView::from(&array)))
.map(|result| {
-
UnchangedOr::changed(result.value_or_else(|| array.into()))
+ UnchangedOr::changed(
+ result.into_option().unwrap_or_else(||
array.into()),
+ )
})
}
})
@@ -2417,10 +2433,14 @@ fn mutation_regions_retargeting_and_error_restore() {
if value.as_any_view().try_as::<bool>() == Some(false) {
return mutator.with_def_region_kind(Pattern, |mutator| {
self.0.push((100, mutator.def_region_kind()));
- let array = Array::new(vec![1_i64]);
+ let array = Array::from_vec(vec![1_i64]);
mutator
.default_mutate(self,
MutationView::borrowed(AnyView::from(&array)))
- .map(|result|
UnchangedOr::changed(result.value_or_else(|| array.into())))
+ .map(|result| {
+ UnchangedOr::changed(
+ result.into_option().unwrap_or_else(||
array.into()),
+ )
+ })
});
}
if let Some(x) = value.as_any_view().try_as::<i64>() {
@@ -2487,7 +2507,10 @@ fn mutation_regions_retargeting_and_error_restore() {
#[test]
fn mapping_preserves_post_recursion_state() {
- let root = Array::new(vec![Array::new(vec![1_i64, 2]), Array::new(vec![3,
4])]);
+ let root = Array::from_vec(vec![
+ Array::from_vec(vec![1_i64, 2]),
+ Array::from_vec(vec![3, 4]),
+ ]);
for order in [WalkOrder::PreOrder, WalkOrder::PostOrder] {
let ordinary = structural_map(root.clone(), |value: i64| value + 1,
order).unwrap();
let leaves = |value: &Any| {
@@ -2537,7 +2560,7 @@ fn mapping_preserves_primitive_replacement_descent() {
for order in [WalkOrder::PreOrder, WalkOrder::PostOrder] {
let callback = |value: i64| -> Any {
if value == 0 {
- Array::new(vec![1_i64, 2]).into()
+ Array::from_vec(vec![1_i64, 2]).into()
} else {
(value + 10).into()
}
@@ -2574,7 +2597,7 @@ fn dispatch_handlers_may_return_typed_results() {
mutator.default_mutate(self, value)?.try_cast()
}
}
- let mutated = structural_mutate(Array::new(vec![1i64, 2]), Typed)
+ let mutated = structural_mutate(Array::from_vec(vec![1i64, 2]), Typed)
.and_then(Array::<i64>::try_from)
.unwrap();
assert_eq!(mutated.iter().collect::<Vec<_>>(), vec![10, 20]);
@@ -2582,11 +2605,14 @@ fn dispatch_handlers_may_return_typed_results() {
struct KeepTyped;
#[dispatch(mutate, (MutationView<'_>, &mut StructuralMutatorView<'_,
Self>), Result<UnchangedOr<Any>>)]
impl KeepTyped {
- fn mutate_array(&mut self, _: MutationView<'_, Array<i64>>) ->
Result<UnchangedOr<Array<i64>>> {
+ fn mutate_array(
+ &mut self,
+ _: MutationView<'_, Array<i64>>,
+ ) -> Result<UnchangedOr<Array<i64>>> {
Ok(UnchangedOr::unchanged())
}
}
- let source = Array::new(vec![1i64, 2]);
+ let source = Array::from_vec(vec![1i64, 2]);
let kept = structural_mutate(source.clone(), KeepTyped)
.and_then(Array::<i64>::try_from)
.unwrap();
@@ -2596,9 +2622,13 @@ fn dispatch_handlers_may_return_typed_results() {
#[test]
fn map_callbacks_may_return_typed_results() {
let mapped = structural_map(
- Array::new(vec![1i64, 2]),
+ Array::from_vec(vec![1i64, 2]),
|value: i64| -> Result<UnchangedOr<i64>> {
- Ok(if value == 1 { UnchangedOr::changed(5) } else {
UnchangedOr::unchanged() })
+ Ok(if value == 1 {
+ UnchangedOr::changed(5)
+ } else {
+ UnchangedOr::unchanged()
+ })
},
WalkOrder::PreOrder,
)
diff --git a/rust/tvm-ffi/tests/test_structural_visit.rs
b/rust/tvm-ffi/tests/test_structural_visit.rs
index 5052c2bb..ce608a59 100644
--- a/rust/tvm-ffi/tests/test_structural_visit.rs
+++ b/rust/tvm-ffi/tests/test_structural_visit.rs
@@ -111,7 +111,7 @@ fn
default_descent_scopes_regions_and_restores_after_halts() {
seen: vec![],
regions: vec![],
};
- let result = structural_visit(&Array::new(vec![1_i64, 5]), &mut
visitor);
+ let result = structural_visit(&Array::from_vec(vec![1_i64, 5]), &mut
visitor);
match outcome {
Outcome::Finish => assert!(result.unwrap().is_none()),
@@ -194,7 +194,10 @@ fn
default_descent_retargets_without_dispatching_the_container() {
}
}
}
- let root = Array::new(vec![Any::from(Array::new(vec![7_i64])),
Any::from(99_i64)]);
+ let root = Array::from_vec(vec![
+ Any::from(Array::from_vec(vec![7_i64])),
+ Any::from(99_i64),
+ ]);
let mut visitor = Probe::default();
assert!(structural_visit(&root, &mut visitor).unwrap().is_none());
assert_eq!(
@@ -392,7 +395,7 @@ fn
public_reflection_access_uses_registered_field_and_type_attr() {
drop(root);
assert_eq!(selected.as_str(), "an owning C++ reflected field value");
- let wrong_type = Array::new(vec![0i64]);
+ let wrong_type = Array::from_vec(vec![0i64]);
assert!(getter.get_any(&**Array::data(&wrong_type)).is_err());
assert!(FieldGetter::new(type_index, "missing").is_err());
@@ -404,7 +407,7 @@ fn
public_reflection_access_uses_registered_field_and_type_attr() {
#[test]
fn plain_walk_uses_registered_array_hook() {
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let mut integers = 0;
assert!(structural_walk(
&root,
@@ -610,7 +613,7 @@ fn handler_error_crosses_map_traversal() {
#[test]
fn interrupt_stops_without_running_remaining_callbacks() {
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let mut integers = 0;
let outcome = structural_walk(
&root,
@@ -672,7 +675,7 @@ impl ManualRegionVisitor {
#[test]
fn manual_child_visit_can_override_def_region() {
- let root = Array::new(vec![7i64, 8]);
+ let root = Array::from_vec(vec![7i64, 8]);
let mut probe = ManualRegionVisitor::default();
assert!(structural_visit(&root, &mut probe).unwrap().is_none());
assert_eq!(probe.seen, vec![DefRegionKind::Simple, DefRegionKind::None]);
@@ -696,7 +699,7 @@ impl GeneratedLeafVisitor {
) -> Result<Option<VisitInterrupt>> {
let kind = visitor.def_region_kind();
if value == -1 {
- let root = Array::new(vec![1_i64, 2]);
+ let root = Array::from_vec(vec![1_i64, 2]);
assert!(
Dispatcher::dispatch_tuple(&mut *self, (AnyView::from(&root),
&mut *visitor))
.is_none()
@@ -716,7 +719,7 @@ impl GeneratedLeafVisitor {
#[test]
fn generated_visitor_defaults_unmatched_values() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut visitor = GeneratedLeafVisitor::default();
assert!(structural_visit(&-1_i64, &mut visitor).unwrap().is_none());
assert_eq!(visitor.integers, vec![(0, DefRegionKind::None)]);
@@ -769,7 +772,7 @@ impl GeneratedRecursiveVisitor {
#[test]
fn generated_visitor_can_drive_recursion_through_mut_self() {
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let mut visitor = GeneratedRecursiveVisitor::default();
let interrupt = structural_visit(&root, &mut visitor).unwrap().unwrap();
assert_eq!(interrupt.value.try_as::<i64>().unwrap(), 2);
@@ -839,7 +842,7 @@ impl MissingWholeImpl {
#[test]
fn generated_dispatch_supports_pod_and_ordered_catch_all() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut probe = GenericDispatchProbe::default();
assert!(structural_walk(&root, &mut probe, WalkOrder::PreOrder)
.unwrap()
@@ -847,7 +850,7 @@ fn generated_dispatch_supports_pod_and_ordered_catch_all() {
assert_eq!(probe.integers, vec![1, 2]);
assert_eq!(probe.objects, 1);
- let floats = Array::new(vec![1.0f64, 2.0]);
+ let floats = Array::from_vec(vec![1.0f64, 2.0]);
assert!(structural_walk(&floats, &mut probe, WalkOrder::PreOrder)
.unwrap()
.is_none());
@@ -921,7 +924,7 @@ impl StraddleVisitor {
#[test]
fn visitor_can_straddle_default_children() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut probe = StraddleVisitor::default();
assert!(structural_visit(&root, &mut probe).unwrap().is_none());
assert_eq!(
@@ -957,7 +960,7 @@ impl OrderProbe {
#[test]
fn stateful_structural_walk_supports_post_order() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut probe = OrderProbe::default();
assert!(structural_walk(&root, &mut probe, WalkOrder::PostOrder)
.unwrap()
@@ -967,8 +970,8 @@ fn stateful_structural_walk_supports_post_order() {
#[test]
fn nested_walk_restores_the_outer_active_visitor() {
- let outer = Array::new(vec![10i64, 20]);
- let inner = Array::new(vec![1i64, 2]);
+ let outer = Array::from_vec(vec![10i64, 20]);
+ let inner = Array::from_vec(vec![1i64, 2]);
let mut entered_inner = false;
let mut outer_values = Vec::new();
let mut inner_values = Vec::new();
@@ -1004,7 +1007,7 @@ fn nested_walk_restores_the_outer_active_visitor() {
#[test]
fn interrupt_payload_is_returned_to_the_caller() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let outcome = structural_walk(
&root,
|value: AnyView<'_>| {
@@ -1024,7 +1027,7 @@ fn interrupt_payload_is_returned_to_the_caller() {
#[test]
fn handler_errors_include_native_visit_path() {
- let root = Array::new(vec![1i64]);
+ let root = Array::from_vec(vec![1i64]);
let error = match structural_walk(
&root,
|value: AnyView<'_>| -> Result<WalkResult> {
@@ -1068,7 +1071,7 @@ fn visitor_errors_include_native_visit_path() {
}
}
- let root = Array::new(vec![1i64]);
+ let root = Array::from_vec(vec![1i64]);
let error = match structural_visit(&root, &mut FailingVisitor) {
Err(error) => error,
Ok(_) => panic!("visitor unexpectedly succeeded"),
@@ -1124,8 +1127,9 @@ fn
visitor_interrupt_propagates_through_default_children() {
}
}
- let root = Array::new(vec![1i64, 2, 3]);
- let outcome = structural_visit::<&Array<i64>, _, _, _, _>(&root, &mut
InterruptingVisitor).unwrap();
+ let root = Array::from_vec(vec![1i64, 2, 3]);
+ let outcome =
+ structural_visit::<&Array<i64>, _, _, _, _>(&root, &mut
InterruptingVisitor).unwrap();
let Some(interrupt) = outcome else {
panic!("visitor traversal unexpectedly completed");
};
@@ -1136,7 +1140,7 @@ fn
visitor_interrupt_propagates_through_default_children() {
fn closure_walk_receives_def_region_kind() {
// C++: StructuralWalk<kPreOrder>(root,
// [&](const TVarObj* var, TVMFFIDefRegionKind kind) { ... })
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut kinds = Vec::new();
assert!(structural_walk(
&root,
@@ -1155,7 +1159,7 @@ fn closure_walk_receives_def_region_kind() {
#[test]
fn closure_walk_supports_post_order_and_skip() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut order_probe = Vec::new();
assert!(structural_walk(
&root,
@@ -1194,7 +1198,10 @@ fn closure_walk_supports_post_order_and_skip() {
// ---------------------------------------------------------------------------
#[test]
fn chain_accepts_owned_object_ref_links() {
- let root = Array::new(vec![Array::new(vec![1i64]), Array::new(vec![2i64,
3])]);
+ let root = Array::from_vec(vec![
+ Array::from_vec(vec![1i64]),
+ Array::from_vec(vec![2i64, 3]),
+ ]);
let mut lengths = Vec::new();
assert!(structural_walk(
&root,
@@ -1216,7 +1223,7 @@ fn chain_accepts_owned_object_ref_links() {
#[test]
fn chain_links_may_mix_def_region_arity() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut kinds = Vec::new();
let mut objects = 0;
assert!(structural_walk(
@@ -1242,7 +1249,10 @@ fn chain_links_may_mix_def_region_arity() {
#[test]
fn chain_links_can_skip_children() {
- let root = Array::new(vec![Array::new(vec![1i64]),
Array::new(vec![2i64])]);
+ let root = Array::from_vec(vec![
+ Array::from_vec(vec![1i64]),
+ Array::from_vec(vec![2i64]),
+ ]);
let mut arrays = 0;
let mut integers = 0;
assert!(structural_walk(
@@ -1267,7 +1277,7 @@ fn chain_links_can_skip_children() {
#[test]
fn chain_link_errors_include_native_visit_path() {
- let root = Array::new(vec![1i64]);
+ let root = Array::from_vec(vec![1i64]);
let error = match structural_walk(
&root,
(
@@ -1285,7 +1295,7 @@ fn chain_link_errors_include_native_visit_path() {
#[test]
fn chain_supports_post_order() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let events = std::cell::RefCell::new(Vec::new());
assert!(structural_walk(
&root,
@@ -1321,7 +1331,7 @@ impl ObjectCounter {
#[test]
fn chain_splices_dispatch_walkers_between_closures() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut counter = ObjectCounter::default();
let mut integers = 0;
assert!(structural_walk(
@@ -1340,7 +1350,7 @@ fn chain_splices_dispatch_walkers_between_closures() {
#[test]
fn chain_supports_full_arity() {
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let mut integers = Vec::new();
let mut objects = 0;
let mut others = 0;
@@ -1383,7 +1393,7 @@ fn typed_lambda_walks_bare_and_as_single_link_tuple() {
// A lone typed handler needs no tuple: unmatched values (the array
// itself) advance normally. The 1-tuple spelling routes through the
// chain impls instead and must agree.
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let mut bare = 0;
assert!(structural_walk(
&root,
@@ -1411,7 +1421,7 @@ fn typed_lambda_walks_bare_and_as_single_link_tuple() {
#[test]
fn bare_node_lambda_takes_def_region_kind() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut objects = 0;
assert!(structural_walk(
&root,
@@ -1461,7 +1471,7 @@ impl InheritedRegionProbe {
#[test]
fn def_region_is_inherited_through_containers() {
- let root = Array::new(vec![Array::new(vec![1i64, 2])]);
+ let root = Array::from_vec(vec![Array::from_vec(vec![1i64, 2])]);
let mut probe = InheritedRegionProbe {
at_root: true,
seen: Vec::new(),
@@ -1520,7 +1530,7 @@ fn reflected_fields_reach_typed_handlers() {
#[test]
fn nested_tuple_chain_exceeds_flat_arity() {
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let mut integers = Vec::new();
let mut objects = 0;
let mut others = 0;
@@ -1570,7 +1580,7 @@ fn nested_tuple_chain_exceeds_flat_arity() {
#[test]
fn nested_tuple_first_match_order_is_flattened() {
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let mut first = 0;
let mut second = 0;
assert!(structural_walk(
@@ -1630,7 +1640,7 @@ fn callback_visit_defaults_only_when_no_link_matches() {
Ok(None)
}
}
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let integers = Cell::new(0);
assert!(structural_visit(&root, Integers(&integers),)
.unwrap()
@@ -1674,7 +1684,7 @@ impl StatefulVisitStats {
#[test]
fn stateful_callback_visit_uses_ordinary_mutable_state() {
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let mut visitor = StatefulVisitStats::default();
assert!(structural_visit(&root, &mut visitor).unwrap().is_none());
@@ -1716,7 +1726,7 @@ impl StatefulVisitDepth {
#[test]
fn stateful_callback_visit_reborrows_visitor_during_recursion() {
- let root = Array::new(vec![Array::new(vec![1i64, 2])]);
+ let root = Array::from_vec(vec![Array::from_vec(vec![1i64, 2])]);
let mut visitor = StatefulVisitDepth::default();
assert!(structural_visit(&root, &mut visitor).unwrap().is_none());
@@ -1743,7 +1753,7 @@ fn
callback_visit_can_reenter_the_same_fn_through_visitor() {
visitor.default_visit(self, &value)
}
}
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let visits = Cell::new(0);
assert!(structural_visit(&root, Reenter(&visits)).unwrap().is_none());
assert_eq!(visits.get(), 3);
@@ -1775,7 +1785,7 @@ fn
callback_visit_tuple_is_first_match_and_can_interrupt() {
visitor.default_visit(self, &value)
}
}
- let root = Array::new(vec![1i64, 2, 3]);
+ let root = Array::from_vec(vec![1i64, 2, 3]);
let fallback = Cell::new(0);
let interrupted = structural_visit(&root,
Stop(&fallback)).unwrap().unwrap();
assert_eq!(interrupted.value.try_as::<i64>().unwrap(), 2);
@@ -1818,7 +1828,10 @@ fn
callback_visit_supports_node_links_and_nested_tuples() {
visitor.default_visit(self, value)
}
}
- let root = Array::new(vec![Any::from(Array::new(vec![1_i64])),
Any::from(2_i64)]);
+ let root = Array::from_vec(vec![
+ Any::from(Array::from_vec(vec![1_i64])),
+ Any::from(2_i64),
+ ]);
let seen = RefCell::new(Vec::new());
assert!(structural_visit(&root, Nodes(&seen)).unwrap().is_none());
assert_eq!(
@@ -1861,7 +1874,7 @@ fn callback_visit_with_overrides_child_def_region() {
Ok(None)
}
}
- let root = Array::new(vec![1i64, 2]);
+ let root = Array::from_vec(vec![1i64, 2]);
let seen = RefCell::new(Vec::new());
assert!(structural_visit(&root, Regions(&seen)).unwrap().is_none());
assert_eq!(
@@ -1911,7 +1924,7 @@ fn
nested_callback_visit_restores_the_outer_active_visitor() {
visitor.default_visit(self, &value)
}
}
- let aligned_root = Array::new(vec![3_i64, 4]);
+ let aligned_root = Array::from_vec(vec![3_i64, 4]);
let mut borrowed = Aligned {
checked: false,
calls: 0,
@@ -1931,7 +1944,7 @@ fn
nested_callback_visit_restores_the_outer_active_visitor() {
for order in [WalkOrder::PreOrder, WalkOrder::PostOrder] {
let observed = RefCell::new(Vec::new());
structural_walk(
- &Array::new(vec![Any::from(Array::new(vec![1_i64]))]),
+ &Array::from_vec(vec![Any::from(Array::from_vec(vec![1_i64]))]),
|value: i64| {
observed.borrow_mut().push(value);
WalkResult::Advance
@@ -1984,8 +1997,8 @@ fn
nested_callback_visit_restores_the_outer_active_visitor() {
visitor.default_visit(self, &value)
}
}
- let outer = Array::new(vec![10i64, 20]);
- let inner = Array::new(vec![1i64, 2]);
+ let outer = Array::from_vec(vec![10i64, 20]);
+ let inner = Array::from_vec(vec![1i64, 2]);
let entered_inner = Cell::new(false);
let outer_values = RefCell::new(Vec::new());
let inner_values = RefCell::new(Vec::new());
@@ -2006,7 +2019,7 @@ fn
nested_callback_visit_restores_the_outer_active_visitor() {
#[test]
fn copied_views_forward_borrows_and_retain_only_explicit_owners() {
- let root = Any::from(Array::new(vec![1_i64, 2]));
+ let root = Any::from(Array::from_vec(vec![1_i64, 2]));
let view = AnyView::from(&root);
struct Identity;
#[dispatch(identity, (AnyView<'a>,), AnyView<'a>)]
@@ -2115,7 +2128,7 @@ fn
managed_walk_preserves_observer_address_and_drop_on_all_exits() {
fn run<const N: usize>(mode: usize) {
let address = Cell::new(0);
let drops = Cell::new(0);
- let root = Array::new(vec![1_i64, 2]);
+ let root = Array::from_vec(vec![1_i64, 2]);
let storage = Storage {
_padding: [0_u8; N],
address: &address,
@@ -2173,7 +2186,10 @@ fn
managed_walk_preserves_observer_address_and_drop_on_all_exits() {
#[test]
fn visitor_preserves_post_recursion_state() {
- let root = Array::new(vec![Array::new(vec![1_i64, 2]), Array::new(vec![3,
4])]);
+ let root = Array::from_vec(vec![
+ Array::from_vec(vec![1_i64, 2]),
+ Array::from_vec(vec![3, 4]),
+ ]);
#[derive(Default)]
struct PostState {
depth: usize,
@@ -2208,8 +2224,11 @@ fn visitor_preserves_post_recursion_state() {
#[test]
fn nested_walk_returns_one_owned_interrupt_payload_and_releases_it() {
- let root = Array::new(vec![Array::new(vec![1_i64, 2]),
Array::new(vec![3])]);
- let payload = Any::from(Array::new(vec![42_i64]));
+ let root = Array::from_vec(vec![
+ Array::from_vec(vec![1_i64, 2]),
+ Array::from_vec(vec![3]),
+ ]);
+ let payload = Any::from(Array::from_vec(vec![42_i64]));
for order in [WalkOrder::PreOrder, WalkOrder::PostOrder] {
let mut visited = Vec::new();
let interrupt = structural_walk(
@@ -2234,8 +2253,8 @@ fn
nested_walk_returns_one_owned_interrupt_payload_and_releases_it() {
#[test]
fn nested_walk_error_keeps_context_and_releases_callback_owner() {
- let root = Array::new(vec![Array::new(vec![1_i64, 2])]);
- let owner = Any::from(Array::new(vec![42_i64]));
+ let root = Array::from_vec(vec![Array::from_vec(vec![1_i64, 2])]);
+ let owner = Any::from(Array::from_vec(vec![42_i64]));
let callback_owner = owner.clone();
let error = structural_walk(
&root,
diff --git a/rust/tvm-ffi/tests/test_structural_visit_base.rs
b/rust/tvm-ffi/tests/test_structural_visit_base.rs
index 2babc299..67680e8d 100644
--- a/rust/tvm-ffi/tests/test_structural_visit_base.rs
+++ b/rust/tvm-ffi/tests/test_structural_visit_base.rs
@@ -24,9 +24,9 @@ use tvm_ffi::tvm_ffi_sys::{
TVMFFITypeMetadata, TVMFFITypeRegisterMetadata,
};
use tvm_ffi::{
- Any, AnyView, Array, DefRegionKind, Dispatcher, Error, Function,
IntoDispatcher, RUNTIME_ERROR,
- Result, StructuralVisitEngine, StructuralVisitorBase, StructuralVisitorObj,
- StructuralVisitorView, VisitInterrupt, dispatch, get_type_attr,
structural_visit,
+ dispatch, get_type_attr, structural_visit, Any, AnyView, Array,
DefRegionKind, Dispatcher,
+ Error, Function, IntoDispatcher, Result, StructuralVisitEngine,
StructuralVisitorBase,
+ StructuralVisitorObj, StructuralVisitorView, VisitInterrupt, RUNTIME_ERROR,
};
thread_local! {
@@ -104,7 +104,7 @@ unsafe impl StructuralVisitorBase for CountingBase {
(*runtime).defaults.set((*runtime).defaults.get() + 1);
// A default with observable behavior: redirect 10 to children 11 and
12.
if value.try_as::<i64>() == Some(10) {
- let children = Array::new(vec![11_i64, 12]);
+ let children = Array::from_vec(vec![11_i64, 12]);
return StructuralVisitorObj::default_visit_raw(runtime.cast(),
(&children).into());
}
if value.try_as::<i64>() == Some(-1) {
@@ -134,22 +134,22 @@ fn visit<'a, H, M, D, O>(root: impl Into<AnyView<'a>>,
visitor: H) -> Result<Opt
where
O: std::borrow::BorrowMut<D>,
for<'v, 'c, 'r> H: IntoDispatcher<
- (
- AnyView<'v>,
- &'c mut StructuralVisitorView<'r, D, CountingBase>,
- ),
- Option<Result<Option<VisitInterrupt>>>,
- M,
- Target = D,
- Output = O,
- >,
+ (
+ AnyView<'v>,
+ &'c mut StructuralVisitorView<'r, D, CountingBase>,
+ ),
+ Option<Result<Option<VisitInterrupt>>>,
+ M,
+ Target = D,
+ Output = O,
+ >,
for<'s, 'v, 'c, 'r> &'s mut D: Dispatcher<
- (
- AnyView<'v>,
- &'c mut StructuralVisitorView<'r, D, CountingBase>,
- ),
- Option<Result<Option<VisitInterrupt>>>,
- >,
+ (
+ AnyView<'v>,
+ &'c mut StructuralVisitorView<'r, D, CountingBase>,
+ ),
+ Option<Result<Option<VisitInterrupt>>>,
+ >,
{
StructuralVisitEngine::<CountingBase>::visit_root(root, visitor)
}
@@ -180,7 +180,7 @@ impl Trace {
result
}),
1 => {
- visitor.visit(self, &Array::new(vec![2_i64, 3]))?;
+ visitor.visit(self, &Array::from_vec(vec![2_i64, 3]))?;
// Resume the parent dispatcher after native recursion, then
recurse again.
self.leaves.push((4, visitor.def_region_kind()));
visitor.visit(self, &5_i64)
@@ -201,7 +201,7 @@ fn
larger_base_defaults_recurse_and_restore_dispatcher_and_region() {
std::mem::size_of::<View<'_, Trace>>(),
std::mem::size_of::<usize>()
);
- let root = Array::new(vec![0_i64, 1, 6]);
+ let root = Array::from_vec(vec![0_i64, 1, 6]);
let mut trace = Trace::default();
assert!(visit(&root, &mut trace).unwrap().is_none());
use DefRegionKind::{None as Use, Pattern};
@@ -234,16 +234,12 @@ fn
unmatched_scalar_uses_selected_default_and_owned_dispatcher() {
DROPPED.with_borrow_mut(Vec::clear);
assert!(visit(&10_i64, Empty).unwrap().is_none());
DROPPED.with_borrow(|drops| assert_eq!(*drops, [3]));
- assert!(
- structural_visit(&Array::new(vec![1_i64]), Empty)
- .unwrap()
- .is_none()
- );
- assert!(
- structural_visit(&Array::new(vec![1_i64]), &mut Empty)
- .unwrap()
- .is_none()
- );
+ assert!(structural_visit(&Array::from_vec(vec![1_i64]), Empty)
+ .unwrap()
+ .is_none());
+ assert!(structural_visit(&Array::from_vec(vec![1_i64]), &mut Empty)
+ .unwrap()
+ .is_none());
}
#[test]
@@ -297,20 +293,18 @@ fn base_failure_and_owned_results_release_exactly_once() {
}
DROPPED.with_borrow_mut(Vec::clear);
FAIL_INIT.set(true);
- assert!(
- visit(&1_i64, Unmatched)
- .err()
- .unwrap()
- .to_string()
- .contains("initialization failed")
- );
+ assert!(visit(&1_i64, Unmatched)
+ .err()
+ .unwrap()
+ .to_string()
+ .contains("initialization failed"));
FAIL_INIT.set(false);
DROPPED.with_borrow(|drops| assert!(drops.is_empty()));
- let payload = Any::from(Array::new(vec![42_i64]));
+ let payload = Any::from(Array::from_vec(vec![42_i64]));
BASE_RESULT
.with_borrow_mut(|slot| *slot =
Some(Ok(Some(VisitInterrupt::with(payload.clone())))));
- let result = visit(&Array::new(vec![-1_i64, 99]), Unmatched)
+ let result = visit(&Array::from_vec(vec![-1_i64, 99]), Unmatched)
.unwrap()
.unwrap();
assert_eq!(payload.debug_strong_count(), Some(2));
@@ -321,7 +315,7 @@ fn base_failure_and_owned_results_release_exactly_once() {
let error = Error::new(RUNTIME_ERROR, "base descent failed", "");
let owner = Any::from(error.clone());
BASE_RESULT.with_borrow_mut(|slot| *slot = Some(Err(error)));
- let result = visit(&Array::new(vec![-1_i64, 99]), Unmatched)
+ let result = visit(&Array::from_vec(vec![-1_i64, 99]), Unmatched)
.err()
.unwrap();
assert!(result.to_string().contains("base descent failed"));
@@ -365,7 +359,7 @@ fn
callback_outcomes_preserve_reborrows_and_owners_through_specialized_defaults(
}
for fail in [false, true] {
DROPPED.with_borrow_mut(Vec::clear);
- let payload = Any::from(Array::new(vec![42_i64]));
+ let payload = Any::from(Array::from_vec(vec![42_i64]));
let error = Error::new(RUNTIME_ERROR, "callback failed", "");
let error_owner = Any::from(error.clone());
let mut visitor = Halt {
@@ -377,18 +371,16 @@ fn
callback_outcomes_preserve_reborrows_and_owners_through_specialized_defaults(
}),
seen: vec![],
};
- let result = visit(&Array::new(vec![10_i64, 100]), &mut visitor);
+ let result = visit(&Array::from_vec(vec![10_i64, 100]), &mut visitor);
assert_eq!(visitor.seen, [10, 11, 99]);
DROPPED.with_borrow(|drops| assert_eq!(*drops, [2]));
if fail {
- assert!(
- result
- .as_ref()
- .err()
- .unwrap()
- .to_string()
- .contains("callback failed")
- );
+ assert!(result
+ .as_ref()
+ .err()
+ .unwrap()
+ .to_string()
+ .contains("callback failed"));
} else {
assert_eq!(payload.debug_strong_count(), Some(2));
}
diff --git a/rust/tvm-ffi/tests/test_structural_visitor_alignment.rs
b/rust/tvm-ffi/tests/test_structural_visitor_alignment.rs
index da06c27a..93b541fc 100644
--- a/rust/tvm-ffi/tests/test_structural_visitor_alignment.rs
+++ b/rust/tvm-ffi/tests/test_structural_visitor_alignment.rs
@@ -106,7 +106,7 @@ impl RecordingVisitor {
/// state flips to Recursive under "params" and back to None for the "body".
#[test]
fn records_values_and_def_region_modes() {
- let root = Array::new(vec![10i64, 20]);
+ let root = Array::from_vec(vec![10i64, 20]);
let mut visitor = RecordingVisitor::default();
let outcome = structural_visit(&root, &mut visitor).unwrap();
@@ -127,7 +127,7 @@ fn records_values_and_def_region_modes() {
/// halts at the marked value and the payload reaches the caller.
#[test]
fn stops_on_interrupt_with_payload() {
- let root = Array::new(vec![10i64, 20]);
+ let root = Array::from_vec(vec![10i64, 20]);
let mut visitor = RecordingVisitor {
interrupt_on: Some(20),
..RecordingVisitor::default()
diff --git a/rust/tvm-ffi/tests/test_tensor_view.rs
b/rust/tvm-ffi/tests/test_tensor_view.rs
index c0fe1409..51be6c43 100644
--- a/rust/tvm-ffi/tests/test_tensor_view.rs
+++ b/rust/tvm-ffi/tests/test_tensor_view.rs
@@ -37,7 +37,7 @@ fn dltensor(data: &mut [f32; 6], shape: &mut [i64; 2],
strides: *mut i64) -> DLT
fn describe() -> Function {
Function::from_typed(|t: TensorView| -> Result<Array<i64>> {
let first = unsafe { *(t.data_ptr() as *const f32) } as i64;
- Ok(Array::new(vec![
+ Ok(Array::from_vec(vec![
t.ndim() as i64,
t.shape()[1],
t.strides()[0],
@@ -48,7 +48,7 @@ fn describe() -> Function {
fn call(f: &Function, arg: AnyView) -> Result<Vec<i64>> {
let out = Array::<i64>::try_from(f.call_packed(&[arg])?)?;
- (0..out.len()).map(|i| Ok(i64::try_from(out[i])?)).collect()
+ Ok((0..out.len()).map(|i| out[i]).collect())
}
#[test]
