""" Unary operations on SomeValues. """ from __future__ import absolute_import from collections import defaultdict from rpython.tool.pairtype import pair from rpython.flowspace.operation import op from rpython.flowspace.model import const, Constant from rpython.flowspace.argument import CallSpec from rpython.annotator.model import (SomeObject, SomeInteger, SomeBool, SomeString, SomeChar, SomeList, SomeDict, SomeTuple, SomeImpossibleValue, SomeUnicodeCodePoint, SomeInstance, SomeBuiltin, SomeBuiltinMethod, SomeFloat, SomeIterator, SomePBC, SomeNone, SomeTypeOf, s_ImpossibleValue, s_Bool, s_None, s_Int, unionof, add_knowntypedata, SomeWeakRef, SomeUnicodeString, SomeByteArray, SomeOrderedDict) from rpython.annotator.bookkeeper import getbookkeeper, immutablevalue from rpython.annotator.binaryop import _clone ## XXX where to put this? from rpython.annotator.binaryop import _dict_can_only_throw_keyerror from rpython.annotator.binaryop import _dict_can_only_throw_nothing from rpython.annotator.classdesc import ClassDesc, is_primitive_type, BuiltinTypeDesc from rpython.annotator.model import AnnotatorError from rpython.annotator.argument import simple_args, complex_args UNARY_OPERATIONS = set([oper.opname for oper in op.__dict__.values() if oper.dispatch == 1]) UNARY_OPERATIONS.remove('contains') @op.type.register(SomeObject) def type_SomeObject(annotator, v_arg): return SomeTypeOf([v_arg]) def our_issubclass(bk, cls1, cls2): def toclassdesc(cls): if isinstance(cls, ClassDesc): return cls elif is_primitive_type(cls): return BuiltinTypeDesc(cls) else: return bk.getdesc(cls) return toclassdesc(cls1).issubclass(toclassdesc(cls2)) def s_isinstance(annotator, s_obj, s_type, variables): if not s_type.is_constant(): return SomeBool() r = SomeBool() typ = s_type.const bk = annotator.bookkeeper if s_obj.is_constant(): r.const = isinstance(s_obj.const, typ) elif our_issubclass(bk, s_obj.knowntype, typ): if not s_obj.can_be_none(): r.const = True elif not our_issubclass(bk, typ, s_obj.knowntype): r.const = False elif s_obj.knowntype == int and typ == bool: # xxx this will explode in case of generalisation # from bool to int, notice that isinstance( , bool|int) # is quite border case for RPython r.const = False for v in variables: assert v.annotation == s_obj knowntypedata = defaultdict(dict) if not hasattr(typ, '_freeze_') and isinstance(s_type, SomePBC): add_knowntypedata(knowntypedata, True, variables, bk.valueoftype(typ)) r.set_knowntypedata(knowntypedata) return r @op.isinstance.register(SomeObject) def isinstance_SomeObject(annotator, v_obj, v_cls): s_obj = annotator.annotation(v_obj) s_cls = annotator.annotation(v_cls) return s_isinstance(annotator, s_obj, s_cls, variables=[v_obj]) @op.bool.register(SomeObject) def bool_SomeObject(annotator, obj): r = SomeBool() annotator.annotation(obj).bool_behavior(r) s_nonnone_obj = annotator.annotation(obj) if s_nonnone_obj.can_be_none(): s_nonnone_obj = s_nonnone_obj.nonnoneify() knowntypedata = defaultdict(dict) add_knowntypedata(knowntypedata, True, [obj], s_nonnone_obj) r.set_knowntypedata(knowntypedata) return r @op.contains.register(SomeObject) def contains_SomeObject(annotator, obj, element): return s_Bool contains_SomeObject.can_only_throw = [] @op.contains.register(SomeNone) def contains_SomeNone(annotator, obj, element): # return False here for the case "... in None", because it can be later # generalized to "... in d" where d is either None or the empty dict # (which would also return the constant False) s_bool = SomeBool() s_bool.const = False return s_bool contains_SomeNone.can_only_throw = [] @op.contains.register(SomeInteger) @op.contains.register(SomeFloat) @op.contains.register(SomeBool) def contains_number(annotator, number, element): raise AnnotatorError("number is not iterable") @op.simple_call.register(SomeObject) def simple_call_SomeObject(annotator, func, *args): s_func = annotator.annotation(func) argspec = simple_args([annotator.annotation(arg) for arg in args]) return s_func.call(argspec) @op.call_args.register_transform(SomeObject) def transform_varargs(annotator, v_func, v_shape, *data_v): callspec = CallSpec.fromshape(v_shape.value, list(data_v)) v_vararg = callspec.w_stararg if callspec.w_stararg: s_vararg = annotator.annotation(callspec.w_stararg) if not isinstance(s_vararg, SomeTuple): raise AnnotatorError( "Calls like f(..., *arg) require 'arg' to be a tuple") n_items = len(s_vararg.items) ops = [op.getitem(v_vararg, const(i)) for i in range(n_items)] new_args = callspec.arguments_w + [hlop.result for hlop in ops] if callspec.keywords: newspec = CallSpec(new_args, callspec.keywords) shape, data_v = newspec.flatten() call_op = op.call_args(v_func, const(shape), *data_v) else: call_op = op.simple_call(v_func, *new_args) ops.append(call_op) return ops @op.call_args.register(SomeObject) def call_args(annotator, func, *args_v): callspec = complex_args([annotator.annotation(v_arg) for v_arg in args_v]) return annotator.annotation(func).call(callspec) @op.issubtype.register(SomeObject) def issubtype(annotator, v_type, v_cls): s_type = v_type.annotation s_cls = annotator.annotation(v_cls) if s_type.is_constant() and s_cls.is_constant(): return annotator.bookkeeper.immutablevalue( issubclass(s_type.const, s_cls.const)) return s_Bool class __extend__(SomeObject): def len(self): return SomeInteger(nonneg=True) def bool_behavior(self, s): if self.is_immutable_constant(): s.const = bool(self.const) else: s_len = self.len() if s_len.is_immutable_constant(): s.const = s_len.const > 0 def hash(self): raise AnnotatorError("cannot use hash() in RPython") def str(self): return SomeString() def unicode(self): return SomeUnicodeString() def repr(self): return SomeString() def hex(self): return SomeString() def oct(self): return SomeString() def id(self): raise AnnotatorError("cannot use id() in RPython; " "see objectmodel.compute_xxx()") def int(self): return SomeInteger() def float(self): return SomeFloat() def delattr(self, s_attr): if self.__class__ != SomeObject or self.knowntype != object: getbookkeeper().warning( ("delattr on potentally non-SomeObjects is not RPythonic: delattr(%r,%r)" % (self, s_attr))) def find_method(self, name): "Look for a special-case implementation for the named method." try: analyser = getattr(self.__class__, 'method_' + name) except AttributeError: return None else: return SomeBuiltinMethod(analyser, self, name) def getattr(self, s_attr): # get a SomeBuiltin if the SomeObject has # a corresponding method to handle it if not s_attr.is_constant() or not isinstance(s_attr.const, str): raise AnnotatorError("getattr(%r, %r) has non-constant argument" % (self, s_attr)) attr = s_attr.const s_method = self.find_method(attr) if s_method is not None: return s_method # if the SomeObject is itself a constant, allow reading its attrs if self.is_immutable_constant() and hasattr(self.const, attr): return immutablevalue(getattr(self.const, attr)) raise AnnotatorError("Cannot find attribute %r on %r" % (attr, self)) getattr.can_only_throw = [] def setattr(self, *args): return s_ImpossibleValue def bind_callables_under(self, classdef, name): return self # default unbound __get__ implementation def call(self, args, implicit_init=False): raise AnnotatorError("Cannot prove that the object is callable") def hint(self, *args_s): return self def getslice(self, *args): return s_ImpossibleValue def setslice(self, *args): return s_ImpossibleValue def delslice(self, *args): return s_ImpossibleValue def pos(self): return s_ImpossibleValue neg = abs = ord = invert = long = iter = next = pos class __extend__(SomeFloat): def pos(self): return self def neg(self): return SomeFloat() abs = neg def bool(self): if self.is_immutable_constant(): return getbookkeeper().immutablevalue(bool(self.const)) return s_Bool def len(self): raise AnnotatorError("'float' has no length") class __extend__(SomeInteger): def invert(self): return SomeInteger(knowntype=self.knowntype) invert.can_only_throw = [] def pos(self): return SomeInteger(knowntype=self.knowntype) pos.can_only_throw = [] int = pos # these are the only ones which can overflow: def neg(self): return SomeInteger(knowntype=self.knowntype) neg.can_only_throw = [] neg_ovf = _clone(neg, [OverflowError]) def abs(self): return SomeInteger(nonneg=True, knowntype=self.knowntype) abs.can_only_throw = [] abs_ovf = _clone(abs, [OverflowError]) def len(self): raise AnnotatorError("'int' has no length") class __extend__(SomeBool): def bool(self): return self def invert(self): return SomeInteger() invert.can_only_throw = [] def neg(self): return SomeInteger() neg.can_only_throw = [] neg_ovf = _clone(neg, [OverflowError]) def abs(self): return SomeInteger(nonneg=True) abs.can_only_throw = [] abs_ovf = _clone(abs, [OverflowError]) def pos(self): return SomeInteger(nonneg=True) pos.can_only_throw = [] int = pos class __extend__(SomeTuple): def len(self): return immutablevalue(len(self.items)) def iter(self): return SomeIterator(self) iter.can_only_throw = [] def getanyitem(self, position): return unionof(*self.items) def getslice(self, s_start, s_stop): assert s_start.is_immutable_constant(),"tuple slicing: needs constants" assert s_stop.is_immutable_constant(), "tuple slicing: needs constants" items = self.items[s_start.const:s_stop.const] return SomeTuple(items) @op.contains.register(SomeList) def contains_SomeList(annotator, obj, element): annotator.annotation(obj).listdef.generalize(annotator.annotation(element)) return s_Bool contains_SomeList.can_only_throw = [] class __extend__(SomeList): def method_append(self, s_value): self.listdef.resize() self.listdef.generalize(s_value) def method_extend(self, s_iterable): self.listdef.resize() if isinstance(s_iterable, SomeList): # unify the two lists self.listdef.agree(getbookkeeper(), s_iterable.listdef) else: s_iter = s_iterable.iter() self.method_append(s_iter.next()) def method_reverse(self): self.listdef.mutate() def method_insert(self, s_index, s_value): self.method_append(s_value) def method_remove(self, s_value): self.listdef.resize() self.listdef.generalize(s_value) def method_pop(self, s_index=None): position = getbookkeeper().position_key self.listdef.resize() return self.listdef.read_item(position) method_pop.can_only_throw = [IndexError] def method_index(self, s_value): self.listdef.generalize(s_value) return SomeInteger(nonneg=True) def len(self): position = getbookkeeper().position_key s_item = self.listdef.read_item(position) if isinstance(s_item, SomeImpossibleValue): return immutablevalue(0) return SomeObject.len(self) def iter(self): return SomeIterator(self) iter.can_only_throw = [] def getanyitem(self, position): return self.listdef.read_item(position) def hint(self, *args_s): hints = args_s[-1].const if 'maxlength' in hints: # only for iteration over lists or dicts or strs at the moment, # not over an iterator object (because it has no known length) s_iterable = args_s[0] if isinstance(s_iterable, (SomeList, SomeDict, SomeString)): self = SomeList(self.listdef) # create a fresh copy self.listdef.resize() self.listdef.listitem.hint_maxlength = True elif 'fence' in hints: self.listdef.resize() self = self.listdef.offspring(getbookkeeper()) return self def getslice(self, s_start, s_stop): bk = getbookkeeper() check_negative_slice(s_start, s_stop) return self.listdef.offspring(bk) def setslice(self, s_start, s_stop, s_iterable): check_negative_slice(s_start, s_stop) if not isinstance(s_iterable, SomeList): raise AnnotatorError("list[start:stop] = x: x must be a list") self.listdef.mutate() self.listdef.agree(getbookkeeper(), s_iterable.listdef) self.listdef.resize() def delslice(self, s_start, s_stop): check_negative_slice(s_start, s_stop) self.listdef.resize() def check_negative_slice(s_start, s_stop, error="slicing"): if isinstance(s_start, SomeInteger) and not s_start.nonneg: raise AnnotatorError("%s: not proven to have non-negative start" % error) if isinstance(s_stop, SomeInteger) and not s_stop.nonneg and \ getattr(s_stop, 'const', 0) != -1: raise AnnotatorError("%s: not proven to have non-negative stop" % error) def dict_contains(s_dct, s_element, position): s_dct.dictdef.generalize_key(s_element) if s_dct._is_empty(position): s_bool = SomeBool() s_bool.const = False return s_bool return s_Bool @op.contains.register(SomeDict) def contains_SomeDict(annotator, dct, element): position = annotator.bookkeeper.position_key return dict_contains(annotator.annotation(dct), annotator.annotation(element), position) contains_SomeDict.can_only_throw = _dict_can_only_throw_nothing class __extend__(SomeDict): def _is_empty(self, position): s_key = self.dictdef.read_key(position) s_value = self.dictdef.read_value(position) return (isinstance(s_key, SomeImpossibleValue) or isinstance(s_value, SomeImpossibleValue)) def len(self): position = getbookkeeper().position_key if self._is_empty(position): return immutablevalue(0) return SomeObject.len(self) def iter(self): return SomeIterator(self) iter.can_only_throw = [] def getanyitem(self, position, variant='keys'): if variant == 'keys': return self.dictdef.read_key(position) elif variant == 'values': return self.dictdef.read_value(position) elif variant == 'items' or variant == 'items_with_hash': s_key = self.dictdef.read_key(position) s_value = self.dictdef.read_value(position) if (isinstance(s_key, SomeImpossibleValue) or isinstance(s_value, SomeImpossibleValue)): return s_ImpossibleValue elif variant == 'items': return SomeTuple((s_key, s_value)) elif variant == 'items_with_hash': return SomeTuple((s_key, s_value, s_Int)) elif variant == 'keys_with_hash': s_key = self.dictdef.read_key(position) if isinstance(s_key, SomeImpossibleValue): return s_ImpossibleValue return SomeTuple((s_key, s_Int)) raise ValueError(variant) def method_get(self, key, dfl=s_None): position = getbookkeeper().position_key self.dictdef.generalize_key(key) self.dictdef.generalize_value(dfl) return self.dictdef.read_value(position) method_setdefault = method_get def method_copy(self): return SomeDict(self.dictdef) def method_update(dct1, dct2): if s_None.contains(dct2): return SomeImpossibleValue() dct1.dictdef.union(dct2.dictdef) def method__prepare_dict_update(dct, num): pass def method_keys(self): bk = getbookkeeper() return bk.newlist(self.dictdef.read_key(bk.position_key)) def method_values(self): bk = getbookkeeper() return bk.newlist(self.dictdef.read_value(bk.position_key)) def method_items(self): bk = getbookkeeper() return bk.newlist(self.getanyitem(bk.position_key, variant='items')) def method_iterkeys(self): return SomeIterator(self, 'keys') def method_itervalues(self): return SomeIterator(self, 'values') def method_iteritems(self): return SomeIterator(self, 'items') def method_iterkeys_with_hash(self): return SomeIterator(self, 'keys_with_hash') def method_iteritems_with_hash(self): return SomeIterator(self, 'items_with_hash') def method_clear(self): pass def method_popitem(self): position = getbookkeeper().position_key return self.getanyitem(position, variant='items') def method_pop(self, s_key, s_dfl=None): self.dictdef.generalize_key(s_key) if s_dfl is not None: self.dictdef.generalize_value(s_dfl) position = getbookkeeper().position_key return self.dictdef.read_value(position) def method_contains_with_hash(self, s_key, s_hash): position = getbookkeeper().position_key return dict_contains(self, s_key, position) method_contains_with_hash.can_only_throw = _dict_can_only_throw_nothing def method_setitem_with_hash(self, s_key, s_hash, s_value): pair(self, s_key).setitem(s_value) method_setitem_with_hash.can_only_throw = _dict_can_only_throw_nothing def method_getitem_with_hash(self, s_key, s_hash): # XXX: copy of binaryop.getitem_SomeDict self.dictdef.generalize_key(s_key) position = getbookkeeper().position_key return self.dictdef.read_value(position) method_getitem_with_hash.can_only_throw = _dict_can_only_throw_keyerror def method_delitem_with_hash(self, s_key, s_hash): pair(self, s_key).delitem() method_delitem_with_hash.can_only_throw = _dict_can_only_throw_keyerror def method_delitem_if_value_is(self, s_key, s_value): pair(self, s_key).setitem(s_value) pair(self, s_key).delitem() class __extend__(SomeOrderedDict): def method_move_to_end(self, s_key, s_last): assert s_Bool.contains(s_last) pair(self, s_key).delitem() method_move_to_end.can_only_throw = _dict_can_only_throw_keyerror @op.contains.register(SomeString) @op.contains.register(SomeUnicodeString) def contains_String(annotator, string, char): if annotator.annotation(char).is_constant() and annotator.annotation(char).const == "\0": r = SomeBool() knowntypedata = defaultdict(dict) add_knowntypedata(knowntypedata, False, [string], annotator.annotation(string).nonnulify()) r.set_knowntypedata(knowntypedata) return r else: return contains_SomeObject(annotator, string, char) contains_String.can_only_throw = [] class __extend__(SomeString, SomeUnicodeString): def method_startswith(self, frag): if self.is_constant() and frag.is_constant(): return immutablevalue(self.const.startswith(frag.const)) return s_Bool def method_endswith(self, frag): if self.is_constant() and frag.is_constant(): return immutablevalue(self.const.endswith(frag.const)) return s_Bool def method_find(self, frag, start=None, end=None): check_negative_slice(start, end, "find") return SomeInteger() def method_rfind(self, frag, start=None, end=None): check_negative_slice(start, end, "rfind") return SomeInteger() def method_count(self, frag, start=None, end=None): check_negative_slice(start, end, "count") return SomeInteger(nonneg=True) def method_strip(self, chr=None): if chr is None and isinstance(self, SomeUnicodeString): raise AnnotatorError("unicode.strip() with no arg is not RPython") return self.basestringclass(no_nul=self.no_nul) def method_lstrip(self, chr=None): if chr is None and isinstance(self, SomeUnicodeString): raise AnnotatorError("unicode.lstrip() with no arg is not RPython") return self.basestringclass(no_nul=self.no_nul) def method_rstrip(self, chr=None): if chr is None and isinstance(self, SomeUnicodeString): raise AnnotatorError("unicode.rstrip() with no arg is not RPython") return self.basestringclass(no_nul=self.no_nul) def method_join(self, s_list): if s_None.contains(s_list): return SomeImpossibleValue() position = getbookkeeper().position_key s_item = s_list.listdef.read_item(position) if s_None.contains(s_item): if isinstance(self, SomeUnicodeString): return immutablevalue(u"") return immutablevalue("") no_nul = self.no_nul and s_item.no_nul return self.basestringclass(no_nul=no_nul) def iter(self): return SomeIterator(self) iter.can_only_throw = [] def getanyitem(self, position): return self.basecharclass() def method_split(self, patt, max=-1): # special-case for .split( '\x00') or .split(u'\x00') if max == -1 and patt.is_constant() and ( len(patt.const) == 1 and ord(patt.const) == 0): no_nul = True else: no_nul = self.no_nul s_item = self.basestringclass(no_nul=no_nul) return getbookkeeper().newlist(s_item) def method_rsplit(self, patt, max=-1): s_item = self.basestringclass(no_nul=self.no_nul) return getbookkeeper().newlist(s_item) def method_replace(self, s1, s2): return self.basestringclass(no_nul=self.no_nul and s2.no_nul) def getslice(self, s_start, s_stop): check_negative_slice(s_start, s_stop) result = self.basestringclass(no_nul=self.no_nul) return result def method_format(self, *args): raise AnnotatorError("Method format() is not RPython") class __extend__(SomeByteArray): def getslice(ba, s_start, s_stop): check_negative_slice(s_start, s_stop) return SomeByteArray() class __extend__(SomeUnicodeString): def method_encode(self, s_enc): if not s_enc.is_constant(): raise AnnotatorError("Non-constant encoding not supported") enc = s_enc.const if enc not in ('ascii', 'latin-1', 'utf-8'): raise AnnotatorError("Encoding %s not supported for unicode" % (enc,)) if enc == 'utf-8': from rpython.rlib import runicode bookkeeper = getbookkeeper() s_func = bookkeeper.immutablevalue( runicode.unicode_encode_utf_8_elidable) s_errors = bookkeeper.immutablevalue('strict') s_errorhandler = bookkeeper.immutablevalue( runicode.default_unicode_error_encode) s_allow_surr = bookkeeper.immutablevalue(True) args = [self, self.len(), s_errors, s_errorhandler, s_allow_surr] bookkeeper.emulate_pbc_call(bookkeeper.position_key, s_func, args) return SomeString(no_nul=self.no_nul) method_encode.can_only_throw = [UnicodeEncodeError] class __extend__(SomeString): def method_isdigit(self): return s_Bool def method_isalpha(self): return s_Bool def method_isalnum(self): return s_Bool def method_upper(self): return SomeString() def method_lower(self): return SomeString() def method_splitlines(self, s_keep_newlines=None): s_list = getbookkeeper().newlist(self.basestringclass()) # Force the list to be resizable because ll_splitlines doesn't # preallocate the list. s_list.listdef.listitem.resize() return s_list def method_decode(self, s_enc): if not s_enc.is_constant(): raise AnnotatorError("Non-constant encoding not supported") enc = s_enc.const if enc not in ('ascii', 'latin-1', 'utf-8'): raise AnnotatorError("Encoding %s not supported for strings" % (enc,)) if enc == 'utf-8': from rpython.rlib import runicode bookkeeper = getbookkeeper() s_func = bookkeeper.immutablevalue( runicode.str_decode_utf_8_elidable) s_errors = bookkeeper.immutablevalue('strict') s_final = bookkeeper.immutablevalue(True) s_errorhandler = bookkeeper.immutablevalue( runicode.default_unicode_error_decode) s_allow_surr = bookkeeper.immutablevalue(True) args = [self, self.len(), s_errors, s_final, s_errorhandler, s_allow_surr] bookkeeper.emulate_pbc_call(bookkeeper.position_key, s_func, args) return SomeUnicodeString(no_nul=self.no_nul) method_decode.can_only_throw = [UnicodeDecodeError] class __extend__(SomeChar, SomeUnicodeCodePoint): def len(self): return immutablevalue(1) class __extend__(SomeChar): def ord(self): return SomeInteger(nonneg=True) def method_isspace(self): return s_Bool def method_isalnum(self): return s_Bool def method_islower(self): return s_Bool def method_isupper(self): return s_Bool def method_lower(self): return self def method_upper(self): return self class __extend__(SomeUnicodeCodePoint): def ord(self): # warning, on 32-bit with 32-bit unichars, this might return # negative numbers return SomeInteger() class __extend__(SomeIterator): def iter(self): return self iter.can_only_throw = [] def _can_only_throw(self): can_throw = [StopIteration] if isinstance(self.s_container, SomeDict): can_throw.append(RuntimeError) return can_throw def next(self): position = getbookkeeper().position_key if s_None.contains(self.s_container): return s_ImpossibleValue # so far if self.variant == ("enumerate",): s_item = self.s_container.getanyitem(position) return SomeTuple((SomeInteger(nonneg=True), s_item)) variant = self.variant if variant == ("reversed",): variant = () return self.s_container.getanyitem(position, *variant) next.can_only_throw = _can_only_throw method_next = next class __extend__(SomeInstance): def getattr(self, s_attr): if not(s_attr.is_constant() and isinstance(s_attr.const, str)): raise AnnotatorError("A variable argument to getattr is not RPython") attr = s_attr.const if attr == '__class__': return self.classdef.read_attr__class__() getbookkeeper().record_getattr(self.classdef.classdesc, attr) return self.classdef.s_getattr(attr, self.flags) getattr.can_only_throw = [] def setattr(self, s_attr, s_obj): if s_attr.is_constant() and isinstance(s_attr.const, str): attr = s_attr.const # find the (possibly parent) class where this attr is defined clsdef = self.classdef.locate_attribute(attr) attrdef = clsdef.attrs[attr] attrdef.modified(clsdef) # if the attrdef is new, this must fail if attrdef.s_value.contains(s_obj): return # create or update the attribute in clsdef clsdef.generalize_attr(attr, s_obj) if isinstance(s_obj, SomeList): clsdef.classdesc.maybe_return_immutable_list(attr, s_obj) else: raise AnnotatorError("setattr(instance, variable_attr, value)") def bool_behavior(self, s): if not self.can_be_None: s.const = True @op.len.register_transform(SomeInstance) def len_SomeInstance(annotator, v_arg): get_len = op.getattr(v_arg, const('__len__')) return [get_len, op.simple_call(get_len.result)] @op.iter.register_transform(SomeInstance) def iter_SomeInstance(annotator, v_arg): get_iter = op.getattr(v_arg, const('__iter__')) return [get_iter, op.simple_call(get_iter.result)] @op.next.register_transform(SomeInstance) def next_SomeInstance(annotator, v_arg): get_next = op.getattr(v_arg, const('next')) return [get_next, op.simple_call(get_next.result)] @op.getslice.register_transform(SomeInstance) def getslice_SomeInstance(annotator, v_obj, v_start, v_stop): get_getslice = op.getattr(v_obj, const('__getslice__')) return [get_getslice, op.simple_call(get_getslice.result, v_start, v_stop)] @op.setslice.register_transform(SomeInstance) def setslice_SomeInstance(annotator, v_obj, v_start, v_stop, v_iterable): get_setslice = op.getattr(v_obj, const('__setslice__')) return [get_setslice, op.simple_call(get_setslice.result, v_start, v_stop, v_iterable)] def _find_property_meth(s_obj, attr, meth): result = [] for clsdef in s_obj.classdef.getmro(): dct = clsdef.classdesc.classdict if attr not in dct: continue obj = dct[attr] if (not isinstance(obj, Constant) or not isinstance(obj.value, property)): return result.append(getattr(obj.value, meth)) return result @op.getattr.register_transform(SomeInstance) def getattr_SomeInstance(annotator, v_obj, v_attr): s_attr = annotator.annotation(v_attr) if not s_attr.is_constant() or not isinstance(s_attr.const, str): return attr = s_attr.const getters = _find_property_meth(annotator.annotation(v_obj), attr, 'fget') if getters: if all(getters): get_getter = op.getattr(v_obj, const(attr + '__getter__')) return [get_getter, op.simple_call(get_getter.result)] elif not any(getters): raise AnnotatorError("Attribute %r is unreadable" % attr) @op.setattr.register_transform(SomeInstance) def setattr_SomeInstance(annotator, v_obj, v_attr, v_value): s_attr = annotator.annotation(v_attr) if not s_attr.is_constant() or not isinstance(s_attr.const, str): return attr = s_attr.const setters = _find_property_meth(annotator.annotation(v_obj), attr, 'fset') if setters: if all(setters): get_setter = op.getattr(v_obj, const(attr + '__setter__')) return [get_setter, op.simple_call(get_setter.result, v_value)] elif not any(setters): raise AnnotatorError("Attribute %r is unwritable" % attr) class __extend__(SomeBuiltin): def call(self, args, implicit_init=False): args_s, kwds = args.unpack() # prefix keyword arguments with 's_' kwds_s = {} for key, s_value in kwds.items(): kwds_s['s_'+key] = s_value return self.analyser(*args_s, **kwds_s) class __extend__(SomeBuiltinMethod): def _can_only_throw(self, *args): analyser_func = getattr(self.analyser, 'im_func', None) can_only_throw = getattr(analyser_func, 'can_only_throw', None) if can_only_throw is None or isinstance(can_only_throw, list): return can_only_throw return can_only_throw(self.s_self, *args) def simple_call(self, *args): return self.analyser(self.s_self, *args) simple_call.can_only_throw = _can_only_throw def call(self, args, implicit_init=False): args_s, kwds = args.unpack() # prefix keyword arguments with 's_' kwds_s = {} for key, s_value in kwds.items(): kwds_s['s_'+key] = s_value return self.analyser(self.s_self, *args_s, **kwds_s) class __extend__(SomePBC): def getattr(self, s_attr): assert s_attr.is_constant() if s_attr.const == '__name__': from rpython.annotator.classdesc import ClassDesc if self.getKind() is ClassDesc: return SomeString() bookkeeper = getbookkeeper() return bookkeeper.pbc_getattr(self, s_attr) getattr.can_only_throw = [] def setattr(self, s_attr, s_value): raise AnnotatorError("Cannot modify attribute of a pre-built constant") def call(self, args): bookkeeper = getbookkeeper() return bookkeeper.pbc_call(self, args) def bind_callables_under(self, classdef, name): d = [desc.bind_under(classdef, name) for desc in self.descriptions] return SomePBC(d, can_be_None=self.can_be_None) def bool_behavior(self, s): if not self.can_be_None: s.const = True def len(self): raise AnnotatorError("Cannot call len on a pbc") class __extend__(SomeNone): def bind_callables_under(self, classdef, name): return self def getattr(self, s_attr): return s_ImpossibleValue getattr.can_only_throw = [] def setattr(self, s_attr, s_value): return None def call(self, args): return s_ImpossibleValue def bool_behavior(self, s): s.const = False def len(self): # This None could later be generalized into a list, for example. # For now, we give the impossible answer (because len(None) would # really crash translated code). It can be generalized later. return SomeImpossibleValue() @op.issubtype.register(SomeTypeOf) def issubtype(annotator, v_type, v_cls): args_v = v_type.annotation.is_type_of return s_isinstance(annotator, args_v[0].annotation, annotator.annotation(v_cls), args_v) #_________________________________________ # weakrefs class __extend__(SomeWeakRef): def simple_call(self): if self.classdef is None: return s_None # known to be a dead weakref else: return SomeInstance(self.classdef, can_be_None=True)