ValueChainBuilder -> InstanceValue

src/dev/peerat/parser/java/tree/ValueTree.java

@@ -2,7 +2,10 @@ package dev.peerat.parser.java.tree;
 
 import java.lang.reflect.Field;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -15,6 +18,7 @@ import dev.peerat.parser.java.value.ArrayAccessValue;
 import dev.peerat.parser.java.value.ArrayValue;
 import dev.peerat.parser.java.value.BiValue;
 import dev.peerat.parser.java.value.CastValue;
+import dev.peerat.parser.java.value.InstanceValue;
 import dev.peerat.parser.java.value.LambdaValue;
 import dev.peerat.parser.java.value.LambdaValue.LambdaParameter;
 import dev.peerat.parser.java.value.MethodCallValue;
@@ -52,20 +56,31 @@ public class ValueTree extends SyntaxTree<JavaElement> { //TODO order tree by mo
 		StateTree<JavaElement> redirectRight = new RedirectStateTree<>(this.current, (global, local) -> {
 			global.<ValueChainBuilder>get().right(local.get());
 		});
-
+		
-		StateTree<JavaElement> value_instance = unary_value.then((validator) -> {
+		StateTree<JavaElement> value_instance = unary_value.equals("new");
-			validator.getBag().set(new ValueChainBuilder());
+		StateTree<JavaElement> value_instance_type = value_instance.redirect(type, (global, local) -> global.set("type", local.get()));
-			return true;
-		}).equals("new");
-		StateTree<JavaElement> value_instance_type = value_instance.redirect(type);
 		StateTree<JavaElement> value_instance_params = value_instance_type.equals("(");
-		StateTree<JavaElement> value_instance_params_end = value_instance_params.equals(")");
+		StateTree<JavaElement> value_instance_params_end = value_instance_params.equals(")", (bag, token) -> {
-		StateTree<JavaElement> value_instance_param = value_instance_params.redirect(this.current);
+			ValueChainBuilder builder = new ValueChainBuilder();
+			List<Value> parameters = bag.get("params");
+			builder.rebase(new InstanceValue(bag.get("type"), parameters == null ? new ArrayList<>() : parameters));
+			bag.remove("type");
+			bag.remove("params");
+			bag.set(builder);
+		});
+		StateTree<JavaElement> value_instance_param = value_instance_params.redirect(this.current, (global, local) -> {
+			List<Value> list = global.get("params");
+			if(list == null){
+				list = new ArrayList<>();
+				global.set("params", list);
+			}
+			list.add(local.get());
+		});
 		value_instance_param.then(value_instance_params_end);
 		value_instance_param.equals(",").then(value_instance_param);
-		value_instance_params_end.<JavaElement>end();
+		value_instance_params_end.<JavaElement>end(ValueChainBuilder.build(false));
 		value_instance_params_end.equals("{")
-		.<JavaElement>end().multiple(class_container)
+		.<JavaElement>end(ValueChainBuilder.build(true)).multiple(class_container)
 		.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
 		
 		StateTree<JavaElement> value_instance_array = value_instance_type.equals("[");

src/dev/peerat/parser/java/value/InstanceValue.java

@@ -1,27 +1,31 @@
 package dev.peerat.parser.java.value;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
 
 import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.Function.FunctionContainer;
+import dev.peerat.parser.java.Annotation;
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.Variable.VariableContainer;
 import dev.peerat.parser.java.visitor.JavaVisitor;
 import dev.peerat.parser.visitor.VisitorBag;
 
-public class InstanceValue extends Value{
+public class InstanceValue extends Value implements VariableContainer, FunctionContainer, AnnotableBuffer{ //TODO LIKE A CLASS, CAN CONTAINS CLASS
 	
-	private Token newer;
 	private Token token;
 	private List<Value> parameters;
 	
-	public InstanceValue(Token newer, Token token, List<Value> parameters){
+	private List<JavaElement> elements;
-		this.newer = newer;
+	private List<Annotation> annotationBuffer;
+	
+	public InstanceValue(Token token, List<Value> parameters){
 		this.token = token;
 		this.parameters = parameters;
-	}
+		this.elements = new ArrayList<>();
-	
-	public Token getNewer(){
-		return this.newer;
 	}
 	
 	public Token getToken(){
@@ -31,6 +35,32 @@ public class InstanceValue extends Value{
 	public List<Value> getParameters(){
 		return this.parameters;
 	}
+	
+	public List<JavaElement> getElements(){
+		return this.elements;
+	}
+	
+	@Override
+	public void addFunction(dev.peerat.parser.java.Function function){
+		this.elements.add(function);
+	}
+
+	@Override
+	public void addVariable(Variable variable){
+		this.elements.add(variable);
+	}
+	
+	@Override
+	public void addAnnotationBuffer(Annotation annotation){
+		if(annotationBuffer == null) annotationBuffer = new ArrayList<>();
+		annotationBuffer.add(annotation);
+	}
+	
+	public List<Annotation> getAnnotationBuffer(){
+		List<Annotation> list = this.annotationBuffer;
+		this.annotationBuffer = null;
+		return list;
+	}
 
 	@Override
 	public void build(Builder builder) throws Exception {

test/dev/peerat/parser/java/ValueTypesTests.java

@@ -17,6 +17,7 @@ import dev.peerat.parser.java.value.ArrayAccessValue;
 import dev.peerat.parser.java.value.ArrayValue;
 import dev.peerat.parser.java.value.BiValue;
 import dev.peerat.parser.java.value.CastValue;
+import dev.peerat.parser.java.value.InstanceValue;
 import dev.peerat.parser.java.value.LambdaValue;
 import dev.peerat.parser.java.value.MethodCallValue;
 import dev.peerat.parser.java.value.ModifierValue;
@@ -346,4 +347,25 @@ public class ValueTypesTests {
 		assertEquals("b", v.getType().getValue());
 		assertEquals("a", assertInstance(v.getValue(), StaticValue.class).getToken().getValue());
 	}
+	
+	@Test
+	public void onInstanceValue() throws Exception{
+		InstanceValue v;
+		v = assertInstance(parse("new String()"), InstanceValue.class);
+		assertEquals("String", v.getToken().getValue());
+		assertEquals(0, v.getParameters().size()+v.getElements().size());
+		
+		v = assertInstance(parse("new String(a)"), InstanceValue.class);
+		assertEquals("String", v.getToken().getValue());
+		assertEquals(1, v.getParameters().size());
+		assertEquals("a", assertInstance(v.getParameters().get(0), StaticValue.class).getToken().getValue());
+		assertEquals(0, v.getElements().size());
+		
+		v = assertInstance(parse("new MyClass(){ @Test public void test(){} }"), InstanceValue.class);
+		assertEquals("MyClass", v.getToken().getValue());
+		assertEquals(0, v.getParameters().size());
+		assertEquals(1, v.getElements().size());
+		dev.peerat.parser.java.Function func = assertInstance(v.getElements().get(0), dev.peerat.parser.java.Function.class);
+		assertEquals(1, func.getAnnotations().size());
+	}
 }