summaryrefslogtreecommitdiff
path: root/src/pkg/reflect
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/reflect')
-rw-r--r--src/pkg/reflect/all_test.go3841
-rw-r--r--src/pkg/reflect/asm_386.s27
-rw-r--r--src/pkg/reflect/asm_amd64.s27
-rw-r--r--src/pkg/reflect/asm_amd64p32.s27
-rw-r--r--src/pkg/reflect/asm_arm.s27
-rw-r--r--src/pkg/reflect/deepequal.go145
-rw-r--r--src/pkg/reflect/example_test.go66
-rw-r--r--src/pkg/reflect/export_test.go19
-rw-r--r--src/pkg/reflect/makefunc.go120
-rw-r--r--src/pkg/reflect/set_test.go211
-rw-r--r--src/pkg/reflect/tostring_test.go95
-rw-r--r--src/pkg/reflect/type.go1926
-rw-r--r--src/pkg/reflect/value.go2684
13 files changed, 0 insertions, 9215 deletions
diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go
deleted file mode 100644
index e9949012c..000000000
--- a/src/pkg/reflect/all_test.go
+++ /dev/null
@@ -1,3841 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package reflect_test
-
-import (
- "bytes"
- "encoding/base64"
- "flag"
- "fmt"
- "io"
- "math/rand"
- "os"
- . "reflect"
- "runtime"
- "sort"
- "strings"
- "sync"
- "testing"
- "time"
- "unsafe"
-)
-
-func TestBool(t *testing.T) {
- v := ValueOf(true)
- if v.Bool() != true {
- t.Fatal("ValueOf(true).Bool() = false")
- }
-}
-
-type integer int
-type T struct {
- a int
- b float64
- c string
- d *int
-}
-
-type pair struct {
- i interface{}
- s string
-}
-
-func isDigit(c uint8) bool { return '0' <= c && c <= '9' }
-
-func assert(t *testing.T, s, want string) {
- if s != want {
- t.Errorf("have %#q want %#q", s, want)
- }
-}
-
-func typestring(i interface{}) string { return TypeOf(i).String() }
-
-var typeTests = []pair{
- {struct{ x int }{}, "int"},
- {struct{ x int8 }{}, "int8"},
- {struct{ x int16 }{}, "int16"},
- {struct{ x int32 }{}, "int32"},
- {struct{ x int64 }{}, "int64"},
- {struct{ x uint }{}, "uint"},
- {struct{ x uint8 }{}, "uint8"},
- {struct{ x uint16 }{}, "uint16"},
- {struct{ x uint32 }{}, "uint32"},
- {struct{ x uint64 }{}, "uint64"},
- {struct{ x float32 }{}, "float32"},
- {struct{ x float64 }{}, "float64"},
- {struct{ x int8 }{}, "int8"},
- {struct{ x (**int8) }{}, "**int8"},
- {struct{ x (**integer) }{}, "**reflect_test.integer"},
- {struct{ x ([32]int32) }{}, "[32]int32"},
- {struct{ x ([]int8) }{}, "[]int8"},
- {struct{ x (map[string]int32) }{}, "map[string]int32"},
- {struct{ x (chan<- string) }{}, "chan<- string"},
- {struct {
- x struct {
- c chan *int32
- d float32
- }
- }{},
- "struct { c chan *int32; d float32 }",
- },
- {struct{ x (func(a int8, b int32)) }{}, "func(int8, int32)"},
- {struct {
- x struct {
- c func(chan *integer, *int8)
- }
- }{},
- "struct { c func(chan *reflect_test.integer, *int8) }",
- },
- {struct {
- x struct {
- a int8
- b int32
- }
- }{},
- "struct { a int8; b int32 }",
- },
- {struct {
- x struct {
- a int8
- b int8
- c int32
- }
- }{},
- "struct { a int8; b int8; c int32 }",
- },
- {struct {
- x struct {
- a int8
- b int8
- c int8
- d int32
- }
- }{},
- "struct { a int8; b int8; c int8; d int32 }",
- },
- {struct {
- x struct {
- a int8
- b int8
- c int8
- d int8
- e int32
- }
- }{},
- "struct { a int8; b int8; c int8; d int8; e int32 }",
- },
- {struct {
- x struct {
- a int8
- b int8
- c int8
- d int8
- e int8
- f int32
- }
- }{},
- "struct { a int8; b int8; c int8; d int8; e int8; f int32 }",
- },
- {struct {
- x struct {
- a int8 `reflect:"hi there"`
- }
- }{},
- `struct { a int8 "reflect:\"hi there\"" }`,
- },
- {struct {
- x struct {
- a int8 `reflect:"hi \x00there\t\n\"\\"`
- }
- }{},
- `struct { a int8 "reflect:\"hi \\x00there\\t\\n\\\"\\\\\"" }`,
- },
- {struct {
- x struct {
- f func(args ...int)
- }
- }{},
- "struct { f func(...int) }",
- },
- {struct {
- x (interface {
- a(func(func(int) int) func(func(int)) int)
- b()
- })
- }{},
- "interface { reflect_test.a(func(func(int) int) func(func(int)) int); reflect_test.b() }",
- },
-}
-
-var valueTests = []pair{
- {new(int), "132"},
- {new(int8), "8"},
- {new(int16), "16"},
- {new(int32), "32"},
- {new(int64), "64"},
- {new(uint), "132"},
- {new(uint8), "8"},
- {new(uint16), "16"},
- {new(uint32), "32"},
- {new(uint64), "64"},
- {new(float32), "256.25"},
- {new(float64), "512.125"},
- {new(complex64), "532.125+10i"},
- {new(complex128), "564.25+1i"},
- {new(string), "stringy cheese"},
- {new(bool), "true"},
- {new(*int8), "*int8(0)"},
- {new(**int8), "**int8(0)"},
- {new([5]int32), "[5]int32{0, 0, 0, 0, 0}"},
- {new(**integer), "**reflect_test.integer(0)"},
- {new(map[string]int32), "map[string]int32{<can't iterate on maps>}"},
- {new(chan<- string), "chan<- string"},
- {new(func(a int8, b int32)), "func(int8, int32)(0)"},
- {new(struct {
- c chan *int32
- d float32
- }),
- "struct { c chan *int32; d float32 }{chan *int32, 0}",
- },
- {new(struct{ c func(chan *integer, *int8) }),
- "struct { c func(chan *reflect_test.integer, *int8) }{func(chan *reflect_test.integer, *int8)(0)}",
- },
- {new(struct {
- a int8
- b int32
- }),
- "struct { a int8; b int32 }{0, 0}",
- },
- {new(struct {
- a int8
- b int8
- c int32
- }),
- "struct { a int8; b int8; c int32 }{0, 0, 0}",
- },
-}
-
-func testType(t *testing.T, i int, typ Type, want string) {
- s := typ.String()
- if s != want {
- t.Errorf("#%d: have %#q, want %#q", i, s, want)
- }
-}
-
-func TestTypes(t *testing.T) {
- for i, tt := range typeTests {
- testType(t, i, ValueOf(tt.i).Field(0).Type(), tt.s)
- }
-}
-
-func TestSet(t *testing.T) {
- for i, tt := range valueTests {
- v := ValueOf(tt.i)
- v = v.Elem()
- switch v.Kind() {
- case Int:
- v.SetInt(132)
- case Int8:
- v.SetInt(8)
- case Int16:
- v.SetInt(16)
- case Int32:
- v.SetInt(32)
- case Int64:
- v.SetInt(64)
- case Uint:
- v.SetUint(132)
- case Uint8:
- v.SetUint(8)
- case Uint16:
- v.SetUint(16)
- case Uint32:
- v.SetUint(32)
- case Uint64:
- v.SetUint(64)
- case Float32:
- v.SetFloat(256.25)
- case Float64:
- v.SetFloat(512.125)
- case Complex64:
- v.SetComplex(532.125 + 10i)
- case Complex128:
- v.SetComplex(564.25 + 1i)
- case String:
- v.SetString("stringy cheese")
- case Bool:
- v.SetBool(true)
- }
- s := valueToString(v)
- if s != tt.s {
- t.Errorf("#%d: have %#q, want %#q", i, s, tt.s)
- }
- }
-}
-
-func TestSetValue(t *testing.T) {
- for i, tt := range valueTests {
- v := ValueOf(tt.i).Elem()
- switch v.Kind() {
- case Int:
- v.Set(ValueOf(int(132)))
- case Int8:
- v.Set(ValueOf(int8(8)))
- case Int16:
- v.Set(ValueOf(int16(16)))
- case Int32:
- v.Set(ValueOf(int32(32)))
- case Int64:
- v.Set(ValueOf(int64(64)))
- case Uint:
- v.Set(ValueOf(uint(132)))
- case Uint8:
- v.Set(ValueOf(uint8(8)))
- case Uint16:
- v.Set(ValueOf(uint16(16)))
- case Uint32:
- v.Set(ValueOf(uint32(32)))
- case Uint64:
- v.Set(ValueOf(uint64(64)))
- case Float32:
- v.Set(ValueOf(float32(256.25)))
- case Float64:
- v.Set(ValueOf(512.125))
- case Complex64:
- v.Set(ValueOf(complex64(532.125 + 10i)))
- case Complex128:
- v.Set(ValueOf(complex128(564.25 + 1i)))
- case String:
- v.Set(ValueOf("stringy cheese"))
- case Bool:
- v.Set(ValueOf(true))
- }
- s := valueToString(v)
- if s != tt.s {
- t.Errorf("#%d: have %#q, want %#q", i, s, tt.s)
- }
- }
-}
-
-var _i = 7
-
-var valueToStringTests = []pair{
- {123, "123"},
- {123.5, "123.5"},
- {byte(123), "123"},
- {"abc", "abc"},
- {T{123, 456.75, "hello", &_i}, "reflect_test.T{123, 456.75, hello, *int(&7)}"},
- {new(chan *T), "*chan *reflect_test.T(&chan *reflect_test.T)"},
- {[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"},
- {&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "*[10]int(&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})"},
- {[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"},
- {&[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "*[]int(&[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})"},
-}
-
-func TestValueToString(t *testing.T) {
- for i, test := range valueToStringTests {
- s := valueToString(ValueOf(test.i))
- if s != test.s {
- t.Errorf("#%d: have %#q, want %#q", i, s, test.s)
- }
- }
-}
-
-func TestArrayElemSet(t *testing.T) {
- v := ValueOf(&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}).Elem()
- v.Index(4).SetInt(123)
- s := valueToString(v)
- const want = "[10]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"
- if s != want {
- t.Errorf("[10]int: have %#q want %#q", s, want)
- }
-
- v = ValueOf([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
- v.Index(4).SetInt(123)
- s = valueToString(v)
- const want1 = "[]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"
- if s != want1 {
- t.Errorf("[]int: have %#q want %#q", s, want1)
- }
-}
-
-func TestPtrPointTo(t *testing.T) {
- var ip *int32
- var i int32 = 1234
- vip := ValueOf(&ip)
- vi := ValueOf(&i).Elem()
- vip.Elem().Set(vi.Addr())
- if *ip != 1234 {
- t.Errorf("got %d, want 1234", *ip)
- }
-
- ip = nil
- vp := ValueOf(&ip).Elem()
- vp.Set(Zero(vp.Type()))
- if ip != nil {
- t.Errorf("got non-nil (%p), want nil", ip)
- }
-}
-
-func TestPtrSetNil(t *testing.T) {
- var i int32 = 1234
- ip := &i
- vip := ValueOf(&ip)
- vip.Elem().Set(Zero(vip.Elem().Type()))
- if ip != nil {
- t.Errorf("got non-nil (%d), want nil", *ip)
- }
-}
-
-func TestMapSetNil(t *testing.T) {
- m := make(map[string]int)
- vm := ValueOf(&m)
- vm.Elem().Set(Zero(vm.Elem().Type()))
- if m != nil {
- t.Errorf("got non-nil (%p), want nil", m)
- }
-}
-
-func TestAll(t *testing.T) {
- testType(t, 1, TypeOf((int8)(0)), "int8")
- testType(t, 2, TypeOf((*int8)(nil)).Elem(), "int8")
-
- typ := TypeOf((*struct {
- c chan *int32
- d float32
- })(nil))
- testType(t, 3, typ, "*struct { c chan *int32; d float32 }")
- etyp := typ.Elem()
- testType(t, 4, etyp, "struct { c chan *int32; d float32 }")
- styp := etyp
- f := styp.Field(0)
- testType(t, 5, f.Type, "chan *int32")
-
- f, present := styp.FieldByName("d")
- if !present {
- t.Errorf("FieldByName says present field is absent")
- }
- testType(t, 6, f.Type, "float32")
-
- f, present = styp.FieldByName("absent")
- if present {
- t.Errorf("FieldByName says absent field is present")
- }
-
- typ = TypeOf([32]int32{})
- testType(t, 7, typ, "[32]int32")
- testType(t, 8, typ.Elem(), "int32")
-
- typ = TypeOf((map[string]*int32)(nil))
- testType(t, 9, typ, "map[string]*int32")
- mtyp := typ
- testType(t, 10, mtyp.Key(), "string")
- testType(t, 11, mtyp.Elem(), "*int32")
-
- typ = TypeOf((chan<- string)(nil))
- testType(t, 12, typ, "chan<- string")
- testType(t, 13, typ.Elem(), "string")
-
- // make sure tag strings are not part of element type
- typ = TypeOf(struct {
- d []uint32 `reflect:"TAG"`
- }{}).Field(0).Type
- testType(t, 14, typ, "[]uint32")
-}
-
-func TestInterfaceGet(t *testing.T) {
- var inter struct {
- E interface{}
- }
- inter.E = 123.456
- v1 := ValueOf(&inter)
- v2 := v1.Elem().Field(0)
- assert(t, v2.Type().String(), "interface {}")
- i2 := v2.Interface()
- v3 := ValueOf(i2)
- assert(t, v3.Type().String(), "float64")
-}
-
-func TestInterfaceValue(t *testing.T) {
- var inter struct {
- E interface{}
- }
- inter.E = 123.456
- v1 := ValueOf(&inter)
- v2 := v1.Elem().Field(0)
- assert(t, v2.Type().String(), "interface {}")
- v3 := v2.Elem()
- assert(t, v3.Type().String(), "float64")
-
- i3 := v2.Interface()
- if _, ok := i3.(float64); !ok {
- t.Error("v2.Interface() did not return float64, got ", TypeOf(i3))
- }
-}
-
-func TestFunctionValue(t *testing.T) {
- var x interface{} = func() {}
- v := ValueOf(x)
- if fmt.Sprint(v.Interface()) != fmt.Sprint(x) {
- t.Fatalf("TestFunction returned wrong pointer")
- }
- assert(t, v.Type().String(), "func()")
-}
-
-var appendTests = []struct {
- orig, extra []int
-}{
- {make([]int, 2, 4), []int{22}},
- {make([]int, 2, 4), []int{22, 33, 44}},
-}
-
-func sameInts(x, y []int) bool {
- if len(x) != len(y) {
- return false
- }
- for i, xx := range x {
- if xx != y[i] {
- return false
- }
- }
- return true
-}
-
-func TestAppend(t *testing.T) {
- for i, test := range appendTests {
- origLen, extraLen := len(test.orig), len(test.extra)
- want := append(test.orig, test.extra...)
- // Convert extra from []int to []Value.
- e0 := make([]Value, len(test.extra))
- for j, e := range test.extra {
- e0[j] = ValueOf(e)
- }
- // Convert extra from []int to *SliceValue.
- e1 := ValueOf(test.extra)
- // Test Append.
- a0 := ValueOf(test.orig)
- have0 := Append(a0, e0...).Interface().([]int)
- if !sameInts(have0, want) {
- t.Errorf("Append #%d: have %v, want %v (%p %p)", i, have0, want, test.orig, have0)
- }
- // Check that the orig and extra slices were not modified.
- if len(test.orig) != origLen {
- t.Errorf("Append #%d origLen: have %v, want %v", i, len(test.orig), origLen)
- }
- if len(test.extra) != extraLen {
- t.Errorf("Append #%d extraLen: have %v, want %v", i, len(test.extra), extraLen)
- }
- // Test AppendSlice.
- a1 := ValueOf(test.orig)
- have1 := AppendSlice(a1, e1).Interface().([]int)
- if !sameInts(have1, want) {
- t.Errorf("AppendSlice #%d: have %v, want %v", i, have1, want)
- }
- // Check that the orig and extra slices were not modified.
- if len(test.orig) != origLen {
- t.Errorf("AppendSlice #%d origLen: have %v, want %v", i, len(test.orig), origLen)
- }
- if len(test.extra) != extraLen {
- t.Errorf("AppendSlice #%d extraLen: have %v, want %v", i, len(test.extra), extraLen)
- }
- }
-}
-
-func TestCopy(t *testing.T) {
- a := []int{1, 2, 3, 4, 10, 9, 8, 7}
- b := []int{11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44}
- c := []int{11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44}
- for i := 0; i < len(b); i++ {
- if b[i] != c[i] {
- t.Fatalf("b != c before test")
- }
- }
- a1 := a
- b1 := b
- aa := ValueOf(&a1).Elem()
- ab := ValueOf(&b1).Elem()
- for tocopy := 1; tocopy <= 7; tocopy++ {
- aa.SetLen(tocopy)
- Copy(ab, aa)
- aa.SetLen(8)
- for i := 0; i < tocopy; i++ {
- if a[i] != b[i] {
- t.Errorf("(i) tocopy=%d a[%d]=%d, b[%d]=%d",
- tocopy, i, a[i], i, b[i])
- }
- }
- for i := tocopy; i < len(b); i++ {
- if b[i] != c[i] {
- if i < len(a) {
- t.Errorf("(ii) tocopy=%d a[%d]=%d, b[%d]=%d, c[%d]=%d",
- tocopy, i, a[i], i, b[i], i, c[i])
- } else {
- t.Errorf("(iii) tocopy=%d b[%d]=%d, c[%d]=%d",
- tocopy, i, b[i], i, c[i])
- }
- } else {
- t.Logf("tocopy=%d elem %d is okay\n", tocopy, i)
- }
- }
- }
-}
-
-func TestCopyArray(t *testing.T) {
- a := [8]int{1, 2, 3, 4, 10, 9, 8, 7}
- b := [11]int{11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44}
- c := b
- aa := ValueOf(&a).Elem()
- ab := ValueOf(&b).Elem()
- Copy(ab, aa)
- for i := 0; i < len(a); i++ {
- if a[i] != b[i] {
- t.Errorf("(i) a[%d]=%d, b[%d]=%d", i, a[i], i, b[i])
- }
- }
- for i := len(a); i < len(b); i++ {
- if b[i] != c[i] {
- t.Errorf("(ii) b[%d]=%d, c[%d]=%d", i, b[i], i, c[i])
- } else {
- t.Logf("elem %d is okay\n", i)
- }
- }
-}
-
-func TestBigUnnamedStruct(t *testing.T) {
- b := struct{ a, b, c, d int64 }{1, 2, 3, 4}
- v := ValueOf(b)
- b1 := v.Interface().(struct {
- a, b, c, d int64
- })
- if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d {
- t.Errorf("ValueOf(%v).Interface().(*Big) = %v", b, b1)
- }
-}
-
-type big struct {
- a, b, c, d, e int64
-}
-
-func TestBigStruct(t *testing.T) {
- b := big{1, 2, 3, 4, 5}
- v := ValueOf(b)
- b1 := v.Interface().(big)
- if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d || b1.e != b.e {
- t.Errorf("ValueOf(%v).Interface().(big) = %v", b, b1)
- }
-}
-
-type Basic struct {
- x int
- y float32
-}
-
-type NotBasic Basic
-
-type DeepEqualTest struct {
- a, b interface{}
- eq bool
-}
-
-// Simple functions for DeepEqual tests.
-var (
- fn1 func() // nil.
- fn2 func() // nil.
- fn3 = func() { fn1() } // Not nil.
-)
-
-var deepEqualTests = []DeepEqualTest{
- // Equalities
- {nil, nil, true},
- {1, 1, true},
- {int32(1), int32(1), true},
- {0.5, 0.5, true},
- {float32(0.5), float32(0.5), true},
- {"hello", "hello", true},
- {make([]int, 10), make([]int, 10), true},
- {&[3]int{1, 2, 3}, &[3]int{1, 2, 3}, true},
- {Basic{1, 0.5}, Basic{1, 0.5}, true},
- {error(nil), error(nil), true},
- {map[int]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, true},
- {fn1, fn2, true},
-
- // Inequalities
- {1, 2, false},
- {int32(1), int32(2), false},
- {0.5, 0.6, false},
- {float32(0.5), float32(0.6), false},
- {"hello", "hey", false},
- {make([]int, 10), make([]int, 11), false},
- {&[3]int{1, 2, 3}, &[3]int{1, 2, 4}, false},
- {Basic{1, 0.5}, Basic{1, 0.6}, false},
- {Basic{1, 0}, Basic{2, 0}, false},
- {map[int]string{1: "one", 3: "two"}, map[int]string{2: "two", 1: "one"}, false},
- {map[int]string{1: "one", 2: "txo"}, map[int]string{2: "two", 1: "one"}, false},
- {map[int]string{1: "one"}, map[int]string{2: "two", 1: "one"}, false},
- {map[int]string{2: "two", 1: "one"}, map[int]string{1: "one"}, false},
- {nil, 1, false},
- {1, nil, false},
- {fn1, fn3, false},
- {fn3, fn3, false},
- {[][]int{[]int{1}}, [][]int{[]int{2}}, false},
-
- // Nil vs empty: not the same.
- {[]int{}, []int(nil), false},
- {[]int{}, []int{}, true},
- {[]int(nil), []int(nil), true},
- {map[int]int{}, map[int]int(nil), false},
- {map[int]int{}, map[int]int{}, true},
- {map[int]int(nil), map[int]int(nil), true},
-
- // Mismatched types
- {1, 1.0, false},
- {int32(1), int64(1), false},
- {0.5, "hello", false},
- {[]int{1, 2, 3}, [3]int{1, 2, 3}, false},
- {&[3]interface{}{1, 2, 4}, &[3]interface{}{1, 2, "s"}, false},
- {Basic{1, 0.5}, NotBasic{1, 0.5}, false},
- {map[uint]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, false},
-}
-
-func TestDeepEqual(t *testing.T) {
- for _, test := range deepEqualTests {
- if r := DeepEqual(test.a, test.b); r != test.eq {
- t.Errorf("DeepEqual(%v, %v) = %v, want %v", test.a, test.b, r, test.eq)
- }
- }
-}
-
-func TestTypeOf(t *testing.T) {
- // Special case for nil
- if typ := TypeOf(nil); typ != nil {
- t.Errorf("expected nil type for nil value; got %v", typ)
- }
- for _, test := range deepEqualTests {
- v := ValueOf(test.a)
- if !v.IsValid() {
- continue
- }
- typ := TypeOf(test.a)
- if typ != v.Type() {
- t.Errorf("TypeOf(%v) = %v, but ValueOf(%v).Type() = %v", test.a, typ, test.a, v.Type())
- }
- }
-}
-
-type Recursive struct {
- x int
- r *Recursive
-}
-
-func TestDeepEqualRecursiveStruct(t *testing.T) {
- a, b := new(Recursive), new(Recursive)
- *a = Recursive{12, a}
- *b = Recursive{12, b}
- if !DeepEqual(a, b) {
- t.Error("DeepEqual(recursive same) = false, want true")
- }
-}
-
-type _Complex struct {
- a int
- b [3]*_Complex
- c *string
- d map[float64]float64
-}
-
-func TestDeepEqualComplexStruct(t *testing.T) {
- m := make(map[float64]float64)
- stra, strb := "hello", "hello"
- a, b := new(_Complex), new(_Complex)
- *a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
- *b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
- if !DeepEqual(a, b) {
- t.Error("DeepEqual(complex same) = false, want true")
- }
-}
-
-func TestDeepEqualComplexStructInequality(t *testing.T) {
- m := make(map[float64]float64)
- stra, strb := "hello", "helloo" // Difference is here
- a, b := new(_Complex), new(_Complex)
- *a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
- *b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
- if DeepEqual(a, b) {
- t.Error("DeepEqual(complex different) = true, want false")
- }
-}
-
-type UnexpT struct {
- m map[int]int
-}
-
-func TestDeepEqualUnexportedMap(t *testing.T) {
- // Check that DeepEqual can look at unexported fields.
- x1 := UnexpT{map[int]int{1: 2}}
- x2 := UnexpT{map[int]int{1: 2}}
- if !DeepEqual(&x1, &x2) {
- t.Error("DeepEqual(x1, x2) = false, want true")
- }
-
- y1 := UnexpT{map[int]int{2: 3}}
- if DeepEqual(&x1, &y1) {
- t.Error("DeepEqual(x1, y1) = true, want false")
- }
-}
-
-func check2ndField(x interface{}, offs uintptr, t *testing.T) {
- s := ValueOf(x)
- f := s.Type().Field(1)
- if f.Offset != offs {
- t.Error("mismatched offsets in structure alignment:", f.Offset, offs)
- }
-}
-
-// Check that structure alignment & offsets viewed through reflect agree with those
-// from the compiler itself.
-func TestAlignment(t *testing.T) {
- type T1inner struct {
- a int
- }
- type T1 struct {
- T1inner
- f int
- }
- type T2inner struct {
- a, b int
- }
- type T2 struct {
- T2inner
- f int
- }
-
- x := T1{T1inner{2}, 17}
- check2ndField(x, uintptr(unsafe.Pointer(&x.f))-uintptr(unsafe.Pointer(&x)), t)
-
- x1 := T2{T2inner{2, 3}, 17}
- check2ndField(x1, uintptr(unsafe.Pointer(&x1.f))-uintptr(unsafe.Pointer(&x1)), t)
-}
-
-func Nil(a interface{}, t *testing.T) {
- n := ValueOf(a).Field(0)
- if !n.IsNil() {
- t.Errorf("%v should be nil", a)
- }
-}
-
-func NotNil(a interface{}, t *testing.T) {
- n := ValueOf(a).Field(0)
- if n.IsNil() {
- t.Errorf("value of type %v should not be nil", ValueOf(a).Type().String())
- }
-}
-
-func TestIsNil(t *testing.T) {
- // These implement IsNil.
- // Wrap in extra struct to hide interface type.
- doNil := []interface{}{
- struct{ x *int }{},
- struct{ x interface{} }{},
- struct{ x map[string]int }{},
- struct{ x func() bool }{},
- struct{ x chan int }{},
- struct{ x []string }{},
- }
- for _, ts := range doNil {
- ty := TypeOf(ts).Field(0).Type
- v := Zero(ty)
- v.IsNil() // panics if not okay to call
- }
-
- // Check the implementations
- var pi struct {
- x *int
- }
- Nil(pi, t)
- pi.x = new(int)
- NotNil(pi, t)
-
- var si struct {
- x []int
- }
- Nil(si, t)
- si.x = make([]int, 10)
- NotNil(si, t)
-
- var ci struct {
- x chan int
- }
- Nil(ci, t)
- ci.x = make(chan int)
- NotNil(ci, t)
-
- var mi struct {
- x map[int]int
- }
- Nil(mi, t)
- mi.x = make(map[int]int)
- NotNil(mi, t)
-
- var ii struct {
- x interface{}
- }
- Nil(ii, t)
- ii.x = 2
- NotNil(ii, t)
-
- var fi struct {
- x func(t *testing.T)
- }
- Nil(fi, t)
- fi.x = TestIsNil
- NotNil(fi, t)
-}
-
-func TestInterfaceExtraction(t *testing.T) {
- var s struct {
- W io.Writer
- }
-
- s.W = os.Stdout
- v := Indirect(ValueOf(&s)).Field(0).Interface()
- if v != s.W.(interface{}) {
- t.Error("Interface() on interface: ", v, s.W)
- }
-}
-
-func TestNilPtrValueSub(t *testing.T) {
- var pi *int
- if pv := ValueOf(pi); pv.Elem().IsValid() {
- t.Error("ValueOf((*int)(nil)).Elem().IsValid()")
- }
-}
-
-func TestMap(t *testing.T) {
- m := map[string]int{"a": 1, "b": 2}
- mv := ValueOf(m)
- if n := mv.Len(); n != len(m) {
- t.Errorf("Len = %d, want %d", n, len(m))
- }
- keys := mv.MapKeys()
- newmap := MakeMap(mv.Type())
- for k, v := range m {
- // Check that returned Keys match keys in range.
- // These aren't required to be in the same order.
- seen := false
- for _, kv := range keys {
- if kv.String() == k {
- seen = true
- break
- }
- }
- if !seen {
- t.Errorf("Missing key %q", k)
- }
-
- // Check that value lookup is correct.
- vv := mv.MapIndex(ValueOf(k))
- if vi := vv.Int(); vi != int64(v) {
- t.Errorf("Key %q: have value %d, want %d", k, vi, v)
- }
-
- // Copy into new map.
- newmap.SetMapIndex(ValueOf(k), ValueOf(v))
- }
- vv := mv.MapIndex(ValueOf("not-present"))
- if vv.IsValid() {
- t.Errorf("Invalid key: got non-nil value %s", valueToString(vv))
- }
-
- newm := newmap.Interface().(map[string]int)
- if len(newm) != len(m) {
- t.Errorf("length after copy: newm=%d, m=%d", len(newm), len(m))
- }
-
- for k, v := range newm {
- mv, ok := m[k]
- if mv != v {
- t.Errorf("newm[%q] = %d, but m[%q] = %d, %v", k, v, k, mv, ok)
- }
- }
-
- newmap.SetMapIndex(ValueOf("a"), Value{})
- v, ok := newm["a"]
- if ok {
- t.Errorf("newm[\"a\"] = %d after delete", v)
- }
-
- mv = ValueOf(&m).Elem()
- mv.Set(Zero(mv.Type()))
- if m != nil {
- t.Errorf("mv.Set(nil) failed")
- }
-}
-
-func TestNilMap(t *testing.T) {
- var m map[string]int
- mv := ValueOf(m)
- keys := mv.MapKeys()
- if len(keys) != 0 {
- t.Errorf(">0 keys for nil map: %v", keys)
- }
-
- // Check that value for missing key is zero.
- x := mv.MapIndex(ValueOf("hello"))
- if x.Kind() != Invalid {
- t.Errorf("m.MapIndex(\"hello\") for nil map = %v, want Invalid Value", x)
- }
-
- // Check big value too.
- var mbig map[string][10 << 20]byte
- x = ValueOf(mbig).MapIndex(ValueOf("hello"))
- if x.Kind() != Invalid {
- t.Errorf("mbig.MapIndex(\"hello\") for nil map = %v, want Invalid Value", x)
- }
-
- // Test that deletes from a nil map succeed.
- mv.SetMapIndex(ValueOf("hi"), Value{})
-}
-
-func TestChan(t *testing.T) {
- for loop := 0; loop < 2; loop++ {
- var c chan int
- var cv Value
-
- // check both ways to allocate channels
- switch loop {
- case 1:
- c = make(chan int, 1)
- cv = ValueOf(c)
- case 0:
- cv = MakeChan(TypeOf(c), 1)
- c = cv.Interface().(chan int)
- }
-
- // Send
- cv.Send(ValueOf(2))
- if i := <-c; i != 2 {
- t.Errorf("reflect Send 2, native recv %d", i)
- }
-
- // Recv
- c <- 3
- if i, ok := cv.Recv(); i.Int() != 3 || !ok {
- t.Errorf("native send 3, reflect Recv %d, %t", i.Int(), ok)
- }
-
- // TryRecv fail
- val, ok := cv.TryRecv()
- if val.IsValid() || ok {
- t.Errorf("TryRecv on empty chan: %s, %t", valueToString(val), ok)
- }
-
- // TryRecv success
- c <- 4
- val, ok = cv.TryRecv()
- if !val.IsValid() {
- t.Errorf("TryRecv on ready chan got nil")
- } else if i := val.Int(); i != 4 || !ok {
- t.Errorf("native send 4, TryRecv %d, %t", i, ok)
- }
-
- // TrySend fail
- c <- 100
- ok = cv.TrySend(ValueOf(5))
- i := <-c
- if ok {
- t.Errorf("TrySend on full chan succeeded: value %d", i)
- }
-
- // TrySend success
- ok = cv.TrySend(ValueOf(6))
- if !ok {
- t.Errorf("TrySend on empty chan failed")
- } else {
- if i = <-c; i != 6 {
- t.Errorf("TrySend 6, recv %d", i)
- }
- }
-
- // Close
- c <- 123
- cv.Close()
- if i, ok := cv.Recv(); i.Int() != 123 || !ok {
- t.Errorf("send 123 then close; Recv %d, %t", i.Int(), ok)
- }
- if i, ok := cv.Recv(); i.Int() != 0 || ok {
- t.Errorf("after close Recv %d, %t", i.Int(), ok)
- }
- }
-
- // check creation of unbuffered channel
- var c chan int
- cv := MakeChan(TypeOf(c), 0)
- c = cv.Interface().(chan int)
- if cv.TrySend(ValueOf(7)) {
- t.Errorf("TrySend on sync chan succeeded")
- }
- if v, ok := cv.TryRecv(); v.IsValid() || ok {
- t.Errorf("TryRecv on sync chan succeeded: isvalid=%v ok=%v", v.IsValid(), ok)
- }
-
- // len/cap
- cv = MakeChan(TypeOf(c), 10)
- c = cv.Interface().(chan int)
- for i := 0; i < 3; i++ {
- c <- i
- }
- if l, m := cv.Len(), cv.Cap(); l != len(c) || m != cap(c) {
- t.Errorf("Len/Cap = %d/%d want %d/%d", l, m, len(c), cap(c))
- }
-}
-
-// caseInfo describes a single case in a select test.
-type caseInfo struct {
- desc string
- canSelect bool
- recv Value
- closed bool
- helper func()
- panic bool
-}
-
-var allselect = flag.Bool("allselect", false, "exhaustive select test")
-
-func TestSelect(t *testing.T) {
- selectWatch.once.Do(func() { go selectWatcher() })
-
- var x exhaustive
- nch := 0
- newop := func(n int, cap int) (ch, val Value) {
- nch++
- if nch%101%2 == 1 {
- c := make(chan int, cap)
- ch = ValueOf(c)
- val = ValueOf(n)
- } else {
- c := make(chan string, cap)
- ch = ValueOf(c)
- val = ValueOf(fmt.Sprint(n))
- }
- return
- }
-
- for n := 0; x.Next(); n++ {
- if testing.Short() && n >= 1000 {
- break
- }
- if n >= 100000 && !*allselect {
- break
- }
- if n%100000 == 0 && testing.Verbose() {
- println("TestSelect", n)
- }
- var cases []SelectCase
- var info []caseInfo
-
- // Ready send.
- if x.Maybe() {
- ch, val := newop(len(cases), 1)
- cases = append(cases, SelectCase{
- Dir: SelectSend,
- Chan: ch,
- Send: val,
- })
- info = append(info, caseInfo{desc: "ready send", canSelect: true})
- }
-
- // Ready recv.
- if x.Maybe() {
- ch, val := newop(len(cases), 1)
- ch.Send(val)
- cases = append(cases, SelectCase{
- Dir: SelectRecv,
- Chan: ch,
- })
- info = append(info, caseInfo{desc: "ready recv", canSelect: true, recv: val})
- }
-
- // Blocking send.
- if x.Maybe() {
- ch, val := newop(len(cases), 0)
- cases = append(cases, SelectCase{
- Dir: SelectSend,
- Chan: ch,
- Send: val,
- })
- // Let it execute?
- if x.Maybe() {
- f := func() { ch.Recv() }
- info = append(info, caseInfo{desc: "blocking send", helper: f})
- } else {
- info = append(info, caseInfo{desc: "blocking send"})
- }
- }
-
- // Blocking recv.
- if x.Maybe() {
- ch, val := newop(len(cases), 0)
- cases = append(cases, SelectCase{
- Dir: SelectRecv,
- Chan: ch,
- })
- // Let it execute?
- if x.Maybe() {
- f := func() { ch.Send(val) }
- info = append(info, caseInfo{desc: "blocking recv", recv: val, helper: f})
- } else {
- info = append(info, caseInfo{desc: "blocking recv"})
- }
- }
-
- // Zero Chan send.
- if x.Maybe() {
- // Maybe include value to send.
- var val Value
- if x.Maybe() {
- val = ValueOf(100)
- }
- cases = append(cases, SelectCase{
- Dir: SelectSend,
- Send: val,
- })
- info = append(info, caseInfo{desc: "zero Chan send"})
- }
-
- // Zero Chan receive.
- if x.Maybe() {
- cases = append(cases, SelectCase{
- Dir: SelectRecv,
- })
- info = append(info, caseInfo{desc: "zero Chan recv"})
- }
-
- // nil Chan send.
- if x.Maybe() {
- cases = append(cases, SelectCase{
- Dir: SelectSend,
- Chan: ValueOf((chan int)(nil)),
- Send: ValueOf(101),
- })
- info = append(info, caseInfo{desc: "nil Chan send"})
- }
-
- // nil Chan recv.
- if x.Maybe() {
- cases = append(cases, SelectCase{
- Dir: SelectRecv,
- Chan: ValueOf((chan int)(nil)),
- })
- info = append(info, caseInfo{desc: "nil Chan recv"})
- }
-
- // closed Chan send.
- if x.Maybe() {
- ch := make(chan int)
- close(ch)
- cases = append(cases, SelectCase{
- Dir: SelectSend,
- Chan: ValueOf(ch),
- Send: ValueOf(101),
- })
- info = append(info, caseInfo{desc: "closed Chan send", canSelect: true, panic: true})
- }
-
- // closed Chan recv.
- if x.Maybe() {
- ch, val := newop(len(cases), 0)
- ch.Close()
- val = Zero(val.Type())
- cases = append(cases, SelectCase{
- Dir: SelectRecv,
- Chan: ch,
- })
- info = append(info, caseInfo{desc: "closed Chan recv", canSelect: true, closed: true, recv: val})
- }
-
- var helper func() // goroutine to help the select complete
-
- // Add default? Must be last case here, but will permute.
- // Add the default if the select would otherwise
- // block forever, and maybe add it anyway.
- numCanSelect := 0
- canProceed := false
- canBlock := true
- canPanic := false
- helpers := []int{}
- for i, c := range info {
- if c.canSelect {
- canProceed = true
- canBlock = false
- numCanSelect++
- if c.panic {
- canPanic = true
- }
- } else if c.helper != nil {
- canProceed = true
- helpers = append(helpers, i)
- }
- }
- if !canProceed || x.Maybe() {
- cases = append(cases, SelectCase{
- Dir: SelectDefault,
- })
- info = append(info, caseInfo{desc: "default", canSelect: canBlock})
- numCanSelect++
- } else if canBlock {
- // Select needs to communicate with another goroutine.
- cas := &info[helpers[x.Choose(len(helpers))]]
- helper = cas.helper
- cas.canSelect = true
- numCanSelect++
- }
-
- // Permute cases and case info.
- // Doing too much here makes the exhaustive loop
- // too exhausting, so just do two swaps.
- for loop := 0; loop < 2; loop++ {
- i := x.Choose(len(cases))
- j := x.Choose(len(cases))
- cases[i], cases[j] = cases[j], cases[i]
- info[i], info[j] = info[j], info[i]
- }
-
- if helper != nil {
- // We wait before kicking off a goroutine to satisfy a blocked select.
- // The pause needs to be big enough to let the select block before
- // we run the helper, but if we lose that race once in a while it's okay: the
- // select will just proceed immediately. Not a big deal.
- // For short tests we can grow [sic] the timeout a bit without fear of taking too long
- pause := 10 * time.Microsecond
- if testing.Short() {
- pause = 100 * time.Microsecond
- }
- time.AfterFunc(pause, helper)
- }
-
- // Run select.
- i, recv, recvOK, panicErr := runSelect(cases, info)
- if panicErr != nil && !canPanic {
- t.Fatalf("%s\npanicked unexpectedly: %v", fmtSelect(info), panicErr)
- }
- if panicErr == nil && canPanic && numCanSelect == 1 {
- t.Fatalf("%s\nselected #%d incorrectly (should panic)", fmtSelect(info), i)
- }
- if panicErr != nil {
- continue
- }
-
- cas := info[i]
- if !cas.canSelect {
- recvStr := ""
- if recv.IsValid() {
- recvStr = fmt.Sprintf(", received %v, %v", recv.Interface(), recvOK)
- }
- t.Fatalf("%s\nselected #%d incorrectly%s", fmtSelect(info), i, recvStr)
- continue
- }
- if cas.panic {
- t.Fatalf("%s\nselected #%d incorrectly (case should panic)", fmtSelect(info), i)
- continue
- }
-
- if cases[i].Dir == SelectRecv {
- if !recv.IsValid() {
- t.Fatalf("%s\nselected #%d but got %v, %v, want %v, %v", fmtSelect(info), i, recv, recvOK, cas.recv.Interface(), !cas.closed)
- }
- if !cas.recv.IsValid() {
- t.Fatalf("%s\nselected #%d but internal error: missing recv value", fmtSelect(info), i)
- }
- if recv.Interface() != cas.recv.Interface() || recvOK != !cas.closed {
- if recv.Interface() == cas.recv.Interface() && recvOK == !cas.closed {
- t.Fatalf("%s\nselected #%d, got %#v, %v, and DeepEqual is broken on %T", fmtSelect(info), i, recv.Interface(), recvOK, recv.Interface())
- }
- t.Fatalf("%s\nselected #%d but got %#v, %v, want %#v, %v", fmtSelect(info), i, recv.Interface(), recvOK, cas.recv.Interface(), !cas.closed)
- }
- } else {
- if recv.IsValid() || recvOK {
- t.Fatalf("%s\nselected #%d but got %v, %v, want %v, %v", fmtSelect(info), i, recv, recvOK, Value{}, false)
- }
- }
- }
-}
-
-// selectWatch and the selectWatcher are a watchdog mechanism for running Select.
-// If the selectWatcher notices that the select has been blocked for >1 second, it prints
-// an error describing the select and panics the entire test binary.
-var selectWatch struct {
- sync.Mutex
- once sync.Once
- now time.Time
- info []caseInfo
-}
-
-func selectWatcher() {
- for {
- time.Sleep(1 * time.Second)
- selectWatch.Lock()
- if selectWatch.info != nil && time.Since(selectWatch.now) > 1*time.Second {
- fmt.Fprintf(os.Stderr, "TestSelect:\n%s blocked indefinitely\n", fmtSelect(selectWatch.info))
- panic("select stuck")
- }
- selectWatch.Unlock()
- }
-}
-
-// runSelect runs a single select test.
-// It returns the values returned by Select but also returns
-// a panic value if the Select panics.
-func runSelect(cases []SelectCase, info []caseInfo) (chosen int, recv Value, recvOK bool, panicErr interface{}) {
- defer func() {
- panicErr = recover()
-
- selectWatch.Lock()
- selectWatch.info = nil
- selectWatch.Unlock()
- }()
-
- selectWatch.Lock()
- selectWatch.now = time.Now()
- selectWatch.info = info
- selectWatch.Unlock()
-
- chosen, recv, recvOK = Select(cases)
- return
-}
-
-// fmtSelect formats the information about a single select test.
-func fmtSelect(info []caseInfo) string {
- var buf bytes.Buffer
- fmt.Fprintf(&buf, "\nselect {\n")
- for i, cas := range info {
- fmt.Fprintf(&buf, "%d: %s", i, cas.desc)
- if cas.recv.IsValid() {
- fmt.Fprintf(&buf, " val=%#v", cas.recv.Interface())
- }
- if cas.canSelect {
- fmt.Fprintf(&buf, " canselect")
- }
- if cas.panic {
- fmt.Fprintf(&buf, " panic")
- }
- fmt.Fprintf(&buf, "\n")
- }
- fmt.Fprintf(&buf, "}")
- return buf.String()
-}
-
-type two [2]uintptr
-
-// Difficult test for function call because of
-// implicit padding between arguments.
-func dummy(b byte, c int, d byte, e two, f byte, g float32, h byte) (i byte, j int, k byte, l two, m byte, n float32, o byte) {
- return b, c, d, e, f, g, h
-}
-
-func TestFunc(t *testing.T) {
- ret := ValueOf(dummy).Call([]Value{
- ValueOf(byte(10)),
- ValueOf(20),
- ValueOf(byte(30)),
- ValueOf(two{40, 50}),
- ValueOf(byte(60)),
- ValueOf(float32(70)),
- ValueOf(byte(80)),
- })
- if len(ret) != 7 {
- t.Fatalf("Call returned %d values, want 7", len(ret))
- }
-
- i := byte(ret[0].Uint())
- j := int(ret[1].Int())
- k := byte(ret[2].Uint())
- l := ret[3].Interface().(two)
- m := byte(ret[4].Uint())
- n := float32(ret[5].Float())
- o := byte(ret[6].Uint())
-
- if i != 10 || j != 20 || k != 30 || l != (two{40, 50}) || m != 60 || n != 70 || o != 80 {
- t.Errorf("Call returned %d, %d, %d, %v, %d, %g, %d; want 10, 20, 30, [40, 50], 60, 70, 80", i, j, k, l, m, n, o)
- }
-}
-
-type emptyStruct struct{}
-
-type nonEmptyStruct struct {
- member int
-}
-
-func returnEmpty() emptyStruct {
- return emptyStruct{}
-}
-
-func takesEmpty(e emptyStruct) {
-}
-
-func returnNonEmpty(i int) nonEmptyStruct {
- return nonEmptyStruct{member: i}
-}
-
-func takesNonEmpty(n nonEmptyStruct) int {
- return n.member
-}
-
-func TestCallWithStruct(t *testing.T) {
- r := ValueOf(returnEmpty).Call(nil)
- if len(r) != 1 || r[0].Type() != TypeOf(emptyStruct{}) {
- t.Errorf("returning empty struct returned %#v instead", r)
- }
- r = ValueOf(takesEmpty).Call([]Value{ValueOf(emptyStruct{})})
- if len(r) != 0 {
- t.Errorf("takesEmpty returned values: %#v", r)
- }
- r = ValueOf(returnNonEmpty).Call([]Value{ValueOf(42)})
- if len(r) != 1 || r[0].Type() != TypeOf(nonEmptyStruct{}) || r[0].Field(0).Int() != 42 {
- t.Errorf("returnNonEmpty returned %#v", r)
- }
- r = ValueOf(takesNonEmpty).Call([]Value{ValueOf(nonEmptyStruct{member: 42})})
- if len(r) != 1 || r[0].Type() != TypeOf(1) || r[0].Int() != 42 {
- t.Errorf("takesNonEmpty returned %#v", r)
- }
-}
-
-func TestMakeFunc(t *testing.T) {
- f := dummy
- fv := MakeFunc(TypeOf(f), func(in []Value) []Value { return in })
- ValueOf(&f).Elem().Set(fv)
-
- // Call g with small arguments so that there is
- // something predictable (and different from the
- // correct results) in those positions on the stack.
- g := dummy
- g(1, 2, 3, two{4, 5}, 6, 7, 8)
-
- // Call constructed function f.
- i, j, k, l, m, n, o := f(10, 20, 30, two{40, 50}, 60, 70, 80)
- if i != 10 || j != 20 || k != 30 || l != (two{40, 50}) || m != 60 || n != 70 || o != 80 {
- t.Errorf("Call returned %d, %d, %d, %v, %d, %g, %d; want 10, 20, 30, [40, 50], 60, 70, 80", i, j, k, l, m, n, o)
- }
-}
-
-func TestMakeFuncInterface(t *testing.T) {
- fn := func(i int) int { return i }
- incr := func(in []Value) []Value {
- return []Value{ValueOf(int(in[0].Int() + 1))}
- }
- fv := MakeFunc(TypeOf(fn), incr)
- ValueOf(&fn).Elem().Set(fv)
- if r := fn(2); r != 3 {
- t.Errorf("Call returned %d, want 3", r)
- }
- if r := fv.Call([]Value{ValueOf(14)})[0].Int(); r != 15 {
- t.Errorf("Call returned %d, want 15", r)
- }
- if r := fv.Interface().(func(int) int)(26); r != 27 {
- t.Errorf("Call returned %d, want 27", r)
- }
-}
-
-func TestMakeFuncVariadic(t *testing.T) {
- // Test that variadic arguments are packed into a slice and passed as last arg
- fn := func(_ int, is ...int) []int { return nil }
- fv := MakeFunc(TypeOf(fn), func(in []Value) []Value { return in[1:2] })
- ValueOf(&fn).Elem().Set(fv)
-
- r := fv.Call([]Value{ValueOf(1), ValueOf(2), ValueOf(3)})[0].Interface().([]int)
- if r[0] != 2 || r[1] != 3 {
- t.Errorf("Call returned [%v, %v]; want 2, 3", r[0], r[1])
- }
-
- r = fv.CallSlice([]Value{ValueOf(1), ValueOf([]int{2, 3})})[0].Interface().([]int)
- if r[0] != 2 || r[1] != 3 {
- t.Errorf("Call returned [%v, %v]; want 2, 3", r[0], r[1])
- }
-}
-
-type Point struct {
- x, y int
-}
-
-// This will be index 0.
-func (p Point) AnotherMethod(scale int) int {
- return -1
-}
-
-// This will be index 1.
-func (p Point) Dist(scale int) int {
- //println("Point.Dist", p.x, p.y, scale)
- return p.x*p.x*scale + p.y*p.y*scale
-}
-
-func TestMethod(t *testing.T) {
- // Non-curried method of type.
- p := Point{3, 4}
- i := TypeOf(p).Method(1).Func.Call([]Value{ValueOf(p), ValueOf(10)})[0].Int()
- if i != 250 {
- t.Errorf("Type Method returned %d; want 250", i)
- }
-
- m, ok := TypeOf(p).MethodByName("Dist")
- if !ok {
- t.Fatalf("method by name failed")
- }
- i = m.Func.Call([]Value{ValueOf(p), ValueOf(11)})[0].Int()
- if i != 275 {
- t.Errorf("Type MethodByName returned %d; want 275", i)
- }
-
- i = TypeOf(&p).Method(1).Func.Call([]Value{ValueOf(&p), ValueOf(12)})[0].Int()
- if i != 300 {
- t.Errorf("Pointer Type Method returned %d; want 300", i)
- }
-
- m, ok = TypeOf(&p).MethodByName("Dist")
- if !ok {
- t.Fatalf("ptr method by name failed")
- }
- i = m.Func.Call([]Value{ValueOf(&p), ValueOf(13)})[0].Int()
- if i != 325 {
- t.Errorf("Pointer Type MethodByName returned %d; want 325", i)
- }
-
- // Curried method of value.
- tfunc := TypeOf((func(int) int)(nil))
- v := ValueOf(p).Method(1)
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Value Method Type is %s; want %s", tt, tfunc)
- }
- i = v.Call([]Value{ValueOf(14)})[0].Int()
- if i != 350 {
- t.Errorf("Value Method returned %d; want 350", i)
- }
- v = ValueOf(p).MethodByName("Dist")
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Value MethodByName Type is %s; want %s", tt, tfunc)
- }
- i = v.Call([]Value{ValueOf(15)})[0].Int()
- if i != 375 {
- t.Errorf("Value MethodByName returned %d; want 375", i)
- }
-
- // Curried method of pointer.
- v = ValueOf(&p).Method(1)
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Pointer Value Method Type is %s; want %s", tt, tfunc)
- }
- i = v.Call([]Value{ValueOf(16)})[0].Int()
- if i != 400 {
- t.Errorf("Pointer Value Method returned %d; want 400", i)
- }
- v = ValueOf(&p).MethodByName("Dist")
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Pointer Value MethodByName Type is %s; want %s", tt, tfunc)
- }
- i = v.Call([]Value{ValueOf(17)})[0].Int()
- if i != 425 {
- t.Errorf("Pointer Value MethodByName returned %d; want 425", i)
- }
-
- // Curried method of interface value.
- // Have to wrap interface value in a struct to get at it.
- // Passing it to ValueOf directly would
- // access the underlying Point, not the interface.
- var x interface {
- Dist(int) int
- } = p
- pv := ValueOf(&x).Elem()
- v = pv.Method(0)
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Interface Method Type is %s; want %s", tt, tfunc)
- }
- i = v.Call([]Value{ValueOf(18)})[0].Int()
- if i != 450 {
- t.Errorf("Interface Method returned %d; want 450", i)
- }
- v = pv.MethodByName("Dist")
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Interface MethodByName Type is %s; want %s", tt, tfunc)
- }
- i = v.Call([]Value{ValueOf(19)})[0].Int()
- if i != 475 {
- t.Errorf("Interface MethodByName returned %d; want 475", i)
- }
-}
-
-func TestMethodValue(t *testing.T) {
- p := Point{3, 4}
- var i int64
-
- // Curried method of value.
- tfunc := TypeOf((func(int) int)(nil))
- v := ValueOf(p).Method(1)
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Value Method Type is %s; want %s", tt, tfunc)
- }
- i = ValueOf(v.Interface()).Call([]Value{ValueOf(10)})[0].Int()
- if i != 250 {
- t.Errorf("Value Method returned %d; want 250", i)
- }
- v = ValueOf(p).MethodByName("Dist")
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Value MethodByName Type is %s; want %s", tt, tfunc)
- }
- i = ValueOf(v.Interface()).Call([]Value{ValueOf(11)})[0].Int()
- if i != 275 {
- t.Errorf("Value MethodByName returned %d; want 275", i)
- }
-
- // Curried method of pointer.
- v = ValueOf(&p).Method(1)
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Pointer Value Method Type is %s; want %s", tt, tfunc)
- }
- i = ValueOf(v.Interface()).Call([]Value{ValueOf(12)})[0].Int()
- if i != 300 {
- t.Errorf("Pointer Value Method returned %d; want 300", i)
- }
- v = ValueOf(&p).MethodByName("Dist")
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Pointer Value MethodByName Type is %s; want %s", tt, tfunc)
- }
- i = ValueOf(v.Interface()).Call([]Value{ValueOf(13)})[0].Int()
- if i != 325 {
- t.Errorf("Pointer Value MethodByName returned %d; want 325", i)
- }
-
- // Curried method of pointer to pointer.
- pp := &p
- v = ValueOf(&pp).Elem().Method(1)
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Pointer Pointer Value Method Type is %s; want %s", tt, tfunc)
- }
- i = ValueOf(v.Interface()).Call([]Value{ValueOf(14)})[0].Int()
- if i != 350 {
- t.Errorf("Pointer Pointer Value Method returned %d; want 350", i)
- }
- v = ValueOf(&pp).Elem().MethodByName("Dist")
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Pointer Pointer Value MethodByName Type is %s; want %s", tt, tfunc)
- }
- i = ValueOf(v.Interface()).Call([]Value{ValueOf(15)})[0].Int()
- if i != 375 {
- t.Errorf("Pointer Pointer Value MethodByName returned %d; want 375", i)
- }
-
- // Curried method of interface value.
- // Have to wrap interface value in a struct to get at it.
- // Passing it to ValueOf directly would
- // access the underlying Point, not the interface.
- var s = struct {
- X interface {
- Dist(int) int
- }
- }{p}
- pv := ValueOf(s).Field(0)
- v = pv.Method(0)
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Interface Method Type is %s; want %s", tt, tfunc)
- }
- i = ValueOf(v.Interface()).Call([]Value{ValueOf(16)})[0].Int()
- if i != 400 {
- t.Errorf("Interface Method returned %d; want 400", i)
- }
- v = pv.MethodByName("Dist")
- if tt := v.Type(); tt != tfunc {
- t.Errorf("Interface MethodByName Type is %s; want %s", tt, tfunc)
- }
- i = ValueOf(v.Interface()).Call([]Value{ValueOf(17)})[0].Int()
- if i != 425 {
- t.Errorf("Interface MethodByName returned %d; want 425", i)
- }
-}
-
-// Reflect version of $GOROOT/test/method5.go
-
-// Concrete types implementing M method.
-// Smaller than a word, word-sized, larger than a word.
-// Value and pointer receivers.
-
-type Tinter interface {
- M(int, byte) (byte, int)
-}
-
-type Tsmallv byte
-
-func (v Tsmallv) M(x int, b byte) (byte, int) { return b, x + int(v) }
-
-type Tsmallp byte
-
-func (p *Tsmallp) M(x int, b byte) (byte, int) { return b, x + int(*p) }
-
-type Twordv uintptr
-
-func (v Twordv) M(x int, b byte) (byte, int) { return b, x + int(v) }
-
-type Twordp uintptr
-
-func (p *Twordp) M(x int, b byte) (byte, int) { return b, x + int(*p) }
-
-type Tbigv [2]uintptr
-
-func (v Tbigv) M(x int, b byte) (byte, int) { return b, x + int(v[0]) + int(v[1]) }
-
-type Tbigp [2]uintptr
-
-func (p *Tbigp) M(x int, b byte) (byte, int) { return b, x + int(p[0]) + int(p[1]) }
-
-// Again, with an unexported method.
-
-type tsmallv byte
-
-func (v tsmallv) m(x int, b byte) (byte, int) { return b, x + int(v) }
-
-type tsmallp byte
-
-func (p *tsmallp) m(x int, b byte) (byte, int) { return b, x + int(*p) }
-
-type twordv uintptr
-
-func (v twordv) m(x int, b byte) (byte, int) { return b, x + int(v) }
-
-type twordp uintptr
-
-func (p *twordp) m(x int, b byte) (byte, int) { return b, x + int(*p) }
-
-type tbigv [2]uintptr
-
-func (v tbigv) m(x int, b byte) (byte, int) { return b, x + int(v[0]) + int(v[1]) }
-
-type tbigp [2]uintptr
-
-func (p *tbigp) m(x int, b byte) (byte, int) { return b, x + int(p[0]) + int(p[1]) }
-
-type tinter interface {
- m(int, byte) (byte, int)
-}
-
-// Embedding via pointer.
-
-type Tm1 struct {
- Tm2
-}
-
-type Tm2 struct {
- *Tm3
-}
-
-type Tm3 struct {
- *Tm4
-}
-
-type Tm4 struct {
-}
-
-func (t4 Tm4) M(x int, b byte) (byte, int) { return b, x + 40 }
-
-func TestMethod5(t *testing.T) {
- CheckF := func(name string, f func(int, byte) (byte, int), inc int) {
- b, x := f(1000, 99)
- if b != 99 || x != 1000+inc {
- t.Errorf("%s(1000, 99) = %v, %v, want 99, %v", name, b, x, 1000+inc)
- }
- }
-
- CheckV := func(name string, i Value, inc int) {
- bx := i.Method(0).Call([]Value{ValueOf(1000), ValueOf(byte(99))})
- b := bx[0].Interface()
- x := bx[1].Interface()
- if b != byte(99) || x != 1000+inc {
- t.Errorf("direct %s.M(1000, 99) = %v, %v, want 99, %v", name, b, x, 1000+inc)
- }
-
- CheckF(name+".M", i.Method(0).Interface().(func(int, byte) (byte, int)), inc)
- }
-
- var TinterType = TypeOf(new(Tinter)).Elem()
- var tinterType = TypeOf(new(tinter)).Elem()
-
- CheckI := func(name string, i interface{}, inc int) {
- v := ValueOf(i)
- CheckV(name, v, inc)
- CheckV("(i="+name+")", v.Convert(TinterType), inc)
- }
-
- sv := Tsmallv(1)
- CheckI("sv", sv, 1)
- CheckI("&sv", &sv, 1)
-
- sp := Tsmallp(2)
- CheckI("&sp", &sp, 2)
-
- wv := Twordv(3)
- CheckI("wv", wv, 3)
- CheckI("&wv", &wv, 3)
-
- wp := Twordp(4)
- CheckI("&wp", &wp, 4)
-
- bv := Tbigv([2]uintptr{5, 6})
- CheckI("bv", bv, 11)
- CheckI("&bv", &bv, 11)
-
- bp := Tbigp([2]uintptr{7, 8})
- CheckI("&bp", &bp, 15)
-
- t4 := Tm4{}
- t3 := Tm3{&t4}
- t2 := Tm2{&t3}
- t1 := Tm1{t2}
- CheckI("t4", t4, 40)
- CheckI("&t4", &t4, 40)
- CheckI("t3", t3, 40)
- CheckI("&t3", &t3, 40)
- CheckI("t2", t2, 40)
- CheckI("&t2", &t2, 40)
- CheckI("t1", t1, 40)
- CheckI("&t1", &t1, 40)
-
- methodShouldPanic := func(name string, i interface{}) {
- v := ValueOf(i)
- m := v.Method(0)
- shouldPanic(func() { m.Call([]Value{ValueOf(1000), ValueOf(byte(99))}) })
- shouldPanic(func() { m.Interface() })
-
- v = v.Convert(tinterType)
- m = v.Method(0)
- shouldPanic(func() { m.Call([]Value{ValueOf(1000), ValueOf(byte(99))}) })
- shouldPanic(func() { m.Interface() })
- }
-
- _sv := tsmallv(1)
- methodShouldPanic("_sv", _sv)
- methodShouldPanic("&_sv", &_sv)
-
- _sp := tsmallp(2)
- methodShouldPanic("&_sp", &_sp)
-
- _wv := twordv(3)
- methodShouldPanic("_wv", _wv)
- methodShouldPanic("&_wv", &_wv)
-
- _wp := twordp(4)
- methodShouldPanic("&_wp", &_wp)
-
- _bv := tbigv([2]uintptr{5, 6})
- methodShouldPanic("_bv", _bv)
- methodShouldPanic("&_bv", &_bv)
-
- _bp := tbigp([2]uintptr{7, 8})
- methodShouldPanic("&_bp", &_bp)
-
- var tnil Tinter
- vnil := ValueOf(&tnil).Elem()
- shouldPanic(func() { vnil.Method(0) })
-}
-
-func TestInterfaceSet(t *testing.T) {
- p := &Point{3, 4}
-
- var s struct {
- I interface{}
- P interface {
- Dist(int) int
- }
- }
- sv := ValueOf(&s).Elem()
- sv.Field(0).Set(ValueOf(p))
- if q := s.I.(*Point); q != p {
- t.Errorf("i: have %p want %p", q, p)
- }
-
- pv := sv.Field(1)
- pv.Set(ValueOf(p))
- if q := s.P.(*Point); q != p {
- t.Errorf("i: have %p want %p", q, p)
- }
-
- i := pv.Method(0).Call([]Value{ValueOf(10)})[0].Int()
- if i != 250 {
- t.Errorf("Interface Method returned %d; want 250", i)
- }
-}
-
-type T1 struct {
- a string
- int
-}
-
-func TestAnonymousFields(t *testing.T) {
- var field StructField
- var ok bool
- var t1 T1
- type1 := TypeOf(t1)
- if field, ok = type1.FieldByName("int"); !ok {
- t.Fatal("no field 'int'")
- }
- if field.Index[0] != 1 {
- t.Error("field index should be 1; is", field.Index)
- }
-}
-
-type FTest struct {
- s interface{}
- name string
- index []int
- value int
-}
-
-type D1 struct {
- d int
-}
-type D2 struct {
- d int
-}
-
-type S0 struct {
- A, B, C int
- D1
- D2
-}
-
-type S1 struct {
- B int
- S0
-}
-
-type S2 struct {
- A int
- *S1
-}
-
-type S1x struct {
- S1
-}
-
-type S1y struct {
- S1
-}
-
-type S3 struct {
- S1x
- S2
- D, E int
- *S1y
-}
-
-type S4 struct {
- *S4
- A int
-}
-
-// The X in S6 and S7 annihilate, but they also block the X in S8.S9.
-type S5 struct {
- S6
- S7
- S8
-}
-
-type S6 struct {
- X int
-}
-
-type S7 S6
-
-type S8 struct {
- S9
-}
-
-type S9 struct {
- X int
- Y int
-}
-
-// The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
-type S10 struct {
- S11
- S12
- S13
-}
-
-type S11 struct {
- S6
-}
-
-type S12 struct {
- S6
-}
-
-type S13 struct {
- S8
-}
-
-// The X in S15.S11.S1 and S16.S11.S1 annihilate.
-type S14 struct {
- S15
- S16
-}
-
-type S15 struct {
- S11
-}
-
-type S16 struct {
- S11
-}
-
-var fieldTests = []FTest{
- {struct{}{}, "", nil, 0},
- {struct{}{}, "Foo", nil, 0},
- {S0{A: 'a'}, "A", []int{0}, 'a'},
- {S0{}, "D", nil, 0},
- {S1{S0: S0{A: 'a'}}, "A", []int{1, 0}, 'a'},
- {S1{B: 'b'}, "B", []int{0}, 'b'},
- {S1{}, "S0", []int{1}, 0},
- {S1{S0: S0{C: 'c'}}, "C", []int{1, 2}, 'c'},
- {S2{A: 'a'}, "A", []int{0}, 'a'},
- {S2{}, "S1", []int{1}, 0},
- {S2{S1: &S1{B: 'b'}}, "B", []int{1, 0}, 'b'},
- {S2{S1: &S1{S0: S0{C: 'c'}}}, "C", []int{1, 1, 2}, 'c'},
- {S2{}, "D", nil, 0},
- {S3{}, "S1", nil, 0},
- {S3{S2: S2{A: 'a'}}, "A", []int{1, 0}, 'a'},
- {S3{}, "B", nil, 0},
- {S3{D: 'd'}, "D", []int{2}, 0},
- {S3{E: 'e'}, "E", []int{3}, 'e'},
- {S4{A: 'a'}, "A", []int{1}, 'a'},
- {S4{}, "B", nil, 0},
- {S5{}, "X", nil, 0},
- {S5{}, "Y", []int{2, 0, 1}, 0},
- {S10{}, "X", nil, 0},
- {S10{}, "Y", []int{2, 0, 0, 1}, 0},
- {S14{}, "X", nil, 0},
-}
-
-func TestFieldByIndex(t *testing.T) {
- for _, test := range fieldTests {
- s := TypeOf(test.s)
- f := s.FieldByIndex(test.index)
- if f.Name != "" {
- if test.index != nil {
- if f.Name != test.name {
- t.Errorf("%s.%s found; want %s", s.Name(), f.Name, test.name)
- }
- } else {
- t.Errorf("%s.%s found", s.Name(), f.Name)
- }
- } else if len(test.index) > 0 {
- t.Errorf("%s.%s not found", s.Name(), test.name)
- }
-
- if test.value != 0 {
- v := ValueOf(test.s).FieldByIndex(test.index)
- if v.IsValid() {
- if x, ok := v.Interface().(int); ok {
- if x != test.value {
- t.Errorf("%s%v is %d; want %d", s.Name(), test.index, x, test.value)
- }
- } else {
- t.Errorf("%s%v value not an int", s.Name(), test.index)
- }
- } else {
- t.Errorf("%s%v value not found", s.Name(), test.index)
- }
- }
- }
-}
-
-func TestFieldByName(t *testing.T) {
- for _, test := range fieldTests {
- s := TypeOf(test.s)
- f, found := s.FieldByName(test.name)
- if found {
- if test.index != nil {
- // Verify field depth and index.
- if len(f.Index) != len(test.index) {
- t.Errorf("%s.%s depth %d; want %d: %v vs %v", s.Name(), test.name, len(f.Index), len(test.index), f.Index, test.index)
- } else {
- for i, x := range f.Index {
- if x != test.index[i] {
- t.Errorf("%s.%s.Index[%d] is %d; want %d", s.Name(), test.name, i, x, test.index[i])
- }
- }
- }
- } else {
- t.Errorf("%s.%s found", s.Name(), f.Name)
- }
- } else if len(test.index) > 0 {
- t.Errorf("%s.%s not found", s.Name(), test.name)
- }
-
- if test.value != 0 {
- v := ValueOf(test.s).FieldByName(test.name)
- if v.IsValid() {
- if x, ok := v.Interface().(int); ok {
- if x != test.value {
- t.Errorf("%s.%s is %d; want %d", s.Name(), test.name, x, test.value)
- }
- } else {
- t.Errorf("%s.%s value not an int", s.Name(), test.name)
- }
- } else {
- t.Errorf("%s.%s value not found", s.Name(), test.name)
- }
- }
- }
-}
-
-func TestImportPath(t *testing.T) {
- tests := []struct {
- t Type
- path string
- }{
- {TypeOf(&base64.Encoding{}).Elem(), "encoding/base64"},
- {TypeOf(int(0)), ""},
- {TypeOf(int8(0)), ""},
- {TypeOf(int16(0)), ""},
- {TypeOf(int32(0)), ""},
- {TypeOf(int64(0)), ""},
- {TypeOf(uint(0)), ""},
- {TypeOf(uint8(0)), ""},
- {TypeOf(uint16(0)), ""},
- {TypeOf(uint32(0)), ""},
- {TypeOf(uint64(0)), ""},
- {TypeOf(uintptr(0)), ""},
- {TypeOf(float32(0)), ""},
- {TypeOf(float64(0)), ""},
- {TypeOf(complex64(0)), ""},
- {TypeOf(complex128(0)), ""},
- {TypeOf(byte(0)), ""},
- {TypeOf(rune(0)), ""},
- {TypeOf([]byte(nil)), ""},
- {TypeOf([]rune(nil)), ""},
- {TypeOf(string("")), ""},
- {TypeOf((*interface{})(nil)).Elem(), ""},
- {TypeOf((*byte)(nil)), ""},
- {TypeOf((*rune)(nil)), ""},
- {TypeOf((*int64)(nil)), ""},
- {TypeOf(map[string]int{}), ""},
- {TypeOf((*error)(nil)).Elem(), ""},
- }
- for _, test := range tests {
- if path := test.t.PkgPath(); path != test.path {
- t.Errorf("%v.PkgPath() = %q, want %q", test.t, path, test.path)
- }
- }
-}
-
-func TestVariadicType(t *testing.T) {
- // Test example from Type documentation.
- var f func(x int, y ...float64)
- typ := TypeOf(f)
- if typ.NumIn() == 2 && typ.In(0) == TypeOf(int(0)) {
- sl := typ.In(1)
- if sl.Kind() == Slice {
- if sl.Elem() == TypeOf(0.0) {
- // ok
- return
- }
- }
- }
-
- // Failed
- t.Errorf("want NumIn() = 2, In(0) = int, In(1) = []float64")
- s := fmt.Sprintf("have NumIn() = %d", typ.NumIn())
- for i := 0; i < typ.NumIn(); i++ {
- s += fmt.Sprintf(", In(%d) = %s", i, typ.In(i))
- }
- t.Error(s)
-}
-
-type inner struct {
- x int
-}
-
-type outer struct {
- y int
- inner
-}
-
-func (*inner) m() {}
-func (*outer) m() {}
-
-func TestNestedMethods(t *testing.T) {
- typ := TypeOf((*outer)(nil))
- if typ.NumMethod() != 1 || typ.Method(0).Func.Pointer() != ValueOf((*outer).m).Pointer() {
- t.Errorf("Wrong method table for outer: (m=%p)", (*outer).m)
- for i := 0; i < typ.NumMethod(); i++ {
- m := typ.Method(i)
- t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Pointer())
- }
- }
-}
-
-type InnerInt struct {
- X int
-}
-
-type OuterInt struct {
- Y int
- InnerInt
-}
-
-func (i *InnerInt) M() int {
- return i.X
-}
-
-func TestEmbeddedMethods(t *testing.T) {
- typ := TypeOf((*OuterInt)(nil))
- if typ.NumMethod() != 1 || typ.Method(0).Func.Pointer() != ValueOf((*OuterInt).M).Pointer() {
- t.Errorf("Wrong method table for OuterInt: (m=%p)", (*OuterInt).M)
- for i := 0; i < typ.NumMethod(); i++ {
- m := typ.Method(i)
- t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Pointer())
- }
- }
-
- i := &InnerInt{3}
- if v := ValueOf(i).Method(0).Call(nil)[0].Int(); v != 3 {
- t.Errorf("i.M() = %d, want 3", v)
- }
-
- o := &OuterInt{1, InnerInt{2}}
- if v := ValueOf(o).Method(0).Call(nil)[0].Int(); v != 2 {
- t.Errorf("i.M() = %d, want 2", v)
- }
-
- f := (*OuterInt).M
- if v := f(o); v != 2 {
- t.Errorf("f(o) = %d, want 2", v)
- }
-}
-
-func TestPtrTo(t *testing.T) {
- var i int
-
- typ := TypeOf(i)
- for i = 0; i < 100; i++ {
- typ = PtrTo(typ)
- }
- for i = 0; i < 100; i++ {
- typ = typ.Elem()
- }
- if typ != TypeOf(i) {
- t.Errorf("after 100 PtrTo and Elem, have %s, want %s", typ, TypeOf(i))
- }
-}
-
-func TestPtrToGC(t *testing.T) {
- type T *uintptr
- tt := TypeOf(T(nil))
- pt := PtrTo(tt)
- const n = 100
- var x []interface{}
- for i := 0; i < n; i++ {
- v := New(pt)
- p := new(*uintptr)
- *p = new(uintptr)
- **p = uintptr(i)
- v.Elem().Set(ValueOf(p).Convert(pt))
- x = append(x, v.Interface())
- }
- runtime.GC()
-
- for i, xi := range x {
- k := ValueOf(xi).Elem().Elem().Elem().Interface().(uintptr)
- if k != uintptr(i) {
- t.Errorf("lost x[%d] = %d, want %d", i, k, i)
- }
- }
-}
-
-func TestAddr(t *testing.T) {
- var p struct {
- X, Y int
- }
-
- v := ValueOf(&p)
- v = v.Elem()
- v = v.Addr()
- v = v.Elem()
- v = v.Field(0)
- v.SetInt(2)
- if p.X != 2 {
- t.Errorf("Addr.Elem.Set failed to set value")
- }
-
- // Again but take address of the ValueOf value.
- // Exercises generation of PtrTypes not present in the binary.
- q := &p
- v = ValueOf(&q).Elem()
- v = v.Addr()
- v = v.Elem()
- v = v.Elem()
- v = v.Addr()
- v = v.Elem()
- v = v.Field(0)
- v.SetInt(3)
- if p.X != 3 {
- t.Errorf("Addr.Elem.Set failed to set value")
- }
-
- // Starting without pointer we should get changed value
- // in interface.
- qq := p
- v = ValueOf(&qq).Elem()
- v0 := v
- v = v.Addr()
- v = v.Elem()
- v = v.Field(0)
- v.SetInt(4)
- if p.X != 3 { // should be unchanged from last time
- t.Errorf("somehow value Set changed original p")
- }
- p = v0.Interface().(struct {
- X, Y int
- })
- if p.X != 4 {
- t.Errorf("Addr.Elem.Set valued to set value in top value")
- }
-
- // Verify that taking the address of a type gives us a pointer
- // which we can convert back using the usual interface
- // notation.
- var s struct {
- B *bool
- }
- ps := ValueOf(&s).Elem().Field(0).Addr().Interface()
- *(ps.(**bool)) = new(bool)
- if s.B == nil {
- t.Errorf("Addr.Interface direct assignment failed")
- }
-}
-
-func noAlloc(t *testing.T, n int, f func(int)) {
- if testing.Short() {
- t.Skip("skipping malloc count in short mode")
- }
- if runtime.GOMAXPROCS(0) > 1 {
- t.Skip("skipping; GOMAXPROCS>1")
- }
- i := -1
- allocs := testing.AllocsPerRun(n, func() {
- f(i)
- i++
- })
- if allocs > 0 {
- t.Errorf("%d iterations: got %v mallocs, want 0", n, allocs)
- }
-}
-
-func TestAllocations(t *testing.T) {
- noAlloc(t, 100, func(j int) {
- var i interface{}
- var v Value
- i = 42 + j
- v = ValueOf(i)
- if int(v.Int()) != 42+j {
- panic("wrong int")
- }
- })
-}
-
-func TestSmallNegativeInt(t *testing.T) {
- i := int16(-1)
- v := ValueOf(i)
- if v.Int() != -1 {
- t.Errorf("int16(-1).Int() returned %v", v.Int())
- }
-}
-
-func TestIndex(t *testing.T) {
- xs := []byte{1, 2, 3, 4, 5, 6, 7, 8}
- v := ValueOf(xs).Index(3).Interface().(byte)
- if v != xs[3] {
- t.Errorf("xs.Index(3) = %v; expected %v", v, xs[3])
- }
- xa := [8]byte{10, 20, 30, 40, 50, 60, 70, 80}
- v = ValueOf(xa).Index(2).Interface().(byte)
- if v != xa[2] {
- t.Errorf("xa.Index(2) = %v; expected %v", v, xa[2])
- }
- s := "0123456789"
- v = ValueOf(s).Index(3).Interface().(byte)
- if v != s[3] {
- t.Errorf("s.Index(3) = %v; expected %v", v, s[3])
- }
-}
-
-func TestSlice(t *testing.T) {
- xs := []int{1, 2, 3, 4, 5, 6, 7, 8}
- v := ValueOf(xs).Slice(3, 5).Interface().([]int)
- if len(v) != 2 {
- t.Errorf("len(xs.Slice(3, 5)) = %d", len(v))
- }
- if cap(v) != 5 {
- t.Errorf("cap(xs.Slice(3, 5)) = %d", cap(v))
- }
- if !DeepEqual(v[0:5], xs[3:]) {
- t.Errorf("xs.Slice(3, 5)[0:5] = %v", v[0:5])
- }
- xa := [8]int{10, 20, 30, 40, 50, 60, 70, 80}
- v = ValueOf(&xa).Elem().Slice(2, 5).Interface().([]int)
- if len(v) != 3 {
- t.Errorf("len(xa.Slice(2, 5)) = %d", len(v))
- }
- if cap(v) != 6 {
- t.Errorf("cap(xa.Slice(2, 5)) = %d", cap(v))
- }
- if !DeepEqual(v[0:6], xa[2:]) {
- t.Errorf("xs.Slice(2, 5)[0:6] = %v", v[0:6])
- }
- s := "0123456789"
- vs := ValueOf(s).Slice(3, 5).Interface().(string)
- if vs != s[3:5] {
- t.Errorf("s.Slice(3, 5) = %q; expected %q", vs, s[3:5])
- }
-}
-
-func TestSlice3(t *testing.T) {
- xs := []int{1, 2, 3, 4, 5, 6, 7, 8}
- v := ValueOf(xs).Slice3(3, 5, 7).Interface().([]int)
- if len(v) != 2 {
- t.Errorf("len(xs.Slice3(3, 5, 7)) = %d", len(v))
- }
- if cap(v) != 4 {
- t.Errorf("cap(xs.Slice3(3, 5, 7)) = %d", cap(v))
- }
- if !DeepEqual(v[0:4], xs[3:7:7]) {
- t.Errorf("xs.Slice3(3, 5, 7)[0:4] = %v", v[0:4])
- }
- rv := ValueOf(&xs).Elem()
- shouldPanic(func() { rv.Slice3(1, 2, 1) })
- shouldPanic(func() { rv.Slice3(1, 1, 11) })
- shouldPanic(func() { rv.Slice3(2, 2, 1) })
-
- xa := [8]int{10, 20, 30, 40, 50, 60, 70, 80}
- v = ValueOf(&xa).Elem().Slice3(2, 5, 6).Interface().([]int)
- if len(v) != 3 {
- t.Errorf("len(xa.Slice(2, 5, 6)) = %d", len(v))
- }
- if cap(v) != 4 {
- t.Errorf("cap(xa.Slice(2, 5, 6)) = %d", cap(v))
- }
- if !DeepEqual(v[0:4], xa[2:6:6]) {
- t.Errorf("xs.Slice(2, 5, 6)[0:4] = %v", v[0:4])
- }
- rv = ValueOf(&xa).Elem()
- shouldPanic(func() { rv.Slice3(1, 2, 1) })
- shouldPanic(func() { rv.Slice3(1, 1, 11) })
- shouldPanic(func() { rv.Slice3(2, 2, 1) })
-
- s := "hello world"
- rv = ValueOf(&s).Elem()
- shouldPanic(func() { rv.Slice3(1, 2, 3) })
-}
-
-func TestSetLenCap(t *testing.T) {
- xs := []int{1, 2, 3, 4, 5, 6, 7, 8}
- xa := [8]int{10, 20, 30, 40, 50, 60, 70, 80}
-
- vs := ValueOf(&xs).Elem()
- shouldPanic(func() { vs.SetLen(10) })
- shouldPanic(func() { vs.SetCap(10) })
- shouldPanic(func() { vs.SetLen(-1) })
- shouldPanic(func() { vs.SetCap(-1) })
- shouldPanic(func() { vs.SetCap(6) }) // smaller than len
- vs.SetLen(5)
- if len(xs) != 5 || cap(xs) != 8 {
- t.Errorf("after SetLen(5), len, cap = %d, %d, want 5, 8", len(xs), cap(xs))
- }
- vs.SetCap(6)
- if len(xs) != 5 || cap(xs) != 6 {
- t.Errorf("after SetCap(6), len, cap = %d, %d, want 5, 6", len(xs), cap(xs))
- }
- vs.SetCap(5)
- if len(xs) != 5 || cap(xs) != 5 {
- t.Errorf("after SetCap(5), len, cap = %d, %d, want 5, 5", len(xs), cap(xs))
- }
- shouldPanic(func() { vs.SetCap(4) }) // smaller than len
- shouldPanic(func() { vs.SetLen(6) }) // bigger than cap
-
- va := ValueOf(&xa).Elem()
- shouldPanic(func() { va.SetLen(8) })
- shouldPanic(func() { va.SetCap(8) })
-}
-
-func TestVariadic(t *testing.T) {
- var b bytes.Buffer
- V := ValueOf
-
- b.Reset()
- V(fmt.Fprintf).Call([]Value{V(&b), V("%s, %d world"), V("hello"), V(42)})
- if b.String() != "hello, 42 world" {
- t.Errorf("after Fprintf Call: %q != %q", b.String(), "hello 42 world")
- }
-
- b.Reset()
- V(fmt.Fprintf).CallSlice([]Value{V(&b), V("%s, %d world"), V([]interface{}{"hello", 42})})
- if b.String() != "hello, 42 world" {
- t.Errorf("after Fprintf CallSlice: %q != %q", b.String(), "hello 42 world")
- }
-}
-
-func TestFuncArg(t *testing.T) {
- f1 := func(i int, f func(int) int) int { return f(i) }
- f2 := func(i int) int { return i + 1 }
- r := ValueOf(f1).Call([]Value{ValueOf(100), ValueOf(f2)})
- if r[0].Int() != 101 {
- t.Errorf("function returned %d, want 101", r[0].Int())
- }
-}
-
-var tagGetTests = []struct {
- Tag StructTag
- Key string
- Value string
-}{
- {`protobuf:"PB(1,2)"`, `protobuf`, `PB(1,2)`},
- {`protobuf:"PB(1,2)"`, `foo`, ``},
- {`protobuf:"PB(1,2)"`, `rotobuf`, ``},
- {`protobuf:"PB(1,2)" json:"name"`, `json`, `name`},
- {`protobuf:"PB(1,2)" json:"name"`, `protobuf`, `PB(1,2)`},
-}
-
-func TestTagGet(t *testing.T) {
- for _, tt := range tagGetTests {
- if v := tt.Tag.Get(tt.Key); v != tt.Value {
- t.Errorf("StructTag(%#q).Get(%#q) = %#q, want %#q", tt.Tag, tt.Key, v, tt.Value)
- }
- }
-}
-
-func TestBytes(t *testing.T) {
- type B []byte
- x := B{1, 2, 3, 4}
- y := ValueOf(x).Bytes()
- if !bytes.Equal(x, y) {
- t.Fatalf("ValueOf(%v).Bytes() = %v", x, y)
- }
- if &x[0] != &y[0] {
- t.Errorf("ValueOf(%p).Bytes() = %p", &x[0], &y[0])
- }
-}
-
-func TestSetBytes(t *testing.T) {
- type B []byte
- var x B
- y := []byte{1, 2, 3, 4}
- ValueOf(&x).Elem().SetBytes(y)
- if !bytes.Equal(x, y) {
- t.Fatalf("ValueOf(%v).Bytes() = %v", x, y)
- }
- if &x[0] != &y[0] {
- t.Errorf("ValueOf(%p).Bytes() = %p", &x[0], &y[0])
- }
-}
-
-type Private struct {
- x int
- y **int
-}
-
-func (p *Private) m() {
-}
-
-type Public struct {
- X int
- Y **int
-}
-
-func (p *Public) M() {
-}
-
-func TestUnexported(t *testing.T) {
- var pub Public
- v := ValueOf(&pub)
- isValid(v.Elem().Field(0))
- isValid(v.Elem().Field(1))
- isValid(v.Elem().FieldByName("X"))
- isValid(v.Elem().FieldByName("Y"))
- isValid(v.Type().Method(0).Func)
- isNonNil(v.Elem().Field(0).Interface())
- isNonNil(v.Elem().Field(1).Interface())
- isNonNil(v.Elem().FieldByName("X").Interface())
- isNonNil(v.Elem().FieldByName("Y").Interface())
- isNonNil(v.Type().Method(0).Func.Interface())
-
- var priv Private
- v = ValueOf(&priv)
- isValid(v.Elem().Field(0))
- isValid(v.Elem().Field(1))
- isValid(v.Elem().FieldByName("x"))
- isValid(v.Elem().FieldByName("y"))
- isValid(v.Type().Method(0).Func)
- shouldPanic(func() { v.Elem().Field(0).Interface() })
- shouldPanic(func() { v.Elem().Field(1).Interface() })
- shouldPanic(func() { v.Elem().FieldByName("x").Interface() })
- shouldPanic(func() { v.Elem().FieldByName("y").Interface() })
- shouldPanic(func() { v.Type().Method(0).Func.Interface() })
-}
-
-func shouldPanic(f func()) {
- defer func() {
- if recover() == nil {
- panic("did not panic")
- }
- }()
- f()
-}
-
-func isNonNil(x interface{}) {
- if x == nil {
- panic("nil interface")
- }
-}
-
-func isValid(v Value) {
- if !v.IsValid() {
- panic("zero Value")
- }
-}
-
-func TestAlias(t *testing.T) {
- x := string("hello")
- v := ValueOf(&x).Elem()
- oldvalue := v.Interface()
- v.SetString("world")
- newvalue := v.Interface()
-
- if oldvalue != "hello" || newvalue != "world" {
- t.Errorf("aliasing: old=%q new=%q, want hello, world", oldvalue, newvalue)
- }
-}
-
-var V = ValueOf
-
-func EmptyInterfaceV(x interface{}) Value {
- return ValueOf(&x).Elem()
-}
-
-func ReaderV(x io.Reader) Value {
- return ValueOf(&x).Elem()
-}
-
-func ReadWriterV(x io.ReadWriter) Value {
- return ValueOf(&x).Elem()
-}
-
-type Empty struct{}
-type MyString string
-type MyBytes []byte
-type MyRunes []int32
-type MyFunc func()
-type MyByte byte
-
-var convertTests = []struct {
- in Value
- out Value
-}{
- // numbers
- /*
- Edit .+1,/\*\//-1>cat >/tmp/x.go && go run /tmp/x.go
-
- package main
-
- import "fmt"
-
- var numbers = []string{
- "int8", "uint8", "int16", "uint16",
- "int32", "uint32", "int64", "uint64",
- "int", "uint", "uintptr",
- "float32", "float64",
- }
-
- func main() {
- // all pairs but in an unusual order,
- // to emit all the int8, uint8 cases
- // before n grows too big.
- n := 1
- for i, f := range numbers {
- for _, g := range numbers[i:] {
- fmt.Printf("\t{V(%s(%d)), V(%s(%d))},\n", f, n, g, n)
- n++
- if f != g {
- fmt.Printf("\t{V(%s(%d)), V(%s(%d))},\n", g, n, f, n)
- n++
- }
- }
- }
- }
- */
- {V(int8(1)), V(int8(1))},
- {V(int8(2)), V(uint8(2))},
- {V(uint8(3)), V(int8(3))},
- {V(int8(4)), V(int16(4))},
- {V(int16(5)), V(int8(5))},
- {V(int8(6)), V(uint16(6))},
- {V(uint16(7)), V(int8(7))},
- {V(int8(8)), V(int32(8))},
- {V(int32(9)), V(int8(9))},
- {V(int8(10)), V(uint32(10))},
- {V(uint32(11)), V(int8(11))},
- {V(int8(12)), V(int64(12))},
- {V(int64(13)), V(int8(13))},
- {V(int8(14)), V(uint64(14))},
- {V(uint64(15)), V(int8(15))},
- {V(int8(16)), V(int(16))},
- {V(int(17)), V(int8(17))},
- {V(int8(18)), V(uint(18))},
- {V(uint(19)), V(int8(19))},
- {V(int8(20)), V(uintptr(20))},
- {V(uintptr(21)), V(int8(21))},
- {V(int8(22)), V(float32(22))},
- {V(float32(23)), V(int8(23))},
- {V(int8(24)), V(float64(24))},
- {V(float64(25)), V(int8(25))},
- {V(uint8(26)), V(uint8(26))},
- {V(uint8(27)), V(int16(27))},
- {V(int16(28)), V(uint8(28))},
- {V(uint8(29)), V(uint16(29))},
- {V(uint16(30)), V(uint8(30))},
- {V(uint8(31)), V(int32(31))},
- {V(int32(32)), V(uint8(32))},
- {V(uint8(33)), V(uint32(33))},
- {V(uint32(34)), V(uint8(34))},
- {V(uint8(35)), V(int64(35))},
- {V(int64(36)), V(uint8(36))},
- {V(uint8(37)), V(uint64(37))},
- {V(uint64(38)), V(uint8(38))},
- {V(uint8(39)), V(int(39))},
- {V(int(40)), V(uint8(40))},
- {V(uint8(41)), V(uint(41))},
- {V(uint(42)), V(uint8(42))},
- {V(uint8(43)), V(uintptr(43))},
- {V(uintptr(44)), V(uint8(44))},
- {V(uint8(45)), V(float32(45))},
- {V(float32(46)), V(uint8(46))},
- {V(uint8(47)), V(float64(47))},
- {V(float64(48)), V(uint8(48))},
- {V(int16(49)), V(int16(49))},
- {V(int16(50)), V(uint16(50))},
- {V(uint16(51)), V(int16(51))},
- {V(int16(52)), V(int32(52))},
- {V(int32(53)), V(int16(53))},
- {V(int16(54)), V(uint32(54))},
- {V(uint32(55)), V(int16(55))},
- {V(int16(56)), V(int64(56))},
- {V(int64(57)), V(int16(57))},
- {V(int16(58)), V(uint64(58))},
- {V(uint64(59)), V(int16(59))},
- {V(int16(60)), V(int(60))},
- {V(int(61)), V(int16(61))},
- {V(int16(62)), V(uint(62))},
- {V(uint(63)), V(int16(63))},
- {V(int16(64)), V(uintptr(64))},
- {V(uintptr(65)), V(int16(65))},
- {V(int16(66)), V(float32(66))},
- {V(float32(67)), V(int16(67))},
- {V(int16(68)), V(float64(68))},
- {V(float64(69)), V(int16(69))},
- {V(uint16(70)), V(uint16(70))},
- {V(uint16(71)), V(int32(71))},
- {V(int32(72)), V(uint16(72))},
- {V(uint16(73)), V(uint32(73))},
- {V(uint32(74)), V(uint16(74))},
- {V(uint16(75)), V(int64(75))},
- {V(int64(76)), V(uint16(76))},
- {V(uint16(77)), V(uint64(77))},
- {V(uint64(78)), V(uint16(78))},
- {V(uint16(79)), V(int(79))},
- {V(int(80)), V(uint16(80))},
- {V(uint16(81)), V(uint(81))},
- {V(uint(82)), V(uint16(82))},
- {V(uint16(83)), V(uintptr(83))},
- {V(uintptr(84)), V(uint16(84))},
- {V(uint16(85)), V(float32(85))},
- {V(float32(86)), V(uint16(86))},
- {V(uint16(87)), V(float64(87))},
- {V(float64(88)), V(uint16(88))},
- {V(int32(89)), V(int32(89))},
- {V(int32(90)), V(uint32(90))},
- {V(uint32(91)), V(int32(91))},
- {V(int32(92)), V(int64(92))},
- {V(int64(93)), V(int32(93))},
- {V(int32(94)), V(uint64(94))},
- {V(uint64(95)), V(int32(95))},
- {V(int32(96)), V(int(96))},
- {V(int(97)), V(int32(97))},
- {V(int32(98)), V(uint(98))},
- {V(uint(99)), V(int32(99))},
- {V(int32(100)), V(uintptr(100))},
- {V(uintptr(101)), V(int32(101))},
- {V(int32(102)), V(float32(102))},
- {V(float32(103)), V(int32(103))},
- {V(int32(104)), V(float64(104))},
- {V(float64(105)), V(int32(105))},
- {V(uint32(106)), V(uint32(106))},
- {V(uint32(107)), V(int64(107))},
- {V(int64(108)), V(uint32(108))},
- {V(uint32(109)), V(uint64(109))},
- {V(uint64(110)), V(uint32(110))},
- {V(uint32(111)), V(int(111))},
- {V(int(112)), V(uint32(112))},
- {V(uint32(113)), V(uint(113))},
- {V(uint(114)), V(uint32(114))},
- {V(uint32(115)), V(uintptr(115))},
- {V(uintptr(116)), V(uint32(116))},
- {V(uint32(117)), V(float32(117))},
- {V(float32(118)), V(uint32(118))},
- {V(uint32(119)), V(float64(119))},
- {V(float64(120)), V(uint32(120))},
- {V(int64(121)), V(int64(121))},
- {V(int64(122)), V(uint64(122))},
- {V(uint64(123)), V(int64(123))},
- {V(int64(124)), V(int(124))},
- {V(int(125)), V(int64(125))},
- {V(int64(126)), V(uint(126))},
- {V(uint(127)), V(int64(127))},
- {V(int64(128)), V(uintptr(128))},
- {V(uintptr(129)), V(int64(129))},
- {V(int64(130)), V(float32(130))},
- {V(float32(131)), V(int64(131))},
- {V(int64(132)), V(float64(132))},
- {V(float64(133)), V(int64(133))},
- {V(uint64(134)), V(uint64(134))},
- {V(uint64(135)), V(int(135))},
- {V(int(136)), V(uint64(136))},
- {V(uint64(137)), V(uint(137))},
- {V(uint(138)), V(uint64(138))},
- {V(uint64(139)), V(uintptr(139))},
- {V(uintptr(140)), V(uint64(140))},
- {V(uint64(141)), V(float32(141))},
- {V(float32(142)), V(uint64(142))},
- {V(uint64(143)), V(float64(143))},
- {V(float64(144)), V(uint64(144))},
- {V(int(145)), V(int(145))},
- {V(int(146)), V(uint(146))},
- {V(uint(147)), V(int(147))},
- {V(int(148)), V(uintptr(148))},
- {V(uintptr(149)), V(int(149))},
- {V(int(150)), V(float32(150))},
- {V(float32(151)), V(int(151))},
- {V(int(152)), V(float64(152))},
- {V(float64(153)), V(int(153))},
- {V(uint(154)), V(uint(154))},
- {V(uint(155)), V(uintptr(155))},
- {V(uintptr(156)), V(uint(156))},
- {V(uint(157)), V(float32(157))},
- {V(float32(158)), V(uint(158))},
- {V(uint(159)), V(float64(159))},
- {V(float64(160)), V(uint(160))},
- {V(uintptr(161)), V(uintptr(161))},
- {V(uintptr(162)), V(float32(162))},
- {V(float32(163)), V(uintptr(163))},
- {V(uintptr(164)), V(float64(164))},
- {V(float64(165)), V(uintptr(165))},
- {V(float32(166)), V(float32(166))},
- {V(float32(167)), V(float64(167))},
- {V(float64(168)), V(float32(168))},
- {V(float64(169)), V(float64(169))},
-
- // truncation
- {V(float64(1.5)), V(int(1))},
-
- // complex
- {V(complex64(1i)), V(complex64(1i))},
- {V(complex64(2i)), V(complex128(2i))},
- {V(complex128(3i)), V(complex64(3i))},
- {V(complex128(4i)), V(complex128(4i))},
-
- // string
- {V(string("hello")), V(string("hello"))},
- {V(string("bytes1")), V([]byte("bytes1"))},
- {V([]byte("bytes2")), V(string("bytes2"))},
- {V([]byte("bytes3")), V([]byte("bytes3"))},
- {V(string("runes♝")), V([]rune("runes♝"))},
- {V([]rune("runes♕")), V(string("runes♕"))},
- {V([]rune("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
- {V(int('a')), V(string("a"))},
- {V(int8('a')), V(string("a"))},
- {V(int16('a')), V(string("a"))},
- {V(int32('a')), V(string("a"))},
- {V(int64('a')), V(string("a"))},
- {V(uint('a')), V(string("a"))},
- {V(uint8('a')), V(string("a"))},
- {V(uint16('a')), V(string("a"))},
- {V(uint32('a')), V(string("a"))},
- {V(uint64('a')), V(string("a"))},
- {V(uintptr('a')), V(string("a"))},
- {V(int(-1)), V(string("\uFFFD"))},
- {V(int8(-2)), V(string("\uFFFD"))},
- {V(int16(-3)), V(string("\uFFFD"))},
- {V(int32(-4)), V(string("\uFFFD"))},
- {V(int64(-5)), V(string("\uFFFD"))},
- {V(uint(0x110001)), V(string("\uFFFD"))},
- {V(uint32(0x110002)), V(string("\uFFFD"))},
- {V(uint64(0x110003)), V(string("\uFFFD"))},
- {V(uintptr(0x110004)), V(string("\uFFFD"))},
-
- // named string
- {V(MyString("hello")), V(string("hello"))},
- {V(string("hello")), V(MyString("hello"))},
- {V(string("hello")), V(string("hello"))},
- {V(MyString("hello")), V(MyString("hello"))},
- {V(MyString("bytes1")), V([]byte("bytes1"))},
- {V([]byte("bytes2")), V(MyString("bytes2"))},
- {V([]byte("bytes3")), V([]byte("bytes3"))},
- {V(MyString("runes♝")), V([]rune("runes♝"))},
- {V([]rune("runes♕")), V(MyString("runes♕"))},
- {V([]rune("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
- {V([]rune("runes🙈🙉🙊")), V(MyRunes("runes🙈🙉🙊"))},
- {V(MyRunes("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
- {V(int('a')), V(MyString("a"))},
- {V(int8('a')), V(MyString("a"))},
- {V(int16('a')), V(MyString("a"))},
- {V(int32('a')), V(MyString("a"))},
- {V(int64('a')), V(MyString("a"))},
- {V(uint('a')), V(MyString("a"))},
- {V(uint8('a')), V(MyString("a"))},
- {V(uint16('a')), V(MyString("a"))},
- {V(uint32('a')), V(MyString("a"))},
- {V(uint64('a')), V(MyString("a"))},
- {V(uintptr('a')), V(MyString("a"))},
- {V(int(-1)), V(MyString("\uFFFD"))},
- {V(int8(-2)), V(MyString("\uFFFD"))},
- {V(int16(-3)), V(MyString("\uFFFD"))},
- {V(int32(-4)), V(MyString("\uFFFD"))},
- {V(int64(-5)), V(MyString("\uFFFD"))},
- {V(uint(0x110001)), V(MyString("\uFFFD"))},
- {V(uint32(0x110002)), V(MyString("\uFFFD"))},
- {V(uint64(0x110003)), V(MyString("\uFFFD"))},
- {V(uintptr(0x110004)), V(MyString("\uFFFD"))},
-
- // named []byte
- {V(string("bytes1")), V(MyBytes("bytes1"))},
- {V(MyBytes("bytes2")), V(string("bytes2"))},
- {V(MyBytes("bytes3")), V(MyBytes("bytes3"))},
- {V(MyString("bytes1")), V(MyBytes("bytes1"))},
- {V(MyBytes("bytes2")), V(MyString("bytes2"))},
-
- // named []rune
- {V(string("runes♝")), V(MyRunes("runes♝"))},
- {V(MyRunes("runes♕")), V(string("runes♕"))},
- {V(MyRunes("runes🙈🙉🙊")), V(MyRunes("runes🙈🙉🙊"))},
- {V(MyString("runes♝")), V(MyRunes("runes♝"))},
- {V(MyRunes("runes♕")), V(MyString("runes♕"))},
-
- // named types and equal underlying types
- {V(new(int)), V(new(integer))},
- {V(new(integer)), V(new(int))},
- {V(Empty{}), V(struct{}{})},
- {V(new(Empty)), V(new(struct{}))},
- {V(struct{}{}), V(Empty{})},
- {V(new(struct{})), V(new(Empty))},
- {V(Empty{}), V(Empty{})},
- {V(MyBytes{}), V([]byte{})},
- {V([]byte{}), V(MyBytes{})},
- {V((func())(nil)), V(MyFunc(nil))},
- {V((MyFunc)(nil)), V((func())(nil))},
-
- // can convert *byte and *MyByte
- {V((*byte)(nil)), V((*MyByte)(nil))},
- {V((*MyByte)(nil)), V((*byte)(nil))},
-
- // cannot convert mismatched array sizes
- {V([2]byte{}), V([2]byte{})},
- {V([3]byte{}), V([3]byte{})},
-
- // cannot convert other instances
- {V((**byte)(nil)), V((**byte)(nil))},
- {V((**MyByte)(nil)), V((**MyByte)(nil))},
- {V((chan byte)(nil)), V((chan byte)(nil))},
- {V((chan MyByte)(nil)), V((chan MyByte)(nil))},
- {V(([]byte)(nil)), V(([]byte)(nil))},
- {V(([]MyByte)(nil)), V(([]MyByte)(nil))},
- {V((map[int]byte)(nil)), V((map[int]byte)(nil))},
- {V((map[int]MyByte)(nil)), V((map[int]MyByte)(nil))},
- {V((map[byte]int)(nil)), V((map[byte]int)(nil))},
- {V((map[MyByte]int)(nil)), V((map[MyByte]int)(nil))},
- {V([2]byte{}), V([2]byte{})},
- {V([2]MyByte{}), V([2]MyByte{})},
-
- // other
- {V((***int)(nil)), V((***int)(nil))},
- {V((***byte)(nil)), V((***byte)(nil))},
- {V((***int32)(nil)), V((***int32)(nil))},
- {V((***int64)(nil)), V((***int64)(nil))},
- {V((chan int)(nil)), V((<-chan int)(nil))},
- {V((chan int)(nil)), V((chan<- int)(nil))},
- {V((chan string)(nil)), V((<-chan string)(nil))},
- {V((chan string)(nil)), V((chan<- string)(nil))},
- {V((chan byte)(nil)), V((chan byte)(nil))},
- {V((chan MyByte)(nil)), V((chan MyByte)(nil))},
- {V((map[int]bool)(nil)), V((map[int]bool)(nil))},
- {V((map[int]byte)(nil)), V((map[int]byte)(nil))},
- {V((map[uint]bool)(nil)), V((map[uint]bool)(nil))},
- {V([]uint(nil)), V([]uint(nil))},
- {V([]int(nil)), V([]int(nil))},
- {V(new(interface{})), V(new(interface{}))},
- {V(new(io.Reader)), V(new(io.Reader))},
- {V(new(io.Writer)), V(new(io.Writer))},
-
- // interfaces
- {V(int(1)), EmptyInterfaceV(int(1))},
- {V(string("hello")), EmptyInterfaceV(string("hello"))},
- {V(new(bytes.Buffer)), ReaderV(new(bytes.Buffer))},
- {ReadWriterV(new(bytes.Buffer)), ReaderV(new(bytes.Buffer))},
- {V(new(bytes.Buffer)), ReadWriterV(new(bytes.Buffer))},
-}
-
-func TestConvert(t *testing.T) {
- canConvert := map[[2]Type]bool{}
- all := map[Type]bool{}
-
- for _, tt := range convertTests {
- t1 := tt.in.Type()
- if !t1.ConvertibleTo(t1) {
- t.Errorf("(%s).ConvertibleTo(%s) = false, want true", t1, t1)
- continue
- }
-
- t2 := tt.out.Type()
- if !t1.ConvertibleTo(t2) {
- t.Errorf("(%s).ConvertibleTo(%s) = false, want true", t1, t2)
- continue
- }
-
- all[t1] = true
- all[t2] = true
- canConvert[[2]Type{t1, t2}] = true
-
- // vout1 represents the in value converted to the in type.
- v1 := tt.in
- vout1 := v1.Convert(t1)
- out1 := vout1.Interface()
- if vout1.Type() != tt.in.Type() || !DeepEqual(out1, tt.in.Interface()) {
- t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t1, out1, tt.in.Interface())
- }
-
- // vout2 represents the in value converted to the out type.
- vout2 := v1.Convert(t2)
- out2 := vout2.Interface()
- if vout2.Type() != tt.out.Type() || !DeepEqual(out2, tt.out.Interface()) {
- t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t2, out2, tt.out.Interface())
- }
-
- // vout3 represents a new value of the out type, set to vout2. This makes
- // sure the converted value vout2 is really usable as a regular value.
- vout3 := New(t2).Elem()
- vout3.Set(vout2)
- out3 := vout3.Interface()
- if vout3.Type() != tt.out.Type() || !DeepEqual(out3, tt.out.Interface()) {
- t.Errorf("Set(ValueOf(%T(%[1]v)).Convert(%s)) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t2, out3, tt.out.Interface())
- }
-
- if IsRO(v1) {
- t.Errorf("table entry %v is RO, should not be", v1)
- }
- if IsRO(vout1) {
- t.Errorf("self-conversion output %v is RO, should not be", vout1)
- }
- if IsRO(vout2) {
- t.Errorf("conversion output %v is RO, should not be", vout2)
- }
- if IsRO(vout3) {
- t.Errorf("set(conversion output) %v is RO, should not be", vout3)
- }
- if !IsRO(MakeRO(v1).Convert(t1)) {
- t.Errorf("RO self-conversion output %v is not RO, should be", v1)
- }
- if !IsRO(MakeRO(v1).Convert(t2)) {
- t.Errorf("RO conversion output %v is not RO, should be", v1)
- }
- }
-
- // Assume that of all the types we saw during the tests,
- // if there wasn't an explicit entry for a conversion between
- // a pair of types, then it's not to be allowed. This checks for
- // things like 'int64' converting to '*int'.
- for t1 := range all {
- for t2 := range all {
- expectOK := t1 == t2 || canConvert[[2]Type{t1, t2}] || t2.Kind() == Interface && t2.NumMethod() == 0
- if ok := t1.ConvertibleTo(t2); ok != expectOK {
- t.Errorf("(%s).ConvertibleTo(%s) = %v, want %v", t1, t2, ok, expectOK)
- }
- }
- }
-}
-
-func TestOverflow(t *testing.T) {
- if ovf := V(float64(0)).OverflowFloat(1e300); ovf {
- t.Errorf("%v wrongly overflows float64", 1e300)
- }
-
- maxFloat32 := float64((1<<24 - 1) << (127 - 23))
- if ovf := V(float32(0)).OverflowFloat(maxFloat32); ovf {
- t.Errorf("%v wrongly overflows float32", maxFloat32)
- }
- ovfFloat32 := float64((1<<24-1)<<(127-23) + 1<<(127-52))
- if ovf := V(float32(0)).OverflowFloat(ovfFloat32); !ovf {
- t.Errorf("%v should overflow float32", ovfFloat32)
- }
- if ovf := V(float32(0)).OverflowFloat(-ovfFloat32); !ovf {
- t.Errorf("%v should overflow float32", -ovfFloat32)
- }
-
- maxInt32 := int64(0x7fffffff)
- if ovf := V(int32(0)).OverflowInt(maxInt32); ovf {
- t.Errorf("%v wrongly overflows int32", maxInt32)
- }
- if ovf := V(int32(0)).OverflowInt(-1 << 31); ovf {
- t.Errorf("%v wrongly overflows int32", -int64(1)<<31)
- }
- ovfInt32 := int64(1 << 31)
- if ovf := V(int32(0)).OverflowInt(ovfInt32); !ovf {
- t.Errorf("%v should overflow int32", ovfInt32)
- }
-
- maxUint32 := uint64(0xffffffff)
- if ovf := V(uint32(0)).OverflowUint(maxUint32); ovf {
- t.Errorf("%v wrongly overflows uint32", maxUint32)
- }
- ovfUint32 := uint64(1 << 32)
- if ovf := V(uint32(0)).OverflowUint(ovfUint32); !ovf {
- t.Errorf("%v should overflow uint32", ovfUint32)
- }
-}
-
-func checkSameType(t *testing.T, x, y interface{}) {
- if TypeOf(x) != TypeOf(y) {
- t.Errorf("did not find preexisting type for %s (vs %s)", TypeOf(x), TypeOf(y))
- }
-}
-
-func TestArrayOf(t *testing.T) {
- // check construction and use of type not in binary
- type T int
- at := ArrayOf(10, TypeOf(T(1)))
- v := New(at).Elem()
- for i := 0; i < v.Len(); i++ {
- v.Index(i).Set(ValueOf(T(i)))
- }
- s := fmt.Sprint(v.Interface())
- want := "[0 1 2 3 4 5 6 7 8 9]"
- if s != want {
- t.Errorf("constructed array = %s, want %s", s, want)
- }
-
- // check that type already in binary is found
- checkSameType(t, Zero(ArrayOf(5, TypeOf(T(1)))).Interface(), [5]T{})
-}
-
-func TestSliceOf(t *testing.T) {
- // check construction and use of type not in binary
- type T int
- st := SliceOf(TypeOf(T(1)))
- v := MakeSlice(st, 10, 10)
- runtime.GC()
- for i := 0; i < v.Len(); i++ {
- v.Index(i).Set(ValueOf(T(i)))
- runtime.GC()
- }
- s := fmt.Sprint(v.Interface())
- want := "[0 1 2 3 4 5 6 7 8 9]"
- if s != want {
- t.Errorf("constructed slice = %s, want %s", s, want)
- }
-
- // check that type already in binary is found
- type T1 int
- checkSameType(t, Zero(SliceOf(TypeOf(T1(1)))).Interface(), []T1{})
-}
-
-func TestSliceOverflow(t *testing.T) {
- // check that MakeSlice panics when size of slice overflows uint
- const S = 1e6
- s := uint(S)
- l := (1<<(unsafe.Sizeof((*byte)(nil))*8)-1)/s + 1
- if l*s >= s {
- t.Fatal("slice size does not overflow")
- }
- var x [S]byte
- st := SliceOf(TypeOf(x))
- defer func() {
- err := recover()
- if err == nil {
- t.Fatal("slice overflow does not panic")
- }
- }()
- MakeSlice(st, int(l), int(l))
-}
-
-func TestSliceOfGC(t *testing.T) {
- type T *uintptr
- tt := TypeOf(T(nil))
- st := SliceOf(tt)
- const n = 100
- var x []interface{}
- for i := 0; i < n; i++ {
- v := MakeSlice(st, n, n)
- for j := 0; j < v.Len(); j++ {
- p := new(uintptr)
- *p = uintptr(i*n + j)
- v.Index(j).Set(ValueOf(p).Convert(tt))
- }
- x = append(x, v.Interface())
- }
- runtime.GC()
-
- for i, xi := range x {
- v := ValueOf(xi)
- for j := 0; j < v.Len(); j++ {
- k := v.Index(j).Elem().Interface()
- if k != uintptr(i*n+j) {
- t.Errorf("lost x[%d][%d] = %d, want %d", i, j, k, i*n+j)
- }
- }
- }
-}
-
-func TestChanOf(t *testing.T) {
- // check construction and use of type not in binary
- type T string
- ct := ChanOf(BothDir, TypeOf(T("")))
- v := MakeChan(ct, 2)
- runtime.GC()
- v.Send(ValueOf(T("hello")))
- runtime.GC()
- v.Send(ValueOf(T("world")))
- runtime.GC()
-
- sv1, _ := v.Recv()
- sv2, _ := v.Recv()
- s1 := sv1.String()
- s2 := sv2.String()
- if s1 != "hello" || s2 != "world" {
- t.Errorf("constructed chan: have %q, %q, want %q, %q", s1, s2, "hello", "world")
- }
-
- // check that type already in binary is found
- type T1 int
- checkSameType(t, Zero(ChanOf(BothDir, TypeOf(T1(1)))).Interface(), (chan T1)(nil))
-}
-
-func TestChanOfGC(t *testing.T) {
- done := make(chan bool, 1)
- go func() {
- select {
- case <-done:
- case <-time.After(5 * time.Second):
- panic("deadlock in TestChanOfGC")
- }
- }()
-
- defer func() {
- done <- true
- }()
-
- type T *uintptr
- tt := TypeOf(T(nil))
- ct := ChanOf(BothDir, tt)
-
- // NOTE: The garbage collector handles allocated channels specially,
- // so we have to save pointers to channels in x; the pointer code will
- // use the gc info in the newly constructed chan type.
- const n = 100
- var x []interface{}
- for i := 0; i < n; i++ {
- v := MakeChan(ct, n)
- for j := 0; j < n; j++ {
- p := new(uintptr)
- *p = uintptr(i*n + j)
- v.Send(ValueOf(p).Convert(tt))
- }
- pv := New(ct)
- pv.Elem().Set(v)
- x = append(x, pv.Interface())
- }
- runtime.GC()
-
- for i, xi := range x {
- v := ValueOf(xi).Elem()
- for j := 0; j < n; j++ {
- pv, _ := v.Recv()
- k := pv.Elem().Interface()
- if k != uintptr(i*n+j) {
- t.Errorf("lost x[%d][%d] = %d, want %d", i, j, k, i*n+j)
- }
- }
- }
-}
-
-func TestMapOf(t *testing.T) {
- // check construction and use of type not in binary
- type K string
- type V float64
-
- v := MakeMap(MapOf(TypeOf(K("")), TypeOf(V(0))))
- runtime.GC()
- v.SetMapIndex(ValueOf(K("a")), ValueOf(V(1)))
- runtime.GC()
-
- s := fmt.Sprint(v.Interface())
- want := "map[a:1]"
- if s != want {
- t.Errorf("constructed map = %s, want %s", s, want)
- }
-
- // check that type already in binary is found
- checkSameType(t, Zero(MapOf(TypeOf(V(0)), TypeOf(K("")))).Interface(), map[V]K(nil))
-
- // check that invalid key type panics
- shouldPanic(func() { MapOf(TypeOf((func())(nil)), TypeOf(false)) })
-}
-
-func TestMapOfGCKeys(t *testing.T) {
- type T *uintptr
- tt := TypeOf(T(nil))
- mt := MapOf(tt, TypeOf(false))
-
- // NOTE: The garbage collector handles allocated maps specially,
- // so we have to save pointers to maps in x; the pointer code will
- // use the gc info in the newly constructed map type.
- const n = 100
- var x []interface{}
- for i := 0; i < n; i++ {
- v := MakeMap(mt)
- for j := 0; j < n; j++ {
- p := new(uintptr)
- *p = uintptr(i*n + j)
- v.SetMapIndex(ValueOf(p).Convert(tt), ValueOf(true))
- }
- pv := New(mt)
- pv.Elem().Set(v)
- x = append(x, pv.Interface())
- }
- runtime.GC()
-
- for i, xi := range x {
- v := ValueOf(xi).Elem()
- var out []int
- for _, kv := range v.MapKeys() {
- out = append(out, int(kv.Elem().Interface().(uintptr)))
- }
- sort.Ints(out)
- for j, k := range out {
- if k != i*n+j {
- t.Errorf("lost x[%d][%d] = %d, want %d", i, j, k, i*n+j)
- }
- }
- }
-}
-
-func TestMapOfGCValues(t *testing.T) {
- type T *uintptr
- tt := TypeOf(T(nil))
- mt := MapOf(TypeOf(1), tt)
-
- // NOTE: The garbage collector handles allocated maps specially,
- // so we have to save pointers to maps in x; the pointer code will
- // use the gc info in the newly constructed map type.
- const n = 100
- var x []interface{}
- for i := 0; i < n; i++ {
- v := MakeMap(mt)
- for j := 0; j < n; j++ {
- p := new(uintptr)
- *p = uintptr(i*n + j)
- v.SetMapIndex(ValueOf(j), ValueOf(p).Convert(tt))
- }
- pv := New(mt)
- pv.Elem().Set(v)
- x = append(x, pv.Interface())
- }
- runtime.GC()
-
- for i, xi := range x {
- v := ValueOf(xi).Elem()
- for j := 0; j < n; j++ {
- k := v.MapIndex(ValueOf(j)).Elem().Interface().(uintptr)
- if k != uintptr(i*n+j) {
- t.Errorf("lost x[%d][%d] = %d, want %d", i, j, k, i*n+j)
- }
- }
- }
-}
-
-type B1 struct {
- X int
- Y int
- Z int
-}
-
-func BenchmarkFieldByName1(b *testing.B) {
- t := TypeOf(B1{})
- for i := 0; i < b.N; i++ {
- t.FieldByName("Z")
- }
-}
-
-func BenchmarkFieldByName2(b *testing.B) {
- t := TypeOf(S3{})
- for i := 0; i < b.N; i++ {
- t.FieldByName("B")
- }
-}
-
-type R0 struct {
- *R1
- *R2
- *R3
- *R4
-}
-
-type R1 struct {
- *R5
- *R6
- *R7
- *R8
-}
-
-type R2 R1
-type R3 R1
-type R4 R1
-
-type R5 struct {
- *R9
- *R10
- *R11
- *R12
-}
-
-type R6 R5
-type R7 R5
-type R8 R5
-
-type R9 struct {
- *R13
- *R14
- *R15
- *R16
-}
-
-type R10 R9
-type R11 R9
-type R12 R9
-
-type R13 struct {
- *R17
- *R18
- *R19
- *R20
-}
-
-type R14 R13
-type R15 R13
-type R16 R13
-
-type R17 struct {
- *R21
- *R22
- *R23
- *R24
-}
-
-type R18 R17
-type R19 R17
-type R20 R17
-
-type R21 struct {
- X int
-}
-
-type R22 R21
-type R23 R21
-type R24 R21
-
-func TestEmbed(t *testing.T) {
- typ := TypeOf(R0{})
- f, ok := typ.FieldByName("X")
- if ok {
- t.Fatalf(`FieldByName("X") should fail, returned %v`, f.Index)
- }
-}
-
-func BenchmarkFieldByName3(b *testing.B) {
- t := TypeOf(R0{})
- for i := 0; i < b.N; i++ {
- t.FieldByName("X")
- }
-}
-
-type S struct {
- i1 int64
- i2 int64
-}
-
-func BenchmarkInterfaceBig(b *testing.B) {
- v := ValueOf(S{})
- for i := 0; i < b.N; i++ {
- v.Interface()
- }
- b.StopTimer()
-}
-
-func TestAllocsInterfaceBig(t *testing.T) {
- if testing.Short() {
- t.Skip("skipping malloc count in short mode")
- }
- v := ValueOf(S{})
- if allocs := testing.AllocsPerRun(100, func() { v.Interface() }); allocs > 0 {
- t.Error("allocs:", allocs)
- }
-}
-
-func BenchmarkInterfaceSmall(b *testing.B) {
- v := ValueOf(int64(0))
- for i := 0; i < b.N; i++ {
- v.Interface()
- }
-}
-
-func TestAllocsInterfaceSmall(t *testing.T) {
- if testing.Short() {
- t.Skip("skipping malloc count in short mode")
- }
- v := ValueOf(int64(0))
- if allocs := testing.AllocsPerRun(100, func() { v.Interface() }); allocs > 0 {
- t.Error("allocs:", allocs)
- }
-}
-
-// An exhaustive is a mechanism for writing exhaustive or stochastic tests.
-// The basic usage is:
-//
-// for x.Next() {
-// ... code using x.Maybe() or x.Choice(n) to create test cases ...
-// }
-//
-// Each iteration of the loop returns a different set of results, until all
-// possible result sets have been explored. It is okay for different code paths
-// to make different method call sequences on x, but there must be no
-// other source of non-determinism in the call sequences.
-//
-// When faced with a new decision, x chooses randomly. Future explorations
-// of that path will choose successive values for the result. Thus, stopping
-// the loop after a fixed number of iterations gives somewhat stochastic
-// testing.
-//
-// Example:
-//
-// for x.Next() {
-// v := make([]bool, x.Choose(4))
-// for i := range v {
-// v[i] = x.Maybe()
-// }
-// fmt.Println(v)
-// }
-//
-// prints (in some order):
-//
-// []
-// [false]
-// [true]
-// [false false]
-// [false true]
-// ...
-// [true true]
-// [false false false]
-// ...
-// [true true true]
-// [false false false false]
-// ...
-// [true true true true]
-//
-type exhaustive struct {
- r *rand.Rand
- pos int
- last []choice
-}
-
-type choice struct {
- off int
- n int
- max int
-}
-
-func (x *exhaustive) Next() bool {
- if x.r == nil {
- x.r = rand.New(rand.NewSource(time.Now().UnixNano()))
- }
- x.pos = 0
- if x.last == nil {
- x.last = []choice{}
- return true
- }
- for i := len(x.last) - 1; i >= 0; i-- {
- c := &x.last[i]
- if c.n+1 < c.max {
- c.n++
- x.last = x.last[:i+1]
- return true
- }
- }
- return false
-}
-
-func (x *exhaustive) Choose(max int) int {
- if x.pos >= len(x.last) {
- x.last = append(x.last, choice{x.r.Intn(max), 0, max})
- }
- c := &x.last[x.pos]
- x.pos++
- if c.max != max {
- panic("inconsistent use of exhaustive tester")
- }
- return (c.n + c.off) % max
-}
-
-func (x *exhaustive) Maybe() bool {
- return x.Choose(2) == 1
-}
-
-func GCFunc(args []Value) []Value {
- runtime.GC()
- return []Value{}
-}
-
-func TestReflectFuncTraceback(t *testing.T) {
- f := MakeFunc(TypeOf(func() {}), GCFunc)
- f.Call([]Value{})
-}
-
-func (p Point) GCMethod(k int) int {
- runtime.GC()
- return k + p.x
-}
-
-func TestReflectMethodTraceback(t *testing.T) {
- p := Point{3, 4}
- m := ValueOf(p).MethodByName("GCMethod")
- i := ValueOf(m.Interface()).Call([]Value{ValueOf(5)})[0].Int()
- if i != 8 {
- t.Errorf("Call returned %d; want 8", i)
- }
-}
-
-func TestBigZero(t *testing.T) {
- const size = 1 << 10
- var v [size]byte
- z := Zero(ValueOf(v).Type()).Interface().([size]byte)
- for i := 0; i < size; i++ {
- if z[i] != 0 {
- t.Fatalf("Zero object not all zero, index %d", i)
- }
- }
-}
-
-func TestFieldByIndexNil(t *testing.T) {
- type P struct {
- F int
- }
- type T struct {
- *P
- }
- v := ValueOf(T{})
-
- v.FieldByName("P") // should be fine
-
- defer func() {
- if err := recover(); err == nil {
- t.Fatalf("no error")
- } else if !strings.Contains(fmt.Sprint(err), "nil pointer to embedded struct") {
- t.Fatalf(`err=%q, wanted error containing "nil pointer to embedded struct"`, err)
- }
- }()
- v.FieldByName("F") // should panic
-
- t.Fatalf("did not panic")
-}
-
-// Given
-// type Outer struct {
-// *Inner
-// ...
-// }
-// the compiler generates the implementation of (*Outer).M dispatching to the embedded Inner.
-// The implementation is logically:
-// func (p *Outer) M() {
-// (p.Inner).M()
-// }
-// but since the only change here is the replacement of one pointer receiver with another,
-// the actual generated code overwrites the original receiver with the p.Inner pointer and
-// then jumps to the M method expecting the *Inner receiver.
-//
-// During reflect.Value.Call, we create an argument frame and the associated data structures
-// to describe it to the garbage collector, populate the frame, call reflect.call to
-// run a function call using that frame, and then copy the results back out of the frame.
-// The reflect.call function does a memmove of the frame structure onto the
-// stack (to set up the inputs), runs the call, and the memmoves the stack back to
-// the frame structure (to preserve the outputs).
-//
-// Originally reflect.call did not distinguish inputs from outputs: both memmoves
-// were for the full stack frame. However, in the case where the called function was
-// one of these wrappers, the rewritten receiver is almost certainly a different type
-// than the original receiver. This is not a problem on the stack, where we use the
-// program counter to determine the type information and understand that
-// during (*Outer).M the receiver is an *Outer while during (*Inner).M the receiver in the same
-// memory word is now an *Inner. But in the statically typed argument frame created
-// by reflect, the receiver is always an *Outer. Copying the modified receiver pointer
-// off the stack into the frame will store an *Inner there, and then if a garbage collection
-// happens to scan that argument frame before it is discarded, it will scan the *Inner
-// memory as if it were an *Outer. If the two have different memory layouts, the
-// collection will intepret the memory incorrectly.
-//
-// One such possible incorrect interpretation is to treat two arbitrary memory words
-// (Inner.P1 and Inner.P2 below) as an interface (Outer.R below). Because interpreting
-// an interface requires dereferencing the itab word, the misinterpretation will try to
-// deference Inner.P1, causing a crash during garbage collection.
-//
-// This came up in a real program in issue 7725.
-
-type Outer struct {
- *Inner
- R io.Reader
-}
-
-type Inner struct {
- X *Outer
- P1 uintptr
- P2 uintptr
-}
-
-func (pi *Inner) M() {
- // Clear references to pi so that the only way the
- // garbage collection will find the pointer is in the
- // argument frame, typed as a *Outer.
- pi.X.Inner = nil
-
- // Set up an interface value that will cause a crash.
- // P1 = 1 is a non-zero, so the interface looks non-nil.
- // P2 = pi ensures that the data word points into the
- // allocated heap; if not the collection skips the interface
- // value as irrelevant, without dereferencing P1.
- pi.P1 = 1
- pi.P2 = uintptr(unsafe.Pointer(pi))
-}
-
-func TestCallMethodJump(t *testing.T) {
- // In reflect.Value.Call, trigger a garbage collection after reflect.call
- // returns but before the args frame has been discarded.
- // This is a little clumsy but makes the failure repeatable.
- *CallGC = true
-
- p := &Outer{Inner: new(Inner)}
- p.Inner.X = p
- ValueOf(p).Method(0).Call(nil)
-
- // Stop garbage collecting during reflect.call.
- *CallGC = false
-}
diff --git a/src/pkg/reflect/asm_386.s b/src/pkg/reflect/asm_386.s
deleted file mode 100644
index 75413c752..000000000
--- a/src/pkg/reflect/asm_386.s
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "../../cmd/ld/textflag.h"
-
-// makeFuncStub is the code half of the function returned by MakeFunc.
-// See the comment on the declaration of makeFuncStub in makefunc.go
-// for more details.
-// No argsize here, gc generates argsize info at call site.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$8
- MOVL DX, 0(SP)
- LEAL argframe+0(FP), CX
- MOVL CX, 4(SP)
- CALL ·callReflect(SB)
- RET
-
-// methodValueCall is the code half of the function returned by makeMethodValue.
-// See the comment on the declaration of methodValueCall in makefunc.go
-// for more details.
-// No argsize here, gc generates argsize info at call site.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$8
- MOVL DX, 0(SP)
- LEAL argframe+0(FP), CX
- MOVL CX, 4(SP)
- CALL ·callMethod(SB)
- RET
diff --git a/src/pkg/reflect/asm_amd64.s b/src/pkg/reflect/asm_amd64.s
deleted file mode 100644
index 712959843..000000000
--- a/src/pkg/reflect/asm_amd64.s
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "../../cmd/ld/textflag.h"
-
-// makeFuncStub is the code half of the function returned by MakeFunc.
-// See the comment on the declaration of makeFuncStub in makefunc.go
-// for more details.
-// No argsize here, gc generates argsize info at call site.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$16
- MOVQ DX, 0(SP)
- LEAQ argframe+0(FP), CX
- MOVQ CX, 8(SP)
- CALL ·callReflect(SB)
- RET
-
-// methodValueCall is the code half of the function returned by makeMethodValue.
-// See the comment on the declaration of methodValueCall in makefunc.go
-// for more details.
-// No argsize here, gc generates argsize info at call site.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$16
- MOVQ DX, 0(SP)
- LEAQ argframe+0(FP), CX
- MOVQ CX, 8(SP)
- CALL ·callMethod(SB)
- RET
diff --git a/src/pkg/reflect/asm_amd64p32.s b/src/pkg/reflect/asm_amd64p32.s
deleted file mode 100644
index 75413c752..000000000
--- a/src/pkg/reflect/asm_amd64p32.s
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "../../cmd/ld/textflag.h"
-
-// makeFuncStub is the code half of the function returned by MakeFunc.
-// See the comment on the declaration of makeFuncStub in makefunc.go
-// for more details.
-// No argsize here, gc generates argsize info at call site.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$8
- MOVL DX, 0(SP)
- LEAL argframe+0(FP), CX
- MOVL CX, 4(SP)
- CALL ·callReflect(SB)
- RET
-
-// methodValueCall is the code half of the function returned by makeMethodValue.
-// See the comment on the declaration of methodValueCall in makefunc.go
-// for more details.
-// No argsize here, gc generates argsize info at call site.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$8
- MOVL DX, 0(SP)
- LEAL argframe+0(FP), CX
- MOVL CX, 4(SP)
- CALL ·callMethod(SB)
- RET
diff --git a/src/pkg/reflect/asm_arm.s b/src/pkg/reflect/asm_arm.s
deleted file mode 100644
index 68ded4ac6..000000000
--- a/src/pkg/reflect/asm_arm.s
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "../../cmd/ld/textflag.h"
-
-// makeFuncStub is jumped to by the code generated by MakeFunc.
-// See the comment on the declaration of makeFuncStub in makefunc.go
-// for more details.
-// No argsize here, gc generates argsize info at call site.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$8
- MOVW R7, 4(R13)
- MOVW $argframe+0(FP), R1
- MOVW R1, 8(R13)
- BL ·callReflect(SB)
- RET
-
-// methodValueCall is the code half of the function returned by makeMethodValue.
-// See the comment on the declaration of methodValueCall in makefunc.go
-// for more details.
-// No argsize here, gc generates argsize info at call site.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$8
- MOVW R7, 4(R13)
- MOVW $argframe+0(FP), R1
- MOVW R1, 8(R13)
- BL ·callMethod(SB)
- RET
diff --git a/src/pkg/reflect/deepequal.go b/src/pkg/reflect/deepequal.go
deleted file mode 100644
index f63715c9a..000000000
--- a/src/pkg/reflect/deepequal.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Deep equality test via reflection
-
-package reflect
-
-// During deepValueEqual, must keep track of checks that are
-// in progress. The comparison algorithm assumes that all
-// checks in progress are true when it reencounters them.
-// Visited comparisons are stored in a map indexed by visit.
-type visit struct {
- a1 uintptr
- a2 uintptr
- typ Type
-}
-
-// Tests for deep equality using reflected types. The map argument tracks
-// comparisons that have already been seen, which allows short circuiting on
-// recursive types.
-func deepValueEqual(v1, v2 Value, visited map[visit]bool, depth int) bool {
- if !v1.IsValid() || !v2.IsValid() {
- return v1.IsValid() == v2.IsValid()
- }
- if v1.Type() != v2.Type() {
- return false
- }
-
- // if depth > 10 { panic("deepValueEqual") } // for debugging
- hard := func(k Kind) bool {
- switch k {
- case Array, Map, Slice, Struct:
- return true
- }
- return false
- }
-
- if v1.CanAddr() && v2.CanAddr() && hard(v1.Kind()) {
- addr1 := v1.UnsafeAddr()
- addr2 := v2.UnsafeAddr()
- if addr1 > addr2 {
- // Canonicalize order to reduce number of entries in visited.
- addr1, addr2 = addr2, addr1
- }
-
- // Short circuit if references are identical ...
- if addr1 == addr2 {
- return true
- }
-
- // ... or already seen
- typ := v1.Type()
- v := visit{addr1, addr2, typ}
- if visited[v] {
- return true
- }
-
- // Remember for later.
- visited[v] = true
- }
-
- switch v1.Kind() {
- case Array:
- for i := 0; i < v1.Len(); i++ {
- if !deepValueEqual(v1.Index(i), v2.Index(i), visited, depth+1) {
- return false
- }
- }
- return true
- case Slice:
- if v1.IsNil() != v2.IsNil() {
- return false
- }
- if v1.Len() != v2.Len() {
- return false
- }
- if v1.Pointer() == v2.Pointer() {
- return true
- }
- for i := 0; i < v1.Len(); i++ {
- if !deepValueEqual(v1.Index(i), v2.Index(i), visited, depth+1) {
- return false
- }
- }
- return true
- case Interface:
- if v1.IsNil() || v2.IsNil() {
- return v1.IsNil() == v2.IsNil()
- }
- return deepValueEqual(v1.Elem(), v2.Elem(), visited, depth+1)
- case Ptr:
- return deepValueEqual(v1.Elem(), v2.Elem(), visited, depth+1)
- case Struct:
- for i, n := 0, v1.NumField(); i < n; i++ {
- if !deepValueEqual(v1.Field(i), v2.Field(i), visited, depth+1) {
- return false
- }
- }
- return true
- case Map:
- if v1.IsNil() != v2.IsNil() {
- return false
- }
- if v1.Len() != v2.Len() {
- return false
- }
- if v1.Pointer() == v2.Pointer() {
- return true
- }
- for _, k := range v1.MapKeys() {
- if !deepValueEqual(v1.MapIndex(k), v2.MapIndex(k), visited, depth+1) {
- return false
- }
- }
- return true
- case Func:
- if v1.IsNil() && v2.IsNil() {
- return true
- }
- // Can't do better than this:
- return false
- default:
- // Normal equality suffices
- return valueInterface(v1, false) == valueInterface(v2, false)
- }
-}
-
-// DeepEqual tests for deep equality. It uses normal == equality where
-// possible but will scan elements of arrays, slices, maps, and fields of
-// structs. In maps, keys are compared with == but elements use deep
-// equality. DeepEqual correctly handles recursive types. Functions are equal
-// only if they are both nil.
-// An empty slice is not equal to a nil slice.
-func DeepEqual(a1, a2 interface{}) bool {
- if a1 == nil || a2 == nil {
- return a1 == a2
- }
- v1 := ValueOf(a1)
- v2 := ValueOf(a2)
- if v1.Type() != v2.Type() {
- return false
- }
- return deepValueEqual(v1, v2, make(map[visit]bool), 0)
-}
diff --git a/src/pkg/reflect/example_test.go b/src/pkg/reflect/example_test.go
deleted file mode 100644
index cca28eeec..000000000
--- a/src/pkg/reflect/example_test.go
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package reflect_test
-
-import (
- "fmt"
- "reflect"
-)
-
-func ExampleMakeFunc() {
- // swap is the implementation passed to MakeFunc.
- // It must work in terms of reflect.Values so that it is possible
- // to write code without knowing beforehand what the types
- // will be.
- swap := func(in []reflect.Value) []reflect.Value {
- return []reflect.Value{in[1], in[0]}
- }
-
- // makeSwap expects fptr to be a pointer to a nil function.
- // It sets that pointer to a new function created with MakeFunc.
- // When the function is invoked, reflect turns the arguments
- // into Values, calls swap, and then turns swap's result slice
- // into the values returned by the new function.
- makeSwap := func(fptr interface{}) {
- // fptr is a pointer to a function.
- // Obtain the function value itself (likely nil) as a reflect.Value
- // so that we can query its type and then set the value.
- fn := reflect.ValueOf(fptr).Elem()
-
- // Make a function of the right type.
- v := reflect.MakeFunc(fn.Type(), swap)
-
- // Assign it to the value fn represents.
- fn.Set(v)
- }
-
- // Make and call a swap function for ints.
- var intSwap func(int, int) (int, int)
- makeSwap(&intSwap)
- fmt.Println(intSwap(0, 1))
-
- // Make and call a swap function for float64s.
- var floatSwap func(float64, float64) (float64, float64)
- makeSwap(&floatSwap)
- fmt.Println(floatSwap(2.72, 3.14))
-
- // Output:
- // 1 0
- // 3.14 2.72
-}
-
-func ExampleStructTag() {
- type S struct {
- F string `species:"gopher" color:"blue"`
- }
-
- s := S{}
- st := reflect.TypeOf(s)
- field := st.Field(0)
- fmt.Println(field.Tag.Get("color"), field.Tag.Get("species"))
-
- // Output:
- // blue gopher
-}
diff --git a/src/pkg/reflect/export_test.go b/src/pkg/reflect/export_test.go
deleted file mode 100644
index 0778ad37f..000000000
--- a/src/pkg/reflect/export_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package reflect
-
-// MakeRO returns a copy of v with the read-only flag set.
-func MakeRO(v Value) Value {
- v.flag |= flagRO
- return v
-}
-
-// IsRO reports whether v's read-only flag is set.
-func IsRO(v Value) bool {
- return v.flag&flagRO != 0
-}
-
-var ArrayOf = arrayOf
-var CallGC = &callGC
diff --git a/src/pkg/reflect/makefunc.go b/src/pkg/reflect/makefunc.go
deleted file mode 100644
index 0e61fdea7..000000000
--- a/src/pkg/reflect/makefunc.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// MakeFunc implementation.
-
-package reflect
-
-import (
- "unsafe"
-)
-
-// makeFuncImpl is the closure value implementing the function
-// returned by MakeFunc.
-type makeFuncImpl struct {
- code uintptr
- typ *funcType
- fn func([]Value) []Value
-}
-
-// MakeFunc returns a new function of the given Type
-// that wraps the function fn. When called, that new function
-// does the following:
-//
-// - converts its arguments to a slice of Values.
-// - runs results := fn(args).
-// - returns the results as a slice of Values, one per formal result.
-//
-// The implementation fn can assume that the argument Value slice
-// has the number and type of arguments given by typ.
-// If typ describes a variadic function, the final Value is itself
-// a slice representing the variadic arguments, as in the
-// body of a variadic function. The result Value slice returned by fn
-// must have the number and type of results given by typ.
-//
-// The Value.Call method allows the caller to invoke a typed function
-// in terms of Values; in contrast, MakeFunc allows the caller to implement
-// a typed function in terms of Values.
-//
-// The Examples section of the documentation includes an illustration
-// of how to use MakeFunc to build a swap function for different types.
-//
-func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
- if typ.Kind() != Func {
- panic("reflect: call of MakeFunc with non-Func type")
- }
-
- t := typ.common()
- ftyp := (*funcType)(unsafe.Pointer(t))
-
- // Indirect Go func value (dummy) to obtain
- // actual code address. (A Go func value is a pointer
- // to a C function pointer. http://golang.org/s/go11func.)
- dummy := makeFuncStub
- code := **(**uintptr)(unsafe.Pointer(&dummy))
-
- impl := &makeFuncImpl{code: code, typ: ftyp, fn: fn}
-
- return Value{t, unsafe.Pointer(impl), 0, flag(Func) << flagKindShift}
-}
-
-// makeFuncStub is an assembly function that is the code half of
-// the function returned from MakeFunc. It expects a *callReflectFunc
-// as its context register, and its job is to invoke callReflect(ctxt, frame)
-// where ctxt is the context register and frame is a pointer to the first
-// word in the passed-in argument frame.
-func makeFuncStub()
-
-type methodValue struct {
- fn uintptr
- method int
- rcvr Value
-}
-
-// makeMethodValue converts v from the rcvr+method index representation
-// of a method value to an actual method func value, which is
-// basically the receiver value with a special bit set, into a true
-// func value - a value holding an actual func. The output is
-// semantically equivalent to the input as far as the user of package
-// reflect can tell, but the true func representation can be handled
-// by code like Convert and Interface and Assign.
-func makeMethodValue(op string, v Value) Value {
- if v.flag&flagMethod == 0 {
- panic("reflect: internal error: invalid use of makeMethodValue")
- }
-
- // Ignoring the flagMethod bit, v describes the receiver, not the method type.
- fl := v.flag & (flagRO | flagAddr | flagIndir)
- fl |= flag(v.typ.Kind()) << flagKindShift
- rcvr := Value{v.typ, v.ptr, v.scalar, fl}
-
- // v.Type returns the actual type of the method value.
- funcType := v.Type().(*rtype)
-
- // Indirect Go func value (dummy) to obtain
- // actual code address. (A Go func value is a pointer
- // to a C function pointer. http://golang.org/s/go11func.)
- dummy := methodValueCall
- code := **(**uintptr)(unsafe.Pointer(&dummy))
-
- fv := &methodValue{
- fn: code,
- method: int(v.flag) >> flagMethodShift,
- rcvr: rcvr,
- }
-
- // Cause panic if method is not appropriate.
- // The panic would still happen during the call if we omit this,
- // but we want Interface() and other operations to fail early.
- methodReceiver(op, fv.rcvr, fv.method)
-
- return Value{funcType, unsafe.Pointer(fv), 0, v.flag&flagRO | flag(Func)<<flagKindShift}
-}
-
-// methodValueCall is an assembly function that is the code half of
-// the function returned from makeMethodValue. It expects a *methodValue
-// as its context register, and its job is to invoke callMethod(ctxt, frame)
-// where ctxt is the context register and frame is a pointer to the first
-// word in the passed-in argument frame.
-func methodValueCall()
diff --git a/src/pkg/reflect/set_test.go b/src/pkg/reflect/set_test.go
deleted file mode 100644
index 85dc55e68..000000000
--- a/src/pkg/reflect/set_test.go
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package reflect_test
-
-import (
- "bytes"
- "go/ast"
- "io"
- . "reflect"
- "testing"
- "unsafe"
-)
-
-type MyBuffer bytes.Buffer
-
-func TestImplicitMapConversion(t *testing.T) {
- // Test implicit conversions in MapIndex and SetMapIndex.
- {
- // direct
- m := make(map[int]int)
- mv := ValueOf(m)
- mv.SetMapIndex(ValueOf(1), ValueOf(2))
- x, ok := m[1]
- if x != 2 {
- t.Errorf("#1 after SetMapIndex(1,2): %d, %t (map=%v)", x, ok, m)
- }
- if n := mv.MapIndex(ValueOf(1)).Interface().(int); n != 2 {
- t.Errorf("#1 MapIndex(1) = %d", n)
- }
- }
- {
- // convert interface key
- m := make(map[interface{}]int)
- mv := ValueOf(m)
- mv.SetMapIndex(ValueOf(1), ValueOf(2))
- x, ok := m[1]
- if x != 2 {
- t.Errorf("#2 after SetMapIndex(1,2): %d, %t (map=%v)", x, ok, m)
- }
- if n := mv.MapIndex(ValueOf(1)).Interface().(int); n != 2 {
- t.Errorf("#2 MapIndex(1) = %d", n)
- }
- }
- {
- // convert interface value
- m := make(map[int]interface{})
- mv := ValueOf(m)
- mv.SetMapIndex(ValueOf(1), ValueOf(2))
- x, ok := m[1]
- if x != 2 {
- t.Errorf("#3 after SetMapIndex(1,2): %d, %t (map=%v)", x, ok, m)
- }
- if n := mv.MapIndex(ValueOf(1)).Interface().(int); n != 2 {
- t.Errorf("#3 MapIndex(1) = %d", n)
- }
- }
- {
- // convert both interface key and interface value
- m := make(map[interface{}]interface{})
- mv := ValueOf(m)
- mv.SetMapIndex(ValueOf(1), ValueOf(2))
- x, ok := m[1]
- if x != 2 {
- t.Errorf("#4 after SetMapIndex(1,2): %d, %t (map=%v)", x, ok, m)
- }
- if n := mv.MapIndex(ValueOf(1)).Interface().(int); n != 2 {
- t.Errorf("#4 MapIndex(1) = %d", n)
- }
- }
- {
- // convert both, with non-empty interfaces
- m := make(map[io.Reader]io.Writer)
- mv := ValueOf(m)
- b1 := new(bytes.Buffer)
- b2 := new(bytes.Buffer)
- mv.SetMapIndex(ValueOf(b1), ValueOf(b2))
- x, ok := m[b1]
- if x != b2 {
- t.Errorf("#5 after SetMapIndex(b1, b2): %p (!= %p), %t (map=%v)", x, b2, ok, m)
- }
- if p := mv.MapIndex(ValueOf(b1)).Elem().Pointer(); p != uintptr(unsafe.Pointer(b2)) {
- t.Errorf("#5 MapIndex(b1) = %#x want %p", p, b2)
- }
- }
- {
- // convert channel direction
- m := make(map[<-chan int]chan int)
- mv := ValueOf(m)
- c1 := make(chan int)
- c2 := make(chan int)
- mv.SetMapIndex(ValueOf(c1), ValueOf(c2))
- x, ok := m[c1]
- if x != c2 {
- t.Errorf("#6 after SetMapIndex(c1, c2): %p (!= %p), %t (map=%v)", x, c2, ok, m)
- }
- if p := mv.MapIndex(ValueOf(c1)).Pointer(); p != ValueOf(c2).Pointer() {
- t.Errorf("#6 MapIndex(c1) = %#x want %p", p, c2)
- }
- }
- {
- // convert identical underlying types
- // TODO(rsc): Should be able to define MyBuffer here.
- // 6l prints very strange messages about .this.Bytes etc
- // when we do that though, so MyBuffer is defined
- // at top level.
- m := make(map[*MyBuffer]*bytes.Buffer)
- mv := ValueOf(m)
- b1 := new(MyBuffer)
- b2 := new(bytes.Buffer)
- mv.SetMapIndex(ValueOf(b1), ValueOf(b2))
- x, ok := m[b1]
- if x != b2 {
- t.Errorf("#7 after SetMapIndex(b1, b2): %p (!= %p), %t (map=%v)", x, b2, ok, m)
- }
- if p := mv.MapIndex(ValueOf(b1)).Pointer(); p != uintptr(unsafe.Pointer(b2)) {
- t.Errorf("#7 MapIndex(b1) = %#x want %p", p, b2)
- }
- }
-
-}
-
-func TestImplicitSetConversion(t *testing.T) {
- // Assume TestImplicitMapConversion covered the basics.
- // Just make sure conversions are being applied at all.
- var r io.Reader
- b := new(bytes.Buffer)
- rv := ValueOf(&r).Elem()
- rv.Set(ValueOf(b))
- if r != b {
- t.Errorf("after Set: r=%T(%v)", r, r)
- }
-}
-
-func TestImplicitSendConversion(t *testing.T) {
- c := make(chan io.Reader, 10)
- b := new(bytes.Buffer)
- ValueOf(c).Send(ValueOf(b))
- if bb := <-c; bb != b {
- t.Errorf("Received %p != %p", bb, b)
- }
-}
-
-func TestImplicitCallConversion(t *testing.T) {
- // Arguments must be assignable to parameter types.
- fv := ValueOf(io.WriteString)
- b := new(bytes.Buffer)
- fv.Call([]Value{ValueOf(b), ValueOf("hello world")})
- if b.String() != "hello world" {
- t.Errorf("After call: string=%q want %q", b.String(), "hello world")
- }
-}
-
-func TestImplicitAppendConversion(t *testing.T) {
- // Arguments must be assignable to the slice's element type.
- s := []io.Reader{}
- sv := ValueOf(&s).Elem()
- b := new(bytes.Buffer)
- sv.Set(Append(sv, ValueOf(b)))
- if len(s) != 1 || s[0] != b {
- t.Errorf("after append: s=%v want [%p]", s, b)
- }
-}
-
-var implementsTests = []struct {
- x interface{}
- t interface{}
- b bool
-}{
- {new(*bytes.Buffer), new(io.Reader), true},
- {new(bytes.Buffer), new(io.Reader), false},
- {new(*bytes.Buffer), new(io.ReaderAt), false},
- {new(*ast.Ident), new(ast.Expr), true},
-}
-
-func TestImplements(t *testing.T) {
- for _, tt := range implementsTests {
- xv := TypeOf(tt.x).Elem()
- xt := TypeOf(tt.t).Elem()
- if b := xv.Implements(xt); b != tt.b {
- t.Errorf("(%s).Implements(%s) = %v, want %v", xv.String(), xt.String(), b, tt.b)
- }
- }
-}
-
-var assignableTests = []struct {
- x interface{}
- t interface{}
- b bool
-}{
- {new(chan int), new(<-chan int), true},
- {new(<-chan int), new(chan int), false},
- {new(*int), new(IntPtr), true},
- {new(IntPtr), new(*int), true},
- {new(IntPtr), new(IntPtr1), false},
- // test runs implementsTests too
-}
-
-type IntPtr *int
-type IntPtr1 *int
-
-func TestAssignableTo(t *testing.T) {
- for _, tt := range append(assignableTests, implementsTests...) {
- xv := TypeOf(tt.x).Elem()
- xt := TypeOf(tt.t).Elem()
- if b := xv.AssignableTo(xt); b != tt.b {
- t.Errorf("(%s).AssignableTo(%s) = %v, want %v", xv.String(), xt.String(), b, tt.b)
- }
- }
-}
diff --git a/src/pkg/reflect/tostring_test.go b/src/pkg/reflect/tostring_test.go
deleted file mode 100644
index e416fd84d..000000000
--- a/src/pkg/reflect/tostring_test.go
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Formatting of reflection types and values for debugging.
-// Not defined as methods so they do not need to be linked into most binaries;
-// the functions are not used by the library itself, only in tests.
-
-package reflect_test
-
-import (
- . "reflect"
- "strconv"
-)
-
-// valueToString returns a textual representation of the reflection value val.
-// For debugging only.
-func valueToString(val Value) string {
- var str string
- if !val.IsValid() {
- return "<zero Value>"
- }
- typ := val.Type()
- switch val.Kind() {
- case Int, Int8, Int16, Int32, Int64:
- return strconv.FormatInt(val.Int(), 10)
- case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
- return strconv.FormatUint(val.Uint(), 10)
- case Float32, Float64:
- return strconv.FormatFloat(val.Float(), 'g', -1, 64)
- case Complex64, Complex128:
- c := val.Complex()
- return strconv.FormatFloat(real(c), 'g', -1, 64) + "+" + strconv.FormatFloat(imag(c), 'g', -1, 64) + "i"
- case String:
- return val.String()
- case Bool:
- if val.Bool() {
- return "true"
- } else {
- return "false"
- }
- case Ptr:
- v := val
- str = typ.String() + "("
- if v.IsNil() {
- str += "0"
- } else {
- str += "&" + valueToString(v.Elem())
- }
- str += ")"
- return str
- case Array, Slice:
- v := val
- str += typ.String()
- str += "{"
- for i := 0; i < v.Len(); i++ {
- if i > 0 {
- str += ", "
- }
- str += valueToString(v.Index(i))
- }
- str += "}"
- return str
- case Map:
- t := typ
- str = t.String()
- str += "{"
- str += "<can't iterate on maps>"
- str += "}"
- return str
- case Chan:
- str = typ.String()
- return str
- case Struct:
- t := typ
- v := val
- str += t.String()
- str += "{"
- for i, n := 0, v.NumField(); i < n; i++ {
- if i > 0 {
- str += ", "
- }
- str += valueToString(v.Field(i))
- }
- str += "}"
- return str
- case Interface:
- return typ.String() + "(" + valueToString(val.Elem()) + ")"
- case Func:
- v := val
- return typ.String() + "(" + strconv.FormatUint(uint64(v.Pointer()), 10) + ")"
- default:
- panic("valueToString: can't print type " + typ.String())
- }
-}
diff --git a/src/pkg/reflect/type.go b/src/pkg/reflect/type.go
deleted file mode 100644
index 40d76f99d..000000000
--- a/src/pkg/reflect/type.go
+++ /dev/null
@@ -1,1926 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package reflect implements run-time reflection, allowing a program to
-// manipulate objects with arbitrary types. The typical use is to take a value
-// with static type interface{} and extract its dynamic type information by
-// calling TypeOf, which returns a Type.
-//
-// A call to ValueOf returns a Value representing the run-time data.
-// Zero takes a Type and returns a Value representing a zero value
-// for that type.
-//
-// See "The Laws of Reflection" for an introduction to reflection in Go:
-// http://golang.org/doc/articles/laws_of_reflection.html
-package reflect
-
-import (
- "runtime"
- "strconv"
- "sync"
- "unsafe"
-)
-
-// Type is the representation of a Go type.
-//
-// Not all methods apply to all kinds of types. Restrictions,
-// if any, are noted in the documentation for each method.
-// Use the Kind method to find out the kind of type before
-// calling kind-specific methods. Calling a method
-// inappropriate to the kind of type causes a run-time panic.
-type Type interface {
- // Methods applicable to all types.
-
- // Align returns the alignment in bytes of a value of
- // this type when allocated in memory.
- Align() int
-
- // FieldAlign returns the alignment in bytes of a value of
- // this type when used as a field in a struct.
- FieldAlign() int
-
- // Method returns the i'th method in the type's method set.
- // It panics if i is not in the range [0, NumMethod()).
- //
- // For a non-interface type T or *T, the returned Method's Type and Func
- // fields describe a function whose first argument is the receiver.
- //
- // For an interface type, the returned Method's Type field gives the
- // method signature, without a receiver, and the Func field is nil.
- Method(int) Method
-
- // MethodByName returns the method with that name in the type's
- // method set and a boolean indicating if the method was found.
- //
- // For a non-interface type T or *T, the returned Method's Type and Func
- // fields describe a function whose first argument is the receiver.
- //
- // For an interface type, the returned Method's Type field gives the
- // method signature, without a receiver, and the Func field is nil.
- MethodByName(string) (Method, bool)
-
- // NumMethod returns the number of methods in the type's method set.
- NumMethod() int
-
- // Name returns the type's name within its package.
- // It returns an empty string for unnamed types.
- Name() string
-
- // PkgPath returns a named type's package path, that is, the import path
- // that uniquely identifies the package, such as "encoding/base64".
- // If the type was predeclared (string, error) or unnamed (*T, struct{}, []int),
- // the package path will be the empty string.
- PkgPath() string
-
- // Size returns the number of bytes needed to store
- // a value of the given type; it is analogous to unsafe.Sizeof.
- Size() uintptr
-
- // String returns a string representation of the type.
- // The string representation may use shortened package names
- // (e.g., base64 instead of "encoding/base64") and is not
- // guaranteed to be unique among types. To test for equality,
- // compare the Types directly.
- String() string
-
- // Kind returns the specific kind of this type.
- Kind() Kind
-
- // Implements returns true if the type implements the interface type u.
- Implements(u Type) bool
-
- // AssignableTo returns true if a value of the type is assignable to type u.
- AssignableTo(u Type) bool
-
- // ConvertibleTo returns true if a value of the type is convertible to type u.
- ConvertibleTo(u Type) bool
-
- // Methods applicable only to some types, depending on Kind.
- // The methods allowed for each kind are:
- //
- // Int*, Uint*, Float*, Complex*: Bits
- // Array: Elem, Len
- // Chan: ChanDir, Elem
- // Func: In, NumIn, Out, NumOut, IsVariadic.
- // Map: Key, Elem
- // Ptr: Elem
- // Slice: Elem
- // Struct: Field, FieldByIndex, FieldByName, FieldByNameFunc, NumField
-
- // Bits returns the size of the type in bits.
- // It panics if the type's Kind is not one of the
- // sized or unsized Int, Uint, Float, or Complex kinds.
- Bits() int
-
- // ChanDir returns a channel type's direction.
- // It panics if the type's Kind is not Chan.
- ChanDir() ChanDir
-
- // IsVariadic returns true if a function type's final input parameter
- // is a "..." parameter. If so, t.In(t.NumIn() - 1) returns the parameter's
- // implicit actual type []T.
- //
- // For concreteness, if t represents func(x int, y ... float64), then
- //
- // t.NumIn() == 2
- // t.In(0) is the reflect.Type for "int"
- // t.In(1) is the reflect.Type for "[]float64"
- // t.IsVariadic() == true
- //
- // IsVariadic panics if the type's Kind is not Func.
- IsVariadic() bool
-
- // Elem returns a type's element type.
- // It panics if the type's Kind is not Array, Chan, Map, Ptr, or Slice.
- Elem() Type
-
- // Field returns a struct type's i'th field.
- // It panics if the type's Kind is not Struct.
- // It panics if i is not in the range [0, NumField()).
- Field(i int) StructField
-
- // FieldByIndex returns the nested field corresponding
- // to the index sequence. It is equivalent to calling Field
- // successively for each index i.
- // It panics if the type's Kind is not Struct.
- FieldByIndex(index []int) StructField
-
- // FieldByName returns the struct field with the given name
- // and a boolean indicating if the field was found.
- FieldByName(name string) (StructField, bool)
-
- // FieldByNameFunc returns the first struct field with a name
- // that satisfies the match function and a boolean indicating if
- // the field was found.
- FieldByNameFunc(match func(string) bool) (StructField, bool)
-
- // In returns the type of a function type's i'th input parameter.
- // It panics if the type's Kind is not Func.
- // It panics if i is not in the range [0, NumIn()).
- In(i int) Type
-
- // Key returns a map type's key type.
- // It panics if the type's Kind is not Map.
- Key() Type
-
- // Len returns an array type's length.
- // It panics if the type's Kind is not Array.
- Len() int
-
- // NumField returns a struct type's field count.
- // It panics if the type's Kind is not Struct.
- NumField() int
-
- // NumIn returns a function type's input parameter count.
- // It panics if the type's Kind is not Func.
- NumIn() int
-
- // NumOut returns a function type's output parameter count.
- // It panics if the type's Kind is not Func.
- NumOut() int
-
- // Out returns the type of a function type's i'th output parameter.
- // It panics if the type's Kind is not Func.
- // It panics if i is not in the range [0, NumOut()).
- Out(i int) Type
-
- common() *rtype
- uncommon() *uncommonType
-}
-
-// BUG(rsc): FieldByName and related functions consider struct field names to be equal
-// if the names are equal, even if they are unexported names originating
-// in different packages. The practical effect of this is that the result of
-// t.FieldByName("x") is not well defined if the struct type t contains
-// multiple fields named x (embedded from different packages).
-// FieldByName may return one of the fields named x or may report that there are none.
-// See golang.org/issue/4876 for more details.
-
-/*
- * These data structures are known to the compiler (../../cmd/gc/reflect.c).
- * A few are known to ../runtime/type.go to convey to debuggers.
- * They are also known to ../runtime/type.h.
- */
-
-// A Kind represents the specific kind of type that a Type represents.
-// The zero Kind is not a valid kind.
-type Kind uint
-
-const (
- Invalid Kind = iota
- Bool
- Int
- Int8
- Int16
- Int32
- Int64
- Uint
- Uint8
- Uint16
- Uint32
- Uint64
- Uintptr
- Float32
- Float64
- Complex64
- Complex128
- Array
- Chan
- Func
- Interface
- Map
- Ptr
- Slice
- String
- Struct
- UnsafePointer
-)
-
-// rtype is the common implementation of most values.
-// It is embedded in other, public struct types, but always
-// with a unique tag like `reflect:"array"` or `reflect:"ptr"`
-// so that code cannot convert from, say, *arrayType to *ptrType.
-type rtype struct {
- size uintptr // size in bytes
- hash uint32 // hash of type; avoids computation in hash tables
- _ uint8 // unused/padding
- align uint8 // alignment of variable with this type
- fieldAlign uint8 // alignment of struct field with this type
- kind uint8 // enumeration for C
- alg *uintptr // algorithm table (../runtime/runtime.h:/Alg)
- gc unsafe.Pointer // garbage collection data
- string *string // string form; unnecessary but undeniably useful
- *uncommonType // (relatively) uncommon fields
- ptrToThis *rtype // type for pointer to this type, if used in binary or has methods
- zero unsafe.Pointer // pointer to zero value
-}
-
-// Method on non-interface type
-type method struct {
- name *string // name of method
- pkgPath *string // nil for exported Names; otherwise import path
- mtyp *rtype // method type (without receiver)
- typ *rtype // .(*FuncType) underneath (with receiver)
- ifn unsafe.Pointer // fn used in interface call (one-word receiver)
- tfn unsafe.Pointer // fn used for normal method call
-}
-
-// uncommonType is present only for types with names or methods
-// (if T is a named type, the uncommonTypes for T and *T have methods).
-// Using a pointer to this struct reduces the overall size required
-// to describe an unnamed type with no methods.
-type uncommonType struct {
- name *string // name of type
- pkgPath *string // import path; nil for built-in types like int, string
- methods []method // methods associated with type
-}
-
-// ChanDir represents a channel type's direction.
-type ChanDir int
-
-const (
- RecvDir ChanDir = 1 << iota // <-chan
- SendDir // chan<-
- BothDir = RecvDir | SendDir // chan
-)
-
-// arrayType represents a fixed array type.
-type arrayType struct {
- rtype `reflect:"array"`
- elem *rtype // array element type
- slice *rtype // slice type
- len uintptr
-}
-
-// chanType represents a channel type.
-type chanType struct {
- rtype `reflect:"chan"`
- elem *rtype // channel element type
- dir uintptr // channel direction (ChanDir)
-}
-
-// funcType represents a function type.
-type funcType struct {
- rtype `reflect:"func"`
- dotdotdot bool // last input parameter is ...
- in []*rtype // input parameter types
- out []*rtype // output parameter types
-}
-
-// imethod represents a method on an interface type
-type imethod struct {
- name *string // name of method
- pkgPath *string // nil for exported Names; otherwise import path
- typ *rtype // .(*FuncType) underneath
-}
-
-// interfaceType represents an interface type.
-type interfaceType struct {
- rtype `reflect:"interface"`
- methods []imethod // sorted by hash
-}
-
-// mapType represents a map type.
-type mapType struct {
- rtype `reflect:"map"`
- key *rtype // map key type
- elem *rtype // map element (value) type
- bucket *rtype // internal bucket structure
- hmap *rtype // internal map header
-}
-
-// ptrType represents a pointer type.
-type ptrType struct {
- rtype `reflect:"ptr"`
- elem *rtype // pointer element (pointed at) type
-}
-
-// sliceType represents a slice type.
-type sliceType struct {
- rtype `reflect:"slice"`
- elem *rtype // slice element type
-}
-
-// Struct field
-type structField struct {
- name *string // nil for embedded fields
- pkgPath *string // nil for exported Names; otherwise import path
- typ *rtype // type of field
- tag *string // nil if no tag
- offset uintptr // byte offset of field within struct
-}
-
-// structType represents a struct type.
-type structType struct {
- rtype `reflect:"struct"`
- fields []structField // sorted by offset
-}
-
-// NOTE: These are copied from ../runtime/mgc0.h.
-// They must be kept in sync.
-const (
- _GC_END = iota
- _GC_PTR
- _GC_APTR
- _GC_ARRAY_START
- _GC_ARRAY_NEXT
- _GC_CALL
- _GC_CHAN_PTR
- _GC_STRING
- _GC_EFACE
- _GC_IFACE
- _GC_SLICE
- _GC_REGION
- _GC_NUM_INSTR
-)
-
-/*
- * The compiler knows the exact layout of all the data structures above.
- * The compiler does not know about the data structures and methods below.
- */
-
-// Method represents a single method.
-type Method struct {
- // Name is the method name.
- // PkgPath is the package path that qualifies a lower case (unexported)
- // method name. It is empty for upper case (exported) method names.
- // The combination of PkgPath and Name uniquely identifies a method
- // in a method set.
- // See http://golang.org/ref/spec#Uniqueness_of_identifiers
- Name string
- PkgPath string
-
- Type Type // method type
- Func Value // func with receiver as first argument
- Index int // index for Type.Method
-}
-
-// High bit says whether type has
-// embedded pointers,to help garbage collector.
-const (
- kindMask = 0x7f
- kindNoPointers = 0x80
-)
-
-func (k Kind) String() string {
- if int(k) < len(kindNames) {
- return kindNames[k]
- }
- return "kind" + strconv.Itoa(int(k))
-}
-
-var kindNames = []string{
- Invalid: "invalid",
- Bool: "bool",
- Int: "int",
- Int8: "int8",
- Int16: "int16",
- Int32: "int32",
- Int64: "int64",
- Uint: "uint",
- Uint8: "uint8",
- Uint16: "uint16",
- Uint32: "uint32",
- Uint64: "uint64",
- Uintptr: "uintptr",
- Float32: "float32",
- Float64: "float64",
- Complex64: "complex64",
- Complex128: "complex128",
- Array: "array",
- Chan: "chan",
- Func: "func",
- Interface: "interface",
- Map: "map",
- Ptr: "ptr",
- Slice: "slice",
- String: "string",
- Struct: "struct",
- UnsafePointer: "unsafe.Pointer",
-}
-
-func (t *uncommonType) uncommon() *uncommonType {
- return t
-}
-
-func (t *uncommonType) PkgPath() string {
- if t == nil || t.pkgPath == nil {
- return ""
- }
- return *t.pkgPath
-}
-
-func (t *uncommonType) Name() string {
- if t == nil || t.name == nil {
- return ""
- }
- return *t.name
-}
-
-func (t *rtype) String() string { return *t.string }
-
-func (t *rtype) Size() uintptr { return t.size }
-
-func (t *rtype) Bits() int {
- if t == nil {
- panic("reflect: Bits of nil Type")
- }
- k := t.Kind()
- if k < Int || k > Complex128 {
- panic("reflect: Bits of non-arithmetic Type " + t.String())
- }
- return int(t.size) * 8
-}
-
-func (t *rtype) Align() int { return int(t.align) }
-
-func (t *rtype) FieldAlign() int { return int(t.fieldAlign) }
-
-func (t *rtype) Kind() Kind { return Kind(t.kind & kindMask) }
-
-func (t *rtype) pointers() bool { return t.kind&kindNoPointers == 0 }
-
-func (t *rtype) common() *rtype { return t }
-
-func (t *uncommonType) Method(i int) (m Method) {
- if t == nil || i < 0 || i >= len(t.methods) {
- panic("reflect: Method index out of range")
- }
- p := &t.methods[i]
- if p.name != nil {
- m.Name = *p.name
- }
- fl := flag(Func) << flagKindShift
- if p.pkgPath != nil {
- m.PkgPath = *p.pkgPath
- fl |= flagRO
- }
- mt := p.typ
- m.Type = mt
- fn := unsafe.Pointer(&p.tfn)
- m.Func = Value{mt, fn, 0, fl}
- m.Index = i
- return
-}
-
-func (t *uncommonType) NumMethod() int {
- if t == nil {
- return 0
- }
- return len(t.methods)
-}
-
-func (t *uncommonType) MethodByName(name string) (m Method, ok bool) {
- if t == nil {
- return
- }
- var p *method
- for i := range t.methods {
- p = &t.methods[i]
- if p.name != nil && *p.name == name {
- return t.Method(i), true
- }
- }
- return
-}
-
-// TODO(rsc): 6g supplies these, but they are not
-// as efficient as they could be: they have commonType
-// as the receiver instead of *rtype.
-func (t *rtype) NumMethod() int {
- if t.Kind() == Interface {
- tt := (*interfaceType)(unsafe.Pointer(t))
- return tt.NumMethod()
- }
- return t.uncommonType.NumMethod()
-}
-
-func (t *rtype) Method(i int) (m Method) {
- if t.Kind() == Interface {
- tt := (*interfaceType)(unsafe.Pointer(t))
- return tt.Method(i)
- }
- return t.uncommonType.Method(i)
-}
-
-func (t *rtype) MethodByName(name string) (m Method, ok bool) {
- if t.Kind() == Interface {
- tt := (*interfaceType)(unsafe.Pointer(t))
- return tt.MethodByName(name)
- }
- return t.uncommonType.MethodByName(name)
-}
-
-func (t *rtype) PkgPath() string {
- return t.uncommonType.PkgPath()
-}
-
-func (t *rtype) Name() string {
- return t.uncommonType.Name()
-}
-
-func (t *rtype) ChanDir() ChanDir {
- if t.Kind() != Chan {
- panic("reflect: ChanDir of non-chan type")
- }
- tt := (*chanType)(unsafe.Pointer(t))
- return ChanDir(tt.dir)
-}
-
-func (t *rtype) IsVariadic() bool {
- if t.Kind() != Func {
- panic("reflect: IsVariadic of non-func type")
- }
- tt := (*funcType)(unsafe.Pointer(t))
- return tt.dotdotdot
-}
-
-func (t *rtype) Elem() Type {
- switch t.Kind() {
- case Array:
- tt := (*arrayType)(unsafe.Pointer(t))
- return toType(tt.elem)
- case Chan:
- tt := (*chanType)(unsafe.Pointer(t))
- return toType(tt.elem)
- case Map:
- tt := (*mapType)(unsafe.Pointer(t))
- return toType(tt.elem)
- case Ptr:
- tt := (*ptrType)(unsafe.Pointer(t))
- return toType(tt.elem)
- case Slice:
- tt := (*sliceType)(unsafe.Pointer(t))
- return toType(tt.elem)
- }
- panic("reflect: Elem of invalid type")
-}
-
-func (t *rtype) Field(i int) StructField {
- if t.Kind() != Struct {
- panic("reflect: Field of non-struct type")
- }
- tt := (*structType)(unsafe.Pointer(t))
- return tt.Field(i)
-}
-
-func (t *rtype) FieldByIndex(index []int) StructField {
- if t.Kind() != Struct {
- panic("reflect: FieldByIndex of non-struct type")
- }
- tt := (*structType)(unsafe.Pointer(t))
- return tt.FieldByIndex(index)
-}
-
-func (t *rtype) FieldByName(name string) (StructField, bool) {
- if t.Kind() != Struct {
- panic("reflect: FieldByName of non-struct type")
- }
- tt := (*structType)(unsafe.Pointer(t))
- return tt.FieldByName(name)
-}
-
-func (t *rtype) FieldByNameFunc(match func(string) bool) (StructField, bool) {
- if t.Kind() != Struct {
- panic("reflect: FieldByNameFunc of non-struct type")
- }
- tt := (*structType)(unsafe.Pointer(t))
- return tt.FieldByNameFunc(match)
-}
-
-func (t *rtype) In(i int) Type {
- if t.Kind() != Func {
- panic("reflect: In of non-func type")
- }
- tt := (*funcType)(unsafe.Pointer(t))
- return toType(tt.in[i])
-}
-
-func (t *rtype) Key() Type {
- if t.Kind() != Map {
- panic("reflect: Key of non-map type")
- }
- tt := (*mapType)(unsafe.Pointer(t))
- return toType(tt.key)
-}
-
-func (t *rtype) Len() int {
- if t.Kind() != Array {
- panic("reflect: Len of non-array type")
- }
- tt := (*arrayType)(unsafe.Pointer(t))
- return int(tt.len)
-}
-
-func (t *rtype) NumField() int {
- if t.Kind() != Struct {
- panic("reflect: NumField of non-struct type")
- }
- tt := (*structType)(unsafe.Pointer(t))
- return len(tt.fields)
-}
-
-func (t *rtype) NumIn() int {
- if t.Kind() != Func {
- panic("reflect: NumIn of non-func type")
- }
- tt := (*funcType)(unsafe.Pointer(t))
- return len(tt.in)
-}
-
-func (t *rtype) NumOut() int {
- if t.Kind() != Func {
- panic("reflect: NumOut of non-func type")
- }
- tt := (*funcType)(unsafe.Pointer(t))
- return len(tt.out)
-}
-
-func (t *rtype) Out(i int) Type {
- if t.Kind() != Func {
- panic("reflect: Out of non-func type")
- }
- tt := (*funcType)(unsafe.Pointer(t))
- return toType(tt.out[i])
-}
-
-func (d ChanDir) String() string {
- switch d {
- case SendDir:
- return "chan<-"
- case RecvDir:
- return "<-chan"
- case BothDir:
- return "chan"
- }
- return "ChanDir" + strconv.Itoa(int(d))
-}
-
-// Method returns the i'th method in the type's method set.
-func (t *interfaceType) Method(i int) (m Method) {
- if i < 0 || i >= len(t.methods) {
- return
- }
- p := &t.methods[i]
- m.Name = *p.name
- if p.pkgPath != nil {
- m.PkgPath = *p.pkgPath
- }
- m.Type = toType(p.typ)
- m.Index = i
- return
-}
-
-// NumMethod returns the number of interface methods in the type's method set.
-func (t *interfaceType) NumMethod() int { return len(t.methods) }
-
-// MethodByName method with the given name in the type's method set.
-func (t *interfaceType) MethodByName(name string) (m Method, ok bool) {
- if t == nil {
- return
- }
- var p *imethod
- for i := range t.methods {
- p = &t.methods[i]
- if *p.name == name {
- return t.Method(i), true
- }
- }
- return
-}
-
-// A StructField describes a single field in a struct.
-type StructField struct {
- // Name is the field name.
- // PkgPath is the package path that qualifies a lower case (unexported)
- // field name. It is empty for upper case (exported) field names.
- // See http://golang.org/ref/spec#Uniqueness_of_identifiers
- Name string
- PkgPath string
-
- Type Type // field type
- Tag StructTag // field tag string
- Offset uintptr // offset within struct, in bytes
- Index []int // index sequence for Type.FieldByIndex
- Anonymous bool // is an embedded field
-}
-
-// A StructTag is the tag string in a struct field.
-//
-// By convention, tag strings are a concatenation of
-// optionally space-separated key:"value" pairs.
-// Each key is a non-empty string consisting of non-control
-// characters other than space (U+0020 ' '), quote (U+0022 '"'),
-// and colon (U+003A ':'). Each value is quoted using U+0022 '"'
-// characters and Go string literal syntax.
-type StructTag string
-
-// Get returns the value associated with key in the tag string.
-// If there is no such key in the tag, Get returns the empty string.
-// If the tag does not have the conventional format, the value
-// returned by Get is unspecified.
-func (tag StructTag) Get(key string) string {
- for tag != "" {
- // skip leading space
- i := 0
- for i < len(tag) && tag[i] == ' ' {
- i++
- }
- tag = tag[i:]
- if tag == "" {
- break
- }
-
- // scan to colon.
- // a space or a quote is a syntax error
- i = 0
- for i < len(tag) && tag[i] != ' ' && tag[i] != ':' && tag[i] != '"' {
- i++
- }
- if i+1 >= len(tag) || tag[i] != ':' || tag[i+1] != '"' {
- break
- }
- name := string(tag[:i])
- tag = tag[i+1:]
-
- // scan quoted string to find value
- i = 1
- for i < len(tag) && tag[i] != '"' {
- if tag[i] == '\\' {
- i++
- }
- i++
- }
- if i >= len(tag) {
- break
- }
- qvalue := string(tag[:i+1])
- tag = tag[i+1:]
-
- if key == name {
- value, _ := strconv.Unquote(qvalue)
- return value
- }
- }
- return ""
-}
-
-// Field returns the i'th struct field.
-func (t *structType) Field(i int) (f StructField) {
- if i < 0 || i >= len(t.fields) {
- return
- }
- p := &t.fields[i]
- f.Type = toType(p.typ)
- if p.name != nil {
- f.Name = *p.name
- } else {
- t := f.Type
- if t.Kind() == Ptr {
- t = t.Elem()
- }
- f.Name = t.Name()
- f.Anonymous = true
- }
- if p.pkgPath != nil {
- f.PkgPath = *p.pkgPath
- }
- if p.tag != nil {
- f.Tag = StructTag(*p.tag)
- }
- f.Offset = p.offset
-
- // NOTE(rsc): This is the only allocation in the interface
- // presented by a reflect.Type. It would be nice to avoid,
- // at least in the common cases, but we need to make sure
- // that misbehaving clients of reflect cannot affect other
- // uses of reflect. One possibility is CL 5371098, but we
- // postponed that ugliness until there is a demonstrated
- // need for the performance. This is issue 2320.
- f.Index = []int{i}
- return
-}
-
-// TODO(gri): Should there be an error/bool indicator if the index
-// is wrong for FieldByIndex?
-
-// FieldByIndex returns the nested field corresponding to index.
-func (t *structType) FieldByIndex(index []int) (f StructField) {
- f.Type = toType(&t.rtype)
- for i, x := range index {
- if i > 0 {
- ft := f.Type
- if ft.Kind() == Ptr && ft.Elem().Kind() == Struct {
- ft = ft.Elem()
- }
- f.Type = ft
- }
- f = f.Type.Field(x)
- }
- return
-}
-
-// A fieldScan represents an item on the fieldByNameFunc scan work list.
-type fieldScan struct {
- typ *structType
- index []int
-}
-
-// FieldByNameFunc returns the struct field with a name that satisfies the
-// match function and a boolean to indicate if the field was found.
-func (t *structType) FieldByNameFunc(match func(string) bool) (result StructField, ok bool) {
- // This uses the same condition that the Go language does: there must be a unique instance
- // of the match at a given depth level. If there are multiple instances of a match at the
- // same depth, they annihilate each other and inhibit any possible match at a lower level.
- // The algorithm is breadth first search, one depth level at a time.
-
- // The current and next slices are work queues:
- // current lists the fields to visit on this depth level,
- // and next lists the fields on the next lower level.
- current := []fieldScan{}
- next := []fieldScan{{typ: t}}
-
- // nextCount records the number of times an embedded type has been
- // encountered and considered for queueing in the 'next' slice.
- // We only queue the first one, but we increment the count on each.
- // If a struct type T can be reached more than once at a given depth level,
- // then it annihilates itself and need not be considered at all when we
- // process that next depth level.
- var nextCount map[*structType]int
-
- // visited records the structs that have been considered already.
- // Embedded pointer fields can create cycles in the graph of
- // reachable embedded types; visited avoids following those cycles.
- // It also avoids duplicated effort: if we didn't find the field in an
- // embedded type T at level 2, we won't find it in one at level 4 either.
- visited := map[*structType]bool{}
-
- for len(next) > 0 {
- current, next = next, current[:0]
- count := nextCount
- nextCount = nil
-
- // Process all the fields at this depth, now listed in 'current'.
- // The loop queues embedded fields found in 'next', for processing during the next
- // iteration. The multiplicity of the 'current' field counts is recorded
- // in 'count'; the multiplicity of the 'next' field counts is recorded in 'nextCount'.
- for _, scan := range current {
- t := scan.typ
- if visited[t] {
- // We've looked through this type before, at a higher level.
- // That higher level would shadow the lower level we're now at,
- // so this one can't be useful to us. Ignore it.
- continue
- }
- visited[t] = true
- for i := range t.fields {
- f := &t.fields[i]
- // Find name and type for field f.
- var fname string
- var ntyp *rtype
- if f.name != nil {
- fname = *f.name
- } else {
- // Anonymous field of type T or *T.
- // Name taken from type.
- ntyp = f.typ
- if ntyp.Kind() == Ptr {
- ntyp = ntyp.Elem().common()
- }
- fname = ntyp.Name()
- }
-
- // Does it match?
- if match(fname) {
- // Potential match
- if count[t] > 1 || ok {
- // Name appeared multiple times at this level: annihilate.
- return StructField{}, false
- }
- result = t.Field(i)
- result.Index = nil
- result.Index = append(result.Index, scan.index...)
- result.Index = append(result.Index, i)
- ok = true
- continue
- }
-
- // Queue embedded struct fields for processing with next level,
- // but only if we haven't seen a match yet at this level and only
- // if the embedded types haven't already been queued.
- if ok || ntyp == nil || ntyp.Kind() != Struct {
- continue
- }
- styp := (*structType)(unsafe.Pointer(ntyp))
- if nextCount[styp] > 0 {
- nextCount[styp] = 2 // exact multiple doesn't matter
- continue
- }
- if nextCount == nil {
- nextCount = map[*structType]int{}
- }
- nextCount[styp] = 1
- if count[t] > 1 {
- nextCount[styp] = 2 // exact multiple doesn't matter
- }
- var index []int
- index = append(index, scan.index...)
- index = append(index, i)
- next = append(next, fieldScan{styp, index})
- }
- }
- if ok {
- break
- }
- }
- return
-}
-
-// FieldByName returns the struct field with the given name
-// and a boolean to indicate if the field was found.
-func (t *structType) FieldByName(name string) (f StructField, present bool) {
- // Quick check for top-level name, or struct without anonymous fields.
- hasAnon := false
- if name != "" {
- for i := range t.fields {
- tf := &t.fields[i]
- if tf.name == nil {
- hasAnon = true
- continue
- }
- if *tf.name == name {
- return t.Field(i), true
- }
- }
- }
- if !hasAnon {
- return
- }
- return t.FieldByNameFunc(func(s string) bool { return s == name })
-}
-
-// TypeOf returns the reflection Type of the value in the interface{}.
-// TypeOf(nil) returns nil.
-func TypeOf(i interface{}) Type {
- eface := *(*emptyInterface)(unsafe.Pointer(&i))
- return toType(eface.typ)
-}
-
-// ptrMap is the cache for PtrTo.
-var ptrMap struct {
- sync.RWMutex
- m map[*rtype]*ptrType
-}
-
-// garbage collection bytecode program for pointer to memory without pointers.
-// See ../../cmd/gc/reflect.c:/^dgcsym1 and :/^dgcsym.
-type ptrDataGC struct {
- width uintptr // sizeof(ptr)
- op uintptr // _GC_APTR
- off uintptr // 0
- end uintptr // _GC_END
-}
-
-var ptrDataGCProg = ptrDataGC{
- width: unsafe.Sizeof((*byte)(nil)),
- op: _GC_APTR,
- off: 0,
- end: _GC_END,
-}
-
-// garbage collection bytecode program for pointer to memory with pointers.
-// See ../../cmd/gc/reflect.c:/^dgcsym1 and :/^dgcsym.
-type ptrGC struct {
- width uintptr // sizeof(ptr)
- op uintptr // _GC_PTR
- off uintptr // 0
- elemgc unsafe.Pointer // element gc type
- end uintptr // _GC_END
-}
-
-// PtrTo returns the pointer type with element t.
-// For example, if t represents type Foo, PtrTo(t) represents *Foo.
-func PtrTo(t Type) Type {
- return t.(*rtype).ptrTo()
-}
-
-func (t *rtype) ptrTo() *rtype {
- if p := t.ptrToThis; p != nil {
- return p
- }
-
- // Otherwise, synthesize one.
- // This only happens for pointers with no methods.
- // We keep the mapping in a map on the side, because
- // this operation is rare and a separate map lets us keep
- // the type structures in read-only memory.
- ptrMap.RLock()
- if m := ptrMap.m; m != nil {
- if p := m[t]; p != nil {
- ptrMap.RUnlock()
- return &p.rtype
- }
- }
- ptrMap.RUnlock()
- ptrMap.Lock()
- if ptrMap.m == nil {
- ptrMap.m = make(map[*rtype]*ptrType)
- }
- p := ptrMap.m[t]
- if p != nil {
- // some other goroutine won the race and created it
- ptrMap.Unlock()
- return &p.rtype
- }
-
- // Create a new ptrType starting with the description
- // of an *unsafe.Pointer.
- p = new(ptrType)
- var iptr interface{} = (*unsafe.Pointer)(nil)
- prototype := *(**ptrType)(unsafe.Pointer(&iptr))
- *p = *prototype
-
- s := "*" + *t.string
- p.string = &s
-
- // For the type structures linked into the binary, the
- // compiler provides a good hash of the string.
- // Create a good hash for the new string by using
- // the FNV-1 hash's mixing function to combine the
- // old hash and the new "*".
- p.hash = fnv1(t.hash, '*')
-
- p.uncommonType = nil
- p.ptrToThis = nil
- p.zero = unsafe.Pointer(&make([]byte, p.size)[0])
- p.elem = t
-
- if t.kind&kindNoPointers != 0 {
- p.gc = unsafe.Pointer(&ptrDataGCProg)
- } else {
- p.gc = unsafe.Pointer(&ptrGC{
- width: p.size,
- op: _GC_PTR,
- off: 0,
- elemgc: t.gc,
- end: _GC_END,
- })
- }
- // INCORRECT. Uncomment to check that TestPtrToGC fails when p.gc is wrong.
- //p.gc = unsafe.Pointer(&badGC{width: p.size, end: _GC_END})
-
- ptrMap.m[t] = p
- ptrMap.Unlock()
- return &p.rtype
-}
-
-// fnv1 incorporates the list of bytes into the hash x using the FNV-1 hash function.
-func fnv1(x uint32, list ...byte) uint32 {
- for _, b := range list {
- x = x*16777619 ^ uint32(b)
- }
- return x
-}
-
-func (t *rtype) Implements(u Type) bool {
- if u == nil {
- panic("reflect: nil type passed to Type.Implements")
- }
- if u.Kind() != Interface {
- panic("reflect: non-interface type passed to Type.Implements")
- }
- return implements(u.(*rtype), t)
-}
-
-func (t *rtype) AssignableTo(u Type) bool {
- if u == nil {
- panic("reflect: nil type passed to Type.AssignableTo")
- }
- uu := u.(*rtype)
- return directlyAssignable(uu, t) || implements(uu, t)
-}
-
-func (t *rtype) ConvertibleTo(u Type) bool {
- if u == nil {
- panic("reflect: nil type passed to Type.ConvertibleTo")
- }
- uu := u.(*rtype)
- return convertOp(uu, t) != nil
-}
-
-// implements returns true if the type V implements the interface type T.
-func implements(T, V *rtype) bool {
- if T.Kind() != Interface {
- return false
- }
- t := (*interfaceType)(unsafe.Pointer(T))
- if len(t.methods) == 0 {
- return true
- }
-
- // The same algorithm applies in both cases, but the
- // method tables for an interface type and a concrete type
- // are different, so the code is duplicated.
- // In both cases the algorithm is a linear scan over the two
- // lists - T's methods and V's methods - simultaneously.
- // Since method tables are stored in a unique sorted order
- // (alphabetical, with no duplicate method names), the scan
- // through V's methods must hit a match for each of T's
- // methods along the way, or else V does not implement T.
- // This lets us run the scan in overall linear time instead of
- // the quadratic time a naive search would require.
- // See also ../runtime/iface.c.
- if V.Kind() == Interface {
- v := (*interfaceType)(unsafe.Pointer(V))
- i := 0
- for j := 0; j < len(v.methods); j++ {
- tm := &t.methods[i]
- vm := &v.methods[j]
- if vm.name == tm.name && vm.pkgPath == tm.pkgPath && vm.typ == tm.typ {
- if i++; i >= len(t.methods) {
- return true
- }
- }
- }
- return false
- }
-
- v := V.uncommon()
- if v == nil {
- return false
- }
- i := 0
- for j := 0; j < len(v.methods); j++ {
- tm := &t.methods[i]
- vm := &v.methods[j]
- if vm.name == tm.name && vm.pkgPath == tm.pkgPath && vm.mtyp == tm.typ {
- if i++; i >= len(t.methods) {
- return true
- }
- }
- }
- return false
-}
-
-// directlyAssignable returns true if a value x of type V can be directly
-// assigned (using memmove) to a value of type T.
-// http://golang.org/doc/go_spec.html#Assignability
-// Ignoring the interface rules (implemented elsewhere)
-// and the ideal constant rules (no ideal constants at run time).
-func directlyAssignable(T, V *rtype) bool {
- // x's type V is identical to T?
- if T == V {
- return true
- }
-
- // Otherwise at least one of T and V must be unnamed
- // and they must have the same kind.
- if T.Name() != "" && V.Name() != "" || T.Kind() != V.Kind() {
- return false
- }
-
- // x's type T and V must have identical underlying types.
- return haveIdenticalUnderlyingType(T, V)
-}
-
-func haveIdenticalUnderlyingType(T, V *rtype) bool {
- if T == V {
- return true
- }
-
- kind := T.Kind()
- if kind != V.Kind() {
- return false
- }
-
- // Non-composite types of equal kind have same underlying type
- // (the predefined instance of the type).
- if Bool <= kind && kind <= Complex128 || kind == String || kind == UnsafePointer {
- return true
- }
-
- // Composite types.
- switch kind {
- case Array:
- return T.Elem() == V.Elem() && T.Len() == V.Len()
-
- case Chan:
- // Special case:
- // x is a bidirectional channel value, T is a channel type,
- // and x's type V and T have identical element types.
- if V.ChanDir() == BothDir && T.Elem() == V.Elem() {
- return true
- }
-
- // Otherwise continue test for identical underlying type.
- return V.ChanDir() == T.ChanDir() && T.Elem() == V.Elem()
-
- case Func:
- t := (*funcType)(unsafe.Pointer(T))
- v := (*funcType)(unsafe.Pointer(V))
- if t.dotdotdot != v.dotdotdot || len(t.in) != len(v.in) || len(t.out) != len(v.out) {
- return false
- }
- for i, typ := range t.in {
- if typ != v.in[i] {
- return false
- }
- }
- for i, typ := range t.out {
- if typ != v.out[i] {
- return false
- }
- }
- return true
-
- case Interface:
- t := (*interfaceType)(unsafe.Pointer(T))
- v := (*interfaceType)(unsafe.Pointer(V))
- if len(t.methods) == 0 && len(v.methods) == 0 {
- return true
- }
- // Might have the same methods but still
- // need a run time conversion.
- return false
-
- case Map:
- return T.Key() == V.Key() && T.Elem() == V.Elem()
-
- case Ptr, Slice:
- return T.Elem() == V.Elem()
-
- case Struct:
- t := (*structType)(unsafe.Pointer(T))
- v := (*structType)(unsafe.Pointer(V))
- if len(t.fields) != len(v.fields) {
- return false
- }
- for i := range t.fields {
- tf := &t.fields[i]
- vf := &v.fields[i]
- if tf.name != vf.name && (tf.name == nil || vf.name == nil || *tf.name != *vf.name) {
- return false
- }
- if tf.pkgPath != vf.pkgPath && (tf.pkgPath == nil || vf.pkgPath == nil || *tf.pkgPath != *vf.pkgPath) {
- return false
- }
- if tf.typ != vf.typ {
- return false
- }
- if tf.tag != vf.tag && (tf.tag == nil || vf.tag == nil || *tf.tag != *vf.tag) {
- return false
- }
- if tf.offset != vf.offset {
- return false
- }
- }
- return true
- }
-
- return false
-}
-
-// typelinks is implemented in package runtime.
-// It returns a slice of all the 'typelink' information in the binary,
-// which is to say a slice of known types, sorted by string.
-// Note that strings are not unique identifiers for types:
-// there can be more than one with a given string.
-// Only types we might want to look up are included:
-// channels, maps, slices, and arrays.
-func typelinks() []*rtype
-
-// typesByString returns the subslice of typelinks() whose elements have
-// the given string representation.
-// It may be empty (no known types with that string) or may have
-// multiple elements (multiple types with that string).
-func typesByString(s string) []*rtype {
- typ := typelinks()
-
- // We are looking for the first index i where the string becomes >= s.
- // This is a copy of sort.Search, with f(h) replaced by (*typ[h].string >= s).
- i, j := 0, len(typ)
- for i < j {
- h := i + (j-i)/2 // avoid overflow when computing h
- // i ≤ h < j
- if !(*typ[h].string >= s) {
- i = h + 1 // preserves f(i-1) == false
- } else {
- j = h // preserves f(j) == true
- }
- }
- // i == j, f(i-1) == false, and f(j) (= f(i)) == true => answer is i.
-
- // Having found the first, linear scan forward to find the last.
- // We could do a second binary search, but the caller is going
- // to do a linear scan anyway.
- j = i
- for j < len(typ) && *typ[j].string == s {
- j++
- }
-
- // This slice will be empty if the string is not found.
- return typ[i:j]
-}
-
-// The lookupCache caches ChanOf, MapOf, and SliceOf lookups.
-var lookupCache struct {
- sync.RWMutex
- m map[cacheKey]*rtype
-}
-
-// A cacheKey is the key for use in the lookupCache.
-// Four values describe any of the types we are looking for:
-// type kind, one or two subtypes, and an extra integer.
-type cacheKey struct {
- kind Kind
- t1 *rtype
- t2 *rtype
- extra uintptr
-}
-
-// cacheGet looks for a type under the key k in the lookupCache.
-// If it finds one, it returns that type.
-// If not, it returns nil with the cache locked.
-// The caller is expected to use cachePut to unlock the cache.
-func cacheGet(k cacheKey) Type {
- lookupCache.RLock()
- t := lookupCache.m[k]
- lookupCache.RUnlock()
- if t != nil {
- return t
- }
-
- lookupCache.Lock()
- t = lookupCache.m[k]
- if t != nil {
- lookupCache.Unlock()
- return t
- }
-
- if lookupCache.m == nil {
- lookupCache.m = make(map[cacheKey]*rtype)
- }
-
- return nil
-}
-
-// cachePut stores the given type in the cache, unlocks the cache,
-// and returns the type. It is expected that the cache is locked
-// because cacheGet returned nil.
-func cachePut(k cacheKey, t *rtype) Type {
- lookupCache.m[k] = t
- lookupCache.Unlock()
- return t
-}
-
-// garbage collection bytecode program for chan.
-// See ../../cmd/gc/reflect.c:/^dgcsym1 and :/^dgcsym.
-type chanGC struct {
- width uintptr // sizeof(map)
- op uintptr // _GC_CHAN_PTR
- off uintptr // 0
- typ *rtype // map type
- end uintptr // _GC_END
-}
-
-type badGC struct {
- width uintptr
- end uintptr
-}
-
-// ChanOf returns the channel type with the given direction and element type.
-// For example, if t represents int, ChanOf(RecvDir, t) represents <-chan int.
-//
-// The gc runtime imposes a limit of 64 kB on channel element types.
-// If t's size is equal to or exceeds this limit, ChanOf panics.
-func ChanOf(dir ChanDir, t Type) Type {
- typ := t.(*rtype)
-
- // Look in cache.
- ckey := cacheKey{Chan, typ, nil, uintptr(dir)}
- if ch := cacheGet(ckey); ch != nil {
- return ch
- }
-
- // This restriction is imposed by the gc compiler and the runtime.
- if typ.size >= 1<<16 {
- lookupCache.Unlock()
- panic("reflect.ChanOf: element size too large")
- }
-
- // Look in known types.
- // TODO: Precedence when constructing string.
- var s string
- switch dir {
- default:
- lookupCache.Unlock()
- panic("reflect.ChanOf: invalid dir")
- case SendDir:
- s = "chan<- " + *typ.string
- case RecvDir:
- s = "<-chan " + *typ.string
- case BothDir:
- s = "chan " + *typ.string
- }
- for _, tt := range typesByString(s) {
- ch := (*chanType)(unsafe.Pointer(tt))
- if ch.elem == typ && ch.dir == uintptr(dir) {
- return cachePut(ckey, tt)
- }
- }
-
- // Make a channel type.
- var ichan interface{} = (chan unsafe.Pointer)(nil)
- prototype := *(**chanType)(unsafe.Pointer(&ichan))
- ch := new(chanType)
- *ch = *prototype
- ch.string = &s
- ch.hash = fnv1(typ.hash, 'c', byte(dir))
- ch.elem = typ
- ch.uncommonType = nil
- ch.ptrToThis = nil
- ch.zero = unsafe.Pointer(&make([]byte, ch.size)[0])
-
- ch.gc = unsafe.Pointer(&chanGC{
- width: ch.size,
- op: _GC_CHAN_PTR,
- off: 0,
- typ: &ch.rtype,
- end: _GC_END,
- })
-
- // INCORRECT. Uncomment to check that TestChanOfGC fails when ch.gc is wrong.
- //ch.gc = unsafe.Pointer(&badGC{width: ch.size, end: _GC_END})
-
- return cachePut(ckey, &ch.rtype)
-}
-
-func ismapkey(*rtype) bool // implemented in runtime
-
-// MapOf returns the map type with the given key and element types.
-// For example, if k represents int and e represents string,
-// MapOf(k, e) represents map[int]string.
-//
-// If the key type is not a valid map key type (that is, if it does
-// not implement Go's == operator), MapOf panics.
-func MapOf(key, elem Type) Type {
- ktyp := key.(*rtype)
- etyp := elem.(*rtype)
-
- if !ismapkey(ktyp) {
- panic("reflect.MapOf: invalid key type " + ktyp.String())
- }
-
- // Look in cache.
- ckey := cacheKey{Map, ktyp, etyp, 0}
- if mt := cacheGet(ckey); mt != nil {
- return mt
- }
-
- // Look in known types.
- s := "map[" + *ktyp.string + "]" + *etyp.string
- for _, tt := range typesByString(s) {
- mt := (*mapType)(unsafe.Pointer(tt))
- if mt.key == ktyp && mt.elem == etyp {
- return cachePut(ckey, tt)
- }
- }
-
- // Make a map type.
- var imap interface{} = (map[unsafe.Pointer]unsafe.Pointer)(nil)
- prototype := *(**mapType)(unsafe.Pointer(&imap))
- mt := new(mapType)
- *mt = *prototype
- mt.string = &s
- mt.hash = fnv1(etyp.hash, 'm', byte(ktyp.hash>>24), byte(ktyp.hash>>16), byte(ktyp.hash>>8), byte(ktyp.hash))
- mt.key = ktyp
- mt.elem = etyp
- mt.bucket = bucketOf(ktyp, etyp)
- mt.hmap = hMapOf(mt.bucket)
- mt.uncommonType = nil
- mt.ptrToThis = nil
- mt.zero = unsafe.Pointer(&make([]byte, mt.size)[0])
- mt.gc = unsafe.Pointer(&ptrGC{
- width: unsafe.Sizeof(uintptr(0)),
- op: _GC_PTR,
- off: 0,
- elemgc: mt.hmap.gc,
- end: _GC_END,
- })
-
- // INCORRECT. Uncomment to check that TestMapOfGC and TestMapOfGCValues
- // fail when mt.gc is wrong.
- //mt.gc = unsafe.Pointer(&badGC{width: mt.size, end: _GC_END})
-
- return cachePut(ckey, &mt.rtype)
-}
-
-// Make sure these routines stay in sync with ../../pkg/runtime/hashmap.c!
-// These types exist only for GC, so we only fill out GC relevant info.
-// Currently, that's just size and the GC program. We also fill in string
-// for possible debugging use.
-const (
- _BUCKETSIZE = 8
- _MAXKEYSIZE = 128
- _MAXVALSIZE = 128
-)
-
-func bucketOf(ktyp, etyp *rtype) *rtype {
- if ktyp.size > _MAXKEYSIZE {
- ktyp = PtrTo(ktyp).(*rtype)
- }
- if etyp.size > _MAXVALSIZE {
- etyp = PtrTo(etyp).(*rtype)
- }
- ptrsize := unsafe.Sizeof(uintptr(0))
-
- gc := make([]uintptr, 1) // first entry is size, filled in at the end
- offset := _BUCKETSIZE * unsafe.Sizeof(uint8(0)) // topbits
- gc = append(gc, _GC_PTR, offset, 0 /*self pointer set below*/) // overflow
- offset += ptrsize
-
- if runtime.GOARCH == "amd64p32" {
- offset += 4
- }
-
- // keys
- if ktyp.kind&kindNoPointers == 0 {
- gc = append(gc, _GC_ARRAY_START, offset, _BUCKETSIZE, ktyp.size)
- gc = appendGCProgram(gc, ktyp)
- gc = append(gc, _GC_ARRAY_NEXT)
- }
- offset += _BUCKETSIZE * ktyp.size
-
- // values
- if etyp.kind&kindNoPointers == 0 {
- gc = append(gc, _GC_ARRAY_START, offset, _BUCKETSIZE, etyp.size)
- gc = appendGCProgram(gc, etyp)
- gc = append(gc, _GC_ARRAY_NEXT)
- }
- offset += _BUCKETSIZE * etyp.size
-
- gc = append(gc, _GC_END)
- gc[0] = offset
- gc[3] = uintptr(unsafe.Pointer(&gc[0])) // set self pointer
-
- b := new(rtype)
- b.size = offset
- b.gc = unsafe.Pointer(&gc[0])
- s := "bucket(" + *ktyp.string + "," + *etyp.string + ")"
- b.string = &s
- return b
-}
-
-// Take the GC program for "t" and append it to the GC program "gc".
-func appendGCProgram(gc []uintptr, t *rtype) []uintptr {
- p := t.gc
- p = unsafe.Pointer(uintptr(p) + unsafe.Sizeof(uintptr(0))) // skip size
-loop:
- for {
- var argcnt int
- switch *(*uintptr)(p) {
- case _GC_END:
- // Note: _GC_END not included in append
- break loop
- case _GC_ARRAY_NEXT:
- argcnt = 0
- case _GC_APTR, _GC_STRING, _GC_EFACE, _GC_IFACE:
- argcnt = 1
- case _GC_PTR, _GC_CALL, _GC_CHAN_PTR, _GC_SLICE:
- argcnt = 2
- case _GC_ARRAY_START, _GC_REGION:
- argcnt = 3
- default:
- panic("unknown GC program op for " + *t.string + ": " + strconv.FormatUint(*(*uint64)(p), 10))
- }
- for i := 0; i < argcnt+1; i++ {
- gc = append(gc, *(*uintptr)(p))
- p = unsafe.Pointer(uintptr(p) + unsafe.Sizeof(uintptr(0)))
- }
- }
- return gc
-}
-func hMapOf(bucket *rtype) *rtype {
- ptrsize := unsafe.Sizeof(uintptr(0))
-
- // make gc program & compute hmap size
- gc := make([]uintptr, 1) // first entry is size, filled in at the end
- offset := unsafe.Sizeof(uint(0)) // count
- offset += unsafe.Sizeof(uint32(0)) // flags
- offset += unsafe.Sizeof(uint32(0)) // hash0
- offset += unsafe.Sizeof(uint8(0)) // B
- offset += unsafe.Sizeof(uint8(0)) // keysize
- offset += unsafe.Sizeof(uint8(0)) // valuesize
- offset = (offset + 1) / 2 * 2
- offset += unsafe.Sizeof(uint16(0)) // bucketsize
- offset = (offset + ptrsize - 1) / ptrsize * ptrsize
- gc = append(gc, _GC_PTR, offset, uintptr(bucket.gc)) // buckets
- offset += ptrsize
- gc = append(gc, _GC_PTR, offset, uintptr(bucket.gc)) // oldbuckets
- offset += ptrsize
- offset += ptrsize // nevacuate
- gc = append(gc, _GC_END)
- gc[0] = offset
-
- h := new(rtype)
- h.size = offset
- h.gc = unsafe.Pointer(&gc[0])
- s := "hmap(" + *bucket.string + ")"
- h.string = &s
- return h
-}
-
-// garbage collection bytecode program for slice of non-zero-length values.
-// See ../../cmd/gc/reflect.c:/^dgcsym1 and :/^dgcsym.
-type sliceGC struct {
- width uintptr // sizeof(slice)
- op uintptr // _GC_SLICE
- off uintptr // 0
- elemgc unsafe.Pointer // element gc program
- end uintptr // _GC_END
-}
-
-// garbage collection bytecode program for slice of zero-length values.
-// See ../../cmd/gc/reflect.c:/^dgcsym1 and :/^dgcsym.
-type sliceEmptyGC struct {
- width uintptr // sizeof(slice)
- op uintptr // _GC_APTR
- off uintptr // 0
- end uintptr // _GC_END
-}
-
-var sliceEmptyGCProg = sliceEmptyGC{
- width: unsafe.Sizeof([]byte(nil)),
- op: _GC_APTR,
- off: 0,
- end: _GC_END,
-}
-
-// SliceOf returns the slice type with element type t.
-// For example, if t represents int, SliceOf(t) represents []int.
-func SliceOf(t Type) Type {
- typ := t.(*rtype)
-
- // Look in cache.
- ckey := cacheKey{Slice, typ, nil, 0}
- if slice := cacheGet(ckey); slice != nil {
- return slice
- }
-
- // Look in known types.
- s := "[]" + *typ.string
- for _, tt := range typesByString(s) {
- slice := (*sliceType)(unsafe.Pointer(tt))
- if slice.elem == typ {
- return cachePut(ckey, tt)
- }
- }
-
- // Make a slice type.
- var islice interface{} = ([]unsafe.Pointer)(nil)
- prototype := *(**sliceType)(unsafe.Pointer(&islice))
- slice := new(sliceType)
- *slice = *prototype
- slice.string = &s
- slice.hash = fnv1(typ.hash, '[')
- slice.elem = typ
- slice.uncommonType = nil
- slice.ptrToThis = nil
- slice.zero = unsafe.Pointer(&make([]byte, slice.size)[0])
-
- if typ.size == 0 {
- slice.gc = unsafe.Pointer(&sliceEmptyGCProg)
- } else {
- slice.gc = unsafe.Pointer(&sliceGC{
- width: slice.size,
- op: _GC_SLICE,
- off: 0,
- elemgc: typ.gc,
- end: _GC_END,
- })
- }
-
- // INCORRECT. Uncomment to check that TestSliceOfOfGC fails when slice.gc is wrong.
- //slice.gc = unsafe.Pointer(&badGC{width: slice.size, end: _GC_END})
-
- return cachePut(ckey, &slice.rtype)
-}
-
-// ArrayOf returns the array type with the given count and element type.
-// For example, if t represents int, ArrayOf(5, t) represents [5]int.
-//
-// If the resulting type would be larger than the available address space,
-// ArrayOf panics.
-//
-// TODO(rsc): Unexported for now. Export once the alg field is set correctly
-// for the type. This may require significant work.
-func arrayOf(count int, elem Type) Type {
- typ := elem.(*rtype)
- slice := SliceOf(elem)
-
- // Look in cache.
- ckey := cacheKey{Array, typ, nil, uintptr(count)}
- if slice := cacheGet(ckey); slice != nil {
- return slice
- }
-
- // Look in known types.
- s := "[" + strconv.Itoa(count) + "]" + *typ.string
- for _, tt := range typesByString(s) {
- slice := (*sliceType)(unsafe.Pointer(tt))
- if slice.elem == typ {
- return cachePut(ckey, tt)
- }
- }
-
- // Make an array type.
- var iarray interface{} = [1]unsafe.Pointer{}
- prototype := *(**arrayType)(unsafe.Pointer(&iarray))
- array := new(arrayType)
- *array = *prototype
- array.string = &s
- array.hash = fnv1(typ.hash, '[')
- for n := uint32(count); n > 0; n >>= 8 {
- array.hash = fnv1(array.hash, byte(n))
- }
- array.hash = fnv1(array.hash, ']')
- array.elem = typ
- max := ^uintptr(0) / typ.size
- if uintptr(count) > max {
- panic("reflect.ArrayOf: array size would exceed virtual address space")
- }
- array.size = typ.size * uintptr(count)
- array.align = typ.align
- array.fieldAlign = typ.fieldAlign
- // TODO: array.alg
- // TODO: array.gc
- array.uncommonType = nil
- array.ptrToThis = nil
- array.zero = unsafe.Pointer(&make([]byte, array.size)[0])
- array.len = uintptr(count)
- array.slice = slice.(*rtype)
-
- return cachePut(ckey, &array.rtype)
-}
-
-// toType converts from a *rtype to a Type that can be returned
-// to the client of package reflect. In gc, the only concern is that
-// a nil *rtype must be replaced by a nil Type, but in gccgo this
-// function takes care of ensuring that multiple *rtype for the same
-// type are coalesced into a single Type.
-func toType(t *rtype) Type {
- if t == nil {
- return nil
- }
- return t
-}
-
-type layoutKey struct {
- t *rtype // function signature
- rcvr *rtype // receiver type, or nil if none
-}
-
-type layoutType struct {
- t *rtype
- argSize uintptr // size of arguments
- retOffset uintptr // offset of return values.
-}
-
-var layoutCache struct {
- sync.RWMutex
- m map[layoutKey]layoutType
-}
-
-// funcLayout computes a struct type representing the layout of the
-// function arguments and return values for the function type t.
-// If rcvr != nil, rcvr specifies the type of the receiver.
-// The returned type exists only for GC, so we only fill out GC relevant info.
-// Currently, that's just size and the GC program. We also fill in
-// the name for possible debugging use.
-func funcLayout(t *rtype, rcvr *rtype) (frametype *rtype, argSize, retOffset uintptr) {
- if t.Kind() != Func {
- panic("reflect: funcLayout of non-func type")
- }
- if rcvr != nil && rcvr.Kind() == Interface {
- panic("reflect: funcLayout with interface receiver " + rcvr.String())
- }
- k := layoutKey{t, rcvr}
- layoutCache.RLock()
- if x := layoutCache.m[k]; x.t != nil {
- layoutCache.RUnlock()
- return x.t, x.argSize, x.retOffset
- }
- layoutCache.RUnlock()
- layoutCache.Lock()
- if x := layoutCache.m[k]; x.t != nil {
- layoutCache.Unlock()
- return x.t, x.argSize, x.retOffset
- }
-
- tt := (*funcType)(unsafe.Pointer(t))
-
- // compute gc program for arguments
- gc := make([]uintptr, 1) // first entry is size, filled in at the end
- offset := uintptr(0)
- if rcvr != nil {
- // Reflect uses the "interface" calling convention for
- // methods, where receivers take one word of argument
- // space no matter how big they actually are.
- if rcvr.size > ptrSize {
- // we pass a pointer to the receiver.
- gc = append(gc, _GC_PTR, offset, uintptr(rcvr.gc))
- } else if rcvr.pointers() {
- // rcvr is a one-word pointer object. Its gc program
- // is just what we need here.
- gc = appendGCProgram(gc, rcvr)
- }
- offset += ptrSize
- }
- for _, arg := range tt.in {
- offset = align(offset, uintptr(arg.align))
- if arg.pointers() {
- gc = append(gc, _GC_REGION, offset, arg.size, uintptr(arg.gc))
- }
- offset += arg.size
- }
- argSize = offset
- if runtime.GOARCH == "amd64p32" {
- offset = align(offset, 8)
- }
- offset = align(offset, ptrSize)
- retOffset = offset
- for _, res := range tt.out {
- offset = align(offset, uintptr(res.align))
- if res.pointers() {
- gc = append(gc, _GC_REGION, offset, res.size, uintptr(res.gc))
- }
- offset += res.size
- }
- gc = append(gc, _GC_END)
- gc[0] = offset
-
- // build dummy rtype holding gc program
- x := new(rtype)
- x.size = offset
- x.gc = unsafe.Pointer(&gc[0])
- var s string
- if rcvr != nil {
- s = "methodargs(" + *rcvr.string + ")(" + *t.string + ")"
- } else {
- s = "funcargs(" + *t.string + ")"
- }
- x.string = &s
-
- // cache result for future callers
- if layoutCache.m == nil {
- layoutCache.m = make(map[layoutKey]layoutType)
- }
- layoutCache.m[k] = layoutType{
- t: x,
- argSize: argSize,
- retOffset: retOffset,
- }
- layoutCache.Unlock()
- return x, argSize, retOffset
-}
diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go
deleted file mode 100644
index 576cbc398..000000000
--- a/src/pkg/reflect/value.go
+++ /dev/null
@@ -1,2684 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package reflect
-
-import (
- "math"
- "runtime"
- "strconv"
- "unsafe"
-)
-
-const bigEndian = false // can be smarter if we find a big-endian machine
-const ptrSize = unsafe.Sizeof((*byte)(nil))
-const cannotSet = "cannot set value obtained from unexported struct field"
-
-// TODO: This will have to go away when
-// the new gc goes in.
-func memmove(adst, asrc unsafe.Pointer, n uintptr) {
- dst := uintptr(adst)
- src := uintptr(asrc)
- switch {
- case src < dst && src+n > dst:
- // byte copy backward
- // careful: i is unsigned
- for i := n; i > 0; {
- i--
- *(*byte)(unsafe.Pointer(dst + i)) = *(*byte)(unsafe.Pointer(src + i))
- }
- case (n|src|dst)&(ptrSize-1) != 0:
- // byte copy forward
- for i := uintptr(0); i < n; i++ {
- *(*byte)(unsafe.Pointer(dst + i)) = *(*byte)(unsafe.Pointer(src + i))
- }
- default:
- // word copy forward
- for i := uintptr(0); i < n; i += ptrSize {
- *(*uintptr)(unsafe.Pointer(dst + i)) = *(*uintptr)(unsafe.Pointer(src + i))
- }
- }
-}
-
-// Value is the reflection interface to a Go value.
-//
-// Not all methods apply to all kinds of values. Restrictions,
-// if any, are noted in the documentation for each method.
-// Use the Kind method to find out the kind of value before
-// calling kind-specific methods. Calling a method
-// inappropriate to the kind of type causes a run time panic.
-//
-// The zero Value represents no value.
-// Its IsValid method returns false, its Kind method returns Invalid,
-// its String method returns "<invalid Value>", and all other methods panic.
-// Most functions and methods never return an invalid value.
-// If one does, its documentation states the conditions explicitly.
-//
-// A Value can be used concurrently by multiple goroutines provided that
-// the underlying Go value can be used concurrently for the equivalent
-// direct operations.
-type Value struct {
- // typ holds the type of the value represented by a Value.
- typ *rtype
-
- // Pointer-valued data or, if flagIndir is set, pointer to data.
- // Valid when either flagIndir is set or typ.pointers() is true.
- ptr unsafe.Pointer
-
- // Non-pointer-valued data. When the data is smaller
- // than a word, it begins at the first byte (in the memory
- // address sense) of this field.
- // Valid when flagIndir is not set and typ.pointers() is false.
- scalar uintptr
-
- // flag holds metadata about the value.
- // The lowest bits are flag bits:
- // - flagRO: obtained via unexported field, so read-only
- // - flagIndir: val holds a pointer to the data
- // - flagAddr: v.CanAddr is true (implies flagIndir)
- // - flagMethod: v is a method value.
- // The next five bits give the Kind of the value.
- // This repeats typ.Kind() except for method values.
- // The remaining 23+ bits give a method number for method values.
- // If flag.kind() != Func, code can assume that flagMethod is unset.
- // If typ.size > ptrSize, code can assume that flagIndir is set.
- flag
-
- // A method value represents a curried method invocation
- // like r.Read for some receiver r. The typ+val+flag bits describe
- // the receiver r, but the flag's Kind bits say Func (methods are
- // functions), and the top bits of the flag give the method number
- // in r's type's method table.
-}
-
-type flag uintptr
-
-const (
- flagRO flag = 1 << iota
- flagIndir
- flagAddr
- flagMethod
- flagKindShift = iota
- flagKindWidth = 5 // there are 27 kinds
- flagKindMask flag = 1<<flagKindWidth - 1
- flagMethodShift = flagKindShift + flagKindWidth
-)
-
-func (f flag) kind() Kind {
- return Kind((f >> flagKindShift) & flagKindMask)
-}
-
-// pointer returns the underlying pointer represented by v.
-// v.Kind() must be Ptr, Map, Chan, Func, or UnsafePointer
-func (v Value) pointer() unsafe.Pointer {
- if v.typ.size != ptrSize || !v.typ.pointers() {
- panic("can't call pointer on a non-pointer Value")
- }
- if v.flag&flagIndir != 0 {
- return *(*unsafe.Pointer)(v.ptr)
- }
- return v.ptr
-}
-
-// packEface converts v to the empty interface.
-func packEface(v Value) interface{} {
- t := v.typ
- var i interface{}
- e := (*emptyInterface)(unsafe.Pointer(&i))
- // First, fill in the data portion of the interface.
- switch {
- case t.size > ptrSize:
- // Value is indirect, and so is the interface we're making.
- ptr := v.ptr
- if v.flag&flagAddr != 0 {
- // TODO: pass safe boolean from valueInterface so
- // we don't need to copy if safe==true?
- c := unsafe_New(t)
- memmove(c, ptr, t.size)
- ptr = c
- }
- e.word = iword(ptr)
- case v.flag&flagIndir != 0:
- // Value is indirect, but interface is direct. We need
- // to load the data at v.ptr into the interface data word.
- if t.pointers() {
- e.word = iword(*(*unsafe.Pointer)(v.ptr))
- } else {
- e.word = iword(loadScalar(v.ptr, t.size))
- }
- default:
- // Value is direct, and so is the interface.
- if t.pointers() {
- e.word = iword(v.ptr)
- } else {
- e.word = iword(v.scalar)
- }
- }
- // Now, fill in the type portion. We're very careful here not
- // to have any operation between the e.word and e.typ assignments
- // that would let the garbage collector observe the partially-built
- // interface value.
- e.typ = t
- return i
-}
-
-// unpackEface converts the empty interface i to a Value.
-func unpackEface(i interface{}) Value {
- e := (*emptyInterface)(unsafe.Pointer(&i))
- // NOTE: don't read e.word until we know whether it is really a pointer or not.
- t := e.typ
- if t == nil {
- return Value{}
- }
- f := flag(t.Kind()) << flagKindShift
- if t.size > ptrSize {
- return Value{t, unsafe.Pointer(e.word), 0, f | flagIndir}
- }
- if t.pointers() {
- return Value{t, unsafe.Pointer(e.word), 0, f}
- }
- return Value{t, nil, uintptr(e.word), f}
-}
-
-// A ValueError occurs when a Value method is invoked on
-// a Value that does not support it. Such cases are documented
-// in the description of each method.
-type ValueError struct {
- Method string
- Kind Kind
-}
-
-func (e *ValueError) Error() string {
- if e.Kind == 0 {
- return "reflect: call of " + e.Method + " on zero Value"
- }
- return "reflect: call of " + e.Method + " on " + e.Kind.String() + " Value"
-}
-
-// methodName returns the name of the calling method,
-// assumed to be two stack frames above.
-func methodName() string {
- pc, _, _, _ := runtime.Caller(2)
- f := runtime.FuncForPC(pc)
- if f == nil {
- return "unknown method"
- }
- return f.Name()
-}
-
-// An iword is the word that would be stored in an
-// interface to represent a given value v. Specifically, if v is
-// bigger than a pointer, its word is a pointer to v's data.
-// Otherwise, its word holds the data stored
-// in its leading bytes (so is not a pointer).
-// This type is very dangerous for the garbage collector because
-// it must be treated conservatively. We try to never expose it
-// to the GC here so that GC remains precise.
-type iword unsafe.Pointer
-
-// loadScalar loads n bytes at p from memory into a uintptr
-// that forms the second word of an interface. The data
-// must be non-pointer in nature.
-func loadScalar(p unsafe.Pointer, n uintptr) uintptr {
- // Run the copy ourselves instead of calling memmove
- // to avoid moving w to the heap.
- var w uintptr
- switch n {
- default:
- panic("reflect: internal error: loadScalar of " + strconv.Itoa(int(n)) + "-byte value")
- case 0:
- case 1:
- *(*uint8)(unsafe.Pointer(&w)) = *(*uint8)(p)
- case 2:
- *(*uint16)(unsafe.Pointer(&w)) = *(*uint16)(p)
- case 3:
- *(*[3]byte)(unsafe.Pointer(&w)) = *(*[3]byte)(p)
- case 4:
- *(*uint32)(unsafe.Pointer(&w)) = *(*uint32)(p)
- case 5:
- *(*[5]byte)(unsafe.Pointer(&w)) = *(*[5]byte)(p)
- case 6:
- *(*[6]byte)(unsafe.Pointer(&w)) = *(*[6]byte)(p)
- case 7:
- *(*[7]byte)(unsafe.Pointer(&w)) = *(*[7]byte)(p)
- case 8:
- *(*uint64)(unsafe.Pointer(&w)) = *(*uint64)(p)
- }
- return w
-}
-
-// storeScalar stores n bytes from w into p.
-func storeScalar(p unsafe.Pointer, w uintptr, n uintptr) {
- // Run the copy ourselves instead of calling memmove
- // to avoid moving w to the heap.
- switch n {
- default:
- panic("reflect: internal error: storeScalar of " + strconv.Itoa(int(n)) + "-byte value")
- case 0:
- case 1:
- *(*uint8)(p) = *(*uint8)(unsafe.Pointer(&w))
- case 2:
- *(*uint16)(p) = *(*uint16)(unsafe.Pointer(&w))
- case 3:
- *(*[3]byte)(p) = *(*[3]byte)(unsafe.Pointer(&w))
- case 4:
- *(*uint32)(p) = *(*uint32)(unsafe.Pointer(&w))
- case 5:
- *(*[5]byte)(p) = *(*[5]byte)(unsafe.Pointer(&w))
- case 6:
- *(*[6]byte)(p) = *(*[6]byte)(unsafe.Pointer(&w))
- case 7:
- *(*[7]byte)(p) = *(*[7]byte)(unsafe.Pointer(&w))
- case 8:
- *(*uint64)(p) = *(*uint64)(unsafe.Pointer(&w))
- }
-}
-
-// emptyInterface is the header for an interface{} value.
-type emptyInterface struct {
- typ *rtype
- word iword
-}
-
-// nonEmptyInterface is the header for a interface value with methods.
-type nonEmptyInterface struct {
- // see ../runtime/iface.c:/Itab
- itab *struct {
- ityp *rtype // static interface type
- typ *rtype // dynamic concrete type
- link unsafe.Pointer
- bad int32
- unused int32
- fun [100000]unsafe.Pointer // method table
- }
- word iword
-}
-
-// mustBe panics if f's kind is not expected.
-// Making this a method on flag instead of on Value
-// (and embedding flag in Value) means that we can write
-// the very clear v.mustBe(Bool) and have it compile into
-// v.flag.mustBe(Bool), which will only bother to copy the
-// single important word for the receiver.
-func (f flag) mustBe(expected Kind) {
- k := f.kind()
- if k != expected {
- panic(&ValueError{methodName(), k})
- }
-}
-
-// mustBeExported panics if f records that the value was obtained using
-// an unexported field.
-func (f flag) mustBeExported() {
- if f == 0 {
- panic(&ValueError{methodName(), 0})
- }
- if f&flagRO != 0 {
- panic("reflect: " + methodName() + " using value obtained using unexported field")
- }
-}
-
-// mustBeAssignable panics if f records that the value is not assignable,
-// which is to say that either it was obtained using an unexported field
-// or it is not addressable.
-func (f flag) mustBeAssignable() {
- if f == 0 {
- panic(&ValueError{methodName(), Invalid})
- }
- // Assignable if addressable and not read-only.
- if f&flagRO != 0 {
- panic("reflect: " + methodName() + " using value obtained using unexported field")
- }
- if f&flagAddr == 0 {
- panic("reflect: " + methodName() + " using unaddressable value")
- }
-}
-
-// Addr returns a pointer value representing the address of v.
-// It panics if CanAddr() returns false.
-// Addr is typically used to obtain a pointer to a struct field
-// or slice element in order to call a method that requires a
-// pointer receiver.
-func (v Value) Addr() Value {
- if v.flag&flagAddr == 0 {
- panic("reflect.Value.Addr of unaddressable value")
- }
- return Value{v.typ.ptrTo(), v.ptr, 0, (v.flag & flagRO) | flag(Ptr)<<flagKindShift}
-}
-
-// Bool returns v's underlying value.
-// It panics if v's kind is not Bool.
-func (v Value) Bool() bool {
- v.mustBe(Bool)
- if v.flag&flagIndir != 0 {
- return *(*bool)(v.ptr)
- }
- return *(*bool)(unsafe.Pointer(&v.scalar))
-}
-
-// Bytes returns v's underlying value.
-// It panics if v's underlying value is not a slice of bytes.
-func (v Value) Bytes() []byte {
- v.mustBe(Slice)
- if v.typ.Elem().Kind() != Uint8 {
- panic("reflect.Value.Bytes of non-byte slice")
- }
- // Slice is always bigger than a word; assume flagIndir.
- return *(*[]byte)(v.ptr)
-}
-
-// runes returns v's underlying value.
-// It panics if v's underlying value is not a slice of runes (int32s).
-func (v Value) runes() []rune {
- v.mustBe(Slice)
- if v.typ.Elem().Kind() != Int32 {
- panic("reflect.Value.Bytes of non-rune slice")
- }
- // Slice is always bigger than a word; assume flagIndir.
- return *(*[]rune)(v.ptr)
-}
-
-// CanAddr returns true if the value's address can be obtained with Addr.
-// Such values are called addressable. A value is addressable if it is
-// an element of a slice, an element of an addressable array,
-// a field of an addressable struct, or the result of dereferencing a pointer.
-// If CanAddr returns false, calling Addr will panic.
-func (v Value) CanAddr() bool {
- return v.flag&flagAddr != 0
-}
-
-// CanSet returns true if the value of v can be changed.
-// A Value can be changed only if it is addressable and was not
-// obtained by the use of unexported struct fields.
-// If CanSet returns false, calling Set or any type-specific
-// setter (e.g., SetBool, SetInt64) will panic.
-func (v Value) CanSet() bool {
- return v.flag&(flagAddr|flagRO) == flagAddr
-}
-
-// Call calls the function v with the input arguments in.
-// For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]).
-// Call panics if v's Kind is not Func.
-// It returns the output results as Values.
-// As in Go, each input argument must be assignable to the
-// type of the function's corresponding input parameter.
-// If v is a variadic function, Call creates the variadic slice parameter
-// itself, copying in the corresponding values.
-func (v Value) Call(in []Value) []Value {
- v.mustBe(Func)
- v.mustBeExported()
- return v.call("Call", in)
-}
-
-// CallSlice calls the variadic function v with the input arguments in,
-// assigning the slice in[len(in)-1] to v's final variadic argument.
-// For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]...).
-// Call panics if v's Kind is not Func or if v is not variadic.
-// It returns the output results as Values.
-// As in Go, each input argument must be assignable to the
-// type of the function's corresponding input parameter.
-func (v Value) CallSlice(in []Value) []Value {
- v.mustBe(Func)
- v.mustBeExported()
- return v.call("CallSlice", in)
-}
-
-var callGC bool // for testing; see TestCallMethodJump
-
-var makeFuncStubFn = makeFuncStub
-var makeFuncStubCode = **(**uintptr)(unsafe.Pointer(&makeFuncStubFn))
-var methodValueCallFn = methodValueCall
-var methodValueCallCode = **(**uintptr)(unsafe.Pointer(&methodValueCallFn))
-
-func (v Value) call(op string, in []Value) []Value {
- // Get function pointer, type.
- t := v.typ
- var (
- fn unsafe.Pointer
- rcvr Value
- rcvrtype *rtype
- )
- if v.flag&flagMethod != 0 {
- rcvr = v
- rcvrtype, t, fn = methodReceiver(op, v, int(v.flag)>>flagMethodShift)
- } else if v.flag&flagIndir != 0 {
- fn = *(*unsafe.Pointer)(v.ptr)
- } else {
- fn = v.ptr
- }
-
- if fn == nil {
- panic("reflect.Value.Call: call of nil function")
- }
-
- isSlice := op == "CallSlice"
- n := t.NumIn()
- if isSlice {
- if !t.IsVariadic() {
- panic("reflect: CallSlice of non-variadic function")
- }
- if len(in) < n {
- panic("reflect: CallSlice with too few input arguments")
- }
- if len(in) > n {
- panic("reflect: CallSlice with too many input arguments")
- }
- } else {
- if t.IsVariadic() {
- n--
- }
- if len(in) < n {
- panic("reflect: Call with too few input arguments")
- }
- if !t.IsVariadic() && len(in) > n {
- panic("reflect: Call with too many input arguments")
- }
- }
- for _, x := range in {
- if x.Kind() == Invalid {
- panic("reflect: " + op + " using zero Value argument")
- }
- }
- for i := 0; i < n; i++ {
- if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(targ) {
- panic("reflect: " + op + " using " + xt.String() + " as type " + targ.String())
- }
- }
- if !isSlice && t.IsVariadic() {
- // prepare slice for remaining values
- m := len(in) - n
- slice := MakeSlice(t.In(n), m, m)
- elem := t.In(n).Elem()
- for i := 0; i < m; i++ {
- x := in[n+i]
- if xt := x.Type(); !xt.AssignableTo(elem) {
- panic("reflect: cannot use " + xt.String() + " as type " + elem.String() + " in " + op)
- }
- slice.Index(i).Set(x)
- }
- origIn := in
- in = make([]Value, n+1)
- copy(in[:n], origIn)
- in[n] = slice
- }
-
- nin := len(in)
- if nin != t.NumIn() {
- panic("reflect.Value.Call: wrong argument count")
- }
- nout := t.NumOut()
-
- // If target is makeFuncStub, short circuit the unpack onto stack /
- // pack back into []Value for the args and return values. Just do the
- // call directly.
- // We need to do this here because otherwise we have a situation where
- // reflect.callXX calls makeFuncStub, neither of which knows the
- // layout of the args. That's bad for precise gc & stack copying.
- x := (*makeFuncImpl)(fn)
- if x.code == makeFuncStubCode {
- return x.fn(in)
- }
-
- // If the target is methodValueCall, do its work here: add the receiver
- // argument and call the real target directly.
- // We need to do this here because otherwise we have a situation where
- // reflect.callXX calls methodValueCall, neither of which knows the
- // layout of the args. That's bad for precise gc & stack copying.
- y := (*methodValue)(fn)
- if y.fn == methodValueCallCode {
- rcvr = y.rcvr
- rcvrtype, t, fn = methodReceiver("call", rcvr, y.method)
- }
-
- // Compute frame type, allocate a chunk of memory for frame
- frametype, _, retOffset := funcLayout(t, rcvrtype)
- args := unsafe_New(frametype)
- off := uintptr(0)
-
- // Copy inputs into args.
- if rcvrtype != nil {
- storeRcvr(rcvr, args)
- off = ptrSize
- }
- for i, v := range in {
- v.mustBeExported()
- targ := t.In(i).(*rtype)
- a := uintptr(targ.align)
- off = (off + a - 1) &^ (a - 1)
- n := targ.size
- addr := unsafe.Pointer(uintptr(args) + off)
- v = v.assignTo("reflect.Value.Call", targ, (*interface{})(addr))
- if v.flag&flagIndir != 0 {
- memmove(addr, v.ptr, n)
- } else if targ.pointers() {
- *(*unsafe.Pointer)(addr) = v.ptr
- } else {
- storeScalar(addr, v.scalar, n)
- }
- off += n
- }
-
- // Call.
- call(fn, args, uint32(frametype.size), uint32(retOffset))
-
- // For testing; see TestCallMethodJump.
- if callGC {
- runtime.GC()
- }
-
- // Copy return values out of args.
- ret := make([]Value, nout)
- off = retOffset
- for i := 0; i < nout; i++ {
- tv := t.Out(i)
- a := uintptr(tv.Align())
- off = (off + a - 1) &^ (a - 1)
- fl := flagIndir | flag(tv.Kind())<<flagKindShift
- ret[i] = Value{tv.common(), unsafe.Pointer(uintptr(args) + off), 0, fl}
- off += tv.Size()
- }
-
- return ret
-}
-
-// callReflect is the call implementation used by a function
-// returned by MakeFunc. In many ways it is the opposite of the
-// method Value.call above. The method above converts a call using Values
-// into a call of a function with a concrete argument frame, while
-// callReflect converts a call of a function with a concrete argument
-// frame into a call using Values.
-// It is in this file so that it can be next to the call method above.
-// The remainder of the MakeFunc implementation is in makefunc.go.
-//
-// NOTE: This function must be marked as a "wrapper" in the generated code,
-// so that the linker can make it work correctly for panic and recover.
-// The gc compilers know to do that for the name "reflect.callReflect".
-func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer) {
- ftyp := ctxt.typ
- f := ctxt.fn
-
- // Copy argument frame into Values.
- ptr := frame
- off := uintptr(0)
- in := make([]Value, 0, len(ftyp.in))
- for _, arg := range ftyp.in {
- typ := arg
- off += -off & uintptr(typ.align-1)
- addr := unsafe.Pointer(uintptr(ptr) + off)
- v := Value{typ, nil, 0, flag(typ.Kind()) << flagKindShift}
- if typ.size > ptrSize {
- // value does not fit in word.
- // Must make a copy, because f might keep a reference to it,
- // and we cannot let f keep a reference to the stack frame
- // after this function returns, not even a read-only reference.
- v.ptr = unsafe_New(typ)
- memmove(v.ptr, addr, typ.size)
- v.flag |= flagIndir
- } else if typ.pointers() {
- v.ptr = *(*unsafe.Pointer)(addr)
- } else {
- v.scalar = loadScalar(addr, typ.size)
- }
- in = append(in, v)
- off += typ.size
- }
-
- // Call underlying function.
- out := f(in)
- if len(out) != len(ftyp.out) {
- panic("reflect: wrong return count from function created by MakeFunc")
- }
-
- // Copy results back into argument frame.
- if len(ftyp.out) > 0 {
- off += -off & (ptrSize - 1)
- if runtime.GOARCH == "amd64p32" {
- off = align(off, 8)
- }
- for i, arg := range ftyp.out {
- typ := arg
- v := out[i]
- if v.typ != typ {
- panic("reflect: function created by MakeFunc using " + funcName(f) +
- " returned wrong type: have " +
- out[i].typ.String() + " for " + typ.String())
- }
- if v.flag&flagRO != 0 {
- panic("reflect: function created by MakeFunc using " + funcName(f) +
- " returned value obtained from unexported field")
- }
- off += -off & uintptr(typ.align-1)
- addr := unsafe.Pointer(uintptr(ptr) + off)
- if v.flag&flagIndir != 0 {
- memmove(addr, v.ptr, typ.size)
- } else if typ.pointers() {
- *(*unsafe.Pointer)(addr) = v.ptr
- } else {
- storeScalar(addr, v.scalar, typ.size)
- }
- off += typ.size
- }
- }
-}
-
-// methodReceiver returns information about the receiver
-// described by v. The Value v may or may not have the
-// flagMethod bit set, so the kind cached in v.flag should
-// not be used.
-// The return value rcvrtype gives the method's actual receiver type.
-// The return value t gives the method type signature (without the receiver).
-// The return value fn is a pointer to the method code.
-func methodReceiver(op string, v Value, methodIndex int) (rcvrtype, t *rtype, fn unsafe.Pointer) {
- i := methodIndex
- if v.typ.Kind() == Interface {
- tt := (*interfaceType)(unsafe.Pointer(v.typ))
- if i < 0 || i >= len(tt.methods) {
- panic("reflect: internal error: invalid method index")
- }
- m := &tt.methods[i]
- if m.pkgPath != nil {
- panic("reflect: " + op + " of unexported method")
- }
- iface := (*nonEmptyInterface)(v.ptr)
- if iface.itab == nil {
- panic("reflect: " + op + " of method on nil interface value")
- }
- rcvrtype = iface.itab.typ
- fn = unsafe.Pointer(&iface.itab.fun[i])
- t = m.typ
- } else {
- rcvrtype = v.typ
- ut := v.typ.uncommon()
- if ut == nil || i < 0 || i >= len(ut.methods) {
- panic("reflect: internal error: invalid method index")
- }
- m := &ut.methods[i]
- if m.pkgPath != nil {
- panic("reflect: " + op + " of unexported method")
- }
- fn = unsafe.Pointer(&m.ifn)
- t = m.mtyp
- }
- return
-}
-
-// v is a method receiver. Store at p the word which is used to
-// encode that receiver at the start of the argument list.
-// Reflect uses the "interface" calling convention for
-// methods, which always uses one word to record the receiver.
-func storeRcvr(v Value, p unsafe.Pointer) {
- t := v.typ
- if t.Kind() == Interface {
- // the interface data word becomes the receiver word
- iface := (*nonEmptyInterface)(v.ptr)
- *(*unsafe.Pointer)(p) = unsafe.Pointer(iface.word)
- } else if v.flag&flagIndir != 0 {
- if t.size > ptrSize {
- *(*unsafe.Pointer)(p) = v.ptr
- } else if t.pointers() {
- *(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(v.ptr)
- } else {
- *(*uintptr)(p) = loadScalar(v.ptr, t.size)
- }
- } else if t.pointers() {
- *(*unsafe.Pointer)(p) = v.ptr
- } else {
- *(*uintptr)(p) = v.scalar
- }
-}
-
-// align returns the result of rounding x up to a multiple of n.
-// n must be a power of two.
-func align(x, n uintptr) uintptr {
- return (x + n - 1) &^ (n - 1)
-}
-
-// callMethod is the call implementation used by a function returned
-// by makeMethodValue (used by v.Method(i).Interface()).
-// It is a streamlined version of the usual reflect call: the caller has
-// already laid out the argument frame for us, so we don't have
-// to deal with individual Values for each argument.
-// It is in this file so that it can be next to the two similar functions above.
-// The remainder of the makeMethodValue implementation is in makefunc.go.
-//
-// NOTE: This function must be marked as a "wrapper" in the generated code,
-// so that the linker can make it work correctly for panic and recover.
-// The gc compilers know to do that for the name "reflect.callMethod".
-func callMethod(ctxt *methodValue, frame unsafe.Pointer) {
- rcvr := ctxt.rcvr
- rcvrtype, t, fn := methodReceiver("call", rcvr, ctxt.method)
- frametype, argSize, retOffset := funcLayout(t, rcvrtype)
-
- // Make a new frame that is one word bigger so we can store the receiver.
- args := unsafe_New(frametype)
-
- // Copy in receiver and rest of args.
- storeRcvr(rcvr, args)
- memmove(unsafe.Pointer(uintptr(args)+ptrSize), frame, argSize-ptrSize)
-
- // Call.
- call(fn, args, uint32(frametype.size), uint32(retOffset))
-
- // Copy return values. On amd64p32, the beginning of return values
- // is 64-bit aligned, so the caller's frame layout (which doesn't have
- // a receiver) is different from the layout of the fn call, which has
- // a receiver.
- // Ignore any changes to args and just copy return values.
- callerRetOffset := retOffset - ptrSize
- if runtime.GOARCH == "amd64p32" {
- callerRetOffset = align(argSize-ptrSize, 8)
- }
- memmove(unsafe.Pointer(uintptr(frame)+callerRetOffset),
- unsafe.Pointer(uintptr(args)+retOffset), frametype.size-retOffset)
-}
-
-// funcName returns the name of f, for use in error messages.
-func funcName(f func([]Value) []Value) string {
- pc := *(*uintptr)(unsafe.Pointer(&f))
- rf := runtime.FuncForPC(pc)
- if rf != nil {
- return rf.Name()
- }
- return "closure"
-}
-
-// Cap returns v's capacity.
-// It panics if v's Kind is not Array, Chan, or Slice.
-func (v Value) Cap() int {
- k := v.kind()
- switch k {
- case Array:
- return v.typ.Len()
- case Chan:
- return int(chancap(v.pointer()))
- case Slice:
- // Slice is always bigger than a word; assume flagIndir.
- return (*sliceHeader)(v.ptr).Cap
- }
- panic(&ValueError{"reflect.Value.Cap", k})
-}
-
-// Close closes the channel v.
-// It panics if v's Kind is not Chan.
-func (v Value) Close() {
- v.mustBe(Chan)
- v.mustBeExported()
- chanclose(v.pointer())
-}
-
-// Complex returns v's underlying value, as a complex128.
-// It panics if v's Kind is not Complex64 or Complex128
-func (v Value) Complex() complex128 {
- k := v.kind()
- switch k {
- case Complex64:
- if v.flag&flagIndir != 0 {
- return complex128(*(*complex64)(v.ptr))
- }
- return complex128(*(*complex64)(unsafe.Pointer(&v.scalar)))
- case Complex128:
- // complex128 is always bigger than a word; assume flagIndir.
- return *(*complex128)(v.ptr)
- }
- panic(&ValueError{"reflect.Value.Complex", k})
-}
-
-// Elem returns the value that the interface v contains
-// or that the pointer v points to.
-// It panics if v's Kind is not Interface or Ptr.
-// It returns the zero Value if v is nil.
-func (v Value) Elem() Value {
- k := v.kind()
- switch k {
- case Interface:
- var eface interface{}
- if v.typ.NumMethod() == 0 {
- eface = *(*interface{})(v.ptr)
- } else {
- eface = (interface{})(*(*interface {
- M()
- })(v.ptr))
- }
- x := unpackEface(eface)
- x.flag |= v.flag & flagRO
- return x
- case Ptr:
- ptr := v.ptr
- if v.flag&flagIndir != 0 {
- ptr = *(*unsafe.Pointer)(ptr)
- }
- // The returned value's address is v's value.
- if ptr == nil {
- return Value{}
- }
- tt := (*ptrType)(unsafe.Pointer(v.typ))
- typ := tt.elem
- fl := v.flag&flagRO | flagIndir | flagAddr
- fl |= flag(typ.Kind() << flagKindShift)
- return Value{typ, ptr, 0, fl}
- }
- panic(&ValueError{"reflect.Value.Elem", k})
-}
-
-// Field returns the i'th field of the struct v.
-// It panics if v's Kind is not Struct or i is out of range.
-func (v Value) Field(i int) Value {
- v.mustBe(Struct)
- tt := (*structType)(unsafe.Pointer(v.typ))
- if i < 0 || i >= len(tt.fields) {
- panic("reflect: Field index out of range")
- }
- field := &tt.fields[i]
- typ := field.typ
-
- // Inherit permission bits from v.
- fl := v.flag & (flagRO | flagIndir | flagAddr)
- // Using an unexported field forces flagRO.
- if field.pkgPath != nil {
- fl |= flagRO
- }
- fl |= flag(typ.Kind()) << flagKindShift
-
- var ptr unsafe.Pointer
- var scalar uintptr
- switch {
- case fl&flagIndir != 0:
- // Indirect. Just bump pointer.
- ptr = unsafe.Pointer(uintptr(v.ptr) + field.offset)
- case typ.pointers():
- if field.offset != 0 {
- panic("field access of ptr value isn't at offset 0")
- }
- ptr = v.ptr
- case bigEndian:
- // Must be scalar. Discard leading bytes.
- scalar = v.scalar << (field.offset * 8)
- default:
- // Must be scalar. Discard leading bytes.
- scalar = v.scalar >> (field.offset * 8)
- }
-
- return Value{typ, ptr, scalar, fl}
-}
-
-// FieldByIndex returns the nested field corresponding to index.
-// It panics if v's Kind is not struct.
-func (v Value) FieldByIndex(index []int) Value {
- v.mustBe(Struct)
- for i, x := range index {
- if i > 0 {
- if v.Kind() == Ptr && v.typ.Elem().Kind() == Struct {
- if v.IsNil() {
- panic("reflect: indirection through nil pointer to embedded struct")
- }
- v = v.Elem()
- }
- }
- v = v.Field(x)
- }
- return v
-}
-
-// FieldByName returns the struct field with the given name.
-// It returns the zero Value if no field was found.
-// It panics if v's Kind is not struct.
-func (v Value) FieldByName(name string) Value {
- v.mustBe(Struct)
- if f, ok := v.typ.FieldByName(name); ok {
- return v.FieldByIndex(f.Index)
- }
- return Value{}
-}
-
-// FieldByNameFunc returns the struct field with a name
-// that satisfies the match function.
-// It panics if v's Kind is not struct.
-// It returns the zero Value if no field was found.
-func (v Value) FieldByNameFunc(match func(string) bool) Value {
- v.mustBe(Struct)
- if f, ok := v.typ.FieldByNameFunc(match); ok {
- return v.FieldByIndex(f.Index)
- }
- return Value{}
-}
-
-// Float returns v's underlying value, as a float64.
-// It panics if v's Kind is not Float32 or Float64
-func (v Value) Float() float64 {
- k := v.kind()
- switch k {
- case Float32:
- if v.flag&flagIndir != 0 {
- return float64(*(*float32)(v.ptr))
- }
- return float64(*(*float32)(unsafe.Pointer(&v.scalar)))
- case Float64:
- if v.flag&flagIndir != 0 {
- return *(*float64)(v.ptr)
- }
- return *(*float64)(unsafe.Pointer(&v.scalar))
- }
- panic(&ValueError{"reflect.Value.Float", k})
-}
-
-var uint8Type = TypeOf(uint8(0)).(*rtype)
-
-// Index returns v's i'th element.
-// It panics if v's Kind is not Array, Slice, or String or i is out of range.
-func (v Value) Index(i int) Value {
- k := v.kind()
- switch k {
- case Array:
- tt := (*arrayType)(unsafe.Pointer(v.typ))
- if i < 0 || i > int(tt.len) {
- panic("reflect: array index out of range")
- }
- typ := tt.elem
- fl := v.flag & (flagRO | flagIndir | flagAddr) // bits same as overall array
- fl |= flag(typ.Kind()) << flagKindShift
- offset := uintptr(i) * typ.size
-
- var val unsafe.Pointer
- var scalar uintptr
- switch {
- case fl&flagIndir != 0:
- // Indirect. Just bump pointer.
- val = unsafe.Pointer(uintptr(v.ptr) + offset)
- case typ.pointers():
- if offset != 0 {
- panic("can't Index(i) with i!=0 on ptrLike value")
- }
- val = v.ptr
- case bigEndian:
- // Direct. Discard leading bytes.
- scalar = v.scalar << (offset * 8)
- default:
- // Direct. Discard leading bytes.
- scalar = v.scalar >> (offset * 8)
- }
- return Value{typ, val, scalar, fl}
-
- case Slice:
- // Element flag same as Elem of Ptr.
- // Addressable, indirect, possibly read-only.
- fl := flagAddr | flagIndir | v.flag&flagRO
- s := (*sliceHeader)(v.ptr)
- if i < 0 || i >= s.Len {
- panic("reflect: slice index out of range")
- }
- tt := (*sliceType)(unsafe.Pointer(v.typ))
- typ := tt.elem
- fl |= flag(typ.Kind()) << flagKindShift
- val := unsafe.Pointer(uintptr(s.Data) + uintptr(i)*typ.size)
- return Value{typ, val, 0, fl}
-
- case String:
- fl := v.flag&flagRO | flag(Uint8<<flagKindShift)
- s := (*stringHeader)(v.ptr)
- if i < 0 || i >= s.Len {
- panic("reflect: string index out of range")
- }
- b := uintptr(0)
- *(*byte)(unsafe.Pointer(&b)) = *(*byte)(unsafe.Pointer(uintptr(s.Data) + uintptr(i)))
- return Value{uint8Type, nil, b, fl}
- }
- panic(&ValueError{"reflect.Value.Index", k})
-}
-
-// Int returns v's underlying value, as an int64.
-// It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64.
-func (v Value) Int() int64 {
- k := v.kind()
- var p unsafe.Pointer
- if v.flag&flagIndir != 0 {
- p = v.ptr
- } else {
- // The escape analysis is good enough that &v.scalar
- // does not trigger a heap allocation.
- p = unsafe.Pointer(&v.scalar)
- }
- switch k {
- case Int:
- return int64(*(*int)(p))
- case Int8:
- return int64(*(*int8)(p))
- case Int16:
- return int64(*(*int16)(p))
- case Int32:
- return int64(*(*int32)(p))
- case Int64:
- return int64(*(*int64)(p))
- }
- panic(&ValueError{"reflect.Value.Int", k})
-}
-
-// CanInterface returns true if Interface can be used without panicking.
-func (v Value) CanInterface() bool {
- if v.flag == 0 {
- panic(&ValueError{"reflect.Value.CanInterface", Invalid})
- }
- return v.flag&flagRO == 0
-}
-
-// Interface returns v's current value as an interface{}.
-// It is equivalent to:
-// var i interface{} = (v's underlying value)
-// It panics if the Value was obtained by accessing
-// unexported struct fields.
-func (v Value) Interface() (i interface{}) {
- return valueInterface(v, true)
-}
-
-func valueInterface(v Value, safe bool) interface{} {
- if v.flag == 0 {
- panic(&ValueError{"reflect.Value.Interface", 0})
- }
- if safe && v.flag&flagRO != 0 {
- // Do not allow access to unexported values via Interface,
- // because they might be pointers that should not be
- // writable or methods or function that should not be callable.
- panic("reflect.Value.Interface: cannot return value obtained from unexported field or method")
- }
- if v.flag&flagMethod != 0 {
- v = makeMethodValue("Interface", v)
- }
-
- if v.kind() == Interface {
- // Special case: return the element inside the interface.
- // Empty interface has one layout, all interfaces with
- // methods have a second layout.
- if v.NumMethod() == 0 {
- return *(*interface{})(v.ptr)
- }
- return *(*interface {
- M()
- })(v.ptr)
- }
-
- // TODO: pass safe to packEface so we don't need to copy if safe==true?
- return packEface(v)
-}
-
-// InterfaceData returns the interface v's value as a uintptr pair.
-// It panics if v's Kind is not Interface.
-func (v Value) InterfaceData() [2]uintptr {
- // TODO: deprecate this
- v.mustBe(Interface)
- // We treat this as a read operation, so we allow
- // it even for unexported data, because the caller
- // has to import "unsafe" to turn it into something
- // that can be abused.
- // Interface value is always bigger than a word; assume flagIndir.
- return *(*[2]uintptr)(v.ptr)
-}
-
-// IsNil reports whether its argument v is nil. The argument must be
-// a chan, func, interface, map, pointer, or slice value; if it is
-// not, IsNil panics. Note that IsNil is not always equivalent to a
-// regular comparison with nil in Go. For example, if v was created
-// by calling ValueOf with an uninitialized interface variable i,
-// i==nil will be true but v.IsNil will panic as v will be the zero
-// Value.
-func (v Value) IsNil() bool {
- k := v.kind()
- switch k {
- case Chan, Func, Map, Ptr:
- if v.flag&flagMethod != 0 {
- return false
- }
- ptr := v.ptr
- if v.flag&flagIndir != 0 {
- ptr = *(*unsafe.Pointer)(ptr)
- }
- return ptr == nil
- case Interface, Slice:
- // Both interface and slice are nil if first word is 0.
- // Both are always bigger than a word; assume flagIndir.
- return *(*unsafe.Pointer)(v.ptr) == nil
- }
- panic(&ValueError{"reflect.Value.IsNil", k})
-}
-
-// IsValid returns true if v represents a value.
-// It returns false if v is the zero Value.
-// If IsValid returns false, all other methods except String panic.
-// Most functions and methods never return an invalid value.
-// If one does, its documentation states the conditions explicitly.
-func (v Value) IsValid() bool {
- return v.flag != 0
-}
-
-// Kind returns v's Kind.
-// If v is the zero Value (IsValid returns false), Kind returns Invalid.
-func (v Value) Kind() Kind {
- return v.kind()
-}
-
-// Len returns v's length.
-// It panics if v's Kind is not Array, Chan, Map, Slice, or String.
-func (v Value) Len() int {
- k := v.kind()
- switch k {
- case Array:
- tt := (*arrayType)(unsafe.Pointer(v.typ))
- return int(tt.len)
- case Chan:
- return chanlen(v.pointer())
- case Map:
- return maplen(v.pointer())
- case Slice:
- // Slice is bigger than a word; assume flagIndir.
- return (*sliceHeader)(v.ptr).Len
- case String:
- // String is bigger than a word; assume flagIndir.
- return (*stringHeader)(v.ptr).Len
- }
- panic(&ValueError{"reflect.Value.Len", k})
-}
-
-// MapIndex returns the value associated with key in the map v.
-// It panics if v's Kind is not Map.
-// It returns the zero Value if key is not found in the map or if v represents a nil map.
-// As in Go, the key's value must be assignable to the map's key type.
-func (v Value) MapIndex(key Value) Value {
- v.mustBe(Map)
- tt := (*mapType)(unsafe.Pointer(v.typ))
-
- // Do not require key to be exported, so that DeepEqual
- // and other programs can use all the keys returned by
- // MapKeys as arguments to MapIndex. If either the map
- // or the key is unexported, though, the result will be
- // considered unexported. This is consistent with the
- // behavior for structs, which allow read but not write
- // of unexported fields.
- key = key.assignTo("reflect.Value.MapIndex", tt.key, nil)
-
- var k unsafe.Pointer
- if key.flag&flagIndir != 0 {
- k = key.ptr
- } else if key.typ.pointers() {
- k = unsafe.Pointer(&key.ptr)
- } else {
- k = unsafe.Pointer(&key.scalar)
- }
- e := mapaccess(v.typ, v.pointer(), k)
- if e == nil {
- return Value{}
- }
- typ := tt.elem
- fl := (v.flag | key.flag) & flagRO
- fl |= flag(typ.Kind()) << flagKindShift
- if typ.size > ptrSize {
- // Copy result so future changes to the map
- // won't change the underlying value.
- c := unsafe_New(typ)
- memmove(c, e, typ.size)
- return Value{typ, c, 0, fl | flagIndir}
- } else if typ.pointers() {
- return Value{typ, *(*unsafe.Pointer)(e), 0, fl}
- } else {
- return Value{typ, nil, loadScalar(e, typ.size), fl}
- }
-}
-
-// MapKeys returns a slice containing all the keys present in the map,
-// in unspecified order.
-// It panics if v's Kind is not Map.
-// It returns an empty slice if v represents a nil map.
-func (v Value) MapKeys() []Value {
- v.mustBe(Map)
- tt := (*mapType)(unsafe.Pointer(v.typ))
- keyType := tt.key
-
- fl := v.flag&flagRO | flag(keyType.Kind())<<flagKindShift
-
- m := v.pointer()
- mlen := int(0)
- if m != nil {
- mlen = maplen(m)
- }
- it := mapiterinit(v.typ, m)
- a := make([]Value, mlen)
- var i int
- for i = 0; i < len(a); i++ {
- key := mapiterkey(it)
- if key == nil {
- // Someone deleted an entry from the map since we
- // called maplen above. It's a data race, but nothing
- // we can do about it.
- break
- }
- if keyType.size > ptrSize {
- // Copy result so future changes to the map
- // won't change the underlying value.
- c := unsafe_New(keyType)
- memmove(c, key, keyType.size)
- a[i] = Value{keyType, c, 0, fl | flagIndir}
- } else if keyType.pointers() {
- a[i] = Value{keyType, *(*unsafe.Pointer)(key), 0, fl}
- } else {
- a[i] = Value{keyType, nil, loadScalar(key, keyType.size), fl}
- }
- mapiternext(it)
- }
- return a[:i]
-}
-
-// Method returns a function value corresponding to v's i'th method.
-// The arguments to a Call on the returned function should not include
-// a receiver; the returned function will always use v as the receiver.
-// Method panics if i is out of range or if v is a nil interface value.
-func (v Value) Method(i int) Value {
- if v.typ == nil {
- panic(&ValueError{"reflect.Value.Method", Invalid})
- }
- if v.flag&flagMethod != 0 || i < 0 || i >= v.typ.NumMethod() {
- panic("reflect: Method index out of range")
- }
- if v.typ.Kind() == Interface && v.IsNil() {
- panic("reflect: Method on nil interface value")
- }
- fl := v.flag & (flagRO | flagIndir)
- fl |= flag(Func) << flagKindShift
- fl |= flag(i)<<flagMethodShift | flagMethod
- return Value{v.typ, v.ptr, v.scalar, fl}
-}
-
-// NumMethod returns the number of methods in the value's method set.
-func (v Value) NumMethod() int {
- if v.typ == nil {
- panic(&ValueError{"reflect.Value.NumMethod", Invalid})
- }
- if v.flag&flagMethod != 0 {
- return 0
- }
- return v.typ.NumMethod()
-}
-
-// MethodByName returns a function value corresponding to the method
-// of v with the given name.
-// The arguments to a Call on the returned function should not include
-// a receiver; the returned function will always use v as the receiver.
-// It returns the zero Value if no method was found.
-func (v Value) MethodByName(name string) Value {
- if v.typ == nil {
- panic(&ValueError{"reflect.Value.MethodByName", Invalid})
- }
- if v.flag&flagMethod != 0 {
- return Value{}
- }
- m, ok := v.typ.MethodByName(name)
- if !ok {
- return Value{}
- }
- return v.Method(m.Index)
-}
-
-// NumField returns the number of fields in the struct v.
-// It panics if v's Kind is not Struct.
-func (v Value) NumField() int {
- v.mustBe(Struct)
- tt := (*structType)(unsafe.Pointer(v.typ))
- return len(tt.fields)
-}
-
-// OverflowComplex returns true if the complex128 x cannot be represented by v's type.
-// It panics if v's Kind is not Complex64 or Complex128.
-func (v Value) OverflowComplex(x complex128) bool {
- k := v.kind()
- switch k {
- case Complex64:
- return overflowFloat32(real(x)) || overflowFloat32(imag(x))
- case Complex128:
- return false
- }
- panic(&ValueError{"reflect.Value.OverflowComplex", k})
-}
-
-// OverflowFloat returns true if the float64 x cannot be represented by v's type.
-// It panics if v's Kind is not Float32 or Float64.
-func (v Value) OverflowFloat(x float64) bool {
- k := v.kind()
- switch k {
- case Float32:
- return overflowFloat32(x)
- case Float64:
- return false
- }
- panic(&ValueError{"reflect.Value.OverflowFloat", k})
-}
-
-func overflowFloat32(x float64) bool {
- if x < 0 {
- x = -x
- }
- return math.MaxFloat32 < x && x <= math.MaxFloat64
-}
-
-// OverflowInt returns true if the int64 x cannot be represented by v's type.
-// It panics if v's Kind is not Int, Int8, int16, Int32, or Int64.
-func (v Value) OverflowInt(x int64) bool {
- k := v.kind()
- switch k {
- case Int, Int8, Int16, Int32, Int64:
- bitSize := v.typ.size * 8
- trunc := (x << (64 - bitSize)) >> (64 - bitSize)
- return x != trunc
- }
- panic(&ValueError{"reflect.Value.OverflowInt", k})
-}
-
-// OverflowUint returns true if the uint64 x cannot be represented by v's type.
-// It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.
-func (v Value) OverflowUint(x uint64) bool {
- k := v.kind()
- switch k {
- case Uint, Uintptr, Uint8, Uint16, Uint32, Uint64:
- bitSize := v.typ.size * 8
- trunc := (x << (64 - bitSize)) >> (64 - bitSize)
- return x != trunc
- }
- panic(&ValueError{"reflect.Value.OverflowUint", k})
-}
-
-// Pointer returns v's value as a uintptr.
-// It returns uintptr instead of unsafe.Pointer so that
-// code using reflect cannot obtain unsafe.Pointers
-// without importing the unsafe package explicitly.
-// It panics if v's Kind is not Chan, Func, Map, Ptr, Slice, or UnsafePointer.
-//
-// If v's Kind is Func, the returned pointer is an underlying
-// code pointer, but not necessarily enough to identify a
-// single function uniquely. The only guarantee is that the
-// result is zero if and only if v is a nil func Value.
-//
-// If v's Kind is Slice, the returned pointer is to the first
-// element of the slice. If the slice is nil the returned value
-// is 0. If the slice is empty but non-nil the return value is non-zero.
-func (v Value) Pointer() uintptr {
- // TODO: deprecate
- k := v.kind()
- switch k {
- case Chan, Map, Ptr, UnsafePointer:
- return uintptr(v.pointer())
- case Func:
- if v.flag&flagMethod != 0 {
- // As the doc comment says, the returned pointer is an
- // underlying code pointer but not necessarily enough to
- // identify a single function uniquely. All method expressions
- // created via reflect have the same underlying code pointer,
- // so their Pointers are equal. The function used here must
- // match the one used in makeMethodValue.
- f := methodValueCall
- return **(**uintptr)(unsafe.Pointer(&f))
- }
- p := v.pointer()
- // Non-nil func value points at data block.
- // First word of data block is actual code.
- if p != nil {
- p = *(*unsafe.Pointer)(p)
- }
- return uintptr(p)
-
- case Slice:
- return (*SliceHeader)(v.ptr).Data
- }
- panic(&ValueError{"reflect.Value.Pointer", k})
-}
-
-// Recv receives and returns a value from the channel v.
-// It panics if v's Kind is not Chan.
-// The receive blocks until a value is ready.
-// The boolean value ok is true if the value x corresponds to a send
-// on the channel, false if it is a zero value received because the channel is closed.
-func (v Value) Recv() (x Value, ok bool) {
- v.mustBe(Chan)
- v.mustBeExported()
- return v.recv(false)
-}
-
-// internal recv, possibly non-blocking (nb).
-// v is known to be a channel.
-func (v Value) recv(nb bool) (val Value, ok bool) {
- tt := (*chanType)(unsafe.Pointer(v.typ))
- if ChanDir(tt.dir)&RecvDir == 0 {
- panic("reflect: recv on send-only channel")
- }
- t := tt.elem
- val = Value{t, nil, 0, flag(t.Kind()) << flagKindShift}
- var p unsafe.Pointer
- if t.size > ptrSize {
- p = unsafe_New(t)
- val.ptr = p
- val.flag |= flagIndir
- } else if t.pointers() {
- p = unsafe.Pointer(&val.ptr)
- } else {
- p = unsafe.Pointer(&val.scalar)
- }
- selected, ok := chanrecv(v.typ, v.pointer(), nb, p)
- if !selected {
- val = Value{}
- }
- return
-}
-
-// Send sends x on the channel v.
-// It panics if v's kind is not Chan or if x's type is not the same type as v's element type.
-// As in Go, x's value must be assignable to the channel's element type.
-func (v Value) Send(x Value) {
- v.mustBe(Chan)
- v.mustBeExported()
- v.send(x, false)
-}
-
-// internal send, possibly non-blocking.
-// v is known to be a channel.
-func (v Value) send(x Value, nb bool) (selected bool) {
- tt := (*chanType)(unsafe.Pointer(v.typ))
- if ChanDir(tt.dir)&SendDir == 0 {
- panic("reflect: send on recv-only channel")
- }
- x.mustBeExported()
- x = x.assignTo("reflect.Value.Send", tt.elem, nil)
- var p unsafe.Pointer
- if x.flag&flagIndir != 0 {
- p = x.ptr
- } else if x.typ.pointers() {
- p = unsafe.Pointer(&x.ptr)
- } else {
- p = unsafe.Pointer(&x.scalar)
- }
- return chansend(v.typ, v.pointer(), p, nb)
-}
-
-// Set assigns x to the value v.
-// It panics if CanSet returns false.
-// As in Go, x's value must be assignable to v's type.
-func (v Value) Set(x Value) {
- v.mustBeAssignable()
- x.mustBeExported() // do not let unexported x leak
- var target *interface{}
- if v.kind() == Interface {
- target = (*interface{})(v.ptr)
- }
- x = x.assignTo("reflect.Set", v.typ, target)
- if x.flag&flagIndir != 0 {
- memmove(v.ptr, x.ptr, v.typ.size)
- } else if x.typ.pointers() {
- *(*unsafe.Pointer)(v.ptr) = x.ptr
- } else {
- memmove(v.ptr, unsafe.Pointer(&x.scalar), v.typ.size)
- }
-}
-
-// SetBool sets v's underlying value.
-// It panics if v's Kind is not Bool or if CanSet() is false.
-func (v Value) SetBool(x bool) {
- v.mustBeAssignable()
- v.mustBe(Bool)
- *(*bool)(v.ptr) = x
-}
-
-// SetBytes sets v's underlying value.
-// It panics if v's underlying value is not a slice of bytes.
-func (v Value) SetBytes(x []byte) {
- v.mustBeAssignable()
- v.mustBe(Slice)
- if v.typ.Elem().Kind() != Uint8 {
- panic("reflect.Value.SetBytes of non-byte slice")
- }
- *(*[]byte)(v.ptr) = x
-}
-
-// setRunes sets v's underlying value.
-// It panics if v's underlying value is not a slice of runes (int32s).
-func (v Value) setRunes(x []rune) {
- v.mustBeAssignable()
- v.mustBe(Slice)
- if v.typ.Elem().Kind() != Int32 {
- panic("reflect.Value.setRunes of non-rune slice")
- }
- *(*[]rune)(v.ptr) = x
-}
-
-// SetComplex sets v's underlying value to x.
-// It panics if v's Kind is not Complex64 or Complex128, or if CanSet() is false.
-func (v Value) SetComplex(x complex128) {
- v.mustBeAssignable()
- switch k := v.kind(); k {
- default:
- panic(&ValueError{"reflect.Value.SetComplex", k})
- case Complex64:
- *(*complex64)(v.ptr) = complex64(x)
- case Complex128:
- *(*complex128)(v.ptr) = x
- }
-}
-
-// SetFloat sets v's underlying value to x.
-// It panics if v's Kind is not Float32 or Float64, or if CanSet() is false.
-func (v Value) SetFloat(x float64) {
- v.mustBeAssignable()
- switch k := v.kind(); k {
- default:
- panic(&ValueError{"reflect.Value.SetFloat", k})
- case Float32:
- *(*float32)(v.ptr) = float32(x)
- case Float64:
- *(*float64)(v.ptr) = x
- }
-}
-
-// SetInt sets v's underlying value to x.
-// It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64, or if CanSet() is false.
-func (v Value) SetInt(x int64) {
- v.mustBeAssignable()
- switch k := v.kind(); k {
- default:
- panic(&ValueError{"reflect.Value.SetInt", k})
- case Int:
- *(*int)(v.ptr) = int(x)
- case Int8:
- *(*int8)(v.ptr) = int8(x)
- case Int16:
- *(*int16)(v.ptr) = int16(x)
- case Int32:
- *(*int32)(v.ptr) = int32(x)
- case Int64:
- *(*int64)(v.ptr) = x
- }
-}
-
-// SetLen sets v's length to n.
-// It panics if v's Kind is not Slice or if n is negative or
-// greater than the capacity of the slice.
-func (v Value) SetLen(n int) {
- v.mustBeAssignable()
- v.mustBe(Slice)
- s := (*sliceHeader)(v.ptr)
- if n < 0 || n > int(s.Cap) {
- panic("reflect: slice length out of range in SetLen")
- }
- s.Len = n
-}
-
-// SetCap sets v's capacity to n.
-// It panics if v's Kind is not Slice or if n is smaller than the length or
-// greater than the capacity of the slice.
-func (v Value) SetCap(n int) {
- v.mustBeAssignable()
- v.mustBe(Slice)
- s := (*sliceHeader)(v.ptr)
- if n < int(s.Len) || n > int(s.Cap) {
- panic("reflect: slice capacity out of range in SetCap")
- }
- s.Cap = n
-}
-
-// SetMapIndex sets the value associated with key in the map v to val.
-// It panics if v's Kind is not Map.
-// If val is the zero Value, SetMapIndex deletes the key from the map.
-// Otherwise if v holds a nil map, SetMapIndex will panic.
-// As in Go, key's value must be assignable to the map's key type,
-// and val's value must be assignable to the map's value type.
-func (v Value) SetMapIndex(key, val Value) {
- v.mustBe(Map)
- v.mustBeExported()
- key.mustBeExported()
- tt := (*mapType)(unsafe.Pointer(v.typ))
- key = key.assignTo("reflect.Value.SetMapIndex", tt.key, nil)
- var k unsafe.Pointer
- if key.flag&flagIndir != 0 {
- k = key.ptr
- } else if key.typ.pointers() {
- k = unsafe.Pointer(&key.ptr)
- } else {
- k = unsafe.Pointer(&key.scalar)
- }
- if val.typ == nil {
- mapdelete(v.typ, v.pointer(), k)
- return
- }
- val.mustBeExported()
- val = val.assignTo("reflect.Value.SetMapIndex", tt.elem, nil)
- var e unsafe.Pointer
- if val.flag&flagIndir != 0 {
- e = val.ptr
- } else if val.typ.pointers() {
- e = unsafe.Pointer(&val.ptr)
- } else {
- e = unsafe.Pointer(&val.scalar)
- }
- mapassign(v.typ, v.pointer(), k, e)
-}
-
-// SetUint sets v's underlying value to x.
-// It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64, or if CanSet() is false.
-func (v Value) SetUint(x uint64) {
- v.mustBeAssignable()
- switch k := v.kind(); k {
- default:
- panic(&ValueError{"reflect.Value.SetUint", k})
- case Uint:
- *(*uint)(v.ptr) = uint(x)
- case Uint8:
- *(*uint8)(v.ptr) = uint8(x)
- case Uint16:
- *(*uint16)(v.ptr) = uint16(x)
- case Uint32:
- *(*uint32)(v.ptr) = uint32(x)
- case Uint64:
- *(*uint64)(v.ptr) = x
- case Uintptr:
- *(*uintptr)(v.ptr) = uintptr(x)
- }
-}
-
-// SetPointer sets the unsafe.Pointer value v to x.
-// It panics if v's Kind is not UnsafePointer.
-func (v Value) SetPointer(x unsafe.Pointer) {
- v.mustBeAssignable()
- v.mustBe(UnsafePointer)
- *(*unsafe.Pointer)(v.ptr) = x
-}
-
-// SetString sets v's underlying value to x.
-// It panics if v's Kind is not String or if CanSet() is false.
-func (v Value) SetString(x string) {
- v.mustBeAssignable()
- v.mustBe(String)
- *(*string)(v.ptr) = x
-}
-
-// Slice returns v[i:j].
-// It panics if v's Kind is not Array, Slice or String, or if v is an unaddressable array,
-// or if the indexes are out of bounds.
-func (v Value) Slice(i, j int) Value {
- var (
- cap int
- typ *sliceType
- base unsafe.Pointer
- )
- switch kind := v.kind(); kind {
- default:
- panic(&ValueError{"reflect.Value.Slice", kind})
-
- case Array:
- if v.flag&flagAddr == 0 {
- panic("reflect.Value.Slice: slice of unaddressable array")
- }
- tt := (*arrayType)(unsafe.Pointer(v.typ))
- cap = int(tt.len)
- typ = (*sliceType)(unsafe.Pointer(tt.slice))
- base = v.ptr
-
- case Slice:
- typ = (*sliceType)(unsafe.Pointer(v.typ))
- s := (*sliceHeader)(v.ptr)
- base = unsafe.Pointer(s.Data)
- cap = s.Cap
-
- case String:
- s := (*stringHeader)(v.ptr)
- if i < 0 || j < i || j > s.Len {
- panic("reflect.Value.Slice: string slice index out of bounds")
- }
- t := stringHeader{unsafe.Pointer(uintptr(s.Data) + uintptr(i)), j - i}
- return Value{v.typ, unsafe.Pointer(&t), 0, v.flag}
- }
-
- if i < 0 || j < i || j > cap {
- panic("reflect.Value.Slice: slice index out of bounds")
- }
-
- // Declare slice so that gc can see the base pointer in it.
- var x []unsafe.Pointer
-
- // Reinterpret as *sliceHeader to edit.
- s := (*sliceHeader)(unsafe.Pointer(&x))
- s.Data = unsafe.Pointer(uintptr(base) + uintptr(i)*typ.elem.Size())
- s.Len = j - i
- s.Cap = cap - i
-
- fl := v.flag&flagRO | flagIndir | flag(Slice)<<flagKindShift
- return Value{typ.common(), unsafe.Pointer(&x), 0, fl}
-}
-
-// Slice3 is the 3-index form of the slice operation: it returns v[i:j:k].
-// It panics if v's Kind is not Array or Slice, or if v is an unaddressable array,
-// or if the indexes are out of bounds.
-func (v Value) Slice3(i, j, k int) Value {
- var (
- cap int
- typ *sliceType
- base unsafe.Pointer
- )
- switch kind := v.kind(); kind {
- default:
- panic(&ValueError{"reflect.Value.Slice3", kind})
-
- case Array:
- if v.flag&flagAddr == 0 {
- panic("reflect.Value.Slice3: slice of unaddressable array")
- }
- tt := (*arrayType)(unsafe.Pointer(v.typ))
- cap = int(tt.len)
- typ = (*sliceType)(unsafe.Pointer(tt.slice))
- base = v.ptr
-
- case Slice:
- typ = (*sliceType)(unsafe.Pointer(v.typ))
- s := (*sliceHeader)(v.ptr)
- base = s.Data
- cap = s.Cap
- }
-
- if i < 0 || j < i || k < j || k > cap {
- panic("reflect.Value.Slice3: slice index out of bounds")
- }
-
- // Declare slice so that the garbage collector
- // can see the base pointer in it.
- var x []unsafe.Pointer
-
- // Reinterpret as *sliceHeader to edit.
- s := (*sliceHeader)(unsafe.Pointer(&x))
- s.Data = unsafe.Pointer(uintptr(base) + uintptr(i)*typ.elem.Size())
- s.Len = j - i
- s.Cap = k - i
-
- fl := v.flag&flagRO | flagIndir | flag(Slice)<<flagKindShift
- return Value{typ.common(), unsafe.Pointer(&x), 0, fl}
-}
-
-// String returns the string v's underlying value, as a string.
-// String is a special case because of Go's String method convention.
-// Unlike the other getters, it does not panic if v's Kind is not String.
-// Instead, it returns a string of the form "<T value>" where T is v's type.
-func (v Value) String() string {
- switch k := v.kind(); k {
- case Invalid:
- return "<invalid Value>"
- case String:
- return *(*string)(v.ptr)
- }
- // If you call String on a reflect.Value of other type, it's better to
- // print something than to panic. Useful in debugging.
- return "<" + v.typ.String() + " Value>"
-}
-
-// TryRecv attempts to receive a value from the channel v but will not block.
-// It panics if v's Kind is not Chan.
-// If the receive delivers a value, x is the transferred value and ok is true.
-// If the receive cannot finish without blocking, x is the zero Value and ok is false.
-// If the channel is closed, x is the zero value for the channel's element type and ok is false.
-func (v Value) TryRecv() (x Value, ok bool) {
- v.mustBe(Chan)
- v.mustBeExported()
- return v.recv(true)
-}
-
-// TrySend attempts to send x on the channel v but will not block.
-// It panics if v's Kind is not Chan.
-// It returns true if the value was sent, false otherwise.
-// As in Go, x's value must be assignable to the channel's element type.
-func (v Value) TrySend(x Value) bool {
- v.mustBe(Chan)
- v.mustBeExported()
- return v.send(x, true)
-}
-
-// Type returns v's type.
-func (v Value) Type() Type {
- f := v.flag
- if f == 0 {
- panic(&ValueError{"reflect.Value.Type", Invalid})
- }
- if f&flagMethod == 0 {
- // Easy case
- return v.typ
- }
-
- // Method value.
- // v.typ describes the receiver, not the method type.
- i := int(v.flag) >> flagMethodShift
- if v.typ.Kind() == Interface {
- // Method on interface.
- tt := (*interfaceType)(unsafe.Pointer(v.typ))
- if i < 0 || i >= len(tt.methods) {
- panic("reflect: internal error: invalid method index")
- }
- m := &tt.methods[i]
- return m.typ
- }
- // Method on concrete type.
- ut := v.typ.uncommon()
- if ut == nil || i < 0 || i >= len(ut.methods) {
- panic("reflect: internal error: invalid method index")
- }
- m := &ut.methods[i]
- return m.mtyp
-}
-
-// Uint returns v's underlying value, as a uint64.
-// It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.
-func (v Value) Uint() uint64 {
- k := v.kind()
- var p unsafe.Pointer
- if v.flag&flagIndir != 0 {
- p = v.ptr
- } else {
- // The escape analysis is good enough that &v.scalar
- // does not trigger a heap allocation.
- p = unsafe.Pointer(&v.scalar)
- }
- switch k {
- case Uint:
- return uint64(*(*uint)(p))
- case Uint8:
- return uint64(*(*uint8)(p))
- case Uint16:
- return uint64(*(*uint16)(p))
- case Uint32:
- return uint64(*(*uint32)(p))
- case Uint64:
- return uint64(*(*uint64)(p))
- case Uintptr:
- return uint64(*(*uintptr)(p))
- }
- panic(&ValueError{"reflect.Value.Uint", k})
-}
-
-// UnsafeAddr returns a pointer to v's data.
-// It is for advanced clients that also import the "unsafe" package.
-// It panics if v is not addressable.
-func (v Value) UnsafeAddr() uintptr {
- // TODO: deprecate
- if v.typ == nil {
- panic(&ValueError{"reflect.Value.UnsafeAddr", Invalid})
- }
- if v.flag&flagAddr == 0 {
- panic("reflect.Value.UnsafeAddr of unaddressable value")
- }
- return uintptr(v.ptr)
-}
-
-// StringHeader is the runtime representation of a string.
-// It cannot be used safely or portably and its representation may
-// change in a later release.
-// Moreover, the Data field is not sufficient to guarantee the data
-// it references will not be garbage collected, so programs must keep
-// a separate, correctly typed pointer to the underlying data.
-type StringHeader struct {
- Data uintptr
- Len int
-}
-
-// stringHeader is a safe version of StringHeader used within this package.
-type stringHeader struct {
- Data unsafe.Pointer
- Len int
-}
-
-// SliceHeader is the runtime representation of a slice.
-// It cannot be used safely or portably and its representation may
-// change in a later release.
-// Moreover, the Data field is not sufficient to guarantee the data
-// it references will not be garbage collected, so programs must keep
-// a separate, correctly typed pointer to the underlying data.
-type SliceHeader struct {
- Data uintptr
- Len int
- Cap int
-}
-
-// sliceHeader is a safe version of SliceHeader used within this package.
-type sliceHeader struct {
- Data unsafe.Pointer
- Len int
- Cap int
-}
-
-func typesMustMatch(what string, t1, t2 Type) {
- if t1 != t2 {
- panic(what + ": " + t1.String() + " != " + t2.String())
- }
-}
-
-// grow grows the slice s so that it can hold extra more values, allocating
-// more capacity if needed. It also returns the old and new slice lengths.
-func grow(s Value, extra int) (Value, int, int) {
- i0 := s.Len()
- i1 := i0 + extra
- if i1 < i0 {
- panic("reflect.Append: slice overflow")
- }
- m := s.Cap()
- if i1 <= m {
- return s.Slice(0, i1), i0, i1
- }
- if m == 0 {
- m = extra
- } else {
- for m < i1 {
- if i0 < 1024 {
- m += m
- } else {
- m += m / 4
- }
- }
- }
- t := MakeSlice(s.Type(), i1, m)
- Copy(t, s)
- return t, i0, i1
-}
-
-// Append appends the values x to a slice s and returns the resulting slice.
-// As in Go, each x's value must be assignable to the slice's element type.
-func Append(s Value, x ...Value) Value {
- s.mustBe(Slice)
- s, i0, i1 := grow(s, len(x))
- for i, j := i0, 0; i < i1; i, j = i+1, j+1 {
- s.Index(i).Set(x[j])
- }
- return s
-}
-
-// AppendSlice appends a slice t to a slice s and returns the resulting slice.
-// The slices s and t must have the same element type.
-func AppendSlice(s, t Value) Value {
- s.mustBe(Slice)
- t.mustBe(Slice)
- typesMustMatch("reflect.AppendSlice", s.Type().Elem(), t.Type().Elem())
- s, i0, i1 := grow(s, t.Len())
- Copy(s.Slice(i0, i1), t)
- return s
-}
-
-// Copy copies the contents of src into dst until either
-// dst has been filled or src has been exhausted.
-// It returns the number of elements copied.
-// Dst and src each must have kind Slice or Array, and
-// dst and src must have the same element type.
-func Copy(dst, src Value) int {
- dk := dst.kind()
- if dk != Array && dk != Slice {
- panic(&ValueError{"reflect.Copy", dk})
- }
- if dk == Array {
- dst.mustBeAssignable()
- }
- dst.mustBeExported()
-
- sk := src.kind()
- if sk != Array && sk != Slice {
- panic(&ValueError{"reflect.Copy", sk})
- }
- src.mustBeExported()
-
- de := dst.typ.Elem()
- se := src.typ.Elem()
- typesMustMatch("reflect.Copy", de, se)
-
- n := dst.Len()
- if sn := src.Len(); n > sn {
- n = sn
- }
-
- // If sk is an in-line array, cannot take its address.
- // Instead, copy element by element.
- // TODO: memmove would be ok for this (sa = unsafe.Pointer(&v.scalar))
- // if we teach the compiler that ptrs don't escape from memmove.
- if src.flag&flagIndir == 0 {
- for i := 0; i < n; i++ {
- dst.Index(i).Set(src.Index(i))
- }
- return n
- }
-
- // Copy via memmove.
- var da, sa unsafe.Pointer
- if dk == Array {
- da = dst.ptr
- } else {
- da = (*sliceHeader)(dst.ptr).Data
- }
- if sk == Array {
- sa = src.ptr
- } else {
- sa = (*sliceHeader)(src.ptr).Data
- }
- memmove(da, sa, uintptr(n)*de.Size())
- return n
-}
-
-// A runtimeSelect is a single case passed to rselect.
-// This must match ../runtime/chan.c:/runtimeSelect
-type runtimeSelect struct {
- dir uintptr // 0, SendDir, or RecvDir
- typ *rtype // channel type
- ch unsafe.Pointer // channel
- val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
-}
-
-// rselect runs a select. It returns the index of the chosen case.
-// If the case was a receive, val is filled in with the received value.
-// The conventional OK bool indicates whether the receive corresponds
-// to a sent value.
-//go:noescape
-func rselect([]runtimeSelect) (chosen int, recvOK bool)
-
-// A SelectDir describes the communication direction of a select case.
-type SelectDir int
-
-// NOTE: These values must match ../runtime/chan.c:/SelectDir.
-
-const (
- _ SelectDir = iota
- SelectSend // case Chan <- Send
- SelectRecv // case <-Chan:
- SelectDefault // default
-)
-
-// A SelectCase describes a single case in a select operation.
-// The kind of case depends on Dir, the communication direction.
-//
-// If Dir is SelectDefault, the case represents a default case.
-// Chan and Send must be zero Values.
-//
-// If Dir is SelectSend, the case represents a send operation.
-// Normally Chan's underlying value must be a channel, and Send's underlying value must be
-// assignable to the channel's element type. As a special case, if Chan is a zero Value,
-// then the case is ignored, and the field Send will also be ignored and may be either zero
-// or non-zero.
-//
-// If Dir is SelectRecv, the case represents a receive operation.
-// Normally Chan's underlying value must be a channel and Send must be a zero Value.
-// If Chan is a zero Value, then the case is ignored, but Send must still be a zero Value.
-// When a receive operation is selected, the received Value is returned by Select.
-//
-type SelectCase struct {
- Dir SelectDir // direction of case
- Chan Value // channel to use (for send or receive)
- Send Value // value to send (for send)
-}
-
-// Select executes a select operation described by the list of cases.
-// Like the Go select statement, it blocks until at least one of the cases
-// can proceed, makes a uniform pseudo-random choice,
-// and then executes that case. It returns the index of the chosen case
-// and, if that case was a receive operation, the value received and a
-// boolean indicating whether the value corresponds to a send on the channel
-// (as opposed to a zero value received because the channel is closed).
-func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool) {
- // NOTE: Do not trust that caller is not modifying cases data underfoot.
- // The range is safe because the caller cannot modify our copy of the len
- // and each iteration makes its own copy of the value c.
- runcases := make([]runtimeSelect, len(cases))
- haveDefault := false
- for i, c := range cases {
- rc := &runcases[i]
- rc.dir = uintptr(c.Dir)
- switch c.Dir {
- default:
- panic("reflect.Select: invalid Dir")
-
- case SelectDefault: // default
- if haveDefault {
- panic("reflect.Select: multiple default cases")
- }
- haveDefault = true
- if c.Chan.IsValid() {
- panic("reflect.Select: default case has Chan value")
- }
- if c.Send.IsValid() {
- panic("reflect.Select: default case has Send value")
- }
-
- case SelectSend:
- ch := c.Chan
- if !ch.IsValid() {
- break
- }
- ch.mustBe(Chan)
- ch.mustBeExported()
- tt := (*chanType)(unsafe.Pointer(ch.typ))
- if ChanDir(tt.dir)&SendDir == 0 {
- panic("reflect.Select: SendDir case using recv-only channel")
- }
- rc.ch = ch.pointer()
- rc.typ = &tt.rtype
- v := c.Send
- if !v.IsValid() {
- panic("reflect.Select: SendDir case missing Send value")
- }
- v.mustBeExported()
- v = v.assignTo("reflect.Select", tt.elem, nil)
- if v.flag&flagIndir != 0 {
- rc.val = v.ptr
- } else if v.typ.pointers() {
- rc.val = unsafe.Pointer(&v.ptr)
- } else {
- rc.val = unsafe.Pointer(&v.scalar)
- }
-
- case SelectRecv:
- if c.Send.IsValid() {
- panic("reflect.Select: RecvDir case has Send value")
- }
- ch := c.Chan
- if !ch.IsValid() {
- break
- }
- ch.mustBe(Chan)
- ch.mustBeExported()
- tt := (*chanType)(unsafe.Pointer(ch.typ))
- if ChanDir(tt.dir)&RecvDir == 0 {
- panic("reflect.Select: RecvDir case using send-only channel")
- }
- rc.ch = ch.pointer()
- rc.typ = &tt.rtype
- rc.val = unsafe_New(tt.elem)
- }
- }
-
- chosen, recvOK = rselect(runcases)
- if runcases[chosen].dir == uintptr(SelectRecv) {
- tt := (*chanType)(unsafe.Pointer(runcases[chosen].typ))
- t := tt.elem
- p := runcases[chosen].val
- fl := flag(t.Kind()) << flagKindShift
- if t.size > ptrSize {
- recv = Value{t, p, 0, fl | flagIndir}
- } else if t.pointers() {
- recv = Value{t, *(*unsafe.Pointer)(p), 0, fl}
- } else {
- recv = Value{t, nil, loadScalar(p, t.size), fl}
- }
- }
- return chosen, recv, recvOK
-}
-
-/*
- * constructors
- */
-
-// implemented in package runtime
-func unsafe_New(*rtype) unsafe.Pointer
-func unsafe_NewArray(*rtype, int) unsafe.Pointer
-
-// MakeSlice creates a new zero-initialized slice value
-// for the specified slice type, length, and capacity.
-func MakeSlice(typ Type, len, cap int) Value {
- if typ.Kind() != Slice {
- panic("reflect.MakeSlice of non-slice type")
- }
- if len < 0 {
- panic("reflect.MakeSlice: negative len")
- }
- if cap < 0 {
- panic("reflect.MakeSlice: negative cap")
- }
- if len > cap {
- panic("reflect.MakeSlice: len > cap")
- }
-
- s := sliceHeader{unsafe_NewArray(typ.Elem().(*rtype), cap), len, cap}
- return Value{typ.common(), unsafe.Pointer(&s), 0, flagIndir | flag(Slice)<<flagKindShift}
-}
-
-// MakeChan creates a new channel with the specified type and buffer size.
-func MakeChan(typ Type, buffer int) Value {
- if typ.Kind() != Chan {
- panic("reflect.MakeChan of non-chan type")
- }
- if buffer < 0 {
- panic("reflect.MakeChan: negative buffer size")
- }
- if typ.ChanDir() != BothDir {
- panic("reflect.MakeChan: unidirectional channel type")
- }
- ch := makechan(typ.(*rtype), uint64(buffer))
- return Value{typ.common(), ch, 0, flag(Chan) << flagKindShift}
-}
-
-// MakeMap creates a new map of the specified type.
-func MakeMap(typ Type) Value {
- if typ.Kind() != Map {
- panic("reflect.MakeMap of non-map type")
- }
- m := makemap(typ.(*rtype))
- return Value{typ.common(), m, 0, flag(Map) << flagKindShift}
-}
-
-// 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() != Ptr {
- return v
- }
- return v.Elem()
-}
-
-// ValueOf returns a new Value initialized to the concrete value
-// stored in the interface i. ValueOf(nil) returns the zero Value.
-func ValueOf(i interface{}) Value {
- if i == nil {
- return Value{}
- }
-
- // TODO(rsc): Eliminate this terrible hack.
- // In the call to unpackEface, i.typ doesn't escape,
- // and i.word is an integer. So it looks like
- // i doesn't escape. But really it does,
- // because i.word is actually a pointer.
- escapes(i)
-
- return unpackEface(i)
-}
-
-// Zero returns a Value representing the zero value for the specified type.
-// The result is different from the zero value of the Value struct,
-// which represents no value at all.
-// For example, Zero(TypeOf(42)) returns a Value with Kind Int and value 0.
-// The returned value is neither addressable nor settable.
-func Zero(typ Type) Value {
- if typ == nil {
- panic("reflect: Zero(nil)")
- }
- t := typ.common()
- fl := flag(t.Kind()) << flagKindShift
- if t.size <= ptrSize {
- return Value{t, nil, 0, fl}
- }
- return Value{t, unsafe_New(typ.(*rtype)), 0, fl | flagIndir}
-}
-
-// New returns a Value representing a pointer to a new zero value
-// for the specified type. That is, the returned Value's Type is PtrTo(typ).
-func New(typ Type) Value {
- if typ == nil {
- panic("reflect: New(nil)")
- }
- ptr := unsafe_New(typ.(*rtype))
- fl := flag(Ptr) << flagKindShift
- return Value{typ.common().ptrTo(), ptr, 0, fl}
-}
-
-// NewAt returns a Value representing a pointer to a value of the
-// specified type, using p as that pointer.
-func NewAt(typ Type, p unsafe.Pointer) Value {
- fl := flag(Ptr) << flagKindShift
- return Value{typ.common().ptrTo(), p, 0, fl}
-}
-
-// assignTo returns a value v that can be assigned directly to typ.
-// It panics if v is not assignable to typ.
-// For a conversion to an interface type, target is a suggested scratch space to use.
-func (v Value) assignTo(context string, dst *rtype, target *interface{}) Value {
- if v.flag&flagMethod != 0 {
- v = makeMethodValue(context, v)
- }
-
- switch {
- case directlyAssignable(dst, v.typ):
- // Overwrite type so that they match.
- // Same memory layout, so no harm done.
- v.typ = dst
- fl := v.flag & (flagRO | flagAddr | flagIndir)
- fl |= flag(dst.Kind()) << flagKindShift
- return Value{dst, v.ptr, v.scalar, fl}
-
- case implements(dst, v.typ):
- if target == nil {
- target = new(interface{})
- }
- x := valueInterface(v, false)
- if dst.NumMethod() == 0 {
- *target = x
- } else {
- ifaceE2I(dst, x, unsafe.Pointer(target))
- }
- return Value{dst, unsafe.Pointer(target), 0, flagIndir | flag(Interface)<<flagKindShift}
- }
-
- // Failed.
- panic(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String())
-}
-
-// Convert returns the value v converted to type t.
-// If the usual Go conversion rules do not allow conversion
-// of the value v to type t, Convert panics.
-func (v Value) Convert(t Type) Value {
- if v.flag&flagMethod != 0 {
- v = makeMethodValue("Convert", v)
- }
- op := convertOp(t.common(), v.typ)
- if op == nil {
- panic("reflect.Value.Convert: value of type " + v.typ.String() + " cannot be converted to type " + t.String())
- }
- return op(v, t)
-}
-
-// convertOp returns the function to convert a value of type src
-// to a value of type dst. If the conversion is illegal, convertOp returns nil.
-func convertOp(dst, src *rtype) func(Value, Type) Value {
- switch src.Kind() {
- case Int, Int8, Int16, Int32, Int64:
- switch dst.Kind() {
- case Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
- return cvtInt
- case Float32, Float64:
- return cvtIntFloat
- case String:
- return cvtIntString
- }
-
- case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
- switch dst.Kind() {
- case Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
- return cvtUint
- case Float32, Float64:
- return cvtUintFloat
- case String:
- return cvtUintString
- }
-
- case Float32, Float64:
- switch dst.Kind() {
- case Int, Int8, Int16, Int32, Int64:
- return cvtFloatInt
- case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
- return cvtFloatUint
- case Float32, Float64:
- return cvtFloat
- }
-
- case Complex64, Complex128:
- switch dst.Kind() {
- case Complex64, Complex128:
- return cvtComplex
- }
-
- case String:
- if dst.Kind() == Slice && dst.Elem().PkgPath() == "" {
- switch dst.Elem().Kind() {
- case Uint8:
- return cvtStringBytes
- case Int32:
- return cvtStringRunes
- }
- }
-
- case Slice:
- if dst.Kind() == String && src.Elem().PkgPath() == "" {
- switch src.Elem().Kind() {
- case Uint8:
- return cvtBytesString
- case Int32:
- return cvtRunesString
- }
- }
- }
-
- // dst and src have same underlying type.
- if haveIdenticalUnderlyingType(dst, src) {
- return cvtDirect
- }
-
- // dst and src are unnamed pointer types with same underlying base type.
- if dst.Kind() == Ptr && dst.Name() == "" &&
- src.Kind() == Ptr && src.Name() == "" &&
- haveIdenticalUnderlyingType(dst.Elem().common(), src.Elem().common()) {
- return cvtDirect
- }
-
- if implements(dst, src) {
- if src.Kind() == Interface {
- return cvtI2I
- }
- return cvtT2I
- }
-
- return nil
-}
-
-// makeInt returns a Value of type t equal to bits (possibly truncated),
-// where t is a signed or unsigned int type.
-func makeInt(f flag, bits uint64, t Type) Value {
- typ := t.common()
- if typ.size > ptrSize {
- // Assume ptrSize >= 4, so this must be uint64.
- ptr := unsafe_New(typ)
- *(*uint64)(unsafe.Pointer(ptr)) = bits
- return Value{typ, ptr, 0, f | flagIndir | flag(typ.Kind())<<flagKindShift}
- }
- var s uintptr
- switch typ.size {
- case 1:
- *(*uint8)(unsafe.Pointer(&s)) = uint8(bits)
- case 2:
- *(*uint16)(unsafe.Pointer(&s)) = uint16(bits)
- case 4:
- *(*uint32)(unsafe.Pointer(&s)) = uint32(bits)
- case 8:
- *(*uint64)(unsafe.Pointer(&s)) = uint64(bits)
- }
- return Value{typ, nil, s, f | flag(typ.Kind())<<flagKindShift}
-}
-
-// makeFloat returns a Value of type t equal to v (possibly truncated to float32),
-// where t is a float32 or float64 type.
-func makeFloat(f flag, v float64, t Type) Value {
- typ := t.common()
- if typ.size > ptrSize {
- // Assume ptrSize >= 4, so this must be float64.
- ptr := unsafe_New(typ)
- *(*float64)(unsafe.Pointer(ptr)) = v
- return Value{typ, ptr, 0, f | flagIndir | flag(typ.Kind())<<flagKindShift}
- }
-
- var s uintptr
- switch typ.size {
- case 4:
- *(*float32)(unsafe.Pointer(&s)) = float32(v)
- case 8:
- *(*float64)(unsafe.Pointer(&s)) = v
- }
- return Value{typ, nil, s, f | flag(typ.Kind())<<flagKindShift}
-}
-
-// makeComplex returns a Value of type t equal to v (possibly truncated to complex64),
-// where t is a complex64 or complex128 type.
-func makeComplex(f flag, v complex128, t Type) Value {
- typ := t.common()
- if typ.size > ptrSize {
- ptr := unsafe_New(typ)
- switch typ.size {
- case 8:
- *(*complex64)(unsafe.Pointer(ptr)) = complex64(v)
- case 16:
- *(*complex128)(unsafe.Pointer(ptr)) = v
- }
- return Value{typ, ptr, 0, f | flagIndir | flag(typ.Kind())<<flagKindShift}
- }
-
- // Assume ptrSize <= 8 so this must be complex64.
- var s uintptr
- *(*complex64)(unsafe.Pointer(&s)) = complex64(v)
- return Value{typ, nil, s, f | flag(typ.Kind())<<flagKindShift}
-}
-
-func makeString(f flag, v string, t Type) Value {
- ret := New(t).Elem()
- ret.SetString(v)
- ret.flag = ret.flag&^flagAddr | f
- return ret
-}
-
-func makeBytes(f flag, v []byte, t Type) Value {
- ret := New(t).Elem()
- ret.SetBytes(v)
- ret.flag = ret.flag&^flagAddr | f
- return ret
-}
-
-func makeRunes(f flag, v []rune, t Type) Value {
- ret := New(t).Elem()
- ret.setRunes(v)
- ret.flag = ret.flag&^flagAddr | f
- return ret
-}
-
-// These conversion functions are returned by convertOp
-// for classes of conversions. For example, the first function, cvtInt,
-// takes any value v of signed int type and returns the value converted
-// to type t, where t is any signed or unsigned int type.
-
-// convertOp: intXX -> [u]intXX
-func cvtInt(v Value, t Type) Value {
- return makeInt(v.flag&flagRO, uint64(v.Int()), t)
-}
-
-// convertOp: uintXX -> [u]intXX
-func cvtUint(v Value, t Type) Value {
- return makeInt(v.flag&flagRO, v.Uint(), t)
-}
-
-// convertOp: floatXX -> intXX
-func cvtFloatInt(v Value, t Type) Value {
- return makeInt(v.flag&flagRO, uint64(int64(v.Float())), t)
-}
-
-// convertOp: floatXX -> uintXX
-func cvtFloatUint(v Value, t Type) Value {
- return makeInt(v.flag&flagRO, uint64(v.Float()), t)
-}
-
-// convertOp: intXX -> floatXX
-func cvtIntFloat(v Value, t Type) Value {
- return makeFloat(v.flag&flagRO, float64(v.Int()), t)
-}
-
-// convertOp: uintXX -> floatXX
-func cvtUintFloat(v Value, t Type) Value {
- return makeFloat(v.flag&flagRO, float64(v.Uint()), t)
-}
-
-// convertOp: floatXX -> floatXX
-func cvtFloat(v Value, t Type) Value {
- return makeFloat(v.flag&flagRO, v.Float(), t)
-}
-
-// convertOp: complexXX -> complexXX
-func cvtComplex(v Value, t Type) Value {
- return makeComplex(v.flag&flagRO, v.Complex(), t)
-}
-
-// convertOp: intXX -> string
-func cvtIntString(v Value, t Type) Value {
- return makeString(v.flag&flagRO, string(v.Int()), t)
-}
-
-// convertOp: uintXX -> string
-func cvtUintString(v Value, t Type) Value {
- return makeString(v.flag&flagRO, string(v.Uint()), t)
-}
-
-// convertOp: []byte -> string
-func cvtBytesString(v Value, t Type) Value {
- return makeString(v.flag&flagRO, string(v.Bytes()), t)
-}
-
-// convertOp: string -> []byte
-func cvtStringBytes(v Value, t Type) Value {
- return makeBytes(v.flag&flagRO, []byte(v.String()), t)
-}
-
-// convertOp: []rune -> string
-func cvtRunesString(v Value, t Type) Value {
- return makeString(v.flag&flagRO, string(v.runes()), t)
-}
-
-// convertOp: string -> []rune
-func cvtStringRunes(v Value, t Type) Value {
- return makeRunes(v.flag&flagRO, []rune(v.String()), t)
-}
-
-// convertOp: direct copy
-func cvtDirect(v Value, typ Type) Value {
- f := v.flag
- t := typ.common()
- ptr := v.ptr
- if f&flagAddr != 0 {
- // indirect, mutable word - make a copy
- c := unsafe_New(t)
- memmove(c, ptr, t.size)
- ptr = c
- f &^= flagAddr
- }
- return Value{t, ptr, v.scalar, v.flag&flagRO | f} // v.flag&flagRO|f == f?
-}
-
-// convertOp: concrete -> interface
-func cvtT2I(v Value, typ Type) Value {
- target := new(interface{})
- x := valueInterface(v, false)
- if typ.NumMethod() == 0 {
- *target = x
- } else {
- ifaceE2I(typ.(*rtype), x, unsafe.Pointer(target))
- }
- return Value{typ.common(), unsafe.Pointer(target), 0, v.flag&flagRO | flagIndir | flag(Interface)<<flagKindShift}
-}
-
-// convertOp: interface -> interface
-func cvtI2I(v Value, typ Type) Value {
- if v.IsNil() {
- ret := Zero(typ)
- ret.flag |= v.flag & flagRO
- return ret
- }
- return cvtT2I(v.Elem(), typ)
-}
-
-// implemented in ../pkg/runtime
-func chancap(ch unsafe.Pointer) int
-func chanclose(ch unsafe.Pointer)
-func chanlen(ch unsafe.Pointer) int
-
-//go:noescape
-func chanrecv(t *rtype, ch unsafe.Pointer, nb bool, val unsafe.Pointer) (selected, received bool)
-
-//go:noescape
-func chansend(t *rtype, ch unsafe.Pointer, val unsafe.Pointer, nb bool) bool
-
-func makechan(typ *rtype, size uint64) (ch unsafe.Pointer)
-func makemap(t *rtype) (m unsafe.Pointer)
-func mapaccess(t *rtype, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
-func mapassign(t *rtype, m unsafe.Pointer, key, val unsafe.Pointer)
-func mapdelete(t *rtype, m unsafe.Pointer, key unsafe.Pointer)
-func mapiterinit(t *rtype, m unsafe.Pointer) unsafe.Pointer
-func mapiterkey(it unsafe.Pointer) (key unsafe.Pointer)
-func mapiternext(it unsafe.Pointer)
-func maplen(m unsafe.Pointer) int
-
-func call(fn, arg unsafe.Pointer, n uint32, retoffset uint32)
-func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer)
-
-// Dummy annotation marking that the value x escapes,
-// for use in cases where the reflect code is so clever that
-// the compiler cannot follow.
-func escapes(x interface{}) {
- if dummy.b {
- dummy.x = x
- }
-}
-
-var dummy struct {
- b bool
- x interface{}
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-13 22:13:35 +0000