chore(Rust): Remove new_from_fory from context.rs (#2831)

## What does this PR do?
1. Remove new_from_fory from context.rs
2. add `allow(clippy::needless_lifetimes)]` to keep lifetime but avoid
lint error.
3. refactor some unit tests.

## Related issues
close #2827

Author: urlyy

java/fory-core/src/test/java/org/apache/fory/RustXlangTest.java

@@ -316,14 +316,14 @@ private void _testStringSerializer(
           "Hello, 世界",
         };
     for (String s : testStrings) {
-      serializer.writeJavaString(buffer, s);
+      fory.serialize(buffer, s);
     }
     Pair<Map<String, String>, File> env_workdir =
         setFilePath(language, command, dataFile, buffer.getBytes(0, buffer.writerIndex()));
     Assert.assertTrue(executeCommand(command, 30, env_workdir.getLeft(), env_workdir.getRight()));
     buffer = MemoryUtils.wrap(Files.readAllBytes(dataFile));
     for (String expected : testStrings) {
-      String actual = serializer.readJavaString(buffer);
+      String actual = (String) fory.deserialize(buffer);
       Assert.assertEquals(actual, expected);
     }
   }
@@ -810,8 +810,9 @@ private void testConsistentNamed(Language language, List<String> command)
     for (int i = 0; i < 3; i++) {
       fory.serialize(buffer, Color.White);
     }
-    // todo: checkVersion
-    //        fory.serialize(buffer, myStruct);
+    for (int i = 0; i < 3; i++) {
+      fory.serialize(buffer, myStruct);
+    }
     for (int i = 0; i < 3; i++) {
       fory.serialize(buffer, myExt);
     }

rust/fory-core/src/buffer.rs

@@ -333,11 +333,13 @@ impl<'a> Writer<'a> {
 }
 
 #[derive(Default)]
+#[allow(clippy::needless_lifetimes)]
 pub struct Reader<'a> {
     pub(crate) bf: &'a [u8],
     pub(crate) cursor: usize,
 }
 
+#[allow(clippy::needless_lifetimes)]
 impl<'a> Reader<'a> {
     #[inline(always)]
     pub fn new(bf: &[u8]) -> Reader<'_> {
@@ -743,5 +745,7 @@ impl<'a> Reader<'a> {
     }
 }
 
+#[allow(clippy::needless_lifetimes)]
 unsafe impl<'a> Send for Reader<'a> {}
+#[allow(clippy::needless_lifetimes)]
 unsafe impl<'a> Sync for Reader<'a> {}

rust/fory-core/src/fory.rs

@@ -335,11 +335,6 @@ impl Fory {
         self.check_struct_version
     }
 
-    /// Returns a type resolver for type lookups.
-    pub(crate) fn get_type_resolver(&self) -> &TypeResolver {
-        &self.type_resolver
-    }
-
     /// Serializes a value of type `T` into a byte vector.
     ///
     /// # Type Parameters

rust/fory-core/src/resolver/context.rs

@@ -19,7 +19,6 @@ use crate::buffer::{Reader, Writer};
 use std::mem;
 
 use crate::error::Error;
-use crate::fory::Fory;
 use crate::meta::MetaString;
 use crate::resolver::meta_resolver::{MetaReaderResolver, MetaWriterResolver};
 use crate::resolver::meta_string_resolver::{MetaStringReaderResolver, MetaStringWriterResolver};
@@ -31,6 +30,7 @@ use std::rc::Rc;
 
 /// Serialization state container used on a single thread at a time.
 /// Sharing the same instance across threads simultaneously causes undefined behavior.
+#[allow(clippy::needless_lifetimes)]
 pub struct WriteContext<'a> {
     // Replicated environment fields (direct access, no Arc indirection for flags)
     type_resolver: TypeResolver,
@@ -48,6 +48,7 @@ pub struct WriteContext<'a> {
     pub ref_writer: RefWriter,
 }
 
+#[allow(clippy::needless_lifetimes)]
 impl<'a> WriteContext<'a> {
     pub fn new(
         type_resolver: TypeResolver,
@@ -89,27 +90,6 @@ impl<'a> WriteContext<'a> {
         self.writer = default.unwrap();
     }
 
-    /// Test method to create WriteContext from Fory instance
-    /// Will be removed in future releases, do not use it in production code
-    pub fn new_from_fory(fory: &Fory) -> WriteContext<'a> {
-        WriteContext {
-            default_writer: None,
-            writer: Writer::from_buffer(Self::get_leak_buffer()),
-            type_resolver: fory
-                .get_type_resolver()
-                .build_final_type_resolver()
-                .unwrap(),
-            compatible: fory.is_compatible(),
-            share_meta: fory.is_share_meta(),
-            compress_string: fory.is_compress_string(),
-            xlang: fory.is_xlang(),
-            check_struct_version: fory.is_check_struct_version(),
-            meta_resolver: MetaWriterResolver::default(),
-            meta_string_resolver: MetaStringWriterResolver::default(),
-            ref_writer: RefWriter::new(),
-        }
-    }
-
     /// Get type resolver
     #[inline(always)]
     pub fn get_type_resolver(&self) -> &TypeResolver {
@@ -227,6 +207,7 @@ impl<'a> WriteContext<'a> {
     }
 }
 
+#[allow(clippy::needless_lifetimes)]
 impl<'a> Drop for WriteContext<'a> {
     fn drop(&mut self) {
         unsafe {
@@ -239,7 +220,9 @@ impl<'a> Drop for WriteContext<'a> {
 // ensures single-threaded access while the context is in use. Users must never hold the same
 // instance on multiple threads simultaneously; that would violate the invariants and result in
 // undefined behavior. Under that assumption, marking it Send/Sync is sound.
+#[allow(clippy::needless_lifetimes)]
 unsafe impl<'a> Send for WriteContext<'a> {}
+#[allow(clippy::needless_lifetimes)]
 unsafe impl<'a> Sync for WriteContext<'a> {}
 
 /// Deserialization state container used on a single thread at a time.
@@ -265,7 +248,9 @@ pub struct ReadContext<'a> {
 // single-threaded use. Concurrent access to the same instance across threads is forbidden and
 // would result in undefined behavior. With exclusive use guaranteed, the Send/Sync markers are safe
 // even though Rc is used internally.
+#[allow(clippy::needless_lifetimes)]
 unsafe impl<'a> Send for ReadContext<'a> {}
+#[allow(clippy::needless_lifetimes)]
 unsafe impl<'a> Sync for ReadContext<'a> {}
 
 impl<'a> ReadContext<'a> {
@@ -292,27 +277,6 @@ impl<'a> ReadContext<'a> {
         }
     }
 
-    /// Test method to create ReadContext from Fory instance
-    /// Will be removed in future releases, do not use it in production code
-    pub fn new_from_fory(fory: &Fory) -> ReadContext<'a> {
-        ReadContext {
-            type_resolver: fory
-                .get_type_resolver()
-                .build_final_type_resolver()
-                .unwrap(),
-            compatible: fory.is_compatible(),
-            share_meta: fory.is_share_meta(),
-            xlang: fory.is_xlang(),
-            max_dyn_depth: fory.get_max_dyn_depth(),
-            check_struct_version: fory.is_check_struct_version(),
-            reader: Reader::default(),
-            meta_resolver: MetaReaderResolver::default(),
-            meta_string_resolver: MetaStringReaderResolver::default(),
-            ref_reader: RefReader::new(),
-            current_depth: 0,
-        }
-    }
-
     /// Get type resolver
     #[inline(always)]
     pub fn get_type_resolver(&self) -> &TypeResolver {

rust/fory-core/src/row/row.rs

@@ -143,6 +143,7 @@ pub struct ArrayGetter<'a, T> {
     _marker: PhantomData<T>,
 }
 
+#[allow(clippy::needless_lifetimes)]
 impl<'a, T: Row<'a>> ArrayGetter<'a, T> {
     pub fn size(&self) -> usize {
         self.array_data.num_elements()
@@ -157,6 +158,7 @@ impl<'a, T: Row<'a>> ArrayGetter<'a, T> {
     }
 }
 
+#[allow(clippy::needless_lifetimes)]
 impl<'a, T: Row<'a>> Row<'a> for Vec<T> {
     type ReadResult = ArrayGetter<'a, T>;
 
@@ -218,6 +220,7 @@ impl<'a, T1: Row<'a> + Ord, T2: Row<'a> + Ord> MapGetter<'a, T1, T2> {
     }
 }
 
+#[allow(clippy::needless_lifetimes)]
 impl<'a, T1: Row<'a> + Ord, T2: Row<'a> + Ord> Row<'a> for BTreeMap<T1, T2> {
     type ReadResult = MapGetter<'a, T1, T2>;
 

rust/fory-core/src/util.rs

@@ -174,23 +174,25 @@ impl<T> Spinlock<T> {
     }
 }
 
+#[allow(clippy::needless_lifetimes)]
 pub struct SpinlockGuard<'a, T> {
     lock: &'a Spinlock<T>,
 }
-
+#[allow(clippy::needless_lifetimes)]
 impl<'a, T> Drop for SpinlockGuard<'a, T> {
     fn drop(&mut self) {
         self.lock.unlock();
     }
 }
-
+#[allow(clippy::needless_lifetimes)]
 impl<'a, T> Deref for SpinlockGuard<'a, T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         unsafe { &*self.lock.data.get() }
     }
 }
 
+#[allow(clippy::needless_lifetimes)]
 impl<'a, T> DerefMut for SpinlockGuard<'a, T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { &mut *self.lock.data.get() }