Rework GetAttr and SetAttr and related parts

  * Add GetDict interface
  * Use it to straighten out GetAttr and SetAttr
  * Use __get__ and __set__ on functions and methods to implement bound methods properly

Author: ncw

py/function.go

@@ -38,6 +38,11 @@ func (o *Function) Type() *Type {
 	return FunctionType
 }
 
+// Get the Dict
+func (f *Function) GetDict() StringDict {
+	return f.Dict
+}
+
 // Define a new function
 //
 // Return a new function object associated with the code object
@@ -131,6 +136,16 @@ func (f *Function) M__call__(args Tuple, kwargs StringDict) Object {
 	return result
 }
 
+// Read a function from a class which makes a bound method
+func (f *Function) M__get__(instance, owner Object) Object {
+	if instance != None {
+		return NewBoundMethod(instance, f)
+	}
+	return f
+}
+
 // Make sure it satisfies the interface
 var _ Object = (*Function)(nil)
 var _ I__call__ = (*Function)(nil)
+var _ IGetDict = (*Function)(nil)
+var _ I__get__ = (*Function)(nil)

py/import.go

@@ -128,15 +128,16 @@ func ImportModuleLevelObject(nameObj, given_globals, locals, given_fromlist Obje
 		panic(ExceptionNewf(ImportError, "import of %q halted; None in sys.modules", abs_name))
 	} else if ok {
 		var value Object
+		var err error
 		initializing := false
 
 		// Optimization: only call _bootstrap._lock_unlock_module() if
 		// __initializing__ is true.
 		// NOTE: because of this, __initializing__ must be set *before*
 		// stuffing the new module in sys.modules.
 
-		value = GetAttrOrNil(mod, "__initializing__")
-		if value != nil {
+		value, err = GetAttrErr(mod, "__initializing__")
+		if err == nil {
 			initializing = bool(MakeBool(value).(Bool))
 		}
 		if initializing {

py/internal.go

@@ -123,88 +123,74 @@ func SetItem(self Object, key Object, value Object) Object {
 	panic(ExceptionNewf(TypeError, "'%s' object does not support item assignment", self.Type().Name))
 }
 
-// GetAttrOrNil - returns the result nil if attribute not found
-func GetAttrOrNil(self Object, key string) (res Object) {
+// GetAttrErr - returns the result or an err to be raised if not found
+func GetAttrErr(self Object, key string) (res Object, err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			if IsException(AttributeError, r) {
-				// AttributeError caught - return nil
+				// AttributeError caught - return nil and error
 				res = nil
+				err = r.(error)
 			} else {
 				// Propagate the exception
 				panic(r)
 			}
 		}
 	}()
 
-	// Call __getattribute unconditionally if it exists
+	// Call __getattribute__ unconditionally if it exists
 	if I, ok := self.(I__getattribute__); ok {
 		res = I.M__getattribute__(key)
-		goto found
+		return
 	} else if res, ok = TypeCall1(self, "__getattribute__", Object(String(key))); ok {
-		// FIXME catch AttributeError here
-		goto found
+		return
 	}
 
-	if t, ok := self.(*Type); ok {
-		// Now look in the instance dictionary etc
-		res = t.GetAttrOrNil(key)
-		if res != nil {
-			goto found
+	// Look in the instance dictionary if it exists
+	if I, ok := self.(IGetDict); ok {
+		dict := I.GetDict()
+		res, ok = dict[key]
+		if ok {
+			return
 		}
-	} else {
-		// Now look in type's dictionary etc
-		res = self.Type().NativeGetAttrOrNil(key)
-		if res != nil {
-			goto found
+	}
+
+	// Now look in type's dictionary etc
+	t := self.Type()
+	res = t.NativeGetAttrOrNil(key)
+	if res != nil {
+		// Call __get__ which creates bound methods, reads properties etc
+		if I, ok := res.(I__get__); ok {
+			res = I.M__get__(self, t)
 		}
-		// FIXME introspection for M__methods__ on non *Type objects
+		return
 	}
 
 	// And now only if not found call __getattr__
 	if I, ok := self.(I__getattr__); ok {
 		res = I.M__getattr__(key)
-		goto found
+		return
 	} else if res, ok = TypeCall1(self, "__getattr__", Object(String(key))); ok {
-		goto found
+		return
 	}
 
 	// Not found - return nil
 	res = nil
-	return
-
-found:
-	// FIXME if self is an instance then if it returning a function then it needs to return a bound method?
-	// otherwise it should return a function
-	//
-	// >>> str.find
-	// <method 'find' of 'str' objects>
-	// >>> "".find
-	// <built-in method find of str object at 0x7f929bd54c00>
-	// >>>
-	//
-	// created by PyMethod_New defined in classobject.c
-	// called by type.tp_descr_get
-
-	// FIXME Not completely correct!
-	// Should be using __get__
-	switch res.(type) {
-	case *Function, *Method:
-		res = NewBoundMethod(self, res)
-	}
+	err = ExceptionNewf(AttributeError, "'%s' has no attribute '%s'", self.Type().Name, key)
 	return
 }
 
-// GetAttrString
+// GetAttrString gets the attribute, raising an error if not found
 func GetAttrString(self Object, key string) Object {
-	res := GetAttrOrNil(self, key)
-	if res == nil {
-		panic(ExceptionNewf(AttributeError, "'%s' has no attribute '%s'", self.Type().Name, key))
+	res, err := GetAttrErr(self, key)
+	if err != nil {
+		panic(err)
 	}
 	return res
 }
 
-// GetAttr
+// GetAttr gets the attribute rasing an error if key isn't a string or
+// attribute not found
 func GetAttr(self Object, keyObj Object) Object {
 	if key, ok := keyObj.(String); ok {
 		return GetAttrString(self, string(key))
@@ -214,22 +200,36 @@ func GetAttr(self Object, keyObj Object) Object {
 
 // SetAttrString
 func SetAttrString(self Object, key string, value Object) Object {
+	// First look in type's dictionary etc for a property that could
+	// be set - do this before looking in the instance dictionary
+	setter := self.Type().NativeGetAttrOrNil(key)
+	if setter != nil {
+		// Call __set__ which writes properties etc
+		if I, ok := setter.(I__set__); ok {
+			return I.M__set__(self, value)
+		}
+	}
+
+	// If we have __setattr__ then use that
 	if I, ok := self.(I__setattr__); ok {
 		return I.M__setattr__(key, value)
 	} else if res, ok := TypeCall2(self, "__setattr__", String(key), value); ok {
 		return res
 	}
 
-	// Set the attribute on *Type
-	if t, ok := self.(*Type); ok {
-		if t.Dict == nil {
-			t.Dict = make(StringDict)
+	// Otherwise set the attribute in the instance dictionary if
+	// possible
+	if I, ok := self.(IGetDict); ok {
+		dict := I.GetDict()
+		if dict == nil {
+			panic(ExceptionNewf(SystemError, "nil Dict in %s", self.Type().Name))
 		}
-		t.Dict[key] = value
+		dict[key] = value
 		return None
 	}
 
-	panic(ExceptionNewf(TypeError, "'%s' object does not support setting attributes", self.Type().Name))
+	// If not blow up
+	panic(ExceptionNewf(AttributeError, "'%s' object has no attribute '%s'", self.Type().Name, key))
 }
 
 // SetAttr

py/method.go

@@ -137,6 +137,15 @@ func (m *Method) M__call__(args Tuple, kwargs StringDict) Object {
 	return result
 }
 
+// Read a method from a class which makes a bound method
+func (m *Method) M__get__(instance, owner Object) Object {
+	if instance != None {
+		return NewBoundMethod(instance, m)
+	}
+	return m
+}
+
 // Make sure it satisfies the interface
 var _ Object = (*Method)(nil)
 var _ I__call__ = (*Method)(nil)
+var _ I__get__ = (*Method)(nil)

py/module.go

@@ -31,6 +31,11 @@ func (o *Module) Type() *Type {
 	return ModuleType
 }
 
+// Get the Dict
+func (m *Module) GetDict() StringDict {
+	return m.Globals
+}
+
 // Define a new module
 func NewModule(name, doc string, methods []*Method, globals StringDict) *Module {
 	m := &Module{
@@ -61,23 +66,8 @@ func NewModule(name, doc string, methods []*Method, globals StringDict) *Module
 
 // Calls a named method of a module
 func (m *Module) Call(name string, args Tuple, kwargs StringDict) Object {
-	return Call(m.M__getattribute__(name), args, kwargs)
-}
-
-// Get an attribute from the module
-func (m *Module) M__getattribute__(name string) Object {
-	res, ok := m.Globals[name]
-	if !ok {
-		panic(ExceptionNewf(AttributeError, "module '%s' has no attribute '%s'", m.Name, name))
-	}
-	return res
-}
-
-func (m *Module) M__setattr__(name string, value Object) Object {
-	m.Globals[name] = value
-	return None
+	return Call(GetAttrString(m, name), args, kwargs)
 }
 
 // Interfaces
-var _ I__getattribute__ = (*Module)(nil)
-var _ I__setattr__ = (*Module)(nil)
+var _ IGetDict = (*Module)(nil)

py/py.go

@@ -6,6 +6,11 @@ type Object interface {
 	Type() *Type
 }
 
+// Optional interfaces
+type IGetDict interface {
+	GetDict() StringDict
+}
+
 // Some well known objects
 var (
 	Ellipsis Object
@@ -390,8 +395,8 @@ type I__get__ interface {
 	M__get__(instance, owner Object) Object
 }
 
-// Called to set the attribute on an instance instance of the owner
-// class to a new value, value.
+// Called to set the attribute on an instance of the owner
+// class to a new value.
 //object.__set__(self, instance, value)
 type I__set__ interface {
 	M__set__(instance, value Object) Object

py/type.go

@@ -171,12 +171,14 @@ type Type struct {
 var TypeType *Type = &Type{
 	Name: "type",
 	Doc:  "type(object) -> the object's type\ntype(name, bases, dict) -> a new type",
+	Dict: StringDict{},
 }
 
 var ObjectType = &Type{
 	Name:  "object",
 	Doc:   "The most base type",
 	Flags: TPFLAGS_BASETYPE,
+	Dict:  StringDict{},
 }
 
 func init() {
@@ -196,6 +198,11 @@ func (t *Type) Type() *Type {
 	return t.ObjectType
 }
 
+// Get the Dict
+func (t *Type) GetDict() StringDict {
+	return t.Dict
+}
+
 // Make a new type from a name
 //
 // For making Go types
@@ -1091,12 +1098,12 @@ func best_base(bases Tuple) *Type {
 
 // Generic object allocator
 func (t *Type) Alloc() *Type {
-	obj := new(Type)
-
 	// Set the type of the new object to this type
-	obj.ObjectType = t
-	obj.Base = t
-
+	obj := &Type{
+		ObjectType: t,
+		Base:       t,
+		Dict:       StringDict{},
+	}
 	return obj
 }
 
@@ -1585,3 +1592,4 @@ func ObjectNew(t *Type, args Tuple, kwargs StringDict) Object {
 // Make sure it satisfies the interface
 var _ Object = (*Type)(nil)
 var _ I__call__ = (*Type)(nil)
+var _ IGetDict = (*Type)(nil)