Remove lombok

11 files changed, 215 insertions, 286 deletions

diff --git a/src/test/java/org/zwobble/couscous/tests/BackendEvalTests.java b/src/test/java/org/zwobble/couscous/tests/BackendEvalTests.java
index 169e0f3..20d1881 100644
--- a/src/test/java/org/zwobble/couscous/tests/BackendEvalTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/BackendEvalTests.java
@@ -5,6 +5,7 @@ import java.util.List;
 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.values.IntegerValue;
 import org.zwobble.couscous.values.PrimitiveValue;
 import org.zwobble.couscous.values.StringValue;
@@ -27,8 +28,6 @@ import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
 import static org.zwobble.couscous.tests.TestIds.ANY_ID;
 import static org.zwobble.couscous.values.PrimitiveValues.value;
 
-import lombok.val;
-
 public abstract class BackendEvalTests {
     @Test
     public void canEvaluateLiterals() {
@@ -40,19 +39,19 @@ public abstract class BackendEvalTests {
     
     @Test
     public void whenConditionIsTrueThenValueOfConditionalTernaryIsTrueBranch() {
-        val result = evalExpression(ternaryConditional(literal(true), literal("T"), literal("F")));
+        PrimitiveValue result = evalExpression(ternaryConditional(literal(true), literal("T"), literal("F")));
         assertEquals(value("T"), result);
     }
     
     @Test
     public void whenConditionIsFalseThenValueOfConditionalTernaryIsFalseBranch() {
-        val result = evalExpression(ternaryConditional(literal(false), literal("T"), literal("F")));
+        PrimitiveValue result = evalExpression(ternaryConditional(literal(false), literal("T"), literal("F")));
         assertEquals(value("F"), result);
     }
     
     @Test
     public void canCallMethodWithNoArgumentsOnBuiltin() {
-        val result = evalExpression(methodCall(
+        PrimitiveValue result = evalExpression(methodCall(
             literal("hello"),
             "length",
             asList(),
@@ -62,7 +61,7 @@ public abstract class BackendEvalTests {
     
     @Test
     public void canCallMethodWithArgumentsOnBuiltin() {
-        val result = evalExpression(methodCall(
+        PrimitiveValue result = evalExpression(methodCall(
             literal("hello"),
             "substring",
             asList(literal(1), literal(4)),
@@ -72,43 +71,43 @@ public abstract class BackendEvalTests {
     
     @Test
     public void canCallBuiltinStaticMethod() {
-        val result = evalExpression(
+        PrimitiveValue result = evalExpression(
             staticMethodCall("java.lang.Integer", "parseInt", literal("42")));
         assertEquals(value(42), result);
     }
     
     @Test
     public void canCallStaticMethodFromUserDefinedStaticMethod() {
-        val classNode = ClassNode.builder("com.example.Example")
+        ClassNode classNode = ClassNode.builder("com.example.Example")
             .staticMethod("main", method -> method
                 .statement(returns(staticMethodCall("java.lang.Integer", "parseInt", literal("42")))))
             .build();
-        val result = evalExpression(asList(classNode),
+        PrimitiveValue result = evalExpression(asList(classNode),
             staticMethodCall("com.example.Example", "main"));
         assertEquals(value(42), result);
     }
     
     @Test
     public void canCallInstanceMethodWithNoArgumentsOnUserDefinedClass() {
-        val classNode = ClassNode.builder("com.example.Example")
+        ClassNode classNode = ClassNode.builder("com.example.Example")
             .method("main", method -> method
                 .statement(returns(literal(42))))
             .build();
-        val result = evalExpression(asList(classNode),
+        PrimitiveValue result = evalExpression(asList(classNode),
             methodCall(constructorCall(classNode.getName(), asList()), "main", asList(), IntegerValue.REF));
         assertEquals(value(42), result);
     }
     
     @Test
     public void canCallInstanceMethodWithArgumentsOnUserDefinedClass() {
-        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")
             .method("main", method -> method
                 .argument(argument)
                 .statement(returns(reference(argument))))
             .build();
         
-        val result = evalExpression(
+        PrimitiveValue result = evalExpression(
             asList(classNode),
             methodCall(
                 constructorCall(classNode.getName(), asList()),
@@ -121,8 +120,8 @@ public abstract class BackendEvalTests {
     
     @Test
     public void constructorIsExecutedOnConstruction() {
-        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")
             .field("value", IntegerValue.REF)
             .constructor(constructor -> constructor
                 .argument(argument)
@@ -134,7 +133,7 @@ public abstract class BackendEvalTests {
                     fieldAccess(method.thisReference(), "value", IntegerValue.REF))))
             .build();
         
-        val result = evalExpression(
+        PrimitiveValue result = evalExpression(
             asList(classNode),
             methodCall(
                 constructorCall(classNode.getName(), asList(literal(42))),
diff --git a/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java b/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java
index 0f463ca..f1af3a9 100644
--- a/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java
@@ -2,12 +2,13 @@ package org.zwobble.couscous.tests;
 
 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.values.PrimitiveValue;
 import org.zwobble.couscous.values.PrimitiveValues;
 import org.zwobble.couscous.values.StringValue;
-
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
 import static org.zwobble.couscous.ast.AssignmentNode.assign;
@@ -22,88 +23,75 @@ import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
 import static org.zwobble.couscous.tests.TestIds.ANY_ID;
 import static org.zwobble.couscous.values.PrimitiveValues.value;
 
-import lombok.val;
-
 public abstract class BackendMethodTests {
     @Test
     public void methodWithNoStatementsReturnsUnit() {
-        val method = staticMethod("hello");
-        val result = runMethod(method);
-        
+        MethodNode.Builder method = staticMethod("hello");
+        final java.lang.Object result = runMethod(method);
         assertEquals(PrimitiveValues.UNIT, result);
     }
     
     @Test
     public void canReturnLiteralValue() {
-        val method = staticMethod("hello")
+        MethodNode.Builder method = staticMethod("hello")
             .statement(returns(literal("hello, world!")));
-        val result = runMethod(method);
-        
+        final java.lang.Object result = runMethod(method);
         assertEquals(value("hello, world!"), result);
     }
+    
     @Test
     public void canPassValueToMethod() {
-        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(returns(reference(arg)));
-        val result = runMethod(method, value("hello, world!"));
-        
+        final java.lang.Object result = runMethod(method, value("hello, world!"));
         assertEquals(value("hello, world!"), result);
     }
     
     @Test
     public void canReassignValueToArgument() {
-        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), LiteralNode.literal("[updated value]"))))
+            .statement(expressionStatement(assign(
+                reference(arg),
+                literal("[updated value]"))))
             .statement(returns(reference(arg)));
-        val result = runMethod(method, value("[initial value]"));
-        
+        final java.lang.Object result = runMethod(method, value("[initial value]"));
         assertEquals(value("[updated value]"), result);
     }
     
     @Test
     public void canDeclareVariable() {
-        val localVariableDeclaration = localVariableDeclaration(
-            ANY_ID, "x", StringValue.REF, LiteralNode.literal("[initial value]"));
-        val method = staticMethod("hello")
+        LocalVariableDeclarationNode localVariableDeclaration = localVariableDeclaration(ANY_ID, "x", StringValue.REF, LiteralNode.literal("[initial value]"));
+        MethodNode.Builder method = staticMethod("hello")
             .statement(localVariableDeclaration)
             .statement(returns(reference(localVariableDeclaration)));
-        val result = runMethod(method);
-        
+        final java.lang.Object result = runMethod(method);
         assertEquals(value("[initial value]"), result);
     }
     
     @Test
     public void canDeclareVariableAndThenAssignValues() {
-        val localVariableDeclaration = localVariableDeclaration(
-            ANY_ID, "x", StringValue.REF, LiteralNode.literal("[initial value]"));
-        val method = staticMethod("hello")
+        LocalVariableDeclarationNode localVariableDeclaration = localVariableDeclaration(ANY_ID, "x", StringValue.REF, LiteralNode.literal("[initial value]"));
+        MethodNode.Builder method = staticMethod("hello")
             .statement(localVariableDeclaration)
-            .statement(expressionStatement(assign(reference(localVariableDeclaration), LiteralNode.literal("[updated value]"))))
+            .statement(expressionStatement(assign(
+                reference(localVariableDeclaration),
+                literal("[updated value]"))))
             .statement(returns(reference(localVariableDeclaration)));
-        val result = runMethod(method);
-        
+        final java.lang.Object result = runMethod(method);
         assertEquals(value("[updated value]"), result);
     }
-
+    
     protected PrimitiveValue runMethod(MethodNode.Builder methodBuilder, PrimitiveValue... arguments) {
-        val method = methodBuilder.build();
-        val className = "com.example.Program";
-        val classNode = ClassNode.builder(className)
-            .method(method)
-            .build();
-        
-        val runner = buildMethodRunner();
-        return runner.runMethod(
-            asList(classNode),
-            classNode.getName(),
-            method.getName(),
-            asList(arguments));
+        MethodNode method = methodBuilder.build();
+        String className = "com.example.Program";
+        ClassNode classNode = ClassNode.builder(className).method(method).build();
+        MethodRunner runner = buildMethodRunner();
+        return runner.runMethod(asList(classNode), classNode.getName(), method.getName(), asList(arguments));
     }
     
     protected abstract MethodRunner buildMethodRunner();
-        
-}
+}
\ No newline at end of file
diff --git a/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java b/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java
index 6732f47..74b0ae4 100644
--- a/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java
@@ -1,54 +1,40 @@
 package org.zwobble.couscous.tests;
 
 import java.nio.file.Files;
+import java.util.List;
 
 import org.junit.Test;
+import org.zwobble.couscous.ast.ClassNode;
 import org.zwobble.couscous.ast.TypeName;
 import org.zwobble.couscous.frontends.java.JavaFrontend;
 import org.zwobble.couscous.tests.backends.python.PythonMethodRunner;
 import org.zwobble.couscous.values.PrimitiveValue;
-
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
 import static org.zwobble.couscous.tests.util.ExtraFiles.deleteRecursively;
 import static org.zwobble.couscous.values.PrimitiveValues.value;
 
-import lombok.SneakyThrows;
-import lombok.val;
-
 public class JavaToPythonTests {
     @Test
     public void canEvaluateLiterals() {
         assertEquals(value("hello"), evalExpression("\"hello\""));
         assertEquals(value(42), evalExpression("42"));
     }
-
-    @SneakyThrows
+    
     private PrimitiveValue evalExpression(String expressionSource) {
-        val javaClass =
-            "package com.example;" +
-            "public class Example {" +
-            "    public static Object main() {" +
-            "        return " + expressionSource + ";" +
-            "    }" +
-            "}";
-
-        val directoryPath = Files.createTempDirectory(null);
         try {
-            Files.createDirectories(directoryPath.resolve("com/example"));
-            Files.write(
-                directoryPath.resolve("com/example/Example.java"),
-                asList(javaClass));
-            
-            val classNodes = JavaFrontend.readSourceDirectory(directoryPath);
-            
-            return new PythonMethodRunner().runMethod(
-                classNodes,
-                TypeName.of("com.example.Example"),
-                "main",
-                asList());
-        } finally {
-            deleteRecursively(directoryPath.toFile());
+            final java.lang.String javaClass = "package com.example;" + "public class Example {" + "    public static Object main() {" + "        return " + expressionSource + ";" + "    }" + "}";
+            final java.nio.file.Path directoryPath = Files.createTempDirectory(null);
+            try {
+                Files.createDirectories(directoryPath.resolve("com/example"));
+                Files.write(directoryPath.resolve("com/example/Example.java"), asList(javaClass));
+                List<ClassNode> classNodes = JavaFrontend.readSourceDirectory(directoryPath);
+                return new PythonMethodRunner().runMethod(classNodes, TypeName.of("com.example.Example"), "main", asList());
+            } finally {
+                deleteRecursively(directoryPath.toFile());
+            }
+        } catch (final java.lang.Throwable $ex) {
+            throw new RuntimeException($ex);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerEvalTests.java b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerEvalTests.java
index c273638..c5c7aab 100644
--- a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerEvalTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerEvalTests.java
@@ -1,39 +1,31 @@
 package org.zwobble.couscous.tests.backends.python;
 
 import java.util.List;
-
 import org.zwobble.couscous.ast.ClassNode;
 import org.zwobble.couscous.ast.ExpressionNode;
 import org.zwobble.couscous.ast.MethodNode;
 import org.zwobble.couscous.ast.ReturnNode;
 import org.zwobble.couscous.tests.BackendEvalTests;
 import org.zwobble.couscous.values.PrimitiveValue;
-
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
-
 import static java.util.Arrays.asList;
 
-import lombok.val;
-
 public class PythonCompilerEvalTests extends BackendEvalTests {
     @Override
-    protected PrimitiveValue evalExpression(
-            List<ClassNode> classes,
-            ExpressionNode expression) {
-        
-        val programNode = ClassNode.builder("Program")
+    protected PrimitiveValue evalExpression(List<ClassNode> classes, ExpressionNode expression) {
+        ClassNode programNode = ClassNode.builder("Program")
             .method(MethodNode.staticMethod("run")
                 .statement(ReturnNode.returns(expression))
                 .build())
             .build();
-        
-        val runner = new PythonMethodRunner();
-        
+        PythonMethodRunner runner = new PythonMethodRunner();
         return runner.runMethod(
-            ImmutableList.copyOf(Iterables.concat(classes, asList(programNode))),
+            ImmutableList.copyOf(Iterables.concat(
+                classes,
+                asList(programNode))),
             programNode.getName(),
             "run",
             ImmutableList.of());
     }
-}
+}
\ No newline at end of file
diff --git a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonMethodRunner.java b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonMethodRunner.java
index 50f0a0a..1fc0d03 100644
--- a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonMethodRunner.java
+++ b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonMethodRunner.java
@@ -4,8 +4,8 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.List;
-
 import org.zwobble.couscous.ast.ClassNode;
 import org.zwobble.couscous.ast.TypeName;
 import org.zwobble.couscous.backends.python.PythonCodeGenerator;
@@ -14,59 +14,44 @@ import org.zwobble.couscous.backends.python.PythonSerializer;
 import org.zwobble.couscous.tests.MethodRunner;
 import org.zwobble.couscous.values.PrimitiveValue;
 import org.zwobble.couscous.values.PrimitiveValues;
-
 import com.google.common.base.Charsets;
 import com.google.common.base.Joiner;
 import com.google.common.io.CharStreams;
-
 import static java.lang.Integer.parseInt;
 import static org.zwobble.couscous.tests.util.ExtraFiles.deleteRecursively;
 import static org.zwobble.couscous.values.PrimitiveValues.value;
 
-import lombok.SneakyThrows;
-import lombok.val;
-
 public class PythonMethodRunner implements MethodRunner {
     @Override
-    @SneakyThrows
-    public PrimitiveValue runMethod(
-            List<ClassNode> classNodes,
-            TypeName className,
-            String methodName,
-            List<PrimitiveValue> arguments) {
-        val directoryPath = Files.createTempDirectory(null);
-        val compiler = new PythonCompiler(directoryPath, "couscous");
+    public PrimitiveValue runMethod(List<ClassNode> classNodes, TypeName className, String methodName, List<PrimitiveValue> arguments) {
         try {
-            compiler.compile(classNodes);
-            
-            val argumentsString = Joiner.on(", ").join(arguments.stream()
-                .map(PythonCodeGenerator::generateCode)
-                .map(PythonSerializer::serialize)
-                .iterator());
-            
-            val program = "from couscous." + className.getQualifiedName() + " import " + className.getSimpleName() +
-                ";print(repr(" + className.getSimpleName() + "." + methodName + "(" + argumentsString + ")))";
-            
-            val process = new ProcessBuilder("python3.4", "-c", program)
-                .directory(directoryPath.toFile())
-                .start();
-            val exitCode = process.waitFor();
-            val output = readString(process.getInputStream()).trim();
-            val stderrOutput = readString(process.getErrorStream());
-            if (exitCode != 0) {
-                throw new RuntimeException("stderr was: " + stderrOutput);
-            } else {
-                return readPrimitive(output);
+            Path directoryPath = Files.createTempDirectory(null);
+            PythonCompiler compiler = new PythonCompiler(directoryPath, "couscous");
+            try {
+                compiler.compile(classNodes);
+                String argumentsString = Joiner.on(", ").join(arguments.stream().map(PythonCodeGenerator::generateCode).map(PythonSerializer::serialize).iterator());
+                String program = "from couscous." + className.getQualifiedName() + " import " + className.getSimpleName() + ";print(repr(" + className.getSimpleName() + "." + methodName + "(" + argumentsString + ")))";
+                Process process = new ProcessBuilder("python3.4", "-c", program).directory(directoryPath.toFile()).start();
+                int exitCode = process.waitFor();
+                String output = readString(process.getInputStream()).trim();
+                String stderrOutput = readString(process.getErrorStream());
+                if (exitCode != 0) {
+                    throw new RuntimeException("stderr was: " + stderrOutput);
+                } else {
+                    return readPrimitive(output);
+                }
+            } finally {
+                deleteRecursively(directoryPath.toFile());
             }
-        } finally {
-            deleteRecursively(directoryPath.toFile());
+        } catch (final java.lang.Throwable $ex) {
+            throw new RuntimeException($ex);
         }
     }
-
+    
     private PrimitiveValue readPrimitive(String output) {
         if (output.equals("None")) {
             return PrimitiveValues.UNIT;
-        } else if (output.startsWith("'")) {
+        } else if (output.startsWith("\'")) {
             return value(output.substring(1, output.length() - 1));
         } else if (output.equals("True")) {
             return value(true);
@@ -76,8 +61,8 @@ public class PythonMethodRunner implements MethodRunner {
             return value(parseInt(output));
         }
     }
-
+    
     private String readString(final InputStream stream) throws IOException {
         return CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8));
     }
-}
+}
\ No newline at end of file
diff --git a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonSerializerTests.java b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonSerializerTests.java
index 46e0aa1..24b2e9a 100644
--- a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonSerializerTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonSerializerTests.java
@@ -3,6 +3,7 @@ package org.zwobble.couscous.tests.backends.python;
 import org.junit.Test;
 import org.zwobble.couscous.backends.python.ast.PythonClassNode;
 import org.zwobble.couscous.backends.python.ast.PythonFunctionDefinitionNode;
+import org.zwobble.couscous.backends.python.ast.PythonModuleNode;
 
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
@@ -22,19 +23,17 @@ import static org.zwobble.couscous.backends.python.ast.PythonReturnNode.pythonRe
 import static org.zwobble.couscous.backends.python.ast.PythonStringLiteralNode.pythonStringLiteral;
 import static org.zwobble.couscous.backends.python.ast.PythonVariableReferenceNode.pythonVariableReference;
 
-import lombok.val;
-
 public class PythonSerializerTests {
     @Test
     public void integersAreNotBoxed() {
-        val output = serialize(pythonIntegerLiteral(42));
+        String output = serialize(pythonIntegerLiteral(42));
         assertEquals("42", output);
     }
     
     @Test
     public void stringsAreNotBoxed() {
         // TODO: escaping
-        val output = serialize(pythonStringLiteral("blah"));
+        String output = serialize(pythonStringLiteral("blah"));
         assertEquals("\"blah\"", output);
     }
     
@@ -51,104 +50,82 @@ public class PythonSerializerTests {
     
     @Test
     public void conditionalExpressionIsSerializedUsingParenthesisedSubExpression() {
-        assertEquals("(1) if (True) else (2)", serialize(
-            pythonConditionalExpression(
-                pythonBooleanLiteral(true),
-                pythonIntegerLiteral(1),
-                pythonIntegerLiteral(2))));
+        assertEquals("(1) if (True) else (2)", serialize(pythonConditionalExpression(pythonBooleanLiteral(true), pythonIntegerLiteral(1), pythonIntegerLiteral(2))));
     }
     
     @Test
     public void attributeAccessIsSerializedUsingParenthesisedSubExpression() {
-        assertEquals("(x).y", serialize(
-            pythonAttributeAccess(
-                pythonVariableReference("x"),
-                "y")));
+        assertEquals("(x).y", serialize(pythonAttributeAccess(pythonVariableReference("x"), "y")));
     }
     
     @Test
     public void callIsSerializedUsingParenthesisedSubExpression() {
-        assertEquals("(f)(x, y)", serialize(
-            pythonCall(
-                pythonVariableReference("f"),
-                asList(
-                    pythonVariableReference("x"),
-                    pythonVariableReference("y")))));
+        assertEquals("(f)(x, y)", serialize(pythonCall(pythonVariableReference("f"), asList(pythonVariableReference("x"), pythonVariableReference("y")))));
     }
     
     @Test
     public void getSliceIsSerializedUsingParenthesisedSubExpression() {
-        assertEquals("(x)[y:z]", serialize(
-            pythonGetSlice(
-                pythonVariableReference("x"),
-                asList(
-                    pythonVariableReference("y"),
-                    pythonVariableReference("z")))));
+        assertEquals("(x)[y:z]", serialize(pythonGetSlice(pythonVariableReference("x"), asList(pythonVariableReference("y"), pythonVariableReference("z")))));
     }
     
     @Test
     public void returnKeywordIsUsedForReturns() {
-        val output = serialize(pythonReturn(pythonIntegerLiteral(42)));
+        String output = serialize(pythonReturn(pythonIntegerLiteral(42)));
         assertEquals("return 42\n", output);
     }
     
     @Test
     public void passStatementIsSerializedAsPassKeyword() {
-        val output = serialize(PASS);
+        final java.lang.Object output = serialize(PASS);
         assertEquals("pass\n", output);
     }
     
     @Test
     public void emptyFunctionHasPassStatement() {
-        val function = PythonFunctionDefinitionNode.builder("empty").build();
-        val output = serialize(function);
+        PythonFunctionDefinitionNode function = PythonFunctionDefinitionNode.builder("empty").build();
+        String output = serialize(function);
         assertEquals("def empty():\n    pass\n", output);
     }
     
     @Test
     public void functionArgumentsAreSerializedWithName() {
-        val function = PythonFunctionDefinitionNode.builder("empty")
+        PythonFunctionDefinitionNode function = PythonFunctionDefinitionNode.builder("empty")
             .argument("one")
             .argument("two")
             .build();
-        val output = serialize(function);
+        String output = serialize(function);
         assertEquals("def empty(one, two):\n    pass\n", output);
     }
     
     @Test
     public void emptyClassHasPassStatement() {
-        val classNode = PythonClassNode.builder("Empty")
-            .build();
-        val output = serialize(classNode);
+        PythonClassNode classNode = PythonClassNode.builder("Empty").build();
+        String output = serialize(classNode);
         assertEquals("class Empty(object):\n    pass\n", output);
     }
     
     @Test
     public void bodiesOfBlocksAreIndented() {
-        val classNode = PythonClassNode.builder("Foo")
+        PythonClassNode classNode = PythonClassNode.builder("Foo")
             .statement(PythonFunctionDefinitionNode.builder("one").build())
             .statement(PythonFunctionDefinitionNode.builder("two").build())
             .build();
-        val output = serialize(classNode);
-        val expectedOutput =
-            "class Foo(object):\n" +
-            "    def one():\n" +
-            "        pass\n" +
-            "    def two():\n" +
-            "        pass\n";
+        String output = serialize(classNode);
+        String expectedOutput = "class Foo(object):\n    def one():\n        pass\n    def two():\n        pass\n";
         assertEquals(expectedOutput, output);
     }
     
     @Test
     public void assignmentIsSerializedWithEqualsSymbolSeparatingTargetAndValue() {
-        val output = serialize(pythonAssignment(
-            pythonVariableReference("x"), pythonIntegerLiteral(42)));
+        String output = serialize(pythonAssignment(
+            pythonVariableReference("x"),
+            pythonIntegerLiteral(42)));
         assertEquals("x = 42\n", output);
     }
     
     @Test
     public void importIsSerializedUsingImportKeyword() {
-        val output = serialize(pythonImport(
+        String output = serialize(pythonImport(
             "com.example",
             asList(pythonImportAlias("Program"))));
         assertEquals("from com.example import Program\n", output);
@@ -156,16 +133,16 @@ public class PythonSerializerTests {
     
     @Test
     public void importAliasesAreSeparatedByCommas() {
-        val output = serialize(pythonImport(
+        String output = serialize(pythonImport(
             "com.example",
-            asList(pythonImportAlias("Program"), pythonImportAlias("Runner"))));
+            asList(pythonImportAlias("Program"),pythonImportAlias("Runner"))));
         assertEquals("from com.example import Program, Runner\n", output);
     }
     
     @Test
     public void moduleIsSerializedStatements() {
-        val classNode = pythonModule(asList(PASS));
-        val output = serialize(classNode);
+        PythonModuleNode classNode = pythonModule(asList(PASS));
+        String output = serialize(classNode);
         assertEquals("pass\n", output);
     }
-}
+}
\ No newline at end of file
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 8c9ee95..d01830f 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
@@ -1,12 +1,16 @@
 package org.zwobble.couscous.tests.frontends.java;
 
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.List;
 
 import org.junit.Test;
 import org.zwobble.couscous.ast.ClassNode;
+import org.zwobble.couscous.ast.ConstructorNode;
 import org.zwobble.couscous.ast.ExpressionNode;
+import org.zwobble.couscous.ast.FormalArgumentNode;
 import org.zwobble.couscous.ast.LocalVariableDeclarationNode;
+import org.zwobble.couscous.ast.MethodNode;
 import org.zwobble.couscous.ast.ReturnNode;
 import org.zwobble.couscous.ast.StatementNode;
 import org.zwobble.couscous.ast.ThisReferenceNode;
@@ -33,9 +37,6 @@ import static org.zwobble.couscous.ast.ThisReferenceNode.thisReference;
 import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
 import static org.zwobble.couscous.tests.util.ExtraFiles.deleteRecursively;
 
-import lombok.SneakyThrows;
-import lombok.val;
-
 public class JavaReaderTests {
     @Test
     public void canReadLiterals() {
@@ -54,7 +55,7 @@ public class JavaReaderTests {
     
     @Test
     public void canReadFieldDeclarations() {
-        val classNode = readClass(
+        ClassNode classNode = readClass(
             "private String name;");
         
         assertEquals(
@@ -73,13 +74,13 @@ public class JavaReaderTests {
     }
     
     private void canReadFieldReference(String expression) {
-        val classNode = readClass(
+        ClassNode classNode = readClass(
             "private String name;" +
             "public String getName() {" +
             "    return " + expression + ";" +
             "}");
         
-        val returnNode = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
+        ReturnNode returnNode = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
         assertEquals(
             fieldAccess(
                 thisReference(TypeName.of("com.example.Example")),
@@ -97,11 +98,11 @@ public class JavaReaderTests {
     
     @Test
     public void canReadImplicitInstanceMethodCalls() {
-        val classNode = readClass(
+        ClassNode classNode = readClass(
             "public String loop() {" +
             "    return loop();" +
             "}");
-        val returnNode = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
+        ReturnNode returnNode = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
         
         assertEquals(
             methodCall(
@@ -121,11 +122,11 @@ public class JavaReaderTests {
     
     @Test
     public void canReadImplicitStaticMethodCalls() {
-        val classNode = readClass(
+        ClassNode classNode = readClass(
             "public static String loop() {" +
             "    return loop();" +
             "}");
-        val returnNode = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
+        ReturnNode returnNode = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
         
         assertEquals(
             staticMethodCall(
@@ -151,13 +152,13 @@ public class JavaReaderTests {
     
     @Test
     public void canReadAssignments() {
-        val classNode = readClass(
+        ClassNode classNode = readClass(
             "private String name;" +
             "public String getName() {" +
             "    return name = \"blah\";" +
             "}");
         
-        val returnNode = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
+        ReturnNode returnNode = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
         assertEquals(
             assign(
                 fieldAccess(
@@ -170,13 +171,13 @@ public class JavaReaderTests {
     
     @Test
     public void canDeclareAndReferenceLocalVariables() {
-        val statements = readStatements("int x = 4; return x;");
+        List<StatementNode> statements = readStatements("int x = 4; return x;");
         
-        val declaration = (LocalVariableDeclarationNode) statements.get(0);
+        LocalVariableDeclarationNode declaration = (LocalVariableDeclarationNode) statements.get(0);
         assertEquals("x", declaration.getName());
         assertEquals(IntegerValue.REF, declaration.getType());
         assertEquals(literal(4), declaration.getInitialValue());
-        val returnNode = (ReturnNode) statements.get(1);
+        ReturnNode returnNode = (ReturnNode) statements.get(1);
         assertEquals(
             reference(declaration),
             returnNode.getValue());
@@ -184,18 +185,18 @@ public class JavaReaderTests {
     
     @Test
     public void canDeclareAndReferenceArguments() {
-        val classNode = readClass(
+        ClassNode classNode = readClass(
             "public String identity(int value) {" +
             "    return value;" +
             "}");
         
-        val method = classNode.getMethods().get(0);
-        val argument = method.getArguments().get(0);
+        MethodNode method = classNode.getMethods().get(0);
+        FormalArgumentNode argument = method.getArguments().get(0);
         assertEquals("value", argument.getName());
         assertEquals(TypeName.of("int"), argument.getType());
         assertEquals(1, method.getArguments().size());
         
-        val returnNode = (ReturnNode)method.getBody().get(0);
+        ReturnNode returnNode = (ReturnNode)method.getBody().get(0);
         assertEquals(reference(argument), returnNode.getValue());
     }
     
@@ -212,13 +213,13 @@ public class JavaReaderTests {
     
     @Test
     public void canDeclareConstructor() {
-        val classNode = readClass(
+        ClassNode classNode = readClass(
             "private final String name;" +
             "public Example() {" +
             "    this.name = \"Flaws\";" +
             "}");
         
-        val constructor = classNode.getConstructor();
+        ConstructorNode constructor = classNode.getConstructor();
         
         assertEquals(asList(), constructor.getArguments());
         
@@ -234,28 +235,28 @@ public class JavaReaderTests {
     
     @Test
     public void canDeclareStaticMethodWithAnnotation() {
-        val classNode = readClass(
+        ClassNode classNode = readClass(
             "@Deprecated public void doNothing() {}");
         
-        val method = classNode.getMethods().get(0);
+        MethodNode method = classNode.getMethods().get(0);
         assertEquals(
             asList(annotation(TypeName.of("java.lang.Deprecated"))),
             method.getAnnotations());
     }
 
     private ExpressionNode readExpressionInInstanceMethod(String expressionSource) {
-        val javaClass =
+        String javaClass =
             "public Object main() {" +
             "    return " + expressionSource + ";" +
             "}";
         
-        val classNode = readClass(javaClass);
-        val returnStatement = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
+        ClassNode classNode = readClass(javaClass);
+        ReturnNode returnStatement = (ReturnNode) classNode.getMethods().get(0).getBody().get(0);
         return returnStatement.getValue();
     }
 
     private ExpressionNode readExpression(String expressionSource) {
-        val returnStatement = (ReturnNode) readStatement("return " + expressionSource + ";");
+        ReturnNode returnStatement = (ReturnNode) readStatement("return " + expressionSource + ";");
         return returnStatement.getValue();
     }
 
@@ -264,33 +265,36 @@ public class JavaReaderTests {
     }
 
     private List<StatementNode> readStatements(String statementsSource) {
-        val javaClass =
+        String javaClass =
             "public static Object main() {" +
             statementsSource +
             "}";
         
-        val classNode = readClass(javaClass);
+        ClassNode classNode = readClass(javaClass);
         return classNode.getMethods().get(0).getBody();
     }
 
-    @SneakyThrows
     private ClassNode readClass(String classBody) {
-        val javaClass =
+        String javaClass =
             "package com.example;" +
             "public class Example {" +
             classBody +
             "}";
-        
-        val directoryPath = Files.createTempDirectory(null);
-        val sourcePath = directoryPath.resolve("com/example/Example.java");
         try {
-            Files.createDirectories(directoryPath.resolve("com/example"));
-            Files.write(sourcePath, asList(javaClass));
-            
-            val reader = new JavaReader();
-            return reader.readClassFromFile(directoryPath, sourcePath);
-        } finally {
-            deleteRecursively(directoryPath.toFile());
+
+            Path directoryPath = Files.createTempDirectory(null);
+            Path sourcePath = directoryPath.resolve("com/example/Example.java");
+            try {
+                Files.createDirectories(directoryPath.resolve("com/example"));
+                Files.write(sourcePath, asList(javaClass));
+                
+                JavaReader reader = new JavaReader();
+                return reader.readClassFromFile(directoryPath, sourcePath);
+            } finally {
+                deleteRecursively(directoryPath.toFile());
+            }
+        } catch (Exception exception) {
+            throw new RuntimeException(exception);
         }
     }
 }
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());
                 
diff --git a/src/test/java/org/zwobble/couscous/tests/util/ExtraAsserts.java b/src/test/java/org/zwobble/couscous/tests/util/ExtraAsserts.java
index c5f1668..e620d7f 100644
--- a/src/test/java/org/zwobble/couscous/tests/util/ExtraAsserts.java
+++ b/src/test/java/org/zwobble/couscous/tests/util/ExtraAsserts.java
@@ -3,15 +3,12 @@ package org.zwobble.couscous.tests.util;
 import org.zwobble.couscous.util.Action;
 import org.zwobble.couscous.util.Casts;
 
-import lombok.SneakyThrows;
-
 public class ExtraAsserts {
-    @SneakyThrows
-    public static <T extends Throwable> T assertThrows(Class<T> exceptionType, Action action) {
+    public static <T extends Throwable> T assertThrows(Class<T> exceptionType, Action action) throws T {
         try {
             action.run();
             throw new AssertionError("Expected exception");
-        } catch (Exception exception) {
+        } catch (RuntimeException exception) {
             return Casts.tryCast(exceptionType, exception)
                 .orElseThrow(() -> exception);
         }
diff --git a/src/test/java/org/zwobble/couscous/tests/util/ExtraFiles.java b/src/test/java/org/zwobble/couscous/tests/util/ExtraFiles.java
index 032e22c..339a084 100644
--- a/src/test/java/org/zwobble/couscous/tests/util/ExtraFiles.java
+++ b/src/test/java/org/zwobble/couscous/tests/util/ExtraFiles.java
@@ -2,15 +2,13 @@ package org.zwobble.couscous.tests.util;
 
 import java.io.File;
 
-import lombok.val;
-
 public class ExtraFiles {
     public static void deleteRecursively(File file) {
         if (file.isDirectory()) {
-            for (val child : file.listFiles()) {
+            for (File child : file.listFiles()) {
                 deleteRecursively(child);
             }
         }
         file.delete();
     }
-}
+}
\ No newline at end of file