Add support for interface methods

Author: antonmedv

checker/checker.go

@@ -319,7 +319,7 @@ func (v *visitor) SliceNode(node *ast.SliceNode) reflect.Type {
 
 func (v *visitor) FunctionNode(node *ast.FunctionNode) reflect.Type {
 	if f, ok := v.types[node.Name]; ok {
-		if fn, ok := funcType(f.Type); ok {
+		if fn, ok := isFuncType(f.Type); ok {
 			if isInterface(fn) {
 				return interfaceType
 			}
@@ -378,7 +378,7 @@ func (v *visitor) FunctionNode(node *ast.FunctionNode) reflect.Type {
 func (v *visitor) MethodNode(node *ast.MethodNode) reflect.Type {
 	t := v.visit(node.Node)
 	if f, method, ok := methodType(t, node.Method); ok {
-		if fn, ok := funcType(f); ok {
+		if fn, ok := isFuncType(f); ok {
 			if isInterface(fn) {
 				return interfaceType
 			}

checker/checker_test.go

@@ -54,7 +54,9 @@ func TestVisitor_MethodNode(t *testing.T) {
 				+ Var.Any(true) 
 				+ Var.Get() 
 				+ Var.Sub(3)
-				+ (Duration.String() == "" ? 1 : 0)`
+				+ (Duration.String() == "" ? 1 : 0)
+				+ Interface.Method(0)
+				+ Tickets[0].Method(0)`
 
 	tree, err := parser.Parse(input)
 	assert.NoError(t, err)
@@ -102,11 +104,12 @@ func TestCheck_AsBool(t *testing.T) {
 
 type mockEnv struct {
 	*mockEmbed
-	Add      func(int64) int64
-	Any      interface{}
-	Var      *mockVar
-	Tickets  []mockTicket
-	Duration time.Duration
+	Add       func(int64) int64
+	Any       interface{}
+	Var       *mockVar
+	Tickets   []mockTicket
+	Duration  time.Duration
+	Interface mockInterface
 }
 
 func (f *mockEnv) Set(v int64, any interface{}) int64 {
@@ -132,11 +135,19 @@ func (*mockVar) Set(v int64, f float64) int64 {
 	return 0
 }
 
+type mockInterface interface {
+	Method(int) int
+}
+
 type mockTicket struct {
 	Price  int
 	Origin string
 }
 
+func (t mockTicket) Method(int) int {
+	return 0
+}
+
 // Other tests.
 
 func TestCheck(t *testing.T) {

checker/types.go

@@ -235,9 +235,13 @@ func methodType(t reflect.Type, name string) (reflect.Type, bool, bool) {
 	if t != nil {
 		// First, check methods defined on type itself,
 		// independent of which type it is.
-		for i := 0; i < t.NumMethod(); i++ {
-			m := t.Method(i)
-			if m.Name == name {
+		if m, ok := t.MethodByName(name); ok {
+			if t.Kind() == reflect.Interface {
+				// In case of interface type method will not have a receiver,
+				// and to prevent checker decreasing numbers of in arguments
+				// return method type as not method (second argument is false).
+				return m.Type, false, true
+			} else {
 				return m.Type, true, true
 			}
 		}
@@ -292,7 +296,7 @@ func indexType(ntype reflect.Type) (reflect.Type, bool) {
 	return nil, false
 }
 
-func funcType(ntype reflect.Type) (reflect.Type, bool) {
+func isFuncType(ntype reflect.Type) (reflect.Type, bool) {
 	ntype = dereference(ntype)
 	if ntype == nil {
 		return nil, false
@@ -308,10 +312,6 @@ func funcType(ntype reflect.Type) (reflect.Type, bool) {
 	return nil, false
 }
 
-func integerTypeWeight(t reflect.Type) uint {
-	return uint(t.Kind())
-}
-
 func isIntegerOrArithmeticOperation(node ast.Node) bool {
 	switch n := node.(type) {
 	case *ast.IntegerNode: