From 9768326b29ae0338a0fb6614b73fa9a03af471fd Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Sat, 21 Nov 2015 19:04:26 +0000 Subject: Allow expression reader to add classes --- .../frontends/java/JavaExpressionReader.java | 31 +++++++++++------- .../couscous/frontends/java/JavaFrontend.java | 3 +- .../couscous/frontends/java/JavaReader.java | 38 +++++++++++++--------- .../frontends/java/JavaStatementReader.java | 25 ++++++++------ 4 files changed, 57 insertions(+), 40 deletions(-) (limited to 'src/main/java') 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 classes; + + JavaExpressionReader(ImmutableList.Builder 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 arguments = readArguments( @@ -177,7 +184,7 @@ public class JavaExpressionReader { } } - private static ExpressionNode readClassInstanceCreation(ClassInstanceCreation expression) { + private ExpressionNode readClassInstanceCreation(ClassInstanceCreation expression) { @SuppressWarnings("unchecked") List arguments = expression.arguments(); return ConstructorCallNode.constructorCall( @@ -185,7 +192,7 @@ public class JavaExpressionReader { readArguments(expression.resolveConstructorBinding(), arguments)); } - private static List readArguments(IMethodBinding method, List javaArguments) { + private List readArguments(IMethodBinding method, List 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 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 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 readClassFromFile(Path root, Path sourcePath) throws IOException { - CompilationUnit ast = parser.parseCompilationUnit(root, sourcePath); - return readCompilationUnit(ast); + public static List 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 readCompilationUnit(CompilationUnit ast) { + + private final ImmutableList.Builder classes; + + private JavaReader() { + classes = ImmutableList.builder(); + } + + private List 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 ClassNodeBuilder.MethodBuilder buildMethod(MethodDeclaration method, ClassNodeBuilder.MethodBuilder builder) { + private ClassNodeBuilder.MethodBuilder buildMethod(MethodDeclaration method, ClassNodeBuilder.MethodBuilder builder) { for (IAnnotationBinding annotation : method.resolveBinding().getAnnotations()) { builder.annotation(typeOf(annotation.getAnnotationType())); } @@ -69,7 +75,7 @@ public class JavaReader { Optional 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 returnType; - JavaStatementReader(Optional returnType) { + JavaStatementReader(JavaExpressionReader expressionReader, Optional 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 readVariableDeclarationStatement(VariableDeclarationStatement statement) { + private List readVariableDeclarationStatement(VariableDeclarationStatement statement) { @SuppressWarnings("unchecked") List fragments = statement.fragments(); TypeName type = typeOf(statement.getType()); return readDeclarationFragments(fragments, type); } - private static List readDeclarationFragments(List fragments, TypeName type) { + private List readDeclarationFragments(List 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); + } } -- cgit v1.2.3