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

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

 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;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.BreakStatement;
 				result.append(parameter.name);
 				
 				if (parameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : parameter.bounds) {
+					for (TypeParameterBound bound : parameter.bounds) {
 						result.append(": ");
 						result.append(bound.accept(typeFormatter));
 					}

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

 		
 		return false;
 	}
+
+	public boolean accepts(int arguments) {
+		return arguments >= this.minParameters && arguments <= this.maxParameters;
+	}
 }

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

 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.MemberCollector;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
  */
 public abstract class HighLevelDefinition extends Taggable {
 	public final CodePosition position;
+	public final Module module;
 	public final ZSPackage pkg;
 	public final String name;
 	public final int modifiers;
 	
 	private boolean isDestructible = false;
 	
-	public HighLevelDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+	public HighLevelDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		if (module == null)
+			throw new NullPointerException();
+		
 		this.position = position;
+		this.module = module;
 		this.pkg = pkg;
 		this.name = name;
 		this.modifiers = modifiers;
 			members.add(member);
 	}
 	
+	public void collectMembers(MemberCollector collector) {
+		for (IDefinitionMember member : members)
+			collector.member(member);
+	}
+	
 	public boolean isDestructible() {
 		boolean isDestructible = false;
 		for (IDefinitionMember member : members) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/Module.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;
+
+import org.openzen.zencode.shared.Taggable;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Module extends Taggable {
+	public static final Module BUILTIN = new Module("builtin");
+	
+	public final String name;
+	
+	public Module(String name) {
+		this.name = name;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingPackage.java

 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
  * @author Hoofdgebruiker
  */
 public class CompilingPackage {
+	public final Module module;
 	private final ZSPackage pkg;
 	private final Map<String, CompilingPackage> packages = new HashMap<>();
 	private final Map<String, CompilingType> types = new HashMap<>();
 	
-	public CompilingPackage(ZSPackage pkg) {
+	public CompilingPackage(ZSPackage pkg, Module module) {
 		this.pkg = pkg;
+		this.module = module;
 	}
 	
 	public ZSPackage getPackage() {
 		if (packages.containsKey(name))
 			return packages.get(name);
 		
-		CompilingPackage newPackage = new CompilingPackage(pkg.getOrCreatePackage(name));
+		CompilingPackage newPackage = new CompilingPackage(pkg.getOrCreatePackage(name), module);
 		packages.put(name, newPackage);
 		return newPackage;
 	}

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 public class AliasDefinition extends HighLevelDefinition {
 	public ITypeID type;
 	
-	public AliasDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public AliasDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void setType(ITypeID type) {

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.Module;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ClassDefinition extends HighLevelDefinition {
-	public ClassDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers) {
-		this(position, pkg, name, modifiers, null);
+	public ClassDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers) {
+		this(position, module, pkg, name, modifiers, null);
 	}
 	
-	public ClassDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public ClassDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 
 /**
 public class EnumDefinition extends HighLevelDefinition {
 	public List<EnumConstantMember> enumConstants = new ArrayList<>();
 	
-	public EnumDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public EnumDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override
 		return visitor.visitEnum(this);
 	}
 	
+	@Override
+	public void collectMembers(MemberCollector collector) {
+		super.collectMembers(collector);
+		
+		for (EnumConstantMember member : enumConstants)
+			collector.enumConstant(member);
+	}
+	
 	public void addEnumConstant(EnumConstantMember constant) {
 		enumConstants.add(constant);
 	}

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 public class ExpansionDefinition extends HighLevelDefinition {
 	public ITypeID target;
 	
-	public ExpansionDefinition(CodePosition position, ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, null, modifiers, outerDefinition);
+	public ExpansionDefinition(CodePosition position, Module module, ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, null, modifiers, outerDefinition);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
 	public CallerMember caller;
 	public final DefinitionMemberGroup callerGroup;
 	
-	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public FunctionDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 		callerGroup = new DefinitionMemberGroup(true, name);
 	}
 	
-	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, FunctionHeader header) {
-		this(position, pkg, name, modifiers, (HighLevelDefinition) null);
+	public FunctionDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, FunctionHeader header) {
+		this(position, module, pkg, name, modifiers, (HighLevelDefinition) null);
 		setHeader(header);
 	}
 	

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 public class InterfaceDefinition extends HighLevelDefinition {
 	public final List<ITypeID> baseInterfaces = new ArrayList<>();
 	
-	public InterfaceDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public InterfaceDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void addBaseInterface(ITypeID baseInterface) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/MemberCollector.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.definition;
+
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MemberCollector {
+	void member(IDefinitionMember member);
+	
+	void enumConstant(EnumConstantMember member);
+	
+	void variantOption(VariantDefinition.Option member);
+}

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class StructDefinition extends HighLevelDefinition {
-	public StructDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public StructDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 public class VariantDefinition extends HighLevelDefinition {
 	public final List<Option> options = new ArrayList<>();
 	
-	public VariantDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public VariantDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override
 		return visitor.visitVariant(this);
 	}
 	
+	@Override
+	public void collectMembers(MemberCollector collector) {
+		super.collectMembers(collector);
+		
+		for (Option option : options)
+			collector.variantOption(option);
+	}
+	
 	public static class Option extends Taggable {
 		public final String name;
 		public final int ordinal;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterSuperBound.java

  *
  * @author Hoofdgebruiker
  */
-public class ParameterSuperBound extends GenericParameterBound {
+public class ParameterSuperBound extends TypeParameterBound {
 	public final ITypeID type;
 	
 	public ParameterSuperBound(ITypeID type) {
 	}
 
 	@Override
-	public GenericParameterBound instance(GenericMapper mapper) {
+	public TypeParameterBound instance(GenericMapper mapper) {
 		ITypeID translated = type.instance(mapper);
 		if (translated == type)
 			return this;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterTypeBound.java

  *
  * @author Hoofdgebruiker
  */
-public class ParameterTypeBound extends GenericParameterBound {
+public class ParameterTypeBound extends TypeParameterBound {
 	public final CodePosition position;
 	public final ITypeID type;
 	
 	}
 
 	@Override
-	public GenericParameterBound instance(GenericMapper mapper) {
+	public TypeParameterBound instance(GenericMapper mapper) {
 		return new ParameterTypeBound(position, type.instance(mapper));
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameter.java

 	
 	public final CodePosition position;
 	public final String name;
-	public final List<GenericParameterBound> bounds = new ArrayList<>();
+	public final List<TypeParameterBound> bounds = new ArrayList<>();
 	
 	public TypeParameter(CodePosition position, String name) {
 		this.position = position;
 		this.name = name;
 	}
 	
-	private TypeParameter(CodePosition position, String name, List<GenericParameterBound> bounds) {
+	private TypeParameter(CodePosition position, String name, List<TypeParameterBound> bounds) {
 		this.position = position;
 		this.name = name;
 		bounds.addAll(bounds);
 	}
 	
-	public void addBound(GenericParameterBound bound) {
+	public void addBound(TypeParameterBound bound) {
 		bounds.add(bound);
 	}
 	
 	public boolean isObjectType() {
-		for (GenericParameterBound bound : bounds)
+		for (TypeParameterBound bound : bounds)
 			if (bound.isObjectType())
 				return true;
 		
 	}
 	
 	public boolean matches(LocalMemberCache cache, ITypeID type) {
-		for (GenericParameterBound bound : bounds) {
+		for (TypeParameterBound bound : bounds) {
 			if (!bound.matches(cache, type))
 				return false;
 		}
 	public String getCanonical() {
 		StringBuilder result = new StringBuilder();
 		result.append(name);
-		for(GenericParameterBound bound : bounds) {
+		for(TypeParameterBound bound : bounds) {
 			result.append(':');
 			result.append(bound.getCanonical());
 		}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/GenericParameterBound.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameterBound.java

  *
  * @author Hoofdgebruiker
  */
-public abstract class GenericParameterBound {
+public abstract class TypeParameterBound {
 	public abstract boolean isObjectType();
 	
 	public abstract <T> T accept(GenericParameterBoundVisitor<T> visitor);
 	
 	public abstract boolean matches(LocalMemberCache cache, ITypeID type);
 	
-	public abstract GenericParameterBound instance(GenericMapper mapper);
+	public abstract TypeParameterBound instance(GenericMapper mapper);
 	
 	public abstract String getCanonical();
 }

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

 	BYTE_AND_BYTE,
 	BYTE_OR_BYTE,
 	BYTE_XOR_BYTE,
+	BYTE_SHL,
+	BYTE_SHR,
 	BYTE_COMPARE,
 	BYTE_TO_SBYTE,
 	BYTE_TO_SHORT,
 	SBYTE_AND_SBYTE,
 	SBYTE_OR_SBYTE,
 	SBYTE_XOR_SBYTE,
+	SBYTE_SHL,
+	SBYTE_SHR,
+	SBYTE_USHR,
 	SBYTE_COMPARE,
 	SBYTE_TO_BYTE,
 	SBYTE_TO_SHORT,
 	SHORT_AND_SHORT,
 	SHORT_OR_SHORT,
 	SHORT_XOR_SHORT,
+	SHORT_SHL,
+	SHORT_SHR,
+	SHORT_USHR,
 	SHORT_COMPARE,
 	SHORT_TO_BYTE,
 	SHORT_TO_SBYTE,
 	USHORT_AND_USHORT,
 	USHORT_OR_USHORT,
 	USHORT_XOR_USHORT,
+	USHORT_SHL,
+	USHORT_SHR,
 	USHORT_COMPARE,
 	USHORT_TO_BYTE,
 	USHORT_TO_SBYTE,
 	LONG_SHR,
 	LONG_USHR,
 	LONG_COMPARE,
+	LONG_COMPARE_INT,
 	LONG_TO_BYTE,
 	LONG_TO_SBYTE,
 	LONG_TO_SHORT,
 	ULONG_SHL,
 	ULONG_SHR,
 	ULONG_COMPARE,
+	ULONG_COMPARE_UINT,
+	ULONG_COMPARE_USIZE,
 	ULONG_TO_BYTE,
 	ULONG_TO_SBYTE,
 	ULONG_TO_SHORT,
 	USIZE_SHL,
 	USIZE_SHR,
 	USIZE_COMPARE,
+	USIZE_COMPARE_UINT,
 	USIZE_TO_BYTE,
 	USIZE_TO_SBYTE,
 	USIZE_TO_SHORT,
 	ARRAY_SAME,
 	ARRAY_NOTSAME,
 	
+	SBYTE_ARRAY_AS_BYTE_ARRAY,
+	BYTE_ARRAY_AS_SBYTE_ARRAY,
+	SHORT_ARRAY_AS_USHORT_ARRAY,
+	USHORT_ARRAY_AS_SHORT_ARRAY,
+	INT_ARRAY_AS_UINT_ARRAY,
+	UINT_ARRAY_AS_INT_ARRAY,
+	LONG_ARRAY_AS_ULONG_ARRAY,
+	ULONG_ARRAY_AS_LONG_ARRAY,
+	
 	FUNCTION_CALL,
 	FUNCTION_SAME,
 	FUNCTION_NOTSAME,

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

 		return false;
 	}
 	
+	public FunctionalMemberRef getStaticMethod(int arguments, ITypeID returnType) {
+		for (TypeMember<FunctionalMemberRef> method : methods) {
+			if (method.member.isStatic() && method.member.getHeader().accepts(arguments) && method.member.getHeader().getReturnType() == returnType)
+				return method.member;
+		}
+		
+		return null;
+	}
+	
 	public List<TypeMember<FunctionalMemberRef>> getMethodMembers() {
 		return this.methods;
 	}

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

 import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
 import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import static org.openzen.zencode.shared.CodePosition.BUILTIN;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
 import org.openzen.zenscript.codemodel.member.IteratorMember;
 
 	@Override
 	public Void visitArray(ArrayTypeID array) {
-		HighLevelDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		HighLevelDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		ITypeID baseType = array.elementType;
 		int dimension = array.dimension;
 
 					OperatorType.INDEXGET,
 					sliceHeader,
 					ARRAY_INDEXGETRANGE);
+			
+			if (baseType == BYTE)
+				castImplicit(definition, BYTE_ARRAY_AS_SBYTE_ARRAY, registry.getArray(SBYTE, 1));
+			if (baseType == SBYTE)
+				castImplicit(definition, SBYTE_ARRAY_AS_BYTE_ARRAY, registry.getArray(BYTE, 1));
+			if (baseType == SHORT)
+				castImplicit(definition, SHORT_ARRAY_AS_USHORT_ARRAY, registry.getArray(USHORT, 1));
+			if (baseType == USHORT)
+				castImplicit(definition, USHORT_ARRAY_AS_SHORT_ARRAY, registry.getArray(SHORT, 1));
+			if (baseType == INT)
+				castImplicit(definition, INT_ARRAY_AS_UINT_ARRAY, registry.getArray(UINT, 1));
+			if (baseType == UINT)
+				castImplicit(definition, UINT_ARRAY_AS_INT_ARRAY, registry.getArray(INT, 1));
+			if (baseType == LONG)
+				castImplicit(definition, LONG_ARRAY_AS_ULONG_ARRAY, registry.getArray(ULONG, 1));
+			if (baseType == ULONG)
+				castImplicit(definition, ULONG_ARRAY_AS_LONG_ARRAY, registry.getArray(LONG, 1));
 		}
 
 		FunctionHeader containsHeader = new FunctionHeader(BOOL, new FunctionParameter(baseType, "value"));
 		ITypeID keyType = assoc.keyType;
 		ITypeID valueType = assoc.valueType;
 		
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		
 		constructor(builtin, ASSOC_CONSTRUCTOR);
 
 		FunctionHeader putHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BasicTypeID.VOID, null, new FunctionParameter(valueType));
 		FunctionHeader containsHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BasicTypeID.BOOL, null, new FunctionParameter[0]);
 		
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		constructor(builtin, GENERICMAP_CONSTRUCTOR);
 		
 		method(builtin, "getOptional", getOptionalHeader, GENERICMAP_GETOPTIONAL);
 
 	@Override
 	public Void visitFunction(FunctionTypeID function) {
-		FunctionDefinition builtin = new FunctionDefinition(BUILTIN, null, "", Modifiers.EXPORT, function.header);
+		FunctionDefinition builtin = new FunctionDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT, function.header);
 		new CallerMember(BUILTIN, builtin, 0, function.header, FUNCTION_CALL).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		
 		same(builtin, FUNCTION_SAME, function);
 	public Void visitGeneric(GenericTypeID generic) {
 		TypeParameter parameter = generic.parameter;
 
-		for (GenericParameterBound bound : parameter.bounds) {
+		for (TypeParameterBound bound : parameter.bounds) {
 			bound.registerMembers(cache, members);
 		}
 		
 	public Void visitRange(RangeTypeID range) {
 		ITypeID baseType = range.baseType;
 
-		ClassDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		getter(definition, RANGE_FROM, "from", baseType);
 		getter(definition, RANGE_TO, "to", baseType);
 		if (baseType == BYTE
 
 	@Override
 	public Void visitModified(ModifiedTypeID modified) {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "modified", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "modified", Modifiers.EXPORT, null);
 		modified.baseType.accept(this);
 		
 		if (modified.isOptional()) {
 	}
 	
 	private void visitBool() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "bool", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "bool", Modifiers.EXPORT, null);
 		not(builtin, BOOL_NOT, BOOL);
 		and(builtin, BOOL_AND, BOOL, BOOL);
 		or(builtin, BOOL_OR, BOOL, BOOL);
 	}
 	
 	private void visitByte() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "byte", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "byte", Modifiers.EXPORT, null);
 		
 		invert(builtin, BYTE_NOT, BYTE);
 		inc(builtin, BYTE_INC, BYTE);
 		and(builtin, BYTE_AND_BYTE, BYTE, BYTE);
 		or(builtin, BYTE_OR_BYTE, BYTE, BYTE);
 		xor(builtin, BYTE_XOR_BYTE, BYTE, BYTE);
+		shl(builtin, BYTE_SHL, USIZE, BYTE);
+		shr(builtin, BYTE_SHR, USIZE, BYTE);
 		compare(builtin, BYTE_COMPARE, BYTE);
 		
 		castImplicit(builtin, BYTE_TO_SBYTE, SBYTE);
 	}
 	
 	private void visitSByte() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "sbyte", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "sbyte", Modifiers.EXPORT, null);
 		
 		invert(builtin, SBYTE_NOT, SBYTE);
 		neg(builtin, SBYTE_NEG, SBYTE);
 		and(builtin, SBYTE_AND_SBYTE, SBYTE, SBYTE);
 		or(builtin, SBYTE_OR_SBYTE, SBYTE, SBYTE);
 		xor(builtin, SBYTE_XOR_SBYTE, SBYTE, SBYTE);
+		shl(builtin, SBYTE_SHL, USIZE, SBYTE);
+		shr(builtin, SBYTE_SHR, USIZE, SBYTE);
+		ushr(builtin, SBYTE_USHR, USIZE, SBYTE);
 		compare(builtin, SBYTE_COMPARE, SBYTE);
 		
 		castImplicit(builtin, SBYTE_TO_BYTE, BYTE);
 	}
 	
 	private void visitShort() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "short", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "short", Modifiers.EXPORT, null);
 		
 		invert(builtin, SHORT_NOT, SHORT);
 		neg(builtin, SHORT_NEG, SHORT);
 		and(builtin, SHORT_AND_SHORT, SHORT, SHORT);
 		or(builtin, SHORT_OR_SHORT, SHORT, SHORT);
 		xor(builtin, SHORT_XOR_SHORT, SHORT, SHORT);
+		shl(builtin, SHORT_SHL, USIZE, SHORT);
+		shr(builtin, SHORT_SHR, USIZE, SHORT);
+		ushr(builtin, SHORT_USHR, USIZE, SHORT);
 		compare(builtin, SHORT_COMPARE, SHORT);
 		
 		castExplicit(builtin, SHORT_TO_BYTE, BYTE);
 	}
 	
 	private void visitUShort() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "ushort", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ushort", Modifiers.EXPORT, null);
 		
 		invert(builtin, USHORT_NOT, USHORT);
 		inc(builtin, USHORT_INC, USHORT);
 		and(builtin, USHORT_AND_USHORT, USHORT, USHORT);
 		or(builtin, USHORT_OR_USHORT, USHORT, USHORT);
 		xor(builtin, USHORT_XOR_USHORT, USHORT, USHORT);
+		shl(builtin, USHORT_SHL, USIZE, USHORT);
+		shr(builtin, USHORT_SHR, USIZE, USHORT);
 		compare(builtin, USHORT_COMPARE, USHORT);
 		
 		castExplicit(builtin, USHORT_TO_BYTE, BYTE);
 	}
 	
 	private void visitInt() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "int", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "int", Modifiers.EXPORT, null);
 		
 		invert(builtin, INT_NOT, INT);
 		neg(builtin, INT_NEG, INT);
 		xor(builtin, INT_XOR_INT, INT, INT);
 		xor(builtin, LONG_XOR_LONG, LONG, LONG, INT_TO_LONG);
 		
-		shl(builtin, INT_SHL, INT, INT);
-		shr(builtin, INT_SHR, INT, INT);
-		ushr(builtin, INT_USHR, INT, INT);
+		shl(builtin, INT_SHL, USIZE, INT);
+		shr(builtin, INT_SHR, USIZE, INT);
+		ushr(builtin, INT_USHR, USIZE, INT);
 		
 		compare(builtin, INT_COMPARE, INT);
 		compare(builtin, LONG_COMPARE, LONG, INT_TO_LONG);
 	}
 
 	private void visitUInt() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "uint", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "uint", Modifiers.EXPORT, null);
 		
 		invert(builtin, UINT_NOT, INT);
 		inc(builtin, UINT_DEC, INT);
 		xor(builtin, UINT_XOR_UINT, UINT, UINT);
 		xor(builtin, ULONG_XOR_ULONG, ULONG, ULONG, UINT_TO_ULONG);
 		
-		shl(builtin, UINT_SHL, UINT, UINT);
-		shr(builtin, UINT_SHR, UINT, UINT);
+		shl(builtin, UINT_SHL, USIZE, UINT);
+		shr(builtin, UINT_SHR, USIZE, UINT);
 		
 		compare(builtin, UINT_COMPARE, UINT);
 		compare(builtin, ULONG_COMPARE, ULONG, UINT_TO_LONG);
 	}
 	
 	private void visitLong() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "long", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "long", Modifiers.EXPORT, null);
 		
 		invert(builtin, LONG_NOT, LONG);
 		neg(builtin, LONG_NEG, LONG);
 		and(builtin, LONG_AND_LONG, LONG, LONG);
 		xor(builtin, LONG_XOR_LONG, LONG, LONG);
 		
-		shl(builtin, LONG_SHL, INT, LONG);
-		shr(builtin, LONG_SHR, INT, LONG);
-		ushr(builtin, LONG_USHR, INT, LONG);
+		shl(builtin, LONG_SHL, USIZE, LONG);
+		shr(builtin, LONG_SHR, USIZE, LONG);
+		ushr(builtin, LONG_USHR, USIZE, LONG);
 		
+		compare(builtin, LONG_COMPARE_INT, INT);
 		compare(builtin, LONG_COMPARE, LONG);
 		compare(builtin, FLOAT_COMPARE, FLOAT, LONG_TO_FLOAT);
 		compare(builtin, DOUBLE_COMPARE, DOUBLE, LONG_TO_DOUBLE);
 	}
 	
 	private void visitULong() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "ulong", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ulong", Modifiers.EXPORT, null);
 		
 		invert(builtin, ULONG_NOT, ULONG);
 		inc(builtin, ULONG_DEC, ULONG);
 		and(builtin, ULONG_AND_ULONG, ULONG, ULONG);
 		xor(builtin, ULONG_XOR_ULONG, ULONG, ULONG);
 		
-		shl(builtin, ULONG_SHL, INT, ULONG);
-		shr(builtin, ULONG_SHR, INT, ULONG);
+		shl(builtin, ULONG_SHL, USIZE, ULONG);
+		shr(builtin, ULONG_SHR, USIZE, ULONG);
 		
+		compare(builtin, ULONG_COMPARE_UINT, UINT);
+		compare(builtin, ULONG_COMPARE_USIZE, USIZE);
 		compare(builtin, ULONG_COMPARE, ULONG);
 		compare(builtin, FLOAT_COMPARE, FLOAT, ULONG_TO_FLOAT);
 		compare(builtin, DOUBLE_COMPARE, DOUBLE, ULONG_TO_DOUBLE);
 	}
 	
 	private void visitUSize() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "usize", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "usize", Modifiers.EXPORT, null);
 		
 		invert(builtin, USIZE_NOT, USIZE);
 		inc(builtin, USIZE_DEC, 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);
+		shl(builtin, USIZE_SHL, USIZE, USIZE);
+		shr(builtin, USIZE_SHR, USIZE, USIZE);
 		
+		compare(builtin, USIZE_COMPARE_UINT, UINT);
 		compare(builtin, USIZE_COMPARE, USIZE);
 		compare(builtin, ULONG_COMPARE, ULONG, USIZE_TO_ULONG);
 		compare(builtin, FLOAT_COMPARE, FLOAT, USIZE_TO_FLOAT);
 	}
 	
 	private void visitFloat() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "float", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "float", Modifiers.EXPORT, null);
 		
 		neg(builtin, FLOAT_NEG, FLOAT);
 		inc(builtin, FLOAT_DEC, FLOAT);
 	}
 	
 	private void visitDouble() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "double", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "double", Modifiers.EXPORT, null);
 		
 		neg(builtin, DOUBLE_NEG, DOUBLE);
 		inc(builtin, DOUBLE_DEC, DOUBLE);
 		castExplicit(builtin, DOUBLE_TO_USHORT, USHORT);
 		castExplicit(builtin, DOUBLE_TO_INT, INT);
 		castExplicit(builtin, DOUBLE_TO_UINT, UINT);
-		castExplicit(builtin, DOUBLE_TO_ULONG, ULONG);
+		castExplicit(builtin, DOUBLE_TO_LONG, LONG);
 		castExplicit(builtin, DOUBLE_TO_ULONG, ULONG);
 		castExplicit(builtin, DOUBLE_TO_USIZE, USIZE);
 		castImplicit(builtin, DOUBLE_TO_FLOAT, FLOAT);
 	}
 
 	private void visitChar() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "char", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "char", Modifiers.EXPORT, null);
 		
 		add(builtin, CHAR_ADD_INT, INT, CHAR);
 		sub(builtin, CHAR_SUB_INT, INT, CHAR);
 	}
 
 	private void visitString() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "string", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "string", Modifiers.EXPORT, null);
 		
 		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, registry.getArray(CHAR, 1));
 		
 		processType(builtin, STRING);
 	}
 	
-	private void castedTargetCall(OperatorMember member, BuiltinID casterBuiltin) {
-		CasterMemberRef caster = castImplicitRef(member.definition, casterBuiltin, member.header.parameters[0].type);
+	private void castedTargetCall(OperatorMember member, ITypeID toType, BuiltinID casterBuiltin) {
+		CasterMemberRef caster = castImplicitRef(member.definition, casterBuiltin, toType);
 		TranslatedOperatorMemberRef method = new TranslatedOperatorMemberRef(member, GenericMapper.EMPTY, call -> member.ref(null).call(call.position, caster.cast(call.position, call.target, true), call.arguments, call.scope));
 		members.getOrCreateGroup(member.operator).addMethod(method, TypeMemberPriority.SPECIFIED);
 	}
 	}
 	
 	private void add(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(addOp(definition, id, operand, result), caster);
+		castedTargetCall(addOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember subOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void sub(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(subOp(definition, id, operand, result), caster);
+		castedTargetCall(subOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember mulOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void mul(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(mulOp(definition, id, operand, result), caster);
+		castedTargetCall(mulOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember divOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void div(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(divOp(definition, id, operand, result), caster);
+		castedTargetCall(divOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember modOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void mod(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(modOp(definition, id, operand, result), caster);
+		castedTargetCall(modOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember shlOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void shl(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(shlOp(definition, id, operand, result), caster);
+		castedTargetCall(shlOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember shrOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void shr(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(shrOp(definition, id, operand, result), caster);
+		castedTargetCall(shrOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember ushrOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void ushr(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(ushrOp(definition, id, operand, result), caster);
+		castedTargetCall(ushrOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember orOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void and(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(andOp(definition, id, operand, result), caster);
+		castedTargetCall(andOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember xorOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void xor(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(xorOp(definition, id, operand, result), caster);
+		castedTargetCall(xorOp(definition, id, operand, result), result, caster);
 	}
 	
 	private void indexGet(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void compare(HighLevelDefinition definition, BuiltinID id, ITypeID operand, BuiltinID caster) {
-		castedTargetCall(compareOp(definition, id, operand), caster);
+		castedTargetCall(compareOp(definition, id, operand), operand, caster);
 	}
 	
 	private void getter(HighLevelDefinition cls, BuiltinID id, String name, ITypeID type) {

CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java

 import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.annotations.AnnotationProcessor;
 	public final SemanticModule[] dependencies;
 	
 	private State state;
+	public final Module module;
 	public final ZSPackage rootPackage;
 	public final ZSPackage modulePackage;
 	public final PackageDefinitions definitions;
 	
 	public SemanticModule(
 			String name,
+			Module module,
 			SemanticModule[] dependencies,
 			State state,
 			ZSPackage rootPackage,
 			AnnotationDefinition[] annotations)
 	{
 		this.name = name;
+		this.module = module;
 		this.dependencies = dependencies;
 		
 		this.state = state;
 		
 		return new SemanticModule(
 				name,
+				module,
 				dependencies,
 				State.NORMALIZED,
 				rootPackage,

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

  *
  * @author Hoofdgebruiker
  */
-public class Module {
+public class ParsedModule {
 	public final String name;
 	public final String[] dependencies;
 	public final File sourceDirectory;
 	public final String host;
 	private final Consumer<CompileException> exceptionLogger;
 	
-	public Module(String name, File directory, File moduleFile, Consumer<CompileException> exceptionLogger) throws IOException {
+	public ParsedModule(String name, File directory, File moduleFile, Consumer<CompileException> exceptionLogger) throws IOException {
 		this.name = name;
 		this.sourceDirectory = new File(directory, "src");
 		this.exceptionLogger = exceptionLogger;

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

 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ConstructorException;
 import org.openzen.zenscript.constructor.JSONUtils;
-import org.openzen.zenscript.constructor.Module;
+import org.openzen.zenscript.constructor.ParsedModule;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.codemodel.type.TypeSymbol;
 import org.openzen.zenscript.parser.ParsedFile;
 				space.addModule(dependencyName, module);
 			}
 
-			Module module = new Module(moduleName, directory, jsonFile, exceptionLogger);
-			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, module.packageName);
-			CompilingPackage compilingPackage = new CompilingPackage(pkg);
+			ParsedModule parsedModule = new ParsedModule(moduleName, directory, jsonFile, exceptionLogger);
+			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, parsedModule.packageName);
+			Module module = new Module(moduleName);
+			CompilingPackage compilingPackage = new CompilingPackage(pkg, module);
 			
-			ParsedFile[] parsedFiles = module.parse(compilingPackage);
-			SemanticModule result = ParsedFile.compileSyntaxToSemantic(module.name, dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
+			ParsedFile[] parsedFiles = parsedModule.parse(compilingPackage);
+			SemanticModule result = ParsedFile.compileSyntaxToSemantic(parsedModule.name, dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

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

 		String extract = tokens.extract(
 				SourcePosition.min(cursorStart, cursorEnd),
 				SourcePosition.max(cursorStart, cursorEnd));
+		if (context.getUIContext() == null)
+			throw new NullPointerException("No context!");
+		if (context.getUIContext().getClipboard() == null)
+			throw new NullPointerException("No clipboard!");
+		
 		context.getUIContext().getClipboard().copyAsString(extract);
 	}
 	
 					return IDENTIFIER;
 				case T_FLOAT:
 				case T_INT:
+				case T_PREFIXED_INT:
 					return NUMBER;
 				case T_STRING_SQ:
 				case T_STRING_DQ:

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

 			
 			for (int i = fromT.line + 1; i < toT.line; i++) {
 				result.append("\n");
-				for (ZSToken t : fromLine.getTokens()) {
+				for (ZSToken t : getLine(i).getTokens()) {
 					result.append(t.content);
 				}
 			}

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

 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 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");
 				case SHORT_COMPARE:
 				case INT_COMPARE:
 				case CHAR_COMPARE:
+				case USIZE_COMPARE:
 					expression.left.accept(this);
 					expression.right.accept(this);
 					compareInt(expression.comparison);
 					break;
 				case UINT_COMPARE:
+				case USIZE_COMPARE_UINT:
 					expression.left.accept(this);
 					expression.right.accept(this);
 					javaWriter.invokeStatic(INTEGER_COMPARE_UNSIGNED);
 					javaWriter.invokeStatic(LONG_COMPARE_UNSIGNED);
 					compareGeneric(expression.comparison);
 					break;
+				case ULONG_COMPARE_UINT:
+					expression.left.accept(this);
+					expression.right.accept(this);
+					javaWriter.i2l();
+					javaWriter.constant(0xFFFF_FFFFL);
+					javaWriter.lAnd();
+					javaWriter.invokeStatic(LONG_COMPARE_UNSIGNED);
+					compareGeneric(expression.comparison);
+					break;
+				case ULONG_COMPARE_USIZE:
+					expression.left.accept(this);
+					expression.right.accept(this);
+					javaWriter.i2l();
+					javaWriter.invokeStatic(LONG_COMPARE_UNSIGNED);
+					compareGeneric(expression.comparison);
+					break;
 				case FLOAT_COMPARE:
 					expression.left.accept(this);
 					expression.right.accept(this);
 			case USIZE_XOR_USIZE:
 				javaWriter.iXor();
 				break;
+			case BYTE_SHL:
+			case SBYTE_SHL:
+			case SHORT_SHL:
+			case USHORT_SHL:
 			case INT_SHL:
 			case UINT_SHL:
 			case USIZE_SHL:
 				javaWriter.iShl();
 				break;
+			case SBYTE_SHR:
+			case SHORT_SHR:
 			case INT_SHR:
 				javaWriter.iShr();
 				break;
+			case BYTE_SHR:
+			case SBYTE_USHR:
+			case USHORT_SHR:
+			case SHORT_USHR:
 			case INT_USHR:
 			case UINT_SHR:
 			case USIZE_SHR:
 
 		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});
+		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{context.getInternalName(new FunctionTypeID(null, expression.header))});
 		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
 
 		javaWriter.newObject(name);

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

 	}
 
 
-	public String getGenericBounds(Collection<GenericParameterBound> collection) {
+	public String getGenericBounds(Collection<TypeParameterBound> collection) {
 		if (collection == null)
 			return "";
-		for (GenericParameterBound parameterBound : collection) {
+		for (TypeParameterBound parameterBound : collection) {
 			String s = parameterBound.accept(new GenericParameterBoundVisitor<String>() {
 				@Override
 				public String visitSuper(ParameterSuperBound bound) {

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

 	T copy(Expression value);
 	
 	T copyTo(CallExpression call);
+	
+	T stringToAscii(Expression value);
+	
+	T stringToUTF8(Expression value);
+	
+	T bytesAsciiToString(Expression value);
+	
+	T bytesUTF8ToString(Expression value);
 }

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

 package org.openzen.zenscript.javashared;
 
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.type.*;
 
 
     @Override
     public String visitGeneric(GenericTypeID generic) {
-		for (GenericParameterBound bound : generic.parameter.bounds) {
+		for (TypeParameterBound bound : generic.parameter.bounds) {
 			if (bound instanceof ParameterTypeBound) {
 				return ((ParameterTypeBound) bound).type.accept(this);
 			}

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

 package org.openzen.zenscript.javashared;
 
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.type.*;
 
 
     @Override
     public String visitGeneric(GenericTypeID generic) {
-		for (GenericParameterBound bound : generic.parameter.bounds) {
+		for (TypeParameterBound bound : generic.parameter.bounds) {
 			if (bound instanceof ParameterTypeBound) {
 				return ((ParameterTypeBound) bound).type.accept(this);
 			}

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

 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 			cls.addInstanceMethod("lastIndexOf", "lastIndexOf", "(I)I");
 			cls.addInstanceMethod("lastIndexOfFrom", "lastIndexOf", "(II)I");
 			cls.addInstanceMethod("trim", "trim", "()Ljava/lang/String;");
+			cls.addMethod("fromAsciiBytes", new JavaMethod((expression, translator) -> {
+				CallStaticExpression call = (CallStaticExpression)expression;
+				return translator.bytesAsciiToString(call.arguments.arguments[0]);
+			}));
+			cls.addMethod("fromUTF8Bytes", new JavaMethod((expression, translator) -> {
+				CallStaticExpression call = (CallStaticExpression)expression;
+				return translator.bytesUTF8ToString(call.arguments.arguments[0]);
+			}));
+			cls.addMethod("toAsciiBytes", new JavaMethod((expression, translator) -> {
+				CallExpression call = (CallExpression)expression;
+				return translator.stringToAscii(call.target);
+			}));
+			cls.addMethod("toUTF8Bytes", new JavaMethod((expression, translator) -> {
+				CallExpression call = (CallExpression)expression;
+				return translator.stringToUTF8(call.target);
+			}));
 			nativeClasses.put("stdlib::String", cls);
 		}
 		
 		{
-			JavaClass arrays = new JavaClass("java.lang", "Arrays", JavaClass.Kind.CLASS);
+			JavaClass arrays = JavaClass.ARRAYS;
 			JavaNativeClass cls = new JavaNativeClass(arrays);
 			cls.addMethod("sort", JavaMethod.getNativeExpansion(arrays, "sort", "([Ljava/lang/Object;)[Ljava/lang/Object;"));
 			cls.addMethod("sorted", new JavaMethod((expression, translator) -> {

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 				result.append(parameter.name);
 				
 				if (parameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : parameter.bounds) {
+					for (TypeParameterBound bound : parameter.bounds) {
 						result.append(": ");
 						result.append(bound.accept(typeFormatter));
 					}

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

 	private static final JavaClass RESULT = new JavaClass("stdlib", "Result", JavaClass.Kind.CLASS);
 	private static final JavaClass RESULT_OK = new JavaClass("stdlib", "Result.Ok", JavaClass.Kind.CLASS);
 	private static final JavaClass RESULT_ERROR = new JavaClass("stdlib", "Result.Error", JavaClass.Kind.CLASS);
+	private static final JavaClass STANDARD_CHARSETS = new JavaClass("java.nio.charset", "StandardCharsets", JavaClass.Kind.CLASS);
 	
 	public final JavaSourceStatementScope scope;
 	public final StatementFormattingTarget target;
 		if (method == null)
 			throw new IllegalStateException("No source method tag for " + expression.member.getCanonicalName() + "!");
 		
+		if (method.kind == JavaMethod.Kind.COMPILED)
+			return (ExpressionString) method.translation.translate(expression, this);
+		
 		StringBuilder result = new StringBuilder();
 		result.append(scope.type(method.cls));
 		result.append('.');
 
 	@Override
 	public ExpressionString visitConstantLong(ConstantLongExpression expression) {
-		return new ExpressionString(Long.toString(expression.value), JavaOperator.PRIMARY);
+		return new ExpressionString(Long.toString(expression.value) + "L", JavaOperator.PRIMARY);
 	}
 
 	@Override
 
 	@Override
 	public ExpressionString visitConstantULong(ConstantULongExpression expression) {
-		return new ExpressionString(Long.toString(expression.value), JavaOperator.CAST);
+		return new ExpressionString(Long.toString(expression.value) + "L", JavaOperator.CAST);
 	}
 
 	@Override
 			GenericTypeID generic = (GenericTypeID)elementType;
 			String array = scope.type(new JavaClass("java.lang.reflect", "Array", JavaClass.Kind.CLASS));
 			return new ExpressionString("(" + generic.parameter.name + "[])(" + array + ".newInstance(typeOf" + generic.parameter.name + ", " + length.value + "))", JavaOperator.CAST);
+		} else if (elementType == BasicTypeID.BYTE) {
+			return new ExpressionString("new byte[" + length.value + "]", JavaOperator.NEW);
+		} else if (elementType == BasicTypeID.USHORT) {
+			return new ExpressionString("new short[" + length.value + "]", JavaOperator.NEW);
+		} else if (elementType == BasicTypeID.UINT) {
+			return new ExpressionString("new int[" + length.value + "]", JavaOperator.NEW);
+		} else if (elementType == BasicTypeID.ULONG) {
+			return new ExpressionString("new long[" + length.value + "]", JavaOperator.NEW);
 		} else {
 			return new ExpressionString("new " + scope.type(elementType) + "[" + length.value + "]", JavaOperator.NEW);
 		}
 		return new ExpressionString(output.toString(), JavaOperator.CALL);
 	}
 	
+	public ExpressionString callAsStaticTruncated(String target, CallExpression expression, JavaOperator truncator) {
+		StringBuilder output = new StringBuilder();
+		output.append(target).append("(");
+		output.append(expression.target.accept(this).value);
+		for (Expression argument : expression.arguments.arguments) {
+			output.append(", ");
+			output.append(argument.accept(this).unaryPostfix(truncator).value);
+		}
+		output.append(")");
+		return new ExpressionString(output.toString(), JavaOperator.CALL);
+	}
+	
 	public ExpressionString callAsStatic(String target, Expression left, Expression right) {
 		StringBuilder output = new StringBuilder();
 		output.append(target).append("(");
 	}
 	
 	private ExpressionString cast(CastExpression cast, String type) {
-		StringBuilder output = new StringBuilder();
-		output.append('(');
-		output.append(type);
-		output.append(')');
-		output.append(cast.target.accept(this).value);
-		return new ExpressionString(output.toString(), JavaOperator.CAST);
+		return cast.target.accept(this).unaryPrefix(JavaOperator.CAST, "(" + type + ")");
 	}
 	
 	private ExpressionString cast(ExpressionString value, String type) {
-		StringBuilder output = new StringBuilder();
-		output.append('(');
-		output.append(type);
-		output.append(')');
-		output.append(value.value);
-		return new ExpressionString(output.toString(), JavaOperator.CAST);
+		return value.unaryPrefix(JavaOperator.CALL, "(" + type + ")");
 	}
 	
 	private ExpressionString castPostfix(CastExpression cast, JavaOperator operator) {
 			case BYTE_ADD_BYTE: return binary(call, JavaOperator.ADD);
 			case BYTE_SUB_BYTE: return binary(call, JavaOperator.SUB);
 			case BYTE_MUL_BYTE: return binary(call, JavaOperator.MUL);
-			case BYTE_DIV_BYTE: return callAsStatic("Integer.divideUnsigned", call);
-			case BYTE_MOD_BYTE: return callAsStatic("Integer.remainderUnsigned", call);
+			case BYTE_DIV_BYTE: return callAsStaticTruncated("Integer.divideUnsigned", call, JavaOperator.AND_FF);
+			case BYTE_MOD_BYTE: return callAsStaticTruncated("Integer.remainderUnsigned", call, JavaOperator.AND_FF);
 			case BYTE_AND_BYTE: return binary(call, JavaOperator.AND);
 			case BYTE_OR_BYTE: return binary(call, JavaOperator.OR);
 			case BYTE_XOR_BYTE: return binary(call, JavaOperator.XOR);
+			case BYTE_SHL: return binary(call, JavaOperator.SHL);
+			case BYTE_SHR: return binary(call, JavaOperator.SHR);
 			case SBYTE_NOT: return unaryPrefix(call, JavaOperator.INVERT);
 			case SBYTE_NEG: return unaryPrefix(call, JavaOperator.NEG);
 			case SBYTE_ADD_SBYTE: return binary(call, JavaOperator.ADD);
 			case SBYTE_AND_SBYTE: return binary(call, JavaOperator.AND);
 			case SBYTE_OR_SBYTE: return binary(call, JavaOperator.OR);
 			case SBYTE_XOR_SBYTE: return binary(call, JavaOperator.XOR);
+			case SBYTE_SHL: return binary(call, JavaOperator.SHL);
+			case SBYTE_SHR: return binary(call, JavaOperator.SHR);
+			case SBYTE_USHR: return binary(call, JavaOperator.USHR);
 			case SHORT_NOT: return unaryPrefix(call, JavaOperator.INVERT);
 			case SHORT_NEG: return unaryPrefix(call, JavaOperator.NEG);
 			case SHORT_ADD_SHORT: return binary(call, JavaOperator.ADD);
 			case SHORT_AND_SHORT: return binary(call, JavaOperator.AND);
 			case SHORT_OR_SHORT: return binary(call, JavaOperator.OR);
 			case SHORT_XOR_SHORT: return binary(call, JavaOperator.XOR);
+			case SHORT_SHL: return binary(call, JavaOperator.SHL);
+			case SHORT_SHR: return binary(call, JavaOperator.SHR);
 			case USHORT_NOT: return unaryPrefix(call, JavaOperator.INVERT);
 			case USHORT_ADD_USHORT: return binary(call, JavaOperator.ADD);
 			case USHORT_SUB_USHORT: return binary(call, JavaOperator.SUB);
 			case USHORT_MUL_USHORT: return binary(call, JavaOperator.MUL);
-			case USHORT_DIV_USHORT: return binary(call, JavaOperator.DIV);
-			case USHORT_MOD_USHORT: return binary(call, JavaOperator.MOD);
+			case USHORT_DIV_USHORT: return callAsStaticTruncated("Integer.divideUnsigned", call, JavaOperator.AND_FFFF);
+			case USHORT_MOD_USHORT: return callAsStaticTruncated("Integer.remainderUnsigned", call, JavaOperator.AND_FFFF);
 			case USHORT_AND_USHORT: return binary(call, JavaOperator.AND);
 			case USHORT_OR_USHORT: return binary(call, JavaOperator.OR);
 			case USHORT_XOR_USHORT: return binary(call, JavaOperator.XOR);
+			case USHORT_SHL: return binary(call, JavaOperator.SHL);
+			case USHORT_SHR: return binary(call, JavaOperator.SHR);
 			case INT_NOT: return unaryPrefix(call, JavaOperator.INVERT);
 			case INT_NEG: return unaryPrefix(call, JavaOperator.NEG);
 			case INT_ADD_INT: return binary(call, JavaOperator.ADD);
 			case GENERICMAP_SAME: return binary(call, JavaOperator.EQUALS);
 			case GENERICMAP_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
 			case ARRAY_INDEXGET: return new ExpressionString(call.target.accept(this) + "[" + call.arguments.arguments[0].accept(this) + "]", JavaOperator.INDEX);
-			case ARRAY_INDEXSET: return new ExpressionString(
+			case ARRAY_INDEXSET: {
+				ExpressionString value = call.arguments.arguments[1].accept(this);
+				ITypeID baseType = ((ArrayTypeID)(call.target.type)).elementType;
+				String asType = "";
+				if (baseType == BasicTypeID.BYTE) {
+					asType = "(byte)";
+				} else if (baseType == BasicTypeID.USHORT) {
+					asType = "(short)";
+				}
+				
+				if (!asType.isEmpty()) {
+					if (value.priority == JavaOperator.CAST && value.value.startsWith("(int)"))
+						value = new ExpressionString(asType + value.value.substring(5), value.priority);
+					else
+						value = value.unaryPrefix(JavaOperator.CAST, asType);
+				}
+				
+				return new ExpressionString(
 					call.target.accept(this)
 							+ "[" + call.arguments.arguments[0].accept(this)
 							+ "] = "
-							+ call.arguments.arguments[1].accept(this), JavaOperator.INDEX);
+							+ value.value, JavaOperator.INDEX);
+			}
 			case ARRAY_INDEXGETRANGE: {
 				ExpressionString left = call.target.accept(this);
 				Expression argument = call.arguments.arguments[0];
 					RangeExpression rangeArgument = (RangeExpression)argument;
 					ExpressionString from = rangeArgument.from.accept(this);
 					ExpressionString to = rangeArgument.to.accept(this);
-					return new ExpressionString("Arrays.copyOfRange(" + left.value + ", " + from.value + ", " + to.value + ")", JavaOperator.CALL);
+					return new ExpressionString(scope.type(JavaClass.ARRAYS) + ".copyOfRange(" + left.value + ", " + from.value + ", " + to.value + ")", JavaOperator.CALL);
 				} else {
 					throw new UnsupportedOperationException("Not yet supported!");
 				}
 				JavaMethod method = scope.fileScope.helperGenerator.createArrayContains((ArrayTypeID)call.target.type);
 				return callAsStatic(scope.fileScope.importer.importType(method.cls) + '.' + method.name, call);
 			}
-			case ARRAY_EQUALS: return callAsStatic("Arrays.equals", call);
-			case ARRAY_NOTEQUALS: return callAsStatic("!Arrays.equals", call);
+			case ARRAY_EQUALS: return callAsStatic(scope.type(JavaClass.ARRAYS) + ".equals", call);
+			case ARRAY_NOTEQUALS: return callAsStatic("!" + scope.type(JavaClass.ARRAYS) + ".equals", call);
 			case ARRAY_SAME: return binary(call, JavaOperator.EQUALS);
 			case ARRAY_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
 			case FUNCTION_CALL: {
 			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);
+			case UINT_COMPARE:
+			case USIZE_COMPARE_UINT:
+				return compare(callAsStatic("Integer.compareUnsigned", call.left, call.right), call.comparison);
+			case LONG_COMPARE:
+			case LONG_COMPARE_INT:
+				return compare(call.left, call.right, call.comparison);
+			case ULONG_COMPARE:
+			case ULONG_COMPARE_UINT:
+				return compare(callAsStatic("Long.compareUnsigned", call.left, call.right), call.comparison);
 			case FLOAT_COMPARE: return compare(call.left, call.right, call.comparison);
 			case DOUBLE_COMPARE: return compare(call.left, call.right, call.comparison);
 			case CHAR_COMPARE: return compare(call.left, call.right, call.comparison);
 			case ARRAY_LENGTH:
 				return call.target.accept(this).unaryPostfix(JavaOperator.MEMBER, ".length");
 			case ARRAY_HASHCODE:
-				return callAsStatic("Arrays.deepHashCode", call);
+				return callAsStatic(scope.type(JavaClass.ARRAYS) + ".deepHashCode", call);
 			case ARRAY_ISEMPTY:
 				return call.target.accept(this).unaryPostfix(JavaOperator.EQUALS, ".length == 0");
 			case ENUM_NAME:
 			case ULONG_TO_DOUBLE: return castImplicit(cast, "double"); // TODO: this is incorrect!
 			case ULONG_TO_CHAR: return cast(cast, "char");
 			case ULONG_TO_STRING: return callStatic("Long.toUnsignedString", cast.target);
+			case USIZE_TO_BYTE: return cast.target.accept(this);
+			case USIZE_TO_SBYTE: return cast(cast, "byte");
+			case USIZE_TO_SHORT: return cast(cast, "short");
+			case USIZE_TO_USHORT: return cast.target.accept(this);
+			case USIZE_TO_INT: return cast.target.accept(this);
+			case USIZE_TO_UINT: return cast.target.accept(this);
+			case USIZE_TO_LONG: return castImplicit(cast, "long");
+			case USIZE_TO_ULONG: return castImplicit(cast, "long");
+			case USIZE_TO_FLOAT: return castImplicit(cast, "float");
+			case USIZE_TO_DOUBLE: return castImplicit(cast, "double");
 			case FLOAT_TO_BYTE: return cast(cast, "int");
 			case FLOAT_TO_SBYTE: return cast(cast, "byte");
 			case FLOAT_TO_SHORT: return cast(cast, "short");
 			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);
+			case BYTE_ARRAY_AS_SBYTE_ARRAY:
+			case SBYTE_ARRAY_AS_BYTE_ARRAY:
+			case SHORT_ARRAY_AS_USHORT_ARRAY:
+			case USHORT_ARRAY_AS_SHORT_ARRAY:
+			case INT_ARRAY_AS_UINT_ARRAY:
+			case UINT_ARRAY_AS_INT_ARRAY:
+			case LONG_ARRAY_AS_ULONG_ARRAY:
+			case ULONG_ARRAY_AS_LONG_ARRAY:
+				return cast.target.accept(this);
 		}
 		
 		throw new UnsupportedOperationException("Unknown builtin cast: " + cast.member.member.builtin);
 	public ExpressionString sorted(Expression value) {
 		Expression target = duplicable(value);
 		ExpressionString targetString = target.accept(this);
-		ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
+		ExpressionString copy = new ExpressionString(scope.type(JavaClass.ARRAYS) + ".copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
 		ExpressionString source = hoist(copy, scope.type(target.type));
-		this.target.writeLine("Arrays.sort(" + source.value + ");");
+		this.target.writeLine(scope.type(JavaClass.ARRAYS) + ".sort(" + source.value + ");");
 		return source;
 	}
 
 		Expression target = duplicable(value);
 		ExpressionString comparatorString = comparator.accept(this);
 		ExpressionString targetString = target.accept(this);
-		ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
+		ExpressionString copy = new ExpressionString(scope.type(JavaClass.ARRAYS) + ".copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
 		ExpressionString source = hoist(copy, scope.type(target.type));
-		this.target.writeLine("Arrays.sort(" + source.value + ", " + comparatorString.value + ");");
+		this.target.writeLine(scope.type(JavaClass.ARRAYS) + ".sort(" + source.value + ", " + comparatorString.value + ");");
 		return source;
 	}
 
 	public ExpressionString copy(Expression value) {
 		Expression target = duplicable(value);
 		ExpressionString source = target.accept(this);
-		return new ExpressionString("Arrays.copyOf(" + source.value + ", " + source.value + ".length)", JavaOperator.CALL);
+		return new ExpressionString(scope.type(JavaClass.ARRAYS) + ".copyOf(" + source.value + ", " + source.value + ".length)", JavaOperator.CALL);
 	}
 
 	@Override
 			+ targetOffset.accept(this) + ", "
 			+ length.accept(this) + ")", JavaOperator.CALL);
 	}
+
+	@Override
+	public ExpressionString stringToAscii(Expression value) {
+		String standardCharsets = scope.type(STANDARD_CHARSETS);
+		return value.accept(this).unaryPostfix(JavaOperator.CALL, ".getBytes(" + standardCharsets + ".US_ASCII)");
+	}
+
+	@Override
+	public ExpressionString stringToUTF8(Expression value) {
+		String standardCharsets = scope.type(STANDARD_CHARSETS);
+		return value.accept(this).unaryPostfix(JavaOperator.CALL, ".getBytes(" + standardCharsets + ".UTF_8)");
+	}
+
+	@Override
+	public ExpressionString bytesAsciiToString(Expression value) {
+		String standardCharsets = scope.type(STANDARD_CHARSETS);
+		return new ExpressionString(
+				"new String(" + value.accept(this).value + ", " + standardCharsets + ".US_ASCII)",
+				JavaOperator.NEW);
+	}
+
+	@Override
+	public ExpressionString bytesUTF8ToString(Expression value) {
+		String standardCharsets = scope.type(STANDARD_CHARSETS);
+		return new ExpressionString(
+				"new String(" + value.accept(this).value + ", " + standardCharsets + ".UTF_8)",
+				JavaOperator.NEW);
+	}
 }

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

 	}
 	
 	public String importType(JavaClass cls) {
-		if (imports.containsKey(cls.outer.getName())) {
+		if (cls == null)
+			throw new NullPointerException();
+		
+		if (cls.outer != null && imports.containsKey(cls.outer.getName())) {
 			JavaClass imported = imports.get(cls.outer.getName());
 			usedImports.add(imported);
 			return imported.fullName.equals(cls.outer.fullName) ? cls.getName() : cls.fullName;

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

  */
 package org.openzen.zenscript.javasource;
 
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 			output.append(typeParameter.name);
 			
 			if (typeParameter.bounds.size() > 0) {
-				for (GenericParameterBound bound : typeParameter.bounds)
+				for (TypeParameterBound bound : typeParameter.bounds)
 					bound.accept(boundVisitor);
 			}
 		}
 				output.append(typeParameter.name);
 
 				if (typeParameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : typeParameter.bounds)
+					for (TypeParameterBound bound : typeParameter.bounds)
 						bound.accept(boundVisitor);
 				}
 			}
 				output.append(typeParameter.name);
 
 				if (typeParameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : typeParameter.bounds)
+					for (TypeParameterBound bound : typeParameter.bounds)
 						bound.accept(boundVisitor);
 				}
 			}

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenType.java

 	T_WHITESPACE_CARRIAGE_RETURN(true, "\r", "\r"),
 	T_IDENTIFIER("@?[a-zA-Z_][a-zA-Z_0-9]*"),
 	T_LOCAL_IDENTIFIER("$[a-zA-Z_][a-zA-Z_0-9]*"),
-	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?"),
-	T_INT("\\-?(0|[1-9][0-9]*)"),
+	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?[a-zA-Z_]"),
+	T_INT("\\-?(0|[1-9][0-9_]*)[a-zA-Z_]*"),
+	T_PREFIXED_INT("\\-?(0b|0x|0o|0B|0X|0O)(0|[1-9a-fA-F][0-9a-fA-F_]*)(u|U|l|L|ul|UL)?"),
 	T_STRING_SQ("\"([^\"\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\""),
 	T_STRING_DQ("\'([^\'\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\'"),
 	T_AOPEN("\\{", "{"),

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 		}
 		
 		if (failed)
-			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
+			return new SemanticModule(name, pkg.module, 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();
 			}
 		}
 		
-		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg.getPackage(), definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
+		return new SemanticModule(name, pkg.module, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg.getPackage(), definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
 	}
 	
 	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File file) throws IOException {

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedAlias.java

 		this.parameters = parameters;
 		this.type = type;
 		
-		compiled = new AliasDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new AliasDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		
 		if (parameters != null && parameters.size() > 0) {
 			TypeParameter[] typeParameters = new TypeParameter[parameters.size()];

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedClass.java

 		this.parameters = parameters;
 		this.superclass = superclass;
 		
-		compiled = new ClassDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new ClassDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(parameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnum.java

 	public ParsedEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, HighLevelDefinition outerDefinition) {
 		super(position, modifiers, pkg, annotations);
 		
-		compiled = new EnumDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new EnumDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 	
 	public void addEnumValue(ParsedEnumConstant value) {

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedExpansion.java

 		this.parameters = genericParameters;
 		this.target = target;
 		
-		compiled = new ExpansionDefinition(position, pkg.getPackage(), modifiers, outerDefinition);
+		compiled = new ExpansionDefinition(position, pkg.module, pkg.getPackage(), modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
 	}
 	

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedFunction.java

 		this.header = header;
 		this.body = body;
 		
-		compiled = new FunctionDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new FunctionDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedGenericBound.java

 package org.openzen.zenscript.parser.definitions;
 
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public abstract class ParsedGenericBound {
-	public abstract GenericParameterBound compile(TypeResolutionContext context);
+	public abstract TypeParameterBound compile(TypeResolutionContext context);
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedInterface.java

 		this.typeParameters = typeParameters;
 		this.superInterfaces = superInterfaces;
 		
-		compiled = new InterfaceDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new InterfaceDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(typeParameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedStruct.java

 		
 		this.parameters = genericParameters;
 		
-		compiled = new StructDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new StructDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedSuperBound.java

 package org.openzen.zenscript.parser.definitions;
 
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 	}
 
 	@Override
-	public GenericParameterBound compile(TypeResolutionContext context) {
+	public TypeParameterBound compile(TypeResolutionContext context) {
 		return new ParameterSuperBound(type.compile(context));
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedTypeBound.java

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 	}
 
 	@Override
-	public GenericParameterBound compile(TypeResolutionContext context) {
+	public TypeParameterBound compile(TypeResolutionContext context) {
 		return new ParameterTypeBound(position, type.compile(context));
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedVariant.java

 		super(position, modifiers, pkg, annotations);
 		
 		this.typeParameters = typeParameters;
-		compiled = new VariantDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new VariantDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(typeParameters));
 	}
 	

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpression.java

 	private static ParsedExpression readPrimaryExpression(CodePosition position, ZSTokenParser parser, ParsingOptions options) {
 		switch (parser.peek().getType()) {
 			case T_INT:
-				return new ParsedExpressionInt(position, Long.parseLong(parser.next().content));
+				return new ParsedExpressionInt(position, parser.next().content);
+			case T_PREFIXED_INT:
+				return ParsedExpressionInt.parsePrefixed(position, parser.next().content);
 			case T_FLOAT:
 				return new ParsedExpressionFloat(
 						position,
-						Double.parseDouble(parser.next().content));
+						parser.next().content);
 			case T_STRING_SQ:
 			case T_STRING_DQ:
 				return new ParsedExpressionString(
 						position,
 						StringExpansion.unescape(parser.next().content).orElse(error -> {
-							
 							return "INVALID_STRING";
 						}));
 			case T_IDENTIFIER: {

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionFloat.java

  */
 package org.openzen.zenscript.parser.expression;
 
+import java.util.Collections;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.parser.PrecompilationState;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
  */
 public class ParsedExpressionFloat extends ParsedExpression {
 	public final double value;
+	public final String suffix;
 	
-	public ParsedExpressionFloat(CodePosition position, double value) {
+	public ParsedExpressionFloat(CodePosition position, String value) {
+		super(position);
+		
+		int split = value.length();
+		while (isLetter(value.charAt(split - 1)))
+			split--;
+		
+		this.value = Long.parseLong(value.substring(0, split));
+		suffix = value.substring(split);
+	}
+	
+	private ParsedExpressionFloat(CodePosition position, double value) {
 		super(position);
 		
 		this.value = value;
+		this.suffix = "";
 	}
 
 	@Override
 		if (scope.hints.isEmpty())
 			return new ConstantDoubleExpression(position, value);
 		
+		if (suffix.equals("f") || suffix.equals("F"))
+			return new ConstantFloatExpression(position, (float)value);
+		if (suffix.equals("d") || suffix.equals("D"))
+			return new ConstantDoubleExpression(position, value);
+		
 		for (ITypeID hint : scope.hints) {
-			if (hint == BasicTypeID.DOUBLE)
-				return new ConstantDoubleExpression(position, value);
-			else if (hint == BasicTypeID.FLOAT)
-				return new ConstantFloatExpression(position, (float) value);
+			if (suffix.isEmpty()) {
+				if (hint == BasicTypeID.DOUBLE)
+					return new ConstantDoubleExpression(position, value);
+				else if (hint == BasicTypeID.FLOAT)
+					return new ConstantFloatExpression(position, (float) value);
+			} else {
+				TypeMembers members = scope.getTypeMembers(hint);
+				FunctionalMemberRef method = members.getOrCreateGroup(suffix, true).getStaticMethod(1, hint);
+				if (method != null) {
+					ParsedCallArguments parsedArguments = new ParsedCallArguments(Collections.emptyList(), Collections.singletonList(new ParsedExpressionFloat(position, value)));
+					CallArguments arguments = parsedArguments.compileCall(position, scope, ITypeID.NONE, method.getHeader());
+					method.callStatic(position, hint, method.getHeader(), arguments, scope);
+				}
+			}
 		}
 		
-		StringBuilder types = new StringBuilder();
-		for (int i = 0; i < scope.hints.size(); i++) {
-			if (i > 0)
-				types.append(", ");
-			
-			types.append(scope.hints.get(i).toString());
+		if (suffix.isEmpty()) {
+			StringBuilder types = new StringBuilder();
+			for (int i = 0; i < scope.hints.size(); i++) {
+				if (i > 0)
+					types.append(", ");
+
+				types.append(scope.hints.get(i).toString());
+			}
+
+			throw new CompileException(position, CompileExceptionCode.INVALID_CAST, "Cannot cast a floating-point value to any of these types: " + types);
+		} else {
+			throw new CompileException(position, CompileExceptionCode.INVALID_SUFFIX, "Invalid suffix: " + suffix);
 		}
-		
-		throw new CompileException(position, CompileExceptionCode.INVALID_CAST, "Cannot cast a floating-point value to any of these types: " + types);
 	}
 
 	@Override
 	public boolean hasStrongType() {
 		return false;
 	}
+	
+	private static boolean isLetter(char c) {
+		return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
+	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionInt.java

  */
 package org.openzen.zenscript.parser.expression;
 
+import java.util.Collections;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.parser.PrecompilationState;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ParsedExpressionInt extends ParsedExpression {
+	public static ParsedExpressionInt parsePrefixed(CodePosition position, String value) {
+		boolean negative = value.startsWith("-");
+		if (negative)
+			value = value.substring(1);
+		
+		String suffix = "";
+		if (value.endsWith("u") || value.endsWith("l") || value.endsWith("U") || value.endsWith("L")) {
+			suffix = value.substring(value.length() - 1);
+			value = value.substring(0, value.length() - 1);
+		} else if (value.endsWith("ul") || value.endsWith("UL")) {
+			suffix = value.substring(value.length() - 2);
+			value = value.substring(0, value.length() - 2);
+		}
+		
+		value = value.toLowerCase();
+		
+		long parsed = 0;
+		if (value.startsWith("0x")) {
+			for (char c : value.substring(2).toCharArray()) {
+				if (c >= '0' && c <= '9')
+					parsed = parsed * 16 + (c - '0');
+				else if (c >= 'a' && c <= 'f')
+					parsed = parsed * 16 + 10 + (c - 'a');
+				else if (c != '_')
+					throw new NumberFormatException("Invalid number: " + value);
+			}
+		} else if (value.startsWith("0b")) {
+			for (char c : value.substring(2).toCharArray()) {
+				if (c == '0')
+					parsed = parsed * 2;
+				else if (c == '1')
+					parsed = parsed * 2 + 1;
+				else if (c != '_')
+					throw new NumberFormatException("Invalid number: " + value);
+			}
+		} else if (value.startsWith("0o")) {
+			for (char c : value.substring(2).toCharArray()) {
+				if (c >= '0' && c <= '7')
+					parsed = parsed * 8 + c - '0';
+				else if (c != '_')
+					throw new NumberFormatException("Invalid number: " + value);
+			}
+		} else {
+			throw new NumberFormatException("Invalid number: " + value);
+		}
+		
+		return new ParsedExpressionInt(position, negative, negative ? -parsed : parsed, suffix);
+	}
+	
+	public final boolean negative;
 	public final long value;
+	public final String suffix;
 	
-	public ParsedExpressionInt(CodePosition position, long value) {
+	public ParsedExpressionInt(CodePosition position, String value) {
 		super(position);
 		
+		int split = value.length();
+		while (isLetter(value.charAt(split - 1)))
+			split--;
+		
+		negative = value.charAt(0) == '-';
+		this.value = Long.parseLong(value.substring(0, split));
+		suffix = value.substring(split);
+	}
+	
+	private ParsedExpressionInt(CodePosition position, boolean negative, long value, String suffix) {
+		super(position);
+		
+		this.negative = negative;
 		this.value = value;
+		this.suffix = suffix;
 	}
-
+	
 	@Override
 	public Expression compile(ExpressionScope scope) {
+		if (suffix.equals("L") || suffix.equals("l"))
+			return new ConstantLongExpression(position, value);
+		if (suffix.equals("UL") || suffix.equals("ul"))
+			return new ConstantULongExpression(position, value);
+		if (suffix.equals("U") || suffix.equals("u"))
+			return new ConstantUIntExpression(position, (int)value);
+		
 		for (ITypeID hint : scope.hints) {
-			if (hint instanceof BasicTypeID) {
+			if (suffix.isEmpty() && (hint instanceof BasicTypeID)) {
 				switch ((BasicTypeID) hint) {
 					case SBYTE:
 						return new ConstantSByteExpression(position, (byte) value);
 					case BYTE:
-						return new ConstantByteExpression(position, (byte) value);
+						if (negative)
+							break;
+						
+						return new ConstantByteExpression(position, (int)(value & 0xFF));
 					case SHORT:
 						return new ConstantShortExpression(position, (short) value);
 					case USHORT:
-						return new ConstantUShortExpression(position, (short) value);
+						if (negative)
+							break;
+						
+						return new ConstantUShortExpression(position, (int)(value & 0xFFFF));
 					case INT:
 						return new ConstantIntExpression(position, (int) value);
 					case UINT:
+						if (negative)
+							break;
+						
 						return new ConstantUIntExpression(position, (int) value);
 					case LONG:
 						return new ConstantLongExpression(position, value);
 					case ULONG:
+						if (negative)
+							break;
+						
 						return new ConstantULongExpression(position, value);
 					case USIZE:
+						if (negative)
+							break;
+						
 						return new ConstantUSizeExpression(position, value);
 					case CHAR:
+						if (negative)
+							break;
+						
 						return new ConstantCharExpression(position, (char) value);
 					default:
 				}
+			} else if (!suffix.isEmpty()) {
+				TypeMembers members = scope.getTypeMembers(hint);
+				FunctionalMemberRef method = members.getOrCreateGroup(suffix, true).getStaticMethod(1, hint);
+				if (method != null) {
+					ParsedCallArguments parsedArguments = new ParsedCallArguments(Collections.emptyList(), Collections.singletonList(new ParsedExpressionInt(position, negative, value, "")));
+					CallArguments arguments = parsedArguments.compileCall(position, scope, ITypeID.NONE, method.getHeader());
+					method.callStatic(position, hint, method.getHeader(), arguments, scope);
+				}
 			}
 		}
 		
-		if (value <= Integer.MAX_VALUE && value >= Integer.MIN_VALUE)
-			return new ConstantIntExpression(position, (int) value);
-		else
-			return new ConstantLongExpression(position, value);
+		if (suffix.isEmpty()) {
+			if (value <= Integer.MAX_VALUE && value >= Integer.MIN_VALUE)
+				return new ConstantIntExpression(position, (int) value);
+			else
+				return new ConstantLongExpression(position, value);
+		} else {
+			throw new CompileException(position, CompileExceptionCode.INVALID_SUFFIX, "Invalid suffix: " + suffix);
+		}
 	}
 	
 	@Override
 	public boolean hasStrongType() {
 		return false;
 	}
+	
+	private static boolean isLetter(char c) {
+		return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
+	}
 }

ScriptingExample/build.gradle

 	compile project(':JavaBytecodeCompiler')
 	compile project(':JavaShared')
 	compile project(':CodeFormatter')
-//	compile project(':ScriptingHost')
+    //compile project(':ScriptingHost')
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/GlobalRegistry.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 			// eg. package my.package with a class MyClass with a single native method test() returning a string
 			// the visitors can then during compilation check if a method is an instance of NativeMethodMember and treat it accordingly
 			ZSPackage packageMyPackage = rootPackage.getOrCreatePackage("my").getOrCreatePackage("test");
-			ClassDefinition myClassDefinition = new ClassDefinition(CodePosition.NATIVE, packageMyPackage, "MyClass", Modifiers.PUBLIC, null);
+			ClassDefinition myClassDefinition = new ClassDefinition(CodePosition.NATIVE, MODULE, packageMyPackage, "MyClass", Modifiers.PUBLIC, null);
 			JavaClass myClassInfo = new JavaClass("my.test", "MyClass", JavaClass.Kind.CLASS);
 			
 			MethodMember member = new MethodMember(CodePosition.NATIVE, myClassDefinition, Modifiers.PUBLIC, "test", new FunctionHeader(BasicTypeID.STRING), null);
 		return globals;
 	}
 	
-	private final ClassDefinition PRINTSTREAM = new ClassDefinition(CodePosition.NATIVE, javaIo, "PrintStream", Modifiers.EXPORT);
-	private final ClassDefinition SYSTEM = new ClassDefinition(CodePosition.NATIVE, javaLang, "System", Modifiers.EXPORT);
+	private final Module MODULE = new Module("scriptingExample");
+	private final ClassDefinition PRINTSTREAM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaIo, "PrintStream", Modifiers.EXPORT);
+	private final ClassDefinition SYSTEM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaLang, "System", Modifiers.EXPORT);
 	private final MethodMember PRINTSTREAM_PRINTLN = new MethodMember(
 			CodePosition.NATIVE,
 			PRINTSTREAM,

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		
 		ZSPackage pkg = new ZSPackage(null, "");
-		CompilingPackage compilingPkg = new CompilingPackage(pkg);
+		Module module = new Module("scripts");
+		CompilingPackage compilingPkg = new CompilingPackage(pkg, module);
 		ParsedFile[] parsedFiles = parse(compilingPkg, inputFiles);
 		
 		ZSPackage global = new ZSPackage(null, "");
 		GlobalRegistry registry = new GlobalRegistry(global);
-		SemanticModule module = compileSyntaxToSemantic(compilingPkg, parsedFiles, registry);
+		SemanticModule semantic = compileSyntaxToSemantic(compilingPkg, parsedFiles, registry);
 		
 		//formatFiles(pkg, module);
 		
-		if (module.isValid()) {
-			JavaModule javaModule = compileSemanticToJava(module);
+		if (semantic.isValid()) {
+			JavaModule javaModule = compileSemanticToJava(semantic);
 			javaModule.execute();
 		} else {
 			System.out.println("There were compilation errors");

Shared/src/main/java/compactio/CompactBytesDataInput.java

+package compactio;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+public final class CompactBytesDataInput implements CompactDataInput, AutoCloseable {
+    private static final int P6 = 1 << 6;
+    private static final int P7 = 1 << 7;
+    private static final int P13 = 1 << 13;
+    private static final int P14 = 1 << 14;
+    private static final int P20 = 1 << 20;
+    private static final int P21 = 1 << 21;
+    private static final int P27 = 1 << 27;
+    private static final int P28 = 1 << 28;
+    private static final long P34 = 1L << 34;
+    private static final long P35 = 1L << 35;
+    private static final long P41 = 1L << 41;
+    private static final long P42 = 1L << 42;
+    private static final long P48 = 1L << 48;
+    private static final long P49 = 1L << 49;
+    private static final long P55 = 1L << 55;
+    private static final long P56 = 1L << 56;
+    private final byte[] data;
+    private int offset;
+    
+    public CompactBytesDataInput(byte[] data) {
+        this.data = data;
+        this.offset = 0;
+    }
+    
+    public CompactBytesDataInput(byte[] data, int offset) {
+        this.data = data;
+        this.offset = offset;
+    }
+    
+    @Override
+    public void close() {
+    }
+    
+    @Override
+    public boolean readBool() {
+        return this.readByte() != (byte)0;
+    }
+    
+    @Override
+    public byte readByte() {
+        return (byte)(data[offset++]);
+    }
+    
+    @Override
+    public int readSByte() {
+        return data[offset++];
+    }
+    
+    @Override
+    public short readShort() {
+        int b0 = data[offset++] & 0xFF;
+        int b1 = data[offset++] & 0xFF;
+        return (short)(b0 << 8 | b1);
+    }
+    
+    @Override
+    public int readUShort() {
+        return this.readShort();
+    }
+    
+    @Override
+    public int readInt() {
+        int b0 = data[offset++] & 0xFF;
+        int b1 = data[offset++] & 0xFF;
+        int b2 = data[offset++] & 0xFF;
+        int b3 = data[offset++] & 0xFF;
+        return b0 << 24 | b1 << 16 | b2 << 8 | b3;
+    }
+    
+    @Override
+    public int readUInt() {
+        return this.readInt();
+    }
+    
+    @Override
+    public long readLong() {
+        long i0 = (long)(this.readUInt());
+        long i1 = (long)(this.readUInt());
+        return i0 << 32 | i1;
+    }
+    
+    @Override
+    public long readULong() {
+        return this.readLong();
+    }
+    
+    @Override
+    public int readVarInt() {
+        int value = this.readVarUInt();
+        return Integer.compareUnsigned(value & 1, 0) == 0 ? value >>> 1 : -((value >>> 1) + 1);
+    }
+    
+    @Override
+    public int readVarUInt() {
+        int value = data[offset++] & 0xFF;
+        if (Integer.compareUnsigned(value & CompactBytesDataInput.P7, 0) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P7 - 1 | (data[offset++] & 0xFF) << 7;
+        if (Integer.compareUnsigned(value & CompactBytesDataInput.P14, 0) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P14 - 1 | (data[offset++] & 0xFF) << 14;
+        if (Integer.compareUnsigned(value & CompactBytesDataInput.P21, 0) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P21 - 1 | (data[offset++] & 0xFF) << 21;
+        if (Integer.compareUnsigned(value & CompactBytesDataInput.P28, 0) == 0)
+            return value;
+        return value & CompactBytesDataInput.P28 - 1 | (data[offset++] & 0xFF) << 28;
+    }
+    
+    @Override
+    public long readVarLong() {
+        long value = this.readVarULong();
+        return Long.compareUnsigned(value & 1L, 0L) == 0 ? value >>> 1 : -((value >>> 1) + 1L);
+    }
+    
+    @Override
+    public long readVarULong() {
+        long value = data[offset++] & 0xFFL;
+        if (Long.compareUnsigned(value & (CompactBytesDataInput.P7 & 0xFFFFFFFFL), 0L) == 0)
+            return value;
+        value = value & (CompactBytesDataInput.P7 - 1 & 0xFFFFFFFFL) | (data[offset++] & 0xFFL) << 7;
+        if (Long.compareUnsigned(value & (CompactBytesDataInput.P14 & 0xFFFFFFFFL), 0L) == 0)
+            return value;
+        value = value & (CompactBytesDataInput.P14 - 1 & 0xFFFFFFFFL) | (data[offset++] & 0xFFL) << 14;
+        if (Long.compareUnsigned(value & (CompactBytesDataInput.P21 & 0xFFFFFFFFL), 0L) == 0)
+            return value;
+        value = value & (CompactBytesDataInput.P21 - 1 & 0xFFFFFFFFL) | (data[offset++] & 0xFFL) << 21;
+        if (Long.compareUnsigned(value & (CompactBytesDataInput.P28 & 0xFFFFFFFFL), 0L) == 0)
+            return value;
+        value = value & (CompactBytesDataInput.P28 - 1 & 0xFFFFFFFFL) | (data[offset++] & 0xFFL) << 28;
+        if (Long.compareUnsigned(value & CompactBytesDataInput.P35, 0L) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P35 - 1L | (data[offset++] & 0xFFL) << 35;
+        if (Long.compareUnsigned(value & CompactBytesDataInput.P42, 0L) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P42 - 1L | (data[offset++] & 0xFFL) << 42;
+        if (Long.compareUnsigned(value & CompactBytesDataInput.P49, 0L) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P49 - 1L | (data[offset++] & 0xFFL) << 49;
+        if (Long.compareUnsigned(value & CompactBytesDataInput.P56, 0L) == 0)
+            return value;
+        return value & CompactBytesDataInput.P56 - 1L | (data[offset++] & 0xFFL) << 56;
+    }
+    
+    @Override
+    public float readFloat() {
+        return Float.intBitsToFloat(this.readUInt());
+    }
+    
+    @Override
+    public double readDouble() {
+        return Double.longBitsToDouble(this.readULong());
+    }
+    
+    @Override
+    public char readChar() {
+        return (char)(this.readVarUInt());
+    }
+    
+    @Override
+    public String readString() {
+        return new String(this.readBytes(), StandardCharsets.UTF_8);
+    }
+    
+    @Override
+    public byte[] readBytes() {
+        int size = this.readVarUInt();
+        return this.readRawBytes(size);
+    }
+    
+    @Override
+    public byte[] readRawBytes(int size) {
+        byte[] result = Arrays.copyOfRange(data, offset, offset + size);
+        this.offset = offset + size;
+        return result;
+    }
+    
+    @Override
+    public boolean[] readBoolArray() {
+        int size = this.readVarUInt();
+        boolean[] result = new boolean[size];
+        int limitForI = (size + 7) / 8;
+        for (int i = 0; i < limitForI; i++) {
+            byte bvalue = this.readByte();
+            int remainingBits = result.length - 8 * i;
+            if (remainingBits > 0)
+                result[i * 8 + 0] = (bvalue & (byte)1) > (byte)0;
+            if (remainingBits > 1)
+                result[i * 8 + 2] = (bvalue & (byte)4) > (byte)0;
+            if (remainingBits > 3)
+                result[i * 8 + 3] = (bvalue & (byte)8) > (byte)0;
+            if (remainingBits > 4)
+                result[i * 8 + 4] = (bvalue & (byte)16) > (byte)0;
+            if (remainingBits > 5)
+                result[i * 8 + 5] = (bvalue & (byte)32) > (byte)0;
+            if (remainingBits > 6)
+                result[i * 8 + 6] = (bvalue & (byte)64) > (byte)0;
+            if (remainingBits > 7)
+                result[i * 8 + 7] = (bvalue & (byte)-128) > (byte)0;
+        }
+        return result;
+    }
+    
+    @Override
+    public byte[] readByteArray() {
+        return this.readBytes();
+    }
+    
+    @Override
+    public byte[] readSByteArray() {
+        return this.readBytes();
+    }
+    
+    @Override
+    public short[] readShortArray() {
+        return this.readShortArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public short[] readShortArrayRaw(int length) {
+        short[] result = new short[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readShort();
+        return result;
+    }
+    
+    @Override
+    public short[] readUShortArray() {
+        return this.readShortArray();
+    }
+    
+    @Override
+    public short[] readUShortArrayRaw(int length) {
+        return this.readShortArrayRaw(length);
+    }
+    
+    @Override
+    public int[] readVarIntArray() {
+        return this.readVarIntArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public int[] readVarIntArrayRaw(int length) {
+        int[] result = new int[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readVarInt();
+        return result;
+    }
+    
+    @Override
+    public int[] readVarUIntArray() {
+        return this.readVarUIntArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public int[] readVarUIntArrayRaw(int length) {
+        int[] result = new int[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readVarUInt();
+        return result;
+    }
+    
+    @Override
+    public int[] readIntArray() {
+        return this.readIntArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public int[] readIntArrayRaw(int length) {
+        int[] result = new int[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readInt();
+        return result;
+    }
+    
+    @Override
+    public int[] readUIntArray() {
+        return this.readUIntArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public int[] readUIntArrayRaw(int length) {
+        int[] result = new int[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readUInt();
+        return result;
+    }
+    
+    @Override
+    public long[] readVarLongArray() {
+        return this.readVarLongArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public long[] readVarLongArrayRaw(int length) {
+        long[] result = new long[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readVarLong();
+        return result;
+    }
+    
+    @Override
+    public long[] readVarULongArray() {
+        return this.readVarULongArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public long[] readVarULongArrayRaw(int length) {
+        long[] result = new long[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readVarULong();
+        return result;
+    }
+    
+    @Override
+    public long[] readLongArray() {
+        return this.readLongArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public long[] readLongArrayRaw(int length) {
+        long[] result = new long[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readLong();
+        return result;
+    }
+    
+    @Override
+    public long[] readULongArray() {
+        return this.readLongArray();
+    }
+    
+    @Override
+    public long[] readULongArrayRaw(int length) {
+        return this.readLongArrayRaw(length);
+    }
+    
+    @Override
+    public float[] readFloatArray() {
+        return this.readFloatArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public float[] readFloatArrayRaw(int length) {
+        float[] result = new float[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readFloat();
+        return result;
+    }
+    
+    @Override
+    public double[] readDoubleArray() {
+        return this.readDoubleArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public double[] readDoubleArrayRaw(int length) {
+        double[] result = new double[length];
+        int limitForI = length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readDouble();
+        return result;
+    }
+    
+    @Override
+    public String[] readStringArray() {
+        return this.readStringArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public String[] readStringArrayRaw(int length) {
+        String[] result = new String[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readString();
+        return result;
+    }
+    
+    @Override
+    public void skip(int bytes) {
+        this.offset = offset + bytes;
+    }
+    
+    @Override
+    public boolean hasMore() {
+        return offset < data.length;
+    }
+    
+    public int getOffset() {
+        return offset;
+    }
+}

Shared/src/main/java/compactio/CompactBytesDataOutput.java

+package compactio;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+public final class CompactBytesDataOutput implements CompactDataOutput, AutoCloseable {
+    private static final int P6 = 1 << 6;
+    private static final int P7 = 1 << 7;
+    private static final int P13 = 1 << 13;
+    private static final int P14 = 1 << 14;
+    private static final int P20 = 1 << 20;
+    private static final int P21 = 1 << 21;
+    private static final int P27 = 1 << 27;
+    private static final int P28 = 1 << 28;
+    private static final long P34 = 1L << 34;
+    private static final long P35 = 1L << 35;
+    private static final long P41 = 1L << 41;
+    private static final long P42 = 1L << 42;
+    private static final long P48 = 1L << 48;
+    private static final long P49 = 1L << 49;
+    private static final long P55 = 1L << 55;
+    private static final long P56 = 1L << 56;
+    private byte[] data = new byte[16];
+    private int length = 0;
+    
+    private void reserve(int bytes) {
+        while (length + bytes > data.length)
+            this.data = Arrays.copyOf(data, 2 * data.length);
+    }
+    
+    public byte[] asByteArray() {
+        return Arrays.copyOf(data, length);
+    }
+    
+    @Override
+    public void close() {
+    }
+    
+    @Override
+    public void writeBool(boolean value) {
+        this.writeByte(value ? 1 : 0);
+    }
+    
+    @Override
+    public void writeByte(int value) {
+        this.reserve(1);
+        data[length++] = (byte)value;
+    }
+    
+    @Override
+    public void writeSByte(byte value) {
+        this.writeByte(value);
+    }
+    
+    @Override
+    public void writeShort(short value) {
+        this.writeUShort(value);
+    }
+    
+    @Override
+    public void writeUShort(int value) {
+        this.reserve(2);
+        data[length++] = (byte)(value >> 8);
+        data[length++] = (byte)value;
+    }
+    
+    @Override
+    public void writeInt(int value) {
+        this.writeUInt(value);
+    }
+    
+    @Override
+    public void writeUInt(int value) {
+        this.reserve(4);
+        data[length++] = (byte)(value >>> 24);
+        data[length++] = (byte)(value >>> 16);
+        data[length++] = (byte)(value >>> 8);
+        data[length++] = (byte)value;
+    }
+    
+    @Override
+    public void writeLong(long value) {
+        this.writeULong(value);
+    }
+    
+    @Override
+    public void writeULong(long value) {
+        this.reserve(8);
+        data[length++] = (byte)(value >>> 56);
+        data[length++] = (byte)(value >>> 48);
+        data[length++] = (byte)(value >>> 40);
+        data[length++] = (byte)(value >>> 32);
+        data[length++] = (byte)(value >>> 24);
+        data[length++] = (byte)(value >>> 16);
+        data[length++] = (byte)(value >>> 8);
+        data[length++] = (byte)value;
+    }
+    
+    @Override
+    public void writeVarInt(int value) {
+        this.writeVarUInt(value < 0 ? (1 - value << 1) + 1 : value << 1);
+    }
+    
+    @Override
+    public void writeVarUInt(int value) {
+        this.reserve(5);
+        if (Integer.compareUnsigned(value, CompactBytesDataOutput.P7) < 0) {
+            data[length++] = (byte)(value & 127);
+        }
+        else
+            if (Integer.compareUnsigned(value, CompactBytesDataOutput.P14) < 0) {
+                data[length++] = (byte)(value & 127 | 128);
+                data[length++] = (byte)(value >>> 7 & 127);
+            }
+            else
+                if (Integer.compareUnsigned(value, CompactBytesDataOutput.P21) < 0) {
+                    data[length++] = (byte)(value & 127 | 128);
+                    data[length++] = (byte)(value >>> 7 & 127 | 128);
+                    data[length++] = (byte)(value >>> 14 & 127);
+                }
+                else
+                    if (Integer.compareUnsigned(value, CompactBytesDataOutput.P28) < 0) {
+                        data[length++] = (byte)(value & 127 | 128);
+                        data[length++] = (byte)(value >>> 7 & 127 | 128);
+                        data[length++] = (byte)(value >>> 14 & 127 | 128);
+                        data[length++] = (byte)(value >>> 21 & 127);
+                    }
+                    else {
+                        data[length++] = (byte)(value & 127 | 128);
+                        data[length++] = (byte)(value >>> 7 & 127 | 128);
+                        data[length++] = (byte)(value >>> 14 & 127 | 128);
+                        data[length++] = (byte)(value >>> 21 & 127 | 128);
+                        data[length++] = (byte)(value >>> 28 & 127);
+                    }
+    }
+    
+    @Override
+    public void writeVarLong(long value) {
+        this.writeVarULong(value < 0L ? (1L - value << 1) + 1L : value << 1);
+    }
+    
+    @Override
+    public void writeVarULong(long value) {
+        this.reserve(9);
+        if (Long.compareUnsigned(value, CompactBytesDataOutput.P7) < 0) {
+            data[length++] = (byte)(value & 127L);
+        }
+        else
+            if (Long.compareUnsigned(value, CompactBytesDataOutput.P14) < 0) {
+                data[length++] = (byte)(value & 127L | 128L);
+                data[length++] = (byte)(value >>> 7 & 127L);
+            }
+            else
+                if (Long.compareUnsigned(value, CompactBytesDataOutput.P21) < 0) {
+                    data[length++] = (byte)(value & 127L | 128L);
+                    data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                    data[length++] = (byte)(value >>> 14 & 127L);
+                }
+                else
+                    if (Long.compareUnsigned(value, CompactBytesDataOutput.P28) < 0) {
+                        data[length++] = (byte)(value & 127L | 128L);
+                        data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                        data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                        data[length++] = (byte)(value >>> 21 & 127L);
+                    }
+                    else
+                        if (Long.compareUnsigned(value, CompactBytesDataOutput.P35) < 0) {
+                            data[length++] = (byte)(value & 127L | 128L);
+                            data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                            data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                            data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                            data[length++] = (byte)(value >>> 28 & 127L);
+                        }
+                        else
+                            if (Long.compareUnsigned(value, CompactBytesDataOutput.P42) < 0) {
+                                data[length++] = (byte)(value & 127L | 128L);
+                                data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                                data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                                data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                                data[length++] = (byte)(value >>> 28 & 127L | 128L);
+                                data[length++] = (byte)(value >>> 35 & 127L);
+                            }
+                            else
+                                if (Long.compareUnsigned(value, CompactBytesDataOutput.P49) < 0) {
+                                    data[length++] = (byte)(value & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 28 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 35 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 42 & 127L);
+                                }
+                                else
+                                    if (Long.compareUnsigned(value, CompactBytesDataOutput.P56) < 0) {
+                                        data[length++] = (byte)(value & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 28 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 35 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 42 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 49 & 127L);
+                                    }
+                                    else {
+                                        data[length++] = (byte)(value & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 28 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 35 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 42 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 49 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 56);
+                                    }
+    }
+    
+    @Override
+    public void writeFloat(float value) {
+        this.writeUInt(Float.floatToRawIntBits(value));
+    }
+    
+    @Override
+    public void writeDouble(double value) {
+        this.writeULong(Double.doubleToRawLongBits(value));
+    }
+    
+    @Override
+    public void writeChar(char value) {
+        this.writeVarUInt(value);
+    }
+    
+    @Override
+    public void writeBytes(byte[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeRawBytes(data);
+    }
+    
+    @Override
+    public void writeBytes(byte[] data, int offset, int length) {
+        if (!(Integer.compareUnsigned(length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(length);
+        this.writeRawBytes(data, offset, length);
+    }
+    
+    @Override
+    public void writeString(String str) {
+        this.writeBytes(str.getBytes(StandardCharsets.UTF_8));
+    }
+    
+    @Override
+    public void writeRawBytes(byte[] value) {
+        this.reserve(value.length);
+        System.arraycopy(value, 0, data, length, value.length);
+        this.length = length + value.length;
+    }
+    
+    @Override
+    public void writeRawBytes(byte[] value, int offset, int length) {
+        this.reserve(value.length);
+        System.arraycopy(value, offset, data, this.length, value.length);
+        this.length = this.length + length;
+    }
+    
+    @Override
+    public void writeBoolArray(boolean[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        int i = 0;
+        while (i < data.length - 7) {
+            int bvalue = 0;
+            if (data[i + 0])
+                bvalue = bvalue | 1;
+            if (data[i + 1])
+                bvalue = bvalue | 2;
+            if (data[i + 2])
+                bvalue = bvalue + 4;
+            if (data[i + 3])
+                bvalue = bvalue + 8;
+            if (data[i + 4])
+                bvalue = bvalue + 16;
+            if (data[i + 5])
+                bvalue = bvalue + 32;
+            if (data[i + 6])
+                bvalue = bvalue + 64;
+            if (data[i + 7])
+                bvalue = bvalue + 128;
+            this.writeByte(bvalue);
+            i = i + 8;
+        }
+        if (i < data.length) {
+            int bvalue = 0;
+            int limitForOffset = data.length % 7;
+            for (int offset = 0; offset < limitForOffset; offset++)
+                if (data[i + offset])
+                    bvalue = bvalue + (1 << i);
+            this.writeByte(bvalue);
+        }
+    }
+    
+    @Override
+    public void writeByteArray(byte[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeBytes(data);
+    }
+    
+    @Override
+    public void writeSByteArray(byte[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeBytes(data);
+    }
+    
+    @Override
+    public void writeShortArray(short[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeShortArrayRaw(data);
+    }
+    
+    @Override
+    public void writeShortArrayRaw(short[] data) {
+        for (short element : data)
+            this.writeShort(element);
+    }
+    
+    @Override
+    public void writeUShortArray(short[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeShortArray(data);
+    }
+    
+    @Override
+    public void writeUShortArrayRaw(short[] data) {
+        this.writeShortArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarIntArray(int[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeVarIntArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarIntArrayRaw(int[] data) {
+        for (int element : data)
+            this.writeVarInt(element);
+    }
+    
+    @Override
+    public void writeVarUIntArray(int[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeVarUIntArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarUIntArrayRaw(int[] data) {
+        for (int element : data)
+            this.writeVarUInt(element);
+    }
+    
+    @Override
+    public void writeIntArray(int[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeIntArrayRaw(data);
+    }
+    
+    @Override
+    public void writeIntArrayRaw(int[] data) {
+        for (int element : data)
+            this.writeInt(element);
+    }
+    
+    @Override
+    public void writeUIntArray(int[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeIntArray(data);
+    }
+    
+    @Override
+    public void writeUIntArrayRaw(int[] data) {
+        this.writeIntArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarLongArray(long[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeVarLongArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarLongArrayRaw(long[] data) {
+        for (long element : data)
+            this.writeVarLong(element);
+    }
+    
+    @Override
+    public void writeVarULongArray(long[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeVarULongArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarULongArrayRaw(long[] data) {
+        for (long element : data)
+            this.writeVarULong(element);
+    }
+    
+    @Override
+    public void writeLongArray(long[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeLongArrayRaw(data);
+    }
+    
+    @Override
+    public void writeLongArrayRaw(long[] data) {
+        for (long element : data)
+            this.writeLong(element);
+    }
+    
+    @Override
+    public void writeULongArray(long[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeLongArray(data);
+    }
+    
+    @Override
+    public void writeULongArrayRaw(long[] data) {
+        this.writeLongArrayRaw(data);
+    }
+    
+    @Override
+    public void writeFloatArray(float[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeFloatArrayRaw(data);
+    }
+    
+    @Override
+    public void writeFloatArrayRaw(float[] data) {
+        for (float element : data)
+            this.writeFloat(element);
+    }
+    
+    @Override
+    public void writeDoubleArray(double[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeDoubleArrayRaw(data);
+    }
+    
+    @Override
+    public void writeDoubleArrayRaw(double[] data) {
+        for (double element : data)
+            this.writeDouble(element);
+    }
+    
+    @Override
+    public void writeStringArray(String[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeStringArrayRaw(data);
+    }
+    
+    @Override
+    public void writeStringArrayRaw(String[] data) {
+        for (String element : data)
+            this.writeString(element);
+    }
+    
+    @Override
+    public void flush() {
+    }
+}

Shared/src/main/java/compactio/CompactDataInput.java

+package compactio;
+
+public interface CompactDataInput extends AutoCloseable {
+    boolean readBool();
+    
+    byte readByte();
+    
+    int readSByte();
+    
+    short readShort();
+    
+    int readUShort();
+    
+    int readInt();
+    
+    int readUInt();
+    
+    long readLong();
+    
+    long readULong();
+    
+    int readVarInt();
+    
+    int readVarUInt();
+    
+    long readVarLong();
+    
+    long readVarULong();
+    
+    float readFloat();
+    
+    double readDouble();
+    
+    char readChar();
+    
+    String readString();
+    
+    byte[] readBytes();
+    
+    byte[] readRawBytes(int length);
+    
+    boolean[] readBoolArray();
+    
+    byte[] readByteArray();
+    
+    byte[] readSByteArray();
+    
+    short[] readShortArray();
+    
+    short[] readShortArrayRaw(int length);
+    
+    short[] readUShortArray();
+    
+    short[] readUShortArrayRaw(int length);
+    
+    int[] readVarIntArray();
+    
+    int[] readVarIntArrayRaw(int length);
+    
+    int[] readVarUIntArray();
+    
+    int[] readVarUIntArrayRaw(int length);
+    
+    int[] readIntArray();
+    
+    int[] readIntArrayRaw(int length);
+    
+    int[] readUIntArray();
+    
+    int[] readUIntArrayRaw(int length);
+    
+    long[] readVarLongArray();
+    
+    long[] readVarLongArrayRaw(int length);
+    
+    long[] readVarULongArray();
+    
+    long[] readVarULongArrayRaw(int length);
+    
+    long[] readLongArray();
+    
+    long[] readLongArrayRaw(int length);
+    
+    long[] readULongArray();
+    
+    long[] readULongArrayRaw(int length);
+    
+    float[] readFloatArray();
+    
+    float[] readFloatArrayRaw(int length);
+    
+    double[] readDoubleArray();
+    
+    double[] readDoubleArrayRaw(int length);
+    
+    String[] readStringArray();
+    
+    String[] readStringArrayRaw(int length);
+    
+    void skip(int bytes);
+    
+    boolean hasMore();
+    
+    @Override
+    public void close();
+}

Shared/src/main/java/compactio/CompactDataOutput.java

+package compactio;
+
+public interface CompactDataOutput extends AutoCloseable {
+    void writeBool(boolean value);
+    
+    void writeByte(int value);
+    
+    void writeSByte(byte value);
+    
+    void writeShort(short value);
+    
+    void writeUShort(int value);
+    
+    void writeInt(int value);
+    
+    void writeUInt(int value);
+    
+    void writeLong(long value);
+    
+    void writeULong(long value);
+    
+    void writeVarInt(int value);
+    
+    void writeVarUInt(int value);
+    
+    void writeVarLong(long value);
+    
+    void writeVarULong(long value);
+    
+    void writeFloat(float value);
+    
+    void writeDouble(double value);
+    
+    void writeChar(char value);
+    
+    void writeString(String value);
+    
+    void writeBytes(byte[] data);
+    
+    void writeBytes(byte[] data, int offset, int length);
+    
+    void writeRawBytes(byte[] value);
+    
+    void writeRawBytes(byte[] value, int offset, int length);
+    
+    void writeBoolArray(boolean[] data);
+    
+    void writeByteArray(byte[] data);
+    
+    void writeSByteArray(byte[] data);
+    
+    void writeShortArray(short[] data);
+    
+    void writeShortArrayRaw(short[] data);
+    
+    void writeUShortArray(short[] data);
+    
+    void writeUShortArrayRaw(short[] data);
+    
+    void writeVarIntArray(int[] data);
+    
+    void writeVarIntArrayRaw(int[] data);
+    
+    void writeVarUIntArray(int[] data);
+    
+    void writeVarUIntArrayRaw(int[] data);
+    
+    void writeIntArray(int[] data);
+    
+    void writeIntArrayRaw(int[] data);
+    
+    void writeUIntArray(int[] data);
+    
+    void writeUIntArrayRaw(int[] data);
+    
+    void writeVarLongArray(long[] data);
+    
+    void writeVarLongArrayRaw(long[] data);
+    
+    void writeVarULongArray(long[] data);
+    
+    void writeVarULongArrayRaw(long[] data);
+    
+    void writeLongArray(long[] data);
+    
+    void writeLongArrayRaw(long[] data);
+    
+    void writeULongArray(long[] data);
+    
+    void writeULongArrayRaw(long[] data);
+    
+    void writeFloatArray(float[] data);
+    
+    void writeFloatArrayRaw(float[] data);
+    
+    void writeDoubleArray(double[] data);
+    
+    void writeDoubleArrayRaw(double[] data);
+    
+    void writeStringArray(String[] data);
+    
+    void writeStringArrayRaw(String[] data);
+    
+    void flush();
+    
+    @Override
+    public void close();
+}

Shared/src/main/java/org/openzen/zencode/shared/CompileExceptionCode.java

 	INVALID_BRACKET_EXPRESSION,
 	VARIANT_OPTION_NOT_AN_EXPRESSION,
 	DUPLICATE_GLOBAL,
-	CANNOT_INFER_RETURN_TYPE
+	CANNOT_INFER_RETURN_TYPE,
+	INVALID_SUFFIX
 }

Shared/src/main/java/zsynthetic/FunctionUSizeTToBool.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionUSizeTToBool<T> {
+    boolean invoke(int index, T value);
+}

Shared/src/main/java/zsynthetic/FunctionUSizeTToU.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionUSizeTToU<U, T> {
+    U invoke(int index, T value);
+}

Shared/src/main/java/zsynthetic/FunctionUSizeTToVoid.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionUSizeTToVoid<T> {
+    void invoke(int index, T value);
+}

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ValidationUtils.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 		
 		for (int i = 0; i < typeParameters.length; i++) {
 			TypeParameter typeParameter = typeParameters[i];
-			for (GenericParameterBound bound : typeParameter.bounds) {
+			for (TypeParameterBound bound : typeParameter.bounds) {
 				// TODO - obtain member cache for validation
 				/*if (!bound.matches(typeArguments[i])) {
 					target.logError(