57dad9342a
* proc: make some type casts less counterintuitive The interaction of type casts with load configuration is sometimes counterintuitive. This commit changes the way it is performed so that when converting slices to strings and vice versa the maximum size corresponding to the target type is used (i.e. MaxStringLen when converting slices to strings and MaxArrayValues when converting slices to strings). This doesn't fully solve the problem (conversions to []rune are problematic and multiple chained type casts will still be confusing) but removes the problem for the majority of practical uses. Fixes #3595, #3539
409 lines
9.3 KiB
Go
409 lines
9.3 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"go/constant"
|
|
"math"
|
|
"os"
|
|
"reflect"
|
|
"runtime"
|
|
"time"
|
|
"unsafe"
|
|
)
|
|
|
|
type Byte byte
|
|
type String string
|
|
|
|
type astruct struct {
|
|
A int
|
|
B int
|
|
}
|
|
|
|
type astructName1 astruct
|
|
type astructName2 astruct
|
|
|
|
type bstruct struct {
|
|
a astruct
|
|
}
|
|
|
|
type cstruct struct {
|
|
pb *bstruct
|
|
sa []*astruct
|
|
}
|
|
|
|
type a struct {
|
|
aas []a
|
|
}
|
|
|
|
type A struct {
|
|
val int
|
|
}
|
|
|
|
type C struct {
|
|
s string
|
|
}
|
|
|
|
type B struct {
|
|
A
|
|
*C
|
|
a A
|
|
ptr *A
|
|
}
|
|
|
|
type D struct {
|
|
u1, u2, u3, u4, u5, u6 uint32
|
|
}
|
|
|
|
func afunc(x int) int {
|
|
return x + 2
|
|
}
|
|
|
|
func afunc1(x int) {
|
|
}
|
|
|
|
func afunc2() int {
|
|
return 0
|
|
}
|
|
|
|
type functype func(int) int
|
|
|
|
func (a *astruct) Error() string {
|
|
return "not an error"
|
|
}
|
|
|
|
func (a astruct) NonPointerReceiverMethod() {
|
|
return
|
|
}
|
|
|
|
func (b *bstruct) Error() string {
|
|
return "not an error"
|
|
}
|
|
|
|
type dstruct struct {
|
|
x interface{}
|
|
}
|
|
|
|
type maptype map[string]interface{}
|
|
|
|
type benchstruct struct {
|
|
a [64]byte
|
|
b [64]byte
|
|
}
|
|
|
|
type Item struct {
|
|
Name string
|
|
Route string
|
|
Active int
|
|
}
|
|
|
|
type Menu []Item
|
|
|
|
type truncatedMap struct {
|
|
v []map[string]astruct
|
|
}
|
|
|
|
type Cache struct {
|
|
blocks [2000]Block
|
|
}
|
|
|
|
type Block struct {
|
|
cache *Cache
|
|
}
|
|
|
|
type List struct {
|
|
N int
|
|
Next *List
|
|
}
|
|
|
|
type T struct {
|
|
F string
|
|
}
|
|
|
|
type W1 struct {
|
|
T
|
|
}
|
|
|
|
func (*W1) M() {}
|
|
|
|
type I interface{ M() }
|
|
|
|
type W2 struct {
|
|
W1
|
|
T
|
|
}
|
|
|
|
type W3 struct {
|
|
I
|
|
T
|
|
}
|
|
|
|
type W4 struct {
|
|
I
|
|
}
|
|
|
|
type W5 struct {
|
|
*W5
|
|
}
|
|
|
|
type ThreeInts struct {
|
|
a, b, c int
|
|
}
|
|
|
|
var _ I = (*W2)(nil)
|
|
|
|
type pptr *pptr
|
|
|
|
func main() {
|
|
i1 := 1
|
|
i2 := 2
|
|
f1 := 3.0
|
|
i3 := 3
|
|
p1 := &i1
|
|
pp1 := &p1
|
|
s1 := []string{"one", "two", "three", "four", "five"}
|
|
s3 := make([]int, 0, 6)
|
|
a0 := [0]int{}
|
|
a1 := [5]string{"one", "two", "three", "four", "five"}
|
|
c1 := cstruct{&bstruct{astruct{1, 2}}, []*astruct{&astruct{1, 2}, &astruct{2, 3}, &astruct{4, 5}}}
|
|
s2 := []astruct{{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {11, 12}, {13, 14}, {15, 16}}
|
|
p2 := &(c1.sa[2].B)
|
|
as1 := astruct{1, 1}
|
|
var p3 *int
|
|
str1 := "01234567890"
|
|
var fn1 functype = afunc
|
|
var fn2 functype = nil
|
|
var nilslice []int = nil
|
|
var nilptr *int = nil
|
|
ch1 := make(chan int, 11)
|
|
ch1 <- 1
|
|
ch1 <- 4
|
|
ch1 <- 3
|
|
ch1 <- 2
|
|
var chnil chan int = nil
|
|
m1 := map[string]astruct{
|
|
"Malone": astruct{2, 3},
|
|
"Adenauer": astruct{},
|
|
"squadrons": astruct{},
|
|
"quintuplets": astruct{},
|
|
"parasite": astruct{},
|
|
"wristwatches": astruct{},
|
|
"flashgun": astruct{},
|
|
"equivocally": astruct{},
|
|
"sweetbrier": astruct{},
|
|
"idealism": astruct{},
|
|
"tangos": astruct{},
|
|
"alterable": astruct{},
|
|
"quaffing": astruct{},
|
|
"arsenic": astruct{},
|
|
"coincidentally": astruct{},
|
|
"hindrances": astruct{},
|
|
"zoning": astruct{},
|
|
"egging": astruct{},
|
|
"inserts": astruct{},
|
|
"adaptive": astruct{},
|
|
"orientations": astruct{},
|
|
"periling": astruct{},
|
|
"lip": astruct{},
|
|
"chant": astruct{},
|
|
"availing": astruct{},
|
|
"fern": astruct{},
|
|
"flummoxes": astruct{},
|
|
"meanders": astruct{},
|
|
"ravenously": astruct{},
|
|
"reminisce": astruct{},
|
|
"snorkel": astruct{},
|
|
"gutters": astruct{},
|
|
"jibbed": astruct{},
|
|
"tiara": astruct{},
|
|
"takers": astruct{},
|
|
"animates": astruct{},
|
|
"Zubenelgenubi": astruct{},
|
|
"bantering": astruct{},
|
|
"tumblers": astruct{},
|
|
"horticulturists": astruct{},
|
|
"thallium": astruct{},
|
|
"capital": astruct{},
|
|
"paramese": astruct{},
|
|
"vaccinationist": astruct{},
|
|
"shadrach": astruct{},
|
|
"unsincereness": astruct{},
|
|
"undazzled": astruct{},
|
|
"heautomorphism": astruct{},
|
|
"undermeasure": astruct{},
|
|
"intentionally": astruct{},
|
|
"glycine": astruct{},
|
|
"basiliscine": astruct{},
|
|
"preinvolvement": astruct{},
|
|
"adversaria": astruct{},
|
|
"capocchia": astruct{},
|
|
"annunciable": astruct{},
|
|
"unguidableness": astruct{},
|
|
"prankster": astruct{},
|
|
"jagless": astruct{},
|
|
"hormonal": astruct{},
|
|
"crenature": astruct{},
|
|
"unfluttering": astruct{},
|
|
"councilmanic": astruct{},
|
|
"Micraster": astruct{},
|
|
"raphidiferous": astruct{},
|
|
"groomer": astruct{},
|
|
}
|
|
var mnil map[string]astruct = nil
|
|
m2 := map[int]*astruct{1: &astruct{10, 11}}
|
|
m3 := map[astruct]int{{1, 1}: 42, {2, 2}: 43}
|
|
m4 := map[astruct]astruct{{1, 1}: {11, 11}, {2, 2}: {22, 22}}
|
|
upnil := unsafe.Pointer(nil)
|
|
up1 := unsafe.Pointer(&i1)
|
|
i4 := 800
|
|
i5 := -3
|
|
i6 := -500
|
|
var err1 error = c1.sa[0]
|
|
var err2 error = c1.pb
|
|
var errnil error = nil
|
|
var psa *astruct = nil
|
|
var errtypednil error = psa
|
|
var iface1 interface{} = c1.sa[0]
|
|
var iface2 interface{} = "test"
|
|
var iface3 interface{} = map[string]constant.Value{}
|
|
var iface4 interface{} = []constant.Value{constant.MakeInt64(4)}
|
|
var ifacenil interface{} = nil
|
|
arr1 := [4]int{0, 1, 2, 3}
|
|
parr := &arr1
|
|
cpx1 := complex(1, 2)
|
|
const1 := constant.MakeInt64(3)
|
|
recursive1 := dstruct{}
|
|
recursive1.x = &recursive1
|
|
var iface5 interface{} = &recursive1
|
|
var iface2fn1 interface{} = afunc1
|
|
var iface2fn2 interface{} = afunc2
|
|
var mapinf maptype = map[string]interface{}{}
|
|
mapinf["inf"] = mapinf
|
|
var bencharr [64]benchstruct
|
|
var benchparr [64]*benchstruct
|
|
var issue1578 Block
|
|
mainMenu := Menu{
|
|
{Name: "home", Route: "/", Active: 1},
|
|
{Name: "About", Route: "/about", Active: 1},
|
|
{Name: "Login", Route: "/login", Active: 1},
|
|
}
|
|
var aas = []a{{nil}}
|
|
aas[0].aas = aas
|
|
b := B{A: A{-314}, C: &C{"hello"}, a: A{42}, ptr: &A{1337}}
|
|
b2 := B{A: A{42}, a: A{47}}
|
|
var sd D
|
|
|
|
ifacearr := []error{&astruct{}, nil}
|
|
efacearr := []interface{}{&astruct{}, "test", nil}
|
|
|
|
var mapanonstruct1 map[string]struct{}
|
|
var anonstruct1 struct{ val constant.Value }
|
|
var anonstruct2 struct{ i, j int }
|
|
var anoniface1 interface {
|
|
SomeFunction(struct{ val constant.Value })
|
|
OtherFunction(i, j int)
|
|
}
|
|
var anonfunc func(a struct{ i int }, b interface{}, c struct{ val constant.Value })
|
|
|
|
for i := range benchparr {
|
|
benchparr[i] = &benchstruct{}
|
|
}
|
|
|
|
ni8 := int8(-5)
|
|
ni16 := int16(-5)
|
|
ni32 := int32(-5)
|
|
ni64 := int64(-5)
|
|
|
|
pinf := math.Inf(+1)
|
|
ninf := math.Inf(-1)
|
|
nan := math.NaN()
|
|
|
|
var iface6 interface{}
|
|
var ptrinf *interface{}
|
|
iface6 = &ptrinf
|
|
ptrinf = &iface6
|
|
|
|
sliceinf := make([]interface{}, 1)
|
|
sliceinf[0] = sliceinf
|
|
|
|
zsvar := struct{}{}
|
|
zsslice := make([]struct{}, 3)
|
|
zsvmap := map[string]struct{}{"testkey": struct{}{}}
|
|
var tm truncatedMap
|
|
tm.v = []map[string]astruct{m1}
|
|
var rettm = func() truncatedMap { return tm }
|
|
|
|
emptyslice := []string{}
|
|
emptymap := make(map[string]string)
|
|
|
|
byteslice := []byte{116, 195, 168, 115, 116}
|
|
bytestypeslice := []Byte{116, 195, 168, 115, 116}
|
|
runeslice := []rune{116, 232, 115, 116}
|
|
|
|
bytearray := [5]byte{116, 195, 168, 115, 116}
|
|
bytetypearray := [5]Byte{116, 195, 168, 115, 116}
|
|
runearray := [4]rune{116, 232, 115, 116}
|
|
|
|
longstr := "very long string 0123456789a0123456789b0123456789c0123456789d0123456789e0123456789f0123456789g012345678h90123456789i0123456789j0123456789"
|
|
longbyteslice := []byte(longstr)
|
|
m5 := map[C]int{{longstr}: 1}
|
|
m6 := map[string]int{longstr: 123}
|
|
m7 := map[C]C{{longstr}: {"hello"}}
|
|
cl := C{s: longstr}
|
|
var nilstruct *astruct = nil
|
|
|
|
val := A{val: 1} // val vs val.val
|
|
var as2 astruct
|
|
s4 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
|
|
|
|
var iface2map interface{} = map[string]interface{}{
|
|
"a": map[string]interface{}{
|
|
"1": map[string]interface{}{
|
|
"x": 1,
|
|
"y": 2,
|
|
},
|
|
},
|
|
}
|
|
|
|
ll := &List{0, &List{1, &List{2, &List{3, &List{4, nil}}}}}
|
|
unread := (*int)(unsafe.Pointer(uintptr(12345)))
|
|
|
|
w2 := &W2{W1{T{"T-inside-W1"}}, T{"T-inside-W2"}}
|
|
w3 := &W3{&W1{T{"T-inside-W1"}}, T{"T-inside-W3"}}
|
|
w4 := &W4{&W1{T{"T-inside-W1"}}}
|
|
w5 := &W5{nil}
|
|
w5.W5 = w5
|
|
|
|
os.Setenv("TZ", "UTC")
|
|
tim1 := time.Unix(233431200, 0).UTC()
|
|
loc, _ := time.LoadLocation("America/Mazatlan")
|
|
tim2, _ := time.ParseInLocation("2006-01-02 15:04:05", "2022-06-07 02:03:04", loc)
|
|
typedstringvar := String("blah")
|
|
namedA1 := astructName1{12, 45}
|
|
namedA2 := astructName2{13, 46}
|
|
|
|
badslice := []int{1, 2, 3}
|
|
h := (*reflect.SliceHeader)(unsafe.Pointer(&badslice))
|
|
h.Data = 0
|
|
tim3 := time.Date(300000, 1, 1, 0, 0, 0, 0, time.Local)
|
|
|
|
int3chan := make(chan ThreeInts, 5)
|
|
int3chan <- ThreeInts{a: 1}
|
|
int3chan <- ThreeInts{a: 2}
|
|
int3chan <- ThreeInts{a: 3}
|
|
|
|
var ptrinf2 pptr
|
|
ptrinf2 = &ptrinf2
|
|
|
|
var amb1 = 1
|
|
runtime.Breakpoint()
|
|
for amb1 := 0; amb1 < 10; amb1++ {
|
|
fmt.Println(amb1)
|
|
}
|
|
|
|
longarr := [100]int{}
|
|
longslice := make([]int, 100, 100)
|
|
|
|
runtime.Breakpoint()
|
|
fmt.Println(i1, i2, i3, p1, pp1, amb1, s1, s3, a0, a1, p2, p3, s2, as1, str1, f1, fn1, fn2, nilslice, nilptr, ch1, chnil, m1, mnil, m2, m3, m4, m5, upnil, up1, i4, i5, i6, err1, err2, errnil, iface1, iface2, ifacenil, arr1, parr, cpx1, const1, iface3, iface4, recursive1, recursive1.x, iface5, iface2fn1, iface2fn2, bencharr, benchparr, mapinf, mainMenu, b, b2, sd, anonstruct1, anonstruct2, anoniface1, anonfunc, mapanonstruct1, ifacearr, efacearr, ni8, ni16, ni32, ni64, pinf, ninf, nan, zsvmap, zsslice, zsvar, tm, rettm, errtypednil, emptyslice, emptymap, byteslice, bytestypeslice, runeslice, bytearray, bytetypearray, runearray, longstr, nilstruct, as2, as2.NonPointerReceiverMethod, s4, iface2map, issue1578, ll, unread, w2, w3, w4, w5, longarr, longslice, val, m6, m7, cl, tim1, tim2, typedstringvar, namedA1, namedA2, astructName1(namedA2), badslice, tim3, int3chan, longbyteslice)
|
|
}
|