git.delta.rocks / jrsonnet / refs/commits / a9d1e03758ef

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -100,27 +100,6 @@
 ]
 
 [[package]]
-name = "gc"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3edaac0f5832202ebc99520cb77c932248010c4645d20be1dc62d6579f5b3752"
-dependencies = [
- "gc_derive",
-]
-
-[[package]]
-name = "gc_derive"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60df8444f094ff7885631d80e78eb7d88c3c2361a98daaabb06256e4500db941"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "synstructure",
-]
-
-[[package]]
 name = "hashbrown"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -190,7 +169,7 @@
  "anyhow",
  "base64",
  "bincode",
- "gc",
+ "jrsonnet-gc",
  "jrsonnet-interner",
  "jrsonnet-parser",
  "jrsonnet-stdlib",
@@ -204,10 +183,31 @@
 ]
 
 [[package]]
+name = "jrsonnet-gc"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68da8bc2f00117b1373bb8877af03b1d391e4c4800e6585d7279e5b99c919dde"
+dependencies = [
+ "jrsonnet-gc-derive",
+]
+
+[[package]]
+name = "jrsonnet-gc-derive"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adcba9c387b64b054f06cc4d724905296e21edeeb7506847f3299117a2d92d12"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
 name = "jrsonnet-interner"
 version = "0.3.8"
 dependencies = [
- "gc",
+ "jrsonnet-gc",
  "rustc-hash",
  "serde",
 ]
@@ -216,7 +216,7 @@
 name = "jrsonnet-parser"
 version = "0.3.8"
 dependencies = [
- "gc",
+ "jrsonnet-gc",
  "jrsonnet-interner",
  "jrsonnet-stdlib",
  "peg",
@@ -232,7 +232,7 @@
 name = "jrsonnet-types"
 version = "0.3.8"
 dependencies = [
- "gc",
+ "jrsonnet-gc",
  "peg",
 ]
 
@@ -240,8 +240,8 @@
 name = "jsonnet"
 version = "0.3.8"
 dependencies = [
- "gc",
  "jrsonnet-evaluator",
+ "jrsonnet-gc",
  "jrsonnet-parser",
 ]
 

--- a/bindings/jsonnet/Cargo.toml
+++ b/bindings/jsonnet/Cargo.toml
@@ -10,7 +10,7 @@
 [dependencies]
 jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.8" }
 jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.8" }
-gc = { version = "0.4.1", features = ["derive"] }
+jrsonnet-gc = { version = "0.4.2", features = ["derive"] }
 
 [lib]
 crate-type = ["cdylib"]

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -1,9 +1,9 @@
-use gc::{unsafe_empty_trace, Finalize, Gc, Trace};
 use jrsonnet_evaluator::{
 	error::{Error, LocError},
 	native::{NativeCallback, NativeCallbackHandler},
 	EvaluationState, Val,
 };
+use jrsonnet_gc::{unsafe_empty_trace, Finalize, Gc, Trace};
 use jrsonnet_parser::{Param, ParamsDesc};
 use std::{
 	ffi::{c_void, CStr},

--- a/bindings/jsonnet/src/val_make.rs
+++ b/bindings/jsonnet/src/val_make.rs
@@ -1,7 +1,7 @@
 //! Create values in VM
 
-use gc::Gc;
 use jrsonnet_evaluator::{ArrValue, EvaluationState, ObjValue, Val};
+use jrsonnet_gc::Gc;
 use std::{
 	ffi::CStr,
 	os::raw::{c_char, c_double, c_int},

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -2,8 +2,8 @@
 //! Only tested with variables, which haven't altered by code before appearing here
 //! In jrsonnet every value is immutable, and this code is probally broken
 
-use gc::Gc;
 use jrsonnet_evaluator::{ArrValue, EvaluationState, LazyBinding, LazyVal, ObjMember, Val};
+use jrsonnet_gc::Gc;
 use jrsonnet_parser::Visibility;
 use std::{ffi::CStr, os::raw::c_char};
 

--- a/crates/jrsonnet-evaluator/Cargo.toml
+++ b/crates/jrsonnet-evaluator/Cargo.toml
@@ -35,7 +35,7 @@
 rustc-hash = "1.1.0"
 
 thiserror = "1.0"
-gc = { version = "0.4.1", features = ["derive"] }
+jrsonnet-gc = { version = "0.4.2", features = ["derive"] }
 
 [dependencies.anyhow]
 version = "1.0"

--- a/crates/jrsonnet-evaluator/src/builtin/format.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/format.rs
@@ -2,12 +2,13 @@
 #![allow(clippy::too_many_arguments)]
 
 use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};
-use gc::{Finalize, Trace};
+use jrsonnet_gc::Trace;
 use jrsonnet_interner::IStr;
 use jrsonnet_types::ValType;
 use thiserror::Error;
 
-#[derive(Debug, Clone, Error, Trace, Finalize)]
+#[derive(Debug, Clone, Error, Trace)]
+#[trivially_drop]
 pub enum FormatError {
 	#[error("truncated format code")]
 	TruncatedFormatCode,

--- a/crates/jrsonnet-evaluator/src/builtin/mod.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/mod.rs
@@ -5,7 +5,7 @@
 	EvaluationState, FuncVal, LazyVal, Val,
 };
 use format::{format_arr, format_obj};
-use gc::Gc;
+use jrsonnet_gc::Gc;
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{ArgsDesc, BinaryOpType, ExprLocation};
 use jrsonnet_types::ty;
@@ -454,7 +454,7 @@
 		0, rest: ty!(any);
 	], {
 		println!("GC start");
-		gc::force_collect();
+		jrsonnet_gc::force_collect();
 		println!("GC done");
 
 		Ok(rest)

--- a/crates/jrsonnet-evaluator/src/builtin/sort.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/sort.rs
@@ -2,7 +2,7 @@
 	error::{Error, LocError, Result},
 	throw, Context, FuncVal, Val,
 };
-use gc::{Finalize, Gc, Trace};
+use jrsonnet_gc::{Finalize, Gc, Trace};
 
 #[derive(Debug, Clone, thiserror::Error, Trace, Finalize)]
 pub enum SortError {

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -2,13 +2,14 @@
 	error::Error::*, map::LayeredHashMap, FutureWrapper, LazyBinding, LazyVal, ObjValue, Result,
 	Val,
 };
-use gc::{Finalize, Gc, Trace};
+use jrsonnet_gc::{Gc, Trace};
 use jrsonnet_interner::IStr;
 use rustc_hash::FxHashMap;
 use std::fmt::Debug;
 use std::hash::BuildHasherDefault;
 
-#[derive(Clone, Trace, Finalize)]
+#[derive(Clone, Trace)]
+#[trivially_drop]
 pub struct ContextCreator(pub Context, pub FutureWrapper<FxHashMap<IStr, LazyBinding>>);
 impl ContextCreator {
 	pub fn create(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<Context> {
@@ -21,12 +22,13 @@
 	}
 }
 
-#[derive(Trace, Finalize)]
+#[derive(Trace)]
+#[trivially_drop]
 struct ContextInternals {
 	dollar: Option<ObjValue>,
 	this: Option<ObjValue>,
 	super_obj: Option<ObjValue>,
-	bindings: LayeredHashMap<LazyVal>,
+	bindings: LayeredHashMap,
 }
 impl Debug for ContextInternals {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -34,7 +36,8 @@
 	}
 }
 
-#[derive(Debug, Clone, Trace, Finalize)]
+#[derive(Debug, Clone, Trace)]
+#[trivially_drop]
 pub struct Context(Gc<ContextInternals>);
 impl Context {
 	pub fn new_future() -> FutureWrapper<Self> {

--- a/crates/jrsonnet-evaluator/src/dynamic.rs
+++ b/crates/jrsonnet-evaluator/src/dynamic.rs
@@ -1,6 +1,7 @@
-use gc::{Finalize, Gc, GcCell, Trace};
+use jrsonnet_gc::{Gc, GcCell, Trace};
 
-#[derive(Clone, Trace, Finalize)]
+#[derive(Clone, Trace)]
+#[trivially_drop]
 pub struct FutureWrapper<V: Trace + 'static>(pub Gc<GcCell<Option<V>>>);
 impl<T: Trace + 'static> FutureWrapper<T> {
 	pub fn new() -> Self {

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -2,7 +2,7 @@
 	builtin::{format::FormatError, sort::SortError},
 	typed::TypeLocError,
 };
-use gc::{Finalize, Trace};
+use jrsonnet_gc::Trace;
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};
 use jrsonnet_types::ValType;
@@ -12,7 +12,8 @@
 };
 use thiserror::Error;
 
-#[derive(Error, Debug, Clone, Trace, Finalize)]
+#[derive(Error, Debug, Clone, Trace)]
+#[trivially_drop]
 pub enum Error {
 	#[error("intrinsic not found: {0}")]
 	IntrinsicNotFound(IStr),
@@ -149,15 +150,18 @@
 	}
 }
 
-#[derive(Clone, Debug, Trace, Finalize)]
+#[derive(Clone, Debug, Trace)]
+#[trivially_drop]
 pub struct StackTraceElement {
 	pub location: Option<ExprLocation>,
 	pub desc: String,
 }
-#[derive(Debug, Clone, Trace, Finalize)]
+#[derive(Debug, Clone, Trace)]
+#[trivially_drop]
 pub struct StackTrace(pub Vec<StackTraceElement>);
 
-#[derive(Debug, Clone, Trace, Finalize)]
+#[derive(Debug, Clone, Trace)]
+#[trivially_drop]
 pub struct LocError(Box<(Error, StackTrace)>);
 impl LocError {
 	pub fn new(e: Error) -> Self {

--- a/crates/jrsonnet-evaluator/src/evaluate.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate.rs
@@ -3,7 +3,7 @@
 	FuncDesc, FuncVal, FutureWrapper, LazyBinding, LazyVal, LazyValValue, ObjMember, ObjValue,
 	ObjectAssertion, Result, Val,
 };
-use gc::{custom_trace, Finalize, Gc, Trace};
+use jrsonnet_gc::{Gc, Trace};
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{
 	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,
@@ -22,21 +22,14 @@
 	if let Some(params) = &b.params {
 		let params = params.clone();
 
+		#[derive(Trace)]
+		#[trivially_drop]
 		struct LazyMethodBinding {
 			context_creator: FutureWrapper<Context>,
 			name: IStr,
 			params: ParamsDesc,
 			value: LocExpr,
 		}
-		impl Finalize for LazyMethodBinding {}
-		unsafe impl Trace for LazyMethodBinding {
-			custom_trace!(this, {
-				mark(&this.context_creator);
-				mark(&this.name);
-				mark(&this.params);
-				mark(&this.value);
-			});
-		}
 		impl LazyValValue for LazyMethodBinding {
 			fn get(self: Box<Self>) -> Result<Val> {
 				Ok(evaluate_method(
@@ -55,19 +48,13 @@
 			value: b.value.clone(),
 		}))
 	} else {
+		#[derive(Trace)]
+		#[trivially_drop]
 		struct LazyNamedBinding {
 			context_creator: FutureWrapper<Context>,
 			name: IStr,
 			value: LocExpr,
 		}
-		impl Finalize for LazyNamedBinding {}
-		unsafe impl Trace for LazyNamedBinding {
-			custom_trace!(this, {
-				mark(&this.context_creator);
-				mark(&this.name);
-				mark(&this.value);
-			});
-		}
 		impl LazyValValue for LazyNamedBinding {
 			fn get(self: Box<Self>) -> Result<Val> {
 				evaluate_named(self.context_creator.unwrap(), &self.value, self.name)
@@ -86,6 +73,8 @@
 	if let Some(params) = &b.params {
 		let params = params.clone();
 
+		#[derive(Trace)]
+		#[trivially_drop]
 		struct BindableMethodLazyVal {
 			this: Option<ObjValue>,
 			super_obj: Option<ObjValue>,
@@ -94,17 +83,6 @@
 			name: IStr,
 			params: ParamsDesc,
 			value: LocExpr,
-		}
-		impl Finalize for BindableMethodLazyVal {}
-		unsafe impl Trace for BindableMethodLazyVal {
-			custom_trace!(this, {
-				mark(&this.this);
-				mark(&this.super_obj);
-				mark(&this.context_creator);
-				mark(&this.name);
-				mark(&this.params);
-				mark(&this.value);
-			});
 		}
 		impl LazyValValue for BindableMethodLazyVal {
 			fn get(self: Box<Self>) -> Result<Val> {
@@ -117,7 +95,8 @@
 			}
 		}
 
-		#[derive(Trace, Finalize)]
+		#[derive(Trace)]
+		#[trivially_drop]
 		struct BindableMethod {
 			context_creator: ContextCreator,
 			name: IStr,
@@ -148,6 +127,8 @@
 			}))),
 		)
 	} else {
+		#[derive(Trace)]
+		#[trivially_drop]
 		struct BindableNamedLazyVal {
 			this: Option<ObjValue>,
 			super_obj: Option<ObjValue>,
@@ -156,16 +137,6 @@
 			name: IStr,
 			value: LocExpr,
 		}
-		impl Finalize for BindableNamedLazyVal {}
-		unsafe impl Trace for BindableNamedLazyVal {
-			custom_trace!(this, {
-				mark(&this.this);
-				mark(&this.super_obj);
-				mark(&this.context_creator);
-				mark(&this.name);
-				mark(&this.value);
-			});
-		}
 		impl LazyValValue for BindableNamedLazyVal {
 			fn get(self: Box<Self>) -> Result<Val> {
 				evaluate_named(
@@ -176,7 +147,8 @@
 			}
 		}
 
-		#[derive(Trace, Finalize)]
+		#[derive(Trace)]
+		#[trivially_drop]
 		struct BindableNamed {
 			context_creator: ContextCreator,
 			name: IStr,
@@ -414,7 +386,8 @@
 				}
 				let name = name.unwrap();
 
-				#[derive(Trace, Finalize)]
+				#[derive(Trace)]
+				#[trivially_drop]
 				struct ObjMemberBinding {
 					context_creator: ContextCreator,
 					value: LocExpr,
@@ -458,7 +431,8 @@
 					continue;
 				}
 				let name = name.unwrap();
-				#[derive(Trace, Finalize)]
+				#[derive(Trace)]
+				#[trivially_drop]
 				struct ObjMemberBinding {
 					context_creator: ContextCreator,
 					value: LocExpr,
@@ -496,16 +470,11 @@
 			}
 			Member::BindStmt(_) => {}
 			Member::AssertStmt(stmt) => {
+				#[derive(Trace)]
+				#[trivially_drop]
 				struct ObjectAssert {
 					context_creator: ContextCreator,
 					assert: AssertStmt,
-				}
-				impl Finalize for ObjectAssert {}
-				unsafe impl Trace for ObjectAssert {
-					custom_trace!(this, {
-						mark(&this.context_creator);
-						mark(&this.assert);
-					});
 				}
 				impl ObjectAssertion for ObjectAssert {
 					fn run(
@@ -558,7 +527,8 @@
 				match key {
 					Val::Null => {}
 					Val::Str(n) => {
-						#[derive(Trace, Finalize)]
+						#[derive(Trace)]
+						#[trivially_drop]
 						struct ObjCompBinding {
 							context: Context,
 							value: LocExpr,
@@ -768,16 +738,11 @@
 			let mut out = Vec::with_capacity(items.len());
 			for item in items {
 				// TODO: Implement ArrValue::Lazy with same context for every element?
+				#[derive(Trace)]
+				#[trivially_drop]
 				struct ArrayElement {
 					context: Context,
 					item: LocExpr,
-				}
-				impl Finalize for ArrayElement {}
-				unsafe impl Trace for ArrayElement {
-					custom_trace!(this, {
-						mark(&this.context);
-						mark(&this.item);
-					});
 				}
 				impl LazyValValue for ArrayElement {
 					fn get(self: Box<Self>) -> Result<Val> {

--- a/crates/jrsonnet-evaluator/src/function.rs
+++ b/crates/jrsonnet-evaluator/src/function.rs
@@ -1,5 +1,5 @@
 use crate::{error::Error::*, evaluate, throw, Context, LazyVal, LazyValValue, Result, Val};
-use gc::{custom_trace, Finalize, Trace};
+use jrsonnet_gc::Trace;
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{ArgsDesc, LocExpr, ParamsDesc};
 use rustc_hash::FxHashMap;
@@ -55,16 +55,11 @@
 		let val = if tailstrict {
 			LazyVal::new_resolved(evaluate(ctx, expr)?)
 		} else {
+			#[derive(Trace)]
+			#[trivially_drop]
 			struct EvaluateLazyVal {
 				context: Context,
 				expr: LocExpr,
-			}
-			impl Finalize for EvaluateLazyVal {}
-			unsafe impl Trace for EvaluateLazyVal {
-				custom_trace!(this, {
-					mark(&this.context);
-					mark(&this.expr);
-				});
 			}
 			impl LazyValValue for EvaluateLazyVal {
 				fn get(self: Box<Self>) -> Result<Val> {
@@ -119,7 +114,8 @@
 			} else {
 				let body_ctx = body_ctx.clone();
 				let default = default.clone();
-				#[derive(Trace, Finalize)]
+				#[derive(Trace)]
+				#[trivially_drop]
 				struct EvaluateLazyVal {
 					body_ctx: Option<Context>,
 					default: LocExpr,

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -2,7 +2,7 @@
 	error::{Error::*, LocError, Result},
 	throw, LazyBinding, LazyVal, ObjMember, ObjValue, Val,
 };
-use gc::Gc;
+use jrsonnet_gc::Gc;
 use jrsonnet_parser::Visibility;
 use rustc_hash::FxHasher;
 use serde_json::{Map, Number, Value};

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -25,8 +25,8 @@
 use error::{Error::*, LocError, Result, StackTraceElement};
 pub use evaluate::*;
 pub use function::parse_function_call;
-use gc::{Finalize, Gc, Trace};
 pub use import::*;
+use jrsonnet_gc::{Finalize, Gc, Trace};
 pub use jrsonnet_interner::IStr;
 use jrsonnet_parser::*;
 use native::NativeCallback;

--- a/crates/jrsonnet-evaluator/src/map.rs
+++ b/crates/jrsonnet-evaluator/src/map.rs
@@ -1,32 +1,29 @@
-use gc::{Finalize, Gc, Trace};
+use jrsonnet_gc::{Gc, Trace};
 use jrsonnet_interner::IStr;
 use rustc_hash::FxHashMap;
 
-pub struct LayeredHashMapInternals<V: Trace + Finalize + 'static> {
-	parent: Option<LayeredHashMap<V>>,
-	current: FxHashMap<IStr, V>,
-}
+use crate::LazyVal;
 
-unsafe impl<V: Trace + Finalize + 'static> Trace for LayeredHashMapInternals<V> {
-	gc::custom_trace!(this, {
-		mark(&this.parent);
-		mark(&this.current);
-	});
+#[derive(Trace)]
+#[trivially_drop]
+pub struct LayeredHashMapInternals {
+	parent: Option<LayeredHashMap>,
+	current: FxHashMap<IStr, LazyVal>,
 }
-impl<V: Trace + Finalize + 'static> Finalize for LayeredHashMapInternals<V> {}
 
-#[derive(Trace, Finalize)]
-pub struct LayeredHashMap<V: Trace + Finalize + 'static>(Gc<LayeredHashMapInternals<V>>);
+#[derive(Trace)]
+#[trivially_drop]
+pub struct LayeredHashMap(Gc<LayeredHashMapInternals>);
 
-impl<V: Trace + 'static> LayeredHashMap<V> {
-	pub fn extend(self, new_layer: FxHashMap<IStr, V>) -> Self {
+impl LayeredHashMap {
+	pub fn extend(self, new_layer: FxHashMap<IStr, LazyVal>) -> Self {
 		Self(Gc::new(LayeredHashMapInternals {
 			parent: Some(self),
 			current: new_layer,
 		}))
 	}
 
-	pub fn get(&self, key: &IStr) -> Option<&V> {
+	pub fn get(&self, key: &IStr) -> Option<&LazyVal> {
 		(self.0)
 			.current
 			.get(key)
@@ -34,13 +31,13 @@
 	}
 }
 
-impl<V: Trace + 'static> Clone for LayeredHashMap<V> {
+impl Clone for LayeredHashMap {
 	fn clone(&self) -> Self {
 		Self(self.0.clone())
 	}
 }
 
-impl<V: Trace + 'static> Default for LayeredHashMap<V> {
+impl Default for LayeredHashMap {
 	fn default() -> Self {
 		Self(Gc::new(LayeredHashMapInternals {
 			parent: None,

--- a/crates/jrsonnet-evaluator/src/native.rs
+++ b/crates/jrsonnet-evaluator/src/native.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::type_complexity)]
 
 use crate::{error::Result, Val};
-use gc::{Finalize, Trace};
+use jrsonnet_gc::Trace;
 use jrsonnet_parser::ParamsDesc;
 use std::fmt::Debug;
 use std::path::Path;
@@ -11,7 +11,8 @@
 	fn call(&self, from: Option<Rc<Path>>, args: &[Val]) -> Result<Val>;
 }
 
-#[derive(Trace, Finalize)]
+#[derive(Trace)]
+#[trivially_drop]
 pub struct NativeCallback {
 	pub params: ParamsDesc,
 	handler: Box<dyn NativeCallbackHandler>,

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -1,12 +1,13 @@
 use crate::{evaluate_add_op, LazyBinding, Result, Val};
-use gc::{Finalize, Gc, GcCell, Trace};
+use jrsonnet_gc::{Gc, GcCell, Trace};
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{ExprLocation, Visibility};
 use rustc_hash::{FxHashMap, FxHashSet};
 use std::hash::{Hash, Hasher};
 use std::{fmt::Debug, hash::BuildHasherDefault};
 
-#[derive(Debug, Trace, Finalize)]
+#[derive(Debug, Trace)]
+#[trivially_drop]
 pub struct ObjMember {
 	pub add: bool,
 	pub visibility: Visibility,
@@ -20,7 +21,8 @@
 
 // Field => This
 type CacheKey = (IStr, ObjValue);
-#[derive(Trace, Finalize)]
+#[derive(Trace)]
+#[trivially_drop]
 pub struct ObjValueInternals {
 	super_obj: Option<ObjValue>,
 	assertions: Gc<Vec<Box<dyn ObjectAssertion>>>,
@@ -30,7 +32,8 @@
 	value_cache: GcCell<FxHashMap<CacheKey, Option<Val>>>,
 }
 
-#[derive(Clone, Trace, Finalize)]
+#[derive(Clone, Trace)]
+#[trivially_drop]
 pub struct ObjValue(pub(crate) Gc<ObjValueInternals>);
 impl Debug for ObjValue {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -9,7 +9,7 @@
 	native::NativeCallback,
 	throw, with_state, Context, ObjValue, Result,
 };
-use gc::{custom_trace, Finalize, Gc, GcCell, Trace};
+use jrsonnet_gc::{Finalize, Gc, GcCell, Trace};
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};
 use jrsonnet_types::ValType;
@@ -19,25 +19,17 @@
 	fn get(self: Box<Self>) -> Result<Val>;
 }
 
+#[derive(Trace)]
+#[trivially_drop]
 enum LazyValInternals {
 	Computed(Val),
 	Errored(LocError),
 	Waiting(Box<dyn LazyValValue>),
 	Pending,
-}
-impl Finalize for LazyValInternals {}
-unsafe impl Trace for LazyValInternals {
-	custom_trace!(this, {
-		match &this {
-			LazyValInternals::Computed(v) => mark(v),
-			LazyValInternals::Errored(e) => mark(e),
-			LazyValInternals::Waiting(w) => mark(w),
-			LazyValInternals::Pending => {}
-		}
-	});
 }
 
-#[derive(Clone, Trace, Finalize)]
+#[derive(Clone, Trace)]
+#[trivially_drop]
 pub struct LazyVal(Gc<GcCell<LazyValInternals>>);
 impl LazyVal {
 	pub fn new(f: Box<dyn LazyValValue>) -> Self {
@@ -83,7 +75,8 @@
 	}
 }
 
-#[derive(Debug, PartialEq, Trace, Finalize)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct FuncDesc {
 	pub name: IStr,
 	pub ctx: Context,
@@ -91,7 +84,8 @@
 	pub body: LocExpr,
 }
 
-#[derive(Debug, Trace, Finalize)]
+#[derive(Debug, Trace)]
+#[trivially_drop]
 pub enum FuncVal {
 	/// Plain function implemented in jsonnet
 	Normal(FuncDesc),
@@ -195,22 +189,13 @@
 	String,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Trace)]
+#[trivially_drop]
 pub enum ArrValue {
 	Lazy(Gc<Vec<LazyVal>>),
 	Eager(Gc<Vec<Val>>),
 	Extended(Box<(Self, Self)>),
 }
-impl Finalize for ArrValue {}
-unsafe impl Trace for ArrValue {
-	custom_trace!(this, {
-		match &this {
-			ArrValue::Lazy(l) => mark(l),
-			ArrValue::Eager(e) => mark(e),
-			ArrValue::Extended(x) => mark(x),
-		}
-	});
-}
 impl ArrValue {
 	pub fn new_eager() -> Self {
 		Self::Eager(Gc::new(Vec::new()))
@@ -419,7 +404,8 @@
 	}
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Trace)]
+#[trivially_drop]
 pub enum Val {
 	Bool(bool),
 	Null,
@@ -429,21 +415,6 @@
 	Obj(ObjValue),
 	Func(Gc<FuncVal>),
 	DebugGcTraceValue(DebugGcTraceValue),
-}
-impl Finalize for Val {}
-unsafe impl Trace for Val {
-	custom_trace!(this, {
-		match &this {
-			Val::Bool(_) => {}
-			Val::Null => {}
-			Val::Str(_) => {}
-			Val::Num(_) => {}
-			Val::Arr(a) => mark(a),
-			Val::Obj(o) => mark(o),
-			Val::Func(f) => mark(f),
-			Val::DebugGcTraceValue(v) => mark(v),
-		}
-	});
 }
 
 macro_rules! matches_unwrap {

--- a/crates/jrsonnet-interner/Cargo.toml
+++ b/crates/jrsonnet-interner/Cargo.toml
@@ -9,4 +9,4 @@
 [dependencies]
 serde = { version = "1.0" }
 rustc-hash = "1.1.0"
-gc = { version = "0.4.1", features = ["derive"] }
+jrsonnet-gc = { version = "0.4.2", features = ["derive"] }

--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -1,4 +1,4 @@
-use gc::{unsafe_empty_trace, Finalize, Trace};
+use jrsonnet_gc::{unsafe_empty_trace, Finalize, Trace};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 use std::{

--- a/crates/jrsonnet-parser/Cargo.toml
+++ b/crates/jrsonnet-parser/Cargo.toml
@@ -18,7 +18,7 @@
 unescape = "0.1.0"
 
 serde = { version = "1.0", features = ["derive", "rc"], optional = true }
-gc = { version = "0.4.1", features = ["derive"] }
+jrsonnet-gc = { version = "0.4.2", features = ["derive"] }
 
 [dev-dependencies]
 jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.3.8" }

--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -1,4 +1,4 @@
-use gc::{unsafe_empty_trace, Finalize, Trace};
+use jrsonnet_gc::{unsafe_empty_trace, Finalize, Trace};
 use jrsonnet_interner::IStr;
 #[cfg(feature = "deserialize")]
 use serde::Deserialize;
@@ -13,21 +13,19 @@
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub enum FieldName {
 	/// {fixed: 2}
 	Fixed(IStr),
 	/// {["dyn"+"amic"]: 3}
 	Dyn(LocExpr),
 }
-impl Finalize for FieldName {}
-unsafe impl Trace for FieldName {
-	unsafe_empty_trace!();
-}
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Trace)]
+#[trivially_drop]
 pub enum Visibility {
 	/// :
 	Normal,
@@ -36,10 +34,6 @@
 	/// :::
 	Unhide,
 }
-impl Finalize for Visibility {}
-unsafe impl Trace for Visibility {
-	unsafe_empty_trace!();
-}
 
 impl Visibility {
 	pub fn is_visible(&self) -> bool {
@@ -49,16 +43,14 @@
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct AssertStmt(pub LocExpr, pub Option<LocExpr>);
-impl Finalize for AssertStmt {}
-unsafe impl Trace for AssertStmt {
-	unsafe_empty_trace!();
-}
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct FieldMember {
 	pub name: FieldName,
 	pub plus: bool,
@@ -66,36 +58,26 @@
 	pub visibility: Visibility,
 	pub value: LocExpr,
 }
-impl Finalize for FieldMember {}
-unsafe impl Trace for FieldMember {
-	unsafe_empty_trace!();
-}
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub enum Member {
 	Field(FieldMember),
 	BindStmt(BindSpec),
 	AssertStmt(AssertStmt),
 }
-impl Finalize for Member {}
-unsafe impl Trace for Member {
-	unsafe_empty_trace!();
-}
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Trace)]
+#[trivially_drop]
 pub enum UnaryOpType {
 	Plus,
 	Minus,
 	BitNot,
 	Not,
-}
-impl Finalize for UnaryOpType {}
-unsafe impl Trace for UnaryOpType {
-	unsafe_empty_trace!();
 }
 
 impl Display for UnaryOpType {
@@ -116,7 +98,8 @@
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Trace)]
+#[trivially_drop]
 pub enum BinaryOpType {
 	Mul,
 	Div,
@@ -145,10 +128,6 @@
 	And,
 	Or,
 }
-impl Finalize for BinaryOpType {}
-unsafe impl Trace for BinaryOpType {
-	unsafe_empty_trace!();
-}
 
 impl Display for BinaryOpType {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -183,22 +162,22 @@
 /// name, default value
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct Param(pub IStr, pub Option<LocExpr>);
-impl Finalize for Param {}
-unsafe impl Trace for Param {
-	unsafe_empty_trace!();
-}
 
 /// Defined function parameters
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 #[derive(Debug, Clone, PartialEq)]
 pub struct ParamsDesc(pub Rc<Vec<Param>>);
-impl Finalize for ParamsDesc {}
+
+/// Safety:
+/// AST is acyclic, and there should be no gc pointers
 unsafe impl Trace for ParamsDesc {
 	unsafe_empty_trace!();
 }
+impl Finalize for ParamsDesc {}
 
 impl Deref for ParamsDesc {
 	type Target = Vec<Param>;
@@ -209,21 +188,15 @@
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct Arg(pub Option<String>, pub LocExpr);
-impl Finalize for Arg {}
-unsafe impl Trace for Arg {
-	unsafe_empty_trace!();
-}
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct ArgsDesc(pub Vec<Arg>);
-impl Finalize for ArgsDesc {}
-unsafe impl Trace for ArgsDesc {
-	unsafe_empty_trace!();
-}
 
 impl Deref for ArgsDesc {
 	type Target = Vec<Arg>;
@@ -234,50 +207,39 @@
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Trace)]
+#[trivially_drop]
 pub struct BindSpec {
 	pub name: IStr,
 	pub params: Option<ParamsDesc>,
 	pub value: LocExpr,
-}
-impl Finalize for BindSpec {}
-unsafe impl Trace for BindSpec {
-	unsafe_empty_trace!();
 }
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct IfSpecData(pub LocExpr);
-impl Finalize for IfSpecData {}
-unsafe impl Trace for IfSpecData {
-	unsafe_empty_trace!();
-}
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct ForSpecData(pub IStr, pub LocExpr);
-impl Finalize for ForSpecData {}
-unsafe impl Trace for ForSpecData {
-	unsafe_empty_trace!();
-}
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub enum CompSpec {
 	IfSpec(IfSpecData),
 	ForSpec(ForSpecData),
-}
-impl Finalize for CompSpec {}
-unsafe impl Trace for CompSpec {
-	unsafe_empty_trace!();
 }
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct ObjComp {
 	pub pre_locals: Vec<BindSpec>,
 	pub key: LocExpr,
@@ -285,26 +247,20 @@
 	pub post_locals: Vec<BindSpec>,
 	pub compspecs: Vec<CompSpec>,
 }
-impl Finalize for ObjComp {}
-unsafe impl Trace for ObjComp {
-	unsafe_empty_trace!();
-}
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub enum ObjBody {
 	MemberList(Vec<Member>),
 	ObjComp(ObjComp),
-}
-impl Finalize for ObjBody {}
-unsafe impl Trace for ObjBody {
-	unsafe_empty_trace!();
 }
 
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, PartialEq, Clone, Copy, Trace)]
+#[trivially_drop]
 pub enum LiteralType {
 	This,
 	Super,
@@ -313,26 +269,20 @@
 	True,
 	False,
 }
-impl Finalize for LiteralType {}
-unsafe impl Trace for LiteralType {
-	unsafe_empty_trace!();
-}
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub struct SliceDesc {
 	pub start: Option<LocExpr>,
 	pub end: Option<LocExpr>,
 	pub step: Option<LocExpr>,
-}
-impl Finalize for SliceDesc {}
-unsafe impl Trace for SliceDesc {
-	unsafe_empty_trace!();
 }
 
 /// Syntax base
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Trace)]
+#[trivially_drop]
 pub enum Expr {
 	Literal(LiteralType),
 
@@ -396,20 +346,13 @@
 		cond_else: Option<LocExpr>,
 	},
 }
-impl Finalize for Expr {}
-unsafe impl Trace for Expr {
-	unsafe_empty_trace!();
-}
 
 /// file, begin offset, end offset
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Trace)]
+#[trivially_drop]
 pub struct ExprLocation(pub Rc<Path>, pub usize, pub usize);
-impl Finalize for ExprLocation {}
-unsafe impl Trace for ExprLocation {
-	unsafe_empty_trace!();
-}
 
 impl Debug for ExprLocation {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -422,10 +365,12 @@
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 #[derive(Clone, PartialEq)]
 pub struct LocExpr(pub Rc<Expr>, pub Option<ExprLocation>);
-impl Finalize for LocExpr {}
+/// Safety:
+/// AST is acyclic, and there should be no gc pointers
 unsafe impl Trace for LocExpr {
 	unsafe_empty_trace!();
 }
+impl Finalize for LocExpr {}
 
 impl Debug for LocExpr {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

--- a/crates/jrsonnet-types/Cargo.toml
+++ b/crates/jrsonnet-types/Cargo.toml
@@ -8,4 +8,4 @@
 
 [dependencies]
 peg = "0.7.0"
-gc = { version = "0.4.1", features = ["derive"] }
+jrsonnet-gc = { version = "0.4.2", features = ["derive"] }

--- a/crates/jrsonnet-types/src/lib.rs
+++ b/crates/jrsonnet-types/src/lib.rs
@@ -1,6 +1,6 @@
 #![allow(clippy::redundant_closure_call)]
 
-use gc::{unsafe_empty_trace, Finalize, Trace};
+use jrsonnet_gc::Trace;
 use std::fmt::Display;
 
 #[macro_export]
@@ -78,7 +78,8 @@
 	);
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Trace)]
+#[trivially_drop]
 pub enum ValType {
 	Bool,
 	Null,
@@ -87,10 +88,6 @@
 	Arr,
 	Obj,
 	Func,
-}
-impl Finalize for ValType {}
-unsafe impl Trace for ValType {
-	unsafe_empty_trace!();
 }
 
 impl ValType {
@@ -114,7 +111,8 @@
 	}
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Trace)]
+#[trivially_drop]
 pub enum ComplexValType {
 	Any,
 	Char,
@@ -127,10 +125,6 @@
 	UnionRef(&'static [ComplexValType]),
 	Sum(Vec<ComplexValType>),
 	SumRef(&'static [ComplexValType]),
-}
-impl Finalize for ComplexValType {}
-unsafe impl Trace for ComplexValType {
-	unsafe_empty_trace!();
 }
 
 impl From<ValType> for ComplexValType {