Make bound methods for built in types work properly

Author: ncw

notes.txt

@@ -111,3 +111,38 @@ Introspect methods by looking at all public methods
 Transform the names, so that initial "M__" becomes "__" then lowercase
 the method. Only if the method matches one of the defined function types will it be exported.
 FIXME meta data for help would be nice?  How attache metadata to go function?
+
+Introspection idea
+==================
+
+	var method string
+	if strings.HasPrefix(key, "_") {
+		method = "M" + key
+	} else {
+		method = strings.Title(key)
+	}
+	fmt.Printf("*** looking for method %q (key %q)\n", method, key)
+	r := reflect.TypeOf(self)
+	if m, ok := r.MethodByName(method); ok {
+		fmt.Printf("*** m = %#v\n", m.Func)
+		fmt.Printf("*** type = %#v\n", m.Func.Type())
+
+		var fptr func(Object) Object
+
+		// fptr is a pointer to a function.
+		// Obtain the function value itself (likely nil) as a reflect.Value
+		// so that we can query its type and then set the value.
+		fn := reflect.ValueOf(fptr).Elem()
+
+		// Make a function of the right type.
+		v := reflect.MakeFunc(fn.Type(), m.Func)
+
+		// Assign it to the value fn represents.
+		fn.Set(v)
+
+		fmt.Printf("fptr = %v\n", fptr)
+
+	} else {
+		fmt.Printf("*** method not found\n")
+	}
+

py/boundmethod.go

@@ -24,6 +24,16 @@ func NewBoundMethod(self, method Object) *BoundMethod {
 
 // Call the bound method
 func (bm *BoundMethod) M__call__(args Tuple, kwargs StringDict) Object {
+	// Call built in methods slightly differently
+	// FIXME not sure this is sensible! something is wrong with the call interface
+	// as we aren't sure whether to call it with a self or not
+	if m, ok := bm.Method.(*Method); ok {
+		if kwargs != nil {
+			return m.CallWithKeywords(bm.Self, args, kwargs)
+		} else {
+			return m.Call(bm.Self, args)
+		}
+	}
 	newArgs := make(Tuple, len(args)+1)
 	newArgs[0] = bm.Self
 	copy(newArgs[1:], args)

py/internal.go

@@ -150,6 +150,11 @@ func GetAttrOrNil(self Object, key string) (res Object) {
 			goto found
 		}
 	} else {
+		// Now look in type's dictionary etc
+		res = self.Type().NativeGetAttrOrNil(key)
+		if res != nil {
+			goto found
+		}
 		// FIXME introspection for M__methods__ on non *Type objects
 	}
 

py/method.go

@@ -64,7 +64,7 @@ type Method struct {
 	Doc string
 	// Flags - see METH_* flags
 	Flags int
-	// C function implementation
+	// Go function implementation
 	method interface{}
 }
 
@@ -109,9 +109,10 @@ func (m *Method) Call(self Object, args Tuple) Object {
 		}
 		return f(self)
 	case func(Object, Object) Object:
+		fmt.Printf("*** CALL %v %v\n", self, args)
 		if len(args) != 1 {
 			// FIXME type error
-			panic(fmt.Sprintf("TypeError: %s() takes exactly 1 argument (%d given)", m.Name, len(args)))
+			panic(fmt.Sprintf("FOO TypeError: %s() takes exactly 1 argument (%d given)", m.Name, len(args)))
 		}
 		return f(self, args[0])
 	}

py/type.go

@@ -204,6 +204,7 @@ func NewType(Name string, Doc string) *Type {
 		ObjectType: TypeType,
 		Name:       Name,
 		Doc:        Doc,
+		Dict:       StringDict{},
 	}
 	//t.Ready()
 	return t
@@ -219,6 +220,7 @@ func NewTypeX(Name string, Doc string, New NewFunc, Init InitFunc) *Type {
 		Doc:        Doc,
 		New:        New,
 		Init:       Init,
+		Dict:       StringDict{},
 	}
 	//t.Ready()
 	return t
@@ -243,6 +245,7 @@ func (t *Type) NewTypeFlags(Name string, Doc string, New NewFunc, Init InitFunc,
 		New:        New,
 		Init:       Init,
 		Flags:      Flags,
+		Dict:       StringDict{},
 	}
 	//tt.Ready()
 	return tt
@@ -386,6 +389,26 @@ func (t *Type) Lookup(name string) Object {
 	return res
 }
 
+// Get an attribute from the type of a go type
+//
+// Doesn't call __getattr__ etc
+//
+// Returns nil if not found
+//
+// Doesn't look in the instance dictionary
+//
+// FIXME this isn't totally correct!
+// as we are ignoring getattribute etc
+// See _PyObject_GenericGetAttrWithDict in object.c
+func (t *Type) NativeGetAttrOrNil(name string) Object {
+	// Look in type Dict
+	if res, ok := t.Dict[name]; ok {
+		return res
+	}
+	// Now look through base classes etc
+	return t.Lookup(name)
+}
+
 // Get an attribute from the type
 //
 // Doesn't call __getattr__ etc