Allow expression reader to add classes

4 files changed, 57 insertions, 40 deletions

diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java
index 15da87e..b5c434d 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java
@@ -1,5 +1,6 @@
 package org.zwobble.couscous.frontends.java;
 
+import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.core.dom.*;
 import org.zwobble.couscous.ast.*;
 import org.zwobble.couscous.values.BooleanValue;
@@ -18,7 +19,13 @@ import static org.zwobble.couscous.frontends.java.JavaOperators.readOperator;
 import static org.zwobble.couscous.frontends.java.JavaTypes.typeOf;
 
 public class JavaExpressionReader {
-    static ExpressionNode readExpression(TypeName targetType, Expression expression) {
+    private final ImmutableList.Builder<ClassNode> classes;
+
+    JavaExpressionReader(ImmutableList.Builder<ClassNode> classes) {
+        this.classes = classes;
+    }
+
+    ExpressionNode readExpression(TypeName targetType, Expression expression) {
         ExpressionNode couscousExpression = readExpressionWithoutBoxing(expression);
         return handleBoxing(targetType, couscousExpression);
     }
@@ -67,7 +74,7 @@ public class JavaExpressionReader {
             targetType.equals(BooleanValue.REF);
     }
 
-    static ExpressionNode readExpressionWithoutBoxing(Expression expression) {
+    ExpressionNode readExpressionWithoutBoxing(Expression expression) {
         switch (expression.getNodeType()) {
             case ASTNode.BOOLEAN_LITERAL:
                 return readBooleanLiteral((BooleanLiteral)expression);
@@ -145,11 +152,11 @@ public class JavaExpressionReader {
         return ThisReferenceNode.thisReference(typeOf(expression));
     }
 
-    private static ExpressionNode readFieldAccess(FieldAccess expression) {
+    private ExpressionNode readFieldAccess(FieldAccess expression) {
         return FieldAccessNode.fieldAccess(readExpressionWithoutBoxing(expression.getExpression()), expression.getName().getIdentifier(), typeOf(expression));
     }
 
-    private static ExpressionNode readMethodInvocation(MethodInvocation expression) {
+    private ExpressionNode readMethodInvocation(MethodInvocation expression) {
         String methodName = expression.getName().getIdentifier();
         @SuppressWarnings("unchecked")
         List<ExpressionNode> arguments = readArguments(
@@ -177,7 +184,7 @@ public class JavaExpressionReader {
         }
     }
 
-    private static ExpressionNode readClassInstanceCreation(ClassInstanceCreation expression) {
+    private ExpressionNode readClassInstanceCreation(ClassInstanceCreation expression) {
         @SuppressWarnings("unchecked")
         List<Expression> arguments = expression.arguments();
         return ConstructorCallNode.constructorCall(
@@ -185,7 +192,7 @@ public class JavaExpressionReader {
             readArguments(expression.resolveConstructorBinding(), arguments));
     }
 
-    private static List<ExpressionNode> readArguments(IMethodBinding method, List<Expression> javaArguments) {
+    private List<ExpressionNode> readArguments(IMethodBinding method, List<Expression> javaArguments) {
         return IntStream.range(0, javaArguments.size())
             .mapToObj(index -> readExpression(
                 typeOf(method.getParameterTypes()[index]),
@@ -193,7 +200,7 @@ public class JavaExpressionReader {
             .collect(Collectors.toList());
     }
 
-    private static ExpressionNode readInfixExpression(InfixExpression expression) {
+    private ExpressionNode readInfixExpression(InfixExpression expression) {
         if (isPrimitiveOperation(expression)) {
             Operator operator = readOperator(expression.getOperator());
             return readPrimitiveOperation(
@@ -226,7 +233,7 @@ public class JavaExpressionReader {
         return type.equals(BooleanValue.REF) || type.equals(IntegerValue.REF);
     }
 
-    private static ExpressionNode readPrefixExpression(PrefixExpression expression) {
+    private ExpressionNode readPrefixExpression(PrefixExpression expression) {
         Operator operator = readOperator(expression.getOperator());
         return AssignmentNode.assign(
             (AssignableExpressionNode) readExpressionWithoutBoxing(expression.getOperand()),
@@ -237,7 +244,7 @@ public class JavaExpressionReader {
                 IntegerValue.REF));
     }
 
-    private static ExpressionNode readConditionalExpression(ConditionalExpression expression) {
+    private ExpressionNode readConditionalExpression(ConditionalExpression expression) {
         TypeName type = typeOf(expression);
         return TernaryConditionalNode.ternaryConditional(
             readExpression(BooleanValue.REF, expression.getExpression()),
@@ -245,7 +252,7 @@ public class JavaExpressionReader {
             readExpression(type, expression.getElseExpression()));
     }
 
-    private static ExpressionNode readAssignment(Assignment expression) {
+    private ExpressionNode readAssignment(Assignment expression) {
         AssignableExpressionNode left = (AssignableExpressionNode)readExpressionWithoutBoxing(expression.getLeftHandSide());
         if (expression.getOperator() == Assignment.Operator.ASSIGN) {
             ExpressionNode right = readExpression(left.getType(), expression.getRightHandSide());
@@ -260,7 +267,7 @@ public class JavaExpressionReader {
         }
     }
 
-    private static ExpressionNode readPrimitiveOperation(Operator operator, Expression leftJava, Expression rightJava) {
+    private ExpressionNode readPrimitiveOperation(Operator operator, Expression leftJava, Expression rightJava) {
         ExpressionNode left = readUnboxedExpression(leftJava);
         ExpressionNode right = readUnboxedExpression(rightJava);
         return MethodCallNode.methodCall(
@@ -270,7 +277,7 @@ public class JavaExpressionReader {
             operator.isBoolean() ? BooleanValue.REF : left.getType());
     }
 
-    private static ExpressionNode readUnboxedExpression(Expression expression) {
+    private ExpressionNode readUnboxedExpression(Expression expression) {
         return readExpression(
             unboxedType(typeOf(expression)),
             expression);
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaFrontend.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaFrontend.java
index 6e9945e..bccd4a8 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaFrontend.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaFrontend.java
@@ -13,10 +13,9 @@ import org.zwobble.couscous.util.ExtraLists;
 public class JavaFrontend implements Frontend {
     @Override
     public List<ClassNode> readSourceDirectory(Path directoryPath) throws IOException {
-        JavaReader reader = new JavaReader();
         return ExtraLists.flatMap(
             findJavaFiles(directoryPath),
-            javaFile -> reader.readClassFromFile(directoryPath, javaFile));
+            javaFile -> JavaReader.readClassFromFile(directoryPath, javaFile));
     }
     
     private Stream<Path> findJavaFiles(Path directoryPath) throws IOException {
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
index 446bc31..0a9e32a 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
@@ -1,5 +1,6 @@
 package org.zwobble.couscous.frontends.java;
 
+import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.core.dom.*;
 import org.zwobble.couscous.ast.ClassNode;
 import org.zwobble.couscous.ast.ClassNodeBuilder;
@@ -11,46 +12,51 @@ import java.nio.file.Path;
 import java.util.List;
 import java.util.Optional;
 
-import static java.util.Arrays.asList;
 import static org.zwobble.couscous.frontends.java.JavaTypes.typeOf;
+import static org.zwobble.couscous.util.ExtraLists.cons;
 
 public class JavaReader {
-    private final JavaParser parser = new JavaParser();
-    
-    public List<ClassNode> readClassFromFile(Path root, Path sourcePath) throws IOException {
-        CompilationUnit ast = parser.parseCompilationUnit(root, sourcePath);
-        return readCompilationUnit(ast);
+    public static List<ClassNode> readClassFromFile(Path root, Path sourcePath) throws IOException {
+        CompilationUnit ast = new JavaParser().parseCompilationUnit(root, sourcePath);
+        JavaReader reader = new JavaReader();
+        return reader.readCompilationUnit(ast);
     }
-    
-    private static List<ClassNode> readCompilationUnit(CompilationUnit ast) {
+
+    private final ImmutableList.Builder<ClassNode> classes;
+
+    private JavaReader() {
+        classes = ImmutableList.builder();
+    }
+
+    private List<ClassNode> readCompilationUnit(CompilationUnit ast) {
         String name = generateClassName(ast);
         ClassNodeBuilder classBuilder = new ClassNodeBuilder(name);
         TypeDeclaration type = (TypeDeclaration)ast.types().get(0);
         readFields(type, classBuilder);
         readMethods(type, classBuilder);
-        return asList(classBuilder.build());
+        return cons(classBuilder.build(), classes.build());
     }
     
-    private static void readFields(TypeDeclaration type, ClassNodeBuilder classBuilder) {
+    private void readFields(TypeDeclaration type, ClassNodeBuilder classBuilder) {
         for (FieldDeclaration field : type.getFields()) {
             readField(field, classBuilder);
         }
     }
     
-    private static void readField(FieldDeclaration field, ClassNodeBuilder classBuilder) {
+    private void readField(FieldDeclaration field, ClassNodeBuilder classBuilder) {
         for (Object fragment : field.fragments()) {
             String name = ((VariableDeclarationFragment)fragment).getName().getIdentifier();
             classBuilder.field(name, typeOf(field.getType()));
         }
     }
     
-    private static void readMethods(TypeDeclaration type, ClassNodeBuilder classBuilder) {
+    private void readMethods(TypeDeclaration type, ClassNodeBuilder classBuilder) {
         for (MethodDeclaration method : type.getMethods()) {
             readMethod(classBuilder, method);
         }
     }
     
-    private static void readMethod(ClassNodeBuilder classBuilder, MethodDeclaration method) {
+    private void readMethod(ClassNodeBuilder classBuilder, MethodDeclaration method) {
         if (method.isConstructor()) {
             classBuilder.constructor(builder -> buildMethod(method, builder));
         } else {
@@ -58,7 +64,7 @@ public class JavaReader {
         }
     }
 
-    private static <T> ClassNodeBuilder.MethodBuilder<T> buildMethod(MethodDeclaration method, ClassNodeBuilder.MethodBuilder<T> builder) {
+    private <T> ClassNodeBuilder.MethodBuilder<T> buildMethod(MethodDeclaration method, ClassNodeBuilder.MethodBuilder<T> builder) {
         for (IAnnotationBinding annotation : method.resolveBinding().getAnnotations()) {
             builder.annotation(typeOf(annotation.getAnnotationType()));
         }
@@ -69,7 +75,7 @@ public class JavaReader {
         Optional<TypeName> returnType = method.getReturnType2() == null
             ? Optional.empty()
             : Optional.of(typeOf(method.getReturnType2()));
-        JavaStatementReader statementReader = new JavaStatementReader(returnType);
+        JavaStatementReader statementReader = new JavaStatementReader(new JavaExpressionReader(classes), returnType);
         for (Object statement : method.getBody().statements()) {
             for (StatementNode intermediateStatement : statementReader.readStatement((Statement)statement)) {
                 builder.statement(intermediateStatement);
@@ -78,7 +84,7 @@ public class JavaReader {
         return builder;
     }
 
-    private static String generateClassName(CompilationUnit ast) {
+    private String generateClassName(CompilationUnit ast) {
         TypeDeclaration type = (TypeDeclaration)ast.types().get(0);
         return ast.getPackage().getName().getFullyQualifiedName() + "." + type.getName().getFullyQualifiedName();
     }
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaStatementReader.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaStatementReader.java
index 97a235e..725882f 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaStatementReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaStatementReader.java
@@ -7,23 +7,20 @@ import org.zwobble.couscous.values.BooleanValue;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import static java.util.Arrays.asList;
 import static org.zwobble.couscous.ast.ExpressionStatementNode.expressionStatement;
 import static org.zwobble.couscous.ast.LocalVariableDeclarationNode.localVariableDeclaration;
 import static org.zwobble.couscous.ast.WhileNode.whileLoop;
-import static org.zwobble.couscous.frontends.java.JavaExpressionReader.readExpression;
-import static org.zwobble.couscous.frontends.java.JavaExpressionReader.readExpressionWithoutBoxing;
 import static org.zwobble.couscous.frontends.java.JavaTypes.typeOf;
-import static org.zwobble.couscous.util.ExtraLists.append;
-import static org.zwobble.couscous.util.ExtraLists.concat;
-import static org.zwobble.couscous.util.ExtraLists.eagerMap;
+import static org.zwobble.couscous.util.ExtraLists.*;
 
 class JavaStatementReader {
+    private final JavaExpressionReader expressionReader;
     private final Optional<TypeName> returnType;
 
-    JavaStatementReader(Optional<TypeName> returnType) {
+    JavaStatementReader(JavaExpressionReader expressionReader, Optional<TypeName> returnType) {
+        this.expressionReader = expressionReader;
         this.returnType = returnType;
     }
 
@@ -67,7 +64,7 @@ class JavaStatementReader {
         return ReturnNode.returns(readExpression(returnType.get(), statement.getExpression()));
     }
 
-    private static StatementNode readExpressionStatement(ExpressionStatement statement) {
+    private StatementNode readExpressionStatement(ExpressionStatement statement) {
         return expressionStatement(readExpressionWithoutBoxing(statement.getExpression()));
     }
 
@@ -104,14 +101,14 @@ class JavaStatementReader {
                     eagerMap(updaters, updater -> expressionStatement(readExpressionWithoutBoxing(updater))))));
     }
 
-    private static List<StatementNode> readVariableDeclarationStatement(VariableDeclarationStatement statement) {
+    private List<StatementNode> readVariableDeclarationStatement(VariableDeclarationStatement statement) {
         @SuppressWarnings("unchecked")
         List<VariableDeclarationFragment> fragments = statement.fragments();
         TypeName type = typeOf(statement.getType());
         return readDeclarationFragments(fragments, type);
     }
 
-    private static List<StatementNode> readDeclarationFragments(List<VariableDeclarationFragment> fragments, TypeName type) {
+    private List<StatementNode> readDeclarationFragments(List<VariableDeclarationFragment> fragments, TypeName type) {
         return eagerMap(fragments, fragment ->
             localVariableDeclaration(
                 fragment.resolveBinding().getKey(),
@@ -119,4 +116,12 @@ class JavaStatementReader {
                 type,
                 readExpression(type, fragment.getInitializer())));
     }
+
+    private ExpressionNode readExpressionWithoutBoxing(Expression expression) {
+        return expressionReader.readExpressionWithoutBoxing(expression);
+    }
+
+    private ExpressionNode readExpression(TypeName targetType, Expression expression) {
+        return expressionReader.readExpression(targetType, expression);
+    }
 }