import ast
import airtight.hindley_milner_ast as hm_ast
from airtight.errors import *
class PythonConverter:
''' converts the python ast
to a lambda-like ast
used for type inference
'''
OPERATOR_MAGIC_FUNCTIONS = {
ast.Add: '__add__',
ast.Sub: '__substract__',
ast.Mult: '__mult__',
ast.FloorDiv: '__real_divide__',
ast.Div: '__divide__',
ast.Mod: '__percent__',
ast.Pow: '__power__',
ast.Eq: '__equals__',
ast.NotEq: '__not_equals__',
ast.Lt: '__lt__',
ast.LtE: '__lte__',
ast.Gt: '__gt__',
ast.GtE: '__gte',
ast.And: '__and__',
ast.Or: '__or__',
ast.Not: '__not__',
ast.Index: '__index__',
ast.Slice: '__slice__'
}
def __init__(self):
pass
def convert(self, python_ast):
self.type_vars = []
return self.convert_node(python_ast)
def _unique_type_var(self):
return hm_ast.TypeVariable()
def node_dict(self, node):
return {field : getattr(node, field) for field in node._fields}
def convert_node(self, node, context=None):
return getattr(self, 'convert_' + str(node.__class__.__name__).lower())(
context=context, **self.node_dict(node))
def convert_module(self, body, context, docstring=None):
return self.convert_body(body, context)
def convert_assign(self, targets, value, context):
'''
var = 'a'
..context
=>
Let('var'
String('a'),
context)
var, z = 'a', 'b'
..context
=>
Letmany(['var', 'z'],
[String('a'), String('b')],
context)
'''
if len(targets) == 1 and hasattr(targets[0], 'id'):
return hm_ast.Let(
targets[0].id,
self.convert_node(value),
context)
else:
return hm_ast.Letmany(
[t.id for t in targets[0].elts],
[self.convert_node(node) for node in value.elts],
context)
def convert_augassign(self, target, op, value, context):
return self.convert_assign(
[target],
ast.BinOp(
target,
op,
value),
context)
def convert_str(self, s, context):
return hm_ast.aString(s)
def convert_num(self, n, context):
if type(n) == float:
return hm_ast.aFloat(n)
else:
return hm_ast.anInteger(n)
def convert_functiondef(self, name, args, body, decorator_list, returns, context, docstring=None):
'''
def name(arg, arg2):
return arg
..context
=>
Let('name',
Multi_Lambda(['arg', 'arg2'],
[Ident('arg')]),
context)
'''
expected = []
vars = {}
for arg in args.args:
expected.append(self.convert_annotation(arg.annotation, vars))
expected.append(self.convert_annotation(returns, vars))
result = hm_ast.Let(
name,
hm_ast.Multi_Lambda(
[arg.arg for arg in args.args],
self.convert_body(body, None),
expected=expected),
context)
result.a_native = False
result.a_vars = []
if decorator_list:
if isinstance(decorator_list[0], ast.Name) and decorator_list[0].id == 'native':
result.a_native = True
if isinstance(decorator_list[-1], ast.Call) and decorator_list[-1].func.id == 'template':
# result.a_vars = vars.keys
result.a_vars = [vars[arg.id] for arg in decorator_list[-1].args] # vars.keys()
return result
def convert_annotation(self, annotation, vars):
if isinstance(annotation, ast.Name) and annotation.id.islower():
if annotation.id not in vars:
vars[annotation.id] = hm_ast.TypeVariable()
return vars[annotation.id]
elif isinstance(annotation, ast.Name):
return hm_ast.TypeOperator(annotation.id, [])
elif isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.RShift):
if isinstance(annotation.left, ast.Name):
# A >> B
left = [annotation.left, annotation.right]
else:
# (A, Z) >> B
left = annotation.left.elts + [annotation.right]
return hm_ast.Multi_Function([self.convert_annotation(l, vars) for l in left])
elif isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.BinOr):
# A | B
left, right = [self.convert_annotation(a, vars) for a in [annotation.left, annotation.right]]
return hm_ast.Union(left, right)
elif isinstance(annotation, ast.List):
# [A]
return hm_ast.List(self.convert_annotation(annotation.elts[0], vars))
else:
return None
def convert_expr(self, value, context):
return self.convert_node(value, context)
def convert_body(self, body, context):
if len(body) == 1:
converted = self.convert_node(body[0], context)
if not isinstance(converted, (hm_ast.Let, hm_ast.Letrec)):
return converted
elif context is None:
converted.body = hm_ast.Ident(converted.v)
return converted
else:
return converted
else:
current = len(body) - 1
# context = context or hm_ast.anInteger(2)
while current >= 0:
next_node = self.convert_node(body[current], context)
if isinstance(next_node, (hm_ast.Let, hm_ast.Letrec)):
context = next_node
elif context:
context = hm_ast.Body(next_node, context)
else:
context = next_node
current -= 1
return context
def convert_return(self, value, context):
return self.convert_node(value, context)
def convert_binop(self, left, right, op, context):
'''
2 / 2
=>
Multi_Apply(
Ident('a_divide'),
[Integer(2), Integer(2)])
'''
return hm_ast.Multi_Apply(
hm_ast.Ident('a' + self.OPERATOR_MAGIC_FUNCTIONS[type(op)]),
[self.convert_node(left, context), self.convert_node(right, context)])
def convert_compare(self, ops, left, comparators, context):
return hm_ast.Multi_Apply(
hm_ast.Ident('a' + self.OPERATOR_MAGIC_FUNCTIONS[type(ops[0])]),
[self.convert_node(left, context), self.convert_node(comparators[0], context)])
def convert_if(self, test, body, orelse, context):
return hm_ast.If(
self.convert_node(test, context),
self.convert_body(body, context),
self.convert_body(orelse, context))
def convert_for(self, target, body, iter, orelse, context):
return hm_ast.For(
self.convert_node(iter, context),
self.convert_node(target, context),
self.convert_body(body, context))
def convert_while(self, test, body, orelse, context):
if orelse:
raise NotSupportedError("else not supported after while")
return hm_ast.While(
self.convert_node(test, context),
self.convert_body(body, context))
def convert_subscript(self, value, slice, ctx, context):
if isinstance(slice, ast.Index):
return hm_ast.Multi_Apply(
hm_ast.Ident('a' + self.OPERATOR_MAGIC_FUNCTIONS[type(slice)]), [
self.convert_node(value, context),
self.convert_node(slice.value)])
else:
return hm_ast.Multi_Apply(
hm_ast.Ident('a' + self.OPERATOR_MAGIC_FUNCTIONS[type(slice)]), [
self.convert_node(value, context),
self.convert_node(slice.lower) if slice.lower else hm_ast.anInteger(0),
self.convert_node(slice.upper) if slice.upper else hm_ast.Multi_Apply(
self.OPERATOR_MAGIC_FUNCTIONS[ast.Sub], [
hm_ast.Apply(hm_ast.Ident('len'), self.convert_node(value, context)),
hm_ast.anInteger(1)])])
def convert_name(self, id, ctx, context):
'''
alexander
=>
Ident("alexander")
'''
return hm_ast.Ident(id)
def convert_nameconstant(self, value, context):
if value in [True, False]:
return hm_ast.aBoolean(value)
else:
return hm_ast.Ident(str(value))
def convert_list(self, elts, ctx, context):
'''
[e]
=>
aList(Ident("e"))
'''
return hm_ast.aList([self.convert_node(elt) for elt in elts])
def convert_call(self, func, args, keywords, context):
'''
a(2)
=>
Apply(Ident("a"), anInteger(2))
'''
return hm_ast.Multi_Apply(self.convert_node(func), [self.convert_node(arg) for arg in args])
def convert_lambda(self, args, body, context):
'''
lambda s: s
=>
Lambda(Ident("s"), Ident("s"))
'''
return hm_ast.Multi_Lambda([arg.arg for arg in args.args], self.convert_node(body))
