Merge remote-tracking branch 'Stan/development' into development

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
 	public ExpressionString visitConstantShort(ConstantShortExpression expression) {
 		return new ExpressionString(Integer.toString(expression.value) + " as short", ZenScriptOperator.CAST);
 	}
+	
+	@Override
+	public ExpressionString visitConstantUSize(ConstantUSizeExpression expression) {
+		return new ExpressionString(Long.toUnsignedString(expression.value) + " as usize", ZenScriptOperator.CAST);
+	}
 
 	@Override
 	public ExpressionString visitConstantString(ConstantStringExpression expression) {
 
 	@Override
 	public ExpressionString visitConstantUInt(ConstantUIntExpression expression) {
-		return new ExpressionString(Integer.toString(expression.value) + " as uint", ZenScriptOperator.CAST);
+		return new ExpressionString(Integer.toUnsignedString(expression.value) + " as uint", ZenScriptOperator.CAST);
 	}
 
 	@Override
 	public ExpressionString visitConstantULong(ConstantULongExpression expression) {
-		return new ExpressionString(Long.toString(expression.value) + " as ulong", ZenScriptOperator.CAST);
+		return new ExpressionString(Long.toUnsignedString(expression.value) + " as ulong", ZenScriptOperator.CAST);
 	}
 
 	@Override
 	public ExpressionString visitConstantUShort(ConstantUShortExpression expression) {
-		return new ExpressionString(Integer.toString(expression.value) + " as ushort", ZenScriptOperator.CAST);
+		return new ExpressionString(Integer.toUnsignedString(expression.value) + " as ushort", ZenScriptOperator.CAST);
 	}
 
 	@Override

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/FormattingUtils.java

 			
 			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.UNDETERMINED) {
 				result.append(" as ");
-				result.append(header.returnType.accept(typeFormatter));
+				result.append(header.getReturnType().accept(typeFormatter));
 			}
 			
 			parameterIndex++;
 		}
 		result.append(")");
-		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.UNDETERMINED) {
+		if (!settings.showAnyInFunctionHeaders || header.getReturnType() != BasicTypeID.UNDETERMINED) {
 			result.append(" as ");
-			result.append(header.returnType.accept(typeFormatter));
+			result.append(header.getReturnType().accept(typeFormatter));
 		}
 	}
 	

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/MemberFormatter.java

 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 	}
 
 	@Override
-	public Void visitCustomIterator(CustomIteratorMember member) {
+	public Void visitCustomIterator(IteratorMember member) {
 		visit(false);
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/TypeFormatter.java

 
 	@Override
 	public String visitRange(RangeTypeID range) {
-		return range.from.accept(this) + " .. " + range.to.accept(this);
+		return range.baseType.accept(this) + " .. " + range.baseType.accept(this);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

 	private static final FunctionParameter[] NO_PARAMETERS = new FunctionParameter[0];
 	
 	public final TypeParameter[] typeParameters;
-	public ITypeID returnType;
+	private ITypeID returnType;
 	public final FunctionParameter[] parameters;
 	public final ITypeID thrownType;
 	
 		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
+	public ITypeID getReturnType() {
+		return returnType;
+	}
+	
+	public void setReturnType(ITypeID returnType) {
+		if (returnType == null)
+			throw new NullPointerException();
+		
+		this.returnType = returnType;
+	}
+	
 	public boolean isDenormalized() {
 		if (returnType.getNormalized() != returnType)
 			return true;
 		return true;
 	}
 	
-	public FunctionHeader withGenericArguments(GenericMapper mapper) {
+	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, GenericMapper mapper) {
 		if (typeParameters.length > 0) {
 			Map<TypeParameter, ITypeID> innerMap = new HashMap<>();
 			for (TypeParameter parameter : typeParameters)
 				innerMap.put(parameter, mapper.registry.getGeneric(parameter));
 			
-			mapper = mapper.getInner(innerMap);
+			mapper = mapper.getInner(registry, innerMap);
 		}
 		
 		ITypeID returnType = this.returnType.instance(mapper);
 		Map<TypeParameter, ITypeID> typeArguments = new HashMap<>();
 		for (int i = 0; i < typeParameters.length; i++)
 			typeArguments.put(typeParameters[i], arguments[i]);
-		GenericMapper mapper = typeParameterMapping.getInner(typeArguments);
+		GenericMapper mapper = typeParameterMapping.getInner(registry, typeArguments);
 		
 		ITypeID returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 				result.append(", ");
 			result.append(parameters[i].toString());
 		}
-		result.append(")");
+		result.append(") as ");
+		result.append(returnType.toString());
 		return result.toString();
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/GenericMapper.java

 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
-		return mapping.isEmpty() ? original : original.withGenericArguments(this);
+		return mapping.isEmpty() ? original : original.withGenericArguments(registry, this);
 	}
 	
-	public GenericMapper getInner(Map<TypeParameter, ITypeID> mapping) {
+	public GenericMapper getInner(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
 		Map<TypeParameter, ITypeID> resultMap = new HashMap<>(this.mapping);
 		resultMap.putAll(mapping);
 		return new GenericMapper(registry, resultMap);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationProcessor.java

 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.DefinitionScope;
 import org.openzen.zenscript.codemodel.scope.FileScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
 
 		@Override
 		public Void visitGetter(GetterMember member) {
-			return functional(member);
+			return getter(member);
 		}
 
 		@Override
 		public Void visitSetter(SetterMember member) {
-			return functional(member);
+			return setter(member);
 		}
 
 		@Override
 		}
 
 		@Override
-		public Void visitCustomIterator(CustomIteratorMember member) {
+		public Void visitCustomIterator(IteratorMember member) {
 			return functional(member);
 		}
 
 			return null;
 		}
 		
+		private Void getter(GetterMember member) {
+			for (MemberAnnotation annotation : member.annotations)
+				annotation.apply(member, scope);
+			
+			if (member.getOverrides() != null) {
+				getter(member, member.getOverrides());
+			}
+			
+			if (member.body == null)
+				return null;
+			
+			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(member.type));
+			member.body = process(member.body, scope);
+			return null;
+		}
+		
+		private Void setter(SetterMember member) {
+			for (MemberAnnotation annotation : member.annotations)
+				annotation.apply(member, scope);
+			
+			if (member.getOverrides() != null) {
+				setter(member, member.getOverrides());
+			}
+			
+			if (member.body == null)
+				return null;
+			
+			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(BasicTypeID.VOID, member.parameter));
+			member.body = process(member.body, scope);
+			return null;
+		}
+		
 		private void functional(FunctionalMember member, DefinitionMemberRef overrides) {
 			for (MemberAnnotation annotation : overrides.getAnnotations())
 				annotation.applyOnOverridingMethod(member, scope);
 				functional(member, overrides.getOverrides());
 			}
 		}
+		
+		private void getter(GetterMember member, GetterMemberRef overrides) {
+			for (MemberAnnotation annotation : overrides.getAnnotations())
+				annotation.applyOnOverridingGetter(member, scope);
+			
+			if (overrides.getOverrides() != null) {
+				getter(member, overrides.getOverrides());
+			}
+		}
+		
+		private void setter(SetterMember member, SetterMemberRef overrides) {
+			for (MemberAnnotation annotation : overrides.getAnnotations())
+				annotation.applyOnOverridingSetter(member, scope);
+			
+			if (overrides.getOverrides() != null) {
+				setter(member, overrides.getOverrides());
+			}
+		}
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/MemberAnnotation.java

 package org.openzen.zenscript.codemodel.annotations;
 
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 
 /**
 	public void apply(IDefinitionMember member, BaseScope scope);
 	
 	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope);
+	
+	public void applyOnOverridingGetter(GetterMember member, BaseScope scope);
+	
+	public void applyOnOverridingSetter(SetterMember member, BaseScope scope);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeMemberAnnotation.java

 package org.openzen.zenscript.codemodel.annotations;
 
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 
 /**
 	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope) {
 		// not inherited
 	}
+
+	@Override
+	public void applyOnOverridingGetter(GetterMember member, BaseScope scope) {
+		// not inherited
+	}
+
+	@Override
+	public void applyOnOverridingSetter(SetterMember member, BaseScope scope) {
+		// not inherited
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/PreconditionForMethod.java

 import org.openzen.zenscript.codemodel.expression.ExpressionBuilder;
 import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 
 	@Override
 	public void apply(IDefinitionMember member, BaseScope scope) {
-		applyOnOverridingMethod((FunctionalMember)member, scope);
+		if (member instanceof GetterMember) {
+			applyOnOverridingGetter((GetterMember)member, scope);
+		} else if (member instanceof SetterMember) {
+			applyOnOverridingSetter((SetterMember)member, scope);
+		} else if (member instanceof FunctionalMember) {
+			applyOnOverridingMethod((FunctionalMember)member, scope);
+		}
 	}
 
 	@Override
 	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope) {
-		if (member.body == null)
-			return;
+		member.body = applyOnOverride(member.body, scope);
+	}
+
+	@Override
+	public void applyOnOverridingGetter(GetterMember member, BaseScope scope) {
+		member.body = applyOnOverride(member.body, scope);
+	}
+
+	@Override
+	public void applyOnOverridingSetter(SetterMember member, BaseScope scope) {
+		member.body = applyOnOverride(member.body, scope);
+	}
+	
+	private Statement applyOnOverride(Statement body, BaseScope scope) {
+		if (body == null)
+			return body;
 		
 		ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL);
 		List<Statement> statements = new ArrayList<>();
 		Expression inverseCondition = expressionBuilder.not(condition);
 		Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, message));
 		statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
-		if (member.body instanceof BlockStatement) {
-			statements.addAll(((BlockStatement)member.body).statements);
+		
+		if (body instanceof BlockStatement) {
+			statements.addAll(((BlockStatement)body).statements);
 		} else {
-			statements.add(member.body);
+			statements.add(body);
 		}
-		member.body = new BlockStatement(position, statements);
+		return new BlockStatement(position, statements);
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/VariantDefinition.java

 			this.types = types;
 		}
 		
-		public VariantOptionRef instance(GenericMapper mapper) {
-			return new VariantOptionRef(this, mapper.map(types));
+		public VariantOptionRef instance(ITypeID variantType, GenericMapper mapper) {
+			return new VariantOptionRef(this, variantType, mapper.map(types));
 		}
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/CallExpression.java

 	public final FunctionHeader instancedHeader;
 	
 	public CallExpression(CodePosition position, Expression target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments) {
-		super(position, instancedHeader.returnType, multiThrow(position, arguments.arguments));
+		super(position, instancedHeader.getReturnType(), multiThrow(position, arguments.arguments));
 		
 		this.target = target;
 		this.member = member;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/CallStaticExpression.java

 	public final FunctionHeader instancedHeader;
 	
 	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments) {
-		super(position, instancedHeader.returnType, multiThrow(position, arguments.arguments));
+		super(position, instancedHeader.getReturnType(), multiThrow(position, arguments.arguments));
 		
 		this.member = member;
 		this.target = target;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ConstantUSizeExpression.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ConstantUSizeExpression extends Expression {
+	public final long value;
+	
+	public ConstantUSizeExpression(CodePosition position, long value) {
+		super(position, BasicTypeID.USIZE, null);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitConstantUSize(this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ExpressionVisitor.java

 	
 	public T visitConstantUShort(ConstantUShortExpression expression);
 	
+	public T visitConstantUSize(ConstantUSizeExpression expression);
+	
 	public T visitConstructorThisCall(ConstructorThisCallExpression expression);
 	
 	public T visitConstructorSuperCall(ConstructorSuperCallExpression expression);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/PostCallExpression.java

 	public final FunctionHeader instancedHeader;
 	
 	public PostCallExpression(CodePosition position, Expression target, FunctionalMemberRef member, FunctionHeader instancedHeader) {
-		super(position, instancedHeader.returnType, binaryThrow(position, instancedHeader.thrownType, target.thrownType));
+		super(position, instancedHeader.getReturnType(), binaryThrow(position, instancedHeader.thrownType, target.thrownType));
 		
 		if (member.getOperator() != OperatorType.DECREMENT && member.getOperator() != OperatorType.INCREMENT)
 			throw new IllegalArgumentException("Operator must be increment or decrement");

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/RangeExpression.java

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
 
 /**
  *
 	public final Expression from;
 	public final Expression to;
 	
-	public RangeExpression(CodePosition position, GlobalTypeRegistry registry, Expression from, Expression to) {
-		super(position, registry.getRange(from.type, to.type), binaryThrow(position, from.thrownType, to.thrownType));
+	public RangeExpression(CodePosition position, RangeTypeID type, Expression from, Expression to) {
+		super(position, type, binaryThrow(position, from.thrownType, to.thrownType));
 	
 		this.from = from;
 		this.to = to;
 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		return new RangeExpression(position, scope.getTypeRegistry(), from.normalize(scope), to.normalize(scope));
+		RangeTypeID rangeType = (RangeTypeID)type;
+		return new RangeExpression(
+				position,
+				rangeType,
+				from.normalize(scope).castImplicit(position, scope, rangeType.baseType),
+				to.normalize(scope).castImplicit(position, scope, rangeType.baseType));
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/SetFieldExpression.java

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 	public final Expression target;
 	public final FieldMemberRef field;
 	public final Expression value;
+	public final FunctionParameter parameter;
 	
 	public SetFieldExpression(CodePosition position, Expression target, FieldMemberRef field, Expression value) {
 		super(position, field.getType(), binaryThrow(position, target.thrownType, value.thrownType));
 		this.target = target;
 		this.field = field;
 		this.value = value;
+		this.parameter = new FunctionParameter(type);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/iterator/ForeachIteratorVisitor.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.iterator;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface ForeachIteratorVisitor<T> {
-	T visitIntRange();
-	
-	T visitArrayValueIterator();
-	
-	T visitArrayKeyValueIterator();
-	
-	T visitAssocKeyIterator();
-	
-	T visitAssocKeyValueIterator();
-	
-	T visitStringCharacterIterator();
-	
-	T visitCustomIterator();
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ConstructorMember.java

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		if (definition instanceof EnumDefinition)
+			modifiers |= Modifiers.PRIVATE;
+		
+		super.normalize(scope);
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/FieldMember.java

 					position,
 					new ThisExpression(position, thisType),
 					new FieldMemberRef(this, null),
-					new GetFunctionParameterExpression(position, this.autoSetter.header.parameters[0]))));
+					new GetFunctionParameterExpression(position, this.autoSetter.parameter))));
 		} else {
 			this.autoSetter = null;
 		}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/GetterMember.java

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
  *
  * @author Hoofdgebruiker
  */
-public class GetterMember extends FunctionalMember implements IPropertyMember {
+public class GetterMember extends PropertyMember {
 	public final String name;
-	public ITypeID type;
 	private GetterMemberRef overrides;
+	public Statement body = null;
 	
 	public GetterMember(
 			CodePosition position,
 			String name,
 			ITypeID type,
 			BuiltinID builtin) {
-		super(position, definition, modifiers, new FunctionHeader(type), builtin);
+		super(position, definition, modifiers, type, builtin);
 		
 		this.name = name;
-		this.type = type;
 	}
 	
-	@Override
 	public void setBody(Statement body) {
-		super.setBody(body);
+		this.body = body;
 		
 		if (type == BasicTypeID.UNDETERMINED)
 			type = body.getReturnType();
 	}
 	
 	@Override
-	public ITypeID getType() {
-		return type;
-	}
-	
-	@Override
-	public String getCanonicalName() {
-		return definition.getFullName() + ":getter:" + name;
-	}
-	
-	@Override
-	public FunctionalKind getKind() {
-		return FunctionalKind.GETTER;
+	public boolean isAbstract() {
+		return body == null && builtin == null;
 	}
 	
 	@Override
 	public GetterMemberRef getOverrides() {
 		return overrides;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		if (body != null)
+			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
+	}
 	
 	public void setOverrides(GetterMemberRef override) {
 		this.overrides = override;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/IIteratorMember.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.member;
-
-import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface IIteratorMember extends IDefinitionMember {
-	public int getLoopVariableCount();
-	
-	public ITypeID[] getLoopVariableTypes();
-	
-	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor);
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/IPropertyMember.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.member;
-
-import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface IPropertyMember extends IDefinitionMember {
-	ITypeID getType();
-	
-	boolean isStatic();
-	
-	boolean isFinal();
-	
-	MemberAnnotation[] getAnnotations();
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/CustomIteratorMember.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/IteratorMember.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
  *
  * @author Hoofdgebruiker
  */
-public class CustomIteratorMember extends FunctionalMember implements IIteratorMember {
+public class IteratorMember extends FunctionalMember {
 	private final ITypeID[] iteratorTypes;
 	public Statement body;
 	public IteratorMemberRef overrides;
 	
-	public CustomIteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID[] iteratorTypes, GlobalTypeRegistry registry, BuiltinID builtin) {
+	public IteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID[] iteratorTypes, GlobalTypeRegistry registry, BuiltinID builtin) {
 		super(position, definition, modifiers, createIteratorHeader(registry, iteratorTypes), builtin);
 		
 		this.iteratorTypes = iteratorTypes;
 	public String getCanonicalName() {
 		return definition.getFullName() + ":iterator:" + iteratorTypes.length;
 	}
-
-	@Override
+	
 	public int getLoopVariableCount() {
 		return iteratorTypes.length;
 	}
-
-	@Override
+	
 	public ITypeID[] getLoopVariableTypes() {
 		return iteratorTypes;
 	}
-	
-	@Override
-	public BuiltinID getBuiltin() {
-		return null;
-	}
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		type.addIterator(new IteratorMemberRef(this, mapper.map(iteratorTypes)), priority);
+		type.addIterator(new IteratorMemberRef(this, mapper == null ? iteratorTypes : mapper.map(iteratorTypes)), priority);
 	}
 
 	@Override
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitCustomIterator(this);
 	}
-
-	@Override
-	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
-		return visitor.visitCustomIterator();
-	}
 	
 	public void setOverrides(IteratorMemberRef overrides) {
 		this.overrides = overrides;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/MemberVisitor.java

 	
 	public T visitCaster(CasterMember member);
 	
-	public T visitCustomIterator(CustomIteratorMember member);
+	public T visitCustomIterator(IteratorMember member);
 	
 	public T visitCaller(CallerMember member);
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/PropertyMember.java

  *
  * @author Hoofdgebruiker
  */
-public abstract class PropertyMember extends DefinitionMember implements IPropertyMember {
+public abstract class PropertyMember extends DefinitionMember {
 	public ITypeID type;
 	public final BuiltinID builtin;
 	
 		this.builtin = builtin;
 	}
 	
-	@Override
 	public ITypeID getType() {
 		return type;
 	}
+	
+	@Override
+	public BuiltinID getBuiltin() {
+		return builtin;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/SetterMember.java

 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
  *
  * @author Hoofdgebruiker
  */
-public class SetterMember extends FunctionalMember implements IPropertyMember {
-	public ITypeID type;
+public class SetterMember extends PropertyMember {
 	public final String name;
 	private SetterMemberRef overrides;
+	public Statement body;
+	public final FunctionParameter parameter;
 	
 	public SetterMember(
 			CodePosition position,
 		super(position,
 				definition,
 				modifiers,
-				new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(type, "$")),
+				type,
 				builtin);
 		
-		this.type = type;
 		this.name = name;
+		this.parameter = new FunctionParameter(type, "value");
 	}
 	
-	@Override
-	public ITypeID getType() {
-		return type;
-	}
-	
-	@Override
-	public String getCanonicalName() {
-		return definition.getFullName() + ":setter:" + name;
-	}
-
-	@Override
-	public FunctionalKind getKind() {
-		return FunctionalKind.SETTER;
+	public void setBody(Statement body) {
+		this.body = body;
 	}
 
 	@Override
 			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
 	}
 	
+	@Override
+	public boolean isAbstract() {
+		return body == null && builtin == null;
+	}
+	
 	public void setOverrides(SetterMemberRef overrides) {
 		this.overrides = overrides;
 		

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/StaticInitializerMember.java

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.ConcatMap;
-import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
  *
  * @author Hoofdgebruiker
  */
-public class StaticInitializerMember extends Taggable implements IDefinitionMember {
-	public final CodePosition position;
+public class StaticInitializerMember extends DefinitionMember {
 	public Statement body;
-	public MemberAnnotation[] annotations = MemberAnnotation.NONE;
 	
-	public StaticInitializerMember(CodePosition position) {
-		this.position = position;
-	}
-	
-	@Override
-	public CodePosition getPosition() {
-		return position;
+	public StaticInitializerMember(CodePosition position, HighLevelDefinition definition) {
+		super(position, definition, 0);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/ArrayIteratorKeyValues.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.member.builtin;
-
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.Taggable;
-import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IIteratorMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ArrayTypeID;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class ArrayIteratorKeyValues extends Taggable implements IIteratorMember {
-	private ArrayTypeID type;
-	private final ITypeID[] loopVariableTypes;
-	
-	public ArrayIteratorKeyValues(ArrayTypeID type) {
-		this.type = type;
-		
-		loopVariableTypes = new ITypeID[type.dimension + 1];
-		for (int i = 0; i < type.dimension; i++)
-			loopVariableTypes[i] = BasicTypeID.INT;
-		loopVariableTypes[type.dimension] = type.elementType;
-	}
-	
-	@Override
-	public CodePosition getPosition() {
-		return CodePosition.BUILTIN;
-	}
-	
-	@Override
-	public BuiltinID getBuiltin() {
-		return null;
-	}
-
-	@Override
-	public int getLoopVariableCount() {
-		return loopVariableTypes.length;
-	}
-
-	@Override
-	public ITypeID[] getLoopVariableTypes() {
-		return loopVariableTypes;
-	}
-
-	@Override
-	public String describe() {
-		return "iterator for array elements with index";
-	}
-
-	@Override
-	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addIterator(new IteratorMemberRef(this, mapper == null ? loopVariableTypes : mapper.map(loopVariableTypes)), priority);
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Not a compilable member");
-	}
-
-	@Override
-	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
-		return visitor.visitArrayKeyValueIterator();
-	}
-
-	@Override
-	public DefinitionMemberRef getOverrides() {
-		return null;
-	}
-
-	@Override
-	public void normalize(TypeScope scope) {
-		
-	}
-
-	@Override
-	public boolean isAbstract() {
-		return false;
-	}
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/ArrayIteratorValues.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.member.builtin;
-
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.Taggable;
-import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IIteratorMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ArrayTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class ArrayIteratorValues extends Taggable implements IIteratorMember {
-	private final ArrayTypeID type;
-	private final ITypeID[] loopVariableTypes;
-	
-	public ArrayIteratorValues(ArrayTypeID type) {
-		this.type = type;
-		loopVariableTypes = new ITypeID[] { type.elementType };
-	}
-	
-	@Override
-	public CodePosition getPosition() {
-		return CodePosition.BUILTIN;
-	}
-	
-	@Override
-	public BuiltinID getBuiltin() {
-		return null;
-	}
-
-	@Override
-	public int getLoopVariableCount() {
-		return 1;
-	}
-
-	@Override
-	public ITypeID[] getLoopVariableTypes() {
-		return loopVariableTypes;
-	}
-
-	@Override
-	public String describe() {
-		return "iterator for array values";
-	}
-
-	@Override
-	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addIterator(new IteratorMemberRef(this, mapper == null ? loopVariableTypes : mapper.map(loopVariableTypes)), priority);
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Not a compilable member");
-	}
-
-	@Override
-	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
-		return visitor.visitArrayValueIterator();
-	}
-
-	@Override
-	public DefinitionMemberRef getOverrides() {
-		return null;
-	}
-
-	@Override
-	public void normalize(TypeScope scope) {
-		
-	}
-
-	@Override
-	public boolean isAbstract() {
-		return false;
-	}
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/AssocIterator.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.member.builtin;
-
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.Taggable;
-import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IIteratorMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.AssocTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class AssocIterator extends Taggable implements IIteratorMember {
-	private final AssocTypeID type;
-	private final ITypeID[] loopVariableTypes;
-	
-	public AssocIterator(AssocTypeID type) {
-		this.type = type;
-		
-		loopVariableTypes = new ITypeID[2];
-		loopVariableTypes[0] = type.keyType;
-		loopVariableTypes[1] = type.valueType;
-	}
-	
-	@Override
-	public CodePosition getPosition() {
-		return CodePosition.BUILTIN;
-	}
-	
-	@Override
-	public BuiltinID getBuiltin() {
-		return null;
-	}
-
-	@Override
-	public int getLoopVariableCount() {
-		return loopVariableTypes.length;
-	}
-
-	@Override
-	public ITypeID[] getLoopVariableTypes() {
-		return loopVariableTypes;
-	}
-
-	@Override
-	public String describe() {
-		return "iterator for key/value pairs in an associative array";
-	}
-
-	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		type.addIterator(new IteratorMemberRef(this, mapper == null ? loopVariableTypes : mapper.map(loopVariableTypes)), priority);
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Not a compilable member");
-	}
-
-	@Override
-	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
-		return visitor.visitAssocKeyValueIterator();
-	}
-
-	@Override
-	public DefinitionMemberRef getOverrides() {
-		return null;
-	}
-
-	@Override
-	public void normalize(TypeScope scope) {
-		
-	}
-
-	@Override
-	public boolean isAbstract() {
-		return false;
-	}
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/RangeIterator.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.member.builtin;
-
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.Taggable;
-import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IIteratorMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.RangeTypeID;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class RangeIterator extends Taggable implements IIteratorMember {
-	private final ITypeID[] loopVariableTypes;
-	
-	public RangeIterator(RangeTypeID type) {
-		if (type.from != type.to)
-			throw new UnsupportedOperationException("Cannot iterator over a range with different from and to types");
-		if (type.from != BasicTypeID.BYTE
-				&& type.from != BasicTypeID.SBYTE
-				&& type.from != BasicTypeID.SHORT
-				&& type.from != BasicTypeID.USHORT
-				&& type.from != BasicTypeID.INT
-				&& type.from != BasicTypeID.UINT
-				&& type.from != BasicTypeID.LONG
-				&& type.from != BasicTypeID.ULONG)
-			throw new UnsupportedOperationException("Can only use range iterator over integer types");
-		
-		loopVariableTypes = new ITypeID[] { type.from };
-	}
-	
-	@Override
-	public CodePosition getPosition() {
-		return CodePosition.BUILTIN;
-	}
-	
-	@Override
-	public BuiltinID getBuiltin() {
-		return null;
-	}
-
-	@Override
-	public int getLoopVariableCount() {
-		return 1;
-	}
-
-	@Override
-	public ITypeID[] getLoopVariableTypes() {
-		return loopVariableTypes;
-	}
-
-	@Override
-	public String describe() {
-		return "range iterator";
-	}
-
-	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		type.addIterator(new IteratorMemberRef(this, mapper == null ? loopVariableTypes : mapper.map(loopVariableTypes)), priority);
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Not a compilable member");
-	}
-
-	@Override
-	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
-		return visitor.visitIntRange();
-	}
-
-	@Override
-	public DefinitionMemberRef getOverrides() {
-		return null;
-	}
-
-	@Override
-	public void normalize(TypeScope scope) {
-		
-	}
-
-	@Override
-	public boolean isAbstract() {
-		return false;
-	}
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/StringCharIterator.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.member.builtin;
-
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.Taggable;
-import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IIteratorMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class StringCharIterator extends Taggable implements IIteratorMember {
-	private static final ITypeID[] TYPES = new ITypeID[] { BasicTypeID.CHAR };
-
-	@Override
-	public int getLoopVariableCount() {
-		return 1;
-	}
-	
-	@Override
-	public BuiltinID getBuiltin() {
-		return null;
-	}
-
-	@Override
-	public ITypeID[] getLoopVariableTypes() {
-		return TYPES;
-	}
-
-	@Override
-	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
-		return visitor.visitStringCharacterIterator();
-	}
-
-	@Override
-	public CodePosition getPosition() {
-		return CodePosition.BUILTIN;
-	}
-
-	@Override
-	public String describe() {
-		return "string character iterator";
-	}
-
-	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		type.addIterator(new IteratorMemberRef(this, TYPES), priority);
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Not a compilable member");
-	}
-
-	@Override
-	public DefinitionMemberRef getOverrides() {
-		return null;
-	}
-
-	@Override
-	public void normalize(TypeScope scope) {
-		
-	}
-
-	@Override
-	public boolean isAbstract() {
-		return false;
-	}
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/GetterMemberRef.java

 	}
 
 	@Override
-	public DefinitionMemberRef getOverrides() {
+	public GetterMemberRef getOverrides() {
 		return member.getOverrides();
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/IteratorMemberRef.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  * @author Hoofdgebruiker
  */
 public class IteratorMemberRef implements DefinitionMemberRef {
-	public final IIteratorMember target;
+	public final IteratorMember target;
 	public final ITypeID[] types;
 	
-	public IteratorMemberRef(IIteratorMember target, ITypeID... types) {
+	public IteratorMemberRef(IteratorMember target, ITypeID... types) {
 		this.target = target;
 		this.types = types;
 	}
 
 	@Override
 	public MemberAnnotation[] getAnnotations() {
-		if (target instanceof CustomIteratorMember) {
-			return ((CustomIteratorMember)target).annotations;
+		if (target instanceof IteratorMember) {
+			return ((IteratorMember)target).annotations;
 		} else {
 			return null;
 		}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/PropertyRef.java

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.member.IPropertyMember;
+import org.openzen.zenscript.codemodel.member.PropertyMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
  * @author Hoofdgebruiker
  */
 public abstract class PropertyRef implements DefinitionMemberRef {
-	private final IPropertyMember member;
+	private final PropertyMember member;
 	
 	private ITypeID type;
 	private GenericMapper mapper;
 	
-	public PropertyRef(IPropertyMember member, GenericMapper mapper) {
+	public PropertyRef(PropertyMember member, GenericMapper mapper) {
 		this.member = member;
 		
 		if (member.getType() == BasicTypeID.UNDETERMINED) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/SetterMemberRef.java

 	}
 
 	@Override
-	public DefinitionMemberRef getOverrides() {
+	public SetterMemberRef getOverrides() {
 		return member.getOverrides();
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/VariantOptionRef.java

  */
 public class VariantOptionRef {
 	private final VariantDefinition.Option option;
+	public final ITypeID variant;
 	public final ITypeID[] types;
 	
-	public VariantOptionRef(VariantDefinition.Option option, ITypeID[] types) {
+	public VariantOptionRef(VariantDefinition.Option option, ITypeID variant, ITypeID[] types) {
 		this.option = option;
+		this.variant = variant;
 		this.types = types;
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialVariantOptionExpression.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.partial;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
+import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PartialVariantOptionExpression implements IPartialExpression {
+	private final CodePosition position;
+	private final TypeScope scope;
+	private final VariantOptionRef option;
+	
+	public PartialVariantOptionExpression(CodePosition position, TypeScope scope, VariantOptionRef option) {
+		this.position = position;
+		this.scope = scope;
+		this.option = option;
+	}
+	
+	@Override
+	public Expression eval() {
+		throw new CompileException(position, CompileExceptionCode.VARIANT_OPTION_NOT_AN_EXPRESSION, "Cannot use a variant option as expression");
+	}
+
+	@Override
+	public List<ITypeID>[] predictCallTypes(TypeScope scope, List<ITypeID> hints, int arguments) {
+		if (arguments != option.getOption().types.length)
+			return new List[0];
+		
+		return new List[] { Arrays.asList(option.getOption().types) };
+	}
+
+	@Override
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<ITypeID> hints, int arguments) {
+		if (arguments != option.getOption().types.length)
+			return Collections.emptyList();
+		
+		return Collections.singletonList(new FunctionHeader(option.variant, option.types));
+	}
+
+	@Override
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<ITypeID> hints, GenericName name) {
+		throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant options don't have members");
+	}
+
+	@Override
+	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
+		return new VariantValueExpression(position, option.variant, option, arguments.arguments);
+	}
+
+	@Override
+	public ITypeID[] getGenericCallTypes() {
+		return ITypeID.NONE;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/DefinitionScope.java

 		}
 		
 		members = withMembers ? outer.getMemberCache().get(type) : null;
-		typeParameterMap = outer.getLocalTypeParameters().getInner(typeParameters);
+		typeParameterMap = outer.getLocalTypeParameters().getInner(getTypeRegistry(), typeParameters);
 	}
 	
 	public void addInnerType(String name, Supplier<HighLevelDefinition> innerType) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/ExpressionScope.java

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	
 	public ExpressionScope(BaseScope scope, ITypeID hint) {
 		this.outer = scope;
-		this.hints = Collections.singletonList(hint);
+		this.hints = hint == BasicTypeID.UNDETERMINED ? Collections.emptyList() : Collections.singletonList(hint);
 		this.dollar = null;
 		this.genericInferenceMap = Collections.emptyMap();
 	}
 	
-	public ExpressionScope(BaseScope scope, List<ITypeID> hints, Function<CodePosition, Expression> dollar, Map<TypeParameter, ITypeID> genericInferenceMap) {
-		this.outer = scope;
-		this.hints = hints;
-		this.dollar = dollar;
-		this.genericInferenceMap = genericInferenceMap;
-	}
-	
 	private ExpressionScope(
 			BaseScope scope,
 			List<ITypeID> hints,

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/BasicTypeID.java

 	UINT("uint"),
 	LONG("long"),
 	ULONG("ulong"),
+	USIZE("usize"),
 	FLOAT("float"),
 	DOUBLE("double"),
 	CHAR("char"),

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java

 			return this;
 		if (mapper.getMapping().isEmpty())
 			return this;
+		if (mapper.registry == null)
+			throw new NullPointerException();
 		
 		ITypeID[] instancedArguments = ITypeID.NONE;
 		if (hasTypeParameters()) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/FunctionTypeID.java

 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		header.returnType.extractTypeParameters(typeParameters);
+		header.getReturnType().extractTypeParameters(typeParameters);
 		for (FunctionParameter parameter : header.parameters)
 			parameter.type.extractTypeParameters(typeParameters);
 	}
 	@Override
 	public int hashCode() {
 		int hash = 5;
-		hash = 71 * hash + header.returnType.hashCode();
+		hash = 71 * hash + header.getReturnType().hashCode();
 		hash = 71 * hash + Arrays.deepHashCode(header.parameters);
 		hash = 71 * hash + Arrays.deepHashCode(header.typeParameters);
 		return hash;
 			return false;
 		}
 		final FunctionTypeID other = (FunctionTypeID) obj;
-		return this.header.returnType == other.header.returnType
+		return this.header.getReturnType() == other.header.getReturnType()
 				&& Arrays.deepEquals(this.header.parameters, other.header.parameters)
 				&& Arrays.deepEquals(this.header.typeParameters, other.header.typeParameters);
 	}
 		}
 		result.append(')');
 		result.append(" as ");
-		result.append(header.returnType);
+		result.append(header.getReturnType());
 		return result.toString();
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GlobalTypeRegistry.java

 		arrayTypes.put(ArrayTypeID.CHAR, ArrayTypeID.CHAR);
 		
 		rangeTypes.put(RangeTypeID.INT, RangeTypeID.INT);
+		rangeTypes.put(RangeTypeID.USIZE, RangeTypeID.USIZE);
 	}
 	
 	public ArrayTypeID getArray(ITypeID baseType, int dimension) {
 		}
 	}
 	
-	public RangeTypeID getRange(ITypeID from, ITypeID to) {
-		RangeTypeID id = new RangeTypeID(this, from, to);
+	public RangeTypeID getRange(ITypeID type) {
+		RangeTypeID id = new RangeTypeID(this, type);
 		if (rangeTypes.containsKey(id)) {
 			return rangeTypes.get(id);
 		} else {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ITypeID.java

 				if (functionType.header.parameters.length != function.header.parameters.length)
 					return false;
 				
-				if (!match(functionType.header.returnType, function.header.returnType))
+				if (!match(functionType.header.getReturnType(), function.header.getReturnType()))
 					return false;
 				
 				for (int i = 0; i < function.header.parameters.length; i++) {
 		public Boolean visitRange(RangeTypeID range) {
 			if (type instanceof RangeTypeID) {
 				RangeTypeID rangeType = (RangeTypeID) type;
-				return match(rangeType.from, range.from) && match(rangeType.to, range.to);
+				return match(rangeType.baseType, range.baseType);
 			} else {
 				return false;
 			}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/RangeTypeID.java

  * @author Hoofdgebruiker
  */
 public class RangeTypeID implements ITypeID {
-	public static final RangeTypeID INT = new RangeTypeID(null, BasicTypeID.INT, BasicTypeID.INT);
+	public static final RangeTypeID INT = new RangeTypeID(null, BasicTypeID.INT);
+	public static final RangeTypeID USIZE = new RangeTypeID(null, BasicTypeID.USIZE);
 	
-	public final ITypeID from;
-	public final ITypeID to;
+	public final ITypeID baseType;
 	private final RangeTypeID normalized;
 	
-	public RangeTypeID(GlobalTypeRegistry registry, ITypeID from, ITypeID to) {
-		this.from = from;
-		this.to = to;
+	public RangeTypeID(GlobalTypeRegistry registry, ITypeID baseType) {
+		this.baseType = baseType;
 		
-		if (from.getNormalized() == from && to.getNormalized() == to) {
+		if (baseType.getNormalized() == baseType) {
 			normalized = this;
 		} else {
-			normalized = registry.getRange(from.getNormalized(), to.getNormalized());
+			normalized = registry.getRange(baseType.getNormalized());
 		}
 	}
 	
 	
 	@Override
 	public ITypeID instance(GenericMapper mapper) {
-		return mapper.registry.getRange(
-				from.instance(mapper),
-				to.instance(mapper));
+		return mapper.registry.getRange(baseType.instance(mapper));
 	}
 
 	@Override
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
-		return from.hasInferenceBlockingTypeParameters(parameters) || to.hasInferenceBlockingTypeParameters(parameters);
+		return baseType.hasInferenceBlockingTypeParameters(parameters);
 	}
 
 	@Override
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		from.extractTypeParameters(typeParameters);
-		to.extractTypeParameters(typeParameters);
+		baseType.extractTypeParameters(typeParameters);
 	}
 
 	@Override
 	public int hashCode() {
 		int hash = 5;
-		hash = 89 * hash + from.hashCode();
-		hash = 89 * hash + to.hashCode();
+		hash = 89 * hash + baseType.hashCode();
 		return hash;
 	}
 
 			return false;
 		}
 		final RangeTypeID other = (RangeTypeID) obj;
-		return this.from == other.from && this.to == other.to;
+		return this.baseType == other.baseType;
 	}
 	
 	@Override
 	public String toString() {
-		return from.toString() + " .. " + to.toString();
+		return baseType.toString() + " .. " + baseType.toString();
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeParameterCollector.java

 
 	@Override
 	public Void visitFunction(FunctionTypeID function) {
-		function.header.returnType.accept(this);
+		function.header.getReturnType().accept(this);
 		for (FunctionParameter parameter : function.header.parameters)
 			parameter.type.accept(this);
 		return null;
 
 	@Override
 	public Void visitRange(RangeTypeID range) {
-		range.from.accept(this);
-		range.to.accept(this);
+		range.baseType.accept(this);
 		return null;
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/BuiltinID.java

 	BYTE_TO_UINT,
 	BYTE_TO_LONG,
 	BYTE_TO_ULONG,
+	BYTE_TO_USIZE,
 	BYTE_TO_FLOAT,
 	BYTE_TO_DOUBLE,
 	BYTE_TO_CHAR,
 	SBYTE_TO_UINT,
 	SBYTE_TO_LONG,
 	SBYTE_TO_ULONG,
+	SBYTE_TO_USIZE,
 	SBYTE_TO_FLOAT,
 	SBYTE_TO_DOUBLE,
 	SBYTE_TO_CHAR,
 	SHORT_TO_UINT,
 	SHORT_TO_LONG,
 	SHORT_TO_ULONG,
+	SHORT_TO_USIZE,
 	SHORT_TO_FLOAT,
 	SHORT_TO_DOUBLE,
 	SHORT_TO_CHAR,
 	USHORT_TO_UINT,
 	USHORT_TO_LONG,
 	USHORT_TO_ULONG,
+	USHORT_TO_USIZE,
 	USHORT_TO_FLOAT,
 	USHORT_TO_DOUBLE,
 	USHORT_TO_CHAR,
 	INT_TO_UINT,
 	INT_TO_LONG,
 	INT_TO_ULONG,
+	INT_TO_USIZE,
 	INT_TO_FLOAT,
 	INT_TO_DOUBLE,
 	INT_TO_CHAR,
 	UINT_TO_INT,
 	UINT_TO_LONG,
 	UINT_TO_ULONG,
+	UINT_TO_USIZE,
 	UINT_TO_FLOAT,
 	UINT_TO_DOUBLE,
 	UINT_TO_CHAR,
 	LONG_TO_INT,
 	LONG_TO_UINT,
 	LONG_TO_ULONG,
+	LONG_TO_USIZE,
 	LONG_TO_FLOAT,
 	LONG_TO_DOUBLE,
 	LONG_TO_CHAR,
 	ULONG_TO_INT,
 	ULONG_TO_UINT,
 	ULONG_TO_LONG,
+	ULONG_TO_USIZE,
 	ULONG_TO_FLOAT,
 	ULONG_TO_DOUBLE,
 	ULONG_TO_CHAR,
 	ULONG_LOWEST_ZERO_BIT,
 	ULONG_BIT_COUNT,
 	
+	USIZE_NOT,
+	USIZE_INC,
+	USIZE_DEC,
+	USIZE_ADD_USIZE,
+	USIZE_SUB_USIZE,
+	USIZE_MUL_USIZE,
+	USIZE_DIV_USIZE,
+	USIZE_MOD_USIZE,
+	USIZE_AND_USIZE,
+	USIZE_OR_USIZE,
+	USIZE_XOR_USIZE,
+	USIZE_SHL,
+	USIZE_SHR,
+	USIZE_COMPARE,
+	USIZE_TO_BYTE,
+	USIZE_TO_SBYTE,
+	USIZE_TO_SHORT,
+	USIZE_TO_USHORT,
+	USIZE_TO_INT,
+	USIZE_TO_UINT,
+	USIZE_TO_LONG,
+	USIZE_TO_ULONG,
+	USIZE_TO_FLOAT,
+	USIZE_TO_DOUBLE,
+	USIZE_TO_CHAR,
+	USIZE_TO_STRING,
+	USIZE_PARSE,
+	USIZE_PARSE_WITH_BASE,
+	USIZE_GET_MIN_VALUE,
+	USIZE_GET_MAX_VALUE,
+	USIZE_COUNT_LOW_ZEROES,
+	USIZE_COUNT_HIGH_ZEROES,
+	USIZE_COUNT_LOW_ONES,
+	USIZE_COUNT_HIGH_ONES,
+	USIZE_HIGHEST_ONE_BIT,
+	USIZE_LOWEST_ONE_BIT,
+	USIZE_HIGHEST_ZERO_BIT,
+	USIZE_LOWEST_ZERO_BIT,
+	USIZE_BIT_COUNT,
+	USIZE_BITS,
+	
 	FLOAT_NEG,
 	FLOAT_INC,
 	FLOAT_DEC,
 	FLOAT_TO_UINT,
 	FLOAT_TO_LONG,
 	FLOAT_TO_ULONG,
+	FLOAT_TO_USIZE,
 	FLOAT_TO_DOUBLE,
 	FLOAT_TO_STRING,
 	FLOAT_BITS,
 	DOUBLE_TO_UINT,
 	DOUBLE_TO_LONG,
 	DOUBLE_TO_ULONG,
+	DOUBLE_TO_USIZE,
 	DOUBLE_TO_FLOAT,
 	DOUBLE_TO_STRING,
 	DOUBLE_BITS,
 	CHAR_TO_UINT,
 	CHAR_TO_LONG,
 	CHAR_TO_ULONG,
+	CHAR_TO_USIZE,
 	CHAR_TO_STRING,
 	CHAR_GET_MIN_VALUE,
 	CHAR_GET_MAX_VALUE,
 	
 	OPTIONAL_IS_NULL,
 	OPTIONAL_IS_NOT_NULL,
-	AUTOOP_NOTEQUALS
+	AUTOOP_NOTEQUALS,
+	
+	ITERATOR_INT_RANGE,
+	ITERATOR_ARRAY_VALUES,
+	ITERATOR_ARRAY_KEY_VALUES,
+	ITERATOR_ASSOC_KEYS,
+	ITERATOR_ASSOC_KEY_VALUES,
+	ITERATOR_STRING_CHARS
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/DefinitionMemberGroup.java

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.ConstExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 			if (header.typeParameters != null) {
 				for (ITypeID resultHint : typeHints) {
 					Map<TypeParameter, ITypeID> mapping = new HashMap<>();
-					if (header.returnType.inferTypeParameters(scope.getMemberCache(), resultHint, mapping)) {
-						header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(mapping));
+					if (header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint, mapping)) {
+						header = header.withGenericArguments(scope.getTypeRegistry(), scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), mapping));
 						break;
 					}
 				}
 				throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "This type has no " + name);
 			}
 			
-			outer: for (TypeMember<FunctionalMemberRef> method : methods) {
+			for (TypeMember<FunctionalMemberRef> method : methods) {
 				if (!(method.member.isStatic() ? allowStatic : allowNonStatic)) {
 					message.append(method.member.isStatic() ? "Method must not be static" : "Method must be static").append('\n');
 					continue;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberBuilder.java

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.MethodMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
-import org.openzen.zenscript.codemodel.member.builtin.ArrayIteratorKeyValues;
-import org.openzen.zenscript.codemodel.member.builtin.ArrayIteratorValues;
-import org.openzen.zenscript.codemodel.member.builtin.AssocIterator;
-import org.openzen.zenscript.codemodel.member.builtin.RangeIterator;
-import org.openzen.zenscript.codemodel.member.builtin.StringCharIterator;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.TranslatedOperatorMemberRef;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
 
 /**
  *
 			case ULONG:
 				visitULong();
 				break;
+			case USIZE:
+				visitUSize();
+				break;
 			case FLOAT:
 				visitFloat();
 				break;
 
 		FunctionParameter[] indexGetParameters = new FunctionParameter[dimension];
 		for (int i = 0; i < indexGetParameters.length; i++)
-			indexGetParameters[i] = new FunctionParameter(INT);
+			indexGetParameters[i] = new FunctionParameter(USIZE);
 		
 		operator(
 				definition,
 				ARRAY_INDEXGET);
 		
 		if (dimension == 1) {
-			FunctionHeader sliceHeader = new FunctionHeader(array, new FunctionParameter(cache.getRegistry().getRange(INT, INT), "range"));
+			FunctionHeader sliceHeader = new FunctionHeader(array, new FunctionParameter(RangeTypeID.USIZE, "range"));
 			operator(
 					definition,
 					OperatorType.INDEXGET,
 
 		FunctionParameter[] initialValueConstructorParameters = new FunctionParameter[dimension + 1];
 		for (int i = 0; i < dimension; i++)
-			initialValueConstructorParameters[i] = new FunctionParameter(INT);
+			initialValueConstructorParameters[i] = new FunctionParameter(USIZE);
 		initialValueConstructorParameters[dimension] = new FunctionParameter(baseType);
 		FunctionHeader initialValueConstructorHeader = new FunctionHeader(VOID, initialValueConstructorParameters);
 		new ConstructorMember(
 		
 		FunctionParameter[] lambdaConstructorParameters = new FunctionParameter[dimension + 1];
 		for (int i = 0; i < dimension; i++)
-			lambdaConstructorParameters[i] = new FunctionParameter(INT, null);
+			lambdaConstructorParameters[i] = new FunctionParameter(USIZE, null);
 		
 		FunctionHeader lambdaConstructorFunction = new FunctionHeader(baseType, indexGetParameters);
 		lambdaConstructorParameters[dimension] = new FunctionParameter(cache.getRegistry().getFunction(lambdaConstructorFunction), null);
 			TypeParameter mappedConstructorParameter = new TypeParameter(BUILTIN, "T");
 			FunctionParameter[] projectionParameters = new FunctionParameter[dimension + 1];
 			for (int i = 0; i < dimension; i++)
-				projectionParameters[i] = new FunctionParameter(INT);
+				projectionParameters[i] = new FunctionParameter(USIZE);
 			projectionParameters[dimension] = new FunctionParameter(registry.getGeneric(mappedConstructorParameter));
 			
 			FunctionHeader mappedConstructorHeaderWithIndex = new FunctionHeader(baseType, projectionParameters);
 		
 		FunctionParameter[] indexSetParameters = new FunctionParameter[dimension + 1];
 		for (int i = 0; i < dimension; i++)
-			indexSetParameters[i] = new FunctionParameter(INT, null);
+			indexSetParameters[i] = new FunctionParameter(USIZE, null);
 		indexSetParameters[dimension] = new FunctionParameter(baseType, null);
 
 		FunctionHeader indexSetHeader = new FunctionHeader(VOID, indexSetParameters);
 		operator(definition, OperatorType.INDEXSET, indexSetHeader, ARRAY_INDEXSET);
 		
 		if (dimension == 1) {
-			getter(definition, ARRAY_LENGTH, "length", INT);
+			getter(definition, ARRAY_LENGTH, "length", USIZE);
 		}
 
 		getter(definition, ARRAY_ISEMPTY, "isEmpty", BOOL);
 		getter(definition, ARRAY_HASHCODE, "objectHashCode", INT);
-		new ArrayIteratorKeyValues(array).registerTo(members, TypeMemberPriority.SPECIFIED, null);
-		new ArrayIteratorValues(array).registerTo(members, TypeMemberPriority.SPECIFIED, null);
+		iterator(definition, ITERATOR_ARRAY_VALUES, baseType);
+		iterator(definition, ITERATOR_ARRAY_KEY_VALUES, USIZE, baseType);
 		
 		equals(definition, ARRAY_EQUALS, array);
 		notequals(definition, ARRAY_NOTEQUALS, array);
 				new FunctionHeader(BOOL, new FunctionParameter(keyType, "key")),
 				ASSOC_CONTAINS);
 		
-		getter(builtin, BuiltinID.ASSOC_SIZE, "size", INT);
+		getter(builtin, BuiltinID.ASSOC_SIZE, "size", USIZE);
 		getter(builtin, BuiltinID.ASSOC_ISEMPTY, "isEmpty", BOOL);
 		getter(builtin, BuiltinID.ASSOC_KEYS, "keys", cache.getRegistry().getArray(keyType, 1));
 		getter(builtin, BuiltinID.ASSOC_VALUES, "values", cache.getRegistry().getArray(valueType, 1));
 		getter(builtin, BuiltinID.ASSOC_HASHCODE, "objectHashCode", BasicTypeID.INT);
 		
-		new AssocIterator(assoc).registerTo(members, TypeMemberPriority.SPECIFIED, null);
+		iterator(builtin, ITERATOR_ASSOC_KEYS, keyType);
+		iterator(builtin, ITERATOR_ASSOC_KEY_VALUES, keyType, valueType);
 		
 		equals(builtin, BuiltinID.ASSOC_EQUALS, assoc);
 		notequals(builtin, BuiltinID.ASSOC_NOTEQUALS, assoc);
 		method(builtin, "contains", containsHeader, GENERICMAP_CONTAINS);
 		method(builtin, "addAll", new FunctionHeader(VOID, map), GENERICMAP_ADDALL);
 		
-		getter(builtin, GENERICMAP_SIZE, "size", INT);
+		getter(builtin, GENERICMAP_SIZE, "size", USIZE);
 		getter(builtin, GENERICMAP_ISEMPTY, "isEmpty", BOOL);
 		getter(builtin, GENERICMAP_HASHCODE, "objectHashCode", INT);
 		
 		if (definition instanceof VariantDefinition) {
 			VariantDefinition variant = (VariantDefinition) definition;
 			for (VariantDefinition.Option option : variant.options)
-				members.addVariantOption(option.instance(mapper));
+				members.addVariantOption(option.instance(type, mapper));
 		}
 		
 		if (definition instanceof EnumDefinition) {
 		
 		if (definition instanceof EnumDefinition) {
 			getter(definition, ENUM_NAME, "name", STRING);
-			getter(definition, ENUM_ORDINAL, "ordinal", INT);
+			getter(definition, ENUM_ORDINAL, "ordinal", USIZE);
 			
 			List<EnumConstantMember> enumConstants = ((EnumDefinition) definition).enumConstants;
 			Expression[] constValues = new Expression[enumConstants.size()];
 
 	@Override
 	public Void visitRange(RangeTypeID range) {
-		ITypeID fromType = range.from;
-		ITypeID toType = range.to;
+		ITypeID baseType = range.baseType;
 
 		ClassDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
-		getter(definition, RANGE_FROM, "from", fromType);
-		getter(definition, RANGE_TO, "to", toType);
-		if (range.from == range.to && (range.from == BasicTypeID.BYTE
-				|| range.from == SBYTE
-				|| range.from == SHORT
-				|| range.from == USHORT
-				|| range.from == INT
-				|| range.from == UINT
-				|| range.from == LONG
-				|| range.from == ULONG)) {
-			new RangeIterator(range).registerTo(members, TypeMemberPriority.SPECIFIED, null);
+		getter(definition, RANGE_FROM, "from", baseType);
+		getter(definition, RANGE_TO, "to", baseType);
+		if (baseType == BYTE
+				|| baseType == SBYTE
+				|| baseType == SHORT
+				|| baseType == USHORT
+				|| baseType == INT
+				|| baseType == UINT
+				|| baseType == LONG
+				|| baseType == ULONG
+				|| baseType == USIZE) {
+			
+			iterator(definition, ITERATOR_INT_RANGE, baseType);
 		}
 		
 		processType(definition, range);
 		castImplicit(builtin, BYTE_TO_UINT, UINT);
 		castImplicit(builtin, BYTE_TO_LONG, LONG);
 		castImplicit(builtin, BYTE_TO_ULONG, ULONG);
+		castImplicit(builtin, BYTE_TO_USIZE, USIZE);
 		castImplicit(builtin, BYTE_TO_FLOAT, FLOAT);
 		castImplicit(builtin, BYTE_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, BYTE_TO_CHAR, CHAR);
 		castImplicit(builtin, SBYTE_TO_UINT, UINT);
 		castImplicit(builtin, SBYTE_TO_LONG, LONG);
 		castImplicit(builtin, SBYTE_TO_ULONG, ULONG);
+		castImplicit(builtin, SBYTE_TO_USIZE, USIZE);
 		castImplicit(builtin, SBYTE_TO_FLOAT, FLOAT);
 		castImplicit(builtin, SBYTE_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, SBYTE_TO_CHAR, CHAR);
 		castImplicit(builtin, SHORT_TO_UINT, UINT);
 		castImplicit(builtin, SHORT_TO_LONG, LONG);
 		castImplicit(builtin, SHORT_TO_ULONG, ULONG);
+		castImplicit(builtin, SHORT_TO_USIZE, USIZE);
 		castImplicit(builtin, SHORT_TO_FLOAT, FLOAT);
 		castImplicit(builtin, SHORT_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, SHORT_TO_CHAR, CHAR);
 		castImplicit(builtin, USHORT_TO_UINT, UINT);
 		castImplicit(builtin, USHORT_TO_LONG, LONG);
 		castImplicit(builtin, USHORT_TO_ULONG, ULONG);
+		castImplicit(builtin, USHORT_TO_USIZE, USIZE);
 		castImplicit(builtin, USHORT_TO_FLOAT, FLOAT);
 		castImplicit(builtin, USHORT_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, USHORT_TO_CHAR, CHAR);
 		castImplicit(builtin, INT_TO_UINT, UINT);
 		castImplicit(builtin, INT_TO_LONG, LONG);
 		castImplicit(builtin, INT_TO_ULONG, ULONG);
+		castImplicit(builtin, INT_TO_USIZE, USIZE);
 		castImplicit(builtin, INT_TO_FLOAT, FLOAT);
 		castImplicit(builtin, INT_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, INT_TO_CHAR, CHAR);
 		castImplicit(builtin, UINT_TO_INT, INT);
 		castImplicit(builtin, UINT_TO_LONG, LONG);
 		castImplicit(builtin, UINT_TO_ULONG, ULONG);
+		castImplicit(builtin, UINT_TO_USIZE, USIZE);
 		castImplicit(builtin, UINT_TO_FLOAT, FLOAT);
 		castImplicit(builtin, UINT_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, UINT_TO_CHAR, CHAR);
 		castExplicit(builtin, LONG_TO_INT, INT);
 		castExplicit(builtin, LONG_TO_UINT, UINT);
 		castImplicit(builtin, LONG_TO_ULONG, ULONG);
+		castExplicit(builtin, LONG_TO_USIZE, USIZE);
 		castImplicit(builtin, LONG_TO_FLOAT, FLOAT);
 		castImplicit(builtin, LONG_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, LONG_TO_CHAR, CHAR);
 		castExplicit(builtin, ULONG_TO_INT, INT);
 		castExplicit(builtin, ULONG_TO_UINT, UINT);
 		castImplicit(builtin, ULONG_TO_LONG, LONG);
+		castExplicit(builtin, ULONG_TO_USIZE, USIZE);
 		castImplicit(builtin, ULONG_TO_FLOAT, FLOAT);
 		castImplicit(builtin, ULONG_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, ULONG_TO_CHAR, CHAR);
 		processType(builtin, ULONG);
 	}
 	
+	private void visitUSize() {
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "usize", Modifiers.EXPORT, null);
+		
+		invert(builtin, USIZE_NOT, USIZE);
+		inc(builtin, USIZE_DEC, USIZE);
+		dec(builtin, USIZE_INC, USIZE);
+
+		add(builtin, USIZE_ADD_USIZE, USIZE, USIZE);
+		add(builtin, ULONG_ADD_ULONG, ULONG, ULONG, USIZE_TO_ULONG);
+		add(builtin, FLOAT_ADD_FLOAT, FLOAT, FLOAT, USIZE_TO_FLOAT);
+		add(builtin, DOUBLE_ADD_DOUBLE, DOUBLE, DOUBLE, USIZE_TO_DOUBLE);
+		
+		sub(builtin, USIZE_SUB_USIZE, USIZE, USIZE);
+		sub(builtin, ULONG_SUB_ULONG, ULONG, ULONG, USIZE_TO_ULONG);
+		sub(builtin, FLOAT_SUB_FLOAT, FLOAT, FLOAT, USIZE_TO_FLOAT);
+		sub(builtin, DOUBLE_SUB_DOUBLE, DOUBLE, DOUBLE, USIZE_TO_DOUBLE);
+		
+		mul(builtin, USIZE_MUL_USIZE, USIZE, USIZE);
+		mul(builtin, ULONG_MUL_ULONG, ULONG, ULONG, USIZE_TO_ULONG);
+		mul(builtin, FLOAT_MUL_FLOAT, FLOAT, FLOAT, USIZE_TO_FLOAT);
+		mul(builtin, DOUBLE_MUL_DOUBLE, DOUBLE, DOUBLE, USIZE_TO_DOUBLE);
+		
+		div(builtin, USIZE_DIV_USIZE, USIZE, USIZE);
+		div(builtin, ULONG_DIV_ULONG, ULONG, ULONG, USIZE_TO_ULONG);
+		div(builtin, FLOAT_DIV_FLOAT, FLOAT, FLOAT, USIZE_TO_FLOAT);
+		div(builtin, DOUBLE_DIV_DOUBLE, DOUBLE, DOUBLE, USIZE_TO_DOUBLE);
+		
+		mod(builtin, USIZE_MOD_USIZE, USIZE, USIZE);
+		
+		or(builtin, USIZE_OR_USIZE, USIZE, USIZE);
+		and(builtin, USIZE_AND_USIZE, USIZE, USIZE);
+		xor(builtin, USIZE_XOR_USIZE, USIZE, USIZE);
+		
+		shl(builtin, USIZE_SHL, INT, USIZE);
+		shr(builtin, USIZE_SHR, INT, USIZE);
+		
+		compare(builtin, USIZE_COMPARE, USIZE);
+		compare(builtin, ULONG_COMPARE, ULONG, USIZE_TO_ULONG);
+		compare(builtin, FLOAT_COMPARE, FLOAT, USIZE_TO_FLOAT);
+		compare(builtin, DOUBLE_COMPARE, DOUBLE, USIZE_TO_DOUBLE);
+		
+		constant(builtin, USIZE_GET_MIN_VALUE, "MIN_VALUE", new ConstantUSizeExpression(BUILTIN, 0));
+		constant(builtin, USIZE_GET_MAX_VALUE, "MAX_VALUE", new ConstantUSizeExpression(BUILTIN, -2L));
+		constant(builtin, USIZE_BITS, "BITS", new ConstantUSizeExpression(BUILTIN, 32));
+		
+		castExplicit(builtin, USIZE_TO_BYTE, BYTE);
+		castExplicit(builtin, USIZE_TO_SBYTE, SBYTE);
+		castExplicit(builtin, USIZE_TO_SHORT, SHORT);
+		castExplicit(builtin, USIZE_TO_USHORT, USHORT);
+		castExplicit(builtin, USIZE_TO_INT, INT);
+		castExplicit(builtin, USIZE_TO_UINT, UINT);
+		castImplicit(builtin, USIZE_TO_LONG, LONG);
+		castImplicit(builtin, USIZE_TO_ULONG, ULONG);
+		castImplicit(builtin, USIZE_TO_FLOAT, FLOAT);
+		castImplicit(builtin, USIZE_TO_DOUBLE, DOUBLE);
+		castExplicit(builtin, USIZE_TO_CHAR, CHAR);
+		castImplicit(builtin, USIZE_TO_STRING, STRING);
+		
+		staticMethod(builtin, USIZE_PARSE, "parse", USIZE, STRING);
+		staticMethod(builtin, USIZE_PARSE_WITH_BASE, "parse", USIZE, STRING, INT);
+		
+		method(builtin, USIZE_COUNT_LOW_ZEROES, "countLowZeroes", INT);
+		method(builtin, USIZE_COUNT_HIGH_ZEROES, "countHighZeroes", INT);
+		method(builtin, USIZE_COUNT_LOW_ONES, "countLowOnes", INT);
+		method(builtin, USIZE_COUNT_HIGH_ONES, "countHighOnes", INT);
+		
+		ITypeID optionalInt = registry.getOptional(INT);
+		getter(builtin, USIZE_HIGHEST_ONE_BIT, "highestOneBit", optionalInt);
+		getter(builtin, USIZE_LOWEST_ONE_BIT, "lowestOneBit", optionalInt);
+		getter(builtin, USIZE_HIGHEST_ZERO_BIT, "highestZeroBit", optionalInt);
+		getter(builtin, USIZE_LOWEST_ZERO_BIT, "lowestZeroBit", optionalInt);
+		getter(builtin, USIZE_BIT_COUNT, "bitCount", INT);
+		
+		processType(builtin, USIZE);
+	}
+	
 	private void visitFloat() {
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "float", Modifiers.EXPORT, null);
 		
 		castExplicit(builtin, FLOAT_TO_USHORT, USHORT);
 		castExplicit(builtin, FLOAT_TO_INT, INT);
 		castExplicit(builtin, FLOAT_TO_UINT, UINT);
+		castExplicit(builtin, FLOAT_TO_LONG, LONG);
 		castExplicit(builtin, FLOAT_TO_ULONG, ULONG);
-		castExplicit(builtin, FLOAT_TO_ULONG, ULONG);
+		castExplicit(builtin, FLOAT_TO_USIZE, USIZE);
 		castImplicit(builtin, FLOAT_TO_DOUBLE, DOUBLE);
 		castImplicit(builtin, FLOAT_TO_STRING, STRING);
 		
 		staticMethod(builtin, FLOAT_PARSE, "parse", FLOAT, STRING);
-		staticMethod(builtin, FLOAT_FROM_BITS, "fromBits", FLOAT, INT);
+		staticMethod(builtin, FLOAT_FROM_BITS, "fromBits", FLOAT, UINT);
 		
-		getter(builtin, FLOAT_BITS, "bits", INT);
+		getter(builtin, FLOAT_BITS, "bits", UINT);
 		
 		processType(builtin, FLOAT);
 	}
 		castExplicit(builtin, DOUBLE_TO_UINT, UINT);
 		castExplicit(builtin, DOUBLE_TO_ULONG, ULONG);
 		castExplicit(builtin, DOUBLE_TO_ULONG, ULONG);
+		castExplicit(builtin, DOUBLE_TO_USIZE, USIZE);
 		castImplicit(builtin, DOUBLE_TO_FLOAT, FLOAT);
 		castImplicit(builtin, DOUBLE_TO_STRING, STRING);
 		
 		staticMethod(builtin, DOUBLE_PARSE, "parse", DOUBLE, STRING);
-		staticMethod(builtin, DOUBLE_FROM_BITS, "fromBits", DOUBLE, LONG);
+		staticMethod(builtin, DOUBLE_FROM_BITS, "fromBits", DOUBLE, ULONG);
 		
-		getter(builtin, DOUBLE_BITS, "bits", LONG);
+		getter(builtin, DOUBLE_BITS, "bits", ULONG);
 		
 		processType(builtin, DOUBLE);
 	}
 		castImplicit(builtin, CHAR_TO_UINT, UINT);
 		castImplicit(builtin, CHAR_TO_LONG, LONG);
 		castImplicit(builtin, CHAR_TO_ULONG, ULONG);
+		castImplicit(builtin, CHAR_TO_USIZE, USIZE);
 		castImplicit(builtin, CHAR_TO_STRING, STRING);
 		
 		getter(builtin, CHAR_GET_MIN_VALUE, "MIN_VALUE", CHAR);
 		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, registry.getArray(CHAR, 1));
 		
 		add(builtin, STRING_ADD_STRING, STRING, STRING);
-		indexGet(builtin, STRING_INDEXGET, INT, CHAR);
-		indexGet(builtin, STRING_RANGEGET, registry.getRange(INT, INT), STRING);
+		indexGet(builtin, STRING_INDEXGET, USIZE, CHAR);
+		indexGet(builtin, STRING_RANGEGET, RangeTypeID.USIZE, STRING);
 		compare(builtin, STRING_COMPARE, STRING);
 		
-		getter(builtin, STRING_LENGTH, "length", INT);
+		getter(builtin, STRING_LENGTH, "length", USIZE);
 		getter(builtin, STRING_CHARACTERS, "characters", registry.getArray(CHAR, 1));
 		getter(builtin, STRING_ISEMPTY, "isEmpty", BOOL);
 
 		method(builtin, STRING_TO_LOWER_CASE, "toLowerCase", STRING);
 		method(builtin, STRING_TO_UPPER_CASE, "toUpperCase", STRING);
 		
-		new StringCharIterator().registerTo(members, TypeMemberPriority.SPECIFIED, null);
+		iterator(builtin, ITERATOR_STRING_CHARS, CHAR);
 		
 		processType(builtin, STRING);
 	}
 				new FunctionHeader(BOOL, new FunctionParameter(type)),
 				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
+	
+	private void iterator(HighLevelDefinition cls, BuiltinID builtin, ITypeID... types) {
+		new IteratorMember(BUILTIN, cls, Modifiers.PUBLIC, types, registry, builtin)
+				.registerTo(members, TypeMemberPriority.SPECIFIED, null);
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMembers.java

 import org.openzen.zenscript.codemodel.partial.PartialMemberGroupExpression;
 import org.openzen.zenscript.codemodel.partial.PartialStaticMemberGroupExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
+import org.openzen.zenscript.codemodel.partial.PartialVariantOptionExpression;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 			return new PartialStaticMemberGroupExpression(position, scope, type, members.get(name.name), name.arguments);
 		if (innerTypes.containsKey(name.name))
 			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type), name.arguments);
+		if (variantOptions.containsKey(name.name))
+			return new PartialVariantOptionExpression(position, scope, variantOptions.get(name.name));
 		
 		return null;
 	}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleSpace.java → CompilerShared/src/main/java/org/openzen/zenscript/compiler/ModuleSpace.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.constructor.module;
+package org.openzen.zenscript.compiler;
 
 import org.openzen.zenscript.compiler.SemanticModule;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.annotations.NativeAnnotationDefinition;
 import org.openzen.zenscript.codemodel.annotations.PreconditionAnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
-import org.openzen.zenscript.constructor.ConstructorException;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 
 /**
 		
 		for (Map.Entry<String, ISymbol> globalEntry : dependency.globals.entrySet()) {
 			if (globals.containsKey(globalEntry.getKey()))
-				throw new ConstructorException("Duplicate global: " + globalEntry.getKey());
+				throw new CompileException(CodePosition.META, CompileExceptionCode.DUPLICATE_GLOBAL, "Duplicate global: " + globalEntry.getKey());
 			
 			globals.put(globalEntry.getKey(), globalEntry.getValue());
 		}

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java

 import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 import java.util.function.Consumer;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.json.JSONTokener;
 import org.openzen.zencode.shared.CompileException;
-import org.openzen.zenscript.codemodel.PackageDefinitions;
-import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
-import org.openzen.zenscript.codemodel.context.ModuleTypeResolutionContext;
-import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.constructor.module.ModuleSpace;
-import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.ParsedFile;
-import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 			}
 		}
 	}
-	
-	public static SemanticModule compileSyntaxToSemantic(
-			String name,
-			SemanticModule[] dependencies,
-			CompilingPackage pkg,
-			ParsedFile[] files,
-			ModuleSpace registry,
-			Consumer<CompileException> exceptionLogger) {
-		// We are considering all these files to be in the same package, so make
-		// a single PackageDefinition instance. If these files were in multiple
-		// packages, we'd need an instance for every package.
-		PackageDefinitions definitions = new PackageDefinitions();
-		for (ParsedFile file : files) {
-			// listDefinitions will merely register all definitions (classes,
-			// interfaces, functions ...) so they can later be available to
-			// the other files as well. It doesn't yet compile anything.
-			file.listDefinitions(definitions);
-		}
-		
-		ZSPackage rootPackage = registry.collectPackages();
-		List<ExpansionDefinition> expansions = registry.collectExpansions();
-		definitions.registerExpansionsTo(expansions);
-		
-		Map<String, ISymbol> globals = registry.collectGlobals();
-		boolean failed = false;
-		
-		ModuleTypeResolutionContext moduleContext = new ModuleTypeResolutionContext(
-				registry.compilationUnit.globalTypeRegistry,
-				registry.getAnnotations(),
-				rootPackage,
-				pkg,
-				globals);
-		
-		for (ParsedFile file : files) {
-			file.registerTypes(moduleContext, rootPackage, pkg);
-		}
-		
-		for (ParsedFile file : files) {
-			// compileMembers will register all definition members to their
-			// respective definitions, such as fields, constructors, methods...
-			// It doesn't yet compile the method contents.
-			try {
-				file.compileTypes(moduleContext, rootPackage, pkg);
-			} catch (CompileException ex) {
-				exceptionLogger.accept(ex);
-				failed = true;
-			}
-		}
-		
-		if (failed)
-			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
-		
-		// scripts will store all the script blocks encountered in the files
-		PrecompilationState precompiler = new PrecompilationState();
-		for (ParsedFile file : files) {
-			file.registerMembers(moduleContext, precompiler, rootPackage, pkg, expansions, globals);
-		}
-		
-		List<ScriptBlock> scripts = new ArrayList<>();
-		for (ParsedFile file : files) {
-			// compileCode will convert the parsed statements and expressions
-			// into semantic code. This semantic code can then be compiled
-			// to various targets.
-			try {
-				file.compileCode(moduleContext, precompiler, rootPackage, pkg, expansions, scripts, globals);
-			} catch (CompileException ex) {
-				exceptionLogger.accept(ex);
-				failed = true;
-			}
-		}
-		
-		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg.getPackage(), definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
-	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

  */
 package org.openzen.zenscript.constructor.module;
 
+import org.openzen.zenscript.compiler.ModuleSpace;
 import org.openzen.zenscript.compiler.SemanticModule;
 import java.io.File;
 import java.io.IOException;
 			CompilingPackage compilingPackage = new CompilingPackage(pkg);
 			
 			ParsedFile[] parsedFiles = module.parse(compilingPackage);
-			SemanticModule result = Module.compileSyntaxToSemantic(module.name, dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
+			SemanticModule result = ParsedFile.compileSyntaxToSemantic(module.name, dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalTarget.java

 			if (compiledModules.contains(dependency.name))
 				continue;
 			compiledModules.add(dependency.name);
-			System.out.println("== Compiling module " + dependency + " ==");
+			System.out.println("== Compiling module " + dependency.name + " ==");
 			
 			if (compilingModules.contains(dependency.name)) {
 				StringBuilder message = new StringBuilder("Circular dependency:\n");

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourceEditor.java

 				case K_UINT:
 				case K_LONG:
 				case K_ULONG:
+				case K_USIZE:
 				case K_FLOAT:
 				case K_DOUBLE:
 				case K_CHAR:

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/implementations/IntRange.java

-package org.openzen.zenscript.implementations;
-
-public class IntRange {
-	public final int from;
-	public final int to;
-
-
-	public IntRange(int from, int to) {
-		this.from = from;
-		this.to = to;
-	}
-}

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import java.util.HashMap;
+import java.util.Map;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
-import org.openzen.zenscript.javabytecode.compiler.CompilerUtils;
+import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaContext;
+import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaSynthesizedClass;
+import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
 import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
 import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
 import org.openzen.zenscript.javashared.JavaTypeInternalNameVisitor;
 	private final TypeGenerator typeGenerator;
 	private final JavaTypeInternalNameVisitor internalNameVisitor;
 	private final JavaTypeDescriptorVisitor descriptorVisitor;
+	private final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
+	private final Map<String, JavaSynthesizedClass> ranges = new HashMap<>();
+	private int lambdaCounter = 0;
 	
 	public JavaBytecodeContext(JavaModule module) {
 		this.module = module;
 	public void register(String name, byte[] bytecode) {
 		module.register(name, bytecode);
 	}
+
+    private JavaSynthesizedClass getLambdaInterface(FunctionTypeID function) {
+		String signature = JavaSynthesizedClassNamer.getFunctionSignature(function);
+		if (functions.containsKey(signature))
+			return functions.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(function));
+		
+		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createFunctionName(function);
+		functions.put(signature, result);
+		
+        createLambdaInterface(function.header, result.cls);
+        return result;
+    }
+	
+	private JavaSynthesizedClass getRangeType(RangeTypeID type) {
+		String signature = JavaSynthesizedClassNamer.getRangeSignature(type);
+		if (ranges.containsKey(signature))
+			return ranges.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(type));
+		
+		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createRangeName(type);
+		ranges.put(signature, result);
+		
+		createRangeClass(type.baseType, result.cls);
+		return result;
+	}
+
+    private void createLambdaInterface(FunctionHeader header, JavaClass cls) {
+        ClassWriter ifaceWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+        ifaceWriter.visitAnnotation("java/lang/FunctionalInterface", true).visitEnd();
+        ifaceWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, cls.internalName, null, "java/lang/Object", null);
+
+        ifaceWriter
+				.visitMethod(
+					Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT,
+					"accept",
+					getMethodDescriptor(header),
+					getMethodSignature(header),
+					null)
+				.visitEnd();
+
+        register(cls.internalName, ifaceWriter.toByteArray());
+    }
+	
+	private void createRangeClass(ITypeID baseType, JavaClass cls) {
+		ClassWriter rangeWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		rangeWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, cls.internalName, null, "java/lang/Object", null);
+		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "from", getDescriptor(baseType), null, null).visitEnd();
+		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(baseType), null, null).visitEnd();
+		
+		JavaMethod method = JavaMethod.getConstructor(cls, "(" + getDescriptor(baseType) + getDescriptor(baseType) + ")V", Opcodes.ACC_PUBLIC);
+		JavaWriter constructorWriter = new JavaWriter(rangeWriter, method, null, method.descriptor, null);
+		constructorWriter.loadObject(0);
+		constructorWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
+		constructorWriter.loadObject(0);
+		constructorWriter.load(getType(baseType), 1);
+		constructorWriter.putField(cls.internalName, "from", getDescriptor(baseType));
+		constructorWriter.loadObject(0);
+		constructorWriter.load(getType(baseType), 2);
+		constructorWriter.putField(cls.internalName, "to", getDescriptor(baseType));
+		constructorWriter.ret();
+		constructorWriter.end();
+		
+		rangeWriter.visitEnd();
+		
+		register(cls.internalName, rangeWriter.toByteArray());
+	}
+
+    public String getLambdaCounter() {
+        return "lambda" + ++lambdaCounter;
+    }
 	
 	private class TypeGenerator implements JavaSyntheticClassGenerator {
 
 		@Override
 		public JavaSynthesizedClass synthesizeFunction(FunctionTypeID type) {
-			return CompilerUtils.getLambdaInterface(JavaBytecodeContext.this, type);
+			return getLambdaInterface(type);
 		}
 
 		@Override
 		public JavaSynthesizedClass synthesizeRange(RangeTypeID type) {
-			throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+			return getRangeType(type);
 		}
 	}
 }

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.javabytecode;
-
-import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
-
-/**
- * @author Hoofdgebruiker
- */
-public interface JavaBytecodeImplementation {
-	void compile(JavaWriter writer);
-}

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.javabytecode;
-
-import org.objectweb.asm.Type;
-import org.openzen.zenscript.javashared.JavaClass;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaCompileUtils {
-	private JavaCompileUtils() {}
-	
-	public static JavaClass get(Class<?> cls) {
-		return JavaClass.fromInternalName(
-				Type.getInternalName(cls),
-				cls.isInterface() ? JavaClass.Kind.INTERFACE : (cls.isEnum() ? JavaClass.Kind.ENUM : JavaClass.Kind.CLASS));
-	}
-}

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

 
 import java.io.File;
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
 
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 
 	}
 
 	public JavaCompiler(boolean debug, File jarFile) {
-		target = new JavaModule();
+		target = new JavaModule(new File("classes"));
 		this.jarFile = jarFile;
 		this.context = new JavaBytecodeContext(target);
 		
 		finished = true;
 		
 		for (HighLevelDefinition definition : definitions) {
-			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, definition.position.getFilename());
+			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context);
 			definition.accept(memberPreparer);
 		}
 		
 			// convert scripts into methods (add them to a Scripts class?)
 			// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
 			final JavaClassWriter visitor = scriptFile.classWriter;
-			JavaMethodInfo method = new JavaMethodInfo(new JavaClass(script.pkg.fullName, className, JavaClass.Kind.CLASS), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+			JavaMethod method = JavaMethod.getStatic(new JavaClass(script.pkg.fullName, className, JavaClass.Kind.CLASS), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 			scriptFile.scriptMethods.add(method);
 
 			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, new JavaWriter(visitor, method, null, null, null));
 			statementVisitor.end();
 		}
 		
-		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		JavaMethod runMethod = JavaMethod.getStatic(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {
-			for (JavaMethodInfo method : entry.getValue().scriptMethods)
+			for (JavaMethod method : entry.getValue().scriptMethods)
 				runWriter.invokeStatic(method);
 
 			entry.getValue().classWriter.visitEnd();

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.javabytecode;
-
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.openzen.zenscript.javashared.JavaClass;
-
-/**
- * @author Hoofdgebruiker
- */
-public class JavaMethodInfo {
-	public static JavaMethodInfo get(int modifiers, Class owner, String name, Class result, Class... arguments) {
-		StringBuilder descriptor = new StringBuilder();
-		descriptor.append('(');
-		for (Class argument : arguments) {
-			descriptor.append(Type.getDescriptor(argument));
-		}
-		descriptor.append(')');
-		descriptor.append(result == null ? 'V' : Type.getDescriptor(result));
-		return new JavaMethodInfo(JavaCompileUtils.get(owner), name, descriptor.toString(), modifiers);
-	}
-
-	public final JavaClass javaClass;
-	public final String name;
-	public final String descriptor;
-	public final int modifiers;
-
-	public JavaMethodInfo(JavaClass javaClass, String name, String signature, int modifiers) {
-		this.javaClass = javaClass;
-		this.name = name;
-		this.descriptor = signature;
-		this.modifiers = modifiers;
-	}
-
-	public boolean isStatic() {
-		return (modifiers & Opcodes.ACC_STATIC) > 0;
-	}
-}

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

  */
 public class JavaModule {
 	private final Map<String, byte[]> classes = new HashMap<>();
-
+	private final File debugOutput;
+	
 	public JavaModule() {
-
+		debugOutput = null;
 	}
-
+	
+	public JavaModule(File debugOutput) {
+		this.debugOutput = debugOutput;
+		debugOutput.mkdirs();
+	}
+	
 	public void register(String classname, byte[] bytecode) {
 		if (bytecode == null)
 			return;
 		
+		classname = classname.replace('/', '.');
 		classes.put(classname, bytecode);
 		
-		try (FileOutputStream writer = new FileOutputStream(new File(classname.replace('/', '_') + ".class"))) {
-			writer.write(bytecode);
-		} catch (IOException e) {
-			e.printStackTrace();
+		if (debugOutput != null) {
+			try (FileOutputStream writer = new FileOutputStream(new File(debugOutput, classname + ".class"))) {
+				writer.write(bytecode);
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 	}
 

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

 package org.openzen.zenscript.javabytecode.compiler;
 
-import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.Map;
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaSynthesizedClass;
-import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
 
 public class CompilerUtils {
 	private CompilerUtils() {}
 		return out;
 	}
 
-	public static String calcClasName(CodePosition position) {
-		return position.getFilename().substring(0, position.getFilename().lastIndexOf('.')).replace("/", "_");
-	}
-
     public static void tagMethodParameters(JavaBytecodeContext context, FunctionHeader header, boolean isStatic) {
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
-            Type parameterType = context.getType(parameter.type);
+            String parameterType = context.getDescriptor(parameter.type);
             parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
         }
     }
     public static void tagConstructorParameters(JavaBytecodeContext context, FunctionHeader header, boolean isEnum) {
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
-            Type parameterType = context.getType(parameter.type);
+            String parameterType = context.getDescriptor(parameter.type);
             parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
         }
     }
         }
     }
 
-	private static final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
-	
-    public static JavaSynthesizedClass getLambdaInterface(JavaBytecodeContext context, FunctionTypeID function) {
-		String signature = JavaSynthesizedClassNamer.getFunctionSignature(function);
-		if (functions.containsKey(signature))
-			return functions.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(function));
-		
-		System.out.println("Generating function " + signature);
-		
-		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createFunctionName(function);
-		functions.put(signature, result);
-		
-        createLambdaInterface(context, function.header, result.cls);
-        return result;
-    }
-
-    private static void createLambdaInterface(JavaBytecodeContext context, FunctionHeader header, JavaClass cls) {
-        ClassWriter ifaceWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
-        ifaceWriter.visitAnnotation("java/lang/FunctionalInterface", true).visitEnd();
-        ifaceWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, cls.internalName, null, "java/lang/Object", null);
-
-        ifaceWriter
-				.visitMethod(
-					Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT,
-					"accept",
-					context.getMethodDescriptor(header),
-					context.getMethodSignature(header),
-					null)
-				.visitEnd();
-
-        context.register(cls.internalName.replace('/', '.'), ifaceWriter.toByteArray());
-
-        try (FileOutputStream out = new FileOutputStream(cls.getClassName() + ".class")){
-            out.write(ifaceWriter.toByteArray());
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-	private static int lambdaCounter = 0;
-    public static String getLambdaCounter() {
-        return "lambda" + ++lambdaCounter;
-    }
-
 	public static int getKeyForSwitch(SwitchValue expression) {
-		return expression.accept(new SwitchKeyVisitor());
-	}
-
-	private static class SwitchKeyVisitor implements SwitchValueVisitor<Integer> {
-
-		@Override
-		public Integer acceptInt(IntSwitchValue value) {
-			return value.value;
-		}
-
-		@Override
-		public Integer acceptChar(CharSwitchValue value) {
-			return (int) value.value;
-		}
-
-		@Override
-		public Integer acceptString(StringSwitchValue value) {
-			return value.value.hashCode();
-		}
-
-		@Override
-		public Integer acceptEnumConstant(EnumConstantSwitchValue value) {
-			return value.constant.ordinal;
-		}
-
-		@Override
-		public Integer acceptVariantOption(VariantOptionSwitchValue value) {
-			return value.option.getOrdinal();
-		}
+		return expression.accept(JavaSwitchKeyVisitor.INSTANCE);
 	}
 }

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.JavaMethodInfo;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
 
-public class JavaBoxingTypeVisitor implements ITypeVisitor<JavaMethodInfo> {
+public class JavaBoxingTypeVisitor implements ITypeVisitor<Void> {
+	private static final JavaMethod BOOLEAN_VALUEOF = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "valueOf", "(Z)Ljava/lang/Boolean;");
+	private static final JavaMethod BYTE_VALUEOF = JavaMethod.getNativeStatic(JavaClass.BYTE, "valueOf", "(B)Ljava/lang/Byte;");
+	private static final JavaMethod SHORT_VALUEOF = JavaMethod.getNativeStatic(JavaClass.SHORT, "valueOf", "(S)Ljava/lang/Short;");
+	private static final JavaMethod INTEGER_VALUEOF = JavaMethod.getNativeStatic(JavaClass.INTEGER, "valueOf", "(I)Ljava/lang/Integer;");
+	private static final JavaMethod LONG_VALUEOF = JavaMethod.getNativeStatic(JavaClass.LONG, "valueOf", "(J)Ljava/lang/Long;");
+	private static final JavaMethod FLOAT_VALUEOF = JavaMethod.getNativeStatic(JavaClass.FLOAT, "valueOf", "(F)Ljava/lang/Float;");
+	private static final JavaMethod DOUBLE_VALUEOF = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "valueOf", "(D)Ljava/lang/Double;");
+	private static final JavaMethod CHARACTER_VALUEOF = JavaMethod.getNativeStatic(JavaClass.CHARACTER, "valueOf", "(C)Ljava/lang/Character;");
 
 	private final JavaWriter writer;
 
 	}
 
 	@Override
-	public JavaMethodInfo visitBasic(BasicTypeID basic) {
-		final JavaMethodInfo info;
+	public Void visitBasic(BasicTypeID basic) {
+		final JavaMethod method;
 		switch (basic) {
 			case BOOL:
-				writer.newObject(Boolean.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Boolean", JavaClass.Kind.CLASS), "<init>", "(Z)V", -1);
+				method = BOOLEAN_VALUEOF;
 				break;
 			case BYTE:
+				method = INTEGER_VALUEOF;
+				break;
 			case SBYTE:
-				writer.newObject(Byte.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Byte", JavaClass.Kind.CLASS), "<init>", "(B)V", -1);
+				method = BYTE_VALUEOF;
 				break;
 			case SHORT:
+				method = SHORT_VALUEOF;
+				break;
 			case USHORT:
-				writer.newObject(Short.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Short", JavaClass.Kind.CLASS), "<init>", "(S)V", -1);
+				method = INTEGER_VALUEOF;
 				break;
 			case INT:
 			case UINT:
-				writer.newObject(Byte.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Byte", JavaClass.Kind.CLASS), "<init>", "(B)V", -1);
+			case USIZE:
+				method = INTEGER_VALUEOF;
 				break;
 			case LONG:
 			case ULONG:
-				writer.newObject(Long.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Long", JavaClass.Kind.CLASS), "<init>", "(S)V", -1);
+				method = LONG_VALUEOF;
 				break;
 			case FLOAT:
-				writer.newObject(Float.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Float", JavaClass.Kind.CLASS), "<init>", "(F)V", -1);
+				method = FLOAT_VALUEOF;
 				break;
 			case DOUBLE:
-				writer.newObject(Double.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Double", JavaClass.Kind.CLASS), "<init>", "(D)V", -1);
+				method = DOUBLE_VALUEOF;
 				break;
 			case CHAR:
-				writer.newObject(Character.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Character", JavaClass.Kind.CLASS), "<init>", "(C)V", -1);
+				method = CHARACTER_VALUEOF;
 				break;
 			default:
 				return null;
 		}
 		writer.dup();
-		return info;
+		
+		if (method != null)
+			writer.invokeStatic(method);
+		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitArray(ArrayTypeID array) {
+	public Void visitArray(ArrayTypeID array) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitAssoc(AssocTypeID assoc) {
+	public Void visitAssoc(AssocTypeID assoc) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitGenericMap(GenericMapTypeID map) {
+	public Void visitGenericMap(GenericMapTypeID map) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitIterator(IteratorTypeID iterator) {
+	public Void visitIterator(IteratorTypeID iterator) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitFunction(FunctionTypeID function) {
+	public Void visitFunction(FunctionTypeID function) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitDefinition(DefinitionTypeID definition) {
+	public Void visitDefinition(DefinitionTypeID definition) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitGeneric(GenericTypeID generic) {
+	public Void visitGeneric(GenericTypeID generic) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitRange(RangeTypeID range) {
+	public Void visitRange(RangeTypeID range) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitModified(ModifiedTypeID type) {
+	public Void visitModified(ModifiedTypeID type) {
 		//NO-OP
 		return null;
 	}

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.StringJoiner;
 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.implementations.IntRange;
 import org.openzen.zenscript.javabytecode.*;
 
 import java.io.FileOutputStream;
 import java.io.IOException;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaSynthesizedClass;
 import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
+import org.openzen.zenscript.javashared.JavaVariantOption;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 	private static final int PUBLIC = Opcodes.ACC_PUBLIC;
 	private static final int STATIC = Opcodes.ACC_STATIC;
 	private static final int PUBLIC_STATIC = PUBLIC | STATIC;
 
-	private static final JavaMethodInfo BOOLEAN_PARSE = new JavaMethodInfo(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo BOOLEAN_TO_STRING = new JavaMethodInfo(JavaClass.BOOLEAN, "toString", "(Z)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo BYTE_PARSE = new JavaMethodInfo(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;)B", PUBLIC_STATIC);
-	private static final JavaMethodInfo BYTE_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;I)B", PUBLIC_STATIC);
+	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
+	private static final JavaMethod BOOLEAN_TO_STRING = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "toString", "(Z)Ljava/lang/String;");
+	private static final JavaMethod BYTE_PARSE = JavaMethod.getNativeStatic(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;)B");
+	private static final JavaMethod BYTE_PARSE_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;I)B");
 	private static final JavaField BYTE_MIN_VALUE = new JavaField(JavaClass.BYTE, "MIN_VALUE", "B");
 	private static final JavaField BYTE_MAX_VALUE = new JavaField(JavaClass.BYTE, "MAX_VALUE", "B");
-	private static final JavaMethodInfo BYTE_TO_STRING = new JavaMethodInfo(JavaClass.BYTE, "toString", "(B)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo SHORT_PARSE = new JavaMethodInfo(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;)S", PUBLIC_STATIC);
-	private static final JavaMethodInfo SHORT_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;I)S", PUBLIC_STATIC);
+	private static final JavaMethod BYTE_TO_STRING = JavaMethod.getNativeStatic(JavaClass.BYTE, "toString", "(B)Ljava/lang/String;");
+	private static final JavaMethod SHORT_PARSE = JavaMethod.getNativeStatic(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;)S");
+	private static final JavaMethod SHORT_PARSE_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;I)S");
 	private static final JavaField SHORT_MIN_VALUE = new JavaField(JavaClass.SHORT, "MIN_VALUE", "S");
 	private static final JavaField SHORT_MAX_VALUE = new JavaField(JavaClass.SHORT, "MAX_VALUE", "S");
-	private static final JavaMethodInfo SHORT_TO_STRING = new JavaMethodInfo(JavaClass.SHORT, "toString", "(S)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_COMPARE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "compareUnsigned", "(II)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_DIVIDE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "divideUnsigned", "(II)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_REMAINDER_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "remainderUnsigned", "(II)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_NUMBER_OF_TRAILING_ZEROS = new JavaMethodInfo(JavaClass.INTEGER, "numberOfTrailingZeros", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_NUMBER_OF_LEADING_ZEROS = new JavaMethodInfo(JavaClass.INTEGER, "numberOfLeadingZeros", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE = new JavaMethodInfo(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_UNSIGNED_WITH_BASE = new JavaMethodInfo(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_HIGHEST_ONE_BIT = new JavaMethodInfo(JavaClass.INTEGER, "highestOneBit", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_LOWEST_ONE_BIT = new JavaMethodInfo(JavaClass.INTEGER, "lowestOneBit", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_BIT_COUNT = new JavaMethodInfo(JavaClass.INTEGER, "bitCount", "(I)I", PUBLIC_STATIC);
+	private static final JavaMethod SHORT_TO_STRING = JavaMethod.getNativeStatic(JavaClass.SHORT, "toString", "(S)Ljava/lang/String;");
+	private static final JavaMethod INTEGER_COMPARE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.INTEGER, "compareUnsigned", "(II)I");
+	private static final JavaMethod INTEGER_DIVIDE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.INTEGER, "divideUnsigned", "(II)I");
+	private static final JavaMethod INTEGER_REMAINDER_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.INTEGER, "remainderUnsigned", "(II)I");
+	private static final JavaMethod INTEGER_NUMBER_OF_TRAILING_ZEROS = JavaMethod.getNativeStatic(JavaClass.INTEGER, "numberOfTrailingZeros", "(I)I");
+	private static final JavaMethod INTEGER_NUMBER_OF_LEADING_ZEROS = JavaMethod.getNativeStatic(JavaClass.INTEGER, "numberOfLeadingZeros", "(I)I");
+	private static final JavaMethod INTEGER_PARSE = JavaMethod.getNativeStatic(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;)I");
+	private static final JavaMethod INTEGER_PARSE_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;I)I");
+	private static final JavaMethod INTEGER_PARSE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;)I");
+	private static final JavaMethod INTEGER_PARSE_UNSIGNED_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;I)I");
+	private static final JavaMethod INTEGER_HIGHEST_ONE_BIT = JavaMethod.getNativeStatic(JavaClass.INTEGER, "highestOneBit", "(I)I");
+	private static final JavaMethod INTEGER_LOWEST_ONE_BIT = JavaMethod.getNativeStatic(JavaClass.INTEGER, "lowestOneBit", "(I)I");
+	private static final JavaMethod INTEGER_BIT_COUNT = JavaMethod.getNativeStatic(JavaClass.INTEGER, "bitCount", "(I)I");
 	private static final JavaField INTEGER_MIN_VALUE = new JavaField(JavaClass.INTEGER, "MIN_VALUE", "I");
 	private static final JavaField INTEGER_MAX_VALUE = new JavaField(JavaClass.INTEGER, "MAX_VALUE", "I");
-	private static final JavaMethodInfo INTEGER_TO_STRING = new JavaMethodInfo(JavaClass.INTEGER, "toString", "(I)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_TO_UNSIGNED_STRING = new JavaMethodInfo(JavaClass.INTEGER, "toUnsignedString", "(I)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_COMPARE = new JavaMethodInfo(JavaClass.LONG, "compare", "(JJ)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_COMPARE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "compareUnsigned", "(JJ)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_DIVIDE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "divideUnsigned", "(JJ)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_REMAINDER_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "remainderUnsigned", "(JJ)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_NUMBER_OF_TRAILING_ZEROS = new JavaMethodInfo(JavaClass.LONG, "numberOfTrailingZeros", "(J)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_NUMBER_OF_LEADING_ZEROS = new JavaMethodInfo(JavaClass.LONG, "numberOfLeadingZeros", "(J)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE = new JavaMethodInfo(JavaClass.LONG, "parseLong", "(Ljava/lang/String;)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.LONG, "parseLong", "(Ljava/lang/String;I)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_UNSIGNED_WITH_BASE = new JavaMethodInfo(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;I)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_HIGHEST_ONE_BIT = new JavaMethodInfo(JavaClass.LONG, "highestOneBit", "(J)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_LOWEST_ONE_BIT = new JavaMethodInfo(JavaClass.LONG, "lowestOneBit", "(J)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_BIT_COUNT = new JavaMethodInfo(JavaClass.LONG, "bitCount", "(J)I", PUBLIC_STATIC);
+	private static final JavaMethod INTEGER_TO_STRING = JavaMethod.getNativeStatic(JavaClass.INTEGER, "toString", "(I)Ljava/lang/String;");
+	private static final JavaMethod INTEGER_TO_UNSIGNED_STRING = JavaMethod.getNativeStatic(JavaClass.INTEGER, "toUnsignedString", "(I)Ljava/lang/String;");
+	private static final JavaMethod LONG_COMPARE = JavaMethod.getNativeStatic(JavaClass.LONG, "compare", "(JJ)I");
+	private static final JavaMethod LONG_COMPARE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.LONG, "compareUnsigned", "(JJ)I");
+	private static final JavaMethod LONG_DIVIDE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.LONG, "divideUnsigned", "(JJ)J");
+	private static final JavaMethod LONG_REMAINDER_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.LONG, "remainderUnsigned", "(JJ)J");
+	private static final JavaMethod LONG_NUMBER_OF_TRAILING_ZEROS = JavaMethod.getNativeStatic(JavaClass.LONG, "numberOfTrailingZeros", "(J)I");
+	private static final JavaMethod LONG_NUMBER_OF_LEADING_ZEROS = JavaMethod.getNativeStatic(JavaClass.LONG, "numberOfLeadingZeros", "(J)I");
+	private static final JavaMethod LONG_PARSE = JavaMethod.getNativeStatic(JavaClass.LONG, "parseLong", "(Ljava/lang/String;)J");
+	private static final JavaMethod LONG_PARSE_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.LONG, "parseLong", "(Ljava/lang/String;I)J");
+	private static final JavaMethod LONG_PARSE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;)J");
+	private static final JavaMethod LONG_PARSE_UNSIGNED_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;I)J");
+	private static final JavaMethod LONG_HIGHEST_ONE_BIT = JavaMethod.getNativeStatic(JavaClass.LONG, "highestOneBit", "(J)J");
+	private static final JavaMethod LONG_LOWEST_ONE_BIT = JavaMethod.getNativeStatic(JavaClass.LONG, "lowestOneBit", "(J)J");
+	private static final JavaMethod LONG_BIT_COUNT = JavaMethod.getNativeStatic(JavaClass.LONG, "bitCount", "(J)I");
 	private static final JavaField LONG_MIN_VALUE = new JavaField(JavaClass.LONG, "MIN_VALUE", "J");
 	private static final JavaField LONG_MAX_VALUE = new JavaField(JavaClass.LONG, "MAX_VALUE", "J");
-	private static final JavaMethodInfo LONG_TO_STRING = new JavaMethodInfo(JavaClass.LONG, "toString", "(J)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_TO_UNSIGNED_STRING = new JavaMethodInfo(JavaClass.LONG, "toUnsignedString", "(J)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo FLOAT_COMPARE = new JavaMethodInfo(JavaClass.FLOAT, "compare", "(FF)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo FLOAT_PARSE = new JavaMethodInfo(JavaClass.FLOAT, "parseFloat", "(Ljava/lang/String;)F", PUBLIC_STATIC);
-	private static final JavaMethodInfo FLOAT_FROM_BITS = new JavaMethodInfo(JavaClass.FLOAT, "intBitsToFloat", "(I)F", PUBLIC_STATIC);
-	private static final JavaMethodInfo FLOAT_BITS = new JavaMethodInfo(JavaClass.FLOAT, "floatToRawIntBits", "(F)I", PUBLIC_STATIC);
+	private static final JavaMethod LONG_TO_STRING = JavaMethod.getNativeStatic(JavaClass.LONG, "toString", "(J)Ljava/lang/String;");
+	private static final JavaMethod LONG_TO_UNSIGNED_STRING = JavaMethod.getNativeStatic(JavaClass.LONG, "toUnsignedString", "(J)Ljava/lang/String;");
+	private static final JavaMethod FLOAT_COMPARE = JavaMethod.getNativeStatic(JavaClass.FLOAT, "compare", "(FF)I");
+	private static final JavaMethod FLOAT_PARSE = JavaMethod.getNativeStatic(JavaClass.FLOAT, "parseFloat", "(Ljava/lang/String;)F");
+	private static final JavaMethod FLOAT_FROM_BITS = JavaMethod.getNativeStatic(JavaClass.FLOAT, "intBitsToFloat", "(I)F");
+	private static final JavaMethod FLOAT_BITS = JavaMethod.getNativeStatic(JavaClass.FLOAT, "floatToRawIntBits", "(F)I");
 	private static final JavaField FLOAT_MIN_VALUE = new JavaField(JavaClass.FLOAT, "MIN_VALUE", "F");
 	private static final JavaField FLOAT_MAX_VALUE = new JavaField(JavaClass.FLOAT, "MAX_VALUE", "F");
-	private static final JavaMethodInfo FLOAT_TO_STRING = new JavaMethodInfo(JavaClass.FLOAT, "toString", "(F)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo DOUBLE_COMPARE = new JavaMethodInfo(JavaClass.DOUBLE, "compare", "(DD)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo DOUBLE_PARSE = new JavaMethodInfo(JavaClass.DOUBLE, "parseDouble", "(Ljava/lang/String;)D", PUBLIC_STATIC);
-	private static final JavaMethodInfo DOUBLE_FROM_BITS = new JavaMethodInfo(JavaClass.DOUBLE, "longBitsToDouble", "(J)D", PUBLIC_STATIC);
-	private static final JavaMethodInfo DOUBLE_BITS = new JavaMethodInfo(JavaClass.DOUBLE, "doubleToRawLongBits", "(D)J", PUBLIC_STATIC);
+	private static final JavaMethod FLOAT_TO_STRING = JavaMethod.getNativeStatic(JavaClass.FLOAT, "toString", "(F)Ljava/lang/String;");
+	private static final JavaMethod DOUBLE_COMPARE = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "compare", "(DD)I");
+	private static final JavaMethod DOUBLE_PARSE = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "parseDouble", "(Ljava/lang/String;)D");
+	private static final JavaMethod DOUBLE_FROM_BITS = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "longBitsToDouble", "(J)D");
+	private static final JavaMethod DOUBLE_BITS = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "doubleToRawLongBits", "(D)J");
 	private static final JavaField DOUBLE_MIN_VALUE = new JavaField(JavaClass.DOUBLE, "MIN_VALUE", "D");
 	private static final JavaField DOUBLE_MAX_VALUE = new JavaField(JavaClass.DOUBLE, "MAX_VALUE", "D");
-	private static final JavaMethodInfo DOUBLE_TO_STRING = new JavaMethodInfo(JavaClass.DOUBLE, "toString", "(D)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo CHARACTER_TO_LOWER_CASE = new JavaMethodInfo(JavaClass.CHARACTER, "toLowerCase", "()C", PUBLIC);
-	private static final JavaMethodInfo CHARACTER_TO_UPPER_CASE = new JavaMethodInfo(JavaClass.CHARACTER, "toUpperCase", "()C", PUBLIC);
+	private static final JavaMethod DOUBLE_TO_STRING = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "toString", "(D)Ljava/lang/String;");
+	private static final JavaMethod CHARACTER_TO_LOWER_CASE = JavaMethod.getNativeVirtual(JavaClass.CHARACTER, "toLowerCase", "()C");
+	private static final JavaMethod CHARACTER_TO_UPPER_CASE = JavaMethod.getNativeVirtual(JavaClass.CHARACTER, "toUpperCase", "()C");
 	private static final JavaField CHARACTER_MIN_VALUE = new JavaField(JavaClass.CHARACTER, "MIN_VALUE", "C");
 	private static final JavaField CHARACTER_MAX_VALUE = new JavaField(JavaClass.CHARACTER, "MAX_VALUE", "C");
-	private static final JavaMethodInfo CHARACTER_TO_STRING = new JavaMethodInfo(JavaClass.CHARACTER, "toString", "(C)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo STRING_COMPARETO = new JavaMethodInfo(JavaClass.STRING, "compareTo", "(Ljava/lang/String;)I", PUBLIC);
-	private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(JavaClass.STRING, "concat", "(Ljava/lang/String;)Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_CHAR_AT = new JavaMethodInfo(JavaClass.STRING, "charAt", "(I)C", PUBLIC);
-	private static final JavaMethodInfo STRING_SUBSTRING = new JavaMethodInfo(JavaClass.STRING, "substring", "(II)Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TRIM = new JavaMethodInfo(JavaClass.STRING, "trim", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TO_LOWER_CASE = new JavaMethodInfo(JavaClass.STRING, "toLowerCase", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TO_UPPER_CASE = new JavaMethodInfo(JavaClass.STRING, "toUpperCase", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_LENGTH = new JavaMethodInfo(JavaClass.STRING, "length", "()I", PUBLIC);
-	private static final JavaMethodInfo STRING_CHARACTERS = new JavaMethodInfo(JavaClass.STRING, "toCharArray", "()[C", PUBLIC);
-	private static final JavaMethodInfo STRING_ISEMPTY = new JavaMethodInfo(JavaClass.STRING, "isEmpty", "()Z", PUBLIC);
-	private static final JavaMethodInfo ENUM_COMPARETO = new JavaMethodInfo(JavaClass.ENUM, "compareTo", "(Ljava/lang/Enum;)I", PUBLIC);
-	private static final JavaMethodInfo ENUM_NAME = new JavaMethodInfo(JavaClass.ENUM, "name", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo ENUM_ORDINAL = new JavaMethodInfo(JavaClass.ENUM, "ordinal", "()I", PUBLIC);
-	private static final JavaMethodInfo MAP_GET = new JavaMethodInfo(JavaClass.MAP, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", PUBLIC);
-	private static final JavaMethodInfo MAP_PUT = new JavaMethodInfo(JavaClass.MAP, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", PUBLIC);
-	private static final JavaMethodInfo MAP_CONTAINS_KEY = new JavaMethodInfo(JavaClass.MAP, "containsKey", "(Ljava/lang/Object;)Z", PUBLIC);
-	private static final JavaMethodInfo MAP_SIZE = new JavaMethodInfo(JavaClass.MAP, "size", "()I", PUBLIC);
-	private static final JavaMethodInfo MAP_ISEMPTY = new JavaMethodInfo(JavaClass.MAP, "isEmpty", "()Z", PUBLIC);
-	private static final JavaMethodInfo MAP_KEYS = new JavaMethodInfo(JavaClass.MAP, "keys", "()Ljava/lang/Object;", PUBLIC);
-	private static final JavaMethodInfo MAP_VALUES = new JavaMethodInfo(JavaClass.MAP, "values", "()Ljava/lang/Object;", PUBLIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_OBJECTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([Ljava/lang/Object;II)[Ljava/lang/Object;", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([ZII)[Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([BII)[B", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([SII)[S", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([III)[I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([JII)[J", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([FII)[F", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([DII)[D", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([CII)[C", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_OBJECTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([Ljava/lang/Object[Ljava/lang/Object)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([Z[Z)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([B[B)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([S[S)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([I[I)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([L[L)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([F[F)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([D[D)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([C[C)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_DEEPHASHCODE = new JavaMethodInfo(JavaClass.ARRAYS, "deepHashCode", "([Ljava/lang/Object;)", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([Z)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([B)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([S)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([L)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([F)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([D)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([C)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo OBJECT_HASHCODE = new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", PUBLIC);
-	private static final JavaMethodInfo COLLECTION_SIZE = new JavaMethodInfo(JavaClass.COLLECTION, "size", "()I", PUBLIC);
-	private static final JavaMethodInfo COLLECTION_TOARRAY = new JavaMethodInfo(JavaClass.COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", PUBLIC);
+	private static final JavaMethod CHARACTER_TO_STRING = JavaMethod.getNativeStatic(JavaClass.CHARACTER, "toString", "(C)Ljava/lang/String;");
+	private static final JavaMethod STRING_COMPARETO = JavaMethod.getNativeVirtual(JavaClass.STRING, "compareTo", "(Ljava/lang/String;)I");
+	private static final JavaMethod STRING_CONCAT = JavaMethod.getNativeVirtual(JavaClass.STRING, "concat", "(Ljava/lang/String;)Ljava/lang/String;");
+	private static final JavaMethod STRING_CHAR_AT = JavaMethod.getNativeVirtual(JavaClass.STRING, "charAt", "(I)C");
+	private static final JavaMethod STRING_SUBSTRING = JavaMethod.getNativeVirtual(JavaClass.STRING, "substring", "(II)Ljava/lang/String;");
+	private static final JavaMethod STRING_TRIM = JavaMethod.getNativeVirtual(JavaClass.STRING, "trim", "()Ljava/lang/String;");
+	private static final JavaMethod STRING_TO_LOWER_CASE = JavaMethod.getNativeVirtual(JavaClass.STRING, "toLowerCase", "()Ljava/lang/String;");
+	private static final JavaMethod STRING_TO_UPPER_CASE = JavaMethod.getNativeVirtual(JavaClass.STRING, "toUpperCase", "()Ljava/lang/String;");
+	private static final JavaMethod STRING_LENGTH = JavaMethod.getNativeVirtual(JavaClass.STRING, "length", "()I");
+	private static final JavaMethod STRING_CHARACTERS = JavaMethod.getNativeVirtual(JavaClass.STRING, "toCharArray", "()[C");
+	private static final JavaMethod STRING_ISEMPTY = JavaMethod.getNativeVirtual(JavaClass.STRING, "isEmpty", "()Z");
+	private static final JavaMethod ENUM_COMPARETO = JavaMethod.getNativeVirtual(JavaClass.ENUM, "compareTo", "(Ljava/lang/Enum;)I");
+	private static final JavaMethod ENUM_NAME = JavaMethod.getNativeVirtual(JavaClass.ENUM, "name", "()Ljava/lang/String;");
+	private static final JavaMethod ENUM_ORDINAL = JavaMethod.getNativeVirtual(JavaClass.ENUM, "ordinal", "()I");
+	private static final JavaMethod MAP_GET = JavaMethod.getNativeVirtual(JavaClass.MAP, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
+	private static final JavaMethod MAP_PUT = JavaMethod.getNativeVirtual(JavaClass.MAP, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+	private static final JavaMethod MAP_CONTAINS_KEY = JavaMethod.getNativeVirtual(JavaClass.MAP, "containsKey", "(Ljava/lang/Object;)Z");
+	private static final JavaMethod MAP_SIZE = JavaMethod.getNativeVirtual(JavaClass.MAP, "size", "()I");
+	private static final JavaMethod MAP_ISEMPTY = JavaMethod.getNativeVirtual(JavaClass.MAP, "isEmpty", "()Z");
+	private static final JavaMethod MAP_KEYS = JavaMethod.getNativeVirtual(JavaClass.MAP, "keys", "()Ljava/lang/Object;");
+	private static final JavaMethod MAP_VALUES = JavaMethod.getNativeVirtual(JavaClass.MAP, "values", "()Ljava/lang/Object;");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_OBJECTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([Ljava/lang/Object;II)[Ljava/lang/Object;");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_BOOLS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([ZII)[Z");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_BYTES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([BII)[B");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_SHORTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([SII)[S");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_INTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([III)[I");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_LONGS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([JII)[J");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_FLOATS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([FII)[F");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_DOUBLES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([DII)[D");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_CHARS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([CII)[C");
+	private static final JavaMethod ARRAYS_EQUALS_OBJECTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([Ljava/lang/Object[Ljava/lang/Object)Z");
+	private static final JavaMethod ARRAYS_EQUALS_BOOLS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([Z[Z)Z");
+	private static final JavaMethod ARRAYS_EQUALS_BYTES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([B[B)Z");
+	private static final JavaMethod ARRAYS_EQUALS_SHORTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([S[S)Z");
+	private static final JavaMethod ARRAYS_EQUALS_INTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([I[I)Z");
+	private static final JavaMethod ARRAYS_EQUALS_LONGS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([L[L)Z");
+	private static final JavaMethod ARRAYS_EQUALS_FLOATS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([F[F)Z");
+	private static final JavaMethod ARRAYS_EQUALS_DOUBLES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([D[D)Z");
+	private static final JavaMethod ARRAYS_EQUALS_CHARS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([C[C)Z");
+	private static final JavaMethod ARRAYS_DEEPHASHCODE = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "deepHashCode", "([Ljava/lang/Object;)");
+	private static final JavaMethod ARRAYS_HASHCODE_BOOLS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([Z)I");
+	private static final JavaMethod ARRAYS_HASHCODE_BYTES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([B)I");
+	private static final JavaMethod ARRAYS_HASHCODE_SHORTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([S)I");
+	private static final JavaMethod ARRAYS_HASHCODE_INTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([I)I");
+	private static final JavaMethod ARRAYS_HASHCODE_LONGS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([L)I");
+	private static final JavaMethod ARRAYS_HASHCODE_FLOATS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([F)I");
+	private static final JavaMethod ARRAYS_HASHCODE_DOUBLES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([D)I");
+	private static final JavaMethod ARRAYS_HASHCODE_CHARS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([C)I");
+	public static final JavaMethod OBJECT_HASHCODE = JavaMethod.getNativeVirtual(JavaClass.OBJECT, "hashCode", "()I");
+	private static final JavaMethod COLLECTION_SIZE = JavaMethod.getNativeVirtual(JavaClass.COLLECTION, "size", "()I");
+	private static final JavaMethod COLLECTION_TOARRAY = JavaMethod.getNativeVirtual(JavaClass.COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;");
 
 	protected final JavaWriter javaWriter;
 	private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
 					throw new UnsupportedOperationException("Unknown builtin comparator: " + expression.operator.getBuiltin());
 			}
 		} else {
-			if (!checkAndExecuteMethodInfo(expression.operator))
+			if (!checkAndExecuteMethodInfo(expression.operator, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			expression.left.accept(this);
 				argument.accept(this);
 			}
 
-			if (!checkAndExecuteMethodInfo(expression.member))
+			if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 			//if (expression.member.getHeader().returnType != expression.type)
 
 			case USHORT_NOT:
 			case INT_NOT:
 			case UINT_NOT:
+			case USIZE_NOT:
 				javaWriter.iNot();
 				break;
 			case SBYTE_NEG:
 			case USHORT_ADD_USHORT:
 			case INT_ADD_INT:
 			case UINT_ADD_UINT:
+			case USIZE_ADD_USIZE:
 				javaWriter.iAdd();
 				break;
 			case BYTE_SUB_BYTE:
 			case USHORT_SUB_USHORT:
 			case INT_SUB_INT:
 			case UINT_SUB_UINT:
+			case USIZE_SUB_USIZE:
 				javaWriter.iSub();
 				break;
 			case BYTE_MUL_BYTE:
 			case USHORT_MUL_USHORT:
 			case INT_MUL_INT:
 			case UINT_MUL_UINT:
+			case USIZE_MUL_USIZE:
 				javaWriter.iMul();
 				break;
 			case SBYTE_DIV_SBYTE:
 			case SHORT_DIV_SHORT:
 			case INT_DIV_INT:
+			case USIZE_DIV_USIZE:
 				javaWriter.iDiv();
 				break;
 			case SBYTE_MOD_SBYTE:
 			case SHORT_MOD_SHORT:
 			case INT_MOD_INT:
+			case USIZE_MOD_USIZE:
 				javaWriter.iRem();
 				break;
 			case BYTE_DIV_BYTE:
 			case USHORT_AND_USHORT:
 			case INT_AND_INT:
 			case UINT_AND_UINT:
+			case USIZE_AND_USIZE:
 				javaWriter.iAnd();
 				break;
 			case BYTE_OR_BYTE:
 			case USHORT_OR_USHORT:
 			case INT_OR_INT:
 			case UINT_OR_UINT:
+			case USIZE_OR_USIZE:
 				javaWriter.iOr();
 				break;
 			case BYTE_XOR_BYTE:
 			case USHORT_XOR_USHORT:
 			case INT_XOR_INT:
 			case UINT_XOR_UINT:
+			case USIZE_XOR_USIZE:
 				javaWriter.iXor();
 				break;
 			case INT_SHL:
 			case UINT_SHL:
+			case USIZE_SHL:
 				javaWriter.iShl();
 				break;
 			case INT_SHR:
 				break;
 			case INT_USHR:
 			case UINT_SHR:
+			case USIZE_SHR:
 				javaWriter.iUShr();
 				break;
 			case INT_COUNT_LOW_ZEROES:
 			case UINT_COUNT_LOW_ZEROES:
+			case USIZE_COUNT_LOW_ZEROES:
 				javaWriter.invokeStatic(INTEGER_NUMBER_OF_TRAILING_ZEROS);
 				break;
 			case INT_COUNT_HIGH_ZEROES:
 			case UINT_COUNT_HIGH_ZEROES:
+			case USIZE_COUNT_HIGH_ZEROES:
 				javaWriter.invokeStatic(INTEGER_NUMBER_OF_LEADING_ZEROS);
 				break;
 			case INT_COUNT_LOW_ONES:
 			case UINT_COUNT_LOW_ONES:
+			case USIZE_COUNT_LOW_ONES:
 				javaWriter.iNot();
 				javaWriter.invokeStatic(INTEGER_NUMBER_OF_TRAILING_ZEROS);
 				break;
 			case INT_COUNT_HIGH_ONES:
 			case UINT_COUNT_HIGH_ONES:
+			case USIZE_COUNT_HIGH_ONES:
 				javaWriter.iNot();
 				javaWriter.invokeStatic(INTEGER_NUMBER_OF_LEADING_ZEROS);
 				break;
 					}
 				} else {
 					javaWriter.invokeStatic(ARRAYS_COPY_OF_RANGE_OBJECTS);
-					javaWriter.checkCast(context.getDescriptor(type));
+					javaWriter.checkCast(context.getInternalName(type));
 				}
 				break;
 			}
 			}
 			case FUNCTION_CALL:
 				javaWriter.invokeInterface(
-						new JavaMethodInfo(
+						JavaMethod.getNativeVirtual(
 								JavaClass.fromInternalName(context.getInternalName(expression.target.type), JavaClass.Kind.INTERFACE),
 								"accept",
-								context.getMethodSignature(expression.instancedHeader),
-								Opcodes.ACC_PUBLIC));
+								context.getMethodSignature(expression.instancedHeader)));
 				break;
 			case AUTOOP_NOTEQUALS:
 				throw new UnsupportedOperationException("Not yet supported!");
 
 		BuiltinID builtin = expression.member.getBuiltin();
 		if (builtin == null) {
-			if (!checkAndExecuteMethodInfo(expression.member))
+			if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
 				javaWriter.invokeStatic(INTEGER_PARSE_WITH_BASE);
 				break;
 			case UINT_PARSE:
+			case USIZE_PARSE:
 				javaWriter.invokeStatic(INTEGER_PARSE_UNSIGNED);
 				break;
 			case UINT_PARSE_WITH_BASE:
+			case USIZE_PARSE_WITH_BASE:
 				javaWriter.invokeStatic(INTEGER_PARSE_UNSIGNED_WITH_BASE);
 				break;
 			case LONG_PARSE:
 
 		BuiltinID builtin = expression.member.member.builtin;
 		if (builtin == null) {
-			if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
+			if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
 			case BYTE_TO_USHORT:
 			case BYTE_TO_INT:
 			case BYTE_TO_UINT:
+			case BYTE_TO_USIZE:
 				javaWriter.constant(0xFF);
 				javaWriter.iAnd();
 				break;
 			case SBYTE_TO_USHORT:
 			case SBYTE_TO_INT:
 			case SBYTE_TO_UINT:
+			case SBYTE_TO_USIZE:
 				break;
 			case SBYTE_TO_LONG:
 			case SBYTE_TO_ULONG:
 			case SHORT_TO_USHORT:
 			case SHORT_TO_INT:
 			case SHORT_TO_UINT:
+			case SHORT_TO_USIZE:
 				break;
 			case SHORT_TO_LONG:
 			case SHORT_TO_ULONG:
 				break;
 			case USHORT_TO_INT:
 			case USHORT_TO_UINT:
+			case USHORT_TO_USIZE:
 				javaWriter.constant(0xFFFF);
 				javaWriter.iAnd();
 				break;
 			case INT_TO_USHORT:
 				break;
 			case INT_TO_UINT:
+			case INT_TO_USIZE:
 				break;
 			case INT_TO_LONG:
 			case INT_TO_ULONG:
 				break;
 			case UINT_TO_USHORT:
 			case UINT_TO_INT:
+			case UINT_TO_USIZE:
 				break;
 			case UINT_TO_LONG:
 				javaWriter.i2l();
 			case LONG_TO_USHORT:
 			case LONG_TO_INT:
 			case LONG_TO_UINT:
+			case LONG_TO_USIZE:
 				javaWriter.l2i();
 				break;
 			case LONG_TO_ULONG:
 			case ULONG_TO_USHORT:
 			case ULONG_TO_INT:
 			case ULONG_TO_UINT:
+			case ULONG_TO_USIZE:
 				javaWriter.l2i();
 				break;
 			case ULONG_TO_LONG:
 			case FLOAT_TO_USHORT:
 			case FLOAT_TO_UINT:
 			case FLOAT_TO_INT:
+			case FLOAT_TO_USIZE:
 				javaWriter.f2i();
 				break;
 			case FLOAT_TO_LONG:
 			case DOUBLE_TO_USHORT:
 			case DOUBLE_TO_INT:
 			case DOUBLE_TO_UINT:
+			case DOUBLE_TO_USIZE:
 				javaWriter.d2i();
 				break;
 			case DOUBLE_TO_LONG:
 			case CHAR_TO_USHORT:
 			case CHAR_TO_INT:
 			case CHAR_TO_UINT:
+			case CHAR_TO_USIZE:
 				break;
 			case CHAR_TO_LONG:
 			case CHAR_TO_ULONG:
         javaWriter.dup();
         javaWriter.ifNonNull(end);
         javaWriter.pop();
-        javaWriter.newObject(NullPointerException.class);
+        javaWriter.newObject("java/lang/NullPointerException");
         javaWriter.dup();
         javaWriter.constant("Tried to convert a null value to nonnull type " + context.getType(expression.type).getClassName());
         javaWriter.invokeSpecial(NullPointerException.class, "<init>", "(Ljava/lang/String;)V");
 			case ULONG_GET_MAX_VALUE:
 				javaWriter.constant(-1L);
 				break;
+			case USIZE_GET_MIN_VALUE:
+				javaWriter.iConst0();
+				break;
+			case USIZE_GET_MAX_VALUE:
+				javaWriter.getStaticField(INTEGER_MAX_VALUE);
+				break;
+			case USIZE_BITS:
+				javaWriter.constant(32);
+				break;
 			case FLOAT_GET_MIN_VALUE:
 				javaWriter.getStaticField(FLOAT_MIN_VALUE);
 				break;
 			case ENUM_VALUES: {
 				DefinitionTypeID type = (DefinitionTypeID) expression.type;
 				JavaClass cls = type.definition.getTag(JavaClass.class);
-				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalName + ";", PUBLIC_STATIC));
+				javaWriter.invokeStatic(JavaMethod.getNativeStatic(cls, "values", "()[L" + cls.internalName + ";"));
 				break;
 			}
 			default:
 		return null;
 	}
 
+	@Override
+	public Void visitConstantUSize(ConstantUSizeExpression expression) {
+		getJavaWriter().constant((int)expression.value);
+		return null;
+	}
+
     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		javaWriter.loadObject(0);
-		if (javaWriter.method.javaClass.isEnum()) {
+		if (javaWriter.method.cls.isEnum()) {
 			javaWriter.loadObject(1);
 			javaWriter.loadInt(2);
 		}
 			argument.accept(this);
 		}
 		String internalName = context.getInternalName(expression.objectType);
-        javaWriter.invokeSpecial(internalName, "<init>", javaWriter.method.javaClass.isEnum()
+        javaWriter.invokeSpecial(internalName, "<init>", javaWriter.method.cls.isEnum()
 				? context.getEnumConstructorDescriptor(expression.constructor.getHeader())
 				: context.getMethodDescriptor(expression.constructor.getHeader()));
         return null;
             return null;
         }
         final String signature = context.getMethodSignature(expression.header);
-		final String name = CompilerUtils.getLambdaCounter();
+		final String name = context.getLambdaCounter();
 
-		final JavaMethodInfo methodInfo = new JavaMethodInfo(javaWriter.method.javaClass, "accept", signature, Opcodes.ACC_PUBLIC);
+		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", signature);
 		final ClassWriter lambdaCW = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{JavaSynthesizedClassNamer.createFunctionName(new FunctionTypeID(null, expression.header)).cls.internalName});
 		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
 		final String constructorDesc = calcFunctionSignature(expression.closure);
 
 
-		final JavaWriter constructorWriter = new JavaWriter(lambdaCW, new JavaMethodInfo(javaWriter.method.javaClass, "<init>", constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
+		final JavaWriter constructorWriter = new JavaWriter(lambdaCW, JavaMethod.getConstructor(javaWriter.method.cls, constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
 		constructorWriter.start();
 		constructorWriter.loadObject(0);
 		constructorWriter.dup();
 	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
 		javaWriter.loadObject(0);
 		final ITypeID type = expression.value.option.getParameterType(expression.index);
-		final JavaClass tag = expression.value.option.getTag(JavaClass.class);
-		javaWriter.checkCast(tag.internalName);
-		javaWriter.getField(new JavaField(tag, "Field" + expression.index, context.getDescriptor(type)));
+		final JavaVariantOption tag = expression.value.option.getTag(JavaVariantOption.class);
+		javaWriter.checkCast(tag.variantOptionClass.internalName);
+		javaWriter.getField(new JavaField(tag.variantOptionClass, "field" + expression.index, context.getDescriptor(type)));
 		return null;
 	}
 
 
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
-			if (!checkAndExecuteMethodInfo(expression.getter))
+			if (!checkAndExecuteMethodInfo(expression.getter, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
 		switch (builtin) {
 			case INT_HIGHEST_ONE_BIT:
 			case UINT_HIGHEST_ONE_BIT:
+			case USIZE_HIGHEST_ONE_BIT:
 				javaWriter.invokeStatic(INTEGER_HIGHEST_ONE_BIT);
 				break;
 			case INT_LOWEST_ONE_BIT:
 			case UINT_LOWEST_ONE_BIT:
+			case USIZE_LOWEST_ONE_BIT:
 				javaWriter.invokeStatic(INTEGER_LOWEST_ONE_BIT);
 				break;
 			case INT_HIGHEST_ZERO_BIT:
 			case UINT_HIGHEST_ZERO_BIT:
+			case USIZE_HIGHEST_ZERO_BIT:
 				javaWriter.iNeg();
 				javaWriter.invokeStatic(INTEGER_HIGHEST_ONE_BIT);
 				break;
 			case INT_LOWEST_ZERO_BIT:
 			case UINT_LOWEST_ZERO_BIT:
+			case USIZE_LOWEST_ZERO_BIT:
 				javaWriter.iNeg();
 				javaWriter.invokeStatic(INTEGER_LOWEST_ONE_BIT);
 				break;
 			case INT_BIT_COUNT:
 			case UINT_BIT_COUNT:
+			case USIZE_BIT_COUNT:
 				javaWriter.invokeStatic(INTEGER_BIT_COUNT);
 				break;
 			case LONG_HIGHEST_ONE_BIT:
 			case OBJECT_HASHCODE:
 				javaWriter.invokeVirtual(OBJECT_HASHCODE);
 				break;
-			case RANGE_FROM:
-				// TODO: range types
-				javaWriter.getField(IntRange.class, "from", int.class);
+			case RANGE_FROM: {
+				RangeTypeID type = (RangeTypeID)expression.target.type;
+				JavaClass cls = context.getTypeGenerator().synthesizeRange(type).cls;
+				javaWriter.getField(cls.internalName, "from", context.getDescriptor(type.baseType));
 				break;
+			}
 			case RANGE_TO:
-				// TODO: range types
-				javaWriter.getField(IntRange.class, "to", int.class);
+				RangeTypeID type = (RangeTypeID)expression.target.type;
+				JavaClass cls = context.getTypeGenerator().synthesizeRange(type).cls;
+				javaWriter.getField(cls.internalName, "to", context.getDescriptor(type.baseType));
 				break;
 		}
 
     @Override
     public Void visitInterfaceCast(InterfaceCastExpression expression) {
         expression.value.accept(this);
-        javaWriter.checkCast(context.getDescriptor(expression.type));
+        javaWriter.checkCast(context.getInternalName(expression.type));
         return null;
     }
 
     @Override
     public Void visitIs(IsExpression expression) {
         expression.value.accept(this);
-        javaWriter.instanceOf(context.getDescriptor(expression.isType));
+        javaWriter.instanceOf(context.getInternalName(expression.isType));
         return null;
     }
 
 
 	@Override
 	public Void visitMatch(MatchExpression expression) {
-
 		final Label start = new Label();
 		final Label end = new Label();
 
-
 		javaWriter.label(start);
 		expression.value.accept(this);
 
-
 		//TODO replace beforeSwitch visitor or similar
 		if (expression.value.type == BasicTypeID.STRING)
-			javaWriter.invokeVirtual(new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", 0));
+			javaWriter.invokeVirtual(OBJECT_HASHCODE);
 
 		//TODO replace with beforeSwitch visitor or similar
 		for (MatchExpression.Case aCase : expression.cases) {
 			if (aCase.key instanceof VariantOptionSwitchValue) {
 				VariantOptionSwitchValue variantOptionSwitchValue = (VariantOptionSwitchValue) aCase.key;
-				final String className = variantOptionSwitchValue.option.getTag(JavaClass.class).internalName;
-				javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClass("", className.substring(0, className.lastIndexOf('$')), JavaClass.Kind.CLASS), "getDenominator", "()I", 0));
+				JavaVariantOption option = variantOptionSwitchValue.option.getTag(JavaVariantOption.class);
+				javaWriter.invokeVirtual(JavaMethod.getNativeVirtual(option.variantClass, "getDenominator", "()I"));
 				break;
 			}
 		}
 
-
 		final boolean hasNoDefault = hasNoDefault(expression);
 
 		final MatchExpression.Case[] cases = expression.cases;
     @Override
     public Void visitNew(NewExpression expression) {
 		// TODO: this code is incorrect!
+		JavaMethod method = expression.constructor.getTag(JavaMethod.class);
 
         final String type;
         if (expression.type instanceof DefinitionTypeID)
 
         javaWriter.newObject(type);
         javaWriter.dup();
-        StringBuilder signatureBuilder = new StringBuilder("(");
-        for (Expression argument : expression.arguments.arguments) {
-            argument.accept(this);
-            signatureBuilder.append(context.getDescriptor(argument.type));
-        }
-        signatureBuilder.append(")V");
-        javaWriter.invokeSpecial(type, "<init>", signatureBuilder.toString());
 
-		//throw new UnsupportedOperationException("Not yet implemented!");
+		for (Expression argument : expression.arguments.arguments) {
+			argument.accept(this);
+		}
+
+        javaWriter.invokeSpecial(method);
 		return null;
 	}
 
 	@Override
 	public Void visitNull(NullExpression expression) {
-		javaWriter.aConstNull();
+		if (expression.type.withoutOptional() == BasicTypeID.USIZE)
+			javaWriter.constant(-1); // special case: usize? null = -1
+		else
+			javaWriter.aConstNull();
 		return null;
 	}
 
 
 	@Override
 	public Void visitPanic(PanicExpression expression) {
-		javaWriter.newObject(AssertionError.class);
+		javaWriter.newObject("java/lang/AssertionError");
 		javaWriter.dup();
 		expression.value.accept(this);
 		javaWriter.invokeSpecial(AssertionError.class, "<init>", "(Ljava/lang/String;)V");
 	public Void visitPostCall(PostCallExpression expression) {
 		expression.target.accept(this);
 		javaWriter.dup(context.getType(expression.type));
-		if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
+		if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 			throw new IllegalStateException("Call target has no method info!");
 
 		return null;
 
     @Override
     public Void visitRange(RangeExpression expression) {
-        // TODO: there are other kinds of ranges also; there should be a Range<T, T> type with creation of synthetic types
-        if (!context.getDescriptor(expression.from.type).equals("I"))
-            throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
-
-		javaWriter.newObject(IntRange.class);
+		RangeTypeID type = (RangeTypeID)expression.type;
+		JavaSynthesizedClass cls = context.getTypeGenerator().synthesizeRange(type);
+		javaWriter.newObject(cls.cls.internalName);
 		javaWriter.dup();
 		expression.from.accept(this);
 		expression.to.accept(this);
-		javaWriter.invokeSpecial("org/openzen/zenscript/implementations/IntRange", "<init>", "(II)V");
+		javaWriter.invokeSpecial(cls.cls.internalName, "<init>", "(" + context.getDescriptor(type.baseType) + context.getDescriptor(type.baseType) + ")V");
 
 		return null;
 	}
 	public Void visitStaticGetter(StaticGetterExpression expression) {
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
-			if (!checkAndExecuteMethodInfo(expression.getter))
+			if (!checkAndExecuteMethodInfo(expression.getter, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
 			case ENUM_VALUES: {
 				DefinitionTypeID type = (DefinitionTypeID) expression.type;
 				JavaClass cls = type.definition.getTag(JavaClass.class);
-				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalName + ";", PUBLIC_STATIC));
+				javaWriter.invokeStatic(JavaMethod.getNativeStatic(cls, "values", "()[L" + cls.internalName + ";"));
 				break;
 			}
 			default:
 
 	@Override
 	public Void visitVariantValue(VariantValueExpression expression) {
-		final String internalName = expression.option.getTag(JavaClass.class).internalName;
+		JavaVariantOption tag = expression.option.getTag(JavaVariantOption.class);
+		final String internalName = tag.variantOptionClass.internalName;
 		javaWriter.newObject(internalName);
 		javaWriter.dup();
 
 	@Override
 	public Void visitWrapOptional(WrapOptionalExpression expression) {
 		//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);
+		expression.value.type.accept(new JavaBoxingTypeVisitor(javaWriter));
 		return null;
 	}
 
         return javaWriter;
     }
 
-
-    //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);
-        if (implementation != null) {
-            implementation.compile(getJavaWriter());
-            return true;
-        }
-        return false;
-    }
-
     //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);
+    private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member, ITypeID resultType) {
+        JavaMethod methodInfo = member.getTag(JavaMethod.class);
         if (methodInfo == null)
             return false;
 
-        if (methodInfo.isStatic()) {
+        if (methodInfo.kind == JavaMethod.Kind.STATIC) {
             getJavaWriter().invokeStatic(methodInfo);
         } else {
             getJavaWriter().invokeVirtual(methodInfo);
         }
+		if (methodInfo.genericResult)
+			getJavaWriter().checkCast(context.getInternalName(resultType));
+
         return true;
     }
 

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaForeachVisitor.java → JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaForeachWriter.java

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Label;
-import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 
-public class JavaForeachVisitor implements ForeachIteratorVisitor<Void> {
+public class JavaForeachWriter {
 
 	private final JavaWriter javaWriter;
 	private final VarStatement[] variables;
 	private final Label endLabel;
 	private final JavaStatementVisitor statementVisitor;
 
-	public JavaForeachVisitor(JavaStatementVisitor statementVisitor, VarStatement[] variables, Statement content, Label start, Label end) {
+	public JavaForeachWriter(JavaStatementVisitor statementVisitor, VarStatement[] variables, Statement content, Label start, Label end) {
 		this.statementVisitor = statementVisitor;
 		this.javaWriter = statementVisitor.getJavaWriter();
 		this.variables = variables;
 		this.endLabel = end;
 	}
 
-	@Override
-	public Void visitIntRange() {
+	public void visitIntRange() {
 		javaWriter.dup();
-		javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "to", "I");
+		javaWriter.getField("zsynthetic/IntRange", "to", "I");
 		javaWriter.swap();
-		javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "from", "I");
+		javaWriter.getField("zsynthetic/IntRange", "from", "I");
 
 		final int z = variables[0].getTag(JavaLocalVariableInfo.class).local;
 		javaWriter.storeInt(z);
 
 		content.accept(statementVisitor);
 		javaWriter.iinc(z);
-
-
-		return null;
 	}
 
-	@Override
-	public Void visitArrayValueIterator() {
+	public void visitArrayValueIterator() {
 		handleArray(javaWriter.local(int.class), variables[0].getTag(JavaLocalVariableInfo.class));
-		return null;
 	}
 
-	@Override
-	public Void visitArrayKeyValueIterator() {
+	public void visitArrayKeyValueIterator() {
 		handleArray(variables[0].getTag(JavaLocalVariableInfo.class).local, variables[1].getTag(JavaLocalVariableInfo.class));
-		return null;
 	}
 
-	@Override
-	public Void visitStringCharacterIterator() {
+	public void visitStringCharacterIterator() {
 		//TODO UNTESTED!
 		javaWriter.invokeSpecial("java/lang/String", "toCharArray()", "()[C");
 		handleArray(javaWriter.local(int.class), variables[0].getTag(JavaLocalVariableInfo.class));
-		return null;
 	}
 
 	private void handleArray(final int z, final JavaLocalVariableInfo arrayTypeInfo) {
 		javaWriter.iinc(z);
 	}
 
-	@Override
-	public Void visitCustomIterator() {
-		return null;
+	public void visitCustomIterator() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 
-	@Override
-	public Void visitAssocKeyIterator() {
+	public void visitAssocKeyIterator() {
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 
-	@Override
-	public Void visitAssocKeyValueIterator() {
+	public void visitAssocKeyValueIterator() {
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 }

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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.expression.AndAndExpression;
-import org.openzen.zenscript.codemodel.expression.ArrayExpression;
-import org.openzen.zenscript.codemodel.expression.CompareExpression;
-import org.openzen.zenscript.codemodel.expression.CallExpression;
-import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
-import org.openzen.zenscript.codemodel.expression.CastExpression;
-import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
-import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
-import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
-import org.openzen.zenscript.codemodel.expression.ConstExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
-import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
-import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
-import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
-import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
-import org.openzen.zenscript.codemodel.expression.FunctionExpression;
-import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
-import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
-import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
-import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
-import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
-import org.openzen.zenscript.codemodel.expression.GetterExpression;
-import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
-import org.openzen.zenscript.codemodel.expression.GlobalExpression;
-import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
-import org.openzen.zenscript.codemodel.expression.IsExpression;
-import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
-import org.openzen.zenscript.codemodel.expression.MapExpression;
-import org.openzen.zenscript.codemodel.expression.MatchExpression;
-import org.openzen.zenscript.codemodel.expression.NewExpression;
-import org.openzen.zenscript.codemodel.expression.NullExpression;
-import org.openzen.zenscript.codemodel.expression.OrOrExpression;
-import org.openzen.zenscript.codemodel.expression.PanicExpression;
-import org.openzen.zenscript.codemodel.expression.PostCallExpression;
-import org.openzen.zenscript.codemodel.expression.RangeExpression;
-import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
-import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
-import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
-import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
-import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
-import org.openzen.zenscript.codemodel.expression.SetterExpression;
-import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
-import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
-import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
-import org.openzen.zenscript.codemodel.expression.ThisExpression;
-import org.openzen.zenscript.codemodel.expression.ThrowExpression;
-import org.openzen.zenscript.codemodel.expression.TryConvertExpression;
-import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
-import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
-import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
-import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 /**
  *
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
 
+	@Override
+	public Void visitConstantUSize(ConstantUSizeExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
 	@Override
 	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");

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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.expression.AndAndExpression;
-import org.openzen.zenscript.codemodel.expression.ArrayExpression;
-import org.openzen.zenscript.codemodel.expression.CompareExpression;
-import org.openzen.zenscript.codemodel.expression.CallExpression;
-import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
-import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
-import org.openzen.zenscript.codemodel.expression.CastExpression;
-import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
-import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
-import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
-import org.openzen.zenscript.codemodel.expression.ConstExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
-import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
-import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
-import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
-import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
-import org.openzen.zenscript.codemodel.expression.FunctionExpression;
-import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
-import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
-import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
-import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
-import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
-import org.openzen.zenscript.codemodel.expression.GetterExpression;
-import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
-import org.openzen.zenscript.codemodel.expression.GlobalExpression;
-import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
-import org.openzen.zenscript.codemodel.expression.IsExpression;
-import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
-import org.openzen.zenscript.codemodel.expression.MapExpression;
-import org.openzen.zenscript.codemodel.expression.MatchExpression;
-import org.openzen.zenscript.codemodel.expression.NewExpression;
-import org.openzen.zenscript.codemodel.expression.NullExpression;
-import org.openzen.zenscript.codemodel.expression.OrOrExpression;
-import org.openzen.zenscript.codemodel.expression.PanicExpression;
-import org.openzen.zenscript.codemodel.expression.PostCallExpression;
-import org.openzen.zenscript.codemodel.expression.RangeExpression;
-import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
-import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
-import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
-import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
-import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
-import org.openzen.zenscript.codemodel.expression.SetterExpression;
-import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
-import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
-import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
-import org.openzen.zenscript.codemodel.expression.ThisExpression;
-import org.openzen.zenscript.codemodel.expression.ThrowExpression;
-import org.openzen.zenscript.codemodel.expression.TryConvertExpression;
-import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
-import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
-import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
-import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 /**
  *
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
 
+	@Override
+	public Void visitConstantUSize(ConstantUSizeExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
 	@Override
 	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");

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

  */
 package org.openzen.zenscript.javabytecode.compiler;
 
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaScriptFile {
 	public final JavaClassWriter classWriter;
-	public final List<JavaMethodInfo> scriptMethods;
+	public final List<JavaMethod> scriptMethods;
 
 	public JavaScriptFile(JavaClassWriter classWriter) {
 		this.classWriter = classWriter;

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

 import org.openzen.zenscript.codemodel.statement.*;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 
 import java.util.Arrays;
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
         }
 
 		//javaWriter.label(min);
-		statement.iterator.target.acceptForIterator(new JavaForeachVisitor(this, statement.loopVariables, statement.content, start, end));
+		JavaForeachWriter iteratorWriter = new JavaForeachWriter(this, statement.loopVariables, statement.content, start, end);
+		if (statement.iterator.target.getBuiltin() == null) {
+			iteratorWriter.visitCustomIterator();
+		} else {
+			switch (statement.iterator.target.getBuiltin()) {
+				case ITERATOR_INT_RANGE:
+					iteratorWriter.visitIntRange();
+					break;
+				case ITERATOR_ARRAY_VALUES:
+					iteratorWriter.visitArrayValueIterator();
+					break;
+				case ITERATOR_ARRAY_KEY_VALUES:
+					iteratorWriter.visitArrayKeyValueIterator();
+					break;
+				case ITERATOR_ASSOC_KEYS:
+					iteratorWriter.visitAssocKeyIterator();
+					break;
+				case ITERATOR_ASSOC_KEY_VALUES:
+					iteratorWriter.visitAssocKeyValueIterator();
+					break;
+				case ITERATOR_STRING_CHARS:
+					iteratorWriter.visitStringCharacterIterator();
+					break;
+				default:
+					throw new IllegalArgumentException("Invalid iterator: " + statement.iterator.target.getBuiltin());
+			}
+		}
+		
 		javaWriter.goTo(start);
 		javaWriter.label(end);
 		return false;
 		javaWriter.label(start);
 		statement.value.accept(expressionVisitor);
 		if (statement.value.type == BasicTypeID.STRING)
-			javaWriter.invokeVirtual(new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", 0));
+			javaWriter.invokeVirtual(JavaExpressionVisitor.OBJECT_HASHCODE);
 		boolean out = false;
 
 		final boolean hasNoDefault = hasNoDefault(statement);

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.openzen.zenscript.codemodel.expression.switchvalue.CharSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.StringSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValueVisitor;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSwitchKeyVisitor implements SwitchValueVisitor<Integer> {
+	public static final JavaSwitchKeyVisitor INSTANCE = new JavaSwitchKeyVisitor();
+	
+	private JavaSwitchKeyVisitor() {}
+	
+	@Override
+	public Integer acceptInt(IntSwitchValue value) {
+		return value.value;
+	}
+
+	@Override
+	public Integer acceptChar(CharSwitchValue value) {
+		return (int) value.value;
+	}
+
+	@Override
+	public Integer acceptString(StringSwitchValue value) {
+		return value.value.hashCode();
+	}
+
+	@Override
+	public Integer acceptEnumConstant(EnumConstantSwitchValue value) {
+		return value.constant.ordinal;
+	}
+
+	@Override
+	public Integer acceptVariantOption(VariantOptionSwitchValue value) {
+		return value.option.getOrdinal();
+	}
+}

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 public class JavaWriter {
-    private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(
+    private static final JavaMethod STRING_CONCAT = JavaMethod.getNativeStatic(
             JavaClass.STRING,
             "concat",
-            "(Ljava/lang/String;)Ljava/lang/String;",
-            Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+            "(Ljava/lang/String;)Ljava/lang/String;");
 
-    public final JavaMethodInfo method;
+    public final JavaMethod method;
     public final HighLevelDefinition forDefinition;
 
     private final LocalVariablesSorter visitor;
     public JavaWriter(
             ClassVisitor visitor,
             boolean nameVariables,
-            JavaMethodInfo method,
+            JavaMethod method,
             HighLevelDefinition forDefinition,
             String signature,
             String[] exceptions,
         this.nameVariables = nameVariables;
     }
 
-    public JavaWriter(ClassVisitor visitor, JavaMethodInfo method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
+    public JavaWriter(ClassVisitor visitor, JavaMethod method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
         this(visitor, true, method, forDefinition, signature, exceptions, annotations);
     }
 
-    private static String signature(Class aClass) {
-        return Type.getDescriptor(aClass);
-    }
-
-    private static String internal(Class aClass) {
-        return Type.getInternalName(aClass);
-    }
-
     public void enableDebug() {
         debug = true;
     }
         if (debug)
             System.out.println("load " + parameter.index);
 
-        visitor.visitVarInsn(parameter.type.getOpcode(ILOAD), parameter.index);
+        visitor.visitVarInsn(Type.getType(parameter.typeDescriptor).getOpcode(ILOAD), parameter.index);
     }
 
     public void load(JavaLocalVariableInfo localVariable) {
         if (debug)
             System.out.println("store " + parameter.index);
 
-        visitor.visitVarInsn(parameter.type.getOpcode(ISTORE), parameter.index);
+        visitor.visitVarInsn(Type.getType(parameter.typeDescriptor).getOpcode(ISTORE), parameter.index);
     }
 
     public void store(JavaLocalVariableInfo localVariable) {
         }
     }
 
-    public void newArray(Class componentType) {
-        if (debug)
-            System.out.println("newArray " + componentType.getName());
-
-        visitor.visitTypeInsn(NEWARRAY, internal(componentType));
-    }
-
-    public void checkCast(Class newClass) {
-        if (debug)
-            System.out.println("checkCast " + newClass.getName());
-
-        visitor.visitTypeInsn(CHECKCAST, signature(newClass));
-    }
-
-    public void checkCast(String descriptor) {
+    public void checkCast(String internalName) {
         if (debug)
-            System.out.println("checkCast " + descriptor);
+            System.out.println("checkCast " + internalName);
 
-        visitor.visitTypeInsn(CHECKCAST, descriptor);
+        visitor.visitTypeInsn(CHECKCAST, internalName);
     }
 
     public void checkCast(Type type) {
         visitor.visitTypeInsn(INSTANCEOF, type.getDescriptor());
     }
 	
-	public void invokeStatic(JavaMethodInfo method) {
+	public void invokeStatic(JavaMethod method) {
 		visitor.visitMethodInsn(
 				INVOKESTATIC,
-				method.javaClass.internalName,
+				method.cls.internalName,
 				method.name,
 				method.descriptor,
 				false);
         invokeSpecial(Type.getInternalName(owner), name, descriptor);
     }
 
-	public void invokeSpecial (JavaMethodInfo method) {
-		invokeSpecial(method.javaClass.internalName, method.name, method.descriptor);
+	public void invokeSpecial(JavaMethod method) {
+		invokeSpecial(method.cls.internalName, method.name, method.descriptor);
 	}
 
-    public void invokeVirtual(JavaMethodInfo method) {
-        if (debug)
-            System.out.println("invokeVirtual " + method.javaClass.internalName + '.' + method.name + method.descriptor);
-
-        visitor.visitMethodInsn(INVOKEVIRTUAL, method.javaClass.internalName, method.name, method.descriptor, false);
-    }
-
-    public void invokeInterface(JavaMethodInfo method) {
+    public void invokeVirtual(JavaMethod method) {
         if (debug)
-            System.out.println("invokeInterface " + method.javaClass.internalName + '.' + method.name + method.descriptor);
+            System.out.println("invokeVirtual " + method.cls.internalName + '.' + method.name + method.descriptor);
 
-        visitor.visitMethodInsn(INVOKEINTERFACE, method.javaClass.internalName, method.name, method.descriptor, true);
+        visitor.visitMethodInsn(INVOKEVIRTUAL, method.cls.internalName, method.name, method.descriptor, false);
     }
 
-    public void newObject(Class type) {
+    public void invokeInterface(JavaMethod method) {
         if (debug)
-            System.out.println("newObject " + type.getName());
+            System.out.println("invokeInterface " + method.cls.internalName + '.' + method.name + method.descriptor);
 
-        visitor.visitTypeInsn(NEW, internal(type));
+        visitor.visitMethodInsn(INVOKEINTERFACE, method.cls.internalName, method.name, method.descriptor, true);
     }
 
     public void newObject(String internalName) {
         visitor.visitTypeInsn(NEW, internalName);
     }
 
-    public void construct(Class type, Class... arguments) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-        for (Class argument : arguments) {
-            descriptor.append(signature(argument));
-        }
-        descriptor.append(")V");
-
-        if (debug)
-            System.out.println("invokeSpecial " + internal(type) + ".<init>" + descriptor);
-
-        visitor.visitMethodInsn(INVOKESPECIAL, internal(type), "<init>", descriptor.toString(), false);
-    }
-
-    public void construct(String type, String... arguments) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-        for (String argument : arguments) {
-            descriptor.append(argument);
-        }
-        descriptor.append(")V");
-
-        if (debug)
-            System.out.println("invokeSpecial " + type + ".<init>" + descriptor);
-
-        visitor.visitMethodInsn(INVOKESPECIAL, type, "<init>", descriptor.toString(), false);
-    }
-
     public void goTo(Label lbl) {
         if (debug)
             System.out.println("goTo " + getLabelName(lbl));
 
         visitor.visitFieldInsn(GETFIELD, owner, name, descriptor);
     }
-
-    public void getField(Class owner, String name, Class descriptor) {
-        if (debug)
-            System.out.println("getField " + owner.getName() + '.' + name + ":" + descriptor.getName());
-
-        visitor.visitFieldInsn(GETFIELD, internal(owner), name, signature(descriptor));
-    }
 	
 	public void getField(JavaField field) {
         if (debug)
-            System.out.println("getField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("getField " + field.cls.internalName + '.' + field.name + ":" + field.descriptor);
 		
-		visitor.visitFieldInsn(GETFIELD, field.cls.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(GETFIELD, field.cls.internalName, field.name, field.descriptor);
 	}
 
     public void putField(String owner, String name, String descriptor) {
 
         visitor.visitFieldInsn(PUTFIELD, owner, name, descriptor);
     }
-
-    public void putField(Class owner, String name, Class descriptor) {
-        if (debug)
-            System.out.println("putField " + owner.getName() + '.' + name + ":" + descriptor.getName());
-
-        visitor.visitFieldInsn(PUTFIELD, internal(owner), name, signature(descriptor));
-    }
 	
 	public void putField(JavaField field) {
         if (debug)
-            System.out.println("putField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("putField " + field.cls.internalName + '.' + field.name + ":" + field.descriptor);
 		
-		visitor.visitFieldInsn(PUTFIELD, field.cls.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(PUTFIELD, field.cls.internalName, field.name, field.descriptor);
 	}
 
     public void getStaticField(String owner, String name, String descriptor) {
 	
 	public void getStaticField(JavaField field) {
         if (debug)
-            System.out.println("getStaticField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("getStaticField " + field.cls.internalName + '.' + field.name + ":" + field.descriptor);
 		
-		visitor.visitFieldInsn(GETSTATIC, field.cls.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(GETSTATIC, field.cls.internalName, field.name, field.descriptor);
 	}
 
     public void putStaticField(String owner, String name, String descriptor) {
 
         visitor.visitFieldInsn(PUTSTATIC, owner, name, descriptor);
     }
-
-    public void putStaticField(Class owner, Field field) {
-        if (debug)
-            System.out.println("putStatic " + owner.getName() + '.' + field.getName() + ":" + signature(field.getType()));
-
-        visitor.visitFieldInsn(PUTSTATIC, internal(owner), field.getName(), signature(field.getType()));
-    }
 	
 	public void putStaticField(JavaField field) {
         if (debug)
-            System.out.println("putStaticField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("putStaticField " + field.cls.internalName + '.' + field.name + ":" + field.descriptor);
 		
-		visitor.visitFieldInsn(PUTSTATIC, field.cls.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(PUTSTATIC, field.cls.internalName, field.name, field.descriptor);
 	}
 
     public void aThrow() {

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

 
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.definition.*;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.compiler.*;
 import org.openzen.zenscript.javashared.JavaClass;
 
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
+import org.openzen.zenscript.javashared.JavaVariantOption;
 
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
-	private static final JavaMethodInfo CLASS_FORNAME = new JavaMethodInfo(
-			JavaClass.CLASS,
-			"forName",
-			"(Ljava/lang/String;)Ljava/lang/Class;",
-			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-
-
-	private static final JavaMethodInfo ENUM_VALUEOF = new JavaMethodInfo(
-			JavaClass.ENUM,
-			"valueOf",
-			"(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;",
-			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+	private static final JavaMethod CLASS_FORNAME
+			= JavaMethod.getNativeStatic(JavaClass.CLASS, "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
+	private static final JavaMethod ENUM_VALUEOF
+			= JavaMethod.getNativeStatic(JavaClass.CLASS, "valueOf", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;");
+	private static final JavaMethod ARRAY_CLONE
+			= JavaMethod.getNativeVirtual(JavaClass.ARRAYS, "clone", "()Ljava/lang/Object;");
 
 	private final JavaClassWriter outerWriter;
 	private final JavaBytecodeContext context;
 
 	@Override
 	public byte[] visitClass(ClassDefinition definition) {
-		//Classes will always be created in a new File/Class
-
-        final Type superType;
-        if (definition.getSuperType() == null)
-            superType = Type.getType(Object.class);
-        else
-            superType = context.getType(definition.getSuperType());
+        final String superTypeInternalName = definition.getSuperType() == null ? "java/lang/Object" : context.getInternalName(definition.getSuperType());
 
-		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.CLASS);
+		JavaClass toClass = definition.getTag(JavaClass.class);
 		JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
-        //TODO: Interfaces?
+		List<String> interfaces = new ArrayList<>();
+		for (IDefinitionMember member : definition.members) {
+			if (member instanceof ImplementationMember)
+				interfaces.add(context.getInternalName(((ImplementationMember) member).type));
+		}
         String signature = null;
 
-        writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
+        writer.visit(Opcodes.V1_8, definition.modifiers, toClass.internalName, signature, superTypeInternalName, interfaces.toArray(new String[interfaces.size()]));
 		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
             member.accept(memberVisitor);
 
 	@Override
 	public byte[] visitInterface(InterfaceDefinition definition) {
-		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.INTERFACE);
+		JavaClass toClass = definition.getTag(JavaClass.class);
 		ClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 		//TODO: Calculate signature from generic parameters
-		//TODO: Extending Interfaces?
 		String signature = null;
-		writer.visit(Opcodes.V1_8, definition.modifiers | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, definition.name, signature, Type.getInternalName(Object.class), null);
+		String[] baseInterfaces = new String[definition.baseInterfaces.size()];
+		for (int i = 0; i < baseInterfaces.length; i++)
+			baseInterfaces[i] = context.getInternalName(definition.baseInterfaces.get(i));
+
+		writer.visit(Opcodes.V1_8, definition.modifiers | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, toClass.internalName, signature, "java/lang/Object", baseInterfaces);
 		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(memberVisitor);
 	public byte[] visitEnum(EnumDefinition definition) {
 		System.out.println("Compiling enum " + definition.name + " in " + definition.position.getFilename());
 
-        final Type superType;
-        if (definition.getSuperType() == null)
-            superType = Type.getType(Object.class);
-        else
-            superType = context.getType(definition.getSuperType());
+		String superTypeInternalName = definition.getSuperType() == null ? "java/lang/Object" : context.getInternalName(definition.getSuperType());
 
 		ClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-		writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, definition.name, "Ljava/lang/Enum<L" + definition.name + ";>;", superType.getInternalName(), null);
-
-		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.ENUM);
+		JavaClass toClass = definition.getTag(JavaClass.class);
+		writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, toClass.internalName, "Ljava/lang/Enum<L" + toClass.internalName + ";>;", superTypeInternalName, null);
 
 		//Enum Stuff(required!)
-		writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
+		writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + toClass.internalName + ";", null, null).visitEnd();
 
         final JavaMemberVisitor visitor = new JavaMemberVisitor(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
             member.accept(visitor);
         }
 
-		JavaClass arrayClass = JavaClass.fromInternalName("[L" + definition.name + ";", JavaClass.Kind.ARRAY);
-		JavaMethodInfo arrayClone = new JavaMethodInfo(arrayClass, "clone", "()Ljava/lang/Object;", Opcodes.ACC_PUBLIC);
-
-		JavaMethodInfo valuesMethodInfo = new JavaMethodInfo(toClass, "values", "()[L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethodInfo, definition, null, null);
+		JavaMethod valuesMethod = JavaMethod.getStatic(toClass, "values", "()[L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+		JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethod, definition, null, null);
 		valuesWriter.start();
-		valuesWriter.getStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
-		valuesWriter.invokeVirtual(arrayClone);
-		valuesWriter.checkCast("[L" + definition.name + ";");
+		valuesWriter.getStaticField(toClass.internalName, "$VALUES", "[L" + toClass.internalName + ";");
+		valuesWriter.invokeVirtual(ARRAY_CLONE);
+		valuesWriter.checkCast("[L" + toClass.internalName + ";");
 		valuesWriter.returnObject();
 		valuesWriter.end();
 
-		JavaMethodInfo valueOfMethodInfo = new JavaMethodInfo(toClass, "valueOf", "(Ljava/lang/String;)L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethodInfo, definition, null, null);
+		JavaMethod valueOfMethod = JavaMethod.getStatic(toClass, "valueOf", "(Ljava/lang/String;)L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+		JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethod, definition, null, null);
 		valueOfWriter.start();
 		valueOfWriter.invokeStatic(CLASS_FORNAME);
 		valueOfWriter.loadObject(0);
 		valueOfWriter.invokeStatic(ENUM_VALUEOF);
-		valueOfWriter.checkCast("L" + definition.name + ";");
+		valueOfWriter.checkCast(toClass.internalName);
 		valueOfWriter.returnObject();
 		valueOfWriter.end();
 
-
 		writer.visitEnd();
 		return writer.toByteArray();
 	}
 
         final String signature = context.getMethodSignature(definition.header);
 
-		final JavaClass toClass = new JavaClass(definition.pkg.fullName, CompilerUtils.calcClasName(definition.position), JavaClass.Kind.CLASS);
-		final JavaMethodInfo methodInfo = new JavaMethodInfo(toClass, definition.name, context.getMethodDescriptor(definition.header), CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC);
+		final JavaMethod method = definition.caller.getTag(JavaMethod.class);
 
-		final JavaWriter writer = new JavaWriter(outerWriter, true, methodInfo, definition, signature, null);
+		final JavaWriter writer = new JavaWriter(outerWriter, true, method, definition, signature, null);
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, writer);
         statementVisitor.start();
 		boolean returns = definition.statement.accept(statementVisitor);
 		if (!returns) {
-			ITypeID type = definition.header.returnType;
+			ITypeID type = definition.header.getReturnType();
 			if (CompilerUtils.isPrimitive(type))
 				writer.iConst0();
 			else if (type != BasicTypeID.VOID)
 		}
 
 		statementVisitor.end();
-
-		definition.setTag(JavaMethodInfo.class, methodInfo);
-		definition.caller.setTag(JavaMethodInfo.class, methodInfo);
 		return null;
 	}
 
 
 	@Override
 	public byte[] visitVariant(VariantDefinition variant) {
-
-		final String variantName = variant.name;
-		final JavaClass toClass = new JavaClass("", variantName, JavaClass.Kind.CLASS);
+		final JavaClass toClass = variant.getTag(JavaClass.class);
 		final JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 
 		final String ss = "<" + javaTypeGenericVisitor.getGenericSignature(variant.genericParameters) + ">Ljava/lang/Object;";
 		JavaClassWriter.registerSuperClass(variantName, "java/lang/Object");
 
-		writer.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, variantName, ss, "java/lang/Object", null);
+		writer.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, toClass.internalName, ss, "java/lang/Object", null);
 		writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "getDenominator", "()I", null, null).visitEnd();
 
-
 		final JavaMemberVisitor visitor = new JavaMemberVisitor(context, writer, toClass, variant);
 
 		final List<VariantDefinition.Option> options = variant.options;
 		//Each option is one of the possible child classes
 		for (final VariantDefinition.Option option : options) {
-			final String optionClassName = variantName + "$" + option.name;
-			final JavaClass optionClass = new JavaClass("", optionClassName, JavaClass.Kind.CLASS);
+			JavaVariantOption optionTag = option.getTag(JavaVariantOption.class);
 			final JavaClassWriter optionWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 			JavaClassWriter.registerSuperClass(optionClassName, variantName);
 
-			writer.visitInnerClass(optionClassName, variantName, option.name, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL);
-
-
-			option.setTag(JavaClass.class, optionClass);
-
+			writer.visitInnerClass(optionTag.variantOptionClass.internalName, optionTag.variantClass.internalName, option.name, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL);
 
 			//Generic option signature
 			final String signature;
 					builder.append(javaTypeGenericVisitor.getSignatureWithBound(type));
 				}
 				builder.append(">");
-				builder.append("L").append(variantName).append("<");
+				builder.append("L").append(toClass.internalName).append("<");
 
 				for (final TypeParameter genericParameter : variant.genericParameters) {
 					boolean t = true;
 				signature = builder.append(">;").toString();
 			}
 
-			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionClassName, signature, variantName, null);
-			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(context, optionWriter, optionClass, variant);
+			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionTag.variantOptionClass.internalName, signature, optionTag.variantClass.internalName, null);
+			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(context, optionWriter, optionTag.variantOptionClass, variant);
 			final StringBuilder optionInitDescBuilder = new StringBuilder("(");
 			final StringBuilder optionInitSignatureBuilder = new StringBuilder("(");
 
 			optionInitDescBuilder.append(")V");
 			optionInitSignatureBuilder.append(")V");
 
-
-			final JavaWriter initWriter = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "<init>", optionInitDescBuilder.toString(), Opcodes.ACC_PUBLIC), variant, optionInitSignatureBuilder.toString(), null);
+JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOptionClass, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
+			final JavaWriter initWriter = new JavaWriter(optionWriter, constructorMethod, variant, optionInitSignatureBuilder.toString(), null);
 			initWriter.start();
 			initWriter.loadObject(0);
 			initWriter.dup();
-			initWriter.invokeSpecial(variantName, "<init>", "()V");
+			initWriter.invokeSpecial(toClass.internalName, "<init>", "()V");
 			for (int i = 0; i < types.length; ++i) {
 				initWriter.dup();
 				initWriter.loadObject(i + 1);
 
 				final String descriptor = context.getDescriptor(types[i]);
-				initWriter.putField(optionClassName, "Field" + i, descriptor);
+				initWriter.putField(optionTag.variantOptionClass.internalName, "field" + i, descriptor);
 			}
 			initWriter.pop();
 			initWriter.ret();
 			initWriter.end();
 
-
 			//Denominator for switch-cases
-			final JavaWriter getDenominator = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "getDenominator", "()I", Modifiers.PUBLIC), null, null, null, "java/lang/Override");
+			JavaMethod denominator = JavaMethod.getVirtual(optionTag.variantOptionClass, "getDenominator", "()I", JavaModifiers.PUBLIC);
+			final JavaWriter getDenominator = new JavaWriter(optionWriter, denominator, null, null, null, "java/lang/Override");
 			getDenominator.start();
 			getDenominator.constant(option.ordinal);
 			getDenominator.returnInt();
 			getDenominator.end();
 
-
 			optionVisitor.end();
 			optionWriter.visitEnd();
 			final byte[] byteArray = optionWriter.toByteArray();
-			context.register(optionClassName, byteArray);
+			context.register(optionTag.variantOptionClass.internalName, byteArray);
 
 			//Print the option files, won't be in production
-			try (FileOutputStream out = new FileOutputStream(optionClassName + ".class")) {
+			try (FileOutputStream out = new FileOutputStream(optionTag.variantOptionClass.internalName.replace('/', '_') + ".class")) {
 				out.write(byteArray);
 			} catch (IOException e) {
 				e.printStackTrace();
 			member.accept(visitor);
 		}
 
-		final JavaWriter superInitWriter = new JavaWriter(writer, new JavaMethodInfo(toClass, "<init>", "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
+		final JavaWriter superInitWriter = new JavaWriter(writer, JavaMethod.getConstructor(toClass, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
 		superInitWriter.start();
 		superInitWriter.loadObject(0);
 		superInitWriter.invokeSpecial("java/lang/Object", "<init>", "()V");

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

 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.*;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
     private final ClassWriter writer;
         this.definition = definition;
 		this.context = context;
 
-        final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethodInfo(toClass, "<clinit>", "()V", 0), definition, null, null);
+        final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
         this.clinitStatementVisitor = new JavaStatementVisitor(context, javaWriter);
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
 
 	@Override
 	public Void visitConst(ConstMember member) {
-        //TODO calc signature
-        String signature = null;
-        final String descriptor = context.getDescriptor(member.type);
-        writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
-        member.setTag(JavaField.class, new JavaField(toClass, member.name, descriptor));
+		JavaField field = member.getTag(JavaField.class);
+        writer.visitField(CompilerUtils.calcAccess(member.modifiers), field.name, field.descriptor, field.signature, null).visitEnd();
         return null;
 	}
 
 	@Override
 	public Void visitField(FieldMember member) {
-
-        //TODO calc signature
-        String signature = null;
-        final String descriptor = context.getDescriptor(member.type);
-        writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
-        member.setTag(JavaField.class, new JavaField(toClass, member.name, descriptor));
+		JavaField field = member.getTag(JavaField.class);
+        writer.visitField(CompilerUtils.calcAccess(member.modifiers), field.name, field.descriptor, field.signature, null).visitEnd();
         return null;
     }
 
     @Override
     public Void visitConstructor(ConstructorMember member) {
         final boolean isEnum = definition instanceof EnumDefinition;
-        String descriptor = isEnum ? context.getEnumConstructorDescriptor(member.header) : context.getMethodDescriptor(member.header);
-        final JavaMethodInfo method = new JavaMethodInfo(toClass, "<init>", descriptor, isEnum ? Opcodes.ACC_PRIVATE : CompilerUtils.calcAccess(member.modifiers));
+        final JavaMethod method = member.getTag(JavaMethod.class);
 
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
 				constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
 			} else if (definition.getSuperType() == null) {
 				System.out.println("Writing regular constructor");
-				constructorWriter.load(Type.getType(Object.class), 0);
+				constructorWriter.loadObject(0);
 				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
 			}
-
         }
 
 		member.body.accept(statementVisitor);
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		final JavaMethodInfo method = new JavaMethodInfo(toClass, "close", "()V", Opcodes.ACC_PUBLIC);
+		final JavaMethod method = JavaMethod.getVirtual(toClass, "close", "()V", Opcodes.ACC_PUBLIC);
 
 		final Label constructorStart = new Label();
 		final Label constructorEnd = new Label();
         CompilerUtils.tagMethodParameters(context, member.header, member.isStatic());
 
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
-        int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
-                | (member.isStatic() ? Opcodes.ACC_STATIC : 0)
-                | CompilerUtils.calcAccess(member.modifiers);
-        final JavaMethodInfo method = new JavaMethodInfo(
-                toClass,
-                member.name,
-                context.getMethodSignature(member.header),
-                modifiers);
+        final JavaMethod method = member.getTag(JavaMethod.class);
 
 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
 			methodWriter.label(methodEnd);
 			statementVisitor.end();
 		}
-
-		member.setTag(JavaMethodInfo.class, method);
 		return null;
 	}
 
 	}
 
 	@Override
-	public Void visitCustomIterator(CustomIteratorMember member) {
+	public Void visitCustomIterator(IteratorMember member) {
 		return null;
 	}
 

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

-package org.openzen.zenscript.javabytecode.compiler.definitions;
-
-public class JavaOptionInfoTag {
-	public final int number;
-
-	public JavaOptionInfoTag(int number) {
-		this.number = number;
-	}
-}

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

 		return new JavaClass(pkg, internalName, kind, nameParts);
 	}
 	
+	public static String getNameFromFile(String filename) {
+		if (filename.indexOf('.') > 0)
+			return filename.substring(0, filename.indexOf('.'));
+		else
+			return filename;
+	}
+	
 	public final JavaClass outer;
 	
 	public final String pkg;

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

         for (FunctionParameter parameter : header.parameters) {
             signatureBuilder.append(getDescriptor(parameter.type));
         }
-        signatureBuilder.append(")").append(getDescriptor(header.returnType));
+        signatureBuilder.append(")").append(getDescriptor(header.getReturnType()));
         return signatureBuilder.toString();
     }
 	
 			descBuilder.append(getDescriptor(parameter.type));
         }
         descBuilder.append(")");
-        descBuilder.append(getDescriptor(header.returnType));
+        descBuilder.append(getDescriptor(header.getReturnType()));
         return descBuilder.toString();
     }
 }

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

 public class JavaField {
 	public final JavaClass cls;
 	public final String name;
-	public final String signature;
+	public final String descriptor;
+	public final String signature = null; // TODO: calculate signature too
 	
-	public JavaField(JavaClass cls, String name, String signature) {
+	public JavaField(JavaClass cls, String name, String descriptor) {
 		this.cls = cls;
 		this.name = name;
-		this.signature = signature;
+		this.descriptor = descriptor;
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public class JavaMethod {
+	public static JavaMethod getConstructor(JavaClass cls, String descriptor, int modifiers) {
+		return new JavaMethod(cls, Kind.CONSTRUCTOR, "<init>", true, descriptor, modifiers, false);
+	}
+	
+	public static JavaMethod getNativeConstructor(JavaClass cls, String descriptor) {
+		return new JavaMethod(cls, Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC, false);
+	}
+	
+	public static JavaMethod getDestructor(JavaClass cls, int modifiers) {
+		return new JavaMethod(cls, Kind.INSTANCE, "close", true, "()V", modifiers, false);
+	}
+	
+	public static JavaMethod getStatic(JavaClass cls, String name, String descriptor, int modifiers) {
+		return new JavaMethod(cls, Kind.STATIC, name, true, descriptor, modifiers | JavaModifiers.STATIC, false);
+	}
+	
+	public static JavaMethod getNativeStatic(JavaClass cls, String name, String descriptor) {
+		return new JavaMethod(cls, Kind.STATIC, name, false, descriptor, JavaModifiers.STATIC | JavaModifiers.PUBLIC, false);
+	}
+	
+	public static JavaMethod getVirtual(JavaClass cls, String name, String descriptor, int modifiers) {
+		return new JavaMethod(cls, Kind.INSTANCE, name, true, descriptor, modifiers, false);
+	}
+	
+	public static JavaMethod getNativeVirtual(JavaClass cls, String name, String descriptor) {
+		return new JavaMethod(cls, Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC, false);
+	}
+
+	public static JavaMethod getNativeExpansion(JavaClass cls, String name, String descriptor) {
+		return new JavaMethod(cls, Kind.EXPANSION, name, false, descriptor, JavaModifiers.PUBLIC | JavaModifiers.STATIC, false);
+	}
+	
 	public final JavaClass cls;
 	public final Kind kind;
 	public final String name;
 	
 	public final String descriptor;
 	public final int modifiers;
+	public final boolean genericResult;
 	
-	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers) {
+	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers, boolean genericResult) {
 		this.cls = cls;
 		this.kind = kind;
 		this.name = name;
 		
 		this.descriptor = descriptor;
 		this.modifiers = modifiers;
+		this.genericResult = genericResult;
 	}
 	
 	public JavaMethod(JavaNativeTranslation<?> translation) {
 		this.translation = translation;
 		this.descriptor = "";
 		this.modifiers = 0;
+		this.genericResult = false;
 	}
 	
 	public enum Kind {
 		STATIC,
+		STATICINIT,
 		INSTANCE,
 		EXPANSION,
 		CONSTRUCTOR,

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

 	}
 	
 	public void addConstructor(String key, String descriptor) {
-		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC));
+		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC, false));
 	}
 	
 	public void addInstanceMethod(String key, String name, String descriptor) {
-		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC));
+		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC, false));
 	}
 	
 	public JavaMethod getMethod(String name) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaParameterInfo.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaParameterInfo.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.javabytecode;
-
-import org.objectweb.asm.Type;
+package org.openzen.zenscript.javashared;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaParameterInfo {
 	public final int index;
-	public final Type type;
+	public final String typeDescriptor;
 
-	public JavaParameterInfo(int index, Type type) {
+	public JavaParameterInfo(int index, String typeDescriptor) {
 		this.index = index;
-		this.type = type;
+		this.typeDescriptor = typeDescriptor;
 	}
 }

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

 	
 	public static JavaSynthesizedClass createRangeName(RangeTypeID range) {
 		String signature = getRangeSignature(range);
-		String className = signature + "Range";
+		String className = signature;
 		JavaClass cls = new JavaClass("zsynthetic", className, JavaClass.Kind.CLASS);
 		return new JavaSynthesizedClass(cls, extractTypeParameters(range));
 	}

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

 			case UINT: return "UInt";
 			case LONG: return "Long";
 			case ULONG: return "ULong";
+			case USIZE: return "USize";
 			case FLOAT: return "Float";
 			case DOUBLE: return "Double";
 			case CHAR: return "Char";
 		for (FunctionParameter parameter : function.header.parameters)
 			result.append(parameter.type.accept(this));
 		result.append("To");
-		result.append(function.header.returnType.accept(this));
+		result.append(function.header.getReturnType().accept(this));
 		if (function.header.thrownType != null) {
 			result.append("Throwing");
 			result.append(function.header.thrownType.accept(this));
 	@Override
 	public String visitRange(RangeTypeID range) {
 		StringBuilder result = new StringBuilder();
-		result.append(range.from.accept(this));
-		if (range.from != range.to)
-			result.append(range.to.accept(this));
+		result.append(range.baseType.accept(this));
 		result.append("Range");
 		return result.toString();
 	}

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

 				case UINT: return "Ljava/lang/Integer;";
 				case LONG: return "Ljava/lang/Long;";
 				case ULONG: return "Ljava/lang/Long;";
+				case USIZE: return "I"; // special case: optional usize fits in an int where null = -1
 				case FLOAT: return "Ljava/lang/Float;";
 				case DOUBLE: return "Ljava/lang/Double;";
 				case STRING: return "Ljava/lang/String;";
 				case UINT: return "I";
 				case LONG: return "J";
 				case ULONG: return "J";
+				case USIZE: return "I";
 				case FLOAT: return "F";
 				case DOUBLE: return "D";
 				case STRING: return "Ljava/lang/String;";
 
     @Override
     public String visitArray(ArrayTypeID array) {
-		return "[" + array.elementType.accept(this);
+		if (array.elementType == BasicTypeID.BYTE)
+			return "[B"; // instead of int[], save memory, save compatibility
+		else if (array.elementType == BasicTypeID.USHORT)
+			return "[S"; // instead of int[], save memory
+		else
+			return "[" + array.elementType.accept(this);
     }
 
     @Override

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

 				case UINT: return "java/lang/Integer";
 				case LONG: return "java/lang/Long";
 				case ULONG: return "java/lang/Long";
+				case USIZE: return "java/lang/Integer";
 				case FLOAT: return "java/lang/Float";
 				case DOUBLE: return "java/lang/Double";
 				case STRING: return "java/lang/String";
 				case UINT: return "I";
 				case LONG: return "J";
 				case ULONG: return "J";
+				case USIZE: return "I";
 				case FLOAT: return "F";
 				case DOUBLE: return "D";
 				case STRING: return "java/lang/String";

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

 		for (FunctionParameter parameter : function.header.parameters)
 			result.append(parameter.type.accept(this));
 		result.append("To");
-		result.append(function.header.returnType.accept(this));
+		result.append(function.header.getReturnType().accept(this));
 		result.append("Function");
 		return result.toString();
 	}
 
 	@Override
 	public String visitRange(RangeTypeID range) {
-		return range.from == range.to
-				? range.from.accept(this) + "Range"
-				: range.from.accept(this) + range.to.accept(this) + "Range";
+		return range.baseType.accept(this) + "Range";
 	}
 
 	@Override

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

 
 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 	private static final boolean DEBUG_EMPTY = true;
 	
 	private final JavaContext context;
-	private final String filename;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	private final JavaPrepareDefinitionMemberVisitor memberPreparer;
 	
 	public JavaPrepareClassMethodVisitor(
 			JavaContext context,
-			String filename,
 			JavaClass cls,
 			JavaNativeClass nativeClass,
 			JavaPrepareDefinitionMemberVisitor memberPreparer,
 			boolean startsEmpty) {
 		this.context = context;
-		this.filename = filename;
 		this.cls = cls;
 		this.nativeClass = nativeClass;
 		this.memberPreparer = memberPreparer;
 
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
-		visitFunctional(member, "<init>");
+		visitFunctional(member, member.header, "<init>");
 		return null;
 	}
 
 
 	@Override
 	public Void visitMethod(MethodMember member) {
-		visitFunctional(member, member.name);
+		visitFunctional(member, member.header, member.name);
 		return null;
 	}
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		visitFunctional(member, "get" + StringExpansion.capitalize(member.name));
+		visitFunctional(member, new FunctionHeader(member.type), "get" + StringExpansion.capitalize(member.name));
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		visitFunctional(member, "set" + StringExpansion.capitalize(member.name));
+		visitFunctional(member, new FunctionHeader(BasicTypeID.VOID, member.type), "set" + StringExpansion.capitalize(member.name));
 		return null;
 	}
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
-		visitFunctional(member, getOperatorName(member.operator));
+		visitFunctional(member, member.header, getOperatorName(member.operator));
 		return null;
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
-		visitFunctional(member, "to" + member.toType.accept(new JavaTypeNameVisitor()));
+		visitFunctional(member, member.header, "to" + member.toType.accept(new JavaTypeNameVisitor()));
 		return null;
 	}
 
 	@Override
-	public Void visitCustomIterator(CustomIteratorMember member) {
-		visitFunctional(member, member.getLoopVariableCount() == 1 ? "iterator" : "iterator" + member.getLoopVariableCount());
+	public Void visitCustomIterator(IteratorMember member) {
+		visitFunctional(member, member.header, member.getLoopVariableCount() == 1 ? "iterator" : "iterator" + member.getLoopVariableCount());
 		return null;
 	}
 
 	@Override
 	public Void visitCaller(CallerMember member) {
-		visitFunctional(member, "call");
+		visitFunctional(member, member.header, "call");
 		return null;
 	}
 
 			JavaClass implementationClass = new JavaClass(cls, member.type.accept(new JavaTypeNameVisitor()) + "Implementation", JavaClass.Kind.CLASS);
 			member.setTag(JavaImplementation.class, new JavaImplementation(false, implementationClass));
 			
-			JavaPrepareClassMethodVisitor visitor = new JavaPrepareClassMethodVisitor(context, filename, implementationClass, null, memberPreparer, true);
+			JavaPrepareClassMethodVisitor visitor = new JavaPrepareClassMethodVisitor(context, implementationClass, null, memberPreparer, true);
 			for (IDefinitionMember m : member.members)
 				m.accept(visitor);
 		}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
-		JavaPrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaPrepareDefinitionMemberVisitor(context, filename);
+		JavaPrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaPrepareDefinitionMemberVisitor(context);
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
 		if (DEBUG_EMPTY && cls.empty)
 		}
 	}
 	
-	private void visitFunctional(FunctionalMember member, String name) {
+	private void visitFunctional(DefinitionMember member, FunctionHeader header, String name) {
 		NativeTag nativeTag = member.getTag(NativeTag.class);
 		JavaMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			if (baseMethod == null)
 				throw new IllegalStateException("Base method not yet prepared!");
 			
-			method = new JavaMethod(cls, baseMethod.kind, baseMethod.name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers));
+			method = new JavaMethod(
+					cls,
+					baseMethod.kind,
+					baseMethod.name,
+					true,
+					context.getMethodDescriptor(header),
+					JavaModifiers.getJavaModifiers(member.modifiers),
+					header.getReturnType() instanceof GenericTypeID);
 		} else if (method == null) {
-			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers));
+			method = new JavaMethod(
+					cls,
+					getKind(member),
+					name,
+					true,
+					context.getMethodDescriptor(header),
+					JavaModifiers.getJavaModifiers(member.modifiers),
+					header.getReturnType() instanceof GenericTypeID);
 		}
 		
-		if (method.compile) {
+		if (method.compile && member.getBuiltin() != BuiltinID.CLASS_DEFAULT_CONSTRUCTOR) {
 			if (DEBUG_EMPTY && cls.empty)
 				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
 			

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionMemberVisitor.java

  */
 public class JavaPrepareDefinitionMemberVisitor implements DefinitionVisitor<JavaClass> {
 	private final JavaContext context;
-	private final String filename;
 	
-	public JavaPrepareDefinitionMemberVisitor(JavaContext context, String filename) {
+	public JavaPrepareDefinitionMemberVisitor(JavaContext context) {
 		this.context = context;
-		this.filename = filename;
 	}
 	
 	private boolean isPrepared(HighLevelDefinition definition) {
 			return;
 			
 		HighLevelDefinition definition = ((DefinitionTypeID)type).definition;
+		System.out.println("Preparing " + definition.name);
 		definition.accept(this);
 	}
 	
 			return definition.getTag(JavaClass.class);
 		
 		JavaClass cls = definition.getTag(JavaClass.class);
-		JavaMethod method = new JavaMethod(cls, JavaMethod.Kind.STATIC, definition.name, true, context.getMethodDescriptor(definition.header), JavaModifiers.getJavaModifiers(definition.modifiers));
+		JavaMethod method = JavaMethod.getStatic(cls, definition.name, context.getMethodDescriptor(definition.header), JavaModifiers.getJavaModifiers(definition.modifiers));
 		definition.caller.setTag(JavaMethod.class, method);
 		return cls;
 	}
 	
 	private void visitClassMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
 		System.out.println("Preparing " + cls.internalName);
-		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, filename, cls, nativeClass, this, startsEmpty);
+		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, cls, nativeClass, this, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionVisitor.java

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.javashared.JavaModifiers;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 /**
 			cls.addInstanceMethod("appendUInt", "append", "(I)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendLong", "append", "(J)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendULong", "append", "(J)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendUSize", "append", "(I)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendFloat", "append", "(F)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendDouble", "append", "(D)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendChar", "append", "(C)Ljava/lang/StringBuilder;");
 		{
 			JavaNativeClass list = new JavaNativeClass(new JavaClass("java.util", "List", JavaClass.Kind.INTERFACE));
 			JavaClass arrayList = new JavaClass("java.util", "ArrayList", JavaClass.Kind.CLASS);
-			list.addMethod("constructor", new JavaMethod(arrayList, JavaMethod.Kind.CONSTRUCTOR, "", false, "()V", JavaModifiers.PUBLIC));
+			list.addMethod("constructor", JavaMethod.getNativeConstructor(arrayList, "()V"));
 			list.addInstanceMethod("add", "add", "(Ljava/lang/Object;)Z"); List<?> l;
 			list.addInstanceMethod("insert", "add", "(Ljava/lang/Object;I)V");
 			list.addInstanceMethod("remove", "remove", "(java/lang/Object;)Z");
 			JavaClass math = new JavaClass("java.lang", "Math", JavaClass.Kind.CLASS);
 			
 			JavaNativeClass cls = new JavaNativeClass(integer);
-			cls.addMethod("min", new JavaMethod(math, JavaMethod.Kind.STATIC, "min", false, "(II)I", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
-			cls.addMethod("max", new JavaMethod(math, JavaMethod.Kind.STATIC, "max", false, "(II)I", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
-			cls.addMethod("toHexString", new JavaMethod(integer, JavaMethod.Kind.EXPANSION, "toHexString", false, "()Ljava/lang/String;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("min", JavaMethod.getNativeStatic(math, "min", "(II)I"));
+			cls.addMethod("max", JavaMethod.getNativeStatic(math, "max", "(II)I"));
+			cls.addMethod("toHexString", JavaMethod.getNativeExpansion(integer, "toHexString", "(I)Ljava/lang/String;"));
 			nativeClasses.put("stdlib::Integer", cls);
+			nativeClasses.put("stdlib::USize", cls);
 		}
 		
 		{
 		{
 			JavaClass arrays = new JavaClass("java.lang", "Arrays", JavaClass.Kind.CLASS);
 			JavaNativeClass cls = new JavaNativeClass(arrays);
-			cls.addMethod("sort", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "sort", false, "([Ljava/lang/Object;)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("sort", JavaMethod.getNativeExpansion(arrays, "sort", "([Ljava/lang/Object;)[Ljava/lang/Object;"));
 			cls.addMethod("sorted", new JavaMethod((expression, translator) -> {
 				return translator.sorted(((CallExpression)expression).target);
 			}));
-			cls.addMethod("sortWithComparator", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "sort", false, "([Ljava/lang/Object;Ljava/lang/Comparator;)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("sortWithComparator", JavaMethod.getNativeExpansion(arrays, "sort", "([Ljava/lang/Object;Ljava/lang/Comparator;)[Ljava/lang/Object;"));
 			cls.addMethod("sortedWithComparator", new JavaMethod((expression, translator) -> {
 				return translator.sortedWithComparator(
 						((CallExpression)expression).target,
 			cls.addMethod("copy", new JavaMethod((expression, translator) -> {
 				return translator.copy(((CallExpression)expression).target);
 			}));
-			cls.addMethod("copyResize", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "copyOf", false, "([Ljava/lang/Object;I)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("copyResize", JavaMethod.getNativeExpansion(arrays, "copyOf", "([Ljava/lang/Object;I)[Ljava/lang/Object;"));
 			cls.addMethod("copyTo", new JavaMethod((expression, translator) -> {
 				return translator.copyTo((CallExpression)expression);
 			}));
 			cls.addInstanceMethod("readSlice", "read", "([CII)I");
 			nativeClasses.put("io::StringReader", cls);
 		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "InputStream", JavaClass.Kind.INTERFACE), true);
+			cls.addInstanceMethod("destructor", "close", "()V");
+			cls.addInstanceMethod("read", "read", "()I");
+			cls.addInstanceMethod("readArray", "read", "([B)I");
+			cls.addInstanceMethod("readSlice", "read", "([BII)I");
+			nativeClasses.put("io::InputStream", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "OutputStream", JavaClass.Kind.INTERFACE), true);
+			cls.addInstanceMethod("destructor", "close", "()V");
+			cls.addInstanceMethod("write", "write", "()I");
+			cls.addInstanceMethod("writeArray", "write", "([B)V");
+			cls.addInstanceMethod("writeSlice", "write", "([BII)V");
+			nativeClasses.put("io::OutputStream", cls);
+		}
 	}
 	
 	private final String filename;
 		if (isPrepared(definition))
 			return definition.getTag(JavaClass.class);
 		
-		JavaClass cls = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(definition.pkg.fullName, JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
 		definition.setTag(JavaClass.class, cls);
 		return cls;
 	}
 			definition.setTag(JavaNativeClass.class, nativeClasses.get(nativeTag.value));
 		}
 		
-		JavaClass cls = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(definition.pkg.fullName, JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
 		definition.setTag(JavaClass.class, cls);
 		return cls;
 	}
 		variant.setTag(JavaClass.class, cls);
 		
 		for (VariantDefinition.Option option : variant.options) {
-			JavaClass variantCls = new JavaClass(cls.fullName, option.name, JavaClass.Kind.CLASS);
+			JavaClass variantCls = new JavaClass(cls, option.name, JavaClass.Kind.CLASS);
 			option.setTag(JavaVariantOption.class, new JavaVariantOption(cls, variantCls));
 		}
 		

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareExpansionMethodVisitor.java

 
 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
-		visitFunctional(member, "");
+		visitFunctional(member, member.header, "");
 		return null;
 	}
 
 		if (nativeClass != null && nativeClass.nonDestructible)
 			return null;
 		
-		visitFunctional(member, "");
+		visitFunctional(member, member.header, "");
 		return null;
 	}
 
 	@Override
 	public Void visitMethod(MethodMember member) {
-		visitFunctional(member, member.name);
+		visitFunctional(member, member.header, member.name);
 		return null;
 	}
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		visitFunctional(member, "get" + StringExpansion.capitalize(member.name));
+		visitFunctional(member, new FunctionHeader(member.type), "get" + StringExpansion.capitalize(member.name));
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		visitFunctional(member, "set" + StringExpansion.capitalize(member.name));
+		visitFunctional(member, new FunctionHeader(BasicTypeID.VOID, member.type), "set" + StringExpansion.capitalize(member.name));
 		return null;
 	}
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
-		visitFunctional(member, getOperatorName(member.operator));
+		visitFunctional(member, member.header, getOperatorName(member.operator));
 		return null;
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
-		visitFunctional(member, "to" + member.toType.accept(new JavaTypeNameVisitor()));
+		visitFunctional(member, member.header, "to" + member.toType.accept(new JavaTypeNameVisitor()));
 		return null;
 	}
 
 	@Override
-	public Void visitCustomIterator(CustomIteratorMember member) {
-		visitFunctional(member, member.getLoopVariableCount() == 1 ? "iterator" : "iterator" + member.getLoopVariableCount());
+	public Void visitCustomIterator(IteratorMember member) {
+		visitFunctional(member, member.header, member.getLoopVariableCount() == 1 ? "iterator" : "iterator" + member.getLoopVariableCount());
 		return null;
 	}
 
 	@Override
 	public Void visitCaller(CallerMember member) {
-		visitFunctional(member, "call");
+		visitFunctional(member, member.header, "call");
 		return null;
 	}
 
 		return null;
 	}
 	
-	private void visitFunctional(FunctionalMember member, String name) {
+	private void visitFunctional(DefinitionMember member, FunctionHeader header, String name) {
 		NativeTag nativeTag = member.getTag(NativeTag.class);
 		JavaMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		if (method == null)
-			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers)); 
+			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(header), JavaModifiers.getJavaModifiers(member.modifiers), header.getReturnType() instanceof GenericTypeID); 
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/ExpressionHoistingChecker.java

 import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
 		return false;
 	}
 
+	@Override
+	public Boolean visitConstantUSize(ConstantUSizeExpression expression) {
+		return false;
+	}
+
 	@Override
 	public Boolean visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		return true;

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/FormattingUtils.java

 
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
 			
 			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.UNDETERMINED) {
 				result.append(" as ");
-				result.append(header.returnType.accept(typeFormatter));
+				result.append(header.getReturnType().accept(typeFormatter));
 			}
 			
 			parameterIndex++;
 		}
 		result.append(")");
-		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.UNDETERMINED) {
+		if (!settings.showAnyInFunctionHeaders || header.getReturnType() != BasicTypeID.UNDETERMINED) {
 			result.append(" as ");
-			result.append(header.returnType.accept(typeFormatter));
+			result.append(header.getReturnType().accept(typeFormatter));
 		}
 	}
 	

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDefinitionVisitor.java

 				output.append(",\n");
 			}
 			output.append("\t").append(constant.name);
-			if (constant.constructor != null) {
-				
+			if (constant.constructor != null && constant.constructor.arguments.arguments.length > 0) {
 				output.append("(");
 				boolean first = true;
 				for (Expression argument : constant.constructor.arguments.arguments) {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaExpansionMemberCompiler.java

 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 		else
 			JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, expansionTypeParameters, header.typeParameters);
 		
-		output.append(header.returnType.accept(scope.typeVisitor));
+		output.append(header.getReturnType().accept(scope.typeVisitor));
 		output.append(" ");
 		output.append(method.name);
 		formatParameters(member.isStatic(), expansionTypeParameters, header);
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		compileMethod(member, member.header, member.body);
+		compileMethod(member, new FunctionHeader(member.type), member.body);
 		return null;
 	}
 
 	}
 
 	@Override
-	public Void visitCustomIterator(CustomIteratorMember member) {
+	public Void visitCustomIterator(IteratorMember member) {
 		compileMethod(member, new FunctionHeader(scope.semanticScope.getTypeRegistry().getIterator(member.getLoopVariableTypes())), member.body);
 		return null;
 	}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaMemberCompiler.java

 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 		
 		modifiers(member.modifiers);
 		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, header.typeParameters, true);
-		output.append(header.returnType.accept(scope.typeVisitor));
+		output.append(header.getReturnType().accept(scope.typeVisitor));
 		output.append(" ");
 		output.append(method.name);
 		formatParameters(member.isStatic(), header);
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		compileMethod(member, member.header, member.body);
+		compileMethod(member, new FunctionHeader(member.type), member.body);
 		return null;
 	}
 
 	}
 
 	@Override
-	public Void visitCustomIterator(CustomIteratorMember member) {
+	public Void visitCustomIterator(IteratorMember member) {
 		compileMethod(member, new FunctionHeader(scope.semanticScope.getTypeRegistry().getIterator(member.getLoopVariableTypes())), member.body);
 		return null;
 	}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceExpressionFormatter.java

 import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
-import org.openzen.zenscript.javashared.JavaNativeTranslation;
 import org.openzen.zenscript.javashared.JavaNativeTranslator;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 		return new ExpressionString("(short)" + Integer.toString(expression.value), JavaOperator.CAST);
 	}
 
+	@Override
+	public ExpressionString visitConstantUSize(ConstantUSizeExpression expression) {
+		return new ExpressionString(Integer.toString((int)expression.value), JavaOperator.CAST);
+	}
+
 	@Override
 	public ExpressionString visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		StringBuilder result = new StringBuilder();
 
 	@Override
 	public ExpressionString visitNull(NullExpression expression) {
+		if (expression.type.withoutOptional() == BasicTypeID.USIZE)
+			return new ExpressionString("-1", JavaOperator.PRIMARY); // usize? null = -1
+		
 		return new ExpressionString("null", JavaOperator.PRIMARY);
 	}
 
 			case ULONG_COUNT_HIGH_ZEROES: return callAsStatic("Long.numberOfLeadingZeros", call);
 			case ULONG_COUNT_LOW_ONES: return new ExpressionString("Long.numberOfTrailingZeros(~" + call.target.accept(this).value + ")", JavaOperator.CALL);
 			case ULONG_COUNT_HIGH_ONES: return new ExpressionString("Long.numberOfLeadingZeros(~" + call.target.accept(this).value + ")", JavaOperator.CALL);
+			case USIZE_NOT: return unaryPrefix(call, JavaOperator.INVERT);
+			case USIZE_ADD_USIZE: return binary(call, JavaOperator.ADD);
+			case USIZE_SUB_USIZE: return binary(call, JavaOperator.SUB);
+			case USIZE_MUL_USIZE: return binary(call, JavaOperator.MUL);
+			case USIZE_DIV_USIZE: return binary(call, JavaOperator.DIV);
+			case USIZE_MOD_USIZE: return binary(call, JavaOperator.MOD);
+			case USIZE_AND_USIZE: return binary(call, JavaOperator.AND);
+			case USIZE_OR_USIZE: return binary(call, JavaOperator.OR);
+			case USIZE_XOR_USIZE: return binary(call, JavaOperator.XOR);
+			case USIZE_SHL: return binary(call, JavaOperator.SHL);
+			case USIZE_SHR: return binary(call, JavaOperator.USHR);
+			case USIZE_COUNT_LOW_ZEROES: return callAsStatic("Integer.numberOfTrailingZeros", call);
+			case USIZE_COUNT_HIGH_ZEROES: return callAsStatic("Integer.numberOfLeadingZeros", call);
+			case USIZE_COUNT_LOW_ONES: return new ExpressionString("Integer.numberOfTrailingZeros(~" + call.target.accept(this).value + ")", JavaOperator.CALL);
+			case USIZE_COUNT_HIGH_ONES: return new ExpressionString("Integer.numberOfLeadingZeros(~" + call.target.accept(this).value + ")", JavaOperator.CALL);
 			case FLOAT_NEG: return unaryPrefix(call, JavaOperator.NEG);
 			case FLOAT_ADD_FLOAT: return binary(call, JavaOperator.ADD);
 			case FLOAT_SUB_FLOAT: return binary(call, JavaOperator.SUB);
 			case FUNCTION_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
 			case OBJECT_SAME: return binary(call, JavaOperator.EQUALS);
 			case OBJECT_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
-			case OPTIONAL_IS_NULL: return call.target.accept(this).unaryPostfix(JavaOperator.EQUALS, " == null");
-			case OPTIONAL_IS_NOT_NULL: return call.target.accept(this).unaryPostfix(JavaOperator.NOTEQUALS, " != null");
+			case OPTIONAL_IS_NULL: return call.target.type.withoutOptional() == BasicTypeID.USIZE
+					? call.target.accept(this).unaryPostfix(JavaOperator.NOTEQUALS, " < 0")
+					: call.target.accept(this).unaryPostfix(JavaOperator.EQUALS, " == null");
+			case OPTIONAL_IS_NOT_NULL: return call.target.type.withoutOptional() == BasicTypeID.USIZE
+					? call.target.accept(this).unaryPostfix(JavaOperator.NOTEQUALS, " >= 0")
+					: call.target.accept(this).unaryPostfix(JavaOperator.NOTEQUALS, " != null");
 			case AUTOOP_NOTEQUALS:
 				throw new UnsupportedOperationException("Not yet supported!");
 		}
 			case SHORT_PARSE_WITH_BASE: return callStatic("Short.parseShort", call);
 			case USHORT_PARSE: return callStatic("Integer.parseShort", call);
 			case USHORT_PARSE_WITH_BASE: return callStatic("Integer.parseShort", call);
-			case INT_PARSE: return callStatic("Integer.parseInt", call);
-			case INT_PARSE_WITH_BASE: return callStatic("Integer.parseInt", call);
+			case INT_PARSE:
+			case USIZE_PARSE:
+				return callStatic("Integer.parseInt", call);
+			case INT_PARSE_WITH_BASE:
+			case USIZE_PARSE_WITH_BASE:
+				return callStatic("Integer.parseInt", call);
 			case UINT_PARSE: return callStatic("Integer.parseUnsignedInt", call);
 			case UINT_PARSE_WITH_BASE: return callStatic("Integer.parseUnsignedInt", call);
 			case LONG_PARSE: return callStatic("Long.parseLong", call);
 					call.left.accept(this).unaryPostfix(JavaOperator.AND_FFFF),
 					call.right.accept(this).unaryPostfix(JavaOperator.AND_FFFF),
 					call.comparison);
-			case INT_COMPARE: return compare(call.left, call.right, call.comparison);
+			case INT_COMPARE:
+			case USIZE_COMPARE:
+				return compare(call.left, call.right, call.comparison);
 			case UINT_COMPARE: return compare(callAsStatic("Integer.compareUnsigned", call.left, call.right), call.comparison);
 			case LONG_COMPARE: return compare(call.left, call.right, call.comparison);
 			case ULONG_COMPARE: return compare(callAsStatic("Long.compareUnsigned", call.left, call.right), call.comparison);
 		switch (builtin) {
 			case INT_HIGHEST_ONE_BIT:
 			case UINT_HIGHEST_ONE_BIT:
+			case USIZE_HIGHEST_ONE_BIT:
 				return callAsStatic("Integer.highestOneBit", call);
 			case INT_LOWEST_ONE_BIT:
 			case UINT_LOWEST_ONE_BIT:
+			case USIZE_LOWEST_ONE_BIT:
 				return callAsStatic("Integer.lowestOneBit", call);
 			case INT_HIGHEST_ZERO_BIT:
 			case UINT_HIGHEST_ZERO_BIT:
+			case USIZE_HIGHEST_ZERO_BIT:
 				return new ExpressionString("Integer.highestOneBit(~" + call.target.accept(this).value + ")", JavaOperator.CALL);
 			case INT_LOWEST_ZERO_BIT:
 			case UINT_LOWEST_ZERO_BIT:
+			case USIZE_LOWEST_ZERO_BIT:
 				return new ExpressionString("Integer.lowestOneBit(~" + call.target.accept(this).value + ")", JavaOperator.CALL);
 			case INT_BIT_COUNT:
 			case UINT_BIT_COUNT:
+			case USIZE_BIT_COUNT:
 				return callAsStatic("Integer.bitCount", call);
 			case LONG_HIGHEST_ONE_BIT:
 			case ULONG_HIGHEST_ONE_BIT:
 			case LONG_GET_MAX_VALUE: return new ExpressionString("Long.MAX_VALUE", JavaOperator.MEMBER);
 			case ULONG_GET_MIN_VALUE: return new ExpressionString("0", JavaOperator.PRIMARY);
 			case ULONG_GET_MAX_VALUE: return new ExpressionString("-1", JavaOperator.PRIMARY);
+			case USIZE_GET_MIN_VALUE: return new ExpressionString("0", JavaOperator.PRIMARY);
+			case USIZE_GET_MAX_VALUE: return new ExpressionString("Integer.MAX_VALUE", JavaOperator.MEMBER);
+			case USIZE_BITS: return new ExpressionString("32", JavaOperator.PRIMARY);
 			case FLOAT_GET_MIN_VALUE: return new ExpressionString("Float.MIN_VALUE", JavaOperator.MEMBER);
 			case FLOAT_GET_MAX_VALUE: return new ExpressionString("Float.MAX_VALUE", JavaOperator.MEMBER);
 			case DOUBLE_GET_MIN_VALUE: return new ExpressionString("Double.MIN_VALUE", JavaOperator.MEMBER);
 			case BYTE_TO_USHORT: return castPostfix(cast, JavaOperator.AND_FF);
 			case BYTE_TO_INT: return castPostfix(cast, JavaOperator.AND_FF);
 			case BYTE_TO_UINT: return castPostfix(cast, JavaOperator.AND_FF);
+			case BYTE_TO_USIZE: return castPostfix(cast, JavaOperator.AND_FF);
 			case BYTE_TO_LONG: return castPostfix(cast, JavaOperator.AND_FFL);
 			case BYTE_TO_ULONG: return castPostfix(cast, JavaOperator.AND_FFL);
 			case BYTE_TO_FLOAT: cast(castPostfix(cast, JavaOperator.AND_FF), "float");
 			case SBYTE_TO_USHORT: return castImplicit(cast, "int");
 			case SBYTE_TO_INT: return castImplicit(cast, "int");
 			case SBYTE_TO_UINT: return castImplicit(cast, "int");
+			case SBYTE_TO_USIZE: return castImplicit(cast, "int");
 			case SBYTE_TO_LONG: return castImplicit(cast, "long");
 			case SBYTE_TO_ULONG: return castImplicit(cast, "long");
 			case SBYTE_TO_FLOAT: return castImplicit(cast, "float");
 			case SHORT_TO_USHORT: return castImplicit(cast, "int");
 			case SHORT_TO_INT: return castImplicit(cast, "int");
 			case SHORT_TO_UINT: return castImplicit(cast, "int");
+			case SHORT_TO_USIZE: return castImplicit(cast, "int");
 			case SHORT_TO_LONG: return castImplicit(cast, "long");
 			case SHORT_TO_ULONG: return castImplicit(cast, "long");
 			case SHORT_TO_FLOAT: return castImplicit(cast, "float");
 			case USHORT_TO_UINT: return castPostfix(cast, JavaOperator.AND_FFFF);
 			case USHORT_TO_LONG: return castPostfix(cast, JavaOperator.AND_FFFFL);
 			case USHORT_TO_ULONG: return castPostfix(cast, JavaOperator.AND_FFFFL);
+			case USHORT_TO_USIZE: return castPostfix(cast, JavaOperator.AND_FFFF);
 			case USHORT_TO_FLOAT: return cast.isImplicit ? cast.target.accept(this) : cast(castPostfix(cast, JavaOperator.AND_FFFF), "float");
 			case USHORT_TO_DOUBLE: return cast.isImplicit ? cast.target.accept(this) : cast(castPostfix(cast, JavaOperator.AND_FFFF), "double");
 			case USHORT_TO_CHAR: return castImplicit(cast, "char");
 			case INT_TO_DOUBLE: return castImplicit(cast, "double");
 			case INT_TO_CHAR: return cast(cast, "char");
 			case INT_TO_STRING: return callStatic("Integer.toString", cast.target);
+			case INT_TO_USIZE: return cast.target.accept(this);
 			case UINT_TO_BYTE: return cast.target.accept(this);
 			case UINT_TO_SBYTE: return cast(cast, "byte");
 			case UINT_TO_SHORT: return cast(cast, "short");
 			case UINT_TO_INT: return cast.target.accept(this);
 			case UINT_TO_LONG: return castImplicit(cast, "long");
 			case UINT_TO_ULONG: return castPostfix(cast, JavaOperator.AND_8FL);
+			case UINT_TO_USIZE: return cast.target.accept(this);
 			case UINT_TO_FLOAT: return cast(castPostfix(cast, JavaOperator.AND_8FL), "float");
 			case UINT_TO_DOUBLE: return cast(castPostfix(cast, JavaOperator.AND_8FL), "double");
 			case UINT_TO_CHAR: return cast(cast, "char");
 			case LONG_TO_INT: return cast(cast, "int");
 			case LONG_TO_UINT: return cast(cast, "int");
 			case LONG_TO_ULONG: return cast.target.accept(this);
+			case LONG_TO_USIZE: return cast(cast, "int");
 			case LONG_TO_FLOAT: return castImplicit(cast, "float");
 			case LONG_TO_DOUBLE: return castImplicit(cast, "double");
 			case LONG_TO_CHAR: return cast(cast, "char");
 			case ULONG_TO_INT: return cast(cast, "int");
 			case ULONG_TO_UINT: return cast(cast, "int");
 			case ULONG_TO_LONG: return cast.target.accept(this);
+			case ULONG_TO_USIZE: return cast(cast, "int");
 			case ULONG_TO_FLOAT: return castImplicit(cast, "float"); // TODO: this is incorrect!
 			case ULONG_TO_DOUBLE: return castImplicit(cast, "double"); // TODO: this is incorrect!
 			case ULONG_TO_CHAR: return cast(cast, "char");
 			case FLOAT_TO_UINT: return cast(cast, "int");
 			case FLOAT_TO_LONG: return cast(cast, "long");
 			case FLOAT_TO_ULONG: return cast(cast, "long");
+			case FLOAT_TO_USIZE: return cast(cast, "int");
 			case FLOAT_TO_DOUBLE: return castImplicit(cast, "double");
 			case FLOAT_TO_STRING: return callStatic("Float.toString", cast.target);
 			case DOUBLE_TO_BYTE: return cast(cast, "int");
 			case DOUBLE_TO_UINT: return cast(cast, "int");
 			case DOUBLE_TO_LONG: return cast(cast, "long");
 			case DOUBLE_TO_ULONG: return cast(cast, "long");
+			case DOUBLE_TO_USIZE: return cast(cast, "int");
 			case DOUBLE_TO_FLOAT: return cast(cast, "float");
 			case DOUBLE_TO_STRING: return callStatic("Double.toString", cast.target);
 			case CHAR_TO_BYTE: return cast.target.accept(this);
 			case CHAR_TO_UINT: return castImplicit(cast, "int");
 			case CHAR_TO_LONG: return castImplicit(cast, "long");
 			case CHAR_TO_ULONG: return castImplicit(cast, "long");
+			case CHAR_TO_USIZE: return castImplicit(cast, "int");
 			case CHAR_TO_STRING: return callStatic("Character.toString", cast.target);
 			case ENUM_TO_STRING: return cast.target.accept(this).unaryPostfix(JavaOperator.TOSTRING);
 		}