Add support for no more than one anonymous class

4 files changed, 57 insertions, 18 deletions

diff --git a/src/main/java/org/zwobble/couscous/ast/TypeName.java b/src/main/java/org/zwobble/couscous/ast/TypeName.java
index e25f911..4ff70ed 100644
--- a/src/main/java/org/zwobble/couscous/ast/TypeName.java
+++ b/src/main/java/org/zwobble/couscous/ast/TypeName.java
@@ -1,7 +1,12 @@
 package org.zwobble.couscous.ast;
 
+import com.google.common.base.Strings;
+
 public class TypeName {
     public static TypeName of(String qualifiedName) {
+        if (Strings.isNullOrEmpty(qualifiedName)) {
+            throw new IllegalArgumentException("qualifiedName cannot be blank");
+        }
         return new TypeName(qualifiedName);
     }
     
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 b5c434d..37a167c 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java
@@ -12,6 +12,7 @@ import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 import static java.util.Arrays.asList;
+import static org.zwobble.couscous.ast.ConstructorCallNode.constructorCall;
 import static org.zwobble.couscous.ast.LiteralNode.literal;
 import static org.zwobble.couscous.ast.VariableDeclaration.var;
 import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
@@ -19,9 +20,11 @@ import static org.zwobble.couscous.frontends.java.JavaOperators.readOperator;
 import static org.zwobble.couscous.frontends.java.JavaTypes.typeOf;
 
 public class JavaExpressionReader {
+    private final JavaReader javaReader;
     private final ImmutableList.Builder<ClassNode> classes;
 
-    JavaExpressionReader(ImmutableList.Builder<ClassNode> classes) {
+    JavaExpressionReader(JavaReader javaReader, ImmutableList.Builder<ClassNode> classes) {
+        this.javaReader = javaReader;
         this.classes = classes;
     }
 
@@ -186,10 +189,18 @@ public class JavaExpressionReader {
 
     private ExpressionNode readClassInstanceCreation(ClassInstanceCreation expression) {
         @SuppressWarnings("unchecked")
-        List<Expression> arguments = expression.arguments();
-        return ConstructorCallNode.constructorCall(
-            typeOf(expression),
-            readArguments(expression.resolveConstructorBinding(), arguments));
+        List<Expression> javaArguments = expression.arguments();
+        IMethodBinding constructor = expression.resolveConstructorBinding();
+        List<ExpressionNode> arguments = readArguments(constructor, javaArguments);
+
+        if (constructor.getDeclaringClass().isAnonymous()) {
+            // TODO: generate anonymous class name
+            TypeName anonymousClassName = TypeName.of("ANONYMOUS");
+            classes.add(javaReader.readTypeDeclaration("ANONYMOUS", expression.getAnonymousClassDeclaration()));
+            return constructorCall(anonymousClassName, arguments);
+        } else {
+            return constructorCall(typeOf(expression), arguments);
+        }
     }
 
     private List<ExpressionNode> readArguments(IMethodBinding method, List<Expression> javaArguments) {
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 0a9e32a..70f9c3d 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
@@ -12,14 +12,16 @@ 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;
+import static org.zwobble.couscous.util.ExtraLists.ofType;
 
 public class JavaReader {
     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);
+        return cons(reader.readCompilationUnit(ast), reader.classes.build());
     }
 
     private final ImmutableList.Builder<ClassNode> classes;
@@ -28,17 +30,28 @@ public class JavaReader {
         classes = ImmutableList.builder();
     }
 
-    private List<ClassNode> readCompilationUnit(CompilationUnit ast) {
+    private 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 cons(classBuilder.build(), classes.build());
+        return readTypeDeclaration(name, type);
     }
-    
-    private void readFields(TypeDeclaration type, ClassNodeBuilder classBuilder) {
-        for (FieldDeclaration field : type.getFields()) {
+
+    ClassNode readTypeDeclaration(String name, AnonymousClassDeclaration type) {
+        ClassNodeBuilder classBuilder = new ClassNodeBuilder(name);
+        readFields(ofType(type.bodyDeclarations(), FieldDeclaration.class), classBuilder);
+        readMethods(ofType(type.bodyDeclarations(), MethodDeclaration.class), classBuilder);
+        return classBuilder.build();
+    }
+
+    ClassNode readTypeDeclaration(String name, TypeDeclaration type) {
+        ClassNodeBuilder classBuilder = new ClassNodeBuilder(name);
+        readFields(asList(type.getFields()), classBuilder);
+        readMethods(asList(type.getMethods()), classBuilder);
+        return classBuilder.build();
+    }
+
+    private void readFields(List<FieldDeclaration> fields, ClassNodeBuilder classBuilder) {
+        for (FieldDeclaration field : fields) {
             readField(field, classBuilder);
         }
     }
@@ -50,8 +63,8 @@ public class JavaReader {
         }
     }
     
-    private void readMethods(TypeDeclaration type, ClassNodeBuilder classBuilder) {
-        for (MethodDeclaration method : type.getMethods()) {
+    private void readMethods(List<MethodDeclaration> methods, ClassNodeBuilder classBuilder) {
+        for (MethodDeclaration method : methods) {
             readMethod(classBuilder, method);
         }
     }
@@ -60,7 +73,10 @@ public class JavaReader {
         if (method.isConstructor()) {
             classBuilder.constructor(builder -> buildMethod(method, builder));
         } else {
-            classBuilder.method(method.getName().getIdentifier(), true, builder -> buildMethod(method, builder));
+            classBuilder.method(
+                method.getName().getIdentifier(),
+                Modifier.isStatic(method.getModifiers()),
+                builder -> buildMethod(method, builder));
         }
     }
 
@@ -75,7 +91,7 @@ public class JavaReader {
         Optional<TypeName> returnType = method.getReturnType2() == null
             ? Optional.empty()
             : Optional.of(typeOf(method.getReturnType2()));
-        JavaStatementReader statementReader = new JavaStatementReader(new JavaExpressionReader(classes), returnType);
+        JavaStatementReader statementReader = new JavaStatementReader(new JavaExpressionReader(this, classes), returnType);
         for (Object statement : method.getBody().statements()) {
             for (StatementNode intermediateStatement : statementReader.readStatement((Statement)statement)) {
                 builder.statement(intermediateStatement);
diff --git a/src/main/java/org/zwobble/couscous/util/ExtraLists.java b/src/main/java/org/zwobble/couscous/util/ExtraLists.java
index 1951868..de28f21 100644
--- a/src/main/java/org/zwobble/couscous/util/ExtraLists.java
+++ b/src/main/java/org/zwobble/couscous/util/ExtraLists.java
@@ -20,6 +20,13 @@ public class ExtraLists {
     }
 
     @SuppressWarnings("unchecked")
+    public static <T, R extends T> List<R> ofType(List<T> list, Class<R> clazz) {
+        return (List<R>)list.stream()
+            .filter(clazz::isInstance)
+            .collect(Collectors.toList());
+    }
+
+    @SuppressWarnings("unchecked")
     public static <T, R, E extends Exception> List<R> flatMap(
             Stream<T> stream,
             CheckedFunction<T, Iterable<R>, E> function) throws E {