Author: Carl Friedrich Bolz <cfb...@gmx.de> Branch: Changeset: r92077:8c68d973f65b Date: 2017-08-04 17:25 +0200 http://bitbucket.org/pypy/pypy/changeset/8c68d973f65b/
Log: merge diff --git a/Makefile b/Makefile --- a/Makefile +++ b/Makefile @@ -10,7 +10,7 @@ RUNINTERP = $(PYPY_EXECUTABLE) endif -.PHONY: cffi_imports +.PHONY: pypy-c cffi_imports pypy-c: @echo @@ -32,7 +32,7 @@ @echo "====================================================================" @echo @sleep 5 - $(RUNINTERP) rpython/bin/rpython -Ojit pypy/goal/targetpypystandalone.py + cd pypy/goal && $(RUNINTERP) ../../rpython/bin/rpython -Ojit targetpypystandalone.py # Note: the -jN option, or MAKEFLAGS=-jN, are not usable. They are # replaced with an opaque --jobserver option by the time this Makefile @@ -40,4 +40,4 @@ # http://lists.gnu.org/archive/html/help-make/2010-08/msg00106.html cffi_imports: pypy-c - PYTHONPATH=. ./pypy-c pypy/tool/build_cffi_imports.py || /bin/true + PYTHONPATH=. pypy/goal/pypy-c pypy/tool/build_cffi_imports.py || /bin/true diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py --- a/pypy/config/pypyoption.py +++ b/pypy/config/pypyoption.py @@ -224,11 +224,6 @@ "use specialised tuples", default=False), - BoolOption("withcelldict", - "use dictionaries that are optimized for being used as module dicts", - default=False, - requires=[("objspace.honor__builtins__", False)]), - BoolOption("withliststrategies", "enable optimized ways to store lists of primitives ", default=True), @@ -288,7 +283,7 @@ # extra optimizations with the JIT if level == 'jit': - config.objspace.std.suggest(withcelldict=True) + pass # none at the moment def enable_allworkingmodules(config): diff --git a/pypy/doc/config/objspace.std.withcelldict.txt b/pypy/doc/config/objspace.std.withcelldict.txt deleted file mode 100644 --- a/pypy/doc/config/objspace.std.withcelldict.txt +++ /dev/null @@ -1,2 +0,0 @@ -Enable cell-dicts. This optimization is not helpful without the JIT. In the -presence of the JIT, it greatly helps looking up globals. diff --git a/pypy/interpreter/argument.py b/pypy/interpreter/argument.py --- a/pypy/interpreter/argument.py +++ b/pypy/interpreter/argument.py @@ -2,6 +2,7 @@ Arguments objects. """ from rpython.rlib.debug import make_sure_not_resized +from rpython.rlib.objectmodel import not_rpython from rpython.rlib import jit from pypy.interpreter.error import OperationError, oefmt @@ -46,8 +47,8 @@ # behaviour but produces better error messages self.methodcall = methodcall + @not_rpython def __repr__(self): - """ NOT_RPYTHON """ name = self.__class__.__name__ if not self.keywords: return '%s(%s)' % (name, self.arguments_w,) diff --git a/pypy/interpreter/error.py b/pypy/interpreter/error.py --- a/pypy/interpreter/error.py +++ b/pypy/interpreter/error.py @@ -7,6 +7,7 @@ from rpython.rlib import jit from rpython.rlib.objectmodel import we_are_translated, specialize +from rpython.rlib.objectmodel import not_rpython from rpython.rlib import rstack, rstackovf from pypy.interpreter import debug @@ -57,8 +58,9 @@ self.match(space, space.w_KeyboardInterrupt)) # note: an extra case is added in OpErrFmtNoArgs + @not_rpython def __str__(self): - "NOT_RPYTHON: Convenience for tracebacks." + "Convenience for tracebacks." s = self._w_value space = getattr(self.w_type, 'space', None) if space is not None: @@ -107,15 +109,16 @@ if RECORD_INTERPLEVEL_TRACEBACK: self.debug_excs.append(sys.exc_info()) + @not_rpython def print_application_traceback(self, space, file=None): - "NOT_RPYTHON: Dump a standard application-level traceback." + "Dump a standard application-level traceback." if file is None: file = sys.stderr self.print_app_tb_only(file) print >> file, self.errorstr(space) + @not_rpython def print_app_tb_only(self, file): - "NOT_RPYTHON" tb = self._application_traceback if tb: import linecache @@ -142,8 +145,9 @@ print >> file, l tb = tb.next + @not_rpython def print_detailed_traceback(self, space=None, file=None): - """NOT_RPYTHON: Dump a nice detailed interpreter- and + """Dump a nice detailed interpreter- and application-level traceback, useful to debug the interpreter.""" if file is None: file = sys.stderr diff --git a/pypy/interpreter/executioncontext.py b/pypy/interpreter/executioncontext.py --- a/pypy/interpreter/executioncontext.py +++ b/pypy/interpreter/executioncontext.py @@ -1,7 +1,7 @@ import sys from pypy.interpreter.error import OperationError, get_cleared_operation_error from rpython.rlib.unroll import unrolling_iterable -from rpython.rlib.objectmodel import specialize +from rpython.rlib.objectmodel import specialize, not_rpython from rpython.rlib import jit, rgc, objectmodel TICK_COUNTER_STEP = 100 @@ -423,8 +423,9 @@ # to run at the next possible bytecode self.reset_ticker(-1) + @not_rpython def register_periodic_action(self, action, use_bytecode_counter): - """NOT_RPYTHON: + """ Register the PeriodicAsyncAction action to be called whenever the tick counter becomes smaller than 0. If 'use_bytecode_counter' is True, make sure that we decrease the tick counter at every bytecode. diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py --- a/pypy/interpreter/gateway.py +++ b/pypy/interpreter/gateway.py @@ -23,7 +23,7 @@ DescrMismatch) from pypy.interpreter.error import OperationError, oefmt from pypy.interpreter.function import ClassMethod, FunctionWithFixedCode -from rpython.rlib.objectmodel import we_are_translated +from rpython.rlib.objectmodel import we_are_translated, not_rpython from rpython.rlib.rarithmetic import r_longlong, r_int, r_ulonglong, r_uint from rpython.tool.sourcetools import func_with_new_name, compile2 @@ -64,8 +64,8 @@ def _freeze_(self): return True + @not_rpython def unwrap(self, space, w_value): - """NOT_RPYTHON""" raise NotImplementedError @@ -380,8 +380,8 @@ class BuiltinActivation(object): _immutable_ = True + @not_rpython def __init__(self, behavior): - """NOT_RPYTHON""" self.behavior = behavior def _run(self, space, scope_w): @@ -621,9 +621,9 @@ # When a BuiltinCode is stored in a Function object, # you get the functionality of CPython's built-in function type. + @not_rpython def __init__(self, func, unwrap_spec=None, self_type=None, descrmismatch=None, doc=None): - "NOT_RPYTHON" # 'implfunc' is the interpreter-level function. # Note that this uses a lot of (construction-time) introspection. Code.__init__(self, func.__name__) @@ -969,10 +969,10 @@ instancecache = {} + @not_rpython def __new__(cls, f, app_name=None, unwrap_spec=None, descrmismatch=None, as_classmethod=False, doc=None): - "NOT_RPYTHON" # f must be a function whose name does NOT start with 'app_' self_type = None if hasattr(f, 'im_func'): @@ -1013,8 +1013,8 @@ self._staticdefs = zip(argnames[-len(defaults):], defaults) return self + @not_rpython def _getdefaults(self, space): - "NOT_RPYTHON" defs_w = [] for name, defaultval in self._staticdefs: if name.startswith('w_'): @@ -1070,8 +1070,8 @@ class GatewayCache(SpaceCache): + @not_rpython def build(cache, gateway): - "NOT_RPYTHON" space = cache.space defs = gateway._getdefaults(space) # needs to be implemented by subclass code = gateway._code @@ -1141,8 +1141,8 @@ w_globals = self.getwdict(space) return space.getitem(w_globals, space.newtext(name)) + @not_rpython def interphook(self, name): - "NOT_RPYTHON" def appcaller(space, *args_w): if not isinstance(space, ObjSpace): raise TypeError("first argument must be a space instance.") @@ -1179,15 +1179,16 @@ """NOT_RPYTHON The cache mapping each applevel instance to its lazily built w_dict""" + @not_rpython def build(self, app): - "NOT_RPYTHON. Called indirectly by Applevel.getwdict()." + "Called indirectly by Applevel.getwdict()." return build_applevel_dict(app, self.space) # __________ pure applevel version __________ +@not_rpython def build_applevel_dict(self, space): - "NOT_RPYTHON" w_glob = space.newdict(module=True) space.setitem(w_glob, space.newtext('__name__'), space.newtext(self.modname)) space.exec_(self.source, w_glob, w_glob, @@ -1198,8 +1199,9 @@ # ____________________________________________________________ +@not_rpython def appdef(source, applevel=ApplevelClass, filename=None): - """ NOT_RPYTHON: build an app-level helper function, like for example: + """ build an app-level helper function, like for example: myfunc = appdef('''myfunc(x, y): return x+y ''') @@ -1245,6 +1247,6 @@ # app2interp_temp is used for testing mainly +@not_rpython def app2interp_temp(func, applevel_temp=applevel_temp, filename=None): - """ NOT_RPYTHON """ return appdef(func, applevel_temp, filename=filename) diff --git a/pypy/interpreter/miscutils.py b/pypy/interpreter/miscutils.py --- a/pypy/interpreter/miscutils.py +++ b/pypy/interpreter/miscutils.py @@ -3,6 +3,7 @@ """ from rpython.rlib.listsort import make_timsort_class +from rpython.rlib.objectmodel import not_rpython class ThreadLocals: @@ -41,9 +42,8 @@ # but in some corner cases it is not... unsure why self._value = None - +@not_rpython def make_weak_value_dictionary(space, keytype, valuetype): - "NOT_RPYTHON" if space.config.translation.rweakref: from rpython.rlib.rweakref import RWeakValueDictionary return RWeakValueDictionary(keytype, valuetype) diff --git a/pypy/interpreter/mixedmodule.py b/pypy/interpreter/mixedmodule.py --- a/pypy/interpreter/mixedmodule.py +++ b/pypy/interpreter/mixedmodule.py @@ -3,6 +3,9 @@ from pypy.interpreter import gateway from pypy.interpreter.error import OperationError from pypy.interpreter.baseobjspace import W_Root + +from rpython.rlib.objectmodel import not_rpython + import sys class MixedModule(Module): @@ -15,16 +18,17 @@ lazy = False submodule_name = None + @not_rpython def __init__(self, space, w_name): - """ NOT_RPYTHON """ Module.__init__(self, space, w_name) self.lazy = True self.__class__.buildloaders() self.loaders = self.loaders.copy() # copy from the class to the inst self.submodules_w = [] + @not_rpython def install(self): - """NOT_RPYTHON: install this module, and it's submodules into + """install this module, and it's submodules into space.builtin_modules""" Module.install(self) if hasattr(self, "submodules"): @@ -61,8 +65,8 @@ self.w_initialdict = self.space.call_method(self.w_dict, 'items') @classmethod + @not_rpython def get_applevel_name(cls): - """ NOT_RPYTHON """ if cls.applevel_name is not None: return cls.applevel_name else: @@ -130,8 +134,8 @@ self._frozen = True @classmethod + @not_rpython def buildloaders(cls): - """ NOT_RPYTHON """ if not hasattr(cls, 'loaders'): # build a constant dictionary out of # applevel/interplevel definitions @@ -161,8 +165,8 @@ return space.newtext_or_none(cls.__doc__) +@not_rpython def getinterpevalloader(pkgroot, spec): - """ NOT_RPYTHON """ def ifileloader(space): d = {'space':space} # EVIL HACK (but it works, and this is not RPython :-) @@ -202,8 +206,8 @@ return ifileloader applevelcache = {} +@not_rpython def getappfileloader(pkgroot, appname, spec): - """ NOT_RPYTHON """ # hum, it's a bit more involved, because we usually # want the import at applevel modname, attrname = spec.split('.') diff --git a/pypy/interpreter/module.py b/pypy/interpreter/module.py --- a/pypy/interpreter/module.py +++ b/pypy/interpreter/module.py @@ -4,7 +4,7 @@ from pypy.interpreter.baseobjspace import W_Root from pypy.interpreter.error import OperationError -from rpython.rlib.objectmodel import we_are_translated +from rpython.rlib.objectmodel import we_are_translated, not_rpython class Module(W_Root): @@ -40,13 +40,15 @@ except OperationError: pass + @not_rpython def install(self): - """NOT_RPYTHON: installs this module into space.builtin_modules""" + """installs this module into space.builtin_modules""" modulename = self.space.text0_w(self.w_name) self.space.builtin_modules[modulename] = self + @not_rpython def setup_after_space_initialization(self): - """NOT_RPYTHON: to allow built-in modules to do some more setup + """to allow built-in modules to do some more setup after the space is fully initialized.""" def init(self, space): diff --git a/pypy/interpreter/pyframe.py b/pypy/interpreter/pyframe.py --- a/pypy/interpreter/pyframe.py +++ b/pypy/interpreter/pyframe.py @@ -7,6 +7,7 @@ from rpython.rlib.debug import ll_assert_not_none from rpython.rlib.jit import hint from rpython.rlib.objectmodel import instantiate, specialize, we_are_translated +from rpython.rlib.objectmodel import not_rpython from rpython.rlib.rarithmetic import intmask, r_uint from rpython.tool.pairtype import extendabletype @@ -144,8 +145,9 @@ return None return d.w_locals + @not_rpython def __repr__(self): - # NOT_RPYTHON: useful in tracebacks + # useful in tracebacks return "<%s.%s executing %s at line %s" % ( self.__class__.__module__, self.__class__.__name__, self.pycode, self.get_last_lineno()) diff --git a/pypy/interpreter/pyopcode.py b/pypy/interpreter/pyopcode.py --- a/pypy/interpreter/pyopcode.py +++ b/pypy/interpreter/pyopcode.py @@ -7,7 +7,7 @@ from rpython.rlib import jit, rstackovf from rpython.rlib.debug import check_nonneg from rpython.rlib.objectmodel import (we_are_translated, always_inline, - dont_inline) + dont_inline, not_rpython) from rpython.rlib.rarithmetic import r_uint, intmask from rpython.tool.sourcetools import func_with_new_name @@ -20,8 +20,8 @@ from pypy.interpreter.pycode import PyCode, BytecodeCorruption from pypy.tool.stdlib_opcode import bytecode_spec +@not_rpython def unaryoperation(operationname): - """NOT_RPYTHON""" def opimpl(self, *ignored): operation = getattr(self.space, operationname) w_1 = self.popvalue() @@ -31,8 +31,8 @@ return func_with_new_name(opimpl, "opcode_impl_for_%s" % operationname) +@not_rpython def binaryoperation(operationname): - """NOT_RPYTHON""" def opimpl(self, *ignored): operation = getattr(self.space, operationname) w_2 = self.popvalue() diff --git a/pypy/interpreter/typedef.py b/pypy/interpreter/typedef.py --- a/pypy/interpreter/typedef.py +++ b/pypy/interpreter/typedef.py @@ -8,14 +8,15 @@ from rpython.rlib.jit import promote from rpython.rlib.objectmodel import compute_identity_hash, specialize -from rpython.rlib.objectmodel import instantiate +from rpython.rlib.objectmodel import instantiate, not_rpython from rpython.tool.sourcetools import compile2, func_with_new_name class TypeDef(object): + @not_rpython def __init__(self, __name, __base=None, __total_ordering__=None, __buffer=None, **rawdict): - "NOT_RPYTHON: initialization-time only" + "initialization-time only" self.name = __name if __base is None: bases = [] @@ -113,8 +114,9 @@ # register_finalizer() or not. @specialize.memo() +@not_rpython def get_unique_interplevel_subclass(space, cls): - "NOT_RPYTHON: initialization-time only" + "initialization-time only" assert cls.typedef.acceptable_as_base_class try: return _unique_subclass_cache[cls] @@ -349,15 +351,17 @@ return self +@not_rpython def interp_attrproperty(name, cls, doc=None, wrapfn=None): - "NOT_RPYTHON: initialization-time only" + "initialization-time only" assert wrapfn is not None def fget(space, obj): return getattr(space, wrapfn)(getattr(obj, name)) return GetSetProperty(fget, cls=cls, doc=doc) +@not_rpython def interp_attrproperty_w(name, cls, doc=None): - "NOT_RPYTHON: initialization-time only" + "initialization-time only" def fget(space, obj): w_value = getattr(obj, name) if w_value is None: diff --git a/pypy/module/__builtin__/test/test_classobj.py b/pypy/module/__builtin__/test/test_classobj.py --- a/pypy/module/__builtin__/test/test_classobj.py +++ b/pypy/module/__builtin__/test/test_classobj.py @@ -1090,18 +1090,18 @@ def setup_class(cls): if cls.runappdirect: py.test.skip("can only be run on py.py") - def is_strdict(space, w_class): - from pypy.objspace.std.dictmultiobject import BytesDictStrategy + def is_moduledict(space, w_class): + from pypy.objspace.std.celldict import ModuleDictStrategy w_d = w_class.getdict(space) - return space.wrap(isinstance(w_d.get_strategy(), BytesDictStrategy)) + return space.wrap(isinstance(w_d.get_strategy(), ModuleDictStrategy)) - cls.w_is_strdict = cls.space.wrap(gateway.interp2app(is_strdict)) + cls.w_is_moduledict = cls.space.wrap(gateway.interp2app(is_moduledict)) - def test_strdict(self): + def test_moduledict(self): class A: a = 1 b = 2 - assert self.is_strdict(A) + assert self.is_moduledict(A) def test_attr_slots(self): class C: diff --git a/pypy/module/_codecs/__init__.py b/pypy/module/_codecs/__init__.py --- a/pypy/module/_codecs/__init__.py +++ b/pypy/module/_codecs/__init__.py @@ -1,5 +1,6 @@ from pypy.interpreter.mixedmodule import MixedModule from rpython.rlib import runicode +from rpython.rlib.objectmodel import not_rpython from pypy.module._codecs import interp_codecs class Module(MixedModule): @@ -86,9 +87,8 @@ 'unicode_internal_encode' : 'interp_codecs.unicode_internal_encode', } + @not_rpython def __init__(self, space, *args): - "NOT_RPYTHON" - # mbcs codec is Windows specific, and based on rffi. if (hasattr(runicode, 'str_decode_mbcs')): self.interpleveldefs['mbcs_encode'] = 'interp_codecs.mbcs_encode' diff --git a/pypy/module/_codecs/interp_codecs.py b/pypy/module/_codecs/interp_codecs.py --- a/pypy/module/_codecs/interp_codecs.py +++ b/pypy/module/_codecs/interp_codecs.py @@ -1,5 +1,5 @@ from rpython.rlib import jit -from rpython.rlib.objectmodel import we_are_translated +from rpython.rlib.objectmodel import we_are_translated, not_rpython from rpython.rlib.rstring import UnicodeBuilder from rpython.rlib.runicode import code_to_unichr, MAXUNICODE @@ -268,8 +268,8 @@ raise oefmt(space.w_TypeError, "don't know how to handle %T in error callback", w_exc) +@not_rpython def register_builtin_error_handlers(space): - "NOT_RPYTHON" state = space.fromcache(CodecState) for error in ("strict", "ignore", "replace", "xmlcharrefreplace", "backslashreplace"): diff --git a/pypy/module/array/interp_array.py b/pypy/module/array/interp_array.py --- a/pypy/module/array/interp_array.py +++ b/pypy/module/array/interp_array.py @@ -118,6 +118,29 @@ return space.w_True return space.w_False +index_count_jd = jit.JitDriver( + greens = ['count', 'arrclass', 'tp_item'], + reds = 'auto', name = 'array.index_or_count') + +def index_count_array(arr, w_val, count=False): + space = arr.space + tp_item = space.type(w_val) + arrclass = arr.__class__ + cnt = 0 + for i in range(arr.len): + index_count_jd.jit_merge_point( + tp_item=tp_item, count=count, + arrclass=arrclass) + w_item = arr.w_getitem(space, i) + if space.eq_w(w_item, w_val): + if count: + cnt += 1 + else: + return i + if count: + return cnt + return -1 + UNICODE_ARRAY = lltype.Ptr(lltype.Array(lltype.UniChar, hints={'nolength': True})) @@ -257,17 +280,12 @@ """ self.extend(w_x) - def descr_count(self, space, w_val): + def descr_count(self, space, w_x): """ count(x) Return number of occurrences of x in the array. """ - cnt = 0 - for i in range(self.len): - # XXX jitdriver - w_item = self.w_getitem(space, i) - if space.eq_w(w_item, w_val): - cnt += 1 + cnt = index_count_array(self, w_x, count=True) return space.newint(cnt) def descr_index(self, space, w_x): @@ -275,10 +293,9 @@ Return index of first occurrence of x in the array. """ - for i in range(self.len): - w_item = self.w_getitem(space, i) - if space.eq_w(w_item, w_x): - return space.newint(i) + res = index_count_array(self, w_x, count=False) + if res >= 0: + return space.newint(res) raise oefmt(space.w_ValueError, "array.index(x): x not in list") def descr_reverse(self, space): @@ -752,7 +769,9 @@ class TypeCode(object): def __init__(self, itemtype, unwrap, canoverflow=False, signed=False, - method='__int__'): + method='__int__', errorname=None): + if errorname is None: + errorname = unwrap[:-2] self.itemtype = itemtype self.bytes = rffi.sizeof(itemtype) self.arraytype = lltype.Array(itemtype, hints={'nolength': True}) @@ -762,6 +781,7 @@ self.canoverflow = canoverflow self.w_class = None self.method = method + self.errorname = errorname def _freeze_(self): # hint for the annotator: track individual constant instances @@ -785,8 +805,8 @@ 'i': TypeCode(rffi.INT, 'int_w', True, True), 'I': _UINTTypeCode, 'l': TypeCode(rffi.LONG, 'int_w', True, True), - 'L': TypeCode(rffi.ULONG, 'bigint_w'), # Overflow handled by - # rbigint.touint() which + 'L': TypeCode(rffi.ULONG, 'bigint_w', # Overflow handled by + errorname="integer"), # rbigint.touint() which # corresponds to the # C-type unsigned long 'f': TypeCode(lltype.SingleFloat, 'float_w', method='__float__'), @@ -864,7 +884,7 @@ item = unwrap(space.call_method(w_item, mytype.method)) except OperationError: raise oefmt(space.w_TypeError, - "array item must be " + mytype.unwrap[:-2]) + "array item must be " + mytype.errorname) else: raise if mytype.unwrap == 'bigint_w': diff --git a/pypy/module/array/test/test_array.py b/pypy/module/array/test/test_array.py --- a/pypy/module/array/test/test_array.py +++ b/pypy/module/array/test/test_array.py @@ -162,6 +162,11 @@ raises(OverflowError, a.append, -1) raises(OverflowError, a.append, 2 ** (8 * b)) + def test_errormessage(self): + a = self.array("L", [1, 2, 3]) + excinfo = raises(TypeError, "a[0] = 'abc'") + assert str(excinfo.value) == "array item must be integer" + def test_fromstring(self): import sys diff --git a/pypy/module/posix/interp_posix.py b/pypy/module/posix/interp_posix.py --- a/pypy/module/posix/interp_posix.py +++ b/pypy/module/posix/interp_posix.py @@ -3,7 +3,7 @@ from rpython.rlib import rposix, rposix_stat from rpython.rlib import objectmodel, rurandom -from rpython.rlib.objectmodel import specialize +from rpython.rlib.objectmodel import specialize, not_rpython from rpython.rlib.rarithmetic import r_longlong, intmask, r_uint from rpython.rlib.unroll import unrolling_iterable @@ -731,8 +731,8 @@ else: assert False, "Unknown fork hook" +@not_rpython def add_fork_hook(where, hook): - "NOT_RPYTHON" get_fork_hooks(where).append(hook) add_fork_hook('child', ExecutionContext._mark_thread_disappeared) diff --git a/pypy/objspace/std/dictmultiobject.py b/pypy/objspace/std/dictmultiobject.py --- a/pypy/objspace/std/dictmultiobject.py +++ b/pypy/objspace/std/dictmultiobject.py @@ -56,7 +56,7 @@ def allocate_and_init_instance(space, w_type=None, module=False, instance=False, strdict=False, kwargs=False): - if space.config.objspace.std.withcelldict and module: + if module: from pypy.objspace.std.celldict import ModuleDictStrategy assert w_type is None # every module needs its own strategy, because the strategy stores diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py --- a/pypy/objspace/std/objspace.py +++ b/pypy/objspace/std/objspace.py @@ -181,8 +181,8 @@ return self._wrap_not_rpython(x) + @not_rpython def _wrap_not_rpython(self, x): - "NOT_RPYTHON" # _____ this code is here to support testing only _____ # wrap() of a container works on CPython, but the code is diff --git a/pypy/objspace/std/test/test_celldict.py b/pypy/objspace/std/test/test_celldict.py --- a/pypy/objspace/std/test/test_celldict.py +++ b/pypy/objspace/std/test/test_celldict.py @@ -58,7 +58,6 @@ assert v2 is v3 class AppTestModuleDict(object): - spaceconfig = {"objspace.std.withcelldict": True} def setup_class(cls): cls.w_runappdirect = cls.space.wrap(cls.runappdirect) @@ -116,7 +115,6 @@ class AppTestCellDict(object): - spaceconfig = {"objspace.std.withcelldict": True} def setup_class(cls): if cls.runappdirect: diff --git a/pypy/objspace/std/test/test_dictmultiobject.py b/pypy/objspace/std/test/test_dictmultiobject.py --- a/pypy/objspace/std/test/test_dictmultiobject.py +++ b/pypy/objspace/std/test/test_dictmultiobject.py @@ -1261,7 +1261,6 @@ class Config: class objspace: class std: - withcelldict = False methodcachesizeexp = 11 withmethodcachecounter = False @@ -1467,6 +1466,7 @@ def test_module_uses_strdict(): + from pypy.objspace.std.celldict import ModuleDictStrategy fakespace = FakeSpace() d = fakespace.newdict(module=True) - assert type(d.get_strategy()) is BytesDictStrategy + assert type(d.get_strategy()) is ModuleDictStrategy diff --git a/pypy/objspace/std/test/test_mapdict.py b/pypy/objspace/std/test/test_mapdict.py --- a/pypy/objspace/std/test/test_mapdict.py +++ b/pypy/objspace/std/test/test_mapdict.py @@ -4,7 +4,6 @@ class Config: class objspace: class std: - withcelldict = False methodcachesizeexp = 11 withmethodcachecounter = False diff --git a/pypy/objspace/std/typeobject.py b/pypy/objspace/std/typeobject.py --- a/pypy/objspace/std/typeobject.py +++ b/pypy/objspace/std/typeobject.py @@ -11,7 +11,7 @@ from rpython.rlib.jit import (promote, elidable_promote, we_are_jitted, elidable, dont_look_inside, unroll_safe) from rpython.rlib.objectmodel import current_object_addr_as_int, compute_hash -from rpython.rlib.objectmodel import we_are_translated +from rpython.rlib.objectmodel import we_are_translated, not_rpython from rpython.rlib.rarithmetic import intmask, r_uint class MutableCell(W_Root): @@ -212,8 +212,8 @@ else: self.terminator = NoDictTerminator(space, self) + @not_rpython def __repr__(self): - "NOT_RPYTHON" return '<W_TypeObject %r at 0x%x>' % (self.name, id(self)) def mutated(self, key): @@ -492,8 +492,9 @@ self, w_subtype, w_subtype) return w_subtype + @not_rpython def _cleanup_(self): - "NOT_RPYTHON. Forces the lazy attributes to be computed." + "Forces the lazy attributes to be computed." if 'lazyloaders' in self.__dict__: for attr in self.lazyloaders.keys(): self.getdictvalue(self.space, attr) @@ -1317,8 +1318,9 @@ class TypeCache(SpaceCache): + @not_rpython def build(self, typedef): - "NOT_RPYTHON: initialization-time only." + "initialization-time only." from pypy.objspace.std.objectobject import W_ObjectObject from pypy.interpreter.typedef import GetSetProperty from rpython.rlib.objectmodel import instantiate _______________________________________________ pypy-commit mailing list pypy-commit@python.org https://mail.python.org/mailman/listinfo/pypy-commit