- Added usize as basic type

- Ranges now only have a single base type; from and to must be the same type
- Adjusted builtins and stdlib to use usize where applicable
- Moved building a SemanticModule from ParsedFile to the parser; reduces dependencies

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

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

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

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

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

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

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

 	private static final FunctionParameter[] NO_PARAMETERS = new FunctionParameter[0];
 	
 	public final TypeParameter[] typeParameters;
-	public ITypeID returnType;
+	private ITypeID returnType;
 	public final FunctionParameter[] parameters;
 	public final ITypeID thrownType;
 	
 		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
+	public ITypeID getReturnType() {
+		return returnType;
+	}
+	
+	public void setReturnType(ITypeID returnType) {
+		if (returnType == null)
+			throw new NullPointerException();
+		
+		this.returnType = returnType;
+	}
+	
 	public boolean isDenormalized() {
 		if (returnType.getNormalized() != returnType)
 			return true;

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

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

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

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

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

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

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

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

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

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

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

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

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

 		this.genericInferenceMap = Collections.emptyMap();
 	}
 	
-	public ExpressionScope(BaseScope scope, List<ITypeID> hints, Function<CodePosition, Expression> dollar, Map<TypeParameter, ITypeID> genericInferenceMap) {
-		this.outer = scope;
-		this.hints = hints;
-		this.dollar = dollar;
-		this.genericInferenceMap = genericInferenceMap;
-	}
-	
 	private ExpressionScope(
 			BaseScope scope,
 			List<ITypeID> hints,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  */
 package org.openzen.zenscript.javabytecode;
 
-import java.io.FileOutputStream;
-import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createRangeName(type);
 		ranges.put(signature, result);
 		
-		createRangeClass(type.from, type.to, result.cls);
+		createRangeClass(type.baseType, result.cls);
 		return result;
 	}
 
         register(cls.internalName, ifaceWriter.toByteArray());
     }
 	
-	private void createRangeClass(ITypeID from, ITypeID to, JavaClass cls) {
+	private void createRangeClass(ITypeID baseType, JavaClass cls) {
 		ClassWriter rangeWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 		rangeWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, cls.internalName, null, "java/lang/Object", null);
-		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "from", getDescriptor(from), null, null).visitEnd();
-		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(to), null, null).visitEnd();
+		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "from", getDescriptor(baseType), null, null).visitEnd();
+		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(baseType), null, null).visitEnd();
 		
-		JavaMethod method = JavaMethod.getConstructor(cls, "(" + getDescriptor(from) + getDescriptor(to) + ")V", Opcodes.ACC_PUBLIC);
+		JavaMethod method = JavaMethod.getConstructor(cls, "(" + getDescriptor(baseType) + getDescriptor(baseType) + ")V", Opcodes.ACC_PUBLIC);
 		JavaWriter constructorWriter = new JavaWriter(rangeWriter, method, null, method.descriptor, null);
 		constructorWriter.loadObject(0);
 		constructorWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
 		constructorWriter.loadObject(0);
-		constructorWriter.load(getType(from), 1);
-		constructorWriter.putField(cls.internalName, "from", getDescriptor(from));
+		constructorWriter.load(getType(baseType), 1);
+		constructorWriter.putField(cls.internalName, "from", getDescriptor(baseType));
 		constructorWriter.loadObject(0);
-		constructorWriter.load(getType(to), 2);
-		constructorWriter.putField(cls.internalName, "to", getDescriptor(from));
+		constructorWriter.load(getType(baseType), 2);
+		constructorWriter.putField(cls.internalName, "to", getDescriptor(baseType));
 		constructorWriter.ret();
 		constructorWriter.end();
 		

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

 				break;
 			case INT:
 			case UINT:
+			case USIZE:
 				method = INTEGER_VALUEOF;
 				break;
 			case LONG:

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

 			case USHORT_NOT:
 			case INT_NOT:
 			case UINT_NOT:
+			case USIZE_NOT:
 				javaWriter.iNot();
 				break;
 			case SBYTE_NEG:
 			case USHORT_ADD_USHORT:
 			case INT_ADD_INT:
 			case UINT_ADD_UINT:
+			case USIZE_ADD_USIZE:
 				javaWriter.iAdd();
 				break;
 			case BYTE_SUB_BYTE:
 			case USHORT_SUB_USHORT:
 			case INT_SUB_INT:
 			case UINT_SUB_UINT:
+			case USIZE_SUB_USIZE:
 				javaWriter.iSub();
 				break;
 			case BYTE_MUL_BYTE:
 			case USHORT_MUL_USHORT:
 			case INT_MUL_INT:
 			case UINT_MUL_UINT:
+			case USIZE_MUL_USIZE:
 				javaWriter.iMul();
 				break;
 			case SBYTE_DIV_SBYTE:
 			case SHORT_DIV_SHORT:
 			case INT_DIV_INT:
+			case USIZE_DIV_USIZE:
 				javaWriter.iDiv();
 				break;
 			case SBYTE_MOD_SBYTE:
 			case SHORT_MOD_SHORT:
 			case INT_MOD_INT:
+			case USIZE_MOD_USIZE:
 				javaWriter.iRem();
 				break;
 			case BYTE_DIV_BYTE:
 			case USHORT_AND_USHORT:
 			case INT_AND_INT:
 			case UINT_AND_UINT:
+			case USIZE_AND_USIZE:
 				javaWriter.iAnd();
 				break;
 			case BYTE_OR_BYTE:
 			case USHORT_OR_USHORT:
 			case INT_OR_INT:
 			case UINT_OR_UINT:
+			case USIZE_OR_USIZE:
 				javaWriter.iOr();
 				break;
 			case BYTE_XOR_BYTE:
 			case USHORT_XOR_USHORT:
 			case INT_XOR_INT:
 			case UINT_XOR_UINT:
+			case USIZE_XOR_USIZE:
 				javaWriter.iXor();
 				break;
 			case INT_SHL:
 			case UINT_SHL:
+			case USIZE_SHL:
 				javaWriter.iShl();
 				break;
 			case INT_SHR:
 				break;
 			case INT_USHR:
 			case UINT_SHR:
+			case USIZE_SHR:
 				javaWriter.iUShr();
 				break;
 			case INT_COUNT_LOW_ZEROES:
 			case UINT_COUNT_LOW_ZEROES:
+			case USIZE_COUNT_LOW_ZEROES:
 				javaWriter.invokeStatic(INTEGER_NUMBER_OF_TRAILING_ZEROS);
 				break;
 			case INT_COUNT_HIGH_ZEROES:
 			case UINT_COUNT_HIGH_ZEROES:
+			case USIZE_COUNT_HIGH_ZEROES:
 				javaWriter.invokeStatic(INTEGER_NUMBER_OF_LEADING_ZEROS);
 				break;
 			case INT_COUNT_LOW_ONES:
 			case UINT_COUNT_LOW_ONES:
+			case USIZE_COUNT_LOW_ONES:
 				javaWriter.iNot();
 				javaWriter.invokeStatic(INTEGER_NUMBER_OF_TRAILING_ZEROS);
 				break;
 			case INT_COUNT_HIGH_ONES:
 			case UINT_COUNT_HIGH_ONES:
+			case USIZE_COUNT_HIGH_ONES:
 				javaWriter.iNot();
 				javaWriter.invokeStatic(INTEGER_NUMBER_OF_LEADING_ZEROS);
 				break;
 				javaWriter.invokeStatic(INTEGER_PARSE_WITH_BASE);
 				break;
 			case UINT_PARSE:
+			case USIZE_PARSE:
 				javaWriter.invokeStatic(INTEGER_PARSE_UNSIGNED);
 				break;
 			case UINT_PARSE_WITH_BASE:
+			case USIZE_PARSE_WITH_BASE:
 				javaWriter.invokeStatic(INTEGER_PARSE_UNSIGNED_WITH_BASE);
 				break;
 			case LONG_PARSE:
 			case BYTE_TO_USHORT:
 			case BYTE_TO_INT:
 			case BYTE_TO_UINT:
+			case BYTE_TO_USIZE:
 				javaWriter.constant(0xFF);
 				javaWriter.iAnd();
 				break;
 			case SBYTE_TO_USHORT:
 			case SBYTE_TO_INT:
 			case SBYTE_TO_UINT:
+			case SBYTE_TO_USIZE:
 				break;
 			case SBYTE_TO_LONG:
 			case SBYTE_TO_ULONG:
 			case SHORT_TO_USHORT:
 			case SHORT_TO_INT:
 			case SHORT_TO_UINT:
+			case SHORT_TO_USIZE:
 				break;
 			case SHORT_TO_LONG:
 			case SHORT_TO_ULONG:
 				break;
 			case USHORT_TO_INT:
 			case USHORT_TO_UINT:
+			case USHORT_TO_USIZE:
 				javaWriter.constant(0xFFFF);
 				javaWriter.iAnd();
 				break;
 			case INT_TO_USHORT:
 				break;
 			case INT_TO_UINT:
+			case INT_TO_USIZE:
 				break;
 			case INT_TO_LONG:
 			case INT_TO_ULONG:
 				break;
 			case UINT_TO_USHORT:
 			case UINT_TO_INT:
+			case UINT_TO_USIZE:
 				break;
 			case UINT_TO_LONG:
 				javaWriter.i2l();
 			case LONG_TO_USHORT:
 			case LONG_TO_INT:
 			case LONG_TO_UINT:
+			case LONG_TO_USIZE:
 				javaWriter.l2i();
 				break;
 			case LONG_TO_ULONG:
 			case ULONG_TO_USHORT:
 			case ULONG_TO_INT:
 			case ULONG_TO_UINT:
+			case ULONG_TO_USIZE:
 				javaWriter.l2i();
 				break;
 			case ULONG_TO_LONG:
 			case FLOAT_TO_USHORT:
 			case FLOAT_TO_UINT:
 			case FLOAT_TO_INT:
+			case FLOAT_TO_USIZE:
 				javaWriter.f2i();
 				break;
 			case FLOAT_TO_LONG:
 			case DOUBLE_TO_USHORT:
 			case DOUBLE_TO_INT:
 			case DOUBLE_TO_UINT:
+			case DOUBLE_TO_USIZE:
 				javaWriter.d2i();
 				break;
 			case DOUBLE_TO_LONG:
 			case CHAR_TO_USHORT:
 			case CHAR_TO_INT:
 			case CHAR_TO_UINT:
+			case CHAR_TO_USIZE:
 				break;
 			case CHAR_TO_LONG:
 			case CHAR_TO_ULONG:
 			case ULONG_GET_MAX_VALUE:
 				javaWriter.constant(-1L);
 				break;
+			case USIZE_GET_MIN_VALUE:
+				javaWriter.iConst0();
+				break;
+			case USIZE_GET_MAX_VALUE:
+				javaWriter.getStaticField(INTEGER_MAX_VALUE);
+				break;
+			case USIZE_BITS:
+				javaWriter.constant(32);
+				break;
 			case FLOAT_GET_MIN_VALUE:
 				javaWriter.getStaticField(FLOAT_MIN_VALUE);
 				break;
 		return null;
 	}
 
+	@Override
+	public Void visitConstantUSize(ConstantUSizeExpression expression) {
+		getJavaWriter().constant((int)expression.value);
+		return null;
+	}
+
     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		javaWriter.loadObject(0);
 		switch (builtin) {
 			case INT_HIGHEST_ONE_BIT:
 			case UINT_HIGHEST_ONE_BIT:
+			case USIZE_HIGHEST_ONE_BIT:
 				javaWriter.invokeStatic(INTEGER_HIGHEST_ONE_BIT);
 				break;
 			case INT_LOWEST_ONE_BIT:
 			case UINT_LOWEST_ONE_BIT:
+			case USIZE_LOWEST_ONE_BIT:
 				javaWriter.invokeStatic(INTEGER_LOWEST_ONE_BIT);
 				break;
 			case INT_HIGHEST_ZERO_BIT:
 			case UINT_HIGHEST_ZERO_BIT:
+			case USIZE_HIGHEST_ZERO_BIT:
 				javaWriter.iNeg();
 				javaWriter.invokeStatic(INTEGER_HIGHEST_ONE_BIT);
 				break;
 			case INT_LOWEST_ZERO_BIT:
 			case UINT_LOWEST_ZERO_BIT:
+			case USIZE_LOWEST_ZERO_BIT:
 				javaWriter.iNeg();
 				javaWriter.invokeStatic(INTEGER_LOWEST_ONE_BIT);
 				break;
 			case INT_BIT_COUNT:
 			case UINT_BIT_COUNT:
+			case USIZE_BIT_COUNT:
 				javaWriter.invokeStatic(INTEGER_BIT_COUNT);
 				break;
 			case LONG_HIGHEST_ONE_BIT:
 			case RANGE_FROM: {
 				RangeTypeID type = (RangeTypeID)expression.target.type;
 				JavaClass cls = context.getTypeGenerator().synthesizeRange(type).cls;
-				javaWriter.getField(cls.internalName, "from", context.getDescriptor(type.from));
+				javaWriter.getField(cls.internalName, "from", context.getDescriptor(type.baseType));
 				break;
 			}
 			case RANGE_TO:
 				RangeTypeID type = (RangeTypeID)expression.target.type;
 				JavaClass cls = context.getTypeGenerator().synthesizeRange(type).cls;
-				javaWriter.getField(cls.internalName, "to", context.getDescriptor(type.to));
+				javaWriter.getField(cls.internalName, "to", context.getDescriptor(type.baseType));
 				break;
 		}
 
 
 	@Override
 	public Void visitNull(NullExpression expression) {
-		javaWriter.aConstNull();
+		if (expression.type.withoutOptional() == BasicTypeID.USIZE)
+			javaWriter.constant(-1); // special case: usize? null = -1
+		else
+			javaWriter.aConstNull();
 		return null;
 	}
 
 		javaWriter.dup();
 		expression.from.accept(this);
 		expression.to.accept(this);
-		javaWriter.invokeSpecial(cls.cls.internalName, "<init>", "(" + context.getDescriptor(type.from) + context.getDescriptor(type.to) + ")V");
+		javaWriter.invokeSpecial(cls.cls.internalName, "<init>", "(" + context.getDescriptor(type.baseType) + context.getDescriptor(type.baseType) + ")V");
 
 		return null;
 	}

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

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

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

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

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

         statementVisitor.start();
 		boolean returns = definition.statement.accept(statementVisitor);
 		if (!returns) {
-			ITypeID type = definition.header.returnType;
+			ITypeID type = definition.header.getReturnType();
 			if (CompilerUtils.isPrimitive(type))
 				writer.iConst0();
 			else if (type != BasicTypeID.VOID)

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

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

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

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

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

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

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

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

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

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

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

 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 					true,
 					context.getMethodDescriptor(header),
 					JavaModifiers.getJavaModifiers(member.modifiers),
-					header.returnType instanceof GenericTypeID);
+					header.getReturnType() instanceof GenericTypeID);
 		} else if (method == null) {
 			method = new JavaMethod(
 					cls,
 					true,
 					context.getMethodDescriptor(header),
 					JavaModifiers.getJavaModifiers(member.modifiers),
-					header.returnType instanceof GenericTypeID);
+					header.getReturnType() instanceof GenericTypeID);
 		}
 		
-		if (method.compile) {
+		if (method.compile && member.getBuiltin() != BuiltinID.CLASS_DEFAULT_CONSTRUCTOR) {
 			if (DEBUG_EMPTY && cls.empty)
 				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
 			

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

 			return;
 			
 		HighLevelDefinition definition = ((DefinitionTypeID)type).definition;
+		System.out.println("Preparing " + definition.name);
 		definition.accept(this);
 	}
 	

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

 			cls.addInstanceMethod("appendUInt", "append", "(I)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendLong", "append", "(J)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendULong", "append", "(J)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendUSize", "append", "(I)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendFloat", "append", "(F)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendDouble", "append", "(D)Ljava/lang/StringBuilder;");
 			cls.addInstanceMethod("appendChar", "append", "(C)Ljava/lang/StringBuilder;");
 			cls.addMethod("max", JavaMethod.getNativeStatic(math, "max", "(II)I"));
 			cls.addMethod("toHexString", JavaMethod.getNativeExpansion(integer, "toHexString", "(I)Ljava/lang/String;"));
 			nativeClasses.put("stdlib::Integer", cls);
+			nativeClasses.put("stdlib::USize", cls);
 		}
 		
 		{
 			cls.addInstanceMethod("readSlice", "read", "([CII)I");
 			nativeClasses.put("io::StringReader", cls);
 		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "InputStream", JavaClass.Kind.INTERFACE), true);
+			cls.addInstanceMethod("destructor", "close", "()V");
+			cls.addInstanceMethod("read", "read", "()I");
+			cls.addInstanceMethod("readArray", "read", "([B)I");
+			cls.addInstanceMethod("readSlice", "read", "([BII)I");
+			nativeClasses.put("io::InputStream", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "OutputStream", JavaClass.Kind.INTERFACE), true);
+			cls.addInstanceMethod("destructor", "close", "()V");
+			cls.addInstanceMethod("write", "write", "()I");
+			cls.addInstanceMethod("writeArray", "write", "([B)V");
+			cls.addInstanceMethod("writeSlice", "write", "([BII)V");
+			nativeClasses.put("io::OutputStream", cls);
+		}
 	}
 	
 	private final String filename;

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

 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		if (method == null)
-			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(header), JavaModifiers.getJavaModifiers(member.modifiers), header.returnType instanceof GenericTypeID); 
+			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(header), JavaModifiers.getJavaModifiers(member.modifiers), header.getReturnType() instanceof GenericTypeID); 
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)

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

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

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

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

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

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

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

 		else
 			JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, expansionTypeParameters, header.typeParameters);
 		
-		output.append(header.returnType.accept(scope.typeVisitor));
+		output.append(header.getReturnType().accept(scope.typeVisitor));
 		output.append(" ");
 		output.append(method.name);
 		formatParameters(member.isStatic(), expansionTypeParameters, header);

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

 		
 		modifiers(member.modifiers);
 		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, header.typeParameters, true);
-		output.append(header.returnType.accept(scope.typeVisitor));
+		output.append(header.getReturnType().accept(scope.typeVisitor));
 		output.append(" ");
 		output.append(method.name);
 		formatParameters(member.isStatic(), header);

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

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

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

 			writer.write(pkg.fullName);
 			writer.write(";\n\n");
 			
-			JavaClass[] imports = importer.getUsedImports();
-			if (imports.length > 0) {
-				for (JavaClass import_ : imports) {
-					if (import_.pkg.equals("java.lang"))
-						continue;
-					
-					writer.write("import ");
-					writer.write(import_.fullName);
-					writer.write(";\n");
-				}
+			boolean hasImports = false;
+			for (JavaClass import_ : importer.getUsedImports()) {
+				if (import_.pkg.equals("java.lang"))
+					continue;
 
-				writer.write("\n");
+				writer.write("import ");
+				writer.write(import_.fullName);
+				writer.write(";\n");
+				hasImports = true;
 			}
+
+			if (hasImports)
+				writer.write("\n");
 			
 			writer.write(contents.toString());
 		} catch (IOException ex) {

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

 		JavaClass cls = definition.getTag(JavaClass.class);
 		if (cls == null)
 			throw new IllegalStateException("Missing source class tag on " + definition.name);
-		if (cls.pkg.equals(this.cls.pkg))
-			return cls.getClassName();
 		
 		return importType(cls);
 	}
 			usedImports.add(imported);
 			return imported.fullName.equals(cls.outer.fullName) ? cls.getName() : cls.fullName;
 		}
+		if (cls.pkg.equals(this.cls.pkg))
+			return cls.getClassName();
 		
 		imports.put(cls.outer.getName(), cls.outer);
 		usedImports.add(cls.outer);

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

 			}
 			contents.append("> ");
 		}
-		contents.append(function.header.returnType.accept(typeVisitor));
+		contents.append(function.header.getReturnType().accept(typeVisitor));
 		contents.append(' ');
 		contents.append("invoke(");
 		boolean first = true;
 		
 		StringBuilder contents = new StringBuilder();
 		contents.append("public final class ").append(result.cls.getName()).append(" {\n");
-		contents.append(settings.indent).append("public final ").append(type.from.accept(typeVisitor)).append(" from;\n");
-		contents.append(settings.indent).append("public final ").append(type.to.accept(typeVisitor)).append(" to;\n");
+		contents.append(settings.indent).append("public final ").append(type.baseType.accept(typeVisitor)).append(" from;\n");
+		contents.append(settings.indent).append("public final ").append(type.baseType.accept(typeVisitor)).append(" to;\n");
 		contents.append(settings.indent).append("\n");
 		contents.append(settings.indent)
 				.append("public ")
 				.append(result.cls.getName())
 				.append("(")
-				.append(type.from.accept(typeVisitor))
+				.append(type.baseType.accept(typeVisitor))
 				.append(" from, ")
-				.append(type.to.accept(typeVisitor))
+				.append(type.baseType.accept(typeVisitor))
 				.append(" to) {\n");
 		contents.append(settings.indent).append(settings.indent).append("this.from = from;\n");
 		contents.append(settings.indent).append(settings.indent).append("this.to = to;\n");

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

 			case UINT: return "int";
 			case LONG: return "long";
 			case ULONG: return "long";
+			case USIZE: return "int";
 			case FLOAT: return "float";
 			case DOUBLE: return "double";
 			case CHAR: return "char";
 	@Override
 	public String visitArray(ArrayTypeID array) {
 		StringBuilder result = new StringBuilder();
-		result.append(array.elementType.accept(this));
+		
+		if (array.elementType == BasicTypeID.BYTE) {
+			result.append("byte");
+		} else if (array.elementType == BasicTypeID.USHORT) {
+			result.append("short");
+		} else {
+			result.append(array.elementType.accept(this));
+		}
+		
 		for (int i = 0; i < array.dimension; i++)
 			result.append("[]");
 		
 
 	@Override
 	public String visitModified(ModifiedTypeID optional) {
+		if (optional.isOptional() && optional.withoutOptional() == BasicTypeID.USIZE)
+			return "int"; // usize? is an int
+		
 		return optional.baseType.accept(new JavaSourceObjectTypeVisitor(importer, typeGenerator));
 	}
 

Parser/build.gradle

 dependencies {
     compile project(':Shared')
 	compile project(':CodeModel')
+	compile project(':CompilerShared')
 }

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

 	K_UINT(true, "uint"),
 	K_LONG(true, "long"),
 	K_ULONG(true, "ulong"),
+	K_USIZE(true, "usize"),
 	K_FLOAT(true, "float"),
 	K_DOUBLE(true, "double"),
 	K_CHAR(true, "char"),

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

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

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

 		FunctionScope innerScope = new FunctionScope(scope, compiled.header);
 		compiled.setCode(body.compile(innerScope, compiled.header));
 		
-		if (compiled.header.returnType == BasicTypeID.UNDETERMINED) {
-			compiled.header.returnType = compiled.statement.getReturnType();
+		if (compiled.header.getReturnType() == BasicTypeID.UNDETERMINED) {
+			compiled.header.setReturnType(compiled.statement.getReturnType());
 		}
 	}
 

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

 		StatementScope innerScope = new LambdaScope(scope, closure, header);
 		Statement statements = body.compile(innerScope, header);
 		
-		if (header.returnType == BasicTypeID.UNDETERMINED) {
-			header.returnType = statements.getReturnType();
+		if (header.getReturnType() == BasicTypeID.UNDETERMINED) {
+			header.setReturnType(statements.getReturnType());
 		}
 		if (!scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
 			ITypeID returnType = statements.getReturnType();
 			Map<TypeParameter, ITypeID> inferredTypes = new HashMap<>();
-			if (!returnType.inferTypeParameters(scope.getMemberCache(), genericHeader.returnType, inferredTypes))
+			if (!returnType.inferTypeParameters(scope.getMemberCache(), genericHeader.getReturnType(), inferredTypes))
 				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
 			
 			scope.genericInferenceMap.putAll(inferredTypes);

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

 import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 						return new ConstantLongExpression(position, value);
 					case ULONG:
 						return new ConstantULongExpression(position, value);
+					case USIZE:
+						return new ConstantUSizeExpression(position, value);
 					case CHAR:
 						return new ConstantCharExpression(position, (char) value);
 					default:

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

 		for (ITypeID hint : scope.hints) {
 			if (hint instanceof RangeTypeID) {
 				RangeTypeID rangeHint = (RangeTypeID) hint;
-				if (!fromHints.contains(rangeHint.from))
-					fromHints.add(rangeHint.from);
-				if (!toHints.contains(rangeHint.to))
-					toHints.add(rangeHint.to);
+				if (!fromHints.contains(rangeHint.baseType))
+					fromHints.add(rangeHint.baseType);
+				if (!toHints.contains(rangeHint.baseType))
+					toHints.add(rangeHint.baseType);
 			}
 		}
 		
 		Expression from = this.from.compile(scope.withHints(fromHints)).eval();
 		Expression to = this.to.compile(scope.withHints(toHints)).eval();
-		return new RangeExpression(position, scope.getTypeRegistry(), from, to);
+		
+		ITypeID baseType = scope.getTypeMembers(from.type).union(to.type);
+		return new RangeExpression(position, scope.getTypeRegistry().getRange(baseType), from, to);
 	}
 
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedFunctionalMember.java

 		getCompiled().annotations = ParsedAnnotation.compileForMember(annotations, getCompiled(), scope);
 		getCompiled().setBody(body.compile(innerScope, getCompiled().header));
 		
-		if (getCompiled().header.returnType == BasicTypeID.UNDETERMINED)
-			getCompiled().header.returnType = getCompiled().body.getReturnType();
+		if (getCompiled().header.getReturnType() == BasicTypeID.UNDETERMINED) {
+			ITypeID returnType = getCompiled().body.getReturnType();
+			if (returnType == null) {
+				throw new CompileException(position, CompileExceptionCode.CANNOT_INFER_RETURN_TYPE, "Method return type could not be inferred");
+			} else {
+				getCompiled().header.setReturnType(returnType);
+			}
+		}
 	}
 	
 	protected abstract void fillOverride(TypeScope scope, ITypeID baseType);

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedLambdaFunctionBody.java

 	
 	@Override
 	public Statement compile(StatementScope scope, FunctionHeader header) {
-		if (header.returnType == BasicTypeID.VOID) {
+		if (header.getReturnType() == BasicTypeID.VOID) {
 			Expression value = this.value.compile(new ExpressionScope(scope)).eval();
 			return new ExpressionStatement(value.position, value);
 		} else {
 			Expression returnValue = value
-					.compile(new ExpressionScope(scope, header.returnType))
+					.compile(new ExpressionScope(scope, header.getReturnType()))
 					.eval()
-					.castImplicit(value.position, scope, header.returnType);
+					.castImplicit(value.position, scope, header.getReturnType());
 			return new ReturnStatement(value.position, returnValue);
 		}
 	}

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementReturn.java

 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
-import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 
 public class ParsedStatementReturn extends ParsedStatement {
 	@Override
 	public Statement compile(StatementScope scope) {
 		if (expression == null) {
-			if (scope.getFunctionHeader().returnType == BasicTypeID.VOID)
+			if (scope.getFunctionHeader().getReturnType() == BasicTypeID.VOID)
 				return new ReturnStatement(position, null);
 			else
 				throw new CompileException(position, CompileExceptionCode.RETURN_VALUE_REQUIRED, "Return value is required");
-		} else if (scope.getFunctionHeader().returnType == BasicTypeID.VOID) {
+		} else if (scope.getFunctionHeader().getReturnType() == BasicTypeID.VOID) {
 			throw new CompileException(position, CompileExceptionCode.RETURN_VALUE_VOID, "Cannot return a value from a void function");
 		} else {
 			Expression value = expression
-					.compile(new ExpressionScope(scope, scope.getFunctionHeader().returnType))
+					.compile(new ExpressionScope(scope, scope.getFunctionHeader().getReturnType()))
 					.eval()
-					.castImplicit(position, scope, scope.getFunctionHeader().returnType);
+					.castImplicit(position, scope, scope.getFunctionHeader().getReturnType());
 			return result(new ReturnStatement(position, value), scope);
 		}
 	}

Parser/src/main/java/org/openzen/zenscript/parser/type/IParsedType.java

 	}
 	
 	public static IParsedType tryParse(ZSTokenParser tokens) {
+		CodePosition position = tokens.getPosition();
 		int modifiers = 0;
 		while (true) {
 			if (tokens.optional(ZSTokenType.K_CONST) != null) {
 				tokens.next();
 				result = ParsedTypeBasic.ULONG;
 				break;
+			case K_USIZE:
+				tokens.next();
+				result = ParsedTypeBasic.USIZE;
+				break;
 			case K_FLOAT:
 				tokens.next();
 				result = ParsedTypeBasic.FLOAT;
 				result = ParsedTypeBasic.STRING;
 				break;
 			case K_FUNCTION: {
-				CodePosition position = tokens.getPosition();
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				result = new ParsedFunctionType(position, header);
 				break;
 			}
 			case T_IDENTIFIER: {
-				CodePosition position = tokens.getPosition();
 				List<ParsedNamedType.ParsedNamePart> name = new ArrayList<>();
 				do {
 					String namePart = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 				case T_DOT2: {
 					tokens.next();
 					IParsedType to = parse(tokens);
-					result = new ParsedTypeRange(result, to);
+					result = new ParsedTypeRange(position, result, to);
 					break;
 				}
 				case T_SQOPEN:

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeBasic.java

 	UINT(BasicTypeID.UINT),
 	LONG(BasicTypeID.LONG),
 	ULONG(BasicTypeID.ULONG),
+	USIZE(BasicTypeID.USIZE),
 	FLOAT(BasicTypeID.FLOAT),
 	DOUBLE(BasicTypeID.DOUBLE),
 	CHAR(BasicTypeID.CHAR),

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeRange.java

  */
 package org.openzen.zenscript.parser.type;
 
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 
 /**
  * @author Hoofdgebruiker
  */
 public class ParsedTypeRange implements IParsedType {
+	private final CodePosition position;
 	private final IParsedType from;
 	private final IParsedType to;
 	private final int modifiers;
 	
-	public ParsedTypeRange(IParsedType from, IParsedType to) {
+	public ParsedTypeRange(CodePosition position, IParsedType from, IParsedType to) {
+		this.position = position;
 		this.from = from;
 		this.to = to;
 		this.modifiers = 0;
 	}
 	
-	private ParsedTypeRange(IParsedType from, IParsedType to, int modifiers) {
+	private ParsedTypeRange(CodePosition position, IParsedType from, IParsedType to, int modifiers) {
+		this.position = position;
 		this.from = from;
 		this.to = to;
 		this.modifiers = modifiers;
 
 	@Override
 	public IParsedType withOptional() {
-		return new ParsedTypeRange(from, to, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL);
+		return new ParsedTypeRange(position, from, to, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL);
 	}
 
 	@Override
 	public IParsedType withModifiers(int modifiers) {
-		return new ParsedTypeRange(from, to, this.modifiers | modifiers);
+		return new ParsedTypeRange(position, from, to, this.modifiers | modifiers);
 	}
 	
 	@Override
 	public ITypeID compile(TypeResolutionContext context) {
 		ITypeID from = this.from.compile(context);
 		ITypeID to = this.to.compile(context);
-		return context.getTypeRegistry().getModified(modifiers, context.getTypeRegistry().getRange(from, to));
+		if (from != to)
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "from and to in a range must be the same type");
+		
+		return context.getTypeRegistry().getModified(modifiers, context.getTypeRegistry().getRange(from));
 	}
 }

ScriptingExample/build.gradle

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

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

 import org.openzen.zenscript.formatter.ScriptFormattingSettings;
 import org.openzen.zenscript.javabytecode.JavaCompiler;
 import org.openzen.zenscript.javabytecode.JavaModule;
-import org.openzen.zenscript.constructor.Module;
-import org.openzen.zenscript.constructor.module.ModuleSpace;
+import org.openzen.zenscript.compiler.ModuleSpace;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
      * @param args the command line arguments
      */
     public static void main(String[] args) throws IOException {
+		
 		System.out.println();
 		File inputDirectory = new File("scripts");
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		for (Map.Entry<String, ISymbol> global : registry.collectGlobals().entrySet()) {
 			space.addGlobal(global.getKey(), global.getValue());
 		}
-		SemanticModule result = Module.compileSyntaxToSemantic(
+		SemanticModule result = ParsedFile.compileSyntaxToSemantic(
 				"scripts",
 				new SemanticModule[0],
 				compiling,

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

 package org.openzen.zencode.shared;
 
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.VirtualSourceFile;
-
 public final class CodePosition {
     public static final CodePosition BUILTIN = new CodePosition(new VirtualSourceFile("builtin"), 0, 0, 0, 0);
     public static final CodePosition NATIVE = new CodePosition(new VirtualSourceFile("native"), 0, 0, 0, 0);
+	public static final CodePosition META = new CodePosition(new VirtualSourceFile("meta"), 0, 0, 0, 0);
+	
     public final SourceFile file;
     public final int fromLine;
     public final int fromLineOffset;

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

 	VAR_WITHOUT_TYPE_OR_INITIALIZER(),
 	NO_BRACKET_PARSER(),
 	INVALID_BRACKET_EXPRESSION(),
-	VARIANT_OPTION_NOT_AN_EXPRESSION
+	VARIANT_OPTION_NOT_AN_EXPRESSION,
+	DUPLICATE_GLOBAL,
+	CANNOT_INFER_RETURN_TYPE
 }

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

 		return null;
 	}
 
+	@Override
+	public Void visitConstantUSize(ConstantUSizeExpression expression) {
+		return null;
+	}
+
 	@Override
 	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		if (!scope.isConstructor()) {
 		expression.to.accept(this);
 		
 		RangeTypeID rangeType = (RangeTypeID) expression.type;
-		if (expression.from.type != rangeType.from) {
-			validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, expression.position, "From operand is not a " + rangeType.from.toString());
+		if (expression.from.type != rangeType.baseType) {
+			validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, expression.position, "From operand is not a " + rangeType.baseType.toString());
 		}
-		if (expression.to.type != rangeType.to) {
-			validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, expression.position, "To operand is not a " + rangeType.to.toString());
+		if (expression.to.type != rangeType.baseType) {
+			validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, expression.position, "To operand is not a " + rangeType.baseType.toString());
 		}
 		return null;
 	}

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

 					validator,
 					new StatementExpressionScope()));
 			
-			if (statement.value.type != scope.getFunctionHeader().returnType) {
+			if (statement.value.type != scope.getFunctionHeader().getReturnType()) {
 				validator.logError(ValidationLogEntry.Code.INVALID_RETURN_TYPE, statement.position, "Invalid return type: " + statement.value.type.toString());
 			}
-		} else if (scope.getFunctionHeader().returnType != BasicTypeID.VOID) {
+		} else if (scope.getFunctionHeader().getReturnType() != BasicTypeID.VOID) {
 			validator.logError(ValidationLogEntry.Code.INVALID_RETURN_TYPE, statement.position, "Missing return value");
 		}
 		

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

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

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

 	
 	public static void validateHeader(Validator target, CodePosition position, FunctionHeader header) {
 		TypeValidator typeValidator = new TypeValidator(target, position);
-		header.returnType.accept(typeValidator);
+		header.getReturnType().accept(typeValidator);
 		
 		Set<String> parameterNames = new HashSet<>();
 		int i = 0;