test(gnovm): add test for bounding issue

examples/gno.land/r/demo/tests/crossrealm/crossrealm.gno

@@ -27,3 +27,13 @@ func Make1() *p_crossrealm.Container {
 		B: local,
 	}
 }
+
+type Fooer interface{ Foo() }
+
+var fooer Fooer
+
+func SetFooer(f Fooer) Fooer {
+	fooer = f
+	return fooer
+}
+func CallFoo() { fooer.Foo() }

examples/gno.land/r/demo/tests/tests.gno

@@ -49,6 +49,8 @@ type TestRealmObject struct {
 	Field string
 }
 
+var TestRealmObjectValue TestRealmObject
+
 func ModifyTestRealmObject(t *TestRealmObject) {
 	t.Field += "_modified"
 }

gnovm/pkg/gnolang/machine.go

@@ -36,8 +36,8 @@ func (e Exception) Sprint(m *Machine) string {
 
 type Machine struct {
 	// State
-	Ops        []Op // main operations
-	NumOps     int
+	Ops        []Op          // operations stack
+	NumOps     int           // number of operations
 	Values     []TypedValue  // buffer of values to be operated on
 	NumValues  int           // number of values
 	Exprs      []Expr        // pending expressions
@@ -47,9 +47,9 @@ type Machine struct {
 	Package    *PackageValue // active package
 	Realm      *Realm        // active realm
 	Alloc      *Allocator    // memory allocations
-	Exceptions []Exception
-	NumResults int   // number of results returned
-	Cycles     int64 // number of "cpu" cycles
+	Exceptions []Exception   // exceptions stack
+	NumResults int           // number of results returned
+	Cycles     int64         // number of "cpu" cycles performed
 
 	Debugger Debugger
 
@@ -199,6 +199,7 @@ func (m *Machine) Release() {
 	machinePool.Put(m)
 }
 
+// Convenience for initial setup of the machine.
 func (m *Machine) SetActivePackage(pv *PackageValue) {
 	if err := m.CheckEmpty(); err != nil {
 		panic(errors.Wrap(err, "set package when machine not empty"))
@@ -210,6 +211,14 @@ func (m *Machine) SetActivePackage(pv *PackageValue) {
 	}
 }
 
+func (m *Machine) setCurrentPackage(pv *PackageValue) {
+	m.Package = pv
+	rlm := pv.GetRealm()
+	if rlm != nil {
+		m.Realm = rlm
+	}
+}
+
 //----------------------------------------
 // top level Run* methods.
 
@@ -1797,29 +1806,36 @@ func (m *Machine) PushFrameCall(cx *CallExpr, fv *FuncValue, recv TypedValue) {
 		m.Printf("+F %#v\n", fr)
 	}
 	m.Frames = append(m.Frames, fr)
-	pv := fv.GetPackage(m.Store)
-	if pv == nil {
-		panic(fmt.Sprintf("package value missing in store: %s", fv.PkgPath))
-	}
-	rlm := pv.GetRealm()
-	if rlm == nil && recv.IsDefined() {
+	if recv.IsDefined() {
+		// If the receiver is defined, we enter the receiver's realm.
 		obj := recv.GetFirstObject(m.Store)
 		if obj == nil {
 			// could be a nil receiver.
-			// just ignore.
+			// set package and realm of function.
+			pv := fv.GetPackage(m.Store)
+			if pv == nil {
+				panic(fmt.Sprintf("package value missing in store: %s", fv.PkgPath))
+			}
+			m.setCurrentPackage(pv) // maybe new realm
 		} else {
 			recvOID := obj.GetObjectInfo().ID
-			if !recvOID.IsZero() {
+			if recvOID.IsZero() {
+				// receiver isn't owned yet.
+				// just continue with current package and realm.
+				// XXX is this reasonable?
+			} else {
 				// override the pv and rlm with receiver's.
 				recvPkgOID := ObjectIDFromPkgID(recvOID.PkgID)
-				pv = m.Store.GetObject(recvPkgOID).(*PackageValue)
-				rlm = pv.GetRealm() // done
+				pv := m.Store.GetObject(recvPkgOID).(*PackageValue)
+				m.setCurrentPackage(pv) // maybe new realm
 			}
 		}
-	}
-	m.Package = pv
-	if rlm != nil && m.Realm != rlm {
-		m.Realm = rlm // enter new realm
+	} else {
+		pv := fv.GetPackage(m.Store)
+		if pv == nil {
+			panic(fmt.Sprintf("package value missing in store: %s", fv.PkgPath))
+		}
+		m.setCurrentPackage(pv) // maybe new realm
 	}
 }
 

gnovm/pkg/gnolang/ownership.go

@@ -140,11 +140,12 @@ type ObjectInfo struct {
 	RefCount  int       // for persistence. deleted/gc'd if 0.
 	IsEscaped bool      `json:",omitempty"` // hash in iavl.
 	// MemRefCount int // consider for optimizations.
-	isDirty      bool
-	isDeleted    bool
-	isNewReal    bool
-	isNewEscaped bool
-	isNewDeleted bool
+	isDirty                 bool
+	isDeleted               bool
+	isNewReal               bool
+	isNewEscaped            bool
+	isNewDeleted            bool
+	lastNewRealEscapedRealm PkgID
 
 	// XXX huh?
 	owner Object // mem reference to owner.
@@ -154,17 +155,21 @@ type ObjectInfo struct {
 // Note that "owner" is nil.
 func (oi *ObjectInfo) Copy() ObjectInfo {
 	return ObjectInfo{
-		ID:           oi.ID,
-		Hash:         oi.Hash.Copy(),
-		OwnerID:      oi.OwnerID,
-		ModTime:      oi.ModTime,
-		RefCount:     oi.RefCount,
-		IsEscaped:    oi.IsEscaped,
-		isDirty:      oi.isDirty,
-		isDeleted:    oi.isDeleted,
-		isNewReal:    oi.isNewReal,
-		isNewEscaped: oi.isNewEscaped,
-		isNewDeleted: oi.isNewDeleted,
+		ID:        oi.ID,
+		Hash:      oi.Hash.Copy(),
+		OwnerID:   oi.OwnerID,
+		ModTime:   oi.ModTime,
+		RefCount:  oi.RefCount,
+		IsEscaped: oi.IsEscaped,
+		/*
+			// XXX do the following need copying too?
+			isDirty:          oi.isDirty,
+			isDeleted:        oi.isDeleted,
+			isNewReal:        oi.isNewReal,
+			isNewEscaped:     oi.isNewEscaped,
+			isNewDeleted:     oi.isNewDeleted,
+			lastNewRealEscapedRealm: oi.lastNewRealEscapedRealm,
+		*/
 	}
 }
 

gnovm/pkg/gnolang/realm.go

@@ -102,7 +102,6 @@ type Realm struct {
 	created []Object // about to become real.
 	updated []Object // real objects that were modified.
 	deleted []Object // real objects that became deleted.
-	escaped []Object // real objects with refcount > 1.
 }
 
 // Creates a blank new realm with counter 0.
@@ -171,7 +170,7 @@ func (rlm *Realm) DidUpdate(po, xo, co Object) {
 			if co.GetIsEscaped() {
 				// already escaped
 			} else {
-				rlm.MarkNewEscaped(co)
+				rlm.MarkNewEscapedCheckCrossRealm(co)
 			}
 		} else if co.GetIsReal() {
 			rlm.MarkDirty(co)
@@ -265,6 +264,24 @@ func (rlm *Realm) MarkNewDeleted(oo Object) {
 	rlm.newDeleted = append(rlm.newDeleted, oo)
 }
 
+func (rlm *Realm) MarkNewEscapedCheckCrossRealm(oo Object) {
+	oi := oo.GetObjectInfo()
+	if oi.lastNewRealEscapedRealm == rlm.ID {
+		// already processed for this realm,
+		// see below.
+		return
+	}
+	if !oi.GetIsReal() {
+		// this can happen if a ref +1
+		// new object gets passed into
+		// an external realm function.
+		oi.lastNewRealEscapedRealm = rlm.ID
+		oi.SetIsNewReal(false)
+		rlm.MarkNewReal(oo)
+	}
+	rlm.MarkNewEscaped(oo)
+}
+
 func (rlm *Realm) MarkNewEscaped(oo Object) {
 	if debug {
 		if !oo.GetIsNewReal() && !oo.GetIsReal() {
@@ -300,8 +317,7 @@ func (rlm *Realm) FinalizeRealmTransaction(readonly bool, store Store) {
 			len(rlm.newDeleted) > 0 ||
 			len(rlm.created) > 0 ||
 			len(rlm.updated) > 0 ||
-			len(rlm.deleted) > 0 ||
-			len(rlm.escaped) > 0 {
+			len(rlm.deleted) > 0 {
 			panic("realm updates in readonly transaction")
 		}
 		return
@@ -317,8 +333,7 @@ func (rlm *Realm) FinalizeRealmTransaction(readonly bool, store Store) {
 		ensureUniq(rlm.updated)
 		if false ||
 			rlm.created != nil ||
-			rlm.deleted != nil ||
-			rlm.escaped != nil {
+			rlm.deleted != nil {
 			panic("realm should not have created, deleted, or escaped marks before beginning finalization")
 		}
 	}
@@ -337,7 +352,6 @@ func (rlm *Realm) FinalizeRealmTransaction(readonly bool, store Store) {
 	rlm.markDirtyAncestors(store)
 	if debug {
 		ensureUniq(rlm.created, rlm.updated, rlm.deleted)
-		ensureUniq(rlm.escaped)
 	}
 	// save all the created and updated objects.
 	// hash calculation is done along the way,
@@ -359,7 +373,12 @@ func (rlm *Realm) FinalizeRealmTransaction(readonly bool, store Store) {
 // and get assigned ids.
 func (rlm *Realm) processNewCreatedMarks(store Store) {
 	// Create new objects and their new descendants.
-	for _, oo := range rlm.newCreated {
+	// NOTE: the following range does not work
+	// because incRefCreatedDescendants may append to newCreated
+	// for the case when new escapes are found to have crossed.
+	// BAD: for _, oo := range rlm.newCreated {
+	for i := 0; i < len(rlm.newCreated); i++ {
+		oo := rlm.newCreated[i]
 		if debug {
 			if oo.GetIsDirty() {
 				panic("new created mark cannot be dirty")
@@ -442,8 +461,7 @@ func (rlm *Realm) incRefCreatedDescendants(store Store, oo Object) {
 				// NOTE: do not unset owner here,
 				// may become unescaped later
 				// in processNewEscapedMarks().
-				// NOTE: may already be escaped.
-				rlm.MarkNewEscaped(child)
+				rlm.MarkNewEscapedCheckCrossRealm(child)
 			}
 		} else {
 			panic("child reference count should be greater than zero after increasing")
@@ -523,7 +541,6 @@ func (rlm *Realm) decRefDeletedDescendants(store Store, oo Object) {
 // objects get their original owners marked dirty (to be further
 // marked via markDirtyAncestors).
 func (rlm *Realm) processNewEscapedMarks(store Store) {
-	escaped := make([]Object, 0, len(rlm.newEscaped))
 	// These are those marked by MarkNewEscaped(),
 	// regardless of whether new-real or was real,
 	// but is always newly escaped,
@@ -549,7 +566,6 @@ func (rlm *Realm) processNewEscapedMarks(store Store) {
 			// we do that upon actually persisting
 			// the hash index.
 			// eo.SetIsNewEscaped(false)
-			escaped = append(escaped, eo)
 
 			// add to escaped, and mark dirty previous owner.
 			po := getOwner(store, eo)
@@ -566,15 +582,16 @@ func (rlm *Realm) processNewEscapedMarks(store Store) {
 					// exists, mark dirty.
 					rlm.MarkDirty(po)
 				}
+				// TODO: move to if debug { } once proven.
 				if eo.GetObjectID().IsZero() {
-					panic("new escaped mark has no object ID")
+					panic("new escaped object has no object ID")
 				}
+
 				// escaped has no owner.
 				eo.SetOwner(nil)
 			}
 		}
 	}
-	rlm.escaped = escaped // XXX is this actually used?
 }
 
 //----------------------------------------
@@ -789,7 +806,6 @@ func (rlm *Realm) clearMarks() {
 	rlm.created = nil
 	rlm.updated = nil
 	rlm.deleted = nil
-	rlm.escaped = nil
 }
 
 //----------------------------------------
@@ -1471,7 +1487,7 @@ func toRefValue(val Value) RefValue {
 		} else if oo.GetIsEscaped() {
 			if debug {
 				if !oo.GetOwnerID().IsZero() {
-					panic("cannot convert escaped object to ref value without an owner ID")
+					panic("cannot convert escaped object to ref value with an owner ID")
 				}
 			}
 			return RefValue{

gnovm/pkg/gnomod/file_test.go

@@ -16,6 +16,7 @@ import (
 
 const testRemote string = "test3.gno.land:26657"
 
+// XXX this test fails when the network is offline.
 func TestFetchDeps(t *testing.T) {
 	for _, tc := range []struct {
 		desc                 string

gnovm/tests/file.go

@@ -307,7 +307,6 @@ func RunFileTest(rootDir string, path string, opts ...RunFileTestOption) error {
 						panic(fmt.Sprintf("fail on %s: got unexpected debug error(s): %v", path, gno.GetDebugErrors()))
 					}
 					// pnc is nil, errWanted empty, no gno debug errors
-					return nil
 				}
 			case "Output":
 				// panic if got unexpected error

gnovm/tests/files/zrealm_crossrealm15_stdlibs.gno

@@ -0,0 +1,32 @@
+// PKGPATH: gno.land/r/crossrealm_test
+package crossrealm_test
+
+import (
+	"std"
+
+	crossrealm "gno.land/r/demo/tests/crossrealm"
+)
+
+type fooer struct{}
+
+func (fooer) Foo() { println("hello " + std.CurrentRealm().PkgPath()) }
+
+var f *fooer
+
+func init() {
+	f = &fooer{}
+	crossrealm.SetFooer(f)
+	crossrealm.CallFoo()
+}
+
+func main() {
+	print(".")
+}
+
+// Output:
+// hello gno.land/r/demo/tests/crossrealm
+// .
+
+// Error:
+
+// Realm: