when "new" and "make" structure, field will not be zero value.

[For-ACGN]

test code:

type FooStruct struct {
    function  func(string)
    Pointer   *int
    Slice     []string
    Map       map[string]string
    Channel   chan string
    Function  func(string)
    Interface interface{}
    Transport http.RoundTripper
    Str2      FooStruct2
    Str2p     *FooStruct2
}

type FooStruct2 struct {
    Pointer *int
}

// Println is used to check structure fields are Zero Value.
func (f *FooStruct) Println() {
    fmt.Println("func(unexported):", f.function == nil)
    fmt.Println("pointer:", f.Pointer == nil)
    fmt.Println("slice:", f.Slice == nil)
    fmt.Println("map:", f.Map == nil)
    fmt.Println("chan:", f.Channel == nil)
    fmt.Println("func:", f.Function == nil)
    fmt.Println("interface{}:", f.Interface == nil)
    fmt.Println("interface:", f.Transport == nil)
    fmt.Println("str2:", f.Str2.Pointer == nil)
    fmt.Println("str2p:", f.Str2p == nil)
    fmt.Println()
}

func TestAnkoMakeStruct(t *testing.T) {
    // Zero Value
    fs1 := new(FooStruct)
    fs1.Println()
    fs2 := FooStruct{}
    fs2.Println()

    // some fields not Zero Value
    e := env.NewEnv()
    err := e.DefineType("FooStruct", reflect.TypeOf(fs1).Elem())
    require.NoError(t, err)
    src := `
fs1 = new(FooStruct)
fs1.Println()

fs2 = make(FooStruct)
fs2.Println()
`
    stmt, err := parser.ParseSrc(src)
    require.NoError(t, err)
    _, err = vm.Run(e, nil, stmt)
    require.NoError(t, err)
}

output:

func(unexported): true
pointer: true
slice: true
map: true
chan: true
func: true
interface{}: true
interface: true
str2: true
str2p: true

func(unexported): true
pointer: true
slice: true
map: true
chan: true
func: true
interface{}: true
interface: true
str2: true
str2p: true

func(unexported): true
pointer: true
slice: false
map: false
chan: false
func: false
interface{}: true
interface: true
str2: true
str2p: true

func(unexported): true
pointer: true
slice: false
map: false
chan: false
func: false
interface{}: true
interface: true
str2: true
str2p: true

slice, map, chan and func will not be set zero value, but pointer is zero value.
it will occur some package panic like net/http.Client

// code in src/net/http
func (c *Client) checkRedirect(req *Request, via []*Request) error {
    fn := c.CheckRedirect
    if fn == nil {       // [error] in anko, this if is unexpected.
        fn = defaultCheckRedirect
    }
    return fn(req, via)
}

func TestAnkoMakeHTTPClient(t *testing.T) {
    e := env.NewEnv()

    src := `
http = import("net/http")

// must 302
url = "http://example.com/302"
req, err = http.NewRequest(http.MethodGet, url, nil)
if err != nil {
    return false, err
}
client = new(http.Client)
resp, err = client.Do(req) // will return a nil pointer error
if err != nil {
    return false, err
}

println(client.CheckRedirect == nil) // false
println(client.CheckRedirect) // invalid function

// ok
client.CheckRedirect = nil
resp, err = client.Do(req)
if err != nil {
    return false, err
}
`
    stmt, err := parser.ParseSrc(src)
    require.NoError(t, err)
    _, err = vm.Run(e, nil, stmt)
    require.NoError(t, err)
}

file anko/vm/vm.go:

line 394:

func makeValue(t reflect.Type) (reflect.Value, error) {
    switch t.Kind() {
    case reflect.Chan:
        return reflect.MakeChan(t, 0), nil
    case reflect.Func:
        return reflect.MakeFunc(t, nil), nil
    case reflect.Map:
        // note creating slice as work around to create map
        // just doing MakeMap can give incorrect type for defined types
        value := reflect.MakeSlice(reflect.SliceOf(t), 0, 1)
        value = reflect.Append(value, reflect.MakeMap(reflect.MapOf(t.Key(), t.Elem())))
        return value.Index(0), nil
    case reflect.Ptr:
        ptrV := reflect.New(t.Elem())
        v, err := makeValue(t.Elem())
        if err != nil {
            return nilValue, err
        }

        ptrV.Elem().Set(v)
        return ptrV, nil
    case reflect.Slice:
        return reflect.MakeSlice(t, 0, 0), nil
    case reflect.Struct:
         structV := reflect.New(t).Elem()
         for i := 0; i < structV.NumField(); i++ {
                        // here Pointer will be zero value, but other type is not
            if structV.Field(i).Kind() == reflect.Ptr {
                continue
            }
            v, err := makeValue(structV.Field(i).Type())
            if err != nil {
                return nilValue, err
            }
            if structV.Field(i).CanSet() {
                structV.Field(i).Set(v)
            }
         }
         return structV, nil

            // only this code is ok
        // return reflect.New(t).Elem(), nil
    }
    return reflect.New(t).Elem(), nil
}