feat: not support list

Author: AsterDY

trim/assign.go

@@ -160,8 +160,6 @@ func assignValue(desc *Descriptor, src interface{}, destValue reflect.Value, opt
 	switch desc.Kind {
 	case TypeKind_Struct:
 		return assignStruct(desc, src, destValue, opt)
-	case TypeKind_List:
-		return assignList(desc, src, destValue, opt)
 	case TypeKind_StrMap:
 		return assignStrMap(desc, src, destValue, opt)
 	default:
@@ -281,71 +279,6 @@ func assignValueToField(desc *Descriptor, src interface{}, fieldValue reflect.Va
 	return assignValue(desc, src, fieldValue, opt)
 }
 
-// assignList handles TypeKind_List assignment
-func assignList(desc *Descriptor, src interface{}, destValue reflect.Value, opt *AssignOptions) error {
-	srcSlice, ok := src.([]interface{})
-	if !ok {
-		// Try to handle typed slices
-		srcValue := reflect.ValueOf(src)
-		if srcValue.Kind() != reflect.Slice && srcValue.Kind() != reflect.Array {
-			return fmt.Errorf("expected slice for list, got %T", src)
-		}
-		// Convert to []interface{}
-		srcSlice = make([]interface{}, srcValue.Len())
-		for i := 0; i < srcValue.Len(); i++ {
-			srcSlice[i] = srcValue.Index(i).Interface()
-		}
-	}
-
-	if destValue.Kind() != reflect.Slice {
-		return fmt.Errorf("expected slice destination, got %v", destValue.Kind())
-	}
-
-	// Find wildcard or indexed descriptors
-	var wildcardDesc *Descriptor
-	indexDescMap := make(map[int]*Descriptor, len(desc.Children))
-	for i := range desc.Children {
-		child := &desc.Children[i]
-		if child.Name == "*" {
-			wildcardDesc = child.Desc
-		} else {
-			indexDescMap[child.ID] = child.Desc
-		}
-	}
-
-	// Create a new slice with the same length as src
-	newSlice := reflect.MakeSlice(destValue.Type(), len(srcSlice), len(srcSlice))
-
-	for i, elem := range srcSlice {
-		if elem == nil {
-			continue
-		}
-
-		elemValue := newSlice.Index(i)
-
-		// Find the appropriate descriptor
-		var childDesc *Descriptor
-		if d, ok := indexDescMap[i]; ok {
-			childDesc = d
-		} else {
-			childDesc = wildcardDesc
-		}
-
-		if childDesc != nil {
-			if err := assignValueToField(childDesc, elem, elemValue, opt); err != nil {
-				return err
-			}
-		} else {
-			if err := assignScalar(elem, elemValue); err != nil {
-				return err
-			}
-		}
-	}
-
-	destValue.Set(newSlice)
-	return nil
-}
-
 // assignStrMap handles TypeKind_StrMap assignment
 func assignStrMap(desc *Descriptor, src interface{}, destValue reflect.Value, opt *AssignOptions) error {
 	srcMap, ok := src.(map[string]interface{})

trim/assign_test.go

@@ -126,7 +126,7 @@ func TestAssignAny_NestedStruct(t *testing.T) {
 
 func TestAssignAny_List(t *testing.T) {
 	src := map[string]interface{}{
-		"field_list": []interface{}{1, 2, 3},
+		"field_list": []int{1, 2, 3},
 	}
 
 	desc := &Descriptor{
@@ -137,11 +137,8 @@ func TestAssignAny_List(t *testing.T) {
 				Name: "field_list",
 				ID:   6,
 				Desc: &Descriptor{
-					Kind: TypeKind_List,
+					Kind: TypeKind_Scalar,
 					Name: "LIST",
-					Children: []Field{
-						{Name: "*"},
-					},
 				},
 			},
 		},
@@ -282,27 +279,28 @@ func TestAssignAny_UnknownFields(t *testing.T) {
 }
 
 func TestAssignAny_ListOfStructs(t *testing.T) {
+
 	src := map[string]interface{}{
-		"field_b": []interface{}{
-			map[string]interface{}{
-				"field_a": 1,
-				"field_e": "first",
+		"field_b": []*SampleAssign{
+			{
+				FieldA: intPtr(1),
+				FieldE: "first",
 			},
-			map[string]interface{}{
-				"field_a": 2,
-				"field_e": "second",
+			{
+				FieldA: intPtr(2),
+				FieldE: "second",
 			},
 		},
 	}
 
-	nestedDesc := &Descriptor{
-		Kind: TypeKind_Struct,
-		Name: "SampleAssign",
-		Children: []Field{
-			{Name: "field_a", ID: 1},
-			{Name: "field_e", ID: 5},
-		},
-	}
+	// nestedDesc := &Descriptor{
+	// 	Kind: TypeKind_Struct,
+	// 	Name: "SampleAssign",
+	// 	Children: []Field{
+	// 		{Name: "field_a", ID: 1},
+	// 		{Name: "field_e", ID: 5},
+	// 	},
+	// }
 
 	desc := &Descriptor{
 		Kind: TypeKind_Struct,
@@ -312,11 +310,8 @@ func TestAssignAny_ListOfStructs(t *testing.T) {
 				Name: "field_b",
 				ID:   2,
 				Desc: &Descriptor{
-					Kind: TypeKind_List,
+					Kind: TypeKind_Scalar,
 					Name: "LIST",
-					Children: []Field{
-						{Name: "*", Desc: nestedDesc},
-					},
 				},
 			},
 		},
@@ -474,9 +469,8 @@ func BenchmarkAssignAny(b *testing.B) {
 				Name: "field_list",
 				ID:   6,
 				Desc: &Descriptor{
-					Kind:     TypeKind_List,
-					Name:     "LIST",
-					Children: []Field{{Name: "*"}},
+					Kind: TypeKind_Scalar,
+					Name: "LIST",
 				},
 			},
 			{

trim/desc.go

@@ -24,9 +24,10 @@ import (
 type TypeKind int
 
 const (
-	TypeKind_Struct TypeKind = iota + 1
+	TypeKind_Scalar TypeKind = iota
+	TypeKind_Struct
 	TypeKind_StrMap
-	TypeKind_List
+	// TypeKind_List
 )
 
 // Descriptor describes the entire a DSL-pruning scheme for a type.
@@ -40,7 +41,6 @@ type Descriptor struct {
 	Name string
 
 	// children for TypeKind_Struct|TypeKind_StrMap|TypeKind_List
-	// - For TypeKind_List, there is either one Field with Name "*" or index as ID
 	// - For TypeKind_StrMap, either each Field is a key-value pair or one field with Name "*"
 	// - For TypeKind_Struct, each Field is a field with both Name and ID
 	Children []Field
@@ -52,7 +52,7 @@ type Field struct {
 	// Or the selection key for TypeKind_StrMap
 	Name string
 
-	// IDL-FieldID or Array-Index
+	// FieldID in IDL
 	ID int
 
 	// the child of the field

trim/fetch.go

@@ -128,9 +128,6 @@ func fetchValue(desc *Descriptor, v reflect.Value, opt *FetchOptions) (interface
 	case TypeKind_Struct:
 		return fetchStruct(desc, v, opt)
 
-	case TypeKind_List:
-		return fetchList(desc, v, opt)
-
 	case TypeKind_StrMap:
 		return fetchStrMap(desc, v, opt)
 
@@ -271,37 +268,6 @@ func fetchUnknownValue(val interface{}, desc *Descriptor) interface{} {
 		}
 		return result
 
-	case TypeKind_List:
-		// ReadAny returns []interface{} for LIST type
-		listVal, ok := val.([]interface{})
-		if !ok {
-			return val
-		}
-
-		// Find wildcard or indexed descriptors
-		var wildcardDesc *Descriptor
-		indexDescMap := make(map[int]*Descriptor, len(desc.Children))
-		for i := range desc.Children {
-			child := &desc.Children[i]
-			if child.Name == "*" {
-				wildcardDesc = child.Desc
-			} else {
-				indexDescMap[child.ID] = child.Desc
-			}
-		}
-
-		result := make([]interface{}, len(listVal))
-		for i, elem := range listVal {
-			if childDesc, ok := indexDescMap[i]; ok {
-				result[i] = fetchUnknownValue(elem, childDesc)
-			} else if wildcardDesc != nil {
-				result[i] = fetchUnknownValue(elem, wildcardDesc)
-			} else {
-				result[i] = elem
-			}
-		}
-		return result
-
 	case TypeKind_StrMap:
 		// ReadAny returns map[string]interface{} for string-keyed MAP type
 		strMap, ok := val.(map[string]interface{})
@@ -338,91 +304,6 @@ func fetchUnknownValue(val interface{}, desc *Descriptor) interface{} {
 	}
 }
 
-// fetchList handles TypeKind_List
-func fetchList(desc *Descriptor, v reflect.Value, opt *FetchOptions) (interface{}, error) {
-	kind := v.Kind()
-	if kind != reflect.Slice && kind != reflect.Array {
-		return nil, nil
-	}
-
-	childrenLen := len(desc.Children)
-	vLen := v.Len()
-
-	// Fast path: only wildcard descriptor
-	if childrenLen == 1 && desc.Children[0].Name == "*" {
-		wildcardDesc := desc.Children[0].Desc
-		result := make([]interface{}, 0, vLen)
-		for i := 0; i < vLen; i++ {
-			elem := v.Index(i)
-			if elem.Kind() == reflect.Ptr && elem.IsNil() {
-				result = append(result, nil)
-				continue
-			}
-			if wildcardDesc != nil {
-				fetched, err := fetchValue(wildcardDesc, elem, opt)
-				if err != nil {
-					return nil, err
-				}
-				result = append(result, fetched)
-			} else {
-				result = append(result, elem.Interface())
-			}
-		}
-		return result, nil
-	}
-
-	// Build a map of index -> descriptor for quick lookup
-	indexDescMap := make(map[int]*Field, childrenLen)
-	var wildcardDesc *Field
-	for i := range desc.Children {
-		child := &desc.Children[i]
-		if child.Name == "*" {
-			wildcardDesc = child
-		} else {
-			// Field.ID represents the slice index
-			indexDescMap[child.ID] = child
-		}
-	}
-
-	// Check if specific indices are requested but not available
-	if opt.DisallowNotFound {
-		for idx := range indexDescMap {
-			if idx >= vLen {
-				return nil, ErrNotFound{Parent: desc, Field: indexDescMap[idx], Msg: fmt.Sprintf("index %d out of range (len=%d)", idx, vLen)}
-			}
-		}
-	}
-
-	result := make([]interface{}, 0, vLen)
-	for i := 0; i < vLen; i++ {
-		elem := v.Index(i)
-		if elem.Kind() == reflect.Ptr && elem.IsNil() {
-			result = append(result, nil)
-			continue
-		}
-
-		// First try to find descriptor by index (Field.ID)
-		var childDesc *Descriptor
-		if field, ok := indexDescMap[i]; ok && field.Desc != nil {
-			childDesc = field.Desc
-		} else if wildcardDesc != nil && wildcardDesc.Desc != nil {
-			// Fallback to wildcard descriptor
-			childDesc = wildcardDesc.Desc
-		}
-
-		if childDesc != nil {
-			fetched, err := fetchValue(childDesc, elem, opt)
-			if err != nil {
-				return nil, err
-			}
-			result = append(result, fetched)
-		} else {
-			result = append(result, elem.Interface())
-		}
-	}
-	return result, nil
-}
-
 // fetchStrMap handles TypeKind_StrMap
 func fetchStrMap(desc *Descriptor, v reflect.Value, opt *FetchOptions) (interface{}, error) {
 	if v.Kind() != reflect.Map || v.Type().Key().Kind() != reflect.String {