diff options
Diffstat (limited to 'src')
24 files changed, 798 insertions, 31 deletions
diff --git a/src/main/java/org/zwobble/couscous/ast/ClassNode.java b/src/main/java/org/zwobble/couscous/ast/ClassNode.java index 72e57d2..3d785d2 100644 --- a/src/main/java/org/zwobble/couscous/ast/ClassNode.java +++ b/src/main/java/org/zwobble/couscous/ast/ClassNode.java @@ -35,4 +35,9 @@ public class ClassNode { String name; @Singular List<MethodNode> methods; + + public String getLocalName() { + // TODO Stronger notion of class names? Should look up the terminology + return name.substring(name.lastIndexOf(".") + 1); + } } diff --git a/src/main/java/org/zwobble/couscous/backends/python/PythonCodeGenerator.java b/src/main/java/org/zwobble/couscous/backends/python/PythonCodeGenerator.java new file mode 100644 index 0000000..816a80d --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/PythonCodeGenerator.java @@ -0,0 +1,121 @@ +package org.zwobble.couscous.backends.python; + +import java.util.stream.Collectors; + +import org.zwobble.couscous.ast.Assignment; +import org.zwobble.couscous.ast.ClassNode; +import org.zwobble.couscous.ast.ExpressionNode; +import org.zwobble.couscous.ast.ExpressionStatementNode; +import org.zwobble.couscous.ast.LiteralNode; +import org.zwobble.couscous.ast.LocalVariableDeclarationNode; +import org.zwobble.couscous.ast.MethodCallNode; +import org.zwobble.couscous.ast.MethodNode; +import org.zwobble.couscous.ast.ReturnNode; +import org.zwobble.couscous.ast.StatementNode; +import org.zwobble.couscous.ast.StaticMethodCallNode; +import org.zwobble.couscous.ast.TernaryConditionalNode; +import org.zwobble.couscous.ast.VariableReferenceNode; +import org.zwobble.couscous.ast.visitors.ExpressionNodeVisitor; +import org.zwobble.couscous.ast.visitors.StatementNodeVisitor; +import org.zwobble.couscous.backends.python.ast.PythonExpressionNode; +import org.zwobble.couscous.backends.python.ast.PythonFunctionDefinitionNode; +import org.zwobble.couscous.backends.python.ast.PythonModuleNode; +import org.zwobble.couscous.backends.python.ast.PythonStatementNode; +import org.zwobble.couscous.values.IntegerValue; +import org.zwobble.couscous.values.StringValue; + +import static java.util.Arrays.asList; +import static org.zwobble.couscous.backends.python.ast.PythonClassNode.pythonClass; +import static org.zwobble.couscous.backends.python.ast.PythonFunctionDefinitionNode.pythonFunctionDefinition; +import static org.zwobble.couscous.backends.python.ast.PythonIntegerLiteralNode.pythonIntegerLiteral; +import static org.zwobble.couscous.backends.python.ast.PythonModuleNode.pythonModule; +import static org.zwobble.couscous.backends.python.ast.PythonReturnNode.pythonReturn; +import static org.zwobble.couscous.backends.python.ast.PythonStringLiteralNode.pythonStringLiteral; + +import lombok.val; + +public class PythonCodeGenerator { + public static PythonModuleNode generateCode(ClassNode classNode) { + val pythonBody = classNode.getMethods() + .stream() + .map(PythonCodeGenerator::generateFunction) + .collect(Collectors.toList()); + + val pythonClass = pythonClass(classNode.getLocalName(), pythonBody); + return pythonModule(asList(pythonClass)); + } + + private static PythonFunctionDefinitionNode generateFunction(MethodNode method) { + val pythonBody = method.getBody() + .stream() + .map(PythonCodeGenerator::generateStatement) + .collect(Collectors.toList()); + return pythonFunctionDefinition(method.getName(), pythonBody); + } + + private static PythonStatementNode generateStatement(StatementNode statement) { + return statement.accept(new StatementGenerator()); + } + + private static class StatementGenerator implements StatementNodeVisitor<PythonStatementNode> { + @Override + public PythonStatementNode visit(ReturnNode returnNode) { + return pythonReturn(generateExpression(returnNode.getValue())); + } + + @Override + public PythonStatementNode visit(ExpressionStatementNode expressionStatement) { + throw new UnsupportedOperationException(); + } + + @Override + public PythonStatementNode visit(LocalVariableDeclarationNode localVariableDeclaration) { + throw new UnsupportedOperationException(); + } + } + + private static PythonExpressionNode generateExpression(ExpressionNode expression) { + return expression.accept(new ExpressionGenerator()); + } + + private static class ExpressionGenerator implements ExpressionNodeVisitor<PythonExpressionNode> { + @Override + public PythonExpressionNode visit(LiteralNode literal) { + // TODO: use visitor + if (literal.getValue() instanceof IntegerValue) { + return pythonIntegerLiteral(((IntegerValue)literal.getValue()).getValue()); + } else if (literal.getValue() instanceof StringValue) { + return pythonStringLiteral(((StringValue)literal.getValue()).getValue()); + } else { + throw new UnsupportedOperationException(); + } + } + + @Override + public PythonExpressionNode visit( + VariableReferenceNode variableReference) { + throw new UnsupportedOperationException(); + } + + @Override + public PythonExpressionNode visit(Assignment assignment) { + throw new UnsupportedOperationException(); + } + + @Override + public PythonExpressionNode visit(TernaryConditionalNode ternaryConditional) { + throw new UnsupportedOperationException(); + } + + @Override + public PythonExpressionNode visit(MethodCallNode methodCall) { + throw new UnsupportedOperationException(); + } + + @Override + public PythonExpressionNode visit(StaticMethodCallNode staticMethodCall) { + throw new UnsupportedOperationException(); + } + + } +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/PythonCompiler.java b/src/main/java/org/zwobble/couscous/backends/python/PythonCompiler.java new file mode 100644 index 0000000..b38bc73 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/PythonCompiler.java @@ -0,0 +1,34 @@ +package org.zwobble.couscous.backends.python; + +import java.io.File; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; + +import org.zwobble.couscous.ast.ClassNode; + +import static java.util.Arrays.asList; +import static org.zwobble.couscous.backends.python.PythonCodeGenerator.generateCode; +import static org.zwobble.couscous.backends.python.PythonSerializer.serialize; + +import lombok.SneakyThrows; +import lombok.val; + +public class PythonCompiler { + public void compile(List<ClassNode> classes, Path path) { + for (val classNode : classes) { + compileClass(classNode, pathForClass(classNode, path)); + } + } + + private Path pathForClass(ClassNode classNode, Path path) { + return path.resolve(classNode.getName().replace(".", File.separator) + ".py"); + } + + @SneakyThrows + private void compileClass(ClassNode classNode, Path path) { + Files.createDirectories(path.getParent()); + Files.write(path, asList(serialize(generateCode(classNode)))); + + } +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/PythonSerializer.java b/src/main/java/org/zwobble/couscous/backends/python/PythonSerializer.java new file mode 100644 index 0000000..e5a13e5 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/PythonSerializer.java @@ -0,0 +1,107 @@ +package org.zwobble.couscous.backends.python; + +import org.zwobble.couscous.backends.python.ast.PythonBlock; +import org.zwobble.couscous.backends.python.ast.PythonClassNode; +import org.zwobble.couscous.backends.python.ast.PythonFunctionDefinitionNode; +import org.zwobble.couscous.backends.python.ast.PythonIntegerLiteralNode; +import org.zwobble.couscous.backends.python.ast.PythonModuleNode; +import org.zwobble.couscous.backends.python.ast.PythonNode; +import org.zwobble.couscous.backends.python.ast.PythonPassNode; +import org.zwobble.couscous.backends.python.ast.PythonReturnNode; +import org.zwobble.couscous.backends.python.ast.PythonStringLiteralNode; +import org.zwobble.couscous.backends.python.ast.PythonWriter; +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +import lombok.val; + +public class PythonSerializer implements PythonNodeVisitor<Void> { + public static String serialize(PythonNode node) { + val writer = new PythonWriter(); + val serializer = new PythonSerializer(writer); + serializer.write(node); + return writer.asString(); + } + + private PythonWriter writer; + + private PythonSerializer(PythonWriter writer) { + this.writer = writer; + } + + public void write(PythonNode node) { + node.accept(this); + } + + @Override + public Void visit(PythonIntegerLiteralNode integerLiteral) { + writer.writeInteger(integerLiteral.getValue()); + return null; + } + + @Override + public Void visit(PythonStringLiteralNode stringLiteral) { + writer.writeStringLiteral(stringLiteral.getValue()); + return null; + } + + @Override + public Void visit(PythonReturnNode pythonReturn) { + writer.startStatement(); + writer.writeKeyword("return"); + writer.writeSpace(); + write(pythonReturn.getValue()); + writer.endStatement(); + return null; + } + + @Override + public Void visit(PythonPassNode pass) { + writer.startStatement(); + writer.writeKeyword("pass"); + writer.endStatement(); + return null; + } + + @Override + public Void visit(PythonClassNode pythonClass) { + writer.startStatement(); + writer.writeKeyword("class"); + writer.writeSpace(); + writer.writeIdentifier(pythonClass.getName()); + writer.writeSymbol("("); + writer.writeIdentifier("object"); + writer.writeSymbol(")"); + writeBlock(pythonClass.getBody()); + writer.endStatement(); + return null; + } + + @Override + public Void visit(PythonFunctionDefinitionNode functionDefinition) { + writer.startStatement(); + writer.writeKeyword("def"); + writer.writeSpace(); + writer.writeIdentifier(functionDefinition.getName()); + writer.writeSymbol("("); + writer.writeSymbol(")"); + writeBlock(functionDefinition.getBody()); + writer.endStatement(); + return null; + } + + @Override + public Void visit(PythonModuleNode module) { + for (val statement : module.getStatements()) { + write(statement); + } + return null; + } + + private void writeBlock(PythonBlock body) { + writer.startBlock(); + for (val statement : body) { + write(statement); + } + writer.endBlock(); + } +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonBlock.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonBlock.java new file mode 100644 index 0000000..8bc7132 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonBlock.java @@ -0,0 +1,25 @@ +package org.zwobble.couscous.backends.python.ast; + +import java.util.Iterator; +import java.util.List; + +import com.google.common.collect.ImmutableList; + +import static java.util.Arrays.asList; + +public class PythonBlock implements Iterable<PythonStatementNode> { + private final List<PythonStatementNode> statements; + + public PythonBlock(List<? extends PythonStatementNode> statements) { + if (statements.isEmpty()) { + this.statements = asList(PythonPassNode.PASS); + } else { + this.statements = ImmutableList.copyOf(statements); + } + } + + @Override + public Iterator<PythonStatementNode> iterator() { + return statements.iterator(); + } +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonClassNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonClassNode.java new file mode 100644 index 0000000..958a21a --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonClassNode.java @@ -0,0 +1,48 @@ +package org.zwobble.couscous.backends.python.ast; + +import java.util.List; + +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +import com.google.common.collect.ImmutableList; + +import lombok.Value; + +@Value(staticConstructor="pythonClass") +public class PythonClassNode implements PythonStatementNode { + public static Builder builder(String name) { + return new Builder(name); + } + + public static class Builder { + private final String name; + private final ImmutableList.Builder<PythonStatementNode> statements; + + public Builder(String name) { + this.name = name; + this.statements = ImmutableList.builder(); + } + + public PythonClassNode build() { + return new PythonClassNode(name, new PythonBlock(statements.build())); + } + + public Builder statement(PythonStatementNode statement) { + statements.add(statement); + return this; + } + } + + public static PythonClassNode pythonClass(String name, List<? extends PythonStatementNode> body) { + return new PythonClassNode(name, new PythonBlock(body)); + } + + String name; + PythonBlock body; + + @Override + public <T> T accept(PythonNodeVisitor<T> visitor) { + return visitor.visit(this); + } + +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonExpressionNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonExpressionNode.java new file mode 100644 index 0000000..9c8a259 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonExpressionNode.java @@ -0,0 +1,5 @@ +package org.zwobble.couscous.backends.python.ast; + +public interface PythonExpressionNode extends PythonNode { + +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonFunctionDefinitionNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonFunctionDefinitionNode.java new file mode 100644 index 0000000..6d66df8 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonFunctionDefinitionNode.java @@ -0,0 +1,22 @@ +package org.zwobble.couscous.backends.python.ast; + +import java.util.List; + +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +import lombok.Value; + +@Value(staticConstructor="pythonFunctionDefinition") +public class PythonFunctionDefinitionNode implements PythonStatementNode { + public static PythonFunctionDefinitionNode pythonFunctionDefinition(String name, List<PythonStatementNode> body) { + return pythonFunctionDefinition(name, new PythonBlock(body)); + } + + String name; + PythonBlock body; + + @Override + public <T> T accept(PythonNodeVisitor<T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonIntegerLiteralNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonIntegerLiteralNode.java new file mode 100644 index 0000000..d8a9358 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonIntegerLiteralNode.java @@ -0,0 +1,15 @@ +package org.zwobble.couscous.backends.python.ast; + +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +import lombok.Value; + +@Value(staticConstructor="pythonIntegerLiteral") +public class PythonIntegerLiteralNode implements PythonExpressionNode { + int value; + + @Override + public <T> T accept(PythonNodeVisitor<T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonModuleNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonModuleNode.java new file mode 100644 index 0000000..92d63a8 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonModuleNode.java @@ -0,0 +1,18 @@ +package org.zwobble.couscous.backends.python.ast; + +import java.util.List; + +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +import lombok.Value; + +@Value(staticConstructor="pythonModule") +public class PythonModuleNode implements PythonNode { + List<PythonStatementNode> statements; + + @Override + public <T> T accept(PythonNodeVisitor<T> visitor) { + return visitor.visit(this); + } + +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonNode.java new file mode 100644 index 0000000..cdda65d --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonNode.java @@ -0,0 +1,7 @@ +package org.zwobble.couscous.backends.python.ast; + +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +public interface PythonNode { + <T> T accept(PythonNodeVisitor<T> visitor); +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonPassNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonPassNode.java new file mode 100644 index 0000000..36d6695 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonPassNode.java @@ -0,0 +1,16 @@ +package org.zwobble.couscous.backends.python.ast; + +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +public class PythonPassNode implements PythonStatementNode { + public static final PythonPassNode PASS = new PythonPassNode(); + + private PythonPassNode() { + // TODO Auto-generated constructor stub + } + + @Override + public <T> T accept(PythonNodeVisitor<T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonReturnNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonReturnNode.java new file mode 100644 index 0000000..b204b4d --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonReturnNode.java @@ -0,0 +1,16 @@ +package org.zwobble.couscous.backends.python.ast; + +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +import lombok.Value; + +@Value(staticConstructor="pythonReturn") +public class PythonReturnNode implements PythonStatementNode { + PythonExpressionNode value; + + @Override + public <T> T accept(PythonNodeVisitor<T> visitor) { + return visitor.visit(this); + } + +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonStatementNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonStatementNode.java new file mode 100644 index 0000000..c27a7dd --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonStatementNode.java @@ -0,0 +1,5 @@ +package org.zwobble.couscous.backends.python.ast; + +public interface PythonStatementNode extends PythonNode { + +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonStringLiteralNode.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonStringLiteralNode.java new file mode 100644 index 0000000..82d91db --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonStringLiteralNode.java @@ -0,0 +1,15 @@ +package org.zwobble.couscous.backends.python.ast; + +import org.zwobble.couscous.backends.python.ast.visitors.PythonNodeVisitor; + +import lombok.Value; + +@Value(staticConstructor="pythonStringLiteral") +public class PythonStringLiteralNode implements PythonExpressionNode { + String value; + + @Override + public <T> T accept(PythonNodeVisitor<T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/PythonWriter.java b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonWriter.java new file mode 100644 index 0000000..4ab04c6 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/PythonWriter.java @@ -0,0 +1,60 @@ +package org.zwobble.couscous.backends.python.ast; + +import com.google.common.base.Strings; + +public class PythonWriter { + private static final int SPACES_PER_INDENT = 4; + private final StringBuilder builder = new StringBuilder(); + private int depth = 0; + + public String asString() { + return builder.toString(); + } + + public void writeInteger(int value) { + builder.append(value); + } + + public void writeStringLiteral(String value) { + builder.append("\""); + builder.append(value); + builder.append("\""); + } + + public void writeKeyword(String keyword) { + builder.append(keyword); + } + + public void writeSpace() { + builder.append(" "); + } + + public void writeIdentifier(String name) { + builder.append(name); + } + + public void writeSymbol(String symbol) { + builder.append(symbol); + } + + public void startBlock() { + depth++; + writeSymbol(":"); + builder.append("\n"); + } + + public void endBlock() { + depth--; + } + + public void startStatement() { + builder.append(Strings.repeat(" ", depth * SPACES_PER_INDENT)); + } + + public void endStatement() { + if (builder.charAt(builder.length() - 1) != '\n') { + builder.append("\n"); + } + } + +} diff --git a/src/main/java/org/zwobble/couscous/backends/python/ast/visitors/PythonNodeVisitor.java b/src/main/java/org/zwobble/couscous/backends/python/ast/visitors/PythonNodeVisitor.java new file mode 100644 index 0000000..0210df6 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/backends/python/ast/visitors/PythonNodeVisitor.java @@ -0,0 +1,22 @@ +package org.zwobble.couscous.backends.python.ast.visitors; + +import org.zwobble.couscous.backends.python.ast.PythonClassNode; +import org.zwobble.couscous.backends.python.ast.PythonFunctionDefinitionNode; +import org.zwobble.couscous.backends.python.ast.PythonIntegerLiteralNode; +import org.zwobble.couscous.backends.python.ast.PythonModuleNode; +import org.zwobble.couscous.backends.python.ast.PythonPassNode; +import org.zwobble.couscous.backends.python.ast.PythonReturnNode; +import org.zwobble.couscous.backends.python.ast.PythonStringLiteralNode; + +public interface PythonNodeVisitor<T> { + T visit(PythonIntegerLiteralNode integerLiteral); + T visit(PythonStringLiteralNode stringLiteral); + + T visit(PythonReturnNode pythonReturn); + T visit(PythonPassNode pass); + T visit(PythonClassNode pythonClass); + T visit(PythonFunctionDefinitionNode functionDefinition); + + T visit(PythonModuleNode module); + +} diff --git a/src/main/java/org/zwobble/couscous/values/InterpreterValues.java b/src/main/java/org/zwobble/couscous/values/InterpreterValues.java new file mode 100644 index 0000000..6b220d0 --- /dev/null +++ b/src/main/java/org/zwobble/couscous/values/InterpreterValues.java @@ -0,0 +1,13 @@ +package org.zwobble.couscous.values; + +public class InterpreterValues { + public static final UnitValue UNIT = UnitValue.UNIT; + + public static InterpreterValue value(int value) { + return new IntegerValue(value); + } + + public static InterpreterValue value(String value) { + return new StringValue(value); + } +} diff --git a/src/test/java/org/zwobble/couscous/tests/BackendTests.java b/src/test/java/org/zwobble/couscous/tests/BackendTests.java new file mode 100644 index 0000000..86818af --- /dev/null +++ b/src/test/java/org/zwobble/couscous/tests/BackendTests.java @@ -0,0 +1,49 @@ +package org.zwobble.couscous.tests; + +import org.junit.Test; +import org.zwobble.couscous.ast.ClassNode; +import org.zwobble.couscous.ast.MethodNode; +import org.zwobble.couscous.ast.ReturnNode; +import org.zwobble.couscous.values.InterpreterValue; +import org.zwobble.couscous.values.StringValue; + +import static java.util.Arrays.asList; +import static org.junit.Assert.assertEquals; +import static org.zwobble.couscous.ast.LiteralNode.literal; +import static org.zwobble.couscous.ast.MethodNode.staticMethod; +import static org.zwobble.couscous.values.UnitValue.UNIT; + +import lombok.val; + +public abstract class BackendTests { + @Test + public void methodWithNoStatementsReturnsUnit() { + val method = staticMethod("hello"); + val result = runMethod(method); + + assertEquals(UNIT, result); + } + + @Test + public void canReturnLiteralValue() { + val method = staticMethod("hello") + .statement(new ReturnNode(literal("hello, world!"))); + val result = runMethod(method); + + assertEquals(new StringValue("hello, world!"), result); + } + + protected InterpreterValue runMethod(MethodNode.MethodNodeBuilder methodBuilder, InterpreterValue... arguments) { + val method = methodBuilder.build(); + val className = "com.example.Program"; + val classNode = ClassNode.builder(className) + .method(method) + .build(); + + val runner = buildMethodRunner(); + return runner.runMethod(classNode, method.getName(), asList(arguments)); + } + + protected abstract MethodRunner buildMethodRunner(); + +} diff --git a/src/test/java/org/zwobble/couscous/tests/MethodRunner.java b/src/test/java/org/zwobble/couscous/tests/MethodRunner.java new file mode 100644 index 0000000..29c15fe --- /dev/null +++ b/src/test/java/org/zwobble/couscous/tests/MethodRunner.java @@ -0,0 +1,10 @@ +package org.zwobble.couscous.tests; + +import java.util.List; + +import org.zwobble.couscous.ast.ClassNode; +import org.zwobble.couscous.values.InterpreterValue; + +public interface MethodRunner { + InterpreterValue runMethod(ClassNode classNode, String methodName, List<InterpreterValue> arguments); +} diff --git a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerTests.java b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerTests.java new file mode 100644 index 0000000..7419aca --- /dev/null +++ b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerTests.java @@ -0,0 +1,70 @@ +package org.zwobble.couscous.tests.backends.python; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.file.Files; +import java.util.List; + +import org.zwobble.couscous.ast.ClassNode; +import org.zwobble.couscous.backends.python.PythonCompiler; +import org.zwobble.couscous.tests.BackendTests; +import org.zwobble.couscous.tests.MethodRunner; +import org.zwobble.couscous.values.InterpreterValue; + +import com.google.common.base.Charsets; +import com.google.common.io.CharStreams; + +import static java.lang.Integer.parseInt; +import static java.util.Arrays.asList; +import static org.zwobble.couscous.tests.util.ExtraFiles.deleteRecursively; +import static org.zwobble.couscous.values.InterpreterValues.UNIT; +import static org.zwobble.couscous.values.InterpreterValues.value; + +import lombok.SneakyThrows; +import lombok.val; + +public class PythonCompilerTests extends BackendTests { + @Override + protected MethodRunner buildMethodRunner() { + return new MethodRunner() { + @Override + @SneakyThrows + public InterpreterValue runMethod( + ClassNode classNode, + String methodName, + List<InterpreterValue> arguments) { + val compiler = new PythonCompiler(); + val directoryPath = Files.createTempDirectory(null); + try { + compiler.compile(asList(classNode), directoryPath); + + val program = "from " + classNode.getName() + " import " + classNode.getLocalName() + + ";print(repr(" + classNode.getLocalName() + "." + methodName + "()))"; + + val process = new ProcessBuilder("python3.4", "-c", program) + .directory(directoryPath.toFile()) + .start(); + val exitCode = process.waitFor(); + val output = readString(process.getInputStream()).trim(); + val stderrOutput = readString(process.getErrorStream()); + if (exitCode != 0) { + throw new RuntimeException("stderr was: " + stderrOutput); + } else if (output.equals("None")) { + return UNIT; + } else if (output.startsWith("'")) { + return value(output.substring(1, output.length() - 1)); + } else { + return value(parseInt(output)); + } + } finally { + deleteRecursively(directoryPath.toFile()); + } + } + + private String readString(final InputStream stream) throws IOException { + return CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8)); + } + }; + } +} diff --git a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonSerializerTests.java b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonSerializerTests.java new file mode 100644 index 0000000..4f9b63b --- /dev/null +++ b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonSerializerTests.java @@ -0,0 +1,80 @@ +package org.zwobble.couscous.tests.backends.python; + +import org.junit.Test; +import org.zwobble.couscous.backends.python.ast.PythonClassNode; + +import static java.util.Arrays.asList; +import static org.junit.Assert.assertEquals; +import static org.zwobble.couscous.backends.python.PythonSerializer.serialize; +import static org.zwobble.couscous.backends.python.ast.PythonFunctionDefinitionNode.pythonFunctionDefinition; +import static org.zwobble.couscous.backends.python.ast.PythonIntegerLiteralNode.pythonIntegerLiteral; +import static org.zwobble.couscous.backends.python.ast.PythonModuleNode.pythonModule; +import static org.zwobble.couscous.backends.python.ast.PythonPassNode.PASS; +import static org.zwobble.couscous.backends.python.ast.PythonReturnNode.pythonReturn; +import static org.zwobble.couscous.backends.python.ast.PythonStringLiteralNode.pythonStringLiteral; + +import lombok.val; + +public class PythonSerializerTests { + @Test + public void integersAreNotBoxed() { + val output = serialize(pythonIntegerLiteral(42)); + assertEquals("42", output); + } + + @Test + public void stringsAreNotBoxed() { + // TODO: escaping + val output = serialize(pythonStringLiteral("blah")); + assertEquals("\"blah\"", output); + } + + @Test + public void returnKeywordIsUsedForReturns() { + val output = serialize(pythonReturn(pythonIntegerLiteral(42))); + assertEquals("return 42\n", output); + } + + @Test + public void passStatementIsSerializedAsPassKeyword() { + val output = serialize(PASS); + assertEquals("pass\n", output); + } + + @Test + public void emptyFunctionHasPassStatement() { + val output = serialize(pythonFunctionDefinition("empty", asList())); + assertEquals("def empty():\n pass\n", output); + } + + @Test + public void emptyClassHasPassStatement() { + val classNode = PythonClassNode.builder("Empty") + .build(); + val output = serialize(classNode); + assertEquals("class Empty(object):\n pass\n", output); + } + + @Test + public void moduleIsSerializedStatements() { + val classNode = pythonModule(asList(PASS)); + val output = serialize(classNode); + assertEquals("pass\n", output); + } + + @Test + public void bodiesOfBlocksAreIndented() { + val classNode = PythonClassNode.builder("Foo") + .statement(pythonFunctionDefinition("one", asList())) + .statement(pythonFunctionDefinition("two", asList())) + .build(); + val output = serialize(classNode); + val expectedOutput = + "class Foo(object):\n" + + " def one():\n" + + " pass\n" + + " def two():\n" + + " pass\n"; + assertEquals(expectedOutput, output); + } +} diff --git a/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterTests.java b/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterTests.java index d0c8976..98271f7 100644 --- a/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterTests.java +++ b/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterTests.java @@ -1,18 +1,21 @@ package org.zwobble.couscous.tests.interpreter; +import java.util.List; + import org.junit.Test; import org.zwobble.couscous.MapBackedProject; import org.zwobble.couscous.ast.Assignment; import org.zwobble.couscous.ast.ClassNode; import org.zwobble.couscous.ast.ExpressionStatementNode; import org.zwobble.couscous.ast.LiteralNode; -import org.zwobble.couscous.ast.MethodNode; import org.zwobble.couscous.ast.ReturnNode; import org.zwobble.couscous.interpreter.Interpreter; import org.zwobble.couscous.interpreter.UnboundVariable; import org.zwobble.couscous.interpreter.UnexpectedValueType; import org.zwobble.couscous.interpreter.VariableNotInScope; import org.zwobble.couscous.interpreter.WrongNumberOfArguments; +import org.zwobble.couscous.tests.BackendTests; +import org.zwobble.couscous.tests.MethodRunner; import org.zwobble.couscous.values.ConcreteType; import org.zwobble.couscous.values.IntegerValue; import org.zwobble.couscous.values.InterpreterValue; @@ -20,7 +23,6 @@ import org.zwobble.couscous.values.StringValue; import com.google.common.collect.ImmutableMap; -import static java.util.Arrays.asList; import static org.junit.Assert.assertEquals; import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg; import static org.zwobble.couscous.ast.LiteralNode.literal; @@ -29,28 +31,10 @@ import static org.zwobble.couscous.ast.MethodNode.staticMethod; import static org.zwobble.couscous.ast.VariableDeclaration.var; import static org.zwobble.couscous.ast.VariableReferenceNode.reference; import static org.zwobble.couscous.tests.util.ExtraAsserts.assertThrows; -import static org.zwobble.couscous.values.UnitValue.UNIT; import lombok.val; -public class InterpreterTests { - @Test - public void methodWithNoStatementsReturnsUnit() { - val method = staticMethod("hello"); - val result = runMethod(method); - - assertEquals(UNIT, result); - } - - @Test - public void canReturnLiteralValue() { - val method = staticMethod("hello") - .statement(new ReturnNode(LiteralNode.literal("hello, world!"))); - val result = runMethod(method); - - assertEquals(new StringValue("hello, world!"), result); - } - +public class InterpreterTests extends BackendTests { @Test public void canPassValueToMethod() { val arg = formalArg(var(42, "x", StringValue.REF)); @@ -162,15 +146,19 @@ public class InterpreterTests { assertEquals(new UnboundVariable(42), exception); } - private InterpreterValue runMethod(MethodNode.MethodNodeBuilder methodBuilder, InterpreterValue... arguments) { - val method = methodBuilder.build(); - val className = "com.example.Program"; - val classNode = ClassNode.builder(className) - .method(method) - .build(); - val interpreter = new Interpreter(new MapBackedProject(ImmutableMap.of( - className, ConcreteType.fromNode(classNode)))); - - return interpreter.run(className, method.getName(), asList(arguments)); + @Override + protected MethodRunner buildMethodRunner() { + return new MethodRunner() { + @Override + public InterpreterValue runMethod( + ClassNode classNode, + String methodName, + List<InterpreterValue> arguments) { + val interpreter = new Interpreter(new MapBackedProject(ImmutableMap.of( + classNode.getName(), ConcreteType.fromNode(classNode)))); + + return interpreter.run(classNode.getName(), methodName, arguments); + } + }; } } diff --git a/src/test/java/org/zwobble/couscous/tests/util/ExtraFiles.java b/src/test/java/org/zwobble/couscous/tests/util/ExtraFiles.java new file mode 100644 index 0000000..032e22c --- /dev/null +++ b/src/test/java/org/zwobble/couscous/tests/util/ExtraFiles.java @@ -0,0 +1,16 @@ +package org.zwobble.couscous.tests.util; + +import java.io.File; + +import lombok.val; + +public class ExtraFiles { + public static void deleteRecursively(File file) { + if (file.isDirectory()) { + for (val child : file.listFiles()) { + deleteRecursively(child); + } + } + file.delete(); + } +} |