Expansion Getters/Setters, expansion static fields and Array contains

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

 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+import org.openzen.zenscript.javabytecode.compiler.JavaModificationExpressionVisitor.PushOption;
 import org.openzen.zenscript.javashared.*;
 
 import java.io.FileOutputStream;
 import java.util.Comparator;
 import java.util.Objects;
 import java.util.StringJoiner;
-import org.openzen.zenscript.javabytecode.compiler.JavaModificationExpressionVisitor.PushOption;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativeTranslator<Void> {
 	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
 			case STRING_RANGEGET:
 			case ARRAY_INDEXGETRANGE:
 			case ARRAY_INDEXGET:
+			case ARRAY_CONTAINS:
 				break;
 			case BYTE_INC:
 				modify(expression.target, () -> {
 			case UINT_INC:
 			case USIZE_INC:
 				if (expression.target instanceof GetLocalVariableExpression) {
-					JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)expression.target).variable.variable);
+					JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression) expression.target).variable.variable);
 					javaWriter.iinc(local.local);
 					javaWriter.load(local);
 				} else {
 			case UINT_DEC:
 			case USIZE_DEC:
 				if (expression.target instanceof GetLocalVariableExpression) {
-					JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)expression.target).variable.variable);
+					JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression) expression.target).variable.variable);
 					javaWriter.iinc(local.local, -1);
 					javaWriter.load(local);
 				} else {
 				final Label isFalse = new Label();
 				final Label end = new Label();
 
-				if(builtin == BuiltinID.OPTIONAL_IS_NULL)
+				if (builtin == BuiltinID.OPTIONAL_IS_NULL)
 					javaWriter.ifNonNull(isFalse);
 				else
 					javaWriter.ifNull(isFalse);
 				break;
 			}
 			case ARRAY_CONTAINS:
-				throw new UnsupportedOperationException("Not yet supported!");
+				expression.target.accept(this);
+				final Label loopStart = new Label();
+				final Label loopEnd = new Label();
+				final Label isTrue = new Label();
+				final Label expressionEnd = new Label();
+
+				final int counterLocation = javaWriter.local(int.class);
+				javaWriter.iConst0();
+				javaWriter.storeInt(counterLocation);
+
+				javaWriter.label(loopStart);
+				javaWriter.dup();
+				javaWriter.arrayLength();
+
+				javaWriter.loadInt(counterLocation);
+
+				javaWriter.ifICmpLE(loopEnd);
+				javaWriter.dup();
+				javaWriter.loadInt(counterLocation);
+				final StoredType itemType = expression.arguments.arguments[0].type;
+				javaWriter.arrayLoad(context.getType(itemType));
+				javaWriter.iinc(counterLocation);
+				expression.arguments.arguments[0].accept(this);
+
+
+				if (CompilerUtils.isPrimitive(itemType.type)) {
+					//Compare non-int types beforehand
+					if (itemType.type == BasicTypeID.LONG || itemType.type == BasicTypeID.ULONG) {
+						javaWriter.lCmp();
+						javaWriter.ifNE(loopStart);
+					} else if (itemType.type == BasicTypeID.FLOAT) {
+						javaWriter.fCmp();
+						javaWriter.ifNE(loopStart);
+					} else if (itemType.type == BasicTypeID.DOUBLE) {
+						javaWriter.dCmp();
+						javaWriter.ifNE(loopStart);
+					} else
+						javaWriter.ifICmpNE(loopStart);
+				} else {
+					//If equals, use Object.equals in case of null
+					javaWriter.invokeStatic(new JavaMethod(JavaClass.fromInternalName("java/util/Objects", JavaClass.Kind.CLASS), JavaMethod.Kind.STATIC, "equals", false, "(Ljava/lang/Object;Ljava/lang/Object;)Z", 0, false));
+					javaWriter.ifNE(loopStart);
+					// If ==
+					// javaWriter.ifACmpNe(loopStart);
+				}
+
+				javaWriter.label(isTrue);
+
+				javaWriter.pop();
+				javaWriter.iConst1();
+				javaWriter.goTo(expressionEnd);
+
+				javaWriter.label(loopEnd);
+				javaWriter.pop();
+				javaWriter.iConst0();
+				javaWriter.label(expressionEnd);
+
+				break;
 			case ARRAY_EQUALS:
 			case ARRAY_NOTEQUALS: {
 				ArrayTypeID type = (ArrayTypeID) expression.target.type.type;
 		javaWriter.aThrow();
 		return null;
 	}
-	
+
 	private void modify(Expression source, Runnable modification, PushOption push) {
 		source.accept(new JavaModificationExpressionVisitor(context, module, javaWriter, this, modification, push));
 	}
 				case UINT_INC:
 				case USIZE_INC:
 					if (expression.target instanceof GetLocalVariableExpression) {
-						JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)expression.target).variable.variable);
+						JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression) expression.target).variable.variable);
 						javaWriter.load(local);
 						javaWriter.iinc(local.local);
 					} else {
 				case UINT_DEC:
 				case USIZE_DEC:
 					if (expression.target instanceof GetLocalVariableExpression) {
-						JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)expression.target).variable.variable);
+						JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression) expression.target).variable.variable);
 						javaWriter.load(local);
 						javaWriter.iinc(local.local, -1);
 					} else {
 					throw new IllegalArgumentException("Unknown postcall builtin: " + expression.member.getBuiltin());
 			}
 		}
-		
+
 		modify(expression.target, () -> {
 			if (!checkAndExecuteMethodInfo(expression.member, expression.type, expression))
 				throw new IllegalStateException("Call target has no method info!");
 		}, PushOption.BEFORE);
-		
+
 		return null;
 	}
 
 				javaWriter.getStaticField(context.getJavaField(expression.getter));
 				return null;
 			}
-			
+
 			if (!checkAndExecuteMethodInfo(expression.getter, expression.type, expression))
 				throw new IllegalStateException("Call target has no method info!");
 
 
 	//Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
 	@SuppressWarnings({"Raw", "unchecked"})
-	private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member, StoredType resultType, Expression expression) {
+	boolean checkAndExecuteMethodInfo(DefinitionMemberRef member, StoredType resultType, Expression expression) {
 		JavaMethod methodInfo = context.getJavaMethod(member);
 		if (methodInfo == null)
 			return false;

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

 
 	@Override
 	public Void visitSetter(SetterExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		expression.target.accept(original);
+		expression.value.accept(original);
+		original.checkAndExecuteMethodInfo(expression.setter, expression.type, expression);
+		return null;
 	}
 
 	@Override

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaExpansionMemberVisitor.java

 	private final HighLevelDefinition definition;
 	private final JavaCompiledModule javaModule;
 
+	private final JavaStatementVisitor clinitStatementVisitor;
+
 	public JavaExpansionMemberVisitor(JavaBytecodeContext context, ClassWriter writer, StoredType expandedClass, HighLevelDefinition definition) {
 		this.writer = writer;
 		this.expandedClass = expandedClass;
 		this.definition = definition;
 		this.context = context;
 		javaModule = context.getJavaModule(definition.module);
+
+		final JavaWriter javaWriter = new JavaWriter(definition.position, writer, new JavaMethod(context.getJavaClass(definition), JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
+		this.clinitStatementVisitor = new JavaStatementVisitor(context, javaModule, javaWriter);
+		this.clinitStatementVisitor.start();
+		CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
 	}
 
 	public void end() {
+		clinitStatementVisitor.end();
 	}
 
 	@Override
 
 	@Override
 	public Void visitField(FieldMember member) {
-		throw new IllegalStateException("Cannot add fields via expansions");
+		if (!member.isStatic())
+			throw new IllegalStateException("Cannot add fields via expansions");
+
+		JavaField field = context.getJavaField(member);
+		writer.visitField(CompilerUtils.calcAccess(member.getEffectiveModifiers()), field.name, field.descriptor, field.signature, null).visitEnd();
+
+		return null;
+
+
 	}
 
 	@Override
 
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
-		throw new IllegalStateException("Cannot add Static initializers via expansions");
+		member.body.accept(clinitStatementVisitor);
+		return null;
 	}
 }