reflect.Type.NumMethod() returns 0 for interface types, impacting CBOR unmarshalling

[frenkel26]

Description

It appears that reflect.Type.NumMethod() returns 0 when called on interface types. This behavior is particularly problematic for functionalities like CBOR unmarshalling that rely on NumMethod() for type resolution.

Potential Source of Issue

This issue may stem from changes made in the following commit: acba074
The relevant code is:

var numMethods int
if hasMethodSet {
  for i := 0; i < ms.Len(); i++ {
    if ms.At(i).Obj().Exported() {
      numMethods++
    }
  }
}

Here, numMethods is incremented only under the hasMethodSet condition, which is set to false if the type is an interface. This might not be the intended functionality.

Example of Affected Code

package main

import (
	"fmt"

	"github.com/fxamacker/cbor/v2"
)

type Marshallable interface {
	MarshalBinary() ([]byte, error)
	UnmarshalBinary(data []byte) error
}

type A struct {
	Data []byte
}

func (a *A) MarshalBinary() ([]byte, error) {
	return a.Data, nil
}

func (a *A) UnmarshalBinary(data []byte) error {
	a.Data = data
	return nil
}

type Message struct {
	SomeMarshallable Marshallable
}

func runMarshalUnmarshal() error {
	messageToMarshal := Message{
		SomeMarshallable: &A{Data: []byte("hello")},
	}

	// Marshal
	msgBytes, err := cbor.Marshal(messageToMarshal)
	if err != nil {
		return err
	}

	// Initiate with concrete type
	messageFromUnmarshal := Message{
		SomeMarshallable: &A{},
	}

	// Unmarshal
	err = cbor.Unmarshal(msgBytes, &messageFromUnmarshal)
	if err != nil {
		return err
	}

	// Print type of Marshallable
	fmt.Printf("%T\n", messageFromUnmarshal.SomeMarshallable)
	return nil
}

func main() {
	err := runMarshalUnmarshal()
	if err != nil {
		panic(err)
	}
}

Expected Behavior

The code above is expected to print the type *main.A but instead it prints []uint8. Removing the if hasMethodSet condition from the code reference above results with the desired behavior.