Refactor symbol propertykey and adjust usages

ssrlive · ssrlive · commit 2e95813c9cd0 · 2026-01-07T13:07:00.000+08:00
- Change PropertyKey::Symbol to hold Gc&lt;SymbolData&gt;
- Update PartialEq/Hash/Display implementations
- Adjust has_own_property_value to use SymbolData directly
- Update multiple call sites in js_object.rs to use new Symbol key form
- Update js_proxy property_key_to_value to return Value::Symbol
diff --git a/src/core.rs b/src/core.rs
@@ -7,9 +7,12 @@ use crate::js_regexp::initialize_regexp;
 use crate::js_string::initialize_string;
 use crate::raise_eval_error;
 use crate::unicode::utf8_to_utf16;
+pub(crate) use gc_arena::GcWeak;
 pub(crate) use gc_arena::Mutation as MutationContext;
+pub(crate) use gc_arena::collect::Trace as GcTrace;
 pub(crate) use gc_arena::lock::RefLock as GcCell;
 pub(crate) use gc_arena::{Collect, Gc};
+pub(crate) type GcPtr<'gc, T> = Gc<'gc, GcCell<T>>;
 use std::collections::HashMap;
 
 mod gc;
@@ -41,7 +44,7 @@ pub use js_error::*;
 #[collect(no_drop)]
 pub struct JsRoot<'gc> {
     pub global_env: JSObjectDataPtr<'gc>,
-    pub well_known_symbols: Gc<'gc, GcCell<HashMap<String, gc::GcPtr<'gc, Value<'gc>>>>>,
+    pub well_known_symbols: Gc<'gc, GcCell<HashMap<String, GcPtr<'gc, Value<'gc>>>>>,
 }
 
 pub type JsArena = gc_arena::Arena<gc_arena::Rootable!['gc => JsRoot<'gc>]>;
diff --git a/src/core/eval.rs b/src/core/eval.rs
@@ -1,5 +1,6 @@
 #![allow(warnings)]
 
+use crate::core::{Gc, GcCell, MutationContext};
 use crate::js_array::handle_array_static_method;
 use crate::js_date::{handle_date_method, handle_date_static_method};
 use crate::js_string::{string_from_char_code, string_from_code_point, string_raw};
@@ -15,9 +16,6 @@ use crate::{
     unicode::{utf8_to_utf16, utf16_to_utf8},
 };
 use crate::{Token, parse_statements, tokenize};
-use gc_arena::Gc;
-use gc_arena::Mutation as MutationContext;
-use gc_arena::lock::RefLock as GcCell;
 
 #[derive(Clone, Debug)]
 pub enum ControlFlow<'gc> {
@@ -291,7 +289,7 @@ fn eval_res<'gc>(
             };
             Ok(Some(ControlFlow::Return(val)))
         }
-        StatementKind::FunctionDeclaration(name, params, body, _) => {
+        StatementKind::FunctionDeclaration(_name, _params, _body, _) => {
             // Function declarations are hoisted, so they are already defined.
             Ok(None)
         }
diff --git a/src/core/gc.rs b/src/core/gc.rs
@@ -1,14 +1,10 @@
+use crate::core::{Collect, GcTrace};
 use crate::core::{DestructuringElement, Expr, Statement, StatementKind};
-use gc_arena::collect::Trace;
-use gc_arena::lock::RefLock as GcCell;
-use gc_arena::{Collect, Gc};
-
-pub type GcPtr<'gc, T> = Gc<'gc, GcCell<T>>;
 
 // Manual implementation of trace to avoid cycles in derive
-pub fn trace_expr<'gc, T: Trace<'gc>>(context: &mut T, expr: &Expr) {
+pub fn trace_expr<'gc, T: GcTrace<'gc>>(context: &mut T, expr: &Expr) {
     // helper to find and trace any Expr defaults nested in destructuring elements
-    fn trace_destructuring<'gc, T: Trace<'gc>>(cc: &mut T, d: &DestructuringElement) {
+    fn trace_destructuring<'gc, T: GcTrace<'gc>>(cc: &mut T, d: &DestructuringElement) {
         match d {
             DestructuringElement::Variable(_, Some(e)) => trace_expr(cc, e),
             DestructuringElement::Property(_, inner) => trace_destructuring(cc, inner),
@@ -75,7 +71,7 @@ pub fn trace_expr<'gc, T: Trace<'gc>>(context: &mut T, expr: &Expr) {
     }
 }
 
-pub fn trace_stmt<'gc, T: Trace<'gc>>(context: &mut T, stmt: &Statement) {
+pub fn trace_stmt<'gc, T: GcTrace<'gc>>(context: &mut T, stmt: &Statement) {
     match &stmt.kind {
         StatementKind::Expr(e) => trace_expr(context, e),
         StatementKind::Let(decls) | StatementKind::Var(decls) => {
diff --git a/src/core/property_key.rs b/src/core/property_key.rs
@@ -1,12 +1,11 @@
-use crate::core::Value;
-use crate::core::gc::GcPtr;
-use gc_arena::Collect;
+use crate::core::SymbolData;
+use crate::core::{Collect, Gc};
 
 #[derive(Clone, Debug, Collect)]
 #[collect(no_drop)]
 pub enum PropertyKey<'gc> {
     String(String),
-    Symbol(GcPtr<'gc, Value<'gc>>),
+    Symbol(Gc<'gc, SymbolData>),
 }
 
 impl<'gc> From<&str> for PropertyKey<'gc> {
@@ -31,13 +30,7 @@ impl<'gc> PartialEq for PropertyKey<'gc> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (PropertyKey::String(s1), PropertyKey::String(s2)) => s1 == s2,
-            (PropertyKey::Symbol(sym1), PropertyKey::Symbol(sym2)) => {
-                if let (Value::Symbol(s1), Value::Symbol(s2)) = (&*sym1.borrow(), &*sym2.borrow()) {
-                    gc_arena::Gc::ptr_eq(*s1, *s2)
-                } else {
-                    false
-                }
-            }
+            (PropertyKey::Symbol(sym1), PropertyKey::Symbol(sym2)) => Gc::ptr_eq(*sym1, *sym2),
             _ => false,
         }
     }
@@ -54,9 +47,7 @@ impl<'gc> std::hash::Hash for PropertyKey<'gc> {
             }
             PropertyKey::Symbol(sym) => {
                 1u8.hash(state);
-                if let Value::Symbol(s) = &*sym.borrow() {
-                    gc_arena::Gc::as_ptr(*s).hash(state);
-                }
+                Gc::as_ptr(*sym).hash(state);
             }
         }
     }
@@ -66,7 +57,7 @@ impl<'gc> std::fmt::Display for PropertyKey<'gc> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             PropertyKey::String(s) => write!(f, "{}", s),
-            PropertyKey::Symbol(ptr) => write!(f, "[symbol {:p}]", gc_arena::Gc::as_ptr(*ptr)),
+            PropertyKey::Symbol(sym) => write!(f, "[symbol {:p}]", Gc::as_ptr(*sym)),
         }
     }
 }
@@ -75,7 +66,7 @@ impl<'gc> AsRef<str> for PropertyKey<'gc> {
     fn as_ref(&self) -> &str {
         match self {
             PropertyKey::String(s) => s,
-            PropertyKey::Symbol(_ptr) => todo!("Cannot convert Symbol to &str"),
+            PropertyKey::Symbol(_sym) => todo!("Cannot convert Symbol to &str"),
         }
     }
 }
diff --git a/src/core/statement.rs b/src/core/statement.rs
@@ -1,4 +1,5 @@
 use crate::core::TemplatePart;
+use crate::core::{Collect, GcTrace};
 
 #[derive(Clone, Debug)]
 pub struct Statement {
@@ -48,14 +49,14 @@ impl From<StatementKind> for Statement {
     }
 }
 
-unsafe impl<'gc> gc_arena::Collect<'gc> for Statement {
-    fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {
+unsafe impl<'gc> Collect<'gc> for Statement {
+    fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {
         crate::core::gc::trace_stmt(cc, self);
     }
 }
 
-unsafe impl<'gc> gc_arena::Collect<'gc> for StatementKind {
-    fn trace<T: gc_arena::collect::Trace<'gc>>(&self, _cc: &mut T) {
+unsafe impl<'gc> Collect<'gc> for StatementKind {
+    fn trace<T: GcTrace<'gc>>(&self, _cc: &mut T) {
         // Handled via Statement trace
     }
 }
@@ -136,8 +137,8 @@ pub enum Expr {
     ValuePlaceholder,
 }
 
-unsafe impl<'gc> gc_arena::Collect<'gc> for Expr {
-    fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {
+unsafe impl<'gc> Collect<'gc> for Expr {
+    fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {
         crate::core::gc::trace_expr(cc, self);
     }
 }
@@ -169,8 +170,8 @@ pub enum BinaryOp {
     Pow,
 }
 
-unsafe impl<'gc> gc_arena::Collect<'gc> for BinaryOp {
-    fn trace<T: gc_arena::collect::Trace<'gc>>(&self, _cc: &mut T) {}
+unsafe impl<'gc> Collect<'gc> for BinaryOp {
+    fn trace<T: GcTrace<'gc>>(&self, _cc: &mut T) {}
 }
 
 #[derive(Debug, Clone)]
@@ -238,8 +239,8 @@ pub enum DestructuringElement {
     NestedObject(Vec<DestructuringElement>),
 }
 
-unsafe impl<'gc> gc_arena::Collect<'gc> for DestructuringElement {
-    fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {
+unsafe impl<'gc> Collect<'gc> for DestructuringElement {
+    fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {
         match self {
             DestructuringElement::Variable(_, e) => {
                 if let Some(e) = e {
diff --git a/src/core/token.rs b/src/core/token.rs
@@ -1,5 +1,5 @@
+use crate::core::{Collect, GcTrace};
 use crate::{JSError, raise_tokenize_error};
-use gc_arena::{Collect, collect::Trace};
 use num_bigint::BigInt;
 use num_traits::{Num, ToPrimitive};
 
@@ -195,7 +195,7 @@ pub struct TokenData {
 unsafe impl<'gc> Collect<'gc> for TokenData {
     const NEEDS_TRACE: bool = false;
 
-    fn trace<'a, T: Trace<'gc>>(&self, _cc: &mut T) {
+    fn trace<'a, T: GcTrace<'gc>>(&self, _cc: &mut T) {
         // do not trace token to break cycle
     }
 }
diff --git a/src/core/value.rs b/src/core/value.rs
@@ -1,20 +1,14 @@
 #![allow(clippy::collapsible_if, clippy::collapsible_match, dead_code)]
 
-use gc_arena::Mutation as MutationContext;
-use gc_arena::collect::Trace;
-use gc_arena::lock::RefLock as GcCell;
-use gc_arena::{Collect, Gc};
-use num_bigint::BigInt;
-use std::sync::{Arc, Mutex};
-
+use crate::core::{Collect, Gc, GcCell, GcPtr, GcTrace, GcWeak, MutationContext};
 use crate::unicode::utf16_to_utf8;
 use crate::{
     JSError,
     core::{DestructuringElement, PropertyKey, Statement, is_error},
     raise_type_error,
 };
-
-pub type GcPtr<'gc, T> = Gc<'gc, GcCell<T>>;
+use num_bigint::BigInt;
+use std::sync::{Arc, Mutex};
 
 #[derive(Clone, Collect)]
 #[collect(no_drop)]
@@ -31,13 +25,13 @@ pub struct JSSet<'gc> {
 #[derive(Clone, Collect)]
 #[collect(no_drop)]
 pub struct JSWeakMap<'gc> {
-    pub entries: Vec<(gc_arena::GcWeak<'gc, GcCell<JSObjectData<'gc>>>, Value<'gc>)>,
+    pub entries: Vec<(GcWeak<'gc, GcCell<JSObjectData<'gc>>>, Value<'gc>)>,
 }
 
 #[derive(Clone, Collect)]
 #[collect(no_drop)]
 pub struct JSWeakSet<'gc> {
-    pub values: Vec<gc_arena::GcWeak<'gc, GcCell<JSObjectData<'gc>>>>,
+    pub values: Vec<GcWeak<'gc, GcCell<JSObjectData<'gc>>>>,
 }
 
 #[derive(Clone, Collect)]
@@ -108,7 +102,7 @@ pub enum GeneratorState<'gc> {
 }
 
 pub type JSObjectDataPtr<'gc> = GcPtr<'gc, JSObjectData<'gc>>;
-pub type JSObjectDataWeakPtr<'gc> = gc_arena::Gc<'gc, GcCell<JSObjectData<'gc>>>;
+pub type JSObjectDataWeakPtr<'gc> = Gc<'gc, GcCell<JSObjectData<'gc>>>;
 
 #[inline]
 pub fn new_js_object_data<'gc>(mc: &MutationContext<'gc>) -> JSObjectDataPtr<'gc> {
@@ -126,8 +120,8 @@ pub struct JSObjectData<'gc> {
     pub is_function_scope: bool,
 }
 
-unsafe impl<'gc> gc_arena::Collect<'gc> for JSObjectData<'gc> {
-    fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {
+unsafe impl<'gc> Collect<'gc> for JSObjectData<'gc> {
+    fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {
         for (k, v) in &self.properties {
             k.trace(cc);
             (*v.borrow()).trace(cc);
@@ -387,7 +381,7 @@ impl From<&String> for Value<'_> {
 }
 
 unsafe impl<'gc> Collect<'gc> for Value<'gc> {
-    fn trace<T: Trace<'gc>>(&self, cc: &mut T) {
+    fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {
         match self {
             Value::Object(obj) => obj.trace(cc),
             Value::Closure(cl) => cl.trace(cc),
@@ -582,6 +576,25 @@ pub fn env_set<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>, key:
     Ok(())
 }
 
+// Helper: Check whether the given object has an own property corresponding to a
+// given JS `Value` (as passed to hasOwnProperty / propertyIsEnumerable). This
+// centralizes conversion from various `Value` variants (String/Number/Boolean/
+// Undefined/Symbol/other) to a `PropertyKey` and calls `get_own_property`.
+// Returns true if an own property exists.
+pub fn has_own_property_value<'gc>(obj: &JSObjectDataPtr<'gc>, key_val: &Value<'gc>) -> bool {
+    match key_val {
+        Value::String(s) => get_own_property(obj, &utf16_to_utf8(s).into()).is_some(),
+        Value::Number(n) => get_own_property(obj, &n.to_string().into()).is_some(),
+        Value::Boolean(b) => get_own_property(obj, &b.to_string().into()).is_some(),
+        Value::Undefined => get_own_property(obj, &"undefined".into()).is_some(),
+        Value::Symbol(sd) => {
+            let sym_key = PropertyKey::Symbol(sd.clone());
+            get_own_property(obj, &sym_key).is_some()
+        }
+        other => get_own_property(obj, &value_to_string(other).into()).is_some(),
+    }
+}
+
 pub fn env_set_recursive<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>, key: &str, val: Value<'gc>) -> Result<(), JSError> {
     let mut current = *env;
     loop {
diff --git a/src/js_array.rs b/src/js_array.rs
@@ -1,12 +1,12 @@
 #![allow(warnings)]
 
+use crate::core::MutationContext;
 use crate::{
     core::{JSObjectDataPtr, PropertyKey, env_set, js_error::EvalError, new_js_object_data},
     error::JSError,
     raise_eval_error, raise_range_error,
     unicode::{utf8_to_utf16, utf16_to_utf8},
 };
-use gc_arena::Mutation as MutationContext;
 
 use crate::core::{
     Expr, Value, evaluate_expr, evaluate_statements, get_own_property, obj_get_key_value, obj_set_key_value, obj_set_rc,
diff --git a/src/js_math.rs b/src/js_math.rs
@@ -1,6 +1,6 @@
+use crate::core::MutationContext;
 use crate::core::{JSObjectDataPtr, Value, env_set, new_js_object_data, obj_set_key_value};
 use crate::error::JSError;
-use gc_arena::Mutation as MutationContext;
 
 /// Create the Math object with all mathematical constants and functions
 pub fn initialize_math<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>) -> Result<(), JSError> {
diff --git a/src/js_number.rs b/src/js_number.rs
@@ -1,9 +1,9 @@
 #![allow(clippy::collapsible_if, clippy::collapsible_match)]
 
+use crate::core::{Collect, Gc, GcCell, GcPtr, MutationContext, Trace};
 use crate::core::{Expr, JSObjectDataPtr, Value, evaluate_expr, new_js_object_data, obj_get_key_value, obj_set_key_value, to_primitive};
 use crate::error::JSError;
 use crate::unicode::{utf8_to_utf16, utf16_to_utf8};
-use gc_arena::Mutation as MutationContext;
 
 /// Create the Number object with all number constants and functions
 pub fn make_number_object<'gc>(mc: &MutationContext<'gc>) -> Result<JSObjectDataPtr<'gc>, JSError> {
diff --git a/src/js_object.rs b/src/js_object.rs
@@ -4,11 +4,11 @@ use crate::core::{
     ClosureData, DestructuringElement, Expr, JSObjectDataPtr, PropertyKey, Statement, Value, evaluate_expr, get_well_known_symbol_rc,
     new_js_object_data, obj_get_key_value, obj_set_key_value, prepare_closure_call_env, prepare_function_call_env, value_to_string,
 };
+use crate::core::{Collect, Gc, GcCell, GcPtr, MutationContext, Trace};
 use crate::error::JSError;
 use crate::js_array::{get_array_length, is_array, set_array_length};
 use crate::js_date::is_date_object;
 use crate::unicode::{utf8_to_utf16, utf16_to_utf8};
-use gc_arena::Mutation as MutationContext;
 use std::rc::Rc;
 
 fn define_property_internal<'gc>(
@@ -443,12 +443,12 @@ pub fn handle_object_method<'gc>(
                                 if let Some((gbody, genv, _)) = getter {
                                     // expose getter as function (Closure) on descriptor
                                     let closure_data = ClosureData::new(&Vec::new(), gbody, genv, None);
-                                    obj_set_key_value(mc, &desc_obj, &"get".into(), Value::Closure(gc_arena::Gc::new(mc, closure_data)))?;
+                                    obj_set_key_value(mc, &desc_obj, &"get".into(), Value::Closure(Gc::new(mc, closure_data)))?;
                                 }
                                 if let Some((sparams, sbody, senv, _)) = setter {
                                     // expose setter as function (Closure) on descriptor
                                     let closure_data = ClosureData::new(sparams, sbody, senv, None);
-                                    obj_set_key_value(mc, &desc_obj, &"set".into(), Value::Closure(gc_arena::Gc::new(mc, closure_data)))?;
+                                    obj_set_key_value(mc, &desc_obj, &"set".into(), Value::Closure(Gc::new(mc, closure_data)))?;
                                 }
                                 // flags: enumerable depends on object's non-enumerable set
                                 let enum_flag = Value::Boolean(obj.borrow().is_enumerable(key));
@@ -942,7 +942,7 @@ pub(crate) fn handle_value_of_method<'gc>(
         Value::Function(name) => Ok(Value::Function(name.clone())),
         Value::Closure(data) | Value::AsyncClosure(data) => {
             let closure_data = ClosureData::new(&data.params, &data.body, &data.env, None);
-            Ok(Value::Closure(gc_arena::Gc::new(mc, closure_data)))
+            Ok(Value::Closure(Gc::new(mc, closure_data)))
         }
         Value::ClassDefinition(class_def) => Ok(Value::ClassDefinition(class_def.clone())),
         Value::Getter(body, env, _) => Ok(Value::Getter(body.clone(), env.clone(), None)),
@@ -960,7 +960,7 @@ pub(crate) fn handle_value_of_method<'gc>(
         Value::WeakSet(weakset) => Ok(Value::WeakSet(weakset.clone())),
         Value::GeneratorFunction(_, data) => {
             let closure_data = ClosureData::new(&data.params, &data.body, &data.env, None);
-            Ok(Value::GeneratorFunction(None, gc_arena::Gc::new(mc, closure_data)))
+            Ok(Value::GeneratorFunction(None, Gc::new(mc, closure_data)))
         }
         Value::Generator(generator) => Ok(Value::Generator(generator.clone())),
         Value::Proxy(proxy) => Ok(Value::Proxy(proxy.clone())),
@@ -999,10 +999,10 @@ pub(crate) fn handle_object_prototype_builtin<'gc>(
             let target_val = crate::core::evaluate_expr(mc, env, &args[0])?;
             match target_val {
                 Value::Object(target_map) => {
-                    let mut current_opt: Option<gc_arena::Gc<'gc, gc_arena::lock::RefLock<crate::core::JSObjectData<'gc>>>> =
+                    let mut current_opt: Option<Gc<'gc, GcCell<crate::core::JSObjectData<'gc>>>> =
                         target_map.borrow().prototype.clone().and_then(|w| w.upgrade());
                     while let Some(parent) = current_opt {
-                        if gc_arena::Gc::ptr_eq(parent, object) {
+                        if Gc::ptr_eq(parent, object) {
                             return Ok(Some(Value::Boolean(true)));
                         }
                         current_opt = parent.borrow().prototype.clone().and_then(|w| w.upgrade());
diff --git a/src/repl.rs b/src/repl.rs

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,11 @@`
`1`		`-use crate::core::Value;`
`2`		`-use crate::core::gc::GcPtr;`
`3`		`-use gc_arena::Collect;`
	`1`	`+use crate::core::SymbolData;`
	`2`	`+use crate::core::{Collect, Gc};`
`4`	`3`
`5`	`4`	`#[derive(Clone, Debug, Collect)]`
`6`	`5`	`#[collect(no_drop)]`
`7`	`6`	`pub enum PropertyKey<'gc> {`
`8`	`7`	`String(String),`
`9`		`- Symbol(GcPtr<'gc, Value<'gc>>),`
	`8`	`+ Symbol(Gc<'gc, SymbolData>),`
`10`	`9`	`}`
`11`	`10`
`12`	`11`	`impl<'gc> From<&str> for PropertyKey<'gc> {`
`@@ -31,13 +30,7 @@ impl<'gc> PartialEq for PropertyKey<'gc> {`
`31`	`30`	`fn eq(&self, other: &Self) -> bool {`
`32`	`31`	`match (self, other) {`
`33`	`32`	`(PropertyKey::String(s1), PropertyKey::String(s2)) => s1 == s2,`
`34`		`- (PropertyKey::Symbol(sym1), PropertyKey::Symbol(sym2)) => {`
`35`		`- if let (Value::Symbol(s1), Value::Symbol(s2)) = (&sym1.borrow(), &sym2.borrow()) {`
`36`		`- gc_arena::Gc::ptr_eq(s1, s2)`
`37`		`- } else {`
`38`		`- false`
`39`		`- }`
`40`		`- }`
	`33`	`+ (PropertyKey::Symbol(sym1), PropertyKey::Symbol(sym2)) => Gc::ptr_eq(sym1, sym2),`
`41`	`34`	`_ => false,`
`42`	`35`	`}`
`43`	`36`	`}`
`@@ -54,9 +47,7 @@ impl<'gc> std::hash::Hash for PropertyKey<'gc> {`
`54`	`47`	`}`
`55`	`48`	`PropertyKey::Symbol(sym) => {`
`56`	`49`	`1u8.hash(state);`
`57`		`- if let Value::Symbol(s) = &*sym.borrow() {`
`58`		`- gc_arena::Gc::as_ptr(*s).hash(state);`
`59`		`- }`
	`50`	`+ Gc::as_ptr(*sym).hash(state);`
`60`	`51`	`}`
`61`	`52`	`}`
`62`	`53`	`}`
`@@ -66,7 +57,7 @@ impl<'gc> std::fmt::Display for PropertyKey<'gc> {`
`66`	`57`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`67`	`58`	`match self {`
`68`	`59`	`PropertyKey::String(s) => write!(f, "{}", s),`
`69`		`- PropertyKey::Symbol(ptr) => write!(f, "[symbol {:p}]", gc_arena::Gc::as_ptr(*ptr)),`
	`60`	`+ PropertyKey::Symbol(sym) => write!(f, "[symbol {:p}]", Gc::as_ptr(*sym)),`
`70`	`61`	`}`
`71`	`62`	`}`
`72`	`63`	`}`
`@@ -75,7 +66,7 @@ impl<'gc> AsRef<str> for PropertyKey<'gc> {`
`75`	`66`	`fn as_ref(&self) -> &str {`
`76`	`67`	`match self {`
`77`	`68`	`PropertyKey::String(s) => s,`
`78`		`- PropertyKey::Symbol(_ptr) => todo!("Cannot convert Symbol to &str"),`
	`69`	`+ PropertyKey::Symbol(_sym) => todo!("Cannot convert Symbol to &str"),`
`79`	`70`	`}`
`80`	`71`	`}`
`81`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`use crate::core::TemplatePart;`
	`2`	`+use crate::core::{Collect, GcTrace};`
`2`	`3`
`3`	`4`	`#[derive(Clone, Debug)]`
`4`	`5`	`pub struct Statement {`
`@@ -48,14 +49,14 @@ impl From<StatementKind> for Statement {`
`48`	`49`	`}`
`49`	`50`	`}`
`50`	`51`
`51`		`-unsafe impl<'gc> gc_arena::Collect<'gc> for Statement {`
`52`		`- fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {`
	`52`	`+unsafe impl<'gc> Collect<'gc> for Statement {`
	`53`	`+ fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {`
`53`	`54`	`crate::core::gc::trace_stmt(cc, self);`
`54`	`55`	`}`
`55`	`56`	`}`
`56`	`57`
`57`		`-unsafe impl<'gc> gc_arena::Collect<'gc> for StatementKind {`
`58`		`- fn trace<T: gc_arena::collect::Trace<'gc>>(&self, _cc: &mut T) {`
	`58`	`+unsafe impl<'gc> Collect<'gc> for StatementKind {`
	`59`	`+ fn trace<T: GcTrace<'gc>>(&self, _cc: &mut T) {`
`59`	`60`	`// Handled via Statement trace`
`60`	`61`	`}`
`61`	`62`	`}`
`@@ -136,8 +137,8 @@ pub enum Expr {`
`136`	`137`	`ValuePlaceholder,`
`137`	`138`	`}`
`138`	`139`
`139`		`-unsafe impl<'gc> gc_arena::Collect<'gc> for Expr {`
`140`		`- fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {`
	`140`	`+unsafe impl<'gc> Collect<'gc> for Expr {`
	`141`	`+ fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {`
`141`	`142`	`crate::core::gc::trace_expr(cc, self);`
`142`	`143`	`}`
`143`	`144`	`}`
`@@ -169,8 +170,8 @@ pub enum BinaryOp {`
`169`	`170`	`Pow,`
`170`	`171`	`}`
`171`	`172`
`172`		`-unsafe impl<'gc> gc_arena::Collect<'gc> for BinaryOp {`
`173`		`- fn trace<T: gc_arena::collect::Trace<'gc>>(&self, _cc: &mut T) {}`
	`173`	`+unsafe impl<'gc> Collect<'gc> for BinaryOp {`
	`174`	`+ fn trace<T: GcTrace<'gc>>(&self, _cc: &mut T) {}`
`174`	`175`	`}`
`175`	`176`
`176`	`177`	`#[derive(Debug, Clone)]`
`@@ -238,8 +239,8 @@ pub enum DestructuringElement {`
`238`	`239`	`NestedObject(Vec<DestructuringElement>),`
`239`	`240`	`}`
`240`	`241`
`241`		`-unsafe impl<'gc> gc_arena::Collect<'gc> for DestructuringElement {`
`242`		`- fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {`
	`242`	`+unsafe impl<'gc> Collect<'gc> for DestructuringElement {`
	`243`	`+ fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {`
`243`	`244`	`match self {`
`244`	`245`	`DestructuringElement::Variable(_, e) => {`
`245`	`246`	`if let Some(e) = e {`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
	`1`	`+use crate::core::{Collect, GcTrace};`
`1`	`2`	`use crate::{JSError, raise_tokenize_error};`
`2`		`-use gc_arena::{Collect, collect::Trace};`
`3`	`3`	`use num_bigint::BigInt;`
`4`	`4`	`use num_traits::{Num, ToPrimitive};`
`5`	`5`
`@@ -195,7 +195,7 @@ pub struct TokenData {`
`195`	`195`	`unsafe impl<'gc> Collect<'gc> for TokenData {`
`196`	`196`	`const NEEDS_TRACE: bool = false;`
`197`	`197`
`198`		`- fn trace<'a, T: Trace<'gc>>(&self, _cc: &mut T) {`
	`198`	`+ fn trace<'a, T: GcTrace<'gc>>(&self, _cc: &mut T) {`
`199`	`199`	`// do not trace token to break cycle`
`200`	`200`	`}`
`201`	`201`	`}`