Optimize range for-loops to native int performance

Range for-loops now emit pure native Go arithmetic with zero
overhead vs while loops (~2µs/10k iterations, same as Go).

Previously, loop variables in for-in loops were always boxed as
interface{}, causing arithmetic to go through runtime dispatch
(~145µs/10k iterations). Integer ranges now get full type inference.

Author: rubiojr

compiler/codegen.go

@@ -1379,6 +1379,13 @@ func (g *codeGen) rangeExprs(coll ast.Expr) (string, string) {
 		return "0", intLit.Value
 	}
 
+	// for i in n (integer variable)
+	if ident, ok := coll.(*ast.IdentExpr); ok {
+		if g.varType(ident.Name) == TypeInt {
+			return "0", ident.Name
+		}
+	}
+
 	// for i in range(...)
 	call, ok := coll.(*ast.CallExpr)
 	if !ok {

compiler/infer.go

@@ -188,10 +188,11 @@ func inferStmt(ti *TypeInfo, scope *typeScope, s ast.Statement) {
 
 	case *ast.ForStmt:
 		inferExpr(ti, scope, st.Collection)
-		// For loop vars are dynamic (collection element type unknown).
-		scope.set(st.Var, TypeDynamic)
+		// Infer loop variable type from collection.
+		loopVarType := inferForVarType(ti, scope, st.Collection)
+		scope.set(st.Var, loopVarType)
 		if st.IndexVar != "" {
-			scope.set(st.IndexVar, TypeDynamic)
+			scope.set(st.IndexVar, loopVarType)
 		}
 		// Infer body twice: the first pass may widen variable types
 		// (e.g. lines = lines + dynamic_var), and the second pass
@@ -519,6 +520,29 @@ func inferCall(ti *TypeInfo, scope *typeScope, e *ast.CallExpr) RugoType {
 	return TypeDynamic
 }
 
+// inferForVarType returns the loop variable type for a for-in collection.
+// Integer literals and range() calls produce TypeInt loop variables;
+// all other collections (arrays, hashes, variables) remain TypeDynamic.
+func inferForVarType(ti *TypeInfo, scope *typeScope, coll ast.Expr) RugoType {
+	// for i in 100
+	if _, ok := coll.(*ast.IntLiteral); ok {
+		return TypeInt
+	}
+	// for i in someIntVar
+	if ident, ok := coll.(*ast.IdentExpr); ok {
+		if scope.get(ident.Name) == TypeInt {
+			return TypeInt
+		}
+	}
+	// for i in range(...)
+	if call, ok := coll.(*ast.CallExpr); ok {
+		if fn, ok := call.Func.(*ast.IdentExpr); ok && fn.Name == "range" {
+			return TypeInt
+		}
+	}
+	return TypeDynamic
+}
+
 // snapshotFuncTypes creates a deep copy of function type info for change detection.
 func snapshotFuncTypes(m map[string]*FuncTypeInfo) map[string]*FuncTypeInfo {
 	snap := make(map[string]*FuncTypeInfo, len(m))