perf: for loop and if

gnovm/pkg/gnolang/gno_test.go

@@ -245,6 +245,38 @@ func main() {
 	m.RunMain()
 }
 
+func BenchmarkForLoop(b *testing.B) {
+	m := NewMachine("test", nil)
+	c := `package test
+func main() {
+	for i:=0; i<10000; i++ {}
+}`
+	n := MustParseFile("main.go", c)
+	m.RunFiles(n)
+
+	for i := 0; i < b.N; i++ {
+		m.RunMain()
+	}
+}
+
+func BenchmarkIfStatement(b *testing.B) {
+	m := NewMachine("test", nil)
+	c := `package test
+func main() {
+	for i:=0; i<10000; i++ {
+		if i > 10 {
+
+		}
+	}
+}`
+	n := MustParseFile("main.go", c)
+	m.RunFiles(n)
+
+	for i := 0; i < b.N; i++ {
+		m.RunMain()
+	}
+}
+
 func TestDoOpEvalBaseConversion(t *testing.T) {
 	m := NewMachine("test", nil)
 

gnovm/pkg/gnolang/op_inc_dec.go

@@ -26,6 +26,10 @@ func (m *Machine) doOpInc() {
 			panic("expected lv.V to be nil for primitive type for OpInc")
 		}
 	}
+
+	// here we can't just switch on the value type
+	// because it could be a type alias
+	// type num int
 	switch baseOf(lv.T) {
 	case IntType:
 		lv.SetInt(lv.GetInt() + 1)

gnovm/pkg/gnolang/preprocess.go

@@ -1702,12 +1702,12 @@
 			// TRANS_LEAVE -----------------------
 			case *ForStmt:
 				// Cond consts become bool *ConstExprs.
-				checkOrConvertType(store, last, &n.Cond, BoolType, false)
+				checkWithoutConvertType(store, last, &n.Cond, BoolType, false)
 
 			// TRANS_LEAVE -----------------------
 			case *IfStmt:
 				// Cond consts become bool *ConstExprs.
-				checkOrConvertType(store, last, &n.Cond, BoolType, false)
+				checkWithoutConvertType(store, last, &n.Cond, BoolType, false)
 
 			// TRANS_LEAVE -----------------------
 			case *RangeStmt:
@@ -2463,6 +2463,42 @@
 	}
 }
 
+func checkWithoutConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative bool) {
+	if cx, ok := (*x).(*ConstExpr); ok {
+		convertConst(store, last, cx, t)
+	} else if bx, ok := (*x).(*BinaryExpr); ok && (bx.Op == SHL || bx.Op == SHR) {
+		// "push" expected type into shift binary's left operand.
+		checkWithoutConvertType(store, last, &bx.Left, t, autoNative)
+	} else if *x != nil { // XXX if x != nil && t != nil {
+		xt := evalStaticTypeOf(store, last, *x)
+		if t != nil {
+			checkType(xt, t, autoNative)
+		}
+		if isUntyped(xt) {
+			if t == nil {
+				t = defaultTypeOf(xt)
+			}
+			// Push type into expr if qualifying binary expr.
+			if bx, ok := (*x).(*BinaryExpr); ok {
+				switch bx.Op {
+				case ADD, SUB, MUL, QUO, REM, BAND, BOR, XOR,
+					BAND_NOT, LAND, LOR:
+					// push t into bx.Left and bx.Right
+					checkWithoutConvertType(store, last, &bx.Left, t, autoNative)
+					checkWithoutConvertType(store, last, &bx.Right, t, autoNative)
+					return
+				case SHL, SHR:
+					// push t into bx.Left
+					checkWithoutConvertType(store, last, &bx.Left, t, autoNative)
+					return
+					// case EQL, LSS, GTR, NEQ, LEQ, GEQ:
+					// default:
+				}
+			}
+		}
+	}
+}
+
 // like checkOrConvertType(last, x, nil)
 func convertIfConst(store Store, last BlockNode, x Expr) {
 	if cx, ok := x.(*ConstExpr); ok {