diff options
Diffstat (limited to 'src')
4 files changed, 170 insertions, 17 deletions
diff --git a/src/main/java/org/zwobble/couscous/ast/ClassNodeBuilder.java b/src/main/java/org/zwobble/couscous/ast/ClassNodeBuilder.java index b4e3891..a2302e4 100644 --- a/src/main/java/org/zwobble/couscous/ast/ClassNodeBuilder.java +++ b/src/main/java/org/zwobble/couscous/ast/ClassNodeBuilder.java @@ -57,9 +57,8 @@ public class ClassNodeBuilder { } private MethodBuilder<MethodNode> methodBuilder(String name, boolean isStatic) { - return new MethodBuilder<MethodNode>(builder -> MethodNode.builder() + return new MethodBuilder<MethodNode>(builder -> MethodNode.builder(name) .isStatic(isStatic) - .name(name) .annotations(builder.annotations.build()) .arguments(builder.arguments.build()) .body(builder.statements.build()) diff --git a/src/main/java/org/zwobble/couscous/ast/MethodNode.java b/src/main/java/org/zwobble/couscous/ast/MethodNode.java index 644b57b..d37f7d7 100644 --- a/src/main/java/org/zwobble/couscous/ast/MethodNode.java +++ b/src/main/java/org/zwobble/couscous/ast/MethodNode.java @@ -4,27 +4,173 @@ import java.util.List; import org.zwobble.couscous.ast.visitors.NodeVisitor; -import lombok.Builder; -import lombok.Singular; -import lombok.Value; +import com.google.common.collect.ImmutableList; -@Builder -@Value public class MethodNode implements CallableNode { - public static MethodNodeBuilder staticMethod(String name) { - return builder().isStatic(true).name(name); + public static Builder staticMethod(String name) { + return builder(name).isStatic(true); + } + public static Builder builder(String name) { + return new Builder(name); + } + + public static class Builder { + private final ImmutableList.Builder<AnnotationNode> annotations = + ImmutableList.builder(); + private boolean isStatic = false; + private final String name; + private final ImmutableList.Builder<FormalArgumentNode> arguments = + ImmutableList.builder(); + private final ImmutableList.Builder<StatementNode> body = + ImmutableList.builder(); + + public Builder(String name) { + this.name = name; + } + + public Builder annotations(List<AnnotationNode> annotations) { + this.annotations.addAll(annotations); + return this; + } + + public Builder isStatic(boolean isStatic) { + this.isStatic = isStatic; + return this; + } + + public Builder argument(FormalArgumentNode argument) { + arguments.add(argument); + return this; + } + + public Builder arguments(List<FormalArgumentNode> arguments) { + this.arguments.addAll(arguments); + return this; + } + + public Builder statement(StatementNode statement) { + this.body.add(statement); + return this; + } + + public Builder body(List<StatementNode> statements) { + this.body.addAll(statements); + return this; + } + + public MethodNode build() { + return new MethodNode( + annotations.build(), + isStatic, + name, + arguments.build(), + body.build()); + } + } + + public static MethodNode method( + List<AnnotationNode> annotations, + boolean isStatic, + String name, + List<FormalArgumentNode> arguments, + List<StatementNode> body) { + return new MethodNode(annotations, isStatic, name, arguments, body); + } + + private final List<AnnotationNode> annotations; + private final boolean isStatic; + private final String name; + private final List<FormalArgumentNode> arguments; + private final List<StatementNode> body; + + private MethodNode( + List<AnnotationNode> annotations, + boolean isStatic, + String name, + List<FormalArgumentNode> arguments, + List<StatementNode> body) { + this.annotations = annotations; + this.isStatic = isStatic; + this.name = name; + this.arguments = arguments; + this.body = body; + } + + public List<AnnotationNode> getAnnotations() { + return annotations; + } + + public boolean isStatic() { + return isStatic; } - List<AnnotationNode> annotations; - boolean isStatic; - String name; - @Singular - List<FormalArgumentNode> arguments; - @Singular("statement") - List<StatementNode> body; + public String getName() { + return name; + } + + public List<FormalArgumentNode> getArguments() { + return arguments; + } + + public List<StatementNode> getBody() { + return body; + } @Override public void accept(NodeVisitor visitor) { visitor.visit(this); } + + @Override + public String toString() { + return "MethodNode(annotations=" + annotations + ", isStatic=" + + isStatic + ", name=" + name + ", arguments=" + arguments + + ", body=" + body + ")"; + } + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + + ((annotations == null) ? 0 : annotations.hashCode()); + result = prime * result + + ((arguments == null) ? 0 : arguments.hashCode()); + result = prime * result + ((body == null) ? 0 : body.hashCode()); + result = prime * result + (isStatic ? 1231 : 1237); + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + MethodNode other = (MethodNode) obj; + if (annotations == null) { + if (other.annotations != null) + return false; + } else if (!annotations.equals(other.annotations)) + return false; + if (arguments == null) { + if (other.arguments != null) + return false; + } else if (!arguments.equals(other.arguments)) + return false; + if (body == null) { + if (other.body != null) + return false; + } else if (!body.equals(other.body)) + return false; + if (isStatic != other.isStatic) + return false; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + return true; + } } diff --git a/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java b/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java index c7549d9..0f463ca 100644 --- a/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java +++ b/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java @@ -89,7 +89,7 @@ public abstract class BackendMethodTests { assertEquals(value("[updated value]"), result); } - protected PrimitiveValue runMethod(MethodNode.MethodNodeBuilder methodBuilder, PrimitiveValue... arguments) { + protected PrimitiveValue runMethod(MethodNode.Builder methodBuilder, PrimitiveValue... arguments) { val method = methodBuilder.build(); val className = "com.example.Program"; val classNode = ClassNode.builder(className) diff --git a/src/test/java/org/zwobble/couscous/tests/ValueObjectTests.java b/src/test/java/org/zwobble/couscous/tests/ValueObjectTests.java index fd63ce0..e112a86 100644 --- a/src/test/java/org/zwobble/couscous/tests/ValueObjectTests.java +++ b/src/test/java/org/zwobble/couscous/tests/ValueObjectTests.java @@ -26,6 +26,7 @@ import org.zwobble.couscous.ast.FormalArgumentNode; import org.zwobble.couscous.ast.LiteralNode; import org.zwobble.couscous.ast.LocalVariableDeclarationNode; import org.zwobble.couscous.ast.MethodCallNode; +import org.zwobble.couscous.ast.MethodNode; import org.zwobble.couscous.ast.ReturnNode; import org.zwobble.couscous.ast.StaticMethodCallNode; import org.zwobble.couscous.ast.TernaryConditionalNode; @@ -67,6 +68,7 @@ public class ValueObjectTests { {LiteralNode.class}, {LocalVariableDeclarationNode.class}, {MethodCallNode.class}, + {MethodNode.class}, {ReturnNode.class}, {StaticMethodCallNode.class}, {TernaryConditionalNode.class}, @@ -139,6 +141,8 @@ public class ValueObjectTests { private static Object generateFirstInstance(Class<?> type) { if (type.equals(String.class)) { return "[string 1]"; + } else if (type.equals(boolean.class)) { + return true; } else if (type.equals(List.class)) { return asList("[list 1]"); } else if (type.equals(PrimitiveValue.class)) { @@ -155,6 +159,8 @@ public class ValueObjectTests { private static Object generateSecondInstance(Class<?> type) { if (type.equals(String.class)) { return "[string 2]"; + } else if (type.equals(boolean.class)) { + return false; } else if (type.equals(List.class)) { return asList("[list 2]"); } else if (type.equals(PrimitiveValue.class)) { @@ -171,6 +177,8 @@ public class ValueObjectTests { private static Object generateInstance(Class<?> type) { if (type.equals(String.class)) { return "[string]"; + } else if (type.equals(boolean.class)) { + return true; } else if (type.equals(List.class)) { return asList("[list]"); } else if (type.equals(PrimitiveValue.class)) { |