Split lambda expression reading out

3 files changed, 83 insertions, 45 deletions

diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaLambdaExpressionReader.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaLambdaExpressionReader.java
new file mode 100644
index 0000000..44a0f2d
--- /dev/null
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaLambdaExpressionReader.java
@@ -0,0 +1,58 @@
+package org.zwobble.couscous.frontends.java;
+
+import org.eclipse.jdt.core.dom.*;
+import org.zwobble.couscous.ast.FormalArgumentNode;
+import org.zwobble.couscous.ast.StatementNode;
+import org.zwobble.couscous.ast.TypeName;
+import org.zwobble.couscous.ast.sugar.Lambda;
+
+import java.util.List;
+import java.util.Optional;
+
+import static java.util.Arrays.asList;
+import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg;
+import static org.zwobble.couscous.ast.ReturnNode.returns;
+import static org.zwobble.couscous.ast.VariableDeclaration.var;
+import static org.zwobble.couscous.ast.sugar.Lambda.lambda;
+import static org.zwobble.couscous.frontends.java.JavaTypes.typeOf;
+import static org.zwobble.couscous.util.ExtraLists.eagerMap;
+
+public class JavaLambdaExpressionReader {
+    private final JavaReader reader;
+
+    public JavaLambdaExpressionReader(JavaReader reader) {
+        this.reader = reader;
+    }
+
+    public Lambda javaLambdaToLambda(LambdaExpression expression) {
+        List<FormalArgumentNode> formalArguments = eagerMap(
+            (List<?>)expression.parameters(),
+            this::readLambdaExpressionParameter);
+
+        return lambda(formalArguments, readLambdaExpressionBody(expression));
+    }
+
+    private FormalArgumentNode readLambdaExpressionParameter(Object parameter) {
+        if (parameter instanceof SingleVariableDeclaration) {
+            return JavaVariableDeclarationReader.read((SingleVariableDeclaration) parameter);
+        } else {
+            VariableDeclarationFragment fragment = (VariableDeclarationFragment)parameter;
+            return formalArg(var(
+                fragment.resolveBinding().getKey(),
+                fragment.getName().getIdentifier(),
+                typeOf(fragment.resolveBinding().getType())));
+        }
+    }
+
+    private List<StatementNode> readLambdaExpressionBody(LambdaExpression expression) {
+        TypeName returnType = typeOf(expression.resolveTypeBinding().getFunctionalInterfaceMethod().getReturnType());
+        if (expression.getBody() instanceof Block) {
+            @SuppressWarnings("unchecked")
+            List<Statement> statements = ((Block) expression.getBody()).statements();
+            return reader.readStatements(statements, Optional.of(returnType));
+        } else {
+            Expression body = (Expression) expression.getBody();
+            return asList(returns(reader.readExpression(returnType, body)));
+        }
+    }
+}
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 b36ece3..d3c285a 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
@@ -26,13 +26,11 @@ import static org.zwobble.couscous.ast.ConstructorNode.constructor;
 import static org.zwobble.couscous.ast.FieldAccessNode.fieldAccess;
 import static org.zwobble.couscous.ast.FieldDeclarationNode.field;
 import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg;
-import static org.zwobble.couscous.ast.ReturnNode.returns;
 import static org.zwobble.couscous.ast.ThisReferenceNode.thisReference;
 import static org.zwobble.couscous.ast.VariableDeclaration.var;
 import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
-import static org.zwobble.couscous.ast.sugar.Lambda.lambda;
-import static org.zwobble.couscous.frontends.java.JavaExpressionMethodReferenceReader.javaExpressionmethodReferenceToLambda;
 import static org.zwobble.couscous.frontends.java.FreeVariables.findFreeVariables;
+import static org.zwobble.couscous.frontends.java.JavaExpressionMethodReferenceReader.javaExpressionmethodReferenceToLambda;
 import static org.zwobble.couscous.frontends.java.JavaTypes.*;
 import static org.zwobble.couscous.util.Casts.tryCast;
 import static org.zwobble.couscous.util.ExtraLists.*;
@@ -86,7 +84,7 @@ public class JavaReader {
         return generateClosure(
             expression,
             expression.resolveTypeBinding().getFunctionalInterfaceMethod(),
-            javaLambdaToLambda(expression));
+            new JavaLambdaExpressionReader(this).javaLambdaToLambda(expression));
     }
 
     GeneratedClosure generateClosure(ASTNode node, IMethodBinding functionalInterfaceMethod, Lambda lambda) {
@@ -274,7 +272,7 @@ public class JavaReader {
     private FunctionDeclaration functionDeclaration(MethodDeclaration method) {
         @SuppressWarnings("unchecked")
         List<SingleVariableDeclaration> parameters = method.parameters();
-        List<FormalArgumentNode> formalArguments = eagerMap(parameters, this::readSingleVariableDeclaration);
+        List<FormalArgumentNode> formalArguments = eagerMap(parameters, JavaVariableDeclarationReader::read);
         @SuppressWarnings("unchecked")
         List<Statement> statements = method.getBody().statements();
         Optional<TypeName> returnType = Optional.ofNullable(method.getReturnType2())
@@ -287,42 +285,10 @@ public class JavaReader {
             readStatements(statements, returnType));
     }
 
-    private Lambda javaLambdaToLambda(LambdaExpression expression) {
-        List<FormalArgumentNode> formalArguments = eagerMap(
-            (List<?>)expression.parameters(),
-            this::readLambdaExpressionParameter);
-
-        return lambda(formalArguments, readLambdaExpressionBody(expression));
-    }
-
     private AnnotationNode readAnnotation(IAnnotationBinding annotationBinding) {
         return annotation(typeOf(annotationBinding.getAnnotationType()));
     }
 
-    private FormalArgumentNode readLambdaExpressionParameter(Object parameter) {
-        if (parameter instanceof SingleVariableDeclaration) {
-            return readSingleVariableDeclaration((SingleVariableDeclaration) parameter);
-        } else {
-            VariableDeclarationFragment fragment = (VariableDeclarationFragment)parameter;
-            return formalArg(var(
-                fragment.resolveBinding().getKey(),
-                fragment.getName().getIdentifier(),
-                typeOf(fragment.resolveBinding().getType())));
-        }
-    }
-
-    private List<StatementNode> readLambdaExpressionBody(LambdaExpression expression) {
-        TypeName returnType = typeOf(expression.resolveTypeBinding().getFunctionalInterfaceMethod().getReturnType());
-        if (expression.getBody() instanceof Block) {
-            @SuppressWarnings("unchecked")
-            List<Statement> statements = ((Block) expression.getBody()).statements();
-            return readStatements(statements, Optional.of(returnType));
-        } else {
-            Expression body = (Expression) expression.getBody();
-            return asList(returns(expressionReader().readExpression(returnType, body)));
-        }
-    }
-
     private class FunctionDeclaration {
         private final List<AnnotationNode> annotations;
         private final List<FormalArgumentNode> formalArguments;
@@ -351,11 +317,15 @@ public class JavaReader {
         }
     }
 
-    private List<StatementNode> readStatements(List<Statement> body, Optional<TypeName> returnType) {
+    List<StatementNode> readStatements(List<Statement> body, Optional<TypeName> returnType) {
         JavaStatementReader statementReader = new JavaStatementReader(expressionReader(), returnType);
         return eagerFlatMap(body, statementReader::readStatement);
     }
 
+    ExpressionNode readExpression(TypeName targetType, Expression body) {
+        return expressionReader().readExpression(targetType, body);
+    }
+
     private TypeName generateClassName(CompilationUnit ast) {
         TypeDeclaration type = (TypeDeclaration)ast.types().get(0);
         String packageName = ast.getPackage().getName().getFullyQualifiedName();
@@ -363,13 +333,6 @@ public class JavaReader {
         return TypeName.of(packageName + "." + className);
     }
 
-    private FormalArgumentNode readSingleVariableDeclaration(SingleVariableDeclaration parameter) {
-        return formalArg(var(
-            parameter.resolveBinding().getKey(),
-            parameter.getName().getIdentifier(),
-            typeOf(parameter.resolveBinding())));
-    }
-
     private JavaExpressionReader expressionReader() {
         return new JavaExpressionReader(this);
     }
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaVariableDeclarationReader.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaVariableDeclarationReader.java
new file mode 100644
index 0000000..992475d
--- /dev/null
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaVariableDeclarationReader.java
@@ -0,0 +1,17 @@
+package org.zwobble.couscous.frontends.java;
+
+import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
+import org.zwobble.couscous.ast.FormalArgumentNode;
+
+import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg;
+import static org.zwobble.couscous.ast.VariableDeclaration.var;
+import static org.zwobble.couscous.frontends.java.JavaTypes.typeOf;
+
+class JavaVariableDeclarationReader {
+    static FormalArgumentNode read(SingleVariableDeclaration parameter) {
+        return formalArg(var(
+            parameter.resolveBinding().getKey(),
+            parameter.getName().getIdentifier(),
+            typeOf(parameter.resolveBinding())));
+    }
+}