fix: count gas for TypedValue.Sprint and println

gno.land/pkg/sdk/vm/keeper.go

@@ -494,7 +494,7 @@ func (vm *VMKeeper) Call(ctx sdk.Context, msg MsgCall) (res string, err error) {
 	defer doRecover(m, &err)
 	rtvs := m.Eval(xn)
 	for i, rtv := range rtvs {
-		res = res + rtv.String()
+		res = res + rtv.String(m)
 		if i < len(rtvs)-1 {
 			res += "\n"
 		}
@@ -558,7 +558,7 @@ func doRecoverInternal(m *gno.Machine, e *error, r any, repanicOutOfGas bool) {
 	*e = errors.Wrapf(
 		fmt.Errorf("%v", r),
 		"VM panic: %v\nMachine State:%s\nStacktrace:\n%s\n",
-		r, m.String(), m.Stacktrace().String(),
+		r, m.String(), m.Stacktrace().String(m),
 	)
 }
 
@@ -738,7 +738,7 @@ func (vm *VMKeeper) QueryEval(ctx sdk.Context, pkgPath string, expr string) (res
 	}
 	res = ""
 	for i, rtv := range rtvs {
-		res += rtv.String()
+		res += rtv.String(nil)
 		if i < len(rtvs)-1 {
 			res += "\n"
 		}

gnovm/cmd/benchops/storage_test.go

@@ -30,7 +30,7 @@ func TestBenchStoreSet(t *testing.T) {
 		for range rounds {
 			cx := gno.Call("GetPost", gno.X(0), gno.X(0))
 			res := callFunc(gstore, pv, cx)
-			parts := strings.Split(res[0].V.String(), ",")
+			parts := strings.Split(res[0].V.String(nil), ",")
 			p := strings.Trim(parts[1], `\"`)
 			expected := strings.Repeat("a", 1024)
 			assert.Equal(p, expected, "it should be 1 KB of character a")

gnovm/cmd/gno/run.go

@@ -196,7 +196,7 @@ func runExpr(m *gno.Machine, expr string) {
 					expr, r.Error(), m.ExceptionsStacktrace())
 			default:
 				fmt.Printf("panic running expression %s: %v\nMachine State:%s\nStacktrace:\n%s\n",
-					expr, r, m.String(), m.Stacktrace().String())
+					expr, r, m.String(), m.Stacktrace().String(m))
 			}
 			panic(r)
 		}

gnovm/pkg/gnolang/debug.go

@@ -96,22 +96,22 @@ func (p *PreprocessError) Unwrap() error {
 
 // Stack produces a string representation of the preprocessing stack
 // trace that was associated with the error occurrence.
-func (p *PreprocessError) Stack() string {
+func (p *PreprocessError) Stack(m *Machine) string {
 	var stacktrace strings.Builder
 	for i := len(p.stack) - 1; i >= 0; i-- {
 		sbn := p.stack[i]
-		fmt.Fprintf(&stacktrace, "stack %d: %s\n", i, sbn.String())
+		fmt.Fprintf(&stacktrace, "stack %d: %s\n", i, sbn.String(m))
 	}
 	return stacktrace.String()
 }
 
 // Error consolidates and returns the full error message, including
 // the actual error followed by its associated preprocessing stack.
-func (p *PreprocessError) Error() string {
+func (p *PreprocessError) Error(m *Machine) string {
 	var err strings.Builder
 	fmt.Fprintf(&err, "%s:\n", p.Unwrap())
 	fmt.Fprintln(&err, "--- preprocess stack ---")
-	fmt.Fprint(&err, p.Stack())
+	fmt.Fprint(&err, p.Stack(m))
 	fmt.Fprintf(&err, "------------------------")
 	return err.String()
 }

gnovm/pkg/gnolang/frame.go

@@ -98,7 +98,7 @@ type Stacktrace struct {
 	LastLine        int
 }
 
-func (s Stacktrace) String() string {
+func (s Stacktrace) String(m *Machine) string {
 	var builder strings.Builder
 
 	for i, call := range s.Calls {
@@ -115,10 +115,10 @@ func (s Stacktrace) String() string {
 		cx := call.Frame.Source.(*CallExpr)
 		switch {
 		case call.Frame.Func != nil && call.Frame.Func.IsNative():
-			fmt.Fprintf(&builder, "%s\n", toExprTrace(cx))
+			fmt.Fprintf(&builder, "%s\n", toExprTrace(m, cx))
 			fmt.Fprintf(&builder, "    gonative:%s.%s\n", call.Frame.Func.NativePkg, call.Frame.Func.NativeName)
 		case call.Frame.Func != nil:
-			fmt.Fprintf(&builder, "%s\n", toExprTrace(cx))
+			fmt.Fprintf(&builder, "%s\n", toExprTrace(m, cx))
 			fmt.Fprintf(&builder, "    %s/%s:%d\n", call.Frame.Func.PkgPath, call.Frame.Func.FileName, line)
 		default:
 			panic("StacktraceCall has a non-call Frame")
@@ -127,44 +127,44 @@ func (s Stacktrace) String() string {
 	return builder.String()
 }
 
-func toExprTrace(ex Expr) string {
+func toExprTrace(m *Machine, ex Expr) string {
 	switch ex := ex.(type) {
 	case *CallExpr:
 		s := make([]string, len(ex.Args))
 		for i, arg := range ex.Args {
-			s[i] = toExprTrace(arg)
+			s[i] = toExprTrace(m, arg)
 		}
-		return fmt.Sprintf("%s(%s)", toExprTrace(ex.Func), strings.Join(s, ","))
+		return fmt.Sprintf("%s(%s)", toExprTrace(m, ex.Func), strings.Join(s, ","))
 	case *BinaryExpr:
-		return fmt.Sprintf("%s %s %s", toExprTrace(ex.Left), ex.Op.TokenString(), toExprTrace(ex.Right))
+		return fmt.Sprintf("%s %s %s", toExprTrace(m, ex.Left), ex.Op.TokenString(), toExprTrace(m, ex.Right))
 	case *UnaryExpr:
-		return fmt.Sprintf("%s%s", ex.Op.TokenString(), toExprTrace(ex.X))
+		return fmt.Sprintf("%s%s", ex.Op.TokenString(), toExprTrace(m, ex.X))
 	case *SelectorExpr:
-		return fmt.Sprintf("%s.%s", toExprTrace(ex.X), ex.Sel)
+		return fmt.Sprintf("%s.%s", toExprTrace(m, ex.X), ex.Sel)
 	case *IndexExpr:
-		return fmt.Sprintf("%s[%s]", toExprTrace(ex.X), toExprTrace(ex.Index))
+		return fmt.Sprintf("%s[%s]", toExprTrace(m, ex.X), toExprTrace(m, ex.Index))
 	case *StarExpr:
-		return fmt.Sprintf("*%s", toExprTrace(ex.X))
+		return fmt.Sprintf("*%s", toExprTrace(m, ex.X))
 	case *RefExpr:
-		return fmt.Sprintf("&%s", toExprTrace(ex.X))
+		return fmt.Sprintf("&%s", toExprTrace(m, ex.X))
 	case *CompositeLitExpr:
 		lenEl := len(ex.Elts)
 		if ex.Type == nil {
 			return fmt.Sprintf("<elided><len=%d>", lenEl)
 		}
 
-		return fmt.Sprintf("%s<len=%d>", toExprTrace(ex.Type), lenEl)
+		return fmt.Sprintf("%s<len=%d>", toExprTrace(m, ex.Type), lenEl)
 	case *FuncLitExpr:
-		return fmt.Sprintf("%s{ ... }", toExprTrace(&ex.Type))
+		return fmt.Sprintf("%s{ ... }", toExprTrace(m, &ex.Type))
 	case *TypeAssertExpr:
-		return fmt.Sprintf("%s.(%s)", toExprTrace(ex.X), toExprTrace(ex.Type))
+		return fmt.Sprintf("%s.(%s)", toExprTrace(m, ex.X), toExprTrace(m, ex.Type))
 	case *ConstExpr:
 		return toConstExpTrace(ex)
 	case *NameExpr, *BasicLitExpr, *SliceExpr:
-		return ex.String()
+		return ex.String(m)
 	}
 
-	return ex.String()
+	return ex.String(m)
 }
 
 func toConstExpTrace(cte *ConstExpr) string {

gnovm/pkg/gnolang/gno_test.go

@@ -144,7 +144,7 @@ func TestConvertTo(t *testing.T) {
 			}
 
 			err := r.(*PreprocessError)
-			c := strings.Contains(err.Error(), msg)
+			c := strings.Contains(err.Error(nil), msg)
 			if !c {
 				t.Fatalf(`expected "%s", got "%s"`, msg, r)
 			}
@@ -548,7 +548,7 @@ func TestDoOpEvalBaseConversion(t *testing.T) {
 		} else {
 			m.doOpEval()
 			v := m.PopValue()
-			assert.Equal(t, tc.expect, v.V.String())
+			assert.Equal(t, tc.expect, v.V.String(nil))
 		}
 	}
 }

gnovm/pkg/gnolang/go2gno_test.go

@@ -23,5 +23,5 @@ func main(){
 	assert.NotNil(t, n, "ParseFile error")
 	fmt.Printf("CODE:\n%s\n\n", gocode)
 	fmt.Printf("AST:\n%#v\n\n", n)
-	fmt.Printf("AST.String():\n%s\n", n.String())
+	fmt.Printf("AST.String():\n%s\n", n.String(nil))
 }

gnovm/pkg/gnolang/machine.go

@@ -314,7 +314,7 @@ func (r redeclarationErrors) add(newI Name) redeclarationErrors {
 }
 
 // checkDuplicates returns an error if there are duplicate declarations in the fset.
-func checkDuplicates(fset *FileSet) error {
+func checkDuplicates(m *Machine, fset *FileSet) error {
 	defined := make(map[Name]struct{}, 128)
 	var duplicated redeclarationErrors
 	for _, f := range fset.Files {
@@ -327,7 +327,7 @@ func checkDuplicates(fset *FileSet) error {
 				}
 				name = d.Name
 				if d.IsMethod {
-					name = Name(destar(d.Recv.Type).String()) + "." + name
+					name = Name(destar(d.Recv.Type).String(m)) + "." + name
 				}
 			case *TypeDecl:
 				name = d.Name
@@ -427,7 +427,7 @@ func (m *Machine) RunFiles(fns ...*FileNode) {
 // compile-time errors in the package.
 func (m *Machine) PreprocessFiles(pkgName, pkgPath string, fset *FileSet, save, withOverrides bool) (*PackageNode, *PackageValue) {
 	if !withOverrides {
-		if err := checkDuplicates(fset); err != nil {
+		if err := checkDuplicates(m, fset); err != nil {
 			panic(fmt.Errorf("running package %q: %w", pkgName, err))
 		}
 	}
@@ -501,7 +501,7 @@ func (m *Machine) runFileDecls(withOverrides bool, fns ...*FileNode) []TypedValu
 		pn.FileSet.AddFiles(fns...)
 	}
 	if !withOverrides {
-		if err := checkDuplicates(pn.FileSet); err != nil {
+		if err := checkDuplicates(nil, pn.FileSet); err != nil {
 			panic(fmt.Errorf("running package %q: %w", pv.PkgPath, err))
 		}
 	}
@@ -689,7 +689,7 @@ func (m *Machine) RunFunc(fn Name) {
 					fn, r.Error(), m.ExceptionsStacktrace())
 			default:
 				fmt.Printf("Machine.RunFunc(%q) panic: %v\nMachine State:%s\nStacktrace:\n%s\n",
-					fn, r, m.String(), m.Stacktrace().String())
+					fn, r, m.String(), m.Stacktrace().String(m))
 			}
 			panic(r)
 		}
@@ -708,7 +708,7 @@ func (m *Machine) RunMain() {
 					r.Error(), m.ExceptionsStacktrace())
 			default:
 				fmt.Printf("Machine.RunMain() panic: %v\nMachine State:%s\nStacktrace:\n%s\n",
-					r, m.String(), m.Stacktrace())
+					r, m.String(), m.Stacktrace().String(m))
 			}
 			panic(r)
 		}
@@ -736,7 +736,7 @@ func (m *Machine) Eval(x Expr) []TypedValue {
 	if x.GetAttribute(ATTR_PREPROCESSED) != nil {
 		panic(fmt.Sprintf(
 			"Machine.Eval(x) expression already preprocessed: %s",
-			x.String()))
+			x.String(m)))
 	}
 	// Preprocess input using last block context.
 	last := m.LastBlock().GetSource(m.Store)
@@ -775,7 +775,7 @@ func (m *Machine) EvalStatic(last BlockNode, x Expr) TypedValue {
 	if x.GetAttribute(ATTR_PREPROCESSED) == nil {
 		panic(fmt.Sprintf(
 			"Machine.EvalStatic(x) expression not yet preprocessed: %s",
-			x.String()))
+			x.String(m)))
 	}
 	// Temporarily push last to m.Blocks.
 	m.PushBlock(last.GetStaticBlock().GetBlock())
@@ -804,7 +804,7 @@ func (m *Machine) EvalStaticTypeOf(last BlockNode, x Expr) Type {
 	if x.GetAttribute(ATTR_PREPROCESSED) == nil {
 		panic(fmt.Sprintf(
 			"Machine.EvalStaticTypeOf(x) expression not yet preprocessed: %s",
-			x.String()))
+			x.String(m)))
 	}
 	// Temporarily push last to m.Blocks.
 	m.PushBlock(last.GetStaticBlock().GetBlock())
@@ -1139,6 +1139,8 @@ const (
 	OpCPURangeIterMap      = 48
 	OpCPURangeIterArrayPtr = 46
 	OpCPUReturnCallDefers  = 78
+
+	OpCharPrint = 100
 )
 
 //----------------------------------------
@@ -2173,12 +2175,12 @@ func (m *Machine) String() string {
 			// print the pkgpath.
 			fmt.Fprintf(builder, "          %s(%d) %s\n", gens, gen, pv.PkgPath)
 		} else {
-			bsi := b.StringIndented("            ")
+			bsi := b.StringIndented(m, "            ")
 			fmt.Fprintf(builder, "          %s(%d) %s\n", gens, gen, bsi)
 
 			if b.Source != nil {
 				sb := b.GetSource(m.Store).GetStaticBlock().GetBlock()
-				fmt.Fprintf(builder, " (s vals) %s(%d) %s\n", gens, gen, sb.StringIndented("            "))
+				fmt.Fprintf(builder, " (s vals) %s(%d) %s\n", gens, gen, sb.StringIndented(m, "            "))
 
 				sts := b.GetSource(m.Store).GetStaticBlock().Types
 				fmt.Fprintf(builder, " (s typs) %s(%d) %s\n", gens, gen, sts)
@@ -2212,11 +2214,11 @@ func (m *Machine) String() string {
 			break // done, skip *PackageNode.
 		} else {
 			fmt.Fprintf(builder, "          #%d %s\n", i,
-				b.StringIndented("            "))
+				b.StringIndented(m, "            "))
 			if b.Source != nil {
 				sb := b.GetSource(m.Store).GetStaticBlock().GetBlock()
 				fmt.Fprintf(builder, " (static) #%d %s\n", i,
-					sb.StringIndented("            "))
+					sb.StringIndented(m, "            "))
 			}
 		}
 	}
@@ -2249,7 +2251,7 @@ func (m *Machine) ExceptionsStacktrace() string {
 
 	ex := m.Exceptions[0]
 	builder.WriteString("panic: " + ex.Sprint(m) + "\n")
-	builder.WriteString(ex.Stacktrace.String())
+	builder.WriteString(ex.Stacktrace.String(m))
 
 	switch {
 	case len(m.Exceptions) > 2:
@@ -2258,7 +2260,7 @@ func (m *Machine) ExceptionsStacktrace() string {
 	case len(m.Exceptions) == 2:
 		ex = m.Exceptions[len(m.Exceptions)-1]
 		builder.WriteString("panic: " + ex.Sprint(m) + "\n")
-		builder.WriteString(ex.Stacktrace.String())
+		builder.WriteString(ex.Stacktrace.String(m))
 	}
 
 	return builder.String()

gnovm/pkg/gnolang/misc.go

@@ -88,11 +88,11 @@ func word2UnaryOp(w Word) Op {
 	}
 }
 
-func toString(n Node) string {
+func toString(m *Machine, n Node) string {
 	if n == nil {
 		return "<nil>"
 	}
-	return n.String()
+	return n.String(m)
 }
 
 // true if the first rune is uppercase.

gnovm/pkg/gnolang/nodes.go

@@ -222,7 +222,7 @@ func (attr *Attributes) DelAttribute(key GnoAttribute) {
 
 type Node interface {
 	assertNode()
-	String() string
+	String(m *Machine) string
 	Copy() Node
 	GetLine() int
 	SetLine(int)
@@ -1033,14 +1033,14 @@ func (x *bodyStmt) PopActiveStmt() (as Stmt) {
 	return
 }
 
-func (x *bodyStmt) String() string {
+func (x *bodyStmt) String(m *Machine) string {
 	next := ""
 	if x.NextBodyIndex < 0 {
 		next = "(init)"
 	} else if x.NextBodyIndex == len(x.Body) {
 		next = "(end)"
 	} else {
-		next = x.Body[x.NextBodyIndex].String()
+		next = x.Body[x.NextBodyIndex].String(m)
 	}
 	active := ""
 	if x.Active != nil {