Remove lombok

1 files changed, 32 insertions, 50 deletions

diff --git a/src/main/java/org/zwobble/couscous/interpreter/Executor.java b/src/main/java/org/zwobble/couscous/interpreter/Executor.java
index 5c26244..e47106d 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/Executor.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/Executor.java
@@ -3,7 +3,6 @@ package org.zwobble.couscous.interpreter;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Stream;
-
 import org.zwobble.couscous.ast.CallableNode;
 import org.zwobble.couscous.ast.ExpressionStatementNode;
 import org.zwobble.couscous.ast.LocalVariableDeclarationNode;
@@ -13,72 +12,55 @@ import org.zwobble.couscous.ast.VariableNode;
 import org.zwobble.couscous.ast.visitors.StatementNodeMapper;
 import org.zwobble.couscous.interpreter.values.InterpreterValue;
 import org.zwobble.couscous.interpreter.values.UnitInterpreterValue;
-
 import static org.zwobble.couscous.interpreter.Evaluator.eval;
 
-import lombok.val;
-
 public class Executor implements StatementNodeMapper<Optional<InterpreterValue>> {
-    public static InterpreterValue callMethod(
-            Environment environment,
-            CallableNode method,
-            Optional<InterpreterValue> thisValue,
-            PositionalArguments arguments) {
-        
-        val innerEnvironment = buildEnvironment(environment, method, thisValue, arguments);
-      
-        for (val statement : method.getBody()) {
-            val result = exec(innerEnvironment, statement);
+    
+    public static InterpreterValue callMethod(Environment environment, CallableNode method, Optional<InterpreterValue> thisValue, PositionalArguments arguments) {
+        final org.zwobble.couscous.interpreter.Environment innerEnvironment = buildEnvironment(environment, method, thisValue, arguments);
+        for (final org.zwobble.couscous.ast.StatementNode statement : method.getBody()) {
+            final java.util.Optional<org.zwobble.couscous.interpreter.values.InterpreterValue> result = exec(innerEnvironment, statement);
             if (result.isPresent()) {
                 return result.get();
             }
         }
         return UnitInterpreterValue.UNIT;
     }
-
-    private static Environment buildEnvironment(
-            final Environment environment,
-            final CallableNode method,
-            Optional<InterpreterValue> thisValue,
-            PositionalArguments arguments) {
-        
-        val stackFrame = new StackFrameBuilder();
+    
+    private static Environment buildEnvironment(final Environment environment, final CallableNode method, Optional<InterpreterValue> thisValue, PositionalArguments arguments) {
+        final org.zwobble.couscous.interpreter.StackFrameBuilder stackFrame = new StackFrameBuilder();
         for (int index = 0; index < method.getArguments().size(); index++) {
             stackFrame.declare(method.getArguments().get(index), arguments.get(index));
         }
-        
-        findDeclarations(method.getBody()).forEach(declaration ->
-            stackFrame.declare(declaration));
-        
+        findDeclarations(method.getBody()).forEach(declaration -> stackFrame.declare(declaration));
         return environment.withStackFrame(thisValue, stackFrame.build());
     }
     
     private static Stream<VariableNode> findDeclarations(List<StatementNode> body) {
-        return body.stream()
-            .flatMap(statement -> statement.accept(new StatementNodeMapper<Stream<VariableNode>>() {
-                @Override
-                public Stream<VariableNode> visit(ReturnNode returnNode) {
-                    return Stream.empty();
-                }
-    
-                @Override
-                public Stream<VariableNode> visit(ExpressionStatementNode expressionStatement) {
-                    return Stream.empty();
-                }
-    
-                @Override
-                public Stream<VariableNode> visit(LocalVariableDeclarationNode localVariableDeclaration) {
-                    return Stream.of(localVariableDeclaration);
-                }
-            }));
+        return body.stream().flatMap(statement -> statement.accept(new StatementNodeMapper<Stream<VariableNode>>(){
+            
+            @Override
+            public Stream<VariableNode> visit(ReturnNode returnNode) {
+                return Stream.empty();
+            }
+            
+            @Override
+            public Stream<VariableNode> visit(ExpressionStatementNode expressionStatement) {
+                return Stream.empty();
+            }
+            
+            @Override
+            public Stream<VariableNode> visit(LocalVariableDeclarationNode localVariableDeclaration) {
+                return Stream.of(localVariableDeclaration);
+            }
+        }));
     }
-
+    
     public static Optional<InterpreterValue> exec(Environment environment, StatementNode statement) {
         return statement.accept(new Executor(environment));
     }
-    
     private final Environment environment;
-
+    
     private Executor(Environment environment) {
         this.environment = environment;
     }
@@ -87,17 +69,17 @@ public class Executor implements StatementNodeMapper<Optional<InterpreterValue>>
     public Optional<InterpreterValue> visit(ReturnNode returnNode) {
         return Optional.of(eval(environment, returnNode.getValue()));
     }
-
+    
     @Override
     public Optional<InterpreterValue> visit(ExpressionStatementNode expressionStatement) {
         eval(environment, expressionStatement.getExpression());
         return Optional.empty();
     }
-
+    
     @Override
     public Optional<InterpreterValue> visit(LocalVariableDeclarationNode localVariableDeclaration) {
-        val value = eval(environment, localVariableDeclaration.getInitialValue());
+        final org.zwobble.couscous.interpreter.values.InterpreterValue value = eval(environment, localVariableDeclaration.getInitialValue());
         environment.put(localVariableDeclaration, value);
         return Optional.empty();
     }
-}
+}
\ No newline at end of file