def test_method_lookup(self):
code="""
class A:
def __init__(self, x):
self.x=x
def get_x(self):
return self.x
a=A('jozo')
b=a.get_x()
getx=a.get_x
a=A(3)
c=a.get_x()
"""
node=ast.parse(code, mode='exec')
parser=Parser()
module_scope=parser.eval_code(node)
a=module_scope.resolve('a')
A=module_scope.resolve('A')
self.assertNotIn('get_x', a.scope)
self.assertIn('get_x', A.scope)
b=module_scope.resolve('b')
c=module_scope.resolve('c')
getx=module_scope.resolve('getx')
self.assertIsStr(b.node)
self.assertIsNum(c.node)
self.assertEqual(getx.kind, 'func')
def test_inheritance(self):
code="""
class A:
def __init__(self):
pass
def get_x(self):
return self.x
class B(A):
def __init__(self):
pass
def get_y(self):
return self.y
b=B()
b.x='jozo'
b.y=4
"""
node=ast.parse(code, mode='exec')
parser=Parser()
module_scope=parser.eval_code(node)
b=module_scope.resolve('b')
self.assertIsNum(b.scope['y'].node)
self.assertIsStr(b.scope['x'].node)
self.assertEqual(b.scope.resolve('get_x', 'class').kind, 'func')
def test_fun_parse(self):
code="""
def mean(x,y):
return (x+y)/2
def gean(x,y):
return x+y
x=3
y=x+2
z=mean(x,y)
x="jozo"
zz=gean(x,"fero")
"""
node=ast.parse(code, mode='exec')
parser=Parser()
module_scope=parser.eval_code(node)
x=module_scope.resolve('x')
y=module_scope.resolve('y')
z=module_scope.resolve('z')
zz=module_scope.resolve('zz')
self.assertIsStr(x.node)
self.assertIsNum(y.node)
self.assertIsNum(z.node)
self.assertIsStr(zz.node)
def test_simple_parse(self):
code="""
x=3
a='ahoj'
y=6
z=3+x
zz=x+y
b='jozo'
c=a+b
x='mumly'
"""
node=ast.parse(code, mode='exec')
parser=Parser()
module_scope=parser.eval_code(node)
x=module_scope.resolve('x')
y=module_scope.resolve('y')
z=module_scope.resolve('z')
zz=module_scope.resolve('zz')
a=module_scope.resolve('a')
b=module_scope.resolve('b')
c=module_scope.resolve('c')
self.assertIsStr(x.node)
self.assertIsNum(y.node)
self.assertIsNum(z.node)
self.assertIsNum(zz.node)
self.assertIsStr(a.node)
self.assertIsStr(b.node)
self.assertIsStr(c.node)
def test_class(self):
code="""
class A:
def __init__(self, x, y, z):
self.x=x
self.y=y
a=A(3,"ahoj", "svet")
"""
node=ast.parse(code, mode='exec')
parser=Parser()
module_scope=parser.eval_code(node)
a=module_scope.resolve('a')
self.assertIsNum(a.scope['x'].node)
self.assertIsStr(a.scope['y'].node)
self.assertEqual(a.scope.resolve('z').value,'None')
def load_externs():
from parse_ast import Parser
parser=Parser()
f=open("externs.py", "r")
source=f.read()
node=ast.parse(source, filename='externs.py', mode='exec')
scope=Scope(is_root=True)
print('@@@@@@ parsing externs')
extern_scope=typez.extern_scope=parser.eval_code(node, scope)
typez.inf_setattr=extern_scope['inf_setattr']
typez.inf_getattr=extern_scope['inf_getattr']
extern_scope['int']=extern_scope['Num_']
extern_scope['str']=extern_scope['Str_']
extern_scope['object']=extern_scope['inf_object']
print(typez.extern_scope)
print('@@@@@@ externs parsed')
def test_nonexistent_attribute(self):
code="""
class A:
def __init__(self, x, y):
self.x=x
self.y=y
a=A(3,4)
a.x=a.z
a.method()
"""
node=ast.parse(code, mode='exec')
parser=Parser()
module_scope=parser.eval_code(node)
problem_symbols={problem.symbol for problem in parser.problems}
self.assertEqual(problem_symbols, {'method', 'z'})
def test_override_setattr(self):
code="""
class A:
def __init__(self, x, y):
pass
def __setattr__(self, attr, val):
object.__setattr__(self, attr, 4)
a=A(3,4)
a.x='jozo'
key='z'
object.__setattr__(a,key,'jozo')
"""
node=ast.parse(code, mode='exec')
parser=Parser()
module_scope=parser.eval_code(node)
a=module_scope.resolve('a')
self.assertIsNum(a.scope['x'].node)
self.assertIsStr(a.scope['z'].node)
def test_closure(self):
code="""
def f(x):
z=x
def g(y):
return(x+y)
return g
g1=f(3)
g2=f('jozo')
a=g1(4)
b=g2('fero')
"""
node=ast.parse(code, mode='exec')
parser=Parser()
module_scope=parser.eval_code(node)
a=module_scope.resolve('a')
b=module_scope.resolve('b')
self.assertIsNum(a.node)
self.assertIsStr(b.node)
