fix(arena): resolve clippy warnings for unsized types in Collect trait

Split static_collect! macro into two variants to handle sized vs unsized types:
- static_collect_sized! for types that implement Sized (implements needs_trace)
- static_collect! for potentially unsized types (skips needs_trace)

This fixes clippy warnings about needs_trace() not being usable for unsized
types like str, CStr, Path, and OsStr due to the Sized bound in the trait.

Also removed needs_trace() implementations from:
- &'static T (where T: ?Sized)
- [T] (slice type is inherently unsized)

The trait's default implementation handles the optimization check for sized
types, while unsized types simply don't provide the method.

Author: Folyd

aiscript-arena/src/collect_impl.rs

@@ -16,6 +16,19 @@ use crate::context::Collection;
 /// simple empty `Collect` implementation.
 #[macro_export]
 macro_rules! static_collect {
+    ($type:ty) => {
+        unsafe impl Collect for $type
+        where
+            $type: 'static,
+        {
+            // Don't implement needs_trace for unsized types
+        }
+    };
+}
+
+/// For sized static types, we can implement needs_trace
+#[macro_export]
+macro_rules! static_collect_sized {
     ($type:ty) => {
         unsafe impl Collect for $type
         where
@@ -29,33 +42,33 @@ macro_rules! static_collect {
     };
 }
 
-static_collect!(bool);
-static_collect!(char);
-static_collect!(u8);
-static_collect!(u16);
-static_collect!(u32);
-static_collect!(u64);
-static_collect!(usize);
-static_collect!(i8);
-static_collect!(i16);
-static_collect!(i32);
-static_collect!(i64);
-static_collect!(isize);
-static_collect!(f32);
-static_collect!(f64);
-static_collect!(String);
+static_collect_sized!(bool);
+static_collect_sized!(char);
+static_collect_sized!(u8);
+static_collect_sized!(u16);
+static_collect_sized!(u32);
+static_collect_sized!(u64);
+static_collect_sized!(usize);
+static_collect_sized!(i8);
+static_collect_sized!(i16);
+static_collect_sized!(i32);
+static_collect_sized!(i64);
+static_collect_sized!(isize);
+static_collect_sized!(f32);
+static_collect_sized!(f64);
+static_collect_sized!(String);
 static_collect!(str);
-static_collect!(alloc::ffi::CString);
+static_collect_sized!(alloc::ffi::CString);
 static_collect!(core::ffi::CStr);
-static_collect!(core::any::TypeId);
+static_collect_sized!(core::any::TypeId);
 #[cfg(feature = "std")]
 static_collect!(std::path::Path);
 #[cfg(feature = "std")]
-static_collect!(std::path::PathBuf);
+static_collect_sized!(std::path::PathBuf);
 #[cfg(feature = "std")]
 static_collect!(std::ffi::OsStr);
 #[cfg(feature = "std")]
-static_collect!(std::ffi::OsString);
+static_collect_sized!(std::ffi::OsString);
 
 /// SAFETY: We know that a `&'static` reference cannot possibly point to `'gc` data, so it is safe
 /// to keep in a rooted objet and we do not have to trace through it.
@@ -84,10 +97,7 @@ static_collect!(std::ffi::OsString);
 ///
 /// DO NOT REMOVE THIS EXTRA `T: 'static` BOUND
 unsafe impl<T: ?Sized + 'static> Collect for &'static T {
-    #[inline]
-    fn needs_trace() -> bool {
-        false
-    }
+    // Don't implement needs_trace since T might be unsized
 }
 
 unsafe impl<T: ?Sized + Collect> Collect for Box<T> {
@@ -98,10 +108,7 @@ unsafe impl<T: ?Sized + Collect> Collect for Box<T> {
 }
 
 unsafe impl<T: Collect> Collect for [T] {
-    #[inline]
-    fn needs_trace() -> bool {
-        T::needs_trace()
-    }
+    // Don't implement needs_trace since [T] is unsized
 
     #[inline]
     fn trace(&self, cc: &Collection) {

aiscript-vm/src/compiler/codegen.rs

@@ -70,7 +70,7 @@ pub struct CodeGen<'gc> {
 
 impl<'gc> CodeGen<'gc> {
     pub fn new(ctx: Context<'gc>, fn_type: FunctionType, name: &str) -> Box<Self> {
-        let generator = Box::new(CodeGen {
+        Box::new(CodeGen {
             ctx,
             chunks: HashMap::new(),
             named_id_map: HashMap::new(),
@@ -107,9 +107,7 @@ impl<'gc> CodeGen<'gc> {
             enclosing: None,
             current_line: 0,
             error_reporter: ErrorReporter::new(),
-        });
-
-        generator
+        })
     }
 
     pub fn register_enum(&mut self, name: &'gc str, enum_: GcRefLock<'gc, Enum<'gc>>) {