[pypy-svn] r9324 - in pypy/branch/dist-interpapp/pypy: interpreter objspace/std objspace/std/test
pedronis at codespeak.net
pedronis at codespeak.net
Sat Feb 19 01:37:35 CET 2005
Author: pedronis
Date: Sat Feb 19 01:37:35 2005
New Revision: 9324
Modified:
pypy/branch/dist-interpapp/pypy/interpreter/typedef.py
pypy/branch/dist-interpapp/pypy/objspace/std/dictproxyobject.py
pypy/branch/dist-interpapp/pypy/objspace/std/dictproxytype.py
pypy/branch/dist-interpapp/pypy/objspace/std/model.py
pypy/branch/dist-interpapp/pypy/objspace/std/slicetype.py
pypy/branch/dist-interpapp/pypy/objspace/std/stdtypedef.py
pypy/branch/dist-interpapp/pypy/objspace/std/test/test_typeobject.py
pypy/branch/dist-interpapp/pypy/objspace/std/typetype.py
Log:
typechecks through GetSetProperty
notice that in std objspace the feature is not that useful because when we construct the typedefs
we don't have the W_*Object classes, in fact they depend on the typedef being there first for their def,
for now I used a direct approach
do we want to reverse space, self where possible, given the situation we would have to support
space, ... / self, ... / self, space, ...
not totally related to the branch
there are surely some more typechecks missing that could use unwrap_specs more,
what to do about typechecking .slots_w access in members (there's no clear superclass we can check for),
same for setdict in generic __dict__ descr impl
Modified: pypy/branch/dist-interpapp/pypy/interpreter/typedef.py
==============================================================================
--- pypy/branch/dist-interpapp/pypy/interpreter/typedef.py (original)
+++ pypy/branch/dist-interpapp/pypy/interpreter/typedef.py Sat Feb 19 01:37:35 2005
@@ -3,7 +3,7 @@
"""
from pypy.interpreter.gateway import interp2app, ObjSpace, Arguments, W_Root
-from pypy.interpreter.baseobjspace import Wrappable
+from pypy.interpreter.baseobjspace import BaseWrappable, Wrappable
from pypy.interpreter.error import OperationError
from pypy.tool.cache import Cache
import new
@@ -92,34 +92,58 @@
else:
return new.instance(cls)
-def make_descr_typecheck_wrapper(func, extraargs=()):
- if not hasattr(func, 'im_func'):
+def make_descr_typecheck_wrapper(func, extraargs=(), cls=None):
+ if func is None:
+ return None
+ if hasattr(func, 'im_func'):
+ assert not cls or cls is func.im_class
+ cls = func.im_class
+ func = func.im_func
+ if not cls:
+ #print "UNCHECKED", func.__module__ or '?', func.__name__
return func
- cls = func.im_class
- func = func.im_func
- #print cls.__name__, func.__name__
+
miniglobals = {
- cls.__name__: cls,
- func.__name__: func,
+ func.__name__: func,
'OperationError': OperationError
}
+ if isinstance(cls, str):
+ #print "<CHECK", func.__module__ or '?', func.__name__
+ assert cls.startswith('<'),"pythontype typecheck should begin with <"
+ unwrap = "w_obj"
+ cls_name = cls[1:]
+ expected = repr(cls_name)
+ check = "space.is_true(space.isinstance(obj, space.w_%s))" % cls_name
+ else:
+ cls_name = cls.__name__
+ if issubclass(cls, BaseWrappable):
+ unwrap = "space.interpclass_w(w_obj)"
+ else:
+ unwrap = "w_obj"
+ miniglobals[cls_name] = cls
+ check = "isinstance(obj, %s)" % cls_name
+ expected = "%s.typedef.name" % cls_name
+
exec ("""def descr_typecheck_%(name)s(space, w_obj, %(extra)s):
- obj = space.interpclass_w(w_obj)
- if obj is None or not isinstance(obj, %(cls)s):
+ obj = %(unwrap)s
+ if obj is None or not %(check)s:
raise OperationError(space.w_TypeError,
- space.wrap("descriptor is for '%%s'" %% %(cls)s.typedef.name)) # xxx improve
+ space.wrap("descriptor is for '%%s'" %% %(expected)s)) # xxx improve
return %(name)s(space, obj, %(extra)s)
-""" % {'name': func.__name__, 'cls': cls.__name__,
+""" % {'name': func.__name__,
+ 'check': check,
+ 'expected': expected,
+ 'unwrap': unwrap,
'extra': ', '.join(extraargs)}) in miniglobals
return miniglobals['descr_typecheck_%s' % func.__name__]
class GetSetProperty(Wrappable):
- def __init__(self, fget, fset=None, fdel=None, doc=None):
+ def __init__(self, fget, fset=None, fdel=None, doc=None, cls=None):
"NOT_RPYTHON: initialization-time only"
- fget = make_descr_typecheck_wrapper(fget)
- fset = make_descr_typecheck_wrapper(fset, ('w_value',))
- fdel = make_descr_typecheck_wrapper(fdel)
+ fget = make_descr_typecheck_wrapper(fget, cls=cls)
+ fset = make_descr_typecheck_wrapper(fset, ('w_value',), cls=cls)
+ fdel = make_descr_typecheck_wrapper(fdel, cls=cls)
self.fget = fget
self.fset = fset
self.fdel = fdel
@@ -160,24 +184,22 @@
GetSetProperty, W_Root]),
)
-def interp_attrproperty(name):
+def interp_attrproperty(name, cls):
"NOT_RPYTHON: initialization-time only"
- def fget(space, w_obj):
- obj = space.interpclass_w(w_obj)
+ def fget(space, obj):
return space.wrap(getattr(obj, name))
- return GetSetProperty(fget)
+ return GetSetProperty(fget, cls=cls)
-def interp_attrproperty_w(name):
+def interp_attrproperty_w(name, cls):
"NOT_RPYTHON: initialization-time only"
- def fget(space, w_obj):
- obj = space.interpclass_w(w_obj)
+ def fget(space, obj):
w_value = getattr(obj, name)
if w_value is None:
return space.w_None
else:
return w_value
- return GetSetProperty(fget)
+ return GetSetProperty(fget, cls=cls)
class Member(Wrappable):
"""For slots."""
@@ -185,30 +207,37 @@
self.index = index
self.name = name
- def descr_member_get(space, w_member, w_obj, w_cls=None):
+ def descr_member_get(space, member, w_obj, w_cls=None):
if space.is_w(w_obj, space.w_None):
- return w_member
+ return space.wrap(member)
else:
- self = space.interpclass_w(w_member)
+ self = member
w_result = w_obj.slots_w[self.index]
if w_result is None:
raise OperationError(space.w_AttributeError,
space.wrap(self.name)) # XXX better message
return w_result
- def descr_member_set(space, w_member, w_obj, w_value):
- self = space.interpclass_w(w_member)
- w_obj.slots_w[self.index] = w_value
-
- def descr_member_del(space, w_member, w_obj):
- self = space.interpclass_w(w_member)
- w_obj.slots_w[self.index] = None
-
- typedef = TypeDef("member",
- __get__ = interp2app(descr_member_get),
- __set__ = interp2app(descr_member_set),
- __delete__ = interp2app(descr_member_del),
- )
+ def descr_member_set(space, member, w_obj, w_value):
+ self = member
+ w_obj.slots_w[self.index] = w_value # xxx typecheck
+
+ def descr_member_del(space, member, w_obj):
+ self = member
+ w_obj.slots_w[self.index] = None # xxx typecheck
+
+Member.typedef = TypeDef(
+ "Member",
+ __get__ = interp2app(Member.descr_member_get.im_func,
+ unwrap_spec = [ObjSpace,
+ Member, W_Root, W_Root]),
+ __set__ = interp2app(Member.descr_member_set.im_func,
+ unwrap_spec = [ObjSpace,
+ Member, W_Root, W_Root]),
+ __delete__ = interp2app(Member.descr_member_del.im_func,
+ unwrap_spec = [ObjSpace,
+ Member, W_Root]),
+ )
# ____________________________________________________________
#
@@ -224,19 +253,14 @@
from pypy.interpreter.nestedscope import Cell
from pypy.interpreter.special import NotImplemented, Ellipsis
-def descr_get_dict(space, w_obj):
- obj = space.interpclass_w(w_obj)
+def descr_get_dict(space, obj):
w_dict = obj.getdict()
assert w_dict is not None, repr(obj)
return w_dict
-def descr_set_dict(space, w_obj, w_dict):
- obj = space.interpclass_w(w_obj)
+def descr_set_dict(space, obj, w_dict):
obj.setdict(w_dict)
-interp_dict_descr = GetSetProperty(descr_get_dict, descr_set_dict)
-
-
# co_xxx interface emulation for built-in code objects
def fget_co_varnames(space, w_code):
code = space.interpclass_w(w_code)
@@ -261,36 +285,36 @@
return space.newtuple([w_docstring])
Code.typedef = TypeDef('internal-code',
- co_name = interp_attrproperty('co_name'),
- co_varnames = GetSetProperty(fget_co_varnames),
- co_argcount = GetSetProperty(fget_co_argcount),
- co_flags = GetSetProperty(fget_co_flags),
- co_consts = GetSetProperty(fget_co_consts),
+ co_name = interp_attrproperty('co_name', cls=Code),
+ co_varnames = GetSetProperty(fget_co_varnames, cls=Code),
+ co_argcount = GetSetProperty(fget_co_argcount, cls=Code),
+ co_flags = GetSetProperty(fget_co_flags, cls=Code),
+ co_consts = GetSetProperty(fget_co_consts, cls=Code),
)
Frame.typedef = TypeDef('internal-frame',
- f_code = interp_attrproperty('code'),
+ f_code = interp_attrproperty('code', cls=Frame),
f_locals = GetSetProperty(Frame.fget_getdictscope),
- f_globals = interp_attrproperty_w('w_globals'),
+ f_globals = interp_attrproperty_w('w_globals', cls=Frame),
)
PyCode.typedef = TypeDef('code',
__new__ = interp2app(PyCode.descr_code__new__.im_func),
__eq__ = interp2app(PyCode.descr_code__eq__),
- co_argcount = interp_attrproperty('co_argcount'),
- co_nlocals = interp_attrproperty('co_nlocals'),
- co_stacksize = interp_attrproperty('co_stacksize'),
- co_flags = interp_attrproperty('co_flags'),
- co_code = interp_attrproperty('co_code'),
+ co_argcount = interp_attrproperty('co_argcount', cls=PyCode),
+ co_nlocals = interp_attrproperty('co_nlocals', cls=PyCode),
+ co_stacksize = interp_attrproperty('co_stacksize', cls=PyCode),
+ co_flags = interp_attrproperty('co_flags', cls=PyCode),
+ co_code = interp_attrproperty('co_code', cls=PyCode),
co_consts = GetSetProperty(PyCode.fget_co_consts),
co_names = GetSetProperty(PyCode.fget_co_names),
- co_varnames = interp_attrproperty('co_varnames'),
- co_freevars = interp_attrproperty('co_freevars'),
- co_cellvars = interp_attrproperty('co_cellvars'),
- co_filename = interp_attrproperty('co_filename'),
- co_name = interp_attrproperty('co_name'),
- co_firstlineno = interp_attrproperty('co_firstlineno'),
- co_lnotab = interp_attrproperty('co_lnotab'),
+ co_varnames = interp_attrproperty('co_varnames', cls=PyCode),
+ co_freevars = interp_attrproperty('co_freevars', cls=PyCode),
+ co_cellvars = interp_attrproperty('co_cellvars', cls=PyCode),
+ co_filename = interp_attrproperty('co_filename', cls=PyCode),
+ co_name = interp_attrproperty('co_name', cls=PyCode),
+ co_firstlineno = interp_attrproperty('co_firstlineno', cls=PyCode),
+ co_lnotab = interp_attrproperty('co_lnotab', cls=PyCode),
)
PyFrame.typedef = TypeDef('frame',
@@ -302,7 +326,7 @@
__new__ = interp2app(Module.descr_module__new__.im_func,
unwrap_spec=[ObjSpace, W_Root, Arguments]),
__init__ = interp2app(Module.descr_module__init__),
- __dict__ = GetSetProperty(descr_get_dict), # module dictionaries are readonly attributes
+ __dict__ = GetSetProperty(descr_get_dict, cls=Module), # module dictionaries are readonly attributes
)
getset_func_doc = GetSetProperty(Function.fget_func_doc,
@@ -324,7 +348,7 @@
getset_func_code = GetSetProperty(Function.fget_func_code,
Function.fset_func_code)
-getset_func_dict = GetSetProperty(descr_get_dict, descr_set_dict)
+getset_func_dict = GetSetProperty(descr_get_dict, descr_set_dict, cls=Function)
Function.typedef = TypeDef("function",
__call__ = interp2app(Function.descr_function_call,
@@ -332,13 +356,13 @@
__get__ = interp2app(Function.descr_function_get),
func_code = getset_func_code,
func_doc = getset_func_doc,
- func_name = interp_attrproperty('name'),
+ func_name = interp_attrproperty('name', cls=Function),
func_dict = getset_func_dict,
func_defaults = getset_func_defaults,
- func_globals = interp_attrproperty_w('w_func_globals'),
+ func_globals = interp_attrproperty_w('w_func_globals', cls=Function),
func_closure = GetSetProperty( Function.fget_func_closure ),
__doc__ = getset_func_doc,
- __name__ = interp_attrproperty('name'),
+ __name__ = interp_attrproperty('name', cls=Function),
__dict__ = getset_func_dict,
__module__ = getset___module__,
# XXX func_closure, etc.pp
@@ -349,9 +373,9 @@
__call__ = interp2app(Method.descr_method_call,
unwrap_spec=['self', Arguments]),
__get__ = interp2app(Method.descr_method_get),
- im_func = interp_attrproperty_w('w_function'),
- im_self = interp_attrproperty_w('w_instance'),
- im_class = interp_attrproperty_w('w_class'),
+ im_func = interp_attrproperty_w('w_function', cls=Method),
+ im_self = interp_attrproperty_w('w_instance', cls=Method),
+ im_class = interp_attrproperty_w('w_class', cls=Method),
__getattribute__ = interp2app(Method.descr_method_getattribute),
# XXX getattribute/setattribute etc.pp
)
@@ -362,17 +386,17 @@
)
PyTraceback.typedef = TypeDef("traceback",
- tb_frame = interp_attrproperty('frame'),
- tb_lasti = interp_attrproperty('lasti'),
- tb_lineno = interp_attrproperty('lineno'),
- tb_next = interp_attrproperty('next'),
+ tb_frame = interp_attrproperty('frame', cls=PyTraceback),
+ tb_lasti = interp_attrproperty('lasti', cls=PyTraceback),
+ tb_lineno = interp_attrproperty('lineno', cls=PyTraceback),
+ tb_next = interp_attrproperty('next', cls=PyTraceback),
)
GeneratorIterator.typedef = TypeDef("generator",
next = interp2app(GeneratorIterator.descr_next),
__iter__ = interp2app(GeneratorIterator.descr__iter__),
- gi_running = interp_attrproperty('running'),
- gi_frame = interp_attrproperty('frame'),
+ gi_running = interp_attrproperty('running', cls=GeneratorIterator),
+ gi_frame = interp_attrproperty('frame', cls=GeneratorIterator),
)
Cell.typedef = TypeDef("cell")
Modified: pypy/branch/dist-interpapp/pypy/objspace/std/dictproxyobject.py
==============================================================================
--- pypy/branch/dist-interpapp/pypy/objspace/std/dictproxyobject.py (original)
+++ pypy/branch/dist-interpapp/pypy/objspace/std/dictproxyobject.py Sat Feb 19 01:37:35 2005
@@ -4,8 +4,6 @@
def descr_get_dictproxy(space, w_obj):
return W_DictProxyObject(space, w_obj.getdict())
-dictproxy_descr = GetSetProperty(descr_get_dictproxy)
-
class W_DictProxyObject(W_Object):
from pypy.objspace.std.dictproxytype import dictproxy_typedef as typedef
Modified: pypy/branch/dist-interpapp/pypy/objspace/std/dictproxytype.py
==============================================================================
--- pypy/branch/dist-interpapp/pypy/objspace/std/dictproxytype.py (original)
+++ pypy/branch/dist-interpapp/pypy/objspace/std/dictproxytype.py Sat Feb 19 01:37:35 2005
@@ -4,34 +4,38 @@
# ____________________________________________________________
-def proxymethod(name):
+def _proxymethod(name):
def fget(space, w_obj):
+ from pypy.objspace.std.dictproxyobject import W_DictProxyObject
+ if not isinstance(w_obj, W_DictProxyObject):
+ raise OperationError(space.w_TypeError,
+ space.wrap("expected dictproxy"))
return space.getattr(w_obj.w_dict, space.wrap(name))
return GetSetProperty(fget)
# ____________________________________________________________
dictproxy_typedef = StdTypeDef("dictproxy",
- has_key = proxymethod('has_key'),
- get = proxymethod('get'),
- keys = proxymethod('keys'),
- values = proxymethod('values'),
- items = proxymethod('items'),
- iterkeys = proxymethod('iterkeys'),
- itervalues = proxymethod('itervalues'),
- iteritems = proxymethod('iteritems'),
- copy = proxymethod('copy'),
- __len__ = proxymethod('__len__'),
- __getitem__ = proxymethod('__getitem__'),
- __contains__ = proxymethod('__contains__'),
- __str__ = proxymethod('__str__'),
- __iter__ = proxymethod('__iter__'),
- __cmp__ = proxymethod('__cmp__'),
- __lt__ = proxymethod('__lt__'),
- __le__ = proxymethod('__le__'),
- __eq__ = proxymethod('__eq__'),
- __ne__ = proxymethod('__ne__'),
- __gt__ = proxymethod('__gt__'),
- __ge__ = proxymethod('__ge__'),
+ has_key = _proxymethod('has_key'),
+ get = _proxymethod('get'),
+ keys = _proxymethod('keys'),
+ values = _proxymethod('values'),
+ items = _proxymethod('items'),
+ iterkeys = _proxymethod('iterkeys'),
+ itervalues = _proxymethod('itervalues'),
+ iteritems = _proxymethod('iteritems'),
+ copy = _proxymethod('copy'),
+ __len__ = _proxymethod('__len__'),
+ __getitem__ = _proxymethod('__getitem__'),
+ __contains__ = _proxymethod('__contains__'),
+ __str__ = _proxymethod('__str__'),
+ __iter__ = _proxymethod('__iter__'),
+ __cmp__ = _proxymethod('__cmp__'),
+ __lt__ = _proxymethod('__lt__'),
+ __le__ = _proxymethod('__le__'),
+ __eq__ = _proxymethod('__eq__'),
+ __ne__ = _proxymethod('__ne__'),
+ __gt__ = _proxymethod('__gt__'),
+ __ge__ = _proxymethod('__ge__'),
)
dictproxy_typedef.registermethods(globals())
Modified: pypy/branch/dist-interpapp/pypy/objspace/std/model.py
==============================================================================
--- pypy/branch/dist-interpapp/pypy/objspace/std/model.py (original)
+++ pypy/branch/dist-interpapp/pypy/objspace/std/model.py Sat Feb 19 01:37:35 2005
@@ -26,6 +26,7 @@
from pypy.objspace.std.slicetype import slice_typedef
from pypy.objspace.std.longtype import long_typedef
from pypy.objspace.std.unicodetype import unicode_typedef
+ from pypy.objspace.std.dictproxytype import dictproxy_typedef
self.pythontypes = [value for key, value in result.__dict__.items()
if not key.startswith('_')] # don't look
Modified: pypy/branch/dist-interpapp/pypy/objspace/std/slicetype.py
==============================================================================
--- pypy/branch/dist-interpapp/pypy/objspace/std/slicetype.py (original)
+++ pypy/branch/dist-interpapp/pypy/objspace/std/slicetype.py Sat Feb 19 01:37:35 2005
@@ -125,10 +125,20 @@
# ____________________________________________________________
+def slicewprop(name):
+ def fget(space, w_obj):
+ from pypy.objspace.std.sliceobject import W_SliceObject
+ if not isinstance(w_obj, W_SliceObject):
+ raise OperationError(space.w_TypeError,
+ space.wrap("descriptor is for 'slice'"))
+ return getattr(w_obj, name)
+ return GetSetProperty(fget)
+
+
slice_typedef = StdTypeDef("slice",
__new__ = newmethod(descr__new__),
- start = attrproperty_w('w_start'),
- stop = attrproperty_w('w_stop'),
- step = attrproperty_w('w_step'),
+ start = slicewprop('w_start'),
+ stop = slicewprop('w_stop'),
+ step = slicewprop('w_step'),
)
slice_typedef.registermethods(globals())
Modified: pypy/branch/dist-interpapp/pypy/objspace/std/stdtypedef.py
==============================================================================
--- pypy/branch/dist-interpapp/pypy/objspace/std/stdtypedef.py (original)
+++ pypy/branch/dist-interpapp/pypy/objspace/std/stdtypedef.py Sat Feb 19 01:37:35 2005
@@ -4,7 +4,7 @@
from pypy.objspace.std.model import MultiMethod, FailedToImplement
__all__ = ['StdTypeDef', 'newmethod', 'gateway',
- 'GetSetProperty', 'Member', 'attrproperty', 'attrproperty_w',
+ 'GetSetProperty', 'Member',
'MultiMethod']
@@ -29,28 +29,12 @@
a = a.base
return True
-def attrproperty(name):
- "NOT_RPYTHON: initialization-time only"
- def fget(space, w_obj):
- return space.wrap(getattr(w_obj, name))
- return GetSetProperty(fget)
-
-def attrproperty_w(name):
- "NOT_RPYTHON: initialization-time only"
- def fget(space, w_obj):
- w_value = getattr(w_obj, name)
- if w_value is None:
- return space.w_None
- else:
- return w_value
- return GetSetProperty(fget)
-
-def descr_get_dict(space, w_obj):
+def descr_get_dict(space, w_obj): # xxx typecheck
w_dict = w_obj.getdict()
assert w_dict is not None, repr(w_obj)
return w_dict
-def descr_set_dict(space, w_obj, w_dict):
+def descr_set_dict(space, w_obj, w_dict): # xxx typecheck
w_obj.setdict(w_dict)
std_dict_descr = GetSetProperty(descr_get_dict, descr_set_dict)
Modified: pypy/branch/dist-interpapp/pypy/objspace/std/test/test_typeobject.py
==============================================================================
--- pypy/branch/dist-interpapp/pypy/objspace/std/test/test_typeobject.py (original)
+++ pypy/branch/dist-interpapp/pypy/objspace/std/test/test_typeobject.py Sat Feb 19 01:37:35 2005
@@ -232,7 +232,11 @@
assert type(D1) is T1
assert type(C) is T1
assert type(G) is T1
-
+
+ def test_descr_typecheck(self):
+ raises(TypeError,type.__dict__['__name__'].__get__,1)
+ raises(TypeError,type.__dict__['__mro__'].__get__,1)
+
Modified: pypy/branch/dist-interpapp/pypy/objspace/std/typetype.py
==============================================================================
--- pypy/branch/dist-interpapp/pypy/objspace/std/typetype.py (original)
+++ pypy/branch/dist-interpapp/pypy/objspace/std/typetype.py Sat Feb 19 01:37:35 2005
@@ -1,6 +1,6 @@
from pypy.interpreter.error import OperationError
from pypy.objspace.std.stdtypedef import *
-from pypy.objspace.std.dictproxyobject import dictproxy_descr
+from pypy.objspace.std.dictproxyobject import descr_get_dictproxy
def descr__new__(space, w_typetype, w_name, w_bases, w_dict):
@@ -42,17 +42,37 @@
w_type.__init__(space, name, bases_w or [space.w_object], dict_w)
return w_type
+def _check(space, w_type, msg=None):
+ from pypy.objspace.std.typeobject import W_TypeObject
+ if not isinstance(w_type, W_TypeObject):
+ raise OperationError(space.w_TypeError,
+ space.wrap(msg or "descriptor is for 'type'"))
+ return w_type
+
+
+def descr_get__name__(space, w_type):
+ w_type = _check(space, w_type)
+ return space.wrap(w_type.name)
+
def descr_get__mro__(space, w_type):
+ w_type = _check(space, w_type)
# XXX this should be inside typeobject.py
return space.newtuple(w_type.mro_w)
def descr_mro(space, w_type):
+ w_type = _check(space, w_type,"expected type")
return space.newlist(w_type.compute_mro())
def descr__bases(space, w_type):
+ w_type = _check(space, w_type)
+ from pypy.objspace.std.typeobject import W_TypeObject
+ if not isinstance(w_type, W_TypeObject):
+ raise OperationError(space.w_TypeError,
+ space.wrap("descriptor is for 'type'"))
return space.newtuple(w_type.bases_w)
def descr__base(space, w_type):
+ w_type = _check(space, w_type)
if w_type is space.w_object:
return space.w_None
b = w_type.instancetypedef.base
@@ -62,6 +82,7 @@
return space.w_object
def descr__doc(space, w_type):
+ w_type = _check(space, w_type)
w_result = w_type.getdictvalue(space, '__doc__')
if w_result is None:
return space.w_None
@@ -72,11 +93,11 @@
type_typedef = StdTypeDef("type",
__new__ = newmethod(descr__new__),
- __name__ = attrproperty('name'),
+ __name__ = GetSetProperty(descr_get__name__),
__bases__ = GetSetProperty(descr__bases),
__base__ = GetSetProperty(descr__base),
__mro__ = GetSetProperty(descr_get__mro__),
- __dict__ = dictproxy_descr,
+ __dict__ = GetSetProperty(descr_get_dictproxy),
__doc__ = GetSetProperty(descr__doc),
mro = gateway.interp2app(descr_mro),
)
More information about the Pypy-commit
mailing list