feat(reflect): add struct test cases for Indirect function

Generated with [codeagent](https://github.com/qbox/codeagent)
Co-authored-by: luoliwoshang <luoliwoshang@users.noreply.github.com>

_cmptest/conversion_float/float_conv.go

@@ -1,107 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"math"
-)
-
-func main() {
-	fmt.Println("=== Float Type Conversions ===")
-
-	// 1. Float32 <-> Float64 precision
-	fmt.Println("\n1. Float32 <-> Float64 Precision:")
-	var f64 float64 = 1.23456789012345678901234567890
-	var f32 float32 = float32(f64)
-	var f64_2 float64 = float64(f32)
-	fmt.Printf("float64: %.20f\n", f64)
-	fmt.Printf("-> float32: %.20f\n", f32)
-	fmt.Printf("-> float64: %.20f\n", f64_2)
-
-	// 2. Special values
-	fmt.Println("\n2. Special Float Values:")
-	var inf64 float64 = math.Inf(1)
-	var inf32 float32 = float32(inf64)
-	fmt.Printf("float64(+Inf) -> float32: %v\n", inf32)
-
-	var negInf64 float64 = math.Inf(-1)
-	var negInf32 float32 = float32(negInf64)
-	fmt.Printf("float64(-Inf) -> float32: %v\n", negInf32)
-
-	var nan64 float64 = math.NaN()
-	var nan32 float32 = float32(nan64)
-	fmt.Printf("float64(NaN) -> float32: %v\n", nan32)
-
-	// 3. Float to Int conversions (normal range)
-	fmt.Println("\n3. Float to Int (Normal Range):")
-	var f1 float64 = 123.456
-	fmt.Printf("float64(123.456) -> int32: %d\n", int32(f1))
-	fmt.Printf("float64(123.456) -> uint32: %d\n", uint32(f1))
-
-	var f_neg float64 = -123.456
-	fmt.Printf("float64(-123.456) -> int32: %d\n", int32(f_neg))
-
-	// 4. Float to Int conversions (overflow/saturation)
-	fmt.Println("\n4. Float to Int (Overflow/Saturation):")
-	var f2 float64 = 1e20
-	fmt.Printf("float64(1e20) -> int32: %d\n", int32(f2))
-	fmt.Printf("float64(1e20) -> int8: %d\n", int8(f2))
-	fmt.Printf("float64(1e20) -> uint32: %d\n", uint32(f2))
-
-	var f3 float64 = -1e20
-	fmt.Printf("float64(-1e20) -> int32: %d\n", int32(f3))
-	fmt.Printf("float64(-1e20) -> int8: %d\n", int8(f3))
-
-	// 5. Negative float to unsigned
-	fmt.Println("\n5. Negative Float to Unsigned:")
-	var f4 float64 = -123.456
-	fmt.Printf("float64(-123.456) -> uint32: %d\n", uint32(f4))
-	fmt.Printf("float64(-123.456) -> uint8: %d\n", uint8(f4))
-
-	// 6. Special float values to int
-	fmt.Println("\n6. Special Float Values to Int:")
-	var fInf float64 = math.Inf(1)
-	fmt.Printf("float64(+Inf) -> int32: %d\n", int32(fInf))
-
-	var fNegInf float64 = math.Inf(-1)
-	fmt.Printf("float64(-Inf) -> int32: %d\n", int32(fNegInf))
-
-	var fNaN float64 = math.NaN()
-	fmt.Printf("float64(NaN) -> int32: %d\n", int32(fNaN))
-
-	// 7. Int to Float conversions (precision loss)
-	fmt.Println("\n7. Int to Float (Precision Loss):")
-	var i1 int64 = 9007199254740993 // 2^53 + 1
-	var ff1 float64 = float64(i1)
-	fmt.Printf("int64(9007199254740993) -> float64: %.0f\n", ff1)
-	fmt.Printf("Precision lost: %v\n", int64(ff1) != i1)
-
-	var i2 int32 = 16777217 // 2^24 + 1
-	var ff2 float32 = float32(i2)
-	fmt.Printf("int32(16777217) -> float32: %.0f\n", ff2)
-	fmt.Printf("Precision lost: %v\n", int32(ff2) != i2)
-
-	// 8. Large uint32 to float to int32 (the bug case)
-	fmt.Println("\n8. Large Uint32 -> Float64 -> Int32:")
-	var bigUint32 uint32 = 0xFFFFFFFF
-	var fBig float64 = float64(bigUint32)
-	var iBig int32 = int32(fBig)
-	fmt.Printf("uint32(0xFFFFFFFF) = %d\n", bigUint32)
-	fmt.Printf("-> float64 = %.0f\n", fBig)
-	fmt.Printf("-> int32 = %d\n", iBig)
-
-	// 9. Unsigned to float conversions
-	fmt.Println("\n9. Unsigned to Float:")
-	var u32 uint32 = 4000000000
-	var fU32_32 float32 = float32(u32)
-	var fU32_64 float64 = float64(u32)
-	fmt.Printf("uint32(4000000000) -> float32: %.0f\n", fU32_32)
-	fmt.Printf("uint32(4000000000) -> float64: %.0f\n", fU32_64)
-
-	// 10. Signed to float conversions
-	fmt.Println("\n10. Signed to Float:")
-	var s32 int32 = -2147483648 // MinInt32
-	var fS32_32 float32 = float32(s32)
-	var fS32_64 float64 = float64(s32)
-	fmt.Printf("int32(MinInt32) -> float32: %.0f\n", fS32_32)
-	fmt.Printf("int32(MinInt32) -> float64: %.0f\n", fS32_64)
-}

_cmptest/conversion_int/int_conv.go

@@ -1,66 +0,0 @@
-package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("=== Integer Type Conversions ===")
-
-	// 1. Signed/Unsigned conversions
-	fmt.Println("\n1. Negative to Unsigned:")
-	var negInt int32 = -1
-	fmt.Printf("int32(-1) -> uint32: %d (0x%X)\n", uint32(negInt), uint32(negInt))
-	fmt.Printf("int32(-1) -> uint8: %d (0x%X)\n", uint8(negInt), uint8(negInt))
-
-	var negInt64 int64 = -1234567890
-	fmt.Printf("int64(-1234567890) -> uint32: %d (0x%X)\n", uint32(negInt64), uint32(negInt64))
-
-	// 2. Large unsigned to signed
-	fmt.Println("\n2. Large Unsigned to Signed:")
-	var bigUint uint32 = 0xFFFFFFFF
-	fmt.Printf("uint32(0xFFFFFFFF) -> int32: %d\n", int32(bigUint))
-	fmt.Printf("uint32(0xFFFFFFFF) -> int16: %d\n", int16(bigUint))
-
-	var bigUint64 uint64 = 0xFFFFFFFFFFFFFFFF
-	fmt.Printf("uint64(max) -> int32: %d\n", int32(bigUint64))
-
-	// 3. Truncation (downward conversion)
-	fmt.Println("\n3. Truncation (Larger to Smaller):")
-	var i64 int64 = 0x123456789ABC
-	fmt.Printf("int64(0x123456789ABC) -> int32: 0x%X\n", int32(i64))
-	fmt.Printf("int64(0x123456789ABC) -> int16: 0x%X\n", int16(i64))
-	fmt.Printf("int64(0x123456789ABC) -> int8: 0x%X\n", int8(i64))
-
-	var u64 uint64 = 0xFFFFFFFFFFFFFFFF
-	fmt.Printf("uint64(max) -> uint32: 0x%X\n", uint32(u64))
-	fmt.Printf("uint64(max) -> uint16: 0x%X\n", uint16(u64))
-	fmt.Printf("uint64(max) -> uint8: 0x%X\n", uint8(u64))
-
-	// 4. Sign extension vs zero extension
-	fmt.Println("\n4. Sign Extension vs Zero Extension:")
-	var i8 int8 = -1
-	fmt.Printf("int8(-1) -> int16: %d (0x%04X)\n", int16(i8), uint16(int16(i8)))
-	fmt.Printf("int8(-1) -> int32: %d (0x%08X)\n", int32(i8), uint32(int32(i8)))
-	fmt.Printf("int8(-1) -> int64: %d (0x%016X)\n", int64(i8), uint64(int64(i8)))
-
-	var u8 uint8 = 0xFF
-	fmt.Printf("uint8(0xFF) -> uint16: %d (0x%04X)\n", uint16(u8), uint16(u8))
-	fmt.Printf("uint8(0xFF) -> uint32: %d (0x%08X)\n", uint32(u8), uint32(u8))
-
-	// 5. Mixed sign conversions with specific values
-	fmt.Println("\n5. Mixed Sign Conversions:")
-	var si16 int16 = -32768 // MinInt16
-	fmt.Printf("int16(MinInt16) -> uint16: %d\n", uint16(si16))
-
-	var su16 uint16 = 32768
-	fmt.Printf("uint16(32768) -> int16: %d\n", int16(su16))
-
-	// 6. Boundary values
-	fmt.Println("\n6. Boundary Value Conversions:")
-	var maxI8 int8 = 127
-	var minI8 int8 = -128
-	fmt.Printf("int8(MaxInt8=%d) -> uint8: %d\n", maxI8, uint8(maxI8))
-	fmt.Printf("int8(MinInt8=%d) -> uint8: %d\n", minI8, uint8(minI8))
-
-	var maxU8 uint8 = 255
-	fmt.Printf("uint8(MaxUint8=%d) -> int8: %d\n", maxU8, int8(maxU8))
-}

_cmptest/conversion_overflow/overflow.go

@@ -1,131 +0,0 @@
-package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("=== Overflow and Wrapping Behavior ===")
-
-	// 1. Signed integer overflow
-	fmt.Println("\n1. Signed Integer Overflow:")
-	var i8max int8 = 127
-	var i8min int8 = -128
-	fmt.Printf("int8 max (127) + 1 = %d\n", i8max+1)
-	fmt.Printf("int8 max (127) + 2 = %d\n", i8max+2)
-	fmt.Printf("int8 min (-128) - 1 = %d\n", i8min-1)
-	fmt.Printf("int8 min (-128) - 2 = %d\n", i8min-2)
-
-	var i16max int16 = 32767
-	var i16min int16 = -32768
-	fmt.Printf("int16 max (32767) + 1 = %d\n", i16max+1)
-	fmt.Printf("int16 min (-32768) - 1 = %d\n", i16min-1)
-
-	var i32max int32 = 2147483647
-	var i32min int32 = -2147483648
-	fmt.Printf("int32 max + 1 = %d\n", i32max+1)
-	fmt.Printf("int32 min - 1 = %d\n", i32min-1)
-
-	// 2. Unsigned integer overflow
-	fmt.Println("\n2. Unsigned Integer Overflow:")
-	var u8max uint8 = 255
-	fmt.Printf("uint8 max (255) + 1 = %d\n", u8max+1)
-	fmt.Printf("uint8 max (255) + 2 = %d\n", u8max+2)
-	fmt.Printf("uint8(0) - 1 = %d\n", uint8(0)-1)
-
-	var u16max uint16 = 65535
-	fmt.Printf("uint16 max (65535) + 1 = %d\n", u16max+1)
-	fmt.Printf("uint16(0) - 1 = %d\n", uint16(0)-1)
-
-	var u32max uint32 = 4294967295
-	fmt.Printf("uint32 max + 1 = %d\n", u32max+1)
-	fmt.Printf("uint32(0) - 1 = %d\n", uint32(0)-1)
-
-	// 3. Multiplication overflow
-	fmt.Println("\n3. Multiplication Overflow:")
-	var mi8 int8 = 64
-	fmt.Printf("int8(64) * 2 = %d\n", mi8*2)
-	fmt.Printf("int8(64) * 3 = %d\n", mi8*3)
-
-	var mi16 int16 = 256
-	fmt.Printf("int16(256) * 128 = %d\n", mi16*128)
-	fmt.Printf("int16(256) * 256 = %d\n", mi16*256)
-
-	// 4. Subtraction underflow
-	fmt.Println("\n4. Subtraction Underflow:")
-	var s8 int8 = -100
-	fmt.Printf("int8(-100) - 30 = %d\n", s8-30)
-	fmt.Printf("int8(-100) - 50 = %d\n", s8-50)
-
-	// 5. Mixed operations causing overflow
-	fmt.Println("\n5. Mixed Operations Causing Overflow:")
-	var m1 int8 = 100
-	var m2 int8 = 50
-	fmt.Printf("int8(100) + int8(50) = %d\n", m1+m2)
-
-	var m3 int8 = 127
-	var m4 int8 = 1
-	fmt.Printf("int8(127) + int8(1) = %d\n", m3+m4)
-
-	// 6. Boundary arithmetic
-	fmt.Println("\n6. Boundary Value Arithmetic:")
-	var b1 int8 = 127
-	var b2 int8 = 127
-	fmt.Printf("int8(127) + int8(127) = %d\n", b1+b2)
-
-	var b3 int8 = -128
-	var b4 int8 = -128
-	fmt.Printf("int8(-128) + int8(-128) = %d\n", b3+b4)
-
-	// 7. Division edge cases
-	fmt.Println("\n7. Division Edge Cases:")
-	var d1 int8 = -128
-	var d2 int8 = -1
-	fmt.Printf("int8(-128) / int8(-1) = %d\n", d1/d2)
-
-	var d3 int32 = -2147483648
-	var d4 int32 = -1
-	fmt.Printf("int32(MinInt32) / int32(-1) = %d\n", d3/d4)
-
-	// 8. Negation overflow
-	fmt.Println("\n8. Negation Overflow:")
-	var n1 int8 = -128
-	fmt.Printf("-int8(-128) = %d\n", -n1)
-
-	var n2 int32 = -2147483648
-	fmt.Printf("-int32(MinInt32) = %d\n", -n2)
-
-	// 9. Shift operations with overflow
-	fmt.Println("\n9. Shift Operations:")
-	var sh1 int8 = 1
-	fmt.Printf("int8(1) << 7 = %d\n", sh1<<7)
-	fmt.Printf("int8(1) << 8 = %d\n", sh1<<8)
-
-	var sh2 int16 = 1
-	fmt.Printf("int16(1) << 15 = %d\n", sh2<<15)
-	fmt.Printf("int16(1) << 16 = %d\n", sh2<<16)
-
-	// 10. Increment/decrement at boundaries
-	fmt.Println("\n10. Increment/Decrement at Boundaries:")
-	var inc1 int8 = 126
-	inc1++
-	fmt.Printf("int8(126)++ = %d\n", inc1)
-	inc1++
-	fmt.Printf("int8(127)++ = %d\n", inc1)
-
-	var dec1 int8 = -127
-	dec1--
-	fmt.Printf("int8(-127)-- = %d\n", dec1)
-	dec1--
-	fmt.Printf("int8(-128)-- = %d\n", dec1)
-
-	var inc2 uint8 = 254
-	inc2++
-	fmt.Printf("uint8(254)++ = %d\n", inc2)
-	inc2++
-	fmt.Printf("uint8(255)++ = %d\n", inc2)
-
-	var dec2 uint8 = 1
-	dec2--
-	fmt.Printf("uint8(1)-- = %d\n", dec2)
-	dec2--
-	fmt.Printf("uint8(0)-- = %d\n", dec2)
-}

_cmptest/conversion_untyped/untyped_conv.go

@@ -1,117 +0,0 @@
-package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("=== Untyped Constant Conversions ===")
-
-	// 1. Untyped int with typed variables
-	fmt.Println("\n1. Untyped Int with Typed Variables:")
-	const untypedInt = 42
-	var i8 int8 = 100
-	var i16 int16 = 1000
-	var i32 int32 = 70000
-	var i64 int64 = 1 << 32
-
-	fmt.Printf("untypedInt(42) + int8(100): %d (type %T)\n", untypedInt+i8, untypedInt+i8)
-	fmt.Printf("untypedInt(42) + int16(1000): %d (type %T)\n", untypedInt+i16, untypedInt+i16)
-	fmt.Printf("untypedInt(42) + int32(70000): %d (type %T)\n", untypedInt+i32, untypedInt+i32)
-	fmt.Printf("untypedInt(42) + int64(1<<32): %d (type %T)\n", untypedInt+i64, untypedInt+i64)
-
-	// 2. Untyped float with typed variables
-	fmt.Println("\n2. Untyped Float with Typed Variables:")
-	const untypedFloat = 3.14
-	var f32 float32 = 2.5
-	var f64 float64 = 2.5
-
-	fmt.Printf("untypedFloat(3.14) + float32(2.5): %f (type %T)\n", untypedFloat+f32, untypedFloat+f32)
-	fmt.Printf("untypedFloat(3.14) + float64(2.5): %f (type %T)\n", untypedFloat+f64, untypedFloat+f64)
-
-	// 3. Untyped complex with typed variables
-	fmt.Println("\n3. Untyped Complex with Typed Variables:")
-	const untypedComplex = 1 + 2i
-	var c64 complex64 = 1 + 2i
-	var c128 complex128 = 1 + 2i
-
-	fmt.Printf("untypedComplex(1+2i) + complex64(1+2i): %v (type %T)\n", untypedComplex+c64, untypedComplex+c64)
-	fmt.Printf("untypedComplex(1+2i) + complex128(1+2i): %v (type %T)\n", untypedComplex+c128, untypedComplex+c128)
-
-	// 4. Untyped bool
-	fmt.Println("\n4. Untyped Bool:")
-	const untypedBool = true
-	const untypedBoolFalse = false
-	var b1 bool = untypedBool
-	var b2 bool = untypedBoolFalse
-	fmt.Printf("untypedBool(true): %v (type %T)\n", b1, b1)
-	fmt.Printf("untypedBool(false): %v (type %T)\n", b2, b2)
-
-	// 5. Untyped string
-	fmt.Println("\n5. Untyped String:")
-	const untypedString = "hello"
-	var s1 string = untypedString
-	fmt.Printf("untypedString: %s (type %T)\n", s1, s1)
-
-	// 6. Untyped rune
-	fmt.Println("\n6. Untyped Rune:")
-	const untypedRune = 'A'
-	var r1 rune = untypedRune
-	var r2 int32 = untypedRune
-	fmt.Printf("untypedRune('A'): %c = %d (type %T)\n", r1, r1, r1)
-	fmt.Printf("untypedRune('A') as int32: %d (type %T)\n", r2, r2)
-
-	// 7. Untyped constant expressions
-	fmt.Println("\n7. Untyped Constant Expressions:")
-	const c1 = 1 << 10
-	const c2 = c1 * 1024
-	const c3 = float64(c2) / 3.0
-	const c4 = int(c3)
-
-	fmt.Printf("1 << 10 = %d\n", c1)
-	fmt.Printf("(1 << 10) * 1024 = %d\n", c2)
-	fmt.Printf("float64(c2) / 3.0 = %f\n", c3)
-	fmt.Printf("int(c3) = %d\n", c4)
-
-	// 8. Untyped operations
-	fmt.Println("\n8. Untyped Operations:")
-	const a = 100
-	const b = 200
-	const c = a + b
-	const d = a * b
-	const e = b / a
-	const f = b % a
-
-	fmt.Printf("100 + 200 = %d\n", c)
-	fmt.Printf("100 * 200 = %d\n", d)
-	fmt.Printf("200 / 100 = %d\n", e)
-	fmt.Printf("200 %% 100 = %d\n", f)
-
-	// 9. Mixed untyped and typed in expressions
-	fmt.Println("\n9. Mixed Untyped and Typed in Expressions:")
-	const uConst = 10
-	var v1 int8 = 5
-	var v2 int16 = 10
-	var v3 int32 = 20
-
-	// These should take the type of the typed variable
-	var result1 = uConst + v1
-	var result2 = uConst + v2
-	var result3 = uConst + v3
-
-	fmt.Printf("const(10) + int8(5) = %d (type %T)\n", result1, result1)
-	fmt.Printf("const(10) + int16(10) = %d (type %T)\n", result2, result2)
-	fmt.Printf("const(10) + int32(20) = %d (type %T)\n", result3, result3)
-
-	// 10. Untyped zero values
-	fmt.Println("\n10. Untyped Zero Values:")
-	const zero = 0
-	const zeroFloat = 0.0
-	const emptyString = ""
-
-	var iz int32 = zero
-	var fz float64 = zeroFloat
-	var sz string = emptyString
-
-	fmt.Printf("untyped 0 -> int32: %d (type %T)\n", iz, iz)
-	fmt.Printf("untyped 0.0 -> float64: %f (type %T)\n", fz, fz)
-	fmt.Printf("untyped \"\" -> string: %q (type %T)\n", sz, sz)
-}

_demo/go/reflectindirect/reflect-indirect.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"reflect"
+)
+
+func main() {
+	x := 42
+	p := &x
+
+	// Test 1: Non-pointer value - should return same value
+	v1 := reflect.Indirect(reflect.ValueOf(x))
+	if !v1.IsValid() || v1.Interface() != 42 {
+		panic("Non-pointer test failed: expected 42")
+	}
+
+	// Test 2: Pointer - should dereference
+	v2 := reflect.Indirect(reflect.ValueOf(p))
+	if !v2.IsValid() || v2.Interface() != 42 {
+		panic("Pointer dereference test failed: expected 42")
+	}
+
+	// Test 3: Nil pointer - should return invalid Value
+	var nilPtr *int
+	v3 := reflect.Indirect(reflect.ValueOf(nilPtr))
+	if v3.IsValid() {
+		panic("Nil pointer test failed: expected invalid Value")
+	}
+
+	// Test 4: Struct value - should return same value
+	type Person struct {
+		Name string
+		Age  int
+	}
+	person := Person{Name: "Alice", Age: 30}
+	v4 := reflect.Indirect(reflect.ValueOf(person))
+	if !v4.IsValid() || v4.Interface().(Person).Name != "Alice" || v4.Interface().(Person).Age != 30 {
+		panic("Struct value test failed: expected Person{Name: Alice, Age: 30}")
+	}
+
+	// Test 5: Struct pointer - should dereference
+	personPtr := &Person{Name: "Bob", Age: 25}
+	v5 := reflect.Indirect(reflect.ValueOf(personPtr))
+	if !v5.IsValid() || v5.Interface().(Person).Name != "Bob" || v5.Interface().(Person).Age != 25 {
+		panic("Struct pointer test failed: expected Person{Name: Bob, Age: 25}")
+	}
+
+	println("PASS")
+}

runtime/internal/lib/reflect/value.go

@@ -1759,6 +1759,16 @@ func ValueOf(i any) Value {
 	return unpackEface(i)
 }
 
+// Indirect returns the value that v points to.
+// If v is a nil pointer, Indirect returns a zero Value.
+// If v is not a pointer, Indirect returns v.
+func Indirect(v Value) Value {
+	if v.Kind() != Pointer {
+		return v
+	}
+	return v.Elem()
+}
+
 // arrayAt returns the i-th element of p,
 // an array whose elements are eltSize bytes wide.
 // The array pointed at by p must have at least i+1 elements: