def test_annotation_to_lltype():
s_i = SomeInteger()
s_pos = SomeInteger(nonneg=True)
s_1 = SomeInteger(nonneg=True)
s_1.const = 1
s_m1 = SomeInteger(nonneg=False)
s_m1.const = -1
s_u = SomeInteger(nonneg=True, unsigned=True)
s_u1 = SomeInteger(nonneg=True, unsigned=True)
s_u1.const = r_uint(1)
assert annotation_to_lltype(s_i) == lltype.Signed
assert annotation_to_lltype(s_pos) == lltype.Signed
assert annotation_to_lltype(s_1) == lltype.Signed
assert annotation_to_lltype(s_m1) == lltype.Signed
assert annotation_to_lltype(s_u) == lltype.Unsigned
assert annotation_to_lltype(s_u1) == lltype.Unsigned
assert annotation_to_lltype(SomeBool()) == lltype.Bool
assert annotation_to_lltype(SomeChar()) == lltype.Char
PS = lltype.Ptr(lltype.GcStruct('s'))
s_p = SomePtr(ll_ptrtype=PS)
assert annotation_to_lltype(s_p) == PS
si0 = SomeInstance(DummyClassDef(), True)
with py.test.raises(ValueError):
annotation_to_lltype(si0)
s_singlefloat = SomeSingleFloat()
s_singlefloat.const = r_singlefloat(0.0)
assert annotation_to_lltype(s_singlefloat) == lltype.SingleFloat
def lltype_to_annotation(cls, TYPE):
if isinstance(TYPE, NativeInstance):
return SomeOOInstance(TYPE)
elif TYPE is ootype.Char:
return SomeChar()
elif TYPE is ootype.String:
return SomeString(can_be_None=True)
else:
return lltype_to_annotation(TYPE)
def test_ll_to_annotation():
s_z = ll_to_annotation(lltype.Signed._defl())
s_s = SomeInteger()
s_u = SomeInteger(nonneg=True, unsigned=True)
assert s_z.contains(s_s)
assert not s_z.contains(s_u)
s_uz = ll_to_annotation(lltype.Unsigned._defl())
assert s_uz.contains(s_u)
assert ll_to_annotation(lltype.Bool._defl()).contains(SomeBool())
assert ll_to_annotation(lltype.Char._defl()).contains(SomeChar())
S = lltype.GcStruct('s')
A = lltype.GcArray()
s_p = ll_to_annotation(lltype.malloc(S))
assert isinstance(s_p, SomePtr) and s_p.ll_ptrtype == lltype.Ptr(S)
s_p = ll_to_annotation(lltype.malloc(A, 0))
assert isinstance(s_p, SomePtr) and s_p.ll_ptrtype == lltype.Ptr(A)
def getitem_idx((str1, int2)):
return SomeChar(no_nul=str1.no_nul)
def union((chr1, chr2)):
no_nul = chr1.no_nul and chr2.no_nul
return SomeChar(no_nul=no_nul)
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:
raise Exception("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:
if len(x) == 1:
result = SomeUnicodeCodePoint()
else:
result = SomeUnicodeString()
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 SomeOrderedDict.knowntype
or tp is r_ordereddict):
key = Constant(x)
try:
return self.immutable_cache[key]
except KeyError:
if tp is SomeOrderedDict.knowntype 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_()
self.see_mutable(x)
result = SomeInstance(self.getuniqueclassdef(x.__class__))
elif x is None:
return s_None
else:
raise Exception("Don't know how to represent %r" % (x, ))
result.const = x
return result
def builtin_chr(s_int):
return constpropagate(chr, [s_int], SomeChar())
# float -> string
DTSF_STR_PRECISION = 12
DTSF_SIGN = 0x1
DTSF_ADD_DOT_0 = 0x2
DTSF_ALT = 0x4
DTSF_CUT_EXP_0 = 0x8
DIST_FINITE = 1
DIST_NAN = 2
DIST_INFINITY = 3
@objectmodel.enforceargs(float, SomeChar(), int, int)
def formatd(x, code, precision, flags=0):
from rpython.rlib.rdtoa import dtoa_formatd
return dtoa_formatd(x, code, precision, flags)
def double_to_string(value, tp, precision, flags):
if isfinite(value):
special = DIST_FINITE
elif isinf(value):
special = DIST_INFINITY
else: #isnan(value):
special = DIST_NAN
result = formatd(value, tp, precision, flags)
return result, special
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
rtyper = PseudoRTyper()
r_key = s_key.rtyper_makerepr(rtyper)
def setitem((p, obj), s_value):
raise AnnotatorError("ptr %r setitem index not an int: %r" %
(p.ll_ptrtype, obj))
class __extend__(pairtype(SomeObject, SomePtr)):
def union((obj, p2)):
return pair(p2, obj).union()
annotation_to_ll_map = [
(SomeSingleFloat(), lltype.SingleFloat),
(s_None, lltype.Void), # also matches SomeImpossibleValue()
(s_Bool, lltype.Bool),
(SomeFloat(), lltype.Float),
(SomeLongFloat(), lltype.LongFloat),
(SomeChar(), lltype.Char),
(SomeUnicodeCodePoint(), lltype.UniChar),
(SomeAddress(), llmemory.Address),
]
def annotation_to_lltype(s_val, info=None):
if isinstance(s_val, SomeInteriorPtr):
p = s_val.ll_ptrtype
if 0 in p.offsets:
assert list(p.offsets).count(0) == 1
return lltype.Ptr(lltype.Ptr(p.PARENTTYPE)._interior_ptr_type_with_index(p.TO))
else:
return lltype.Ptr(p.PARENTTYPE)
if isinstance(s_val, SomePtr):
return s_val.ll_ptrtype