recursive type error cases: call of reflect.Value.Interface on zero Value

[flamelx]

case

package main

import (
	"github.com/cosmos72/gomacro/fast"
)

func main() {
	// case1() // as expected
	// case2() // panic: reflect: call of reflect.Value.Interface on zero Value
	// case3() // panic: reflect: call of reflect.Value.Interface on zero Value
	// case4() // as expected
	// case5() // panic: reflect: call of reflect.Value.Interface on zero Value
	// case6() // as expected
	// case7() // as expected
}
func case1(){
	type RR struct {
		// A *RR diff
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script:=`func Execute()([]*RR,error){
			return nil,nil
		}`
	interp.Eval(script)
}

func case2(){
	type RR struct {
		A *RR // diff
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script:=`func Execute()([]*RR,error){
			return nil,nil
		}`
	interp.Eval(script)
}

func case3(){
	type RR struct {
		A *RR
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script:=`func Execute()[]*RR{ // diff
			return nil
		}`
	interp.Eval(script)
}

func case4(){
	type RR struct {
		A *RR
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script:=`func Execute()[]*RR{ // diff
			var rr []*RR
			return rr
		}`
	interp.Eval(script)
}

func case5(){
	type RR struct {
		A *RR
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script:=`func Execute()([]*RR, error){ // diff
			var rr []*RR 
			return rr,nil
		}`
	interp.Eval(script)
}

func case6(){
	type RR struct {
		A *RR
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script:=`func Execute()(*RR, error){ // diff
			var rr *RR 
			return rr,nil
		}`
	interp.Eval(script)
}

func case7(){
	type RR struct {
		A *RR
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script:=`import "fmt"
	func Execute()([]*RR, error){ // diff
			var rr []*RR 
			return rr,fmt.Errorf("1")
		}`
	interp.Eval(script)
}

description

hi, firstly thank you for a great go interpreter, secondly I encountered unexpected errors while writing case5 above. Here I have made more attempts to give the above example and look forward to your reply.

[cosmos72]

Thanks for spotting this!

The Go package reflect has some missing features - namely, it cannot create new recursive types, new interfaces or new named types at runtime.
Gomacro has a package github.com/cosmos72/gomacro/xreflect which emulates such missing features, but it's really complicated and error-prone.
The bugs you found are in such package - I will need some time to find a way to fix them without introducing regressions,
and (possibly) without further complicating it.

[cosmos72]

Update: to be precise, there's a flag OptIncomplete that is set in a named type while constructing it.
The flag gets cleared once the named type is complete, but related types (such as pointers to the named type) created while the type is not yet complete, inherit the flag but don't clear it once the named type is completed.
It's a classic cache invalidation bug.

[cosmos72]

Fixed in commit 1f88d82
Also, commit af24dc3 adds a test for this issue, to detect any future regression

[flamelx]

Great! Thank a million for the prompt fix.

[flamelx]

func case8() {
	type RR struct {
		A []*RR // diff
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script := `func Execute()([]*RR,error){
			return nil,nil
		}`
	interp.Eval(script)
}

@cosmos72 The problem still occurs when a field is a slice. Could you help to see it again?

[flamelx]

func case8() {
	type RR struct {
		A []*RR // diff
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script := `func Execute()([]*RR,error){
			return nil,nil
		}`
	interp.Eval(script)
}

@cosmos72 The problem still occurs when a field is a slice. Could you help to see it again? :p~

func case9() {
	type RR struct {
		A []*RR // diff
		B int
	}
	interp := fast.New()
	interp.DeclType(interp.Comp.TypeOf(RR{}))
	script := `func Execute()[]*RR{ 
			var rr []*RR
                         r:=&RR{} // r:=&RR{B:1} success
                         rr=append(rr,r)
			return rr
		}`
	interp.Eval(script)
	v, _ := interp.Eval("Execute()")
        // reflect.Value.Convert: value of type []xreflect.Forward cannot be converted to type []*RR
	v[0].Convert(reflect.TypeOf([]*RR{}))
        // success
	v[0].Index(0).Convert(reflect.TypeOf(&RR{}))
}

This is another issue.