WIP Array initializers pt. II

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaLocalVariableInfo.java

 	public Label end;
 
 	public JavaLocalVariableInfo(Type type, int local, Label start, String name) {
+		this(type, local, start, name, start);
+	}
+
+	public JavaLocalVariableInfo(Type type, int local, Label start, String name, Label end) {
 		this.type = type;
 		this.local = local;
 		this.start = start;
-		this.end = start;
+		this.end = end;
 		this.name = name;
 	}
 }

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/ArrayInitializerHelper.java

 
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
+
+import java.util.ArrayList;
+
+class ArrayInitializerHelper {
+
+	/**
+	 * creates an int[] with the given array size locations and writes the code that gets them in the generated file.
+	 * Uses an already present origin array (rectangular!)
+	 *
+	 * @param dimension           the array's dim
+	 * @param originArrayType     the type of the original array
+	 * @param originArrayLocation the location of the original array
+	 * @param javaWriter          the writer
+	 * @return the size locations
+	 */
+	static int[] getArraySizeLocationsProjected(int dimension, Type originArrayType, int originArrayLocation, JavaWriter javaWriter) {
+		int[] arraySizes;
+		final ArrayList<Integer> list = new ArrayList<>();
+		javaWriter.loadObject(originArrayLocation);
+		Type currentElementType = originArrayType;
+		for (int i = 0; i < dimension; i++) {
+			currentElementType = Type.getType(currentElementType.getDescriptor().substring(1));
+			final int location = javaWriter.local(int.class);
+			javaWriter.dup();
+			javaWriter.arrayLength();
+			javaWriter.storeInt(location);
+			list.add(location);
+
+			if (i < dimension - 1) {
+				javaWriter.iConst0();
+				javaWriter.arrayLoad(currentElementType);
+			}
+		}
+		javaWriter.pop();
+		arraySizes = new int[list.size()];
+		for (int i = 0; i < list.size(); i++) {
+			arraySizes[i] = list.get(i);
+		}
+		return arraySizes;
+	}
+
+	/**
+	 * Creates an int[] with the given array size locations and writes the code that gets them in the generated file
+	 * Uses the constructor arguments (sizes are expressions 0 .. dimension-1)
+	 *
+	 * @param dimension the array's dim
+	 * @param arguments the arguments form the constructor
+	 * @param visitor   the visitor visiting them
+	 * @return the size locations
+	 */
+	static int[] getArraySizeLocationsFromConstructor(int dimension, Expression[] arguments, JavaExpressionVisitor visitor) {
+		final ArrayList<Integer> list = new ArrayList<>();
+		for (int i = 0; i < dimension; i++) {
+			final int location = visitor.javaWriter.local(int.class);
+			arguments[i].accept(visitor);
+			visitor.javaWriter.storeInt(location);
+			list.add(location);
+		}
+		int[] arraySizes = new int[list.size()];
+		for (int i = 0; i < list.size(); i++) {
+			arraySizes[i] = list.get(i);
+		}
+		return arraySizes;
+	}
 
-public class ArrayInitializerHelper {
-	public static void visitProjected(JavaWriter javaWriter, int[] sizeLocations, int dim, int originArrayLocation, Type originArrayType, int functionLocation, Type functionType, Type currentArrayType) {
+	/**
+	 * Writes the code for visiting a multidimensional array that is projected from an origin array.
+	 * Accepts a function that will decide what to do with each value from the origin array
+	 * When the function is executed, the value from the origin array will be on top of the stack and when it is finished the value on top should be what will be inserted into the array.
+	 * After the function is completed the stack size must be the same as when it started (effectively replacing the item on top of the stack with the item that should be inserted.
+	 * The function should not modify the other stacks.
+	 *
+	 * @param javaWriter          the writer that will write the actual opcode
+	 * @param sizeLocations       the locations of the array dimension sizes sizeLocations.length == dim !!
+	 * @param dim                 the array's dimensions, reduced during the recursions of the loop to find the innermost loop
+	 * @param originArrayLocation The location of the origin array.
+	 * @param originArrayType     the type of the origin array. The element type needs to be assignable to the new array element type!
+	 * @param currentArrayType    The current type of the array, reduced during the recursions of the functions
+	 * @param innermostFunction   The function that will decide what to add to the array, needs to increase the stack size by one and may not touch the other stacks!
+	 */
+	static void visitProjected(JavaWriter javaWriter, int[] sizeLocations, int dim, int originArrayLocation, Type originArrayType, Type currentArrayType, InnermostFunction innermostFunction) {
 
 		visitMultiDimArray(javaWriter, sizeLocations, dim, currentArrayType, (elementType, counterLocations) -> {
 			//Load origin array
 				javaWriter.arrayLoad(modifiedOriginArrayType = Type.getType(modifiedOriginArrayType.getDescriptor().substring(1)));
 			}
 
-			//Apply function here
-			//javaWriter.loadObject(functionLocation);
-			//javaWriter.swap();
+			innermostFunction.apply(elementType, counterLocations);
+
 
-			//TODO invoke?
-			//javaWriter.invokeVirtual(new JavaMethod(JavaClass.fromInternalName("lambda1", JavaClass.Kind.CLASS), JavaMethod.Kind.INSTANCE, "accept", true, "(Ljava/lang/String;)Ljava/lang/String;", 0, false));
 		});
 	}
 
-
-	public static void visitMultiDimArrayWithDefaultValue(JavaWriter javaWriter, int dim, int defaultLocation, Type currentArrayType, int[] sizeLocations) {
+	/**
+	 * Writes the code for visiting a multidimensional array with a default value.
+	 * The variable at defaultLocation needs to be of or assignable to the resulting array element type.
+	 *
+	 * @param javaWriter       the writer that will write the actual opcode
+	 * @param sizeLocations    the locations of the array dimension sizes sizeLocations.length == dim !!
+	 * @param dim              the array's dimensions, reduced during the recursions of the loop to find the innermost loop
+	 * @param currentArrayType The current type of the array, reduced during the recursions of the functions
+	 * @param defaultLocation  The location of the default value. Needs to be of or assignable to elementType!
+	 */
+	static void visitMultiDimArrayWithDefaultValue(JavaWriter javaWriter, int[] sizeLocations, int dim, Type currentArrayType, int defaultLocation) {
 		visitMultiDimArray(javaWriter, sizeLocations, new int[dim], dim, currentArrayType, (elementType, counterLocations) -> javaWriter.load(elementType, defaultLocation));
 	}
 
-	public static void visitMultiDimArray(JavaWriter javaWriter, int[] sizeLocations, int dim, Type currentArrayType, InnermostFunction innermostFunction){
+	/**
+	 * Writes the code for visiting a multidimensional array.
+	 * Accepts a function that will decide what value to insert into the array slots.
+	 * When the function is finished, one additional item needs to have been added to the stack.
+	 * The already present stacks may not be touched!
+	 *
+	 * @param javaWriter        the writer that will write the actual opcode
+	 * @param sizeLocations     the locations of the array dimension sizes sizeLocations.length == dim !!
+	 * @param dim               the array's dimensions, reduced during the recursions of the loop to find the innermost loop
+	 * @param currentArrayType  The current type of the array, reduced during the recursions of the functions
+	 * @param innermostFunction The function that will decide what to add to the array, needs to increase the stack size by one and may not touch the other stacks!
+	 */
+	private static void visitMultiDimArray(JavaWriter javaWriter, int[] sizeLocations, int dim, Type currentArrayType, InnermostFunction innermostFunction) {
 		visitMultiDimArray(javaWriter, sizeLocations, new int[dim], dim, currentArrayType, innermostFunction);
 	}
 
+	/**
+	 * Checks if an expression can be inlined
+	 *
+	 * @param expression Expression to check for.
+	 * @return can expression be inlined
+	 */
+	static boolean canBeInlined(Expression expression) {
+		while (expression instanceof StorageCastExpression)
+			expression = ((StorageCastExpression) expression).value;
+
+		return expression instanceof FunctionExpression && ((FunctionExpression) expression).body instanceof ReturnStatement;
+	}
 
+	/**
+	 * The function that is actually setting up the loops and naming the counter variables.
+	 * Private because the other static methods provide the new int[] sizeLocations.
+	 * Recursively creates a forLoop per array dimension and in the innermost loop, applies the given function.
+	 * That function needs to add one stack and may not touch the existing stacks.
+	 *
+	 * @param javaWriter        the writer that will write the actual opcode
+	 * @param sizeLocations     the locations of the array dimension sizes sizeLocations.length == dim !!
+	 * @param counterLocations  the locations of the for-Loop counter variables (will be filled by the function itself, counterLocations.length == dim !!
+	 * @param dim               the array's dimensions, reduced during the recursions of the loop to find the innermost loop
+	 * @param currentArrayType  The current type of the array, reduced during the recursions of the functions
+	 * @param innermostFunction The function that will decide what to add to the array, needs to increase the stack size by one and may not touch the other stacks!
+	 */
 	private static void visitMultiDimArray(JavaWriter javaWriter, int[] sizeLocations, int[] counterLocations, int dim, Type currentArrayType, InnermostFunction innermostFunction) {
 		final Label begin = new Label();
 		final Label end = new Label();

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java

 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.type.*;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.StringJoiner;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativeTranslator<Void> {
 	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
 			case ARRAY_CONSTRUCTOR_INITIAL_VALUE: {
 				ArrayTypeID type = (ArrayTypeID) expression.type.type;
 
-				//D1Array = new T[arguments[0]];
-				//value = arguments[last];
-				//Arrays.fill(D1Array, value);
-
-				//D2Array = new T[arguments[1]][];
-				//Arrays.fill(D2Array, D1Array);
-
 				final Type ASMType = context.getType(expression.type);
 				final Type ASMElementType = context.getType(type.elementType);
 
 
 				javaWriter.label(begin);
 				final int defaultValueLocation = javaWriter.local(ASMElementType);
+				javaWriter.addVariableInfo(new JavaLocalVariableInfo(ASMElementType, defaultValueLocation, begin, "defaultValue", end));
+
 
 				if (builtin == BuiltinID.ARRAY_CONSTRUCTOR_SIZED) {
-					//TODO type.elementType.type.accept(JavaDefaultExpressionVisitor.Instance).accept(this);
-					//TODO I still need to write that one, I guess
-					if (CompilerUtils.isPrimitive(type.elementType.type))
-						if (type.elementType.type == BasicTypeID.FLOAT) javaWriter.constant(0f);
-						else if (type.elementType.type == BasicTypeID.DOUBLE) javaWriter.constant(0D);
-						else javaWriter.iConst0();
-					else
-						javaWriter.aConstNull();
+					type.elementType.type.accept(JavaDefaultExpressionTypeVisitor.INSTANCE).accept(this);
 				} else {
 					expression.arguments.arguments[expression.arguments.arguments.length - 1].accept(this);
 				}
 				javaWriter.store(ASMElementType, defaultValueLocation);
 
 
-				final int[] arraySizes;
-				{
-					final ArrayList<Integer> list = new ArrayList<>();
-					for (int i = 0; i < type.dimension; i++) {
-						final int location = javaWriter.local(int.class);
-						expression.arguments.arguments[i].accept(this);
-						javaWriter.storeInt(location);
-						list.add(location);
-					}
-					arraySizes = new int[list.size()];
-					for (int i = 0; i < list.size(); i++) {
-						arraySizes[i] = list.get(i);
-					}
-				}
-
-
-				ArrayInitializerHelper.visitMultiDimArrayWithDefaultValue(javaWriter, type.dimension, defaultValueLocation, ASMType, arraySizes);
-
+				final int[] arraySizes = ArrayInitializerHelper.getArraySizeLocationsFromConstructor(type.dimension, expression.arguments.arguments, this);
+				ArrayInitializerHelper.visitMultiDimArrayWithDefaultValue(javaWriter, arraySizes, type.dimension, ASMType, defaultValueLocation);
 
 				javaWriter.label(end);
-
-				//naming the variables
-				javaWriter.nameVariable(defaultValueLocation, "defaultValue", begin, end, ASMElementType);
 				return;
 			}
 			case ARRAY_CONSTRUCTOR_LAMBDA: {
 				final Type originArrayType = context.getType(expression.arguments.arguments[0].type);
 				final int originArrayLocation = javaWriter.local(originArrayType);
 				javaWriter.storeObject(originArrayLocation);
-
-
-				expression.arguments.arguments[1].accept(this); //Projection Function
-				final Type functionType = context.getType(expression.arguments.arguments[1].type);
-				final int functionLocation = javaWriter.local(functionType);
-				javaWriter.storeObject(functionLocation);
-
 				Type destinationArrayType = context.getType(expression.type);
 
 
-				final int[] arraySizes;
-				{
-					final ArrayList<Integer> list = new ArrayList<>();
-					javaWriter.loadObject(originArrayLocation);
-					Type currentElementType = originArrayType;
-					for (int i = 0; i < type.dimension; i++) {
-						currentElementType = Type.getType(currentElementType.getDescriptor().substring(1));
-						final int location = javaWriter.local(int.class);
-						javaWriter.dup();
-						javaWriter.arrayLength();
-						javaWriter.storeInt(location);
-						list.add(location);
-
-						if (i < type.dimension - 1) {
-							javaWriter.iConst0();
-							javaWriter.arrayLoad(currentElementType);
-						}
-					}
-					javaWriter.pop();
-					arraySizes = new int[list.size()];
-					for (int i = 0; i < list.size(); i++) {
-						arraySizes[i] = list.get(i);
-					}
+				final boolean canBeInlined = ArrayInitializerHelper.canBeInlined(expression.arguments.arguments[1]);
+				final Type functionType;    //Only used if not inline able
+				final int functionLocation; //Only used if not inline able
+				if (!canBeInlined) {
+					expression.arguments.arguments[1].accept(this); //Projection Function
+					functionType = context.getType(expression.arguments.arguments[1].type);
+					functionLocation = javaWriter.local(functionType);
+					javaWriter.storeObject(functionLocation);
+					javaWriter.addVariableInfo(new JavaLocalVariableInfo(functionType, functionLocation, begin, "projectionFunction", end));
 				}
 
+				final int[] arraySizes = ArrayInitializerHelper.getArraySizeLocationsProjected(type.dimension, originArrayType, originArrayLocation, javaWriter);
+				ArrayInitializerHelper.visitProjected(javaWriter, arraySizes, type.dimension, originArrayLocation, originArrayType, destinationArrayType,
+						(elementType, counterLocations) -> {
+							if (canBeInlined) {
+								Label inlineBegin = new Label();
+								Label inlineEnd = new Label();
+								javaWriter.label(inlineBegin);
+								final Type projectedElementType = Type.getType(originArrayType.getDescriptor().substring(type.dimension));
+								final int projectedElementLocal = javaWriter.local(projectedElementType);
+								javaWriter.store(projectedElementType, projectedElementLocal);
+
+
+								JavaExpressionVisitor visitor = new JavaExpressionVisitor(context, module, javaWriter) {
+									@Override
+									public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+										javaWriter.load(projectedElementType, projectedElementLocal);
+										return null;
+									}
+								};
+
+								Expression funcExpression = expression.arguments.arguments[1];
+								while (funcExpression instanceof StorageCastExpression) {
+									funcExpression = ((StorageCastExpression) funcExpression).value;
+								}
+
+								if (funcExpression instanceof FunctionExpression && ((FunctionExpression) funcExpression).body instanceof ReturnStatement) {
+									((ReturnStatement) ((FunctionExpression) funcExpression).body).value.accept(visitor);
+									javaWriter.addVariableInfo(new JavaLocalVariableInfo(projectedElementType, projectedElementLocal, inlineBegin, ((FunctionExpression) funcExpression).header.parameters[0].name, inlineEnd));
+								} else throw new IllegalStateException("Trying to inline a non-inlineable expression");
+
+
+								javaWriter.label(inlineEnd);
+							} else {
+								//Apply function here
+								//javaWriter.loadObject(functionLocation);
+								//javaWriter.swap();
+
+								//TODO invoke?
+								//javaWriter.invokeVirtual(new JavaMethod(JavaClass.fromInternalName("lambda1", JavaClass.Kind.CLASS), JavaMethod.Kind.INSTANCE, "accept", true, "(Ljava/lang/String;)Ljava/lang/String;", 0, false));
+								throw new UnsupportedOperationException("Cannot use projection functions yet!");
+							}
+						});
 
-				ArrayInitializerHelper.visitProjected(javaWriter, arraySizes, type.dimension, originArrayLocation, originArrayType, functionLocation, functionType, destinationArrayType);
 
 				javaWriter.label(end);
-
-				//naming the variables
-				javaWriter.nameVariable(functionLocation, "projectionFunction", begin, end, functionType);
 				return;
 
 			}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaDefaultExpressionTypeVisitor.java

+package org.openzen.zenscript.javashared;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.expression.*;
+import org.openzen.zenscript.codemodel.type.*;
+
+public class JavaDefaultExpressionTypeVisitor implements TypeVisitor<Expression> {
+
+	public static final JavaDefaultExpressionTypeVisitor INSTANCE = new JavaDefaultExpressionTypeVisitor();
+
+	private JavaDefaultExpressionTypeVisitor(){}
+
+	@Override
+	public Expression visitBasic(BasicTypeID basic) {
+
+
+		if (basic == null)
+			throw new IllegalStateException("Null basic type!");
+
+		switch (basic) {
+			case UNDETERMINED:
+			case VOID:
+				throw new IllegalStateException("Void and Undetermined have no default type");
+			case NULL:
+				return new NullExpression(CodePosition.UNKNOWN);
+			case BOOL:
+				return new ConstantBoolExpression(CodePosition.UNKNOWN, false);
+			case BYTE:
+				return new ConstantByteExpression(CodePosition.UNKNOWN, 0);
+			case SBYTE:
+				return new ConstantSByteExpression(CodePosition.UNKNOWN, (byte) 0);
+			case SHORT:
+				return new ConstantShortExpression(CodePosition.UNKNOWN, (short) 0);
+			case USHORT:
+				return new ConstantUShortExpression(CodePosition.UNKNOWN, 0);
+			case INT:
+				return new ConstantIntExpression(CodePosition.UNKNOWN, 0);
+			case UINT:
+				return new ConstantUIntExpression(CodePosition.UNKNOWN, 0);
+			case LONG:
+				return new ConstantLongExpression(CodePosition.UNKNOWN, 0L);
+			case ULONG:
+				return new ConstantULongExpression(CodePosition.UNKNOWN, 0L);
+			case USIZE:
+				return new ConstantUSizeExpression(CodePosition.UNKNOWN, 0L);
+			case FLOAT:
+				return new ConstantFloatExpression(CodePosition.UNKNOWN, 0.0f);
+			case DOUBLE:
+				return new ConstantDoubleExpression(CodePosition.UNKNOWN, 0.0d);
+			case CHAR:
+				return new ConstantCharExpression(CodePosition.UNKNOWN, '\0');
+			default:
+				throw new IllegalStateException("Unknown basic type!");
+		}
+
+
+	}
+
+	@Override
+	public Expression visitString(StringTypeID string) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitArray(ArrayTypeID array) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitAssoc(AssocTypeID assoc) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitGenericMap(GenericMapTypeID map) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitIterator(IteratorTypeID iterator) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitFunction(FunctionTypeID function) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitDefinition(DefinitionTypeID definition) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitGeneric(GenericTypeID generic) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitRange(RangeTypeID range) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitOptional(OptionalTypeID type) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+
+	@Override
+	public Expression visitInvalid(InvalidTypeID type) {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+}

ScriptingExample/scripts/arrays.zs

 //println(a[1]);
 ////
 ////
-//val multiDim = new int[,,](1,2,3, 130);
-//println(multiDim[0,1,2]);
+val multiDim = new int[,,](1,2,3, 130);
+println(multiDim[0,1,2]);
+
+val t = multiDim;
 //
-//val t = multiDim;
-////
-////
-//val b = new int[](3);
-//for i in b {
-//	println(i);
-//}
 //
+val b = new int[](3);
+for i in b {
+	println(i);
+}
+
+
+val c = new int[,,](1,2,3);
+println(c[0,1,2]);
 //
-//val c = new int[,,](1,2,3);
-//println(c[0,1,2]);
-////
-////
-////val d = new string[,,](5,5,5, "HelloWorld");
-////println(d[2,2,2]);
+//
+//val d = new string[,,](5,5,5, "HelloWorld");
+//println(d[2,2,2]);
 //
 //
 ////val e = new int[](a, value => value);
 //val a = new string[](5, "HelloWorld");
 //val b = new string[]<string>(a, projection);
 
-val d = new string[,,](5,5,5, "HelloWorld");
+val d = new string[,,](3,4,5, "HelloWorld");
+
+val someString = "someString";
 
 var projection = (value => "" + value) as function(value as string`borrow) as string;
-val e = new string[,,]<string>(d, projection);
+val e = new string[,,]<string>(
+    d, 
+    (value => "137" + value + someString) as function(value as string`borrow) as string
+);
 
 
-val a = new string[](5, "HelloWorld");
-val b = new string[]<string>(a, projection);
+//val a = new string[](5, "HelloWorld");
+//val b = new string[]<string>(a, projection);
 
-println(e[0,0,0]);
+println(e[2,3,4]);