def oct(self): return SomeString()
def repr(self): return SomeString()
def hex(self): return SomeString()
def mul((str1, int2)): # xxx do we want to support this return SomeString(no_nul=str1.no_nul)
def str(self): return SomeString()
def method_build(self): return SomeString(can_be_None=False)
def method_build(self): return SomeString()
self.listitem.resized and 'r' or '', self.listitem.immutable and 'I' or '', self.listitem.must_not_resize and '!R' or '') def mutate(self): self.listitem.mutate() def resize(self): self.listitem.mutate() self.listitem.resize() def never_resize(self): if self.listitem.resized: raise ListChangeUnallowed("list already resized") self.listitem.must_not_resize = True def mark_as_immutable(self): # Sets the 'immutable' flag. Note that unlike "never resized", # the immutable flag is only a hint. It is cleared again e.g. # when we merge with a "normal" list that doesn't have it. It # is thus expected to live only shortly, mostly for the case # of writing 'x.list[n]'. self.never_resize() if not self.listitem.mutated: self.listitem.immutable = True #else: it's fine, don't set immutable=True at all (see # test_can_merge_immutable_list_with_regular_list) s_list_of_strings = SomeList(ListDef(None, SomeString(no_nul=True), resized = True))
def immutablevalue(self, x): """The most precise SomeValue instance that contains the immutable value x.""" # convert unbound methods to the underlying function if hasattr(x, 'im_self') and x.im_self is None: x = x.im_func assert not hasattr(x, 'im_self') tp = type(x) if issubclass(tp, Symbolic): # symbolic constants support result = x.annotation() result.const_box = Constant(x) return result if tp is bool: result = SomeBool() elif tp is int: result = SomeInteger(nonneg=x >= 0) elif tp is long: if -sys.maxint - 1 <= x <= sys.maxint: x = int(x) result = SomeInteger(nonneg=x >= 0) else: # XXX: better error reporting? raise ValueError("seeing a prebuilt long (value %s)" % hex(x)) elif issubclass(tp, str): # py.lib uses annotated str subclasses no_nul = not '\x00' in x if len(x) == 1: result = SomeChar(no_nul=no_nul) else: result = SomeString(no_nul=no_nul) elif tp is unicode: no_nul = not u'\x00' in x if len(x) == 1: result = SomeUnicodeCodePoint(no_nul=no_nul) else: result = SomeUnicodeString(no_nul=no_nul) elif tp is bytearray: result = SomeByteArray() elif tp is tuple: result = SomeTuple(items=[self.immutablevalue(e) for e in x]) elif tp is float: result = SomeFloat() elif tp is list: key = Constant(x) try: return self.immutable_cache[key] except KeyError: result = SomeList(ListDef(self, s_ImpossibleValue)) self.immutable_cache[key] = result for e in x: result.listdef.generalize(self.immutablevalue(e)) result.const_box = key return result elif (tp is dict or tp is r_dict or tp is OrderedDict or tp is r_ordereddict): key = Constant(x) try: return self.immutable_cache[key] except KeyError: if tp is OrderedDict or tp is r_ordereddict: cls = SomeOrderedDict else: cls = SomeDict is_r_dict = issubclass(tp, r_dict) result = cls( DictDef(self, s_ImpossibleValue, s_ImpossibleValue, is_r_dict=is_r_dict)) self.immutable_cache[key] = result if is_r_dict: s_eqfn = self.immutablevalue(x.key_eq) s_hashfn = self.immutablevalue(x.key_hash) result.dictdef.dictkey.update_rdict_annotations( s_eqfn, s_hashfn) seen_elements = 0 while seen_elements != len(x): items = x.items() for ek, ev in items: result.dictdef.generalize_key(self.immutablevalue(ek)) result.dictdef.generalize_value( self.immutablevalue(ev)) result.dictdef.seen_prebuilt_key(ek) seen_elements = len(items) # if the dictionary grew during the iteration, # start over again result.const_box = key return result elif tp is weakref.ReferenceType: x1 = x() if x1 is None: result = SomeWeakRef(None) # dead weakref else: s1 = self.immutablevalue(x1) assert isinstance(s1, SomeInstance) result = SomeWeakRef(s1.classdef) elif tp is property: return SomeProperty(x) elif ishashable(x) and x in BUILTIN_ANALYZERS: _module = getattr(x, "__module__", "unknown") result = SomeBuiltin(BUILTIN_ANALYZERS[x], methodname="%s.%s" % (_module, x.__name__)) elif extregistry.is_registered(x): entry = extregistry.lookup(x) result = entry.compute_annotation_bk(self) elif tp is type: result = SomeConstantType(x, self) elif callable(x): if hasattr(x, 'im_self') and hasattr(x, 'im_func'): # on top of PyPy, for cases like 'l.append' where 'l' is a # global constant list, the find_method() returns non-None s_self = self.immutablevalue(x.im_self) result = s_self.find_method(x.im_func.__name__) elif hasattr(x, '__self__') and x.__self__ is not None: # for cases like 'l.append' where 'l' is a global constant list s_self = self.immutablevalue(x.__self__) result = s_self.find_method(x.__name__) assert result is not None else: result = None if result is None: result = SomePBC([self.getdesc(x)]) elif hasattr(x, '_freeze_'): assert x._freeze_() is True # user-defined classes can define a method _freeze_(), which # is called when a prebuilt instance is found. If the method # returns True, the instance is considered immutable and becomes # a SomePBC(). Otherwise it's just SomeInstance(). result = SomePBC([self.getdesc(x)]) elif hasattr(x, '__class__') \ and x.__class__.__module__ != '__builtin__': if hasattr(x, '_cleanup_'): x._cleanup_() classdef = self.getuniqueclassdef(x.__class__) classdef.see_instance(x) result = SomeInstance(classdef) elif x is None: return s_None else: raise Exception("Don't know how to represent %r" % (x, )) result.const = x return result
result = getattr(self.obj, '__dict__', {}).keys() tp = self.obj.__class__ if isinstance(tp, type): for basetype in tp.__mro__: slots = basetype.__dict__.get('__slots__') if slots: if isinstance(slots, str): result.append(slots) else: result.extend(slots) return result class NoSuchAttrError(AnnotatorError): """Raised when an attribute is found on a class where __slots__ or _attrs_ forbits it.""" # ____________________________________________________________ FORCE_ATTRIBUTES_INTO_CLASSES = { EnvironmentError: {'errno': SomeInteger(), 'strerror': SomeString(can_be_None=True), 'filename': SomeString(can_be_None=True)}, } try: WindowsError except NameError: pass else: FORCE_ATTRIBUTES_INTO_CLASSES[WindowsError] = {'winerror': SomeInteger()}
def conf(): return SomeString()
or '', self.listitem.resized and 'r' or '', self.listitem.immutable and 'I' or '', self.listitem.must_not_resize and '!R' or '') def mutate(self): self.listitem.mutate() def resize(self): self.listitem.mutate() self.listitem.resize() def never_resize(self): if self.listitem.resized: raise ListChangeUnallowed("list already resized") self.listitem.must_not_resize = True def mark_as_immutable(self): # Sets the 'immutable' flag. Note that unlike "never resized", # the immutable flag is only a hint. It is cleared again e.g. # when we merge with a "normal" list that doesn't have it. It # is thus expected to live only shortly, mostly for the case # of writing 'x.list[n]'. self.never_resize() if not self.listitem.mutated: self.listitem.immutable = True #else: it's fine, don't set immutable=True at all (see # test_can_merge_immutable_list_with_regular_list) s_list_of_strings = SomeList( ListDef(None, SomeString(no_nul=True), resized=True))
self.args = args def execute(self, space): getattr(space, self.method)(*self.args) def __repr__(self): return "space.%s(%s)" % (self.method, ', '.join(map(repr, self.args))) class PseudoRTyper: cache_dummy_values = {} # XXX: None keys crash the test, but translation sort-of allows it keytypes_s = [ SomeString(), SomeInteger(), SomeChar(), SomeUnicodeString(), SomeUnicodeCodePoint() ] st_keys = sampled_from(keytypes_s) st_values = sampled_from(keytypes_s + [SomeString(can_be_None=True)]) class MappingSpace(object): def __init__(self, s_key, s_value): from rpython.rtyper.rtuple import TupleRepr self.s_key = s_key self.s_value = s_value
self.setupterm_called = False module_info = ModuleInfo() class curses_error(Exception): def __init__(self, msg): self.msg = msg from rpython.annotator.classdef import FORCE_ATTRIBUTES_INTO_CLASSES from rpython.annotator.model import SomeString # this is necessary due to annmixlevel FORCE_ATTRIBUTES_INTO_CLASSES[curses_error] = {'msg': SomeString()} def convert_error(space, error): msg = error.msg w_module = space.getbuiltinmodule('_minimal_curses') w_exception_class = space.getattr(w_module, space.wrap('error')) w_exception = space.call_function(w_exception_class, space.wrap(msg)) return OperationError(w_exception_class, w_exception) def _curses_setupterm_null(fd): # NOT_RPYTHON try: _curses.setupterm(None, fd) except _curses.error, e:
def method_upper(self): return SomeString()
def union((str1, str2)): can_be_None = str1.can_be_None or str2.can_be_None no_nul = str1.no_nul and str2.no_nul return SomeString(can_be_None=can_be_None, no_nul=no_nul)
def method_lower(self): return SomeString()
def add((str1, str2)): # propagate const-ness to help getattr(obj, 'prefix' + const_name) result = SomeString(no_nul=str1.no_nul and str2.no_nul) if str1.is_immutable_constant() and str2.is_immutable_constant(): result.const = str1.const + str2.const return result
def get_annotation(x): if isinstance(x, basestring) and len(x) > 1: return SomeString(no_nul='\x00' not in x) else: return lltype_to_annotation(typeOf(x))