Read some infix operators for int

3 files changed, 96 insertions, 1 deletions

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 36c6b9c..baef84a 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
@@ -18,6 +18,8 @@ import org.eclipse.jdt.core.dom.IBinding;
 import org.eclipse.jdt.core.dom.IMethodBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.IVariableBinding;
+import org.eclipse.jdt.core.dom.InfixExpression;
+import org.eclipse.jdt.core.dom.InfixExpression.Operator;
 import org.eclipse.jdt.core.dom.MethodDeclaration;
 import org.eclipse.jdt.core.dom.MethodInvocation;
 import org.eclipse.jdt.core.dom.Modifier;
@@ -48,6 +50,9 @@ import org.zwobble.couscous.ast.StaticMethodCallNode;
 import org.zwobble.couscous.ast.TernaryConditionalNode;
 import org.zwobble.couscous.ast.ThisReferenceNode;
 import org.zwobble.couscous.ast.TypeName;
+import org.zwobble.couscous.values.BooleanValue;
+import org.zwobble.couscous.values.IntegerValue;
+
 import com.google.common.collect.Lists;
 import static java.util.Arrays.asList;
 import static org.zwobble.couscous.ast.ExpressionStatementNode.expressionStatement;
@@ -174,6 +179,9 @@ public class JavaReader {
         case ASTNode.CLASS_INSTANCE_CREATION: 
             return readClassInstanceCreation((ClassInstanceCreation)expression);
         
+        case ASTNode.INFIX_EXPRESSION:
+            return readInfixExpression((InfixExpression)expression);
+            
         case ASTNode.CONDITIONAL_EXPRESSION: 
             return readConditionalExpression((ConditionalExpression)expression);
         
@@ -185,7 +193,7 @@ public class JavaReader {
         
         }
     }
-    
+
     private static ExpressionNode readBooleanLiteral(BooleanLiteral expression) {
         return LiteralNode.literal(expression.booleanValue());
     }
@@ -252,6 +260,53 @@ public class JavaReader {
         return Lists.transform((List<Expression>)javaArguments, JavaReader::readExpression);
     }
     
+    private static ExpressionNode readInfixExpression(InfixExpression expression) {
+        JavaOperator operator = readOperator(expression.getOperator());
+        return MethodCallNode.methodCall(
+            readExpression(expression.getLeftOperand()),
+            operator.methodName,
+            asList(readExpression(expression.getRightOperand())),
+            operator.returnValue);
+    }
+    
+    private static JavaOperator readOperator(Operator operator) {
+        if (operator == Operator.PLUS) {
+            return JavaOperator.of("add", IntegerValue.REF);
+        } else if (operator == Operator.MINUS) {
+            return JavaOperator.of("subtract", IntegerValue.REF);
+        } else if (operator == Operator.TIMES) {
+            return JavaOperator.of("multiply", IntegerValue.REF);
+        } else if (operator == Operator.DIVIDE) {
+            return JavaOperator.of("divide", IntegerValue.REF);
+        } else if (operator == Operator.REMAINDER) {
+            return JavaOperator.of("mod", IntegerValue.REF);
+        } else if (operator == Operator.GREATER) {
+            return JavaOperator.of("greaterThan", BooleanValue.REF);
+        } else if (operator == Operator.GREATER_EQUALS) {
+            return JavaOperator.of("greaterThanOrEqual", BooleanValue.REF);
+        } else if (operator == Operator.LESS) {
+            return JavaOperator.of("lessThan", BooleanValue.REF);
+        } else if (operator == Operator.LESS_EQUALS) {
+            return JavaOperator.of("lessThanOrEqual", BooleanValue.REF);
+        } else {
+            throw new RuntimeException("Unrecognised operator: " + operator);
+        }
+    }
+    
+    private static class JavaOperator {
+        private static JavaOperator of(String methodName, TypeName returnValue) {
+            return new JavaOperator(methodName, returnValue);
+        }
+        
+        private final String methodName;
+        private final TypeName returnValue;
+
+        private JavaOperator(String methodName, TypeName returnValue) {
+            this.methodName = methodName;
+            this.returnValue = returnValue;
+        }
+    }
+
     private static ExpressionNode readConditionalExpression(ConditionalExpression expression) {
         return TernaryConditionalNode.ternaryConditional(readExpression(expression.getExpression()), readExpression(expression.getThenExpression()), readExpression(expression.getElseExpression()));
     }
diff --git a/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java b/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java
index 74b0ae4..b1101ec 100644
--- a/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java
@@ -3,6 +3,7 @@ package org.zwobble.couscous.tests;
 import java.nio.file.Files;
 import java.util.List;
 
+import org.junit.Ignore;
 import org.junit.Test;
 import org.zwobble.couscous.ast.ClassNode;
 import org.zwobble.couscous.ast.TypeName;
@@ -21,6 +22,13 @@ public class JavaToPythonTests {
         assertEquals(value(42), evalExpression("42"));
     }
     
+    @Test
+    @Ignore("WIP")
+    public void canUseOperatorsOnPrimitives() {
+        assertEquals(value(3), evalExpression("1 + 2"));
+        assertEquals(value(false), evalExpression("1 > 2"));
+    }
+    
     private PrimitiveValue evalExpression(String expressionSource) {
         try {
             final java.lang.String javaClass = "package com.example;" + "public class Example {" + "    public static Object main() {" + "        return " + expressionSource + ";" + "    }" + "}";
diff --git a/src/test/java/org/zwobble/couscous/tests/frontends/java/JavaReaderTests.java b/src/test/java/org/zwobble/couscous/tests/frontends/java/JavaReaderTests.java
index d01830f..ecb4d2a 100644
--- a/src/test/java/org/zwobble/couscous/tests/frontends/java/JavaReaderTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/frontends/java/JavaReaderTests.java
@@ -144,6 +144,38 @@ public class JavaReaderTests {
     }
     
     @Test
+    public void canUseOperatorsOnIntegers() {
+        assertEquals(
+            methodCall(literal(1), "add", asList(literal(2)), IntegerValue.REF),
+            readExpression("1 + 2"));
+        assertEquals(
+            methodCall(literal(1), "subtract", asList(literal(2)), IntegerValue.REF),
+            readExpression("1 - 2"));
+        assertEquals(
+            methodCall(literal(1), "multiply", asList(literal(2)), IntegerValue.REF),
+            readExpression("1 * 2"));
+        assertEquals(
+            methodCall(literal(1), "divide", asList(literal(2)), IntegerValue.REF),
+            readExpression("1 / 2"));
+        assertEquals(
+            methodCall(literal(1), "mod", asList(literal(2)), IntegerValue.REF),
+            readExpression("1 % 2"));
+        
+        assertEquals(
+            methodCall(literal(1), "greaterThan", asList(literal(2)), BooleanValue.REF),
+            readExpression("1 > 2"));
+        assertEquals(
+            methodCall(literal(1), "greaterThanOrEqual", asList(literal(2)), BooleanValue.REF),
+            readExpression("1 >= 2"));
+        assertEquals(
+            methodCall(literal(1), "lessThan", asList(literal(2)), BooleanValue.REF),
+            readExpression("1 < 2"));
+        assertEquals(
+            methodCall(literal(1), "lessThanOrEqual", asList(literal(2)), BooleanValue.REF),
+            readExpression("1 <= 2"));
+    }
+    
+    @Test
     public void canReadTernaryConditionals() {
         assertEquals(
             ternaryConditional(literal(true), literal(1), literal(2)),