Remove lombok

2 files changed, 43 insertions, 40 deletions

diff --git a/src/test/java/org/zwobble/couscous/tests/interpreter/EvaluatorTests.java b/src/test/java/org/zwobble/couscous/tests/interpreter/EvaluatorTests.java
index 2231bf0..a80934c 100644
--- a/src/test/java/org/zwobble/couscous/tests/interpreter/EvaluatorTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/interpreter/EvaluatorTests.java
@@ -6,6 +6,7 @@ import java.util.Optional;
 import org.junit.Test;
 import org.zwobble.couscous.ast.ClassNode;
 import org.zwobble.couscous.ast.ExpressionNode;
+import org.zwobble.couscous.ast.FormalArgumentNode;
 import org.zwobble.couscous.interpreter.ConditionMustBeBoolean;
 import org.zwobble.couscous.interpreter.Environment;
 import org.zwobble.couscous.interpreter.JavaProject;
@@ -17,6 +18,7 @@ import org.zwobble.couscous.interpreter.UnboundField;
 import org.zwobble.couscous.interpreter.UnexpectedValueType;
 import org.zwobble.couscous.interpreter.WrongNumberOfArguments;
 import org.zwobble.couscous.interpreter.values.IntegerInterpreterValue;
+import org.zwobble.couscous.interpreter.values.InterpreterValue;
 import org.zwobble.couscous.interpreter.values.StringInterpreterValue;
 import org.zwobble.couscous.tests.BackendEvalTests;
 import org.zwobble.couscous.values.IntegerValue;
@@ -41,23 +43,21 @@ import static org.zwobble.couscous.interpreter.values.InterpreterValues.value;
 import static org.zwobble.couscous.tests.TestIds.ANY_ID;
 import static org.zwobble.couscous.tests.util.ExtraAsserts.assertThrows;
 
-import lombok.val;
-
 public class EvaluatorTests extends BackendEvalTests {
     @Test
     public void valueOfAssignmentExpressionIsNewValue() {
-        val arg = formalArg(var(ANY_ID, "x", StringValue.REF));
-        val environment = new Environment(
+        FormalArgumentNode arg = formalArg(var(ANY_ID, "x", StringValue.REF));
+        Environment environment = new Environment(
             new MapBackedProject(ImmutableMap.of()),
             Optional.empty(),
             new StackFrameBuilder().declare(arg, value("[initial value]")).build());
-        val result = eval(environment, assign(arg, literal("[updated value]")));
+        InterpreterValue result = eval(environment, assign(arg, literal("[updated value]")));
         assertEquals(new StringInterpreterValue("[updated value]"), result);
     }
     
     @Test
     public void errorIfConditionIsNotBoolean() {
-        val exception = assertThrows(ConditionMustBeBoolean.class,
+        ConditionMustBeBoolean exception = assertThrows(ConditionMustBeBoolean.class,
             () -> eval(emptyEnvironment(),
                 ternaryConditional(literal(1), literal("T"), literal("F"))));
         assertEquals(new ConditionMustBeBoolean(new IntegerInterpreterValue(1)), exception);
@@ -65,7 +65,7 @@ public class EvaluatorTests extends BackendEvalTests {
     
     @Test
     public void errorIfMethodDoesNotExist() {
-        val exception = assertThrows(NoSuchMethod.class,
+        NoSuchMethod exception = assertThrows(NoSuchMethod.class,
             () -> eval(emptyEnvironment(),
                 methodCall(
                     literal("hello"),
@@ -77,7 +77,7 @@ public class EvaluatorTests extends BackendEvalTests {
     
     @Test
     public void errorIfWrongNumberOfArgumentsArePassed() {
-        val exception = assertThrows(WrongNumberOfArguments.class,
+        WrongNumberOfArguments exception = assertThrows(WrongNumberOfArguments.class,
             () -> eval(emptyEnvironment(),
                 methodCall(
                     literal("hello"),
@@ -89,7 +89,7 @@ public class EvaluatorTests extends BackendEvalTests {
     
     @Test
     public void errorIfArgumentIsWrongType() {
-        val exception = assertThrows(UnexpectedValueType.class,
+        UnexpectedValueType exception = assertThrows(UnexpectedValueType.class,
             () -> eval(emptyEnvironment(),
                 methodCall(
                     literal("hello"),
@@ -101,13 +101,13 @@ public class EvaluatorTests extends BackendEvalTests {
     
     @Test
     public void errorIfConstructorArgumentIsWrongType() {
-        val argument = formalArg(var(ANY_ID, "x", IntegerValue.REF));
-        val classNode = ClassNode.builder("com.example.Example")
+        FormalArgumentNode argument = formalArg(var(ANY_ID, "x", IntegerValue.REF));
+        ClassNode classNode = ClassNode.builder("com.example.Example")
             .constructor(constructor -> constructor
                 .argument(argument))
             .build();
         
-        val exception = assertThrows(UnexpectedValueType.class,
+        UnexpectedValueType exception = assertThrows(UnexpectedValueType.class,
             () -> evalExpression(
                 asList(classNode),
                 constructorCall(
@@ -119,10 +119,10 @@ public class EvaluatorTests extends BackendEvalTests {
     
     @Test
     public void cannotGetValueOfUndeclaredField() {
-        val classNode = ClassNode.builder("com.example.Example")
+        ClassNode classNode = ClassNode.builder("com.example.Example")
             .build();
         
-        val exception = assertThrows(NoSuchField.class,
+        NoSuchField exception = assertThrows(NoSuchField.class,
             () -> evalExpression(
                 asList(classNode),
                 fieldAccess(
@@ -137,11 +137,11 @@ public class EvaluatorTests extends BackendEvalTests {
     
     @Test
     public void cannotGetValueOfUnbounddField() {
-        val classNode = ClassNode.builder("com.example.Example")
+        ClassNode classNode = ClassNode.builder("com.example.Example")
             .field("value", IntegerValue.REF)
             .build();
         
-        val exception = assertThrows(UnboundField.class,
+        UnboundField exception = assertThrows(UnboundField.class,
             () -> evalExpression(
                 asList(classNode),
                 fieldAccess(
@@ -156,14 +156,14 @@ public class EvaluatorTests extends BackendEvalTests {
     
     @Test
     public void cannotSetValueOfUndeclaredField() {
-        val classNode = ClassNode.builder("com.example.Example")
+        ClassNode classNode = ClassNode.builder("com.example.Example")
             .constructor(constructor -> constructor
                 .statement(assignStatement(
                     fieldAccess(constructor.thisReference(), "value", IntegerValue.REF),
                     literal(42))))
             .build();
         
-        val exception = assertThrows(NoSuchField.class,
+        NoSuchField exception = assertThrows(NoSuchField.class,
             () -> evalExpression(
                 asList(classNode),
                 constructorCall(
@@ -175,7 +175,7 @@ public class EvaluatorTests extends BackendEvalTests {
     
     @Test
     public void cannotSetValueOfFieldWithWrongType() {
-        val classNode = ClassNode.builder("com.example.Example")
+        ClassNode classNode = ClassNode.builder("com.example.Example")
             .field("value", IntegerValue.REF)
             .constructor(constructor -> constructor
                 .statement(assignStatement(
@@ -183,7 +183,7 @@ public class EvaluatorTests extends BackendEvalTests {
                     literal(""))))
             .build();
         
-        val exception = assertThrows(UnexpectedValueType.class,
+        UnexpectedValueType exception = assertThrows(UnexpectedValueType.class,
             () -> evalExpression(
                 asList(classNode),
                 constructorCall(
@@ -205,7 +205,7 @@ public class EvaluatorTests extends BackendEvalTests {
             List<ClassNode> classes,
             ExpressionNode expression) {
         
-        val environment = new Environment(
+        Environment environment = new Environment(
             JavaProject.of(classes),
             Optional.empty(),
             ImmutableMap.of());
diff --git a/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterMethodTests.java b/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterMethodTests.java
index 118d657..50188ce 100644
--- a/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterMethodTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterMethodTests.java
@@ -5,14 +5,19 @@ import java.util.stream.Collectors;
 
 import org.junit.Test;
 import org.zwobble.couscous.ast.ClassNode;
+import org.zwobble.couscous.ast.FormalArgumentNode;
 import org.zwobble.couscous.ast.LiteralNode;
+import org.zwobble.couscous.ast.LocalVariableDeclarationNode;
+import org.zwobble.couscous.ast.MethodNode;
 import org.zwobble.couscous.ast.TypeName;
 import org.zwobble.couscous.interpreter.Interpreter;
 import org.zwobble.couscous.interpreter.JavaProject;
+import org.zwobble.couscous.interpreter.Project;
 import org.zwobble.couscous.interpreter.UnboundVariable;
 import org.zwobble.couscous.interpreter.UnexpectedValueType;
 import org.zwobble.couscous.interpreter.VariableNotInScope;
 import org.zwobble.couscous.interpreter.WrongNumberOfArguments;
+import org.zwobble.couscous.interpreter.values.InterpreterValue;
 import org.zwobble.couscous.interpreter.values.InterpreterValues;
 import org.zwobble.couscous.tests.BackendMethodTests;
 import org.zwobble.couscous.tests.MethodRunner;
@@ -34,14 +39,12 @@ import static org.zwobble.couscous.tests.TestIds.ANY_ID;
 import static org.zwobble.couscous.tests.util.ExtraAsserts.assertThrows;
 import static org.zwobble.couscous.values.PrimitiveValues.value;
 
-import lombok.val;
-
 public class InterpreterMethodTests extends BackendMethodTests {
     @Test
     public void errorIfWrongNumberOfArgumentsArePassed() {
-        val method = staticMethod("hello");
+        MethodNode.Builder method = staticMethod("hello");
         
-        val exception = assertThrows(WrongNumberOfArguments.class,
+        WrongNumberOfArguments exception = assertThrows(WrongNumberOfArguments.class,
             () -> runMethod(method, value("hello, world!")));
         
         assertEquals(new WrongNumberOfArguments(0, 1), exception);
@@ -49,12 +52,12 @@ public class InterpreterMethodTests extends BackendMethodTests {
     
     @Test
     public void errorIfTryingToAssignValueOfWrongTypeToVariable() {
-        val arg = formalArg(var(ANY_ID, "x", StringValue.REF));
-        val method = staticMethod("hello")
+        FormalArgumentNode arg = formalArg(var(ANY_ID, "x", StringValue.REF));
+        MethodNode.Builder method = staticMethod("hello")
             .argument(arg)
             .statement(expressionStatement(assign(reference(arg), literal(0))));
 
-        val exception = assertThrows(UnexpectedValueType.class,
+        UnexpectedValueType exception = assertThrows(UnexpectedValueType.class,
             () -> runMethod(method, value("")));
         
         assertEquals(new UnexpectedValueType(StringValue.REF, IntegerValue.REF), exception);
@@ -62,12 +65,12 @@ public class InterpreterMethodTests extends BackendMethodTests {
     
     @Test
     public void errorIfTryingToAssignToVariableNotInScope() {
-        val localVariableDeclaration = localVariableDeclaration(
+        LocalVariableDeclarationNode localVariableDeclaration = localVariableDeclaration(
             ANY_ID, "x", StringValue.REF, literal(""));
-        val method = staticMethod("hello")
+        MethodNode.Builder method = staticMethod("hello")
             .statement(expressionStatement(assign(reference(localVariableDeclaration), LiteralNode.literal("[updated value]"))));
 
-        val exception = assertThrows(VariableNotInScope.class,
+        VariableNotInScope exception = assertThrows(VariableNotInScope.class,
             () -> runMethod(method));
         
         assertEquals(new VariableNotInScope(ANY_ID), exception);
@@ -75,12 +78,12 @@ public class InterpreterMethodTests extends BackendMethodTests {
     
     @Test
     public void errorIfTryingToGetValueOfVariableNotInScope() {
-        val localVariableDeclaration = localVariableDeclaration(
+        LocalVariableDeclarationNode localVariableDeclaration = localVariableDeclaration(
             ANY_ID, "x", StringValue.REF, literal(""));
-        val method = staticMethod("hello")
+        MethodNode.Builder method = staticMethod("hello")
             .statement(returns(reference(localVariableDeclaration)));
 
-        val exception = assertThrows(VariableNotInScope.class,
+        VariableNotInScope exception = assertThrows(VariableNotInScope.class,
             () -> runMethod(method));
         
         assertEquals(new VariableNotInScope(ANY_ID), exception);
@@ -88,13 +91,13 @@ public class InterpreterMethodTests extends BackendMethodTests {
     
     @Test
     public void errorIfTryingToGetValueOfUnboundVariable() {
-        val localVariableDeclaration = localVariableDeclaration(
+        LocalVariableDeclarationNode localVariableDeclaration = localVariableDeclaration(
             ANY_ID, "x", StringValue.REF, literal(""));
-        val method = staticMethod("hello")
+        MethodNode.Builder method = staticMethod("hello")
             .statement(returns(reference(localVariableDeclaration)))
             .statement(localVariableDeclaration);
 
-        val exception = assertThrows(UnboundVariable.class,
+        UnboundVariable exception = assertThrows(UnboundVariable.class,
             () -> runMethod(method));
         
         assertEquals(new UnboundVariable(ANY_ID), exception);
@@ -110,9 +113,9 @@ public class InterpreterMethodTests extends BackendMethodTests {
                     String methodName,
                     List<PrimitiveValue> arguments) {
                 
-                val project = JavaProject.of(classNodes);
-                val interpreter = new Interpreter(project);
-                val argumentValues = arguments.stream()
+                Project project = JavaProject.of(classNodes);
+                Interpreter interpreter = new Interpreter(project);
+                List<InterpreterValue> argumentValues = arguments.stream()
                     .map(InterpreterValues::value)
                     .collect(Collectors.toList());