Stop ignoring val.Drop and val.Clone memory errors

2 files changed, 57 insertions, 26 deletions

diff --git a/pkg/lang/vm/value/cells.go b/pkg/lang/vm/value/cells.go
index 19ecfde..646f3c1 100644
--- a/pkg/lang/vm/value/cells.go
+++ b/pkg/lang/vm/value/cells.go
@@ -1,16 +1,21 @@
 package value
 
 import (
+	"fmt"
 	"jinx/pkg/lang/vm/code"
 	"jinx/pkg/lang/vm/mem"
 )
 
 type ArrayCell []Value
 
-func (a ArrayCell) DropCell(m mem.Mem) {
+func (a ArrayCell) DropCell(m mem.Mem) error {
 	for _, v := range a {
-		v.Drop(m)
+		if err := v.Drop(m); err != nil {
+			return err
+		}
 	}
+
+	return nil
 }
 
 func (a ArrayCell) MatchingCellKind() mem.CellKind {
@@ -23,7 +28,8 @@ func (a ArrayCell) Get() []Value {
 
 type StringCell string
 
-func (s StringCell) DropCell(m mem.Mem) {
+func (s StringCell) DropCell(m mem.Mem) error {
+	return nil
 }
 
 func (s StringCell) MatchingCellKind() mem.CellKind {
@@ -38,10 +44,14 @@ type ObjectCell struct {
 	Members map[string]Value
 }
 
-func (o ObjectCell) DropCell(m mem.Mem) {
+func (o ObjectCell) DropCell(m mem.Mem) error {
 	for _, v := range o.Members {
-		v.Drop(m)
+		if err := v.Drop(m); err != nil {
+			return err
+		}
 	}
+
+	return nil
 }
 
 func (o ObjectCell) MatchingCellKind() mem.CellKind {
@@ -54,17 +64,23 @@ func (o ObjectCell) Get() map[string]Value {
 
 type TypeCell Type
 
-func (t TypeCell) DropCell(m mem.Mem) {
+func (t TypeCell) DropCell(m mem.Mem) error {
 	typ := t.Get()
 	for _, f := range typ.Methods {
 		// Wrap data in a Value to drop it.
 		val := NewFunction(code.Pos{}, 0).WithData(f)
-		val.Drop(m)
+		if err := val.Drop(m); err != nil {
+			return err
+		}
 	}
 
 	for _, v := range typ.Statics {
-		v.Drop(m)
+		if err := v.Drop(m); err != nil {
+			return err
+		}
 	}
+
+	return nil
 }
 
 func (t TypeCell) MatchingCellKind() mem.CellKind {
@@ -77,8 +93,8 @@ func (t TypeCell) Get() Type {
 
 type OutletCell Value
 
-func (o OutletCell) DropCell(m mem.Mem) {
-	Value(o).Drop(m)
+func (o OutletCell) DropCell(m mem.Mem) error {
+	return Value(o).Drop(m)
 }
 
 func (o OutletCell) MatchingCellKind() mem.CellKind {
@@ -91,10 +107,14 @@ func (o OutletCell) Get() Value {
 
 type EnvCell Env
 
-func (e EnvCell) DropCell(m mem.Mem) {
+func (e EnvCell) DropCell(m mem.Mem) error {
 	for _, v := range e.references {
-		m.Release(v.outlet)
+		if err := m.Release(v.outlet); err != nil {
+			return err
+		}
 	}
+
+	return nil
 }
 
 func (e EnvCell) MatchingCellKind() mem.CellKind {
@@ -107,8 +127,8 @@ func (e EnvCell) Get() Env {
 
 type GlobalCell Value
 
-func (g GlobalCell) DropCell(m mem.Mem) {
-	panic("global cell cannot be dropped")
+func (g GlobalCell) DropCell(m mem.Mem) error {
+	return fmt.Errorf("global cell cannot be dropped")
 }
 
 func (g GlobalCell) MatchingCellKind() mem.CellKind {
diff --git a/pkg/lang/vm/value/value.go b/pkg/lang/vm/value/value.go
index cce2f5e..e2750f4 100644
--- a/pkg/lang/vm/value/value.go
+++ b/pkg/lang/vm/value/value.go
@@ -142,20 +142,28 @@ func (v Value) IsEmpty() bool {
 	return v == Value{}
 }
 
-func (v Value) Clone(m mem.Mem) Value {
+func (v Value) Clone(m mem.Mem) (Value, error) {
 	if v.t == StringType {
 		str := v.d.(StringData)
-		m.Retain(str.data)
+		if err := m.Retain(str.data); err != nil {
+			return Value{}, err
+		}
 	}
 
 	if v.t == ArrayType {
 		arr := v.d.(ArrayData)
-		m.Retain(arr.data)
+		if err := m.Retain(arr.data); err != nil {
+			return Value{}, err
+		}
 	}
 
 	if v.t == FunctionType {
 		fn := v.d.(FunctionData)
-		m.Retain(fn.env)
+		if !fn.env.IsNull() {
+			if err := m.Retain(fn.env); err != nil {
+				return Value{}, err
+			}
+		}
 	}
 
 	// If value has an outlet don't copy it into the clone,
@@ -163,28 +171,31 @@ func (v Value) Clone(m mem.Mem) Value {
 	// I don't know if this fixes the entire problem, but it seems to work.
 	v.outlet = mem.NullPtr
 
-	return v
+	return v, nil
 }
 
-func (v Value) Drop(m mem.Mem) {
+func (v Value) Drop(m mem.Mem) error {
 	// If value has an outlet, don't drop it and instead move it to the outlet.
 	if !v.outlet.IsNull() {
-		m.Set(v.outlet, OutletCell(v))
-		return
+		return m.Set(v.outlet, OutletCell(v))
 	}
 
 	if v.t == StringType {
 		str := v.d.(StringData)
-		m.Release(str.data)
+		return m.Release(str.data)
 	}
 
 	if v.t == ArrayType {
 		arr := v.d.(ArrayData)
-		m.Release(arr.data)
+		return m.Release(arr.data)
 	}
 
 	if v.t == FunctionType {
-		f := v.d.(FunctionData)
-		m.Release(f.env)
+		fn := v.d.(FunctionData)
+		if !fn.env.IsNull() {
+			return m.Release(fn.env)
+		}
 	}
+
+	return nil
 }