errors.As fails for interpreted concrete error types due to reflect/type identity mismatch

package main

  import (
  	"fmt"

  	"github.com/traefik/yaegi/interp"
  	"github.com/traefik/yaegi/stdlib"
  )

  func main() {
  	i := interp.New(interp.Options{})
  	i.Use(stdlib.Symbols)

  	src := "" +
  		"import (\"errors\"; \"fmt\")\n" +
  		"type MyErr struct{}\n" +
  		"func (e *MyErr) Error() string { return \"x\" }\n" +
  		"func F() bool {\n" +
  		"  err := fmt.Errorf(\"wrap: %w\", &MyErr{})\n" +
  		"  var target *MyErr\n" +
  		"  return errors.As(err, &target)\n" +
  		"}\n"

  	if _, err := i.Eval(src); err != nil {
  		panic(err)
  	}
  	v, err := i.Eval("F()")
  	fmt.Printf("v=%v err=%v\n", v, err)
  }

errors.As should behave like compiled Go for interpreted error types.

  In the repro:
  - errors.As(fmt.Errorf("wrap: %w", &MyErr{}), &target)
  should return true
  - target should be set to the wrapped *MyErr
  - no panic/error should occur

errors.As does not match compiled Go behavior.

  In the repro:
  - errors.As(fmt.Errorf("wrap: %w", &MyErr{}), &target)
  does not return true
  - instead evaluation fails with:
    errors: *target must be interface or implement error