Implement tests for deletion, correctly implementation delay of deletion

jerbob92 · Sep 22, 2023 · 1332047 · 1332047
1 parent ee8c165
commit 1332047
Show file tree

Hide file tree

Showing 9 changed files with 993 additions and 108 deletions.
diff --git a/engine.go b/engine.go
@@ -11,6 +11,8 @@ type Engine interface {
 	NewFunctionExporterForModule(guest wazero.CompiledModule) FunctionExporter
 }
 
+type DelayFunction internal.DelayFunction
+
 type EngineKey = internal.EngineKey
 
 func CreateEngine(config internal.IEngineConfig) Engine {

diff --git a/examples/classes/generated/classes.go b/examples/classes/generated/classes.go
diff --git a/generator/generator/templates/classes.tmpl b/generator/generator/templates/classes.tmpl
@@ -24,6 +24,14 @@ func (class *{{ $class.GoName }}) Delete(ctx context.Context) error {
 	return class.DeleteInstance(ctx, class)
 }
 
+func (class *{{ $class.GoName }}) DeleteLater(ctx context.Context) (embind.ClassBase, error) {
+	return class.DeleteInstanceLater(ctx, class)
+}
+
+func (class *{{ $class.GoName }}) IsDeleted(ctx context.Context) bool {
+	return class.IsInstanceDeleted(ctx, class)
+}
+
 func (class *{{ $class.GoName }}) IsAliasOf(ctx context.Context, second embind.ClassBase) (bool, error) {
 	return class.IsAliasOfInstance(ctx, class, second)
 }

diff --git a/internal/class.go b/internal/class.go
@@ -115,11 +115,11 @@ func (erc *classType) validate() error {
 	return nil
 }
 
-func (erc *classType) isDeleted(handle IClassBase) bool {
+func (erc *classType) isDeleted(ctx context.Context, handle IClassBase) bool {
 	return handle.getRegisteredPtrTypeRecord().ptr == 0
 }
 
-func (erc *classType) deleteLater(handle IClassBase) (any, error) {
+func (erc *classType) deleteLater(ctx context.Context, handle IClassBase) (IClassBase, error) {
 	registeredPtrTypeRecord := handle.getRegisteredPtrTypeRecord()
 	if registeredPtrTypeRecord.ptr == 0 {
 		return nil, fmt.Errorf("class handle already deleted")
@@ -129,13 +129,17 @@ func (erc *classType) deleteLater(handle IClassBase) (any, error) {
 		return nil, fmt.Errorf("object already scheduled for deletion")
 	}
 
-	// @todo: implement me.
-	/*
-	   deletionQueue.push(this);
-	   if (deletionQueue.length === 1 && delayFunction) {
-	     delayFunction(flushPendingDeletes);
-	   }
-	*/
+	e := MustGetEngineFromContext(ctx, nil).(*engine)
+	e.deletionQueue = append(e.deletionQueue, handle)
+
+	if len(e.deletionQueue) == 1 && e.delayFunction != nil {
+		err := e.delayFunction(func(ctx context.Context) error {
+			return e.FlushPendingDeletes(ctx)
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
 
 	registeredPtrTypeRecord.deleteScheduled = true
 
@@ -214,7 +218,7 @@ func (erc *classType) delete(ctx context.Context, handle IClassBase) error {
 		return err
 	}
 
-	if registeredPtrTypeRecord.preservePointerOnDelete {
+	if !registeredPtrTypeRecord.preservePointerOnDelete {
 		registeredPtrTypeRecord.smartPtr = 0
 		registeredPtrTypeRecord.ptr = 0
 	}
@@ -453,6 +457,14 @@ func (ecb *ClassBase) DeleteInstance(ctx context.Context, this IClassBase) error
 	return ecb.classType.delete(ctx, this)
 }
 
+func (ecb *ClassBase) DeleteInstanceLater(ctx context.Context, this IClassBase) (IClassBase, error) {
+	return ecb.classType.deleteLater(ctx, this)
+}
+
+func (ecb *ClassBase) IsInstanceDeleted(ctx context.Context, this IClassBase) bool {
+	return ecb.classType.isDeleted(ctx, this)
+}
+
 func (ecb *ClassBase) IsAliasOfInstance(ctx context.Context, this IClassBase, second IClassBase) (bool, error) {
 	return ecb.classType.isAliasOf(ctx, this, second)
 }
@@ -520,6 +532,8 @@ type IClassBase interface {
 	isValid() bool
 	CloneInstance(ctx context.Context, this IClassBase) (IClassBase, error)
 	DeleteInstance(ctx context.Context, this IClassBase) error
+	DeleteInstanceLater(ctx context.Context, this IClassBase) (IClassBase, error)
+	IsInstanceDeleted(ctx context.Context, this IClassBase) bool
 	IsAliasOfInstance(ctx context.Context, this IClassBase, second IClassBase) (bool, error)
 	CallInstanceMethod(ctx context.Context, this any, name string, arguments ...any) (any, error)
 	SetInstanceProperty(ctx context.Context, this any, name string, value any) error

diff --git a/internal/embind.go b/internal/embind.go
@@ -25,8 +25,15 @@ type IEngine interface {
 	RegisterEmvalSymbol(name string, symbol any) error
 	EmvalToHandle(value any) int32
 	EmvalToValue(handle int32) (any, error)
+	CountEmvalHandles() int
+	GetInheritedInstanceCount() int
+	GetLiveInheritedInstances() []IClassBase
+	FlushPendingDeletes(ctx context.Context) error
+	SetDelayFunction(fn DelayFunction) error
 }
 
+type DelayFunction func(func(ctx context.Context) error) error
+
 type IEngineConfig interface {
 }
 
@@ -92,6 +99,9 @@ func CreateEngine(config IEngineConfig) IEngine {
 		registeredPointers:   map[int32]*registeredPointer{},
 		registeredTuples:     map[int32]*registeredTuple{},
 		registeredObjects:    map[int32]*registeredObject{},
+		registeredInstances:  map[uint32]IClassBase{},
+		deletionQueue:        []IClassBase{},
+		delayFunction:        nil,
 		emvalEngine:          createEmvalEngine(),
 	}
 }
diff --git a/internal/emval.go b/internal/emval.go
@@ -74,6 +74,10 @@ func (ea *emvalAllocator) get(id int32) (*emvalHandle, error) {
 		return nil, fmt.Errorf("invalid id: %d", id)
 	}
 
+	if ea.allocated[int(id)] == nil {
+		return nil, fmt.Errorf("invalid id: %d", id)
+	}
+
 	return ea.allocated[int(id)], nil
 }
 

diff --git a/internal/engine.go b/internal/engine.go
@@ -29,6 +29,8 @@ type engine struct {
 	registeredTuples     map[int32]*registeredTuple
 	registeredObjects    map[int32]*registeredObject
 	registeredInstances  map[uint32]IClassBase
+	deletionQueue        []IClassBase
+	delayFunction        DelayFunction
 	emvalEngine          *emvalEngine
 }
 
@@ -761,6 +763,53 @@ func (e *engine) validateThis(ctx context.Context, this any, classType *register
 
 	// @todo: check if based.ptrType.registeredClass is or extends classType.registeredClass
 
-	// todo: kill this
+	// todo: kill this (comment from Emscripten)
 	return e.upcastPointer(ctx, based.getPtr(), based.getPtrType().registeredClass, classType.registeredClass)
 }
+
+func (e *engine) CountEmvalHandles() int {
+	return len(e.emvalEngine.allocator.allocated) - len(e.emvalEngine.allocator.freelist)
+}
+
+func (e *engine) GetInheritedInstanceCount() int {
+	return len(e.registeredInstances)
+}
+
+func (e *engine) GetLiveInheritedInstances() []IClassBase {
+	instances := make([]IClassBase, len(e.registeredInstances))
+	i := 0
+	for id := range e.registeredInstances {
+		instances[i] = e.registeredInstances[id]
+		i++
+	}
+	return instances
+}
+
+func (e *engine) FlushPendingDeletes(ctx context.Context) error {
+	for len(e.deletionQueue) > 0 {
+		obj := e.deletionQueue[len(e.deletionQueue)-1]
+		e.deletionQueue = e.deletionQueue[:len(e.deletionQueue)-1]
+
+		obj.getRegisteredPtrTypeRecord().deleteScheduled = false
+		err := obj.DeleteInstance(ctx, obj)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (e *engine) SetDelayFunction(fn DelayFunction) error {
+	e.delayFunction = fn
+
+	if len(e.deletionQueue) > 0 && fn != nil {
+		err := fn(func(ctx context.Context) error {
+			return e.FlushPendingDeletes(ctx)
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}