Synchronize and finish plugging gas metering in

Author: odeke-em

gnovm/pkg/gnolang/gotypecheck.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 
 	"github.com/gnolang/gno/gnovm"
+	storetypes "github.com/gnolang/gno/tm2/pkg/store/types"
 	"go.uber.org/multierr"
 )
 
@@ -23,26 +24,40 @@ type MemPackageGetter interface {
 	GetMemPackage(path string) *gnovm.MemPackage
 }
 
+const DEFAULT_MAX_GAS_UGNOT = 1_000_000 // 1Gnot aka 1e6 ugnots
+
 // TypeCheckMemPackage performs type validation and checking on the given
 // mempkg. To retrieve dependencies, it uses getter.
 //
 // The syntax checking is performed entirely using Go's go/types package.
 //
 // If format is true, the code will be automatically updated with the
 // formatted source code.
+//
+// By default is uses a gas meter of `DEFAULT_MAX_GAS_UGNOT`.
 func TypeCheckMemPackage(mempkg *gnovm.MemPackage, getter MemPackageGetter, format bool) error {
-	return typeCheckMemPackage(mempkg, getter, false, format)
+	return typeCheckMemPackage(mempkg, getter, false, format, newDefaultGasMeter())
+}
+
+// TypeCheckMemPackageWithGasMeter is like TypeCheckMemPackage, except
+// that it allows passing in the gas meter to use.
+func TypeCheckMemPackageWithGasMeter(mempkg *gnovm.MemPackage, getter MemPackageGetter, format bool, gasMeter storetypes.GasMeter) error {
+	return typeCheckMemPackage(mempkg, getter, false, format, gasMeter)
 }
 
 // TypeCheckMemPackageTest performs the same type checks as [TypeCheckMemPackage],
 // but allows re-declarations.
 //
 // Note: like TypeCheckMemPackage, this function ignores tests and filetests.
 func TypeCheckMemPackageTest(mempkg *gnovm.MemPackage, getter MemPackageGetter) error {
-	return typeCheckMemPackage(mempkg, getter, true, false)
+	return typeCheckMemPackage(mempkg, getter, true, false, newDefaultGasMeter())
 }
 
-func typeCheckMemPackage(mempkg *gnovm.MemPackage, getter MemPackageGetter, testing, format bool) error {
+func newDefaultGasMeter() storetypes.GasMeter {
+	return storetypes.NewGasMeter(DEFAULT_MAX_GAS_UGNOT)
+}
+
+func typeCheckMemPackage(mempkg *gnovm.MemPackage, getter MemPackageGetter, testing, format bool, gasMeter storetypes.GasMeter) error {
 	var errs error
 	imp := &gnoImporter{
 		getter: getter,
@@ -53,6 +68,7 @@ func typeCheckMemPackage(mempkg *gnovm.MemPackage, getter MemPackageGetter, test
 			},
 		},
 		allowRedefinitions: testing,
+		gasMeter:           gasMeter,
 	}
 	imp.cfg.Importer = imp
 
@@ -77,6 +93,7 @@ type gnoImporter struct {
 
 	// allow symbol redefinitions? (test standard libraries)
 	allowRedefinitions bool
+	gasMeter           storetypes.GasMeter
 }
 
 // Unused, but satisfies the Importer interface.
@@ -136,7 +153,7 @@ func (g *gnoImporter) parseCheckMemPackage(mpkg *gnovm.MemPackage, fmt bool) (*t
 			continue
 		}
 
-		// m.chargeGasForTypecheck(f)
+		chargeGasForTypecheck(g.gasMeter, f)
 
 		if delFunc != nil {
 			deleteOldIdents(delFunc, f)
@@ -162,64 +179,107 @@ func (g *gnoImporter) parseCheckMemPackage(mpkg *gnovm.MemPackage, fmt bool) (*t
 	return g.cfg.Check(mpkg.Path, fset, files, nil)
 }
 
-func (m *Machine) chargeGasForTypecheck(f *ast.File) {
-	ast.Walk(&astTraversingGasCharger{m}, f)
+func deleteOldIdents(idents map[string]func(), f *ast.File) {
+	for _, decl := range f.Decls {
+		fd, ok := decl.(*ast.FuncDecl)
+		if !ok || fd.Recv != nil { // ignore methods
+			continue
+		}
+		if del := idents[fd.Name.Name]; del != nil {
+			del()
+		}
+		decl := decl
+		idents[fd.Name.Name] = func() {
+			// NOTE: cannot use the index as a file may contain multiple decls to be removed,
+			// so removing one would make all "later" indexes wrong.
+			f.Decls = slices.DeleteFunc(f.Decls, func(d ast.Decl) bool { return decl == d })
+		}
+	}
+}
+
+func chargeGasForTypecheck(gasMeter storetypes.GasMeter, f *ast.File) {
+	ast.Walk(&astTraversingGasCharger{gasMeter}, f)
 }
 
 // astTraversingGasCharger is an ast.Visitor helper that statically traverses an AST
 // charging gas for the respective typechecking operations so as to bear a cost
 // and not let typechecking be abused
 type astTraversingGasCharger struct {
-	m *Machine
+	m storetypes.GasMeter
 }
 
 var _ ast.Visitor = (*astTraversingGasCharger)(nil)
 
+func (atgc *astTraversingGasCharger) consumeGas(amount storetypes.Gas) {
+	atgc.m.ConsumeGas(amount, "typeCheck")
+}
+
+const _BASIC_TYPECHECK_GAS_CHARGE = 5 // Arbitrary value.
+
 func (wmv *astTraversingGasCharger) Visit(n ast.Node) ast.Visitor {
-	switch n := n.(type) {
+	switch n.(type) {
 	case *ast.ImportSpec:
+		// No need to charge gas for imports.
 		return nil
 
+	case *ast.UnaryExpr:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 2)
+
 	case *ast.BinaryExpr:
-		// TODO: Charge more gas for the operands that aren't constant.
-		opCode := word2UnaryOp(Word(n.Op))
-		wmv.m.incrCPU(opCode.cpuCycles())
-		wmv.m.incrCPU(OpCPUBinary1)
-		return wmv
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 3)
 
-	case *ast.UnaryExpr:
-		opCode := word2BinaryOp(Word(n.Op))
-		wmv.m.incrCPU(opCode.cpuCycles())
-		// TODO: Charge gas for the expression itself too?
+	case *ast.BasicLit:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 2)
+
+	case *ast.CompositeLit:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 3)
 
 	case *ast.CallExpr:
-		wmv.m.incrCPU(OpCall.cpuCycles())
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 4)
 
 	case *ast.ForStmt:
-		wmv.m.incrCPU(OpCPUForLoop)
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 5)
 
 	case *ast.RangeStmt:
-		wmv.m.incrCPU(OpRangeIter)
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 6)
 		// TODO: Alternate on the different type of range statements.
-	}
 
-	return wmv
-}
+	case *ast.FuncDecl:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 6)
 
-func deleteOldIdents(idents map[string]func(), f *ast.File) {
-	for _, decl := range f.Decls {
-		fd, ok := decl.(*ast.FuncDecl)
-		if !ok || fd.Recv != nil { // ignore methods
-			continue
-		}
-		if del := idents[fd.Name.Name]; del != nil {
-			del()
-		}
-		decl := decl
-		idents[fd.Name.Name] = func() {
-			// NOTE: cannot use the index as a file may contain multiple decls to be removed,
-			// so removing one would make all "later" indexes wrong.
-			f.Decls = slices.DeleteFunc(f.Decls, func(d ast.Decl) bool { return decl == d })
-		}
+	case *ast.SwitchStmt:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 4)
+
+	case *ast.IfStmt:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 5)
+
+	case *ast.CaseClause:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 3)
+
+	case *ast.BranchStmt:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 3)
+
+	case *ast.AssignStmt:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 2)
+
+	case *ast.Ident:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 1)
+
+	case *ast.SelectorExpr:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 5)
+
+	case *ast.ParenExpr:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 3)
+
+	case *ast.ReturnStmt, *ast.DeferStmt:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 2)
+
+	case nil:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE / 2)
+
+	default:
+		wmv.consumeGas(_BASIC_TYPECHECK_GAS_CHARGE * 3)
 	}
+
+	return wmv
 }

gnovm/pkg/gnolang/gotypecheck_test.go

@@ -1,9 +1,15 @@
 package gnolang
 
 import (
+	"bytes"
+	"fmt"
+	"os"
+	"runtime"
 	"testing"
 
 	"github.com/gnolang/gno/gnovm"
+	storetypes "github.com/gnolang/gno/tm2/pkg/store/types"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/multierr"
@@ -357,3 +363,92 @@ func Hello(name string) string {
 	assert.NotEqual(t, input, pkg.Files[0].Body)
 	assert.Equal(t, expected, pkg.Files[0].Body)
 }
+
+func TestTypecheckMemPackageGasMetering(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		src     string
+		wantErr string
+	}{
+		{
+			"basic expression + print",
+			`
+package main
+func main() {
+    println("abcdefgh")
+    var _ = 1+2+3+4+5+6+7+8+9+10
+}`,
+			"",
+		},
+		{
+			name: "this entire file",
+			src: func() string {
+				_, thisFile, _, _ := runtime.Caller(1)
+				blob, err := os.ReadFile(thisFile)
+				require.NoError(t, err)
+				return string(blob)
+			}(),
+			wantErr: "could not import", // Not out of gas.
+		},
+		{
+			name: "deeply nested expression",
+			src: func() string {
+				buf := new(bytes.Buffer)
+				N := 1000
+				buf.WriteString("package main\nfunc main() {\n\tconst x = 1")
+				for i := 0; i < 3; i++ {
+					for j := 0; j < N; j++ {
+						buf.WriteString("+\n(1")
+					}
+					for j := 0; j < N; j++ {
+						buf.WriteByte(')')
+					}
+				}
+				buf.WriteString("\nprintln(x)\n}")
+				return buf.String()
+			}(),
+			wantErr: "out of gas",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			pkg := &gnovm.MemPackage{
+				Name: "hello",
+				Path: "gno.land/p/demo/hello",
+				Files: []*gnovm.MemFile{
+					{
+						Name: "hello.gno",
+						Body: tt.src,
+					},
+				},
+			}
+
+			mpkgGetter := mockPackageGetter{}
+			format := false
+			gasMeter := storetypes.NewGasMeter(100_000)
+			var err error
+
+			defer func() {
+				r := recover()
+				if r != nil && err == nil {
+					err = fmt.Errorf("%v", r)
+				}
+
+				if tt.wantErr != "" {
+					assert.Error(t, err)
+					assert.Contains(t, err.Error(), tt.wantErr)
+					return
+				}
+
+				assert.NoError(t, err)
+				assert.Equal(t, tt.src, pkg.Files[0].Body) // unchanged
+				assert.True(t, gasMeter.Remaining() > 0)
+			}()
+
+			err = TypeCheckMemPackageWithGasMeter(pkg, mpkgGetter, format, gasMeter)
+		})
+	}
+}