Prevent filter and array from needlessly weakening types

checker/checker.go

@@ -623,9 +623,9 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 				return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String())
 			}
 			if isAny(collection) {
-				return arrayType, info{}
+				return anyArrayType, info{}
 			}
-			return arrayType, info{}
+			return collection, info{}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
@@ -643,7 +643,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) {
 			closure.NumOut() == 1 &&
 			closure.NumIn() == 1 && isAny(closure.In(0)) {
 
-			return arrayType, info{}
+			return anyArrayType, info{}
 		}
 		return v.error(node.Arguments[1], "predicate should has one input and one output param")
 
@@ -1122,9 +1122,9 @@ func (v *checker) ArrayNode(node *ast.ArrayNode) (reflect.Type, info) {
 		prev = curr
 	}
 	if allElementsAreSameType && prev != nil {
-		return arrayType, info{elem: prev}
+		return arrayType(prev), info{elem: prev}
 	}
-	return arrayType, info{}
+	return anyArrayType, info{}
 }
 
 func (v *checker) MapNode(node *ast.MapNode) (reflect.Type, info) {

checker/checker_test.go

@@ -974,3 +974,21 @@ func TestCheck_builtin_without_call(t *testing.T) {
 		})
 	}
 }
+
+func TestCheck_types(t *testing.T) {
+	tests := []struct {
+		input    string
+		nodeType reflect.Type
+	}{
+		{`filter([1,2,3], # > 1)`, reflect.TypeOf([]int{})},
+	}
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			tree, err := parser.Parse(test.input)
+			require.NoError(t, err)
+
+			nodeType, err := checker.Check(tree, conf.New(nil))
+			require.Equal(t, test.nodeType.String(), nodeType.String())
+		})
+	}
+}

checker/types.go

@@ -13,13 +13,17 @@ var (
 	integerType  = reflect.TypeOf(0)
 	floatType    = reflect.TypeOf(float64(0))
 	stringType   = reflect.TypeOf("")
-	arrayType    = reflect.TypeOf([]any{})
+	anyArrayType = reflect.TypeOf([]any{})
 	mapType      = reflect.TypeOf(map[string]any{})
 	anyType      = reflect.TypeOf(new(any)).Elem()
 	timeType     = reflect.TypeOf(time.Time{})
 	durationType = reflect.TypeOf(time.Duration(0))
 )
 
+func arrayType(t reflect.Type) reflect.Type {
+	return reflect.SliceOf(t)
+}
+
 func combined(a, b reflect.Type) reflect.Type {
 	if a.Kind() == b.Kind() {
 		return a