simplify DropWithHeap trait (#227)

davidhewitt · web-flow · commit 083af83d6191 · 2026-03-03T11:13:40.000Z
diff --git a/crates/monty-js/package-lock.json b/crates/monty-js/package-lock.json
diff --git a/crates/monty/src/args.rs b/crates/monty/src/args.rs
@@ -4,7 +4,7 @@ use crate::{
     MontyObject, ResourceTracker, defer_drop, defer_drop_mut,
     exception_private::{ExcType, RunError, RunResult, SimpleException},
     expressions::{ExprLoc, Identifier},
-    heap::{DropWithHeap, Heap, HeapGuard},
+    heap::{ContainsHeap, DropWithHeap, Heap, HeapGuard},
     intern::{Interns, StringId},
     parse::ParseError,
     types::{Dict, dict::DictIntoIter},
@@ -300,7 +300,7 @@ impl ArgValues {
 }
 
 impl DropWithHeap for ArgValues {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         match self {
             Self::Empty => {}
             Self::One(v) => v.drop_with_heap(heap),
@@ -384,7 +384,7 @@ impl Iterator for ArgPosIter {
 impl ExactSizeIterator for ArgPosIter {}
 
 impl DropWithHeap for ArgPosIter {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         match self {
             Self::Empty => {}
             Self::One(v1) => v1.drop_with_heap(heap),
@@ -464,7 +464,7 @@ impl KwargsValues {
 
 impl DropWithHeap for KwargsValues {
     /// Properly drops all values in the arguments, decrementing reference counts.
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         match self {
             Self::Empty => {}
             Self::Inline(kvs) => {
@@ -529,7 +529,7 @@ impl Iterator for KwargsValuesIter {
 impl ExactSizeIterator for KwargsValuesIter {}
 
 impl DropWithHeap for KwargsValuesIter {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         match self {
             Self::Empty => {}
             Self::Inline(iter) => {
diff --git a/crates/monty/src/heap.rs b/crates/monty/src/heap.rs
@@ -773,8 +773,8 @@ pub(crate) struct RecursionToken(());
 
 impl DropWithHeap for RecursionToken {
     #[inline]
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
-        heap.decr_recursion_depth();
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
+        heap.heap().decr_recursion_depth();
     }
 }
 
@@ -1779,56 +1779,51 @@ impl<T: ResourceTracker> ContainsHeap for Heap<T> {
 /// types that hold heap references.
 pub(crate) trait DropWithHeap: Sized {
     /// Consume `self` and decrement reference counts for any heap-allocated values contained within.
-    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
-        self.drop_with_concrete_heap(heap.heap_mut());
-    }
-
-    /// Consume `self` and decrement reference counts for any heap-allocated values contained within.
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>);
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H);
 }
 
 impl DropWithHeap for Value {
     #[inline]
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         Self::drop_with_heap(self, heap);
     }
 }
 
 impl<U: DropWithHeap> DropWithHeap for Option<U> {
     #[inline]
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         if let Some(value) = self {
             value.drop_with_heap(heap);
         }
     }
 }
 
 impl<U: DropWithHeap> DropWithHeap for Vec<U> {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         for value in self {
             value.drop_with_heap(heap);
         }
     }
 }
 
 impl<U: DropWithHeap> DropWithHeap for vec::IntoIter<U> {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         for value in self {
             value.drop_with_heap(heap);
         }
     }
 }
 
 impl<const N: usize> DropWithHeap for [Value; N] {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         for value in self {
             value.drop_with_heap(heap);
         }
     }
 }
 
 impl<U: DropWithHeap, V: DropWithHeap> DropWithHeap for (U, V) {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         let (left, right) = self;
         left.drop_with_heap(heap);
         right.drop_with_heap(heap);
diff --git a/crates/monty/src/signature.rs b/crates/monty/src/signature.rs
@@ -9,7 +9,7 @@ use crate::{
     defer_drop_mut,
     exception_private::{ExcType, RunResult, SimpleException},
     expressions::Identifier,
-    heap::{DropWithHeap, Heap, HeapData, HeapGuard},
+    heap::{ContainsHeap, DropWithHeap, Heap, HeapData, HeapGuard},
     intern::{Interns, StringId},
     resource::ResourceTracker,
     types::{Dict, allocate_tuple},
@@ -659,7 +659,7 @@ struct NamespaceGuard<'a> {
 }
 
 impl DropWithHeap for NamespaceGuard<'_> {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         for value in self.namespace.drain(..) {
             value.drop_with_heap(heap);
         }
diff --git a/crates/monty/src/types/dict.rs b/crates/monty/src/types/dict.rs
@@ -14,7 +14,7 @@ use crate::{
     bytecode::VM,
     defer_drop, defer_drop_mut,
     exception_private::{ExcType, RunResult},
-    heap::{DropWithHeap, Heap, HeapData, HeapGuard, HeapId},
+    heap::{ContainsHeap, DropWithHeap, Heap, HeapData, HeapGuard, HeapId},
     intern::{Interns, StaticStrings},
     resource::{ResourceError, ResourceTracker},
     types::Type,
@@ -647,7 +647,7 @@ impl PyTrait for Dict {
 }
 
 impl DropWithHeap for Dict {
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         for entry in self.entries {
             entry.key.drop_with_heap(heap);
             entry.value.drop_with_heap(heap);
diff --git a/crates/monty/src/types/iter.rs b/crates/monty/src/types/iter.rs
@@ -756,7 +756,7 @@ impl IterValue {
 
 impl DropWithHeap for MontyIter {
     #[inline]
-    fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {
+    fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {
         Self::drop_with_heap(self, heap);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -773,8 +773,8 @@ pub(crate) struct RecursionToken(());`
`773`	`773`
`774`	`774`	`impl DropWithHeap for RecursionToken {`
`775`	`775`	`#[inline]`
`776`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {`
`777`		`- heap.decr_recursion_depth();`
	`776`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
	`777`	`+ heap.heap().decr_recursion_depth();`
`778`	`778`	`}`
`779`	`779`	`}`
`780`	`780`
`@@ -1779,56 +1779,51 @@ impl<T: ResourceTracker> ContainsHeap for Heap<T> {`
`1779`	`1779`	`/// types that hold heap references.`
`1780`	`1780`	`pub(crate) trait DropWithHeap: Sized {`
`1781`	`1781`	/// Consume `self` and decrement reference counts for any heap-allocated values contained within.
`1782`		`- fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
`1783`		`- self.drop_with_concrete_heap(heap.heap_mut());`
`1784`		`- }`
`1785`		`-`
`1786`		- /// Consume `self` and decrement reference counts for any heap-allocated values contained within.
`1787`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>);`
	`1782`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H);`
`1788`	`1783`	`}`
`1789`	`1784`
`1790`	`1785`	`impl DropWithHeap for Value {`
`1791`	`1786`	`#[inline]`
`1792`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {`
	`1787`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
`1793`	`1788`	`Self::drop_with_heap(self, heap);`
`1794`	`1789`	`}`
`1795`	`1790`	`}`
`1796`	`1791`
`1797`	`1792`	`impl<U: DropWithHeap> DropWithHeap for Option<U> {`
`1798`	`1793`	`#[inline]`
`1799`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {`
	`1794`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
`1800`	`1795`	`if let Some(value) = self {`
`1801`	`1796`	`value.drop_with_heap(heap);`
`1802`	`1797`	`}`
`1803`	`1798`	`}`
`1804`	`1799`	`}`
`1805`	`1800`
`1806`	`1801`	`impl<U: DropWithHeap> DropWithHeap for Vec<U> {`
`1807`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {`
	`1802`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
`1808`	`1803`	`for value in self {`
`1809`	`1804`	`value.drop_with_heap(heap);`
`1810`	`1805`	`}`
`1811`	`1806`	`}`
`1812`	`1807`	`}`
`1813`	`1808`
`1814`	`1809`	`impl<U: DropWithHeap> DropWithHeap for vec::IntoIter<U> {`
`1815`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {`
	`1810`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
`1816`	`1811`	`for value in self {`
`1817`	`1812`	`value.drop_with_heap(heap);`
`1818`	`1813`	`}`
`1819`	`1814`	`}`
`1820`	`1815`	`}`
`1821`	`1816`
`1822`	`1817`	`impl<const N: usize> DropWithHeap for [Value; N] {`
`1823`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {`
	`1818`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
`1824`	`1819`	`for value in self {`
`1825`	`1820`	`value.drop_with_heap(heap);`
`1826`	`1821`	`}`
`1827`	`1822`	`}`
`1828`	`1823`	`}`
`1829`	`1824`
`1830`	`1825`	`impl<U: DropWithHeap, V: DropWithHeap> DropWithHeap for (U, V) {`
`1831`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {`
	`1826`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
`1832`	`1827`	`let (left, right) = self;`
`1833`	`1828`	`left.drop_with_heap(heap);`
`1834`	`1829`	`right.drop_with_heap(heap);`
Original file line number	Diff line number	Diff line change
`@@ -756,7 +756,7 @@ impl IterValue {`
`756`	`756`
`757`	`757`	`impl DropWithHeap for MontyIter {`
`758`	`758`	`#[inline]`
`759`		`- fn drop_with_concrete_heap<T: ResourceTracker>(self, heap: &mut Heap<T>) {`
	`759`	`+ fn drop_with_heap<H: ContainsHeap>(self, heap: &mut H) {`
`760`	`760`	`Self::drop_with_heap(self, heap);`
`761`	`761`	`}`
`762`	`762`	`}`