auto adjust code

internal/app/run/runner.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"maps"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"sync"
 
@@ -145,7 +146,7 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 	var stepIds []string
 	for i, v := range job.Steps {
 		if v.ID == "" {
-			v.ID = fmt.Sprint(i)
+			v.ID = strconv.Itoa(i)
 		}
 		stepIds = append(stepIds, v.ID)
 	}
@@ -204,7 +205,7 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 	// 	maxLifetime = time.Until(deadline)
 	// }
 
-	actCtx := map[string]interface{}{}
+	actCtx := map[string]any{}
 	forgeCtx := task.Context.AsMap()
 	actCtx["github"] = forgeCtx
 	actCtx["gitea"] = forgeCtx

internal/eval/functions/format.go

@@ -10,7 +10,7 @@ import (
 // It behaves like the C# implementation in the repository –
 // it supports escaped braces and numeric argument indices.
 // Format specifiers (e.g. :D) are recognised but currently ignored.
-func Format(formatStr string, args ...interface{}) (string, error) {
+func Format(formatStr string, args ...any) (string, error) {
 	var sb strings.Builder
 	i := 0
 	for i < len(formatStr) {
@@ -47,7 +47,7 @@ func Format(formatStr string, args ...interface{}) (string, error) {
 				}
 				// append argument (format specifier is ignored here)
 				arg := args[idx]
-				sb.WriteString(fmt.Sprintf("%v", arg))
+				fmt.Fprintf(&sb, "%v", arg)
 				if spec != "" {
 					// placeholder for future specifier handling
 					_ = spec

internal/eval/v2/evaluation_result.go

@@ -93,14 +93,14 @@ func (o CaseSensitiveObject[T]) GetEnumerator() map[string]T {
 type EvaluationResult struct {
 	context     *EvaluationContext
 	level       int
-	value       interface{}
+	value       any
 	kind        ValueKind
-	raw         interface{}
+	raw         any
 	omitTracing bool
 }
 
 // NewEvaluationResult creates a new EvaluationResult.
-func NewEvaluationResult(context *EvaluationContext, level int, val interface{}, kind ValueKind, raw interface{}, omitTracing bool) *EvaluationResult {
+func NewEvaluationResult(context *EvaluationContext, level int, val any, kind ValueKind, raw any, omitTracing bool) *EvaluationResult {
 	er := &EvaluationResult{context: context, level: level, value: val, kind: kind, raw: raw, omitTracing: omitTracing}
 	if !omitTracing {
 		er.traceValue()
@@ -112,10 +112,10 @@ func NewEvaluationResult(context *EvaluationContext, level int, val interface{},
 func (er *EvaluationResult) Kind() ValueKind { return er.kind }
 
 // Raw returns the raw value that was passed to the constructor.
-func (er *EvaluationResult) Raw() interface{} { return er.raw }
+func (er *EvaluationResult) Raw() any { return er.raw }
 
 // Value returns the canonical value.
-func (er *EvaluationResult) Value() interface{} { return er.value }
+func (er *EvaluationResult) Value() any { return er.value }
 
 // IsFalsy implements the logic from the C# class.
 func (er *EvaluationResult) IsFalsy() bool {
@@ -195,7 +195,7 @@ func (er *EvaluationResult) ConvertToString() string {
 }
 
 // TryGetCollectionInterface returns the underlying collection if the value is an array or object.
-func (er *EvaluationResult) TryGetCollectionInterface() (interface{}, bool) {
+func (er *EvaluationResult) TryGetCollectionInterface() (any, bool) {
 	switch v := er.value.(type) {
 	case ReadOnlyArray[any]:
 		return v, true
@@ -207,7 +207,7 @@ func (er *EvaluationResult) TryGetCollectionInterface() (interface{}, bool) {
 }
 
 // CreateIntermediateResult creates an EvaluationResult from an arbitrary object.
-func CreateIntermediateResult(context *EvaluationContext, obj interface{}) *EvaluationResult {
+func CreateIntermediateResult(context *EvaluationContext, obj any) *EvaluationResult {
 	val, kind, raw := convertToCanonicalValue(obj)
 	return NewEvaluationResult(context, 0, val, kind, raw, true)
 }
@@ -226,7 +226,7 @@ var ExpressionConstants = struct {
 }
 
 // convertToCanonicalValue converts an arbitrary Go value to a canonical form.
-func convertToCanonicalValue(obj interface{}) (interface{}, ValueKind, interface{}) {
+func convertToCanonicalValue(obj any) (any, ValueKind, any) {
 	switch v := obj.(type) {
 	case nil:
 		return nil, ValueKindNull, nil
@@ -243,11 +243,11 @@ func convertToCanonicalValue(obj interface{}) (interface{}, ValueKind, interface
 		return f, ValueKindNumber, f
 	case string:
 		return v, ValueKindString, v
-	case []interface{}:
+	case []any:
 		return BasicArray[any](v), ValueKindArray, v
 	case ReadOnlyArray[any]:
 		return v, ValueKindArray, v
-	case map[string]interface{}:
+	case map[string]any:
 		return CaseInsensitiveObject[any](v), ValueKindObject, v
 	case ReadOnlyObject[any]:
 		return v, ValueKindObject, v
@@ -257,7 +257,7 @@ func convertToCanonicalValue(obj interface{}) (interface{}, ValueKind, interface
 	}
 }
 
-func toInt64(v interface{}) int64 {
+func toInt64(v any) int64 {
 	switch i := v.(type) {
 	case int:
 		return int64(i)
@@ -274,7 +274,7 @@ func toInt64(v interface{}) int64 {
 	}
 }
 
-func toUint64(v interface{}) uint64 {
+func toUint64(v any) uint64 {
 	switch i := v.(type) {
 	case uint:
 		return uint64(i)
@@ -291,7 +291,7 @@ func toUint64(v interface{}) uint64 {
 	}
 }
 
-func toFloat64(v interface{}) float64 {
+func toFloat64(v any) float64 {
 	switch f := v.(type) {
 	case float32:
 		return float64(f)
@@ -304,7 +304,7 @@ func toFloat64(v interface{}) float64 {
 
 // coerceTypes implements the C# CoerceTypes logic.
 // It converts values to compatible types before comparison.
-func coerceTypes(left, right interface{}) (interface{}, interface{}, ValueKind, ValueKind) {
+func coerceTypes(left, right any) (any, any, ValueKind, ValueKind) {
 	leftKind := getKind(left)
 	rightKind := getKind(right)
 
@@ -340,7 +340,7 @@ func coerceTypes(left, right interface{}) (interface{}, interface{}, ValueKind,
 }
 
 // abstractEqual uses coerceTypes before comparing.
-func abstractEqual(left, right interface{}) bool {
+func abstractEqual(left, right any) bool {
 	left, right, leftKind, rightKind := coerceTypes(left, right)
 	if leftKind != rightKind {
 		return false
@@ -367,7 +367,7 @@ func abstractEqual(left, right interface{}) bool {
 }
 
 // abstractGreaterThan uses coerceTypes before comparing.
-func abstractGreaterThan(left, right interface{}) bool {
+func abstractGreaterThan(left, right any) bool {
 	left, right, leftKind, rightKind := coerceTypes(left, right)
 	if leftKind != rightKind {
 		return false
@@ -389,7 +389,7 @@ func abstractGreaterThan(left, right interface{}) bool {
 }
 
 // abstractLessThan uses coerceTypes before comparing.
-func abstractLessThan(left, right interface{}) bool {
+func abstractLessThan(left, right any) bool {
 	left, right, leftKind, rightKind := coerceTypes(left, right)
 	if leftKind != rightKind {
 		return false
@@ -411,7 +411,7 @@ func abstractLessThan(left, right interface{}) bool {
 }
 
 // convertToNumber converts a value to a float64 following JavaScript rules.
-func convertToNumber(v interface{}) float64 {
+func convertToNumber(v any) float64 {
 	switch val := v.(type) {
 	case nil:
 		return 0
@@ -447,7 +447,7 @@ func convertToNumber(v interface{}) float64 {
 }
 
 // getKind returns the ValueKind for a Go value.
-func getKind(v interface{}) ValueKind {
+func getKind(v any) ValueKind {
 	switch v.(type) {
 	case nil:
 		return ValueKindNull
@@ -457,9 +457,9 @@ func getKind(v interface{}) ValueKind {
 		return ValueKindNumber
 	case string:
 		return ValueKindString
-	case []interface{}:
+	case []any:
 		return ValueKindArray
-	case map[string]interface{}:
+	case map[string]any:
 		return ValueKindObject
 	default:
 		return ValueKindObject

internal/eval/v2/evaluator.go

@@ -56,11 +56,11 @@ func (e *Evaluator) EvaluateBoolean(expr string) (bool, error) {
 	return result.IsTruthy(), nil
 }
 
-func (e *Evaluator) ToRaw(result *EvaluationResult) (interface{}, error) {
+func (e *Evaluator) ToRaw(result *EvaluationResult) (any, error) {
 	if col, ok := result.TryGetCollectionInterface(); ok {
 		switch node := col.(type) {
 		case ReadOnlyObject[any]:
-			rawMap := map[string]interface{}{}
+			rawMap := map[string]any{}
 			for k, v := range node.GetEnumerator() {
 				rawRes, err := e.ToRaw(CreateIntermediateResult(e.Context(), v))
 				if err != nil {
@@ -70,7 +70,7 @@ func (e *Evaluator) ToRaw(result *EvaluationResult) (interface{}, error) {
 			}
 			return rawMap, nil
 		case ReadOnlyArray[any]:
-			rawArray := []interface{}{}
+			rawArray := []any{}
 			for _, v := range node.GetEnumerator() {
 				rawRes, err := e.ToRaw(CreateIntermediateResult(e.Context(), v))
 				if err != nil {
@@ -85,7 +85,7 @@ func (e *Evaluator) ToRaw(result *EvaluationResult) (interface{}, error) {
 }
 
 // Evaluate parses and evaluates the expression, returning a boolean result.
-func (e *Evaluator) EvaluateRaw(expr string) (interface{}, error) {
+func (e *Evaluator) EvaluateRaw(expr string) (any, error) {
 	root, err := exprparser.Parse(expr)
 	if err != nil {
 		return false, fmt.Errorf("parse error: %w", err)
@@ -97,16 +97,16 @@ func (e *Evaluator) EvaluateRaw(expr string) (interface{}, error) {
 	return e.ToRaw(result)
 }
 
-type FilteredArray []interface{}
+type FilteredArray []any
 
-func (a FilteredArray) GetAt(i int64) interface{} {
+func (a FilteredArray) GetAt(i int64) any {
 	if int(i) > len(a) {
 		return nil
 	}
 	return a[i]
 }
 
-func (a FilteredArray) GetEnumerator() []interface{} {
+func (a FilteredArray) GetEnumerator() []any {
 	return a
 }
 
@@ -244,7 +244,7 @@ func (e *Evaluator) evalUnaryNode(node *exprparser.UnaryNode) (*EvaluationResult
 	}
 }
 
-func processIndex(col interface{}, right *EvaluationResult) interface{} {
+func processIndex(col any, right *EvaluationResult) any {
 	if mapVal, ok := col.(ReadOnlyObject[any]); ok {
 		key, ok := right.Value().(string)
 		if !ok {
@@ -264,7 +264,7 @@ func processIndex(col interface{}, right *EvaluationResult) interface{} {
 	return nil
 }
 
-func processStar(subcol interface{}, ret FilteredArray) FilteredArray {
+func processStar(subcol any, ret FilteredArray) FilteredArray {
 	if array, ok := subcol.(ReadOnlyArray[any]); ok {
 		ret = append(ret, array.GetEnumerator()...)
 	} else if obj, ok := subcol.(ReadOnlyObject[any]); ok {

internal/eval/v2/evaluator_test.go

@@ -6,7 +6,7 @@ import (
 
 // Test boolean and comparison operations using the evaluator.
 func TestEvaluator_BooleanOps(t *testing.T) {
-	ctx := &EvaluationContext{Variables: CaseInsensitiveObject[any](map[string]interface{}{"a": 5, "b": 3})}
+	ctx := &EvaluationContext{Variables: CaseInsensitiveObject[any](map[string]any{"a": 5, "b": 3})}
 	eval := NewEvaluator(ctx)
 
 	tests := []struct {
@@ -44,7 +44,7 @@ func TestEvaluator_Raw(t *testing.T) {
 
 	tests := []struct {
 		expr string
-		want interface{}
+		want any
 	}{
 		{"a.b['x']", nil},
 		{"(a.b).c['x']", nil},

internal/eval/v2/functions.go

@@ -113,7 +113,7 @@ func (Format) Evaluate(eval *Evaluator, args []exprparser.Node) (*EvaluationResu
 		return nil, err
 	}
 
-	sargs := []interface{}{}
+	sargs := []any{}
 	for _, arg := range args[1:] {
 		el, err := eval.Evaluate(arg)
 		if err != nil {

internal/expr/expression_parser.go

@@ -20,7 +20,7 @@ type Node interface {
 
 type ValueNode struct {
 	Kind  TokenKind
-	Value interface{}
+	Value any
 }
 
 // FunctionNode represents a function call with arguments.

internal/expr/lexer.go

@@ -51,7 +51,7 @@ const (
 type Token struct {
 	Kind  TokenKind
 	Raw   string
-	Value interface{}
+	Value any
 	Index int
 }
 
@@ -256,7 +256,7 @@ func (l *Lexer) readNumber() *Token {
 		}
 	}
 	// Try to parse as float64
-	var val interface{} = raw
+	var val any = raw
 	if f, err := strconv.ParseFloat(raw, 64); err == nil {
 		val = f
 	}

internal/expr/lexer_additional_test.go

@@ -12,7 +12,7 @@ func TestLexerMultiple(t *testing.T) {
 	cases := []struct {
 		expr     string
 		expected []TokenKind
-		values   []interface{} // optional, nil if not checking values
+		values   []any // optional, nil if not checking values
 	}{
 		{
 			expr: "github.event_name == 'push'",
@@ -67,12 +67,12 @@ func TestLexerMultiple(t *testing.T) {
 		{
 			expr:     "true",
 			expected: []TokenKind{TokenKindBoolean},
-			values:   []interface{}{true},
+			values:   []any{true},
 		},
 		{
 			expr:     "123",
 			expected: []TokenKind{TokenKindNumber},
-			values:   []interface{}{123.0},
+			values:   []any{123.0},
 		},
 		{
 			expr:     "(a && b)",
@@ -85,7 +85,7 @@ func TestLexerMultiple(t *testing.T) {
 		{
 			expr:     "'Hello i''s escaped'",
 			expected: []TokenKind{TokenKindString},
-			values:   []interface{}{"Hello i's escaped"},
+			values:   []any{"Hello i's escaped"},
 		},
 	}
 
@@ -99,7 +99,7 @@ func TestLexerMultiple(t *testing.T) {
 			}
 			tokens = append(tokens, tok)
 		}
-		assert.Equal(t, len(tc.expected), len(tokens), "expression: %s", tc.expr)
+		assert.Len(t, tokens, len(tc.expected), "expression: %s", tc.expr)
 		for i, kind := range tc.expected {
 			assert.Equal(t, kind, tokens[i].Kind, "expr %s token %d", tc.expr, i)
 		}

internal/expr/lexer_test.go

@@ -22,13 +22,13 @@ func TestLexer(t *testing.T) {
 	for i, tok := range tokens {
 		t.Logf("Token %d: Kind=%v, Value=%v", i, tok.Kind, tok.Value)
 	}
-	assert.Equal(t, tokens[1].Kind, TokenKindDereference)
+	assert.Equal(t, TokenKindDereference, tokens[1].Kind)
 }
 
 func TestLexerNumbers(t *testing.T) {
 	table := []struct {
 		in  string
-		out interface{}
+		out any
 	}{
 		{"-Infinity", math.Inf(-1)},
 		{"Infinity", math.Inf(1)},

internal/model/strategy_utils.go

@@ -2,7 +2,7 @@ package model
 
 import (
 	"errors"
-	"fmt"
+	"maps"
 	"strings"
 
 	"gopkg.in/yaml.v3"
@@ -11,7 +11,7 @@ import (
 // TraceWriter is an interface for logging trace information.
 // Implementations can write to console, file, or any other sink.
 type TraceWriter interface {
-	Info(format string, args ...interface{})
+	Info(format string, args ...any)
 }
 
 // StrategyResult holds the result of expanding a strategy.
@@ -46,14 +46,14 @@ func (strategyContext *strategyContext) handleInclude() error {
 	if len(strategyContext.include) > 0 {
 		for _, incNode := range strategyContext.include {
 			if incNode.Kind != yaml.MappingNode {
-				return fmt.Errorf("include entry is not a mapping node")
+				return errors.New("include entry is not a mapping node")
 			}
 			incMap := make(map[string]yaml.Node)
 			for i := 0; i < len(incNode.Content); i += 2 {
 				keyNode := incNode.Content[i]
 				valNode := incNode.Content[i+1]
 				if keyNode.Kind != yaml.ScalarNode {
-					return fmt.Errorf("include key is not scalar")
+					return errors.New("include key is not scalar")
 				}
 				incMap[keyNode.Value] = *valNode
 			}
@@ -94,7 +94,7 @@ func (strategyContext *strategyContext) handleExclude() error {
 		for _, exNode := range strategyContext.exclude {
 			// exNode is expected to be a mapping node
 			if exNode.Kind != yaml.MappingNode {
-				return fmt.Errorf("exclude entry is not a mapping node")
+				return errors.New("exclude entry is not a mapping node")
 			}
 			// Convert mapping to map[string]yaml.Node
 			exMap := make(map[string]yaml.Node)
@@ -102,7 +102,7 @@ func (strategyContext *strategyContext) handleExclude() error {
 				keyNode := exNode.Content[i]
 				valNode := exNode.Content[i+1]
 				if keyNode.Kind != yaml.ScalarNode {
-					return fmt.Errorf("exclude key is not scalar")
+					return errors.New("exclude key is not scalar")
 				}
 				exMap[keyNode.Value] = *valNode
 			}
@@ -158,9 +158,7 @@ func ExpandStrategy(strategy *Strategy, jobTraceWriter TraceWriter) (*StrategyRe
 			for _, row := range strategyContext.flatMatrix {
 				for _, val := range values {
 					newRow := make(map[string]yaml.Node)
-					for k, v := range row {
-						newRow[k] = v
-					}
+					maps.Copy(newRow, row)
 					newRow[key] = val
 					next = append(next, newRow)
 				}

internal/model/strategy_utils_test.go

@@ -10,7 +10,7 @@ import (
 type EmptyTraceWriter struct {
 }
 
-func (e *EmptyTraceWriter) Info(_ string, _ ...interface{}) {
+func (e *EmptyTraceWriter) Info(_ string, _ ...any) {
 }
 
 func TestStrategy(t *testing.T) {

internal/model/workflow_state.go

@@ -96,7 +96,7 @@ func (a *On) UnmarshalYAML(node *yaml.Node) error {
 	return nil
 }
 
-func (a *On) MarshalYAML() (interface{}, error) {
+func (a *On) MarshalYAML() (any, error) {
 	return a.Data, nil
 }