Use Operator instead of magic strings

3 files changed, 33 insertions, 31 deletions

diff --git a/src/main/java/org/zwobble/couscous/ast/MethodCallNode.java b/src/main/java/org/zwobble/couscous/ast/MethodCallNode.java
index 508a8f7..9ad750b 100644
--- a/src/main/java/org/zwobble/couscous/ast/MethodCallNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/MethodCallNode.java
@@ -20,23 +20,23 @@ public class MethodCallNode implements ExpressionNode {
     }
 
     public static ExpressionNode integerAdd(ExpressionNode left, ExpressionNode right) {
-        return integerOperation("add", left, right);
+        return integerOperation(Operator.ADD.getMethodName(), left, right);
     }
 
     public static ExpressionNode integerSubtract(ExpressionNode left, ExpressionNode right) {
-        return integerOperation("subtract", left, right);
+        return integerOperation(Operator.SUBTRACT.getMethodName(), left, right);
     }
 
     public static ExpressionNode integerMultiply(ExpressionNode left, ExpressionNode right) {
-        return integerOperation("multiply", left, right);
+        return integerOperation(Operator.MULTIPLY.getMethodName(), left, right);
     }
 
     public static ExpressionNode integerDivide(ExpressionNode left, ExpressionNode right) {
-        return integerOperation("divide", left, right);
+        return integerOperation(Operator.DIVIDE.getMethodName(), left, right);
     }
 
     public static ExpressionNode integerMod(ExpressionNode left, ExpressionNode right) {
-        return integerOperation("mod", left, right);
+        return integerOperation(Operator.MOD.getMethodName(), left, right);
     }
 
     private static MethodCallNode integerOperation(String methodName, ExpressionNode left, ExpressionNode right) {
@@ -44,27 +44,27 @@ public class MethodCallNode implements ExpressionNode {
     }
 
     public static ExpressionNode equal(ExpressionNode left, ExpressionNode right) {
-        return booleanOperation("equals", left, right);
+        return booleanOperation(Operator.EQUALS.getMethodName(), left, right);
     }
 
     public static ExpressionNode notEqual(ExpressionNode left, ExpressionNode right) {
-        return not(booleanOperation("equals", left, right));
+        return not(booleanOperation(Operator.EQUALS.getMethodName(), left, right));
     }
 
     public static ExpressionNode greaterThan(ExpressionNode left, ExpressionNode right) {
-        return booleanOperation("greaterThan", left, right);
+        return booleanOperation(Operator.GREATER_THAN.getMethodName(), left, right);
     }
 
     public static ExpressionNode greaterThanOrEqual(ExpressionNode left, ExpressionNode right) {
-        return booleanOperation("greaterThanOrEqual", left, right);
+        return booleanOperation(Operator.GREATER_THAN_OR_EQUAL.getMethodName(), left, right);
     }
 
     public static ExpressionNode lessThan(ExpressionNode left, ExpressionNode right) {
-        return booleanOperation("lessThan", left, right);
+        return booleanOperation(Operator.LESS_THAN.getMethodName(), left, right);
     }
 
     public static ExpressionNode lessThanOrEqual(ExpressionNode left, ExpressionNode right) {
-        return booleanOperation("lessThanOrEqual", left, right);
+        return booleanOperation(Operator.LESS_THAN_OR_EQUAL.getMethodName(), left, right);
     }
 
     private static ExpressionNode booleanOperation(String methodName, ExpressionNode left, ExpressionNode right) {
diff --git a/src/main/java/org/zwobble/couscous/backends/python/PrimitiveMethods.java b/src/main/java/org/zwobble/couscous/backends/python/PrimitiveMethods.java
index 6605fc9..db2cac0 100644
--- a/src/main/java/org/zwobble/couscous/backends/python/PrimitiveMethods.java
+++ b/src/main/java/org/zwobble/couscous/backends/python/PrimitiveMethods.java
@@ -4,6 +4,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
+import org.zwobble.couscous.ast.Operator;
 import org.zwobble.couscous.ast.TypeName;
 import org.zwobble.couscous.backends.python.ast.PythonExpressionNode;
 import org.zwobble.couscous.backends.python.ast.PythonNotNode;
@@ -49,24 +50,24 @@ public class PrimitiveMethods {
     static {
         ImmutableMap.Builder<String, PrimitiveMethodGenerator> methods = ImmutableMap.builder();
         
-        addMethod(methods, "add", "__add__");
-        addMethod(methods, "subtract", "__sub__");
-        addMethod(methods, "multiply", "__mul__");
+        addMethod(methods, Operator.ADD.getMethodName(), "__add__");
+        addMethod(methods, Operator.SUBTRACT.getMethodName(), "__sub__");
+        addMethod(methods, Operator.MULTIPLY.getMethodName(), "__mul__");
 
-        methods.put("divide", (receiver, arguments) ->
+        methods.put(Operator.DIVIDE.getMethodName(), (receiver, arguments) ->
             pythonCall(
                 internalReference("_div_round_to_zero"),
                 asList(receiver, arguments.get(0))));
-        methods.put("mod", (receiver, arguments) ->
+        methods.put(Operator.MOD.getMethodName(), (receiver, arguments) ->
             pythonCall(
                 internalReference("_mod_round_to_zero"),
                 asList(receiver, arguments.get(0))));
 
-        addMethod(methods, "equals", "__eq__");
-        addMethod(methods, "greaterThan", "__gt__");
-        addMethod(methods, "greaterThanOrEqual", "__ge__");
-        addMethod(methods, "lessThan", "__lt__");
-        addMethod(methods, "lessThanOrEqual", "__le__");
+        addMethod(methods, Operator.EQUALS.getMethodName(), "__eq__");
+        addMethod(methods, Operator.GREATER_THAN.getMethodName(), "__gt__");
+        addMethod(methods, Operator.GREATER_THAN_OR_EQUAL.getMethodName(), "__ge__");
+        addMethod(methods, Operator.LESS_THAN.getMethodName(), "__lt__");
+        addMethod(methods, Operator.LESS_THAN_OR_EQUAL.getMethodName(), "__le__");
         
         INT_METHODS = methods.build();
     }
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java
index 2364f6f..dce3cab 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java
@@ -3,6 +3,7 @@ package org.zwobble.couscous.interpreter.values;
 import java.util.Optional;
 import java.util.function.BiFunction;
 
+import org.zwobble.couscous.ast.Operator;
 import org.zwobble.couscous.interpreter.Environment;
 import org.zwobble.couscous.interpreter.NoSuchField;
 import org.zwobble.couscous.values.IntegerValue;
@@ -13,25 +14,25 @@ import static java.util.Arrays.asList;
 
 public final class IntegerInterpreterValue implements InterpreterValue {
     public static final ConcreteType TYPE = ConcreteType.builder(IntegerInterpreterValue.class, IntegerValue.REF)
-        .method("add", asList(IntegerValue.REF),
+        .method(Operator.ADD.getMethodName(), asList(IntegerValue.REF),
             infixReturningInteger((left, right) -> left + right))
-        .method("subtract", asList(IntegerValue.REF),
+        .method(Operator.SUBTRACT.getMethodName(), asList(IntegerValue.REF),
             infixReturningInteger((left, right) -> left - right))
-        .method("multiply", asList(IntegerValue.REF),
+        .method(Operator.MULTIPLY.getMethodName(), asList(IntegerValue.REF),
             infixReturningInteger((left, right) -> left * right))
-        .method("divide", asList(IntegerValue.REF),
+        .method(Operator.DIVIDE.getMethodName(), asList(IntegerValue.REF),
             infixReturningInteger((left, right) -> left / right))
-        .method("mod", asList(IntegerValue.REF),
+        .method(Operator.MOD.getMethodName(), asList(IntegerValue.REF),
             infixReturningInteger((left, right) -> left % right))
-        .method("equals", asList(IntegerValue.REF),
+        .method(Operator.EQUALS.getMethodName(), asList(IntegerValue.REF),
             infixReturningBoolean((left, right) -> left == right))
-        .method("greaterThan", asList(IntegerValue.REF),
+        .method(Operator.GREATER_THAN.getMethodName(), asList(IntegerValue.REF),
             infixReturningBoolean((left, right) -> left > right))
-        .method("greaterThanOrEqual", asList(IntegerValue.REF),
+        .method(Operator.GREATER_THAN_OR_EQUAL.getMethodName(), asList(IntegerValue.REF),
             infixReturningBoolean((left, right) -> left >= right))
-        .method("lessThan", asList(IntegerValue.REF),
+        .method(Operator.LESS_THAN.getMethodName(), asList(IntegerValue.REF),
             infixReturningBoolean((left, right) -> left < right))
-        .method("lessThanOrEqual", asList(IntegerValue.REF),
+        .method(Operator.LESS_THAN_OR_EQUAL.getMethodName(), asList(IntegerValue.REF),
             infixReturningBoolean((left, right) -> left <= right))
         .build();