def compile(src, filename, mode='exec', showTree=False, importlogix=True,
module=None):
global lineno
lineno = 0
global modulename
modulename = module
implogix = ast.Import([(logixModuleName, 'logix')])
prepend = importlogix and [implogix] or None
if len(src) == 0:
src = [None]
try:
if mode == "exec":
statements = block(src, False, prepend)
tree = ast.Module(None, statements)
gen = pycodegen.ModuleCodeGenerator
else:
assert len(src) == 1
stmt = src[0]
if mode == "single":
statements = block([stmt], False, prepend=prepend)
tree = ast.Module(None, statements)
gen = pycodegen.InteractiveCodeGenerator
elif mode == "eval":
statements = block([stmt], True, prepend)
tree = ast.Expression(statements)
gen = pycodegen.ExpressionCodeGenerator
else:
raise ValueError("compile() 3rd arg must be 'exec' or "
"'eval' or 'single'")
except CompileError, exc:
offset = None
raise SyntaxError(str(exc), (filename, lineno, offset, None))
def test_data_vector_with_complex_function():
source = """
import System::Output;
export data Vector(x: i32, y: i32) {
function add(self: Vector, other: Vector): Vector {
Vector(x = self.x + other.x, y = self.y + other.y);
}
}
export function Main(): void {
}
"""
result = get_semantic_analysis(source)
assert_equal_programs(
result,
ast.Program(
imports=[ast.Import(value="System::Output")],
traits=[],
data_defs=[
ast.DataDef(
name="Vector",
implements=[],
is_exported=True,
params=[
ast.Param(name="x",
type=types.Field(name="x",
type=types.I32())),
ast.Param(name="y",
type=types.Field(name="y",
type=types.I32())),
],
functions=[
ast.Function(
name="add",
is_exported=False,
params=[
ast.Param(
name="self",
type=types.Param(
name="self",
type=types.TypeRef(name="Vector")),
),
ast.Param(
name="other",
type=types.Param(
name="other",
type=types.TypeRef(name="Vector")),
),
],
type=types.Function(
name="add",
params=[
types.Param(
name="self",
type=types.TypeRef(name="Vector")),
types.Param(
name="other",
type=types.TypeRef(name="Vector")),
],
result=types.TypeRef(name="Vector"),
),
body=[
ast.FunctionCall(
name="Vector",
arguments=[
ast.Argument(
name="x",
value=ast.BinaryOperation(
operator=ast.BinaryOperator.
ADD,
left=ast.MemberAccess(
value=ast.Variable(
name="self"),
member="x",
),
right=ast.MemberAccess(
value=ast.Variable(
name="other"),
member="x",
),
),
),
ast.Argument(
name="y",
value=ast.BinaryOperation(
operator=ast.BinaryOperator.
ADD,
left=ast.MemberAccess(
value=ast.Variable(
name="self"),
member="y",
),
right=ast.MemberAccess(
value=ast.Variable(
name="other"),
member="y",
),
),
),
],
)
],
)
],
type=types.Data(
name="Vector",
implements=[],
fields=[
types.Field(name="x", type=types.I32()),
types.Field(name="y", type=types.I32()),
],
functions=[],
),
)
],
functions=[
ast.Function(
name="Main",
is_exported=True,
params=[],
type=types.Function(name="Main",
params=[],
result=types.Void()),
body=[],
)
],
),
)
def _do_ImportStatement(self, node):
names = [name.MakeString() for name in node.Names]
as_names = map(str, node.AsNames)
names = zip(names, as_names)
return ast.Import(names)
def p_import_stmt(
p): # extremely oversimplified. "from","dots","as" to be done
"""import_stmt : IMPORT NAME
"""
p[0] = ast.Import(p[2])