feat(gnovm): improved native bindings

gnovm/pkg/gnolang/go2gno.go

@@ -96,9 +96,11 @@ func MustParseExpr(expr string) Expr {
 	return x
 }
 
-// filename must not include the path.
+// ParseFile uses the Go parser to parse body. It then runs [Go2Gno] on the
+// resulting AST -- the resulting FileNode is returned, together with any other
+// error (including panics, which are recovered) from [Go2Gno].
 func ParseFile(filename string, body string) (fn *FileNode, err error) {
-	// Parse src but stop after processing the imports.
+	// Use go parser to parse the body.
 	fs := token.NewFileSet()
 	f, err := parser.ParseFile(fs, filename, body, parser.ParseComments|parser.DeclarationErrors)
 	if err != nil {
@@ -112,9 +114,9 @@ func ParseFile(filename string, body string) (fn *FileNode, err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			if rerr, ok := r.(error); ok {
-				err = rerr
+				err = errors.Wrap(rerr, "parsing file")
 			} else {
-				err = errors.New(fmt.Sprintf("%v", r))
+				err = errors.New(fmt.Sprintf("%v", r)).Stacktrace()
 			}
 			return
 		}
@@ -431,7 +433,16 @@ func Go2Gno(fs *token.FileSet, gon ast.Node) (n Node) {
 		}
 		name := toName(gon.Name)
 		type_ := Go2Gno(fs, gon.Type).(*FuncTypeExpr)
-		body := Go2Gno(fs, gon.Body).(*BlockStmt).Body
+		var body []Stmt
+		if gon.Body != nil {
+			body = Go2Gno(fs, gon.Body).(*BlockStmt).Body
+		} else {
+			bd, err := ParseExpr(`panic("call to bodyless/external function is invalid outside of standard library")`)
+			if err != nil {
+				panic(err)
+			}
+			body = []Stmt{&ExprStmt{X: bd}}
+		}
 		return &FuncDecl{
 			IsMethod: isMethod,
 			Recv:     recv,

gnovm/pkg/gnolang/machine.go

@@ -34,6 +34,7 @@ type Machine struct {
 	Exceptions []*TypedValue // if panic'd unless recovered
 	NumResults int           // number of results returned
 	Cycles     int64         // number of "cpu" cycles
+	Injector   func(store Store, pn *PackageNode)
 
 	// Configuration
 	CheckTypes bool // not yet used
@@ -45,14 +46,15 @@ type Machine struct {
 	Context interface{}
 }
 
-// machine.Release() must be called on objects
-// created via this constructor
-// Machine with new package of given path.
-// Creates a new MemRealmer for any new realms.
-// Looks in store for package of pkgPath; if not found,
-// creates new instances as necessary.
-// If pkgPath is zero, the machine has no active package
-// and one must be set prior to usage.
+// NewMachine initializes a new gno virtual machine, acting as a shorthand
+// for [NewMachineWithOptions], setting the given options PkgPath and Store.
+//
+// The machine will run on the package at the given path, which will be
+// retrieved through the given store. If it is not set, the machine has no
+// active package, and one must be set prior to usage.
+//
+// Like for [NewMachineWithOptions], Machines initialized through this
+// constructor must be finalized with [Machine.Release].
 func NewMachine(pkgPath string, store Store) *Machine {
 	return NewMachineWithOptions(
 		MachineOptions{
@@ -61,16 +63,19 @@ func NewMachine(pkgPath string, store Store) *Machine {
 		})
 }
 
+// MachineOptions is used to pass options to [NewMachineWithOptions].
 type MachineOptions struct {
+	// Active package of the given machine; must be set before execution.
 	PkgPath       string
 	CheckTypes    bool // not yet used
 	ReadOnly      bool
-	Output        io.Writer
-	Store         Store
+	Output        io.Writer // default os.Stdout
+	Store         Store     // default NewStore(Alloc, nil, nil)
 	Context       interface{}
 	Alloc         *Allocator // or see MaxAllocBytes.
 	MaxAllocBytes int64      // or 0 for no limit.
 	MaxCycles     int64      // or 0 for no limit.
+	Injector      func(store Store, pn *PackageNode)
 }
 
 // the machine constructor gets spammed
@@ -86,6 +91,11 @@ var machinePool = sync.Pool{
 	},
 }
 
+// NewMachineWithOptions initializes a new gno virtual machine with the given
+// options.
+//
+// Machines initialized through this constructor must be finalized with
+// [Machine.Release].
 func NewMachineWithOptions(opts MachineOptions) *Machine {
 	checkTypes := opts.CheckTypes
 	readOnly := opts.ReadOnly
@@ -129,6 +139,7 @@ func NewMachineWithOptions(opts MachineOptions) *Machine {
 		Output:     output,
 		Store:      store,
 		Context:    context,
+		Injector:   opts.Injector,
 	}
 
 	if pv != nil {
@@ -147,13 +158,11 @@ var (
 	valueZeroed [ValueSize]TypedValue
 )
 
-// m should not be used after this call
-// if m is nil, this will panic
-// this is on purpose, to discourage misuse
-// and prevent objects that were not taken from
-// the pool, to call Release
+// Release resets some of the values of *Machine and puts back m into the
+// machine pool; for this reason, Release() should be called as a finalizer,
+// and m should not be used after this call. Only Machines initialized with this
+// package's constructors should be released.
 func (m *Machine) Release() {
-	// copy()
 	// here we zero in the values for the next user
 	m.NumOps = 0
 	m.NumValues = 0
@@ -494,6 +503,11 @@ func (m *Machine) runFiles(fns ...*FileNode) {
 		}
 	}
 
+	// Inject native functions
+	if m.Injector != nil {
+		m.Injector(m.Store, pn)
+	}
+
 	// Declarations (and variable initializations).  This must happen
 	// after all files are preprocessed, because value decl may be out of
 	// order and depend on other files.

gnovm/pkg/gnolang/nodes.go

@@ -1089,14 +1089,22 @@ func PackageNameFromFileBody(name string, body string) Name {
 	return n.PkgName
 }
 
-// NOTE: panics if package name is invalid.
+// ReadMemPackage initializes a new MemPackage by reading the OS directory
+// at dir, and saving it with the given pkgPath (import path).
+// The resulting MemPackage will contain the names and content of all *.gno files,
+// and additionally README.md, LICENSE, and gno.mod.
+//
+// ReadMemPackage does not perform validation aside from the package's name;
+// the files are not parsed but their contents are merely stored inside a MemFile.
+//
+// NOTE: panics if package name is invalid (characters must be alphanumeric or _,
+// lowercase, and must start with a letter).
 func ReadMemPackage(dir string, pkgPath string) *std.MemPackage {
 	files, err := ioutil.ReadDir(dir)
 	if err != nil {
 		panic(err)
 	}
 	memPkg := &std.MemPackage{Path: pkgPath}
-	var pkgName Name
 	allowedFiles := []string{ // make case insensitive?
 		"gno.mod",
 		"LICENSE",
@@ -1105,6 +1113,7 @@ func ReadMemPackage(dir string, pkgPath string) *std.MemPackage {
 	allowedFileExtensions := []string{
 		".gno",
 	}
+	var pkgName Name
 	for _, file := range files {
 		if file.IsDir() ||
 			strings.HasPrefix(file.Name(), ".") ||
@@ -1116,6 +1125,7 @@ func ReadMemPackage(dir string, pkgPath string) *std.MemPackage {
 		if err != nil {
 			panic(err)
 		}
+		// XXX: should check that all pkg names are the same (else package is invalid)
 		if pkgName == "" && strings.HasSuffix(file.Name(), ".gno") {
 			pkgName = PackageNameFromFileBody(file.Name(), string(bz))
 			if strings.HasSuffix(string(pkgName), "_test") {
@@ -1133,33 +1143,29 @@ func ReadMemPackage(dir string, pkgPath string) *std.MemPackage {
 	return memPkg
 }
 
-func PrecompileMemPackage(memPkg *std.MemPackage) error {
-	return nil
-}
-
-// Returns the code fileset minus any spurious or test files.
+// ParseMemPackage executes [ParseFile] on each file of the memPkg, excluding
+// test and spurious (non-gno) files. The resulting *FileSet is returned.
+//
+// If one of the files has a different package name than memPkg.Name,
+// or [ParseFile] returns an error, ParseMemPackage panics.
 func ParseMemPackage(memPkg *std.MemPackage) (fset *FileSet) {
 	fset = &FileSet{}
 	for _, mfile := range memPkg.Files {
-		if !strings.HasSuffix(mfile.Name, ".gno") {
-			continue // skip spurious file.
+		if !strings.HasSuffix(mfile.Name, ".gno") ||
+			endsWith(mfile.Name, []string{"_test.gno", "_filetest.gno"}) {
+			continue // skip spurious or test file.
 		}
 		n, err := ParseFile(mfile.Name, mfile.Body)
 		if err != nil {
 			panic(errors.Wrap(err, "parsing file "+mfile.Name))
 		}
-		if strings.HasSuffix(mfile.Name, "_test.gno") {
-			// skip test file.
-		} else if strings.HasSuffix(mfile.Name, "_filetest.gno") {
-			// skip test file.
-		} else if memPkg.Name == string(n.PkgName) {
-			// add package file.
-			fset.AddFiles(n)
-		} else {
+		if memPkg.Name != string(n.PkgName) {
 			panic(fmt.Sprintf(
-				"expected package name [%s] or [%s_test] but got [%s]",
-				memPkg.Name, memPkg.Name, n.PkgName))
+				"expected package name [%s] but got [%s]",
+				memPkg.Name, n.PkgName))
 		}
+		// add package file.
+		fset.AddFiles(n)
 	}
 	return fset
 }
@@ -1369,6 +1375,20 @@ func (x *PackageNode) DefineNative(n Name, ps, rs FieldTypeExprs, native func(*M
 	if native == nil {
 		panic("DefineNative expects a function, but got nil")
 	}
+
+	if v := x.GetValueRef(nil, n); v != nil {
+		// redefinition
+		fv, ok := v.V.(*FuncValue)
+		if !ok {
+			panic("cannot redefine non-function as native function")
+		}
+		fmt.Printf("REDEFINE %s %p\n", n, fv)
+		// XXX: type-check
+		fv.body = nil
+		fv.nativeBody = native
+		return
+	}
+
 	fd := FuncD(n, ps, rs, nil)
 	fd = Preprocess(nil, x, fd).(*FuncDecl)
 	ft := evalStaticType(nil, x, &fd.Type).(*FuncType)
@@ -1648,7 +1668,6 @@ func (sb *StaticBlock) GetStaticTypeOfAt(store Store, path ValuePath) Type {
 			path.Depth -= 1
 		}
 	}
-	panic("should not happen")
 }
 
 // Implements BlockNode.
@@ -2016,6 +2035,7 @@ const (
 )
 
 // TODO: consider length restrictions.
+// If this function is changed, ReadMemPackage's documentation should be updated accordingly.
 func validatePkgName(name string) {
 	if nameOK, _ := regexp.MatchString(
 		`^[a-z][a-z0-9_]+$`, name); !nameOK {

gnovm/pkg/gnolang/op_call.go

@@ -58,6 +58,9 @@ func (m *Machine) doOpCall() {
 	clo := fr.Func.GetClosure(m.Store)
 	b := m.Alloc.NewBlock(fr.Func.GetSource(m.Store), clo)
 	m.PushBlock(b)
+	if fv.Name == "now" {
+		fmt.Printf("CALL NOW %p %#v\n", fv, fv)
+	}
 	if fv.nativeBody == nil {
 		fbody := fv.GetBodyFromSource(m.Store)
 		if len(ft.Results) == 0 {

gnovm/stdlibs/context.go

@@ -18,3 +18,6 @@ type ExecContext struct {
 	OrigSendSpent *std.Coins // mutable
 	Banker        Banker
 }
+
+func (e ExecContext) GetTimestamp() int64     { return e.Timestamp }
+func (e ExecContext) GetTimestampNano() int64 { return e.TimestampNano }

gnovm/stdlibs/crypto/sha256/sha256.gno

@@ -1,12 +1,6 @@
 package sha256
 
-import (
-	isha256 "internal/crypto/sha256"
-)
-
 const Size = 32
 
 // Sum returns the SHA-256 checksum of the data.
-func Sum256(data []byte) [Size]byte {
-	return isha256.Sum256(data)
-}
+func Sum256(data []byte) [Size]byte

gnovm/stdlibs/crypto/sha256/sha256.go

@@ -0,0 +1,7 @@
+package sha256
+
+import "crypto/sha256"
+
+func Sum256(data []byte) [32]byte {
+	return sha256.Sum256(data)
+}