PanicExpression and primitive Boxing Expression, probably

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+
+public class JavaBoxingTypeVisitor implements ITypeVisitor<JavaMethodInfo> {
+
+	private final JavaWriter writer;
+
+	public JavaBoxingTypeVisitor(JavaWriter writer) {
+		this.writer = writer;
+	}
+
+	@Override
+	public JavaMethodInfo visitBasic(BasicTypeID basic) {
+		final JavaMethodInfo info;
+		switch (basic) {
+			case BOOL:
+				writer.newObject(Boolean.class);
+				info = new JavaMethodInfo(new JavaClassInfo("java/lang/Boolean"), "<init>", "(Z)V", -1);
+				break;
+			case BYTE:
+			case SBYTE:
+				writer.newObject(Byte.class);
+				info = new JavaMethodInfo(new JavaClassInfo("java/lang/Byte"), "<init>", "(B)V", -1);
+				break;
+			case SHORT:
+			case USHORT:
+				writer.newObject(Short.class);
+				info = new JavaMethodInfo(new JavaClassInfo("java/lang/Short"), "<init>", "(S)V", -1);
+				break;
+			case INT:
+			case UINT:
+				writer.newObject(Byte.class);
+				info = new JavaMethodInfo(new JavaClassInfo("java/lang/Byte"), "<init>", "(B)V", -1);
+				break;
+			case LONG:
+			case ULONG:
+				writer.newObject(Long.class);
+				info = new JavaMethodInfo(new JavaClassInfo("java/lang/Long"), "<init>", "(S)V", -1);
+				break;
+			case FLOAT:
+				writer.newObject(Float.class);
+				info = new JavaMethodInfo(new JavaClassInfo("java/lang/Float"), "<init>", "(F)V", -1);
+				break;
+			case DOUBLE:
+				writer.newObject(Double.class);
+				info = new JavaMethodInfo(new JavaClassInfo("java/lang/Double"), "<init>", "(D)V", -1);
+				break;
+			case CHAR:
+				writer.newObject(Character.class);
+				info = new JavaMethodInfo(new JavaClassInfo("java/lang/Character"), "<init>", "(C)V", -1);
+				break;
+			default:
+				return null;
+		}
+		writer.dup();
+		return info;
+	}
+
+	@Override
+	public JavaMethodInfo visitArray(ArrayTypeID array) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitAssoc(AssocTypeID assoc) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitGenericMap(GenericMapTypeID map) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitIterator(IteratorTypeID iterator) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitFunction(FunctionTypeID function) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitDefinition(DefinitionTypeID definition) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitGeneric(GenericTypeID generic) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitRange(RangeTypeID range) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitConst(ConstTypeID type) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitOptional(OptionalTypeID optional) {
+		//NO-OP
+		return null;
+	}
+}

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

 		this.javaWriter = javaWriter;
 	}
 
-	private static Class<?> getForEquals(ITypeID id) {
-		if (CompilerUtils.isPrimitive(id))
-			return id.accept(JavaTypeClassVisitor.INSTANCE);
-		return Object.class;
-	}
-
 	@Override
 	public Void visitAndAnd(AndAndExpression expression) {
 		Label end = new Label();
 		javaWriter.invokeSpecial(NullPointerException.class, "<init>", "(Ljava/lang/String;)V");
 		javaWriter.aThrow();
 		javaWriter.label(end);
-		
+
 		return null;
 	}
 
 
 	@Override
 	public Void visitPanic(PanicExpression expression) {
-		// TODO: compile to: throw new AssertionError(expression.value)
-		throw new UnsupportedOperationException("Not yet supported");
+		javaWriter.newObject(AssertionError.class);
+		javaWriter.dup();
+		expression.value.accept(this);
+		javaWriter.invokeSpecial(AssertionError.class, "<init>", "(Ljava/lang/String;)V");
+		javaWriter.aThrow();
+		return null;
 	}
 
 	@Override
 		javaWriter.dup();
 		expression.from.accept(this);
 		expression.to.accept(this);
-		System.out.println(IntRange.class.getName());
 		javaWriter.invokeSpecial("org/openzen/zenscript/implementations/IntRange", "<init>", "(II)V");
 
 		return null;
 
 	@Override
 	public Void visitWrapOptional(WrapOptionalExpression expression) {
-		// TODO: convert basic types (char, int, float, ...) to their boxed (Character, Integer, Float, ...) counterparts
-		// -- any object type values can just be passed as-is
+		//Does nothing if not required to be wrapped
+		final JavaMethodInfo info = expression.value.type.accept(new JavaBoxingTypeVisitor(javaWriter));
 		expression.value.accept(this);
+
+		//i.e. if it was a primitive
+		if(info != null)
+			javaWriter.invokeSpecial(info);
 		return null;
 	}
 
 
 	//Will return true if a JavaBytecodeImplementation.class tag exists, and will compile that tag
 	private boolean checkAndExecuteByteCodeImplementation(DefinitionMemberRef member) {
-		JavaBytecodeImplementation implementation = member.getTag(JavaBytecodeImplementation.class);
+		final JavaBytecodeImplementation implementation = member.getTag(JavaBytecodeImplementation.class);
 		if (implementation != null) {
 			implementation.compile(getJavaWriter());
 			return true;
 
 	//Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
 	private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member) {
-		JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
+		final JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
 		if (methodInfo == null)
 			return false;
 
 
 	//Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
 	public boolean checkAndPutFieldInfo(FieldMemberRef field, boolean isStatic) {
-		JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+		final JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
 		if (fieldInfo == null)
 			return false;
 		//TODO Remove isStatic
 	}
 
 	public boolean checkAndGetFieldInfo(ConstMemberRef field, boolean isStatic) {
-		JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+		final JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
 		if (fieldInfo == null)
 			return false;
 
 	}
 
 	public boolean checkAndGetFieldInfo(FieldMemberRef field, boolean isStatic) {
-		JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+		final JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
 		if (fieldInfo == null)
 			return false;
 

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

 		invokeSpecial(Type.getInternalName(owner), name, descriptor);
 	}
 
+	public void invokeSpecial (JavaMethodInfo method) {
+		invokeSpecial(method.javaClass.internalClassName, method.name, method.descriptor);
+	}
+
 	public void invokeVirtual(JavaMethodInfo method) {
 		if (debug)
 			System.out.println("invokeVirtual " + method.javaClass.internalClassName + '.' + method.name + method.descriptor);