[pypy-svn] pypy improve-unwrap_spec: modernize unwrap_spec in the __builtin__ module
amauryfa
commits-noreply at bitbucket.org
Wed Feb 16 19:19:11 CET 2011
Author: Amaury Forgeot d'Arc <amauryfa at gmail.com>
Branch: improve-unwrap_spec
Changeset: r42050:3ed721ed67a1
Date: 2011-02-16 11:02 +0100
http://bitbucket.org/pypy/pypy/changeset/3ed721ed67a1/
Log: modernize unwrap_spec in the __builtin__ module
diff --git a/pypy/module/__builtin__/interp_memoryview.py b/pypy/module/__builtin__/interp_memoryview.py
--- a/pypy/module/__builtin__/interp_memoryview.py
+++ b/pypy/module/__builtin__/interp_memoryview.py
@@ -3,7 +3,7 @@
"""
from pypy.interpreter.baseobjspace import Wrappable
from pypy.interpreter import gateway, buffer
-from pypy.interpreter.gateway import interp2app, unwrap_spec, ObjSpace, W_Root
+from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.typedef import TypeDef, GetSetProperty
from pypy.interpreter.error import OperationError
import operator
@@ -39,7 +39,6 @@
str1 = self.as_str()
str2 = space.buffer_w(w_buf).as_str()
return space.wrap(getattr(operator, name)(str1, str2))
- descr__cmp.unwrap_spec = ['self', ObjSpace, W_Root]
descr__cmp.func_name = name
return descr__cmp
@@ -69,15 +68,12 @@
buf = buffer.SubBuffer(buf, start, size)
return W_MemoryView(buf)
- @unwrap_spec('self', ObjSpace)
def descr_buffer(self, space):
return space.wrap(self.buf)
- @unwrap_spec('self', ObjSpace)
def descr_tobytes(self, space):
return space.wrap(self.as_str())
- @unwrap_spec('self', ObjSpace)
def descr_tolist(self, space):
buf = self.buf
result = []
@@ -85,7 +81,6 @@
result.append(space.wrap(ord(buf.getitem(i))))
return space.newlist(result)
- @unwrap_spec('self', ObjSpace, W_Root)
def descr_getitem(self, space, w_index):
start, stop, step = space.decode_index(w_index, self.getlength())
if step == 0: # index only
@@ -98,7 +93,7 @@
space.wrap("memoryview object does not support"
" slicing with a step"))
- @unwrap_spec('self', ObjSpace, W_Root, 'bufferstr')
+ @unwrap_spec(newstring='bufferstr')
def descr_setitem(self, space, w_index, newstring):
buf = self.buf
if isinstance(buf, buffer.RWBuffer):
@@ -107,7 +102,6 @@
raise OperationError(space.w_TypeError,
space.wrap("cannot modify read-only memory"))
- @unwrap_spec('self', ObjSpace)
def descr_len(self, space):
return self.buf.descr_len(space)
@@ -128,7 +122,6 @@
return space.w_None
- at unwrap_spec(ObjSpace, W_Root, W_Root)
def descr_new(space, w_subtype, w_object):
memoryview = W_MemoryView(space.buffer(w_object))
return space.wrap(memoryview)
diff --git a/pypy/module/__builtin__/compiling.py b/pypy/module/__builtin__/compiling.py
--- a/pypy/module/__builtin__/compiling.py
+++ b/pypy/module/__builtin__/compiling.py
@@ -3,11 +3,11 @@
"""
from pypy.interpreter.pycode import PyCode
-from pypy.interpreter.baseobjspace import W_Root, ObjSpace
from pypy.interpreter.error import OperationError
from pypy.interpreter.astcompiler import consts, ast
-from pypy.interpreter.gateway import NoneNotWrapped
+from pypy.interpreter.gateway import NoneNotWrapped, unwrap_spec
+ at unwrap_spec(filename=str, mode=str, flags=int, dont_inherit=int)
def compile(space, w_source, filename, mode, flags=0, dont_inherit=0):
"""Compile the source string (a Python module, statement or expression)
into a code object that can be executed by the exec statement or eval().
@@ -61,8 +61,6 @@
else:
code = ec.compiler.compile_ast(ast_node, filename, mode, flags)
return space.wrap(code)
-#
-compile.unwrap_spec = [ObjSpace,W_Root,str,str,int,int]
def eval(space, w_code, w_globals=None, w_locals=None):
diff --git a/pypy/module/__builtin__/interp_classobj.py b/pypy/module/__builtin__/interp_classobj.py
--- a/pypy/module/__builtin__/interp_classobj.py
+++ b/pypy/module/__builtin__/interp_classobj.py
@@ -1,9 +1,7 @@
import new
from pypy.interpreter.error import OperationError, operationerrfmt
-from pypy.interpreter.gateway import (ObjSpace, W_Root, NoneNotWrapped,
- applevel, interp2app, ObjSpace, unwrap_spec)
+from pypy.interpreter.gateway import NoneNotWrapped, applevel, interp2app
from pypy.interpreter.typedef import TypeDef, make_weakref_descr
-from pypy.interpreter.argument import Arguments
from pypy.interpreter.baseobjspace import Wrappable
from pypy.interpreter.typedef import GetSetProperty, descr_get_dict
from pypy.interpreter.typedef import descr_set_dict
@@ -233,18 +231,12 @@
W_ClassObject.typedef = TypeDef("classobj",
__new__ = interp2app(descr_classobj_new),
- __repr__ = interp2app(W_ClassObject.descr_repr,
- unwrap_spec=['self', ObjSpace]),
- __str__ = interp2app(W_ClassObject.descr_str,
- unwrap_spec=['self', ObjSpace]),
- __call__ = interp2app(class_descr_call,
- unwrap_spec=[ObjSpace, W_Root, Arguments]),
- __getattribute__ = interp2app(W_ClassObject.descr_getattribute,
- unwrap_spec=['self', ObjSpace, W_Root]),
- __setattr__ = interp2app(W_ClassObject.descr_setattr,
- unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
- __delattr__ = interp2app(W_ClassObject.descr_delattr,
- unwrap_spec=['self', ObjSpace, W_Root]),
+ __repr__ = interp2app(W_ClassObject.descr_repr),
+ __str__ = interp2app(W_ClassObject.descr_str),
+ __call__ = interp2app(class_descr_call),
+ __getattribute__ = interp2app(W_ClassObject.descr_getattribute),
+ __setattr__ = interp2app(W_ClassObject.descr_setattr),
+ __delattr__ = interp2app(W_ClassObject.descr_delattr),
__weakref__ = make_weakref_descr(W_ClassObject),
)
W_ClassObject.typedef.acceptable_as_base_class = False
@@ -454,7 +446,6 @@
return self.descr_str(space)
return space.call_function(w_meth)
- @unwrap_spec("self", ObjSpace, W_Root)
def descr_format(self, space, w_format_spec):
w_meth = self.getattr(space, "__format__", False)
if w_meth is not None:
@@ -737,9 +728,7 @@
make_unary_instance_method(specialname),
None,
W_InstanceObject)
- rawdict[specialname] = interp2app(
- meth,
- unwrap_spec=["self", ObjSpace])
+ rawdict[specialname] = interp2app(meth)
# binary operations that return NotImplemented if they fail
# e.g. rich comparisons, coerce and inplace ops
@@ -750,9 +739,7 @@
make_binary_returning_notimplemented_instance_method(specialname),
None,
W_InstanceObject)
- rawdict[specialname] = interp2app(
- meth,
- unwrap_spec=["self", ObjSpace, W_Root])
+ rawdict[specialname] = interp2app(meth)
for op in "or and xor lshift rshift add sub mul div mod divmod floordiv truediv".split():
specialname = "__%s__" % (op, )
@@ -760,13 +747,9 @@
func, rfunc = make_binary_instance_method(op)
# fool the gateway logic by giving it a real unbound method
meth = new.instancemethod(func, None, W_InstanceObject)
- rawdict[specialname] = interp2app(
- meth,
- unwrap_spec=["self", ObjSpace, W_Root])
+ rawdict[specialname] = interp2app(meth)
rmeth = new.instancemethod(rfunc, None, W_InstanceObject)
- rawdict[rspecialname] = interp2app(
- rmeth,
- unwrap_spec=["self", ObjSpace, W_Root])
+ rawdict[rspecialname] = interp2app(meth)
def descr_del_dict(space, w_inst):
@@ -778,62 +761,34 @@
W_InstanceObject.typedef = TypeDef("instance",
__new__ = interp2app(descr_instance_new),
- __getattribute__ = interp2app(W_InstanceObject.descr_getattribute,
- unwrap_spec=['self', ObjSpace, W_Root]),
- __setattr__ = interp2app(W_InstanceObject.descr_setattr,
- unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
- __delattr__ = interp2app(W_InstanceObject.descr_delattr,
- unwrap_spec=['self', ObjSpace, W_Root]),
- __repr__ = interp2app(W_InstanceObject.descr_repr,
- unwrap_spec=['self', ObjSpace]),
- __str__ = interp2app(W_InstanceObject.descr_str,
- unwrap_spec=['self', ObjSpace]),
- __unicode__ = interp2app(W_InstanceObject.descr_unicode,
- unwrap_spec=['self', ObjSpace]),
+ __getattribute__ = interp2app(W_InstanceObject.descr_getattribute),
+ __setattr__ = interp2app(W_InstanceObject.descr_setattr),
+ __delattr__ = interp2app(W_InstanceObject.descr_delattr),
+ __repr__ = interp2app(W_InstanceObject.descr_repr),
+ __str__ = interp2app(W_InstanceObject.descr_str),
+ __unicode__ = interp2app(W_InstanceObject.descr_unicode),
__format__ = interp2app(W_InstanceObject.descr_format),
- __len__ = interp2app(W_InstanceObject.descr_len,
- unwrap_spec=['self', ObjSpace]),
- __getitem__ = interp2app(W_InstanceObject.descr_getitem,
- unwrap_spec=['self', ObjSpace, W_Root]),
- __setitem__ = interp2app(W_InstanceObject.descr_setitem,
- unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
- __delitem__ = interp2app(W_InstanceObject.descr_delitem,
- unwrap_spec=['self', ObjSpace, W_Root]),
- __iter__ = interp2app(W_InstanceObject.descr_iter,
- unwrap_spec=['self', ObjSpace]),
- __getslice__ = interp2app(W_InstanceObject.descr_getslice,
- unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
- __setslice__ = interp2app(W_InstanceObject.descr_setslice,
- unwrap_spec=['self', ObjSpace, W_Root,
- W_Root, W_Root]),
- __delslice__ = interp2app(W_InstanceObject.descr_delslice,
- unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
- __call__ = interp2app(W_InstanceObject.descr_call,
- unwrap_spec=['self', ObjSpace, Arguments]),
- __nonzero__ = interp2app(W_InstanceObject.descr_nonzero,
- unwrap_spec=['self', ObjSpace]),
- __cmp__ = interp2app(W_InstanceObject.descr_cmp,
- unwrap_spec=['self', ObjSpace, W_Root]),
- __hash__ = interp2app(W_InstanceObject.descr_hash,
- unwrap_spec=['self', ObjSpace]),
- __int__ = interp2app(W_InstanceObject.descr_int,
- unwrap_spec=['self', ObjSpace]),
- __long__ = interp2app(W_InstanceObject.descr_long,
- unwrap_spec=['self', ObjSpace]),
- __index__ = interp2app(W_InstanceObject.descr_index,
- unwrap_spec=['self', ObjSpace]),
- __contains__ = interp2app(W_InstanceObject.descr_contains,
- unwrap_spec=['self', ObjSpace, W_Root]),
- __pow__ = interp2app(W_InstanceObject.descr_pow,
- unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
- __rpow__ = interp2app(W_InstanceObject.descr_rpow,
- unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
- next = interp2app(W_InstanceObject.descr_next,
- unwrap_spec=['self', ObjSpace]),
- __del__ = interp2app(W_InstanceObject.descr_del,
- unwrap_spec=['self', ObjSpace]),
- __exit__ = interp2app(W_InstanceObject.descr_exit,
- unwrap_spec=['self', ObjSpace, W_Root, W_Root, W_Root]),
+ __len__ = interp2app(W_InstanceObject.descr_len),
+ __getitem__ = interp2app(W_InstanceObject.descr_getitem),
+ __setitem__ = interp2app(W_InstanceObject.descr_setitem),
+ __delitem__ = interp2app(W_InstanceObject.descr_delitem),
+ __iter__ = interp2app(W_InstanceObject.descr_iter),
+ __getslice__ = interp2app(W_InstanceObject.descr_getslice),
+ __setslice__ = interp2app(W_InstanceObject.descr_setslice),
+ __delslice__ = interp2app(W_InstanceObject.descr_delslice),
+ __call__ = interp2app(W_InstanceObject.descr_call),
+ __nonzero__ = interp2app(W_InstanceObject.descr_nonzero),
+ __cmp__ = interp2app(W_InstanceObject.descr_cmp),
+ __hash__ = interp2app(W_InstanceObject.descr_hash),
+ __int__ = interp2app(W_InstanceObject.descr_int),
+ __long__ = interp2app(W_InstanceObject.descr_long),
+ __index__ = interp2app(W_InstanceObject.descr_index),
+ __contains__ = interp2app(W_InstanceObject.descr_contains),
+ __pow__ = interp2app(W_InstanceObject.descr_pow),
+ __rpow__ = interp2app(W_InstanceObject.descr_rpow),
+ next = interp2app(W_InstanceObject.descr_next),
+ __del__ = interp2app(W_InstanceObject.descr_del),
+ __exit__ = interp2app(W_InstanceObject.descr_exit),
__dict__ = dict_descr,
**rawdict
)
diff --git a/pypy/module/__builtin__/operation.py b/pypy/module/__builtin__/operation.py
--- a/pypy/module/__builtin__/operation.py
+++ b/pypy/module/__builtin__/operation.py
@@ -3,9 +3,8 @@
"""
from pypy.interpreter import gateway
-from pypy.interpreter.baseobjspace import ObjSpace, W_Root
from pypy.interpreter.error import OperationError
-from pypy.interpreter.gateway import interp2app
+from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.typedef import TypeDef
from pypy.rlib.runicode import UNICHR
from pypy.rlib.rarithmetic import isnan, isinf, round_double
@@ -27,6 +26,7 @@
space.wrap("character code not in range(256)"))
return space.wrap(char)
+ at unwrap_spec(code=int)
def unichr(space, code):
"Return a Unicode string of one character with the given ordinal."
# XXX range checking!
@@ -36,7 +36,6 @@
raise OperationError(space.w_ValueError,
space.wrap("unichr() arg out of range"))
return space.wrap(c)
-unichr.unwrap_spec = [ObjSpace, int]
def len(space, w_obj):
"len(object) -> integer\n\nReturn the number of items of a sequence or mapping."
@@ -128,6 +127,7 @@
NDIGITS_MAX = int((rfloat.DBL_MANT_DIG - rfloat.DBL_MIN_EXP) * 0.30103)
NDIGITS_MIN = -int((rfloat.DBL_MAX_EXP + 1) * 0.30103)
+ at unwrap_spec(number=float)
def round(space, number, w_ndigits=0):
"""round(number[, ndigits]) -> floating point number
@@ -157,8 +157,6 @@
raise OperationError(space.w_OverflowError,
space.wrap("rounded value too large to represent"))
return space.wrap(z)
-#
-round.unwrap_spec = [ObjSpace, float, W_Root]
# ____________________________________________________________
diff --git a/pypy/module/__builtin__/descriptor.py b/pypy/module/__builtin__/descriptor.py
--- a/pypy/module/__builtin__/descriptor.py
+++ b/pypy/module/__builtin__/descriptor.py
@@ -1,8 +1,7 @@
from pypy.interpreter.typedef import TypeDef, GetSetProperty
-from pypy.interpreter.baseobjspace import W_Root, ObjSpace, Wrappable, \
- Arguments
-from pypy.interpreter.gateway import interp2app
+from pypy.interpreter.baseobjspace import Wrappable
+from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.error import OperationError, operationerrfmt
from pypy.objspace.descroperation import object_getattribute, object_setattr
from pypy.interpreter.function import StaticMethod, ClassMethod
@@ -24,8 +23,8 @@
# XXX write a fast path for this common case
w_selftype = space.type(w(self))
return space.call_function(w_selftype, self.w_starttype, w_obj)
- get.unwrap_spec = ['self', ObjSpace, W_Root, W_Root]
+ @unwrap_spec(name=str)
def getattribute(self, space, name):
w = space.wrap
# only use a special logic for bound super objects and not for
@@ -49,7 +48,6 @@
# fallback to object.__getattribute__()
return space.call_function(object_getattribute(space),
w(self), w(name))
- getattribute.unwrap_spec = ['self', ObjSpace, str]
def descr_new_super(space, w_subtype, w_starttype, w_obj_or_type=None):
if space.is_w(w_obj_or_type, space.w_None):
@@ -77,7 +75,6 @@
w_result = space.allocate_instance(W_Super, w_subtype)
W_Super.__init__(w_result, space, w_starttype, w_type, w_obj_or_type)
return w_result
-descr_new_super.unwrap_spec = [ObjSpace, W_Root, W_Root, W_Root]
W_Super.typedef = TypeDef(
'super',
@@ -115,12 +112,10 @@
space.setattr(space.wrap(self), space.wrap("__doc__"),
w_getter_doc)
self.getter_doc = True
- init.unwrap_spec = ['self', ObjSpace, W_Root, W_Root, W_Root, W_Root]
def new(space, w_subtype, w_fget=None, w_fset=None, w_fdel=None, w_doc=None):
w_result = space.allocate_instance(W_Property, w_subtype)
return w_result
- new.unwrap_spec = [ObjSpace, W_Root, W_Root, W_Root, W_Root, W_Root]
def get(self, space, w_obj, w_objtype=None):
if space.is_w(w_obj, space.w_None):
@@ -129,7 +124,6 @@
raise OperationError(space.w_AttributeError, space.wrap(
"unreadable attribute"))
return space.call_function(self.w_fget, w_obj)
- get.unwrap_spec = ['self', ObjSpace, W_Root, W_Root]
def set(self, space, w_obj, w_value):
if space.is_w(self.w_fset, space.w_None):
@@ -137,7 +131,6 @@
"can't set attribute"))
space.call_function(self.w_fset, w_obj, w_value)
return space.w_None
- set.unwrap_spec = ['self', ObjSpace, W_Root, W_Root]
def delete(self, space, w_obj):
if space.is_w(self.w_fdel, space.w_None):
@@ -145,19 +138,15 @@
"can't delete attribute"))
space.call_function(self.w_fdel, w_obj)
return space.w_None
- delete.unwrap_spec = ['self', ObjSpace, W_Root]
def getter(self, space, w_getter):
return self._copy(space, w_getter=w_getter)
- getter.unwrap_spec = ['self', ObjSpace, W_Root]
def setter(self, space, w_setter):
return self._copy(space, w_setter=w_setter)
- setter.unwrap_spec = ['self', ObjSpace, W_Root]
def deleter(self, space, w_deleter):
return self._copy(space, w_deleter=w_deleter)
- deleter.unwrap_spec = ['self', ObjSpace, W_Root]
def _copy(self, space, w_getter=None, w_setter=None, w_deleter=None):
if w_getter is None:
diff --git a/pypy/module/__builtin__/functional.py b/pypy/module/__builtin__/functional.py
--- a/pypy/module/__builtin__/functional.py
+++ b/pypy/module/__builtin__/functional.py
@@ -4,11 +4,10 @@
"""
from pypy.interpreter.error import OperationError
-from pypy.interpreter.gateway import ObjSpace, W_Root, NoneNotWrapped, applevel
-from pypy.interpreter.gateway import interp2app
+from pypy.interpreter.gateway import NoneNotWrapped, applevel
+from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.typedef import TypeDef
from pypy.interpreter.baseobjspace import Wrappable
-from pypy.interpreter.argument import Arguments
from pypy.rlib.rarithmetic import r_uint, intmask
from pypy.rlib.objectmodel import specialize
from inspect import getsource, getfile
@@ -96,7 +95,6 @@
res_w[idx] = space.wrap(v)
v += step
return space.newlist(res_w)
-range_int.unwrap_spec = [ObjSpace, W_Root, W_Root, W_Root]
def range_withspecialized_implementation(space, start, step, howmany):
@@ -211,7 +209,6 @@
With two or more arguments, return the largest argument.
"""
return min_max(space, __args__, "max")
-max.unwrap_spec = [ObjSpace, Arguments]
def min(space, __args__):
"""Return the smallest item in a sequence.
@@ -219,8 +216,8 @@
If more than one argument is passed, return the minimum of them.
"""
return min_max(space, __args__, "min")
-min.unwrap_spec = [ObjSpace, Arguments]
+ at unwrap_spec(collections_w="args_w")
def map(space, w_func, collections_w):
"""does 3 separate things, hence this enormous docstring.
1. if function is None, return a list of tuples, each with one
@@ -250,7 +247,6 @@
result_w = map_multiple_collections(space, w_func, collections_w,
none_func)
return space.newlist(result_w)
-map.unwrap_spec = [ObjSpace, W_Root, "args_w"]
def map_single_collection(space, w_func, w_collection):
"""Special case for 'map(func, coll)', where 'func' is not None and there
@@ -350,8 +346,8 @@
break
w_last = space.add(w_last, w_next)
return w_last
-sum.unwrap_spec = [ObjSpace, W_Root, W_Root]
+ at unwrap_spec(sequences_w="args_w")
def zip(space, sequences_w):
"""Return a list of tuples, where the nth tuple contains every nth item of
each collection.
@@ -371,7 +367,6 @@
raise
return space.newlist(result_w)
result_w.append(space.newtuple(items_w))
-zip.unwrap_spec = [ObjSpace, "args_w"]
def reduce(space, w_func, w_sequence, w_initial=NoneNotWrapped):
""" Apply function of two arguments cumulatively to the items of sequence,
@@ -397,7 +392,6 @@
break
w_result = space.call_function(w_func, w_result, w_next)
return w_result
-reduce.unwrap_spec = [ObjSpace, W_Root, W_Root, W_Root]
def filter(space, w_func, w_seq):
"""construct a list of those elements of collection for which function
@@ -473,7 +467,6 @@
if not space.is_true(w_next):
return space.w_False
return space.w_True
-all.unwrap_spec = [ObjSpace, W_Root]
def any(space, w_S):
@@ -491,7 +484,6 @@
if space.is_true(w_next):
return space.w_True
return space.w_False
-any.unwrap_spec = [ObjSpace, W_Root]
class W_Enumerate(Wrappable):
@@ -511,14 +503,12 @@
def descr___iter__(self, space):
return space.wrap(self)
- descr___iter__.unwrap_spec = ["self", ObjSpace]
def descr_next(self, space):
w_item = space.next(self.w_iter)
w_index = self.w_index
self.w_index = space.add(w_index, space.wrap(1))
return space.newtuple([w_index, w_item])
- descr_next.unwrap_spec = ["self", ObjSpace]
def descr___reduce__(self, space):
from pypy.interpreter.mixedmodule import MixedModule
@@ -527,7 +517,6 @@
w_new_inst = mod.get('enumerate_new')
w_info = space.newtuple([self.w_iter, self.w_index])
return space.newtuple([w_new_inst, w_info])
- descr___reduce__.unwrap_spec = ["self", ObjSpace]
# exported through _pickle_support
def _make_enumerate(space, w_iter, w_index):
@@ -553,7 +542,6 @@
if w_reversed is not None:
return space.call_function(w_reversed)
return space.wrap(W_ReversedIterator(space, w_sequence))
-reversed.unwrap_spec = [ObjSpace, W_Root]
class W_ReversedIterator(Wrappable):
@@ -566,7 +554,6 @@
def descr___iter__(self, space):
return space.wrap(self)
- descr___iter__.unwrap_spec = ["self", ObjSpace]
def descr_next(self, space):
if self.remaining >= 0:
@@ -583,7 +570,6 @@
# Done
self.remaining = -1
raise OperationError(space.w_StopIteration, space.w_None)
- descr_next.unwrap_spec = ["self", ObjSpace]
def descr___reduce__(self, space):
from pypy.interpreter.mixedmodule import MixedModule
@@ -593,7 +579,6 @@
info_w = [self.w_sequence, space.wrap(self.remaining)]
w_info = space.newtuple(info_w)
return space.newtuple([w_new_inst, w_info])
- descr___reduce__.unwrap_spec = ["self", ObjSpace]
W_ReversedIterator.typedef = TypeDef("reversed",
__iter__=interp2app(W_ReversedIterator.descr___iter__),
@@ -643,6 +628,7 @@
def descr_len(self):
return self.space.wrap(self.len)
+ @unwrap_spec(i='index')
def descr_getitem(self, i):
# xrange does NOT support slicing
space = self.space
@@ -680,8 +666,7 @@
W_XRange.typedef = TypeDef("xrange",
__new__ = interp2app(W_XRange.descr_new.im_func),
__repr__ = interp2app(W_XRange.descr_repr),
- __getitem__ = interp2app(W_XRange.descr_getitem,
- unwrap_spec=['self', 'index']),
+ __getitem__ = interp2app(W_XRange.descr_getitem),
__iter__ = interp2app(W_XRange.descr_iter),
__len__ = interp2app(W_XRange.descr_len),
__reversed__ = interp2app(W_XRange.descr_reversed),
More information about the Pypy-commit
mailing list