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

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
 		return true;
 	}
 	
-	public String getCanonical() {
+	public String getCanonicalWithoutReturnType() {
 		StringBuilder result = new StringBuilder();
 		if (getNumberOfTypeParameters() > 0) {
 			result.append('<');
 			}
 			result.append('>');
 		}
-		if (storage != null)
-			result.append(storage);
+		if (storage != null && storage != AutoStorageTag.INSTANCE)
+			result.append('`').append(storage);
 		result.append('(');
 		for (int i = 0; i < parameters.length; i++) {
 			if (i > 0)
 		return result.toString();
 	}
 	
-	public StoredType[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<StoredType> resultHint) {
-		if (arguments.arguments.length != this.parameters.length)
-			return null;
-		
-		Map<TypeParameter, StoredType> mapping = new HashMap<>();
-		if (!resultHint.isEmpty()) {
-			for (StoredType hint : resultHint) {
-				Map<TypeParameter, StoredType> temp = returnType.inferTypeParameters(cache, hint);
-				if (temp != null) {
-					mapping = temp;
-					break;
-				}
-			}
-		}
-		
-		// TODO: lambda header inference
-		for (int i = 0; i < parameters.length; i++) {
-			Map<TypeParameter, StoredType> forParameter = parameters[i].type.inferTypeParameters(cache, arguments.arguments[i].type);
-			if (forParameter == null)
-				return null;
-			
-			mapping.putAll(forParameter);
-		}
-		
-		if (mapping.size() > typeParameters.length)
-			return null;
-		
-		StoredType[] result = new StoredType[typeParameters.length];
-		for (int i = 0; i < typeParameters.length; i++) {
-			TypeParameter typeParameter = typeParameters[i];
-			if (!mapping.containsKey(typeParameter)) {
-				return null;
-			} else {
-				result[i] = mapping.get(typeParameter);
-			}
-		}
-		
-		return result;
+	public String getCanonical() {
+		return getCanonicalWithoutReturnType() + returnType.type.toString();
 	}
 	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

 			pkg.register(this);
 	}
 	
-	public HighLevelDefinition getOutermost() {
-		HighLevelDefinition result = this;
-		while (result.outerDefinition != null)
-			result = result.outerDefinition;
-		return result;
-	}
-	
 	public String getFullName() {
 		return pkg.fullName + '.' + name;
 	}
 	public void setOuterDefinition(HighLevelDefinition outerDefinition) {
 		this.outerDefinition = outerDefinition;
 	}
-	
+
+	public boolean isExpansion() {
+		return this instanceof ExpansionDefinition;
+	}
+
 	public boolean isInnerDefinition() {
 		return outerDefinition != null;
 	}
 	
 	public void normalize(TypeScope scope) {
 		DestructorMember destructor = null;
-		List<FieldMember> fields = new ArrayList();
+		List<FieldMember> fields = new ArrayList<>();
 		
 		for (IDefinitionMember member : members) {
 			member.normalize(scope);

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

  * @author Hoofdgebruiker
  */
 public interface ModuleProcessor {
-	public ScriptBlock process(ScriptBlock block);
+	ScriptBlock process(ScriptBlock block);
 	
-	public void process(HighLevelDefinition definition);
+	void process(HighLevelDefinition definition);
 }

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

 	public final String operator;
 	public final String compiledName;
 	
-	private OperatorType(String operator, String compiledName) {
+	OperatorType(String operator, String compiledName) {
 		this.operator = operator;
 		this.compiledName = compiledName;
 		assignOperatorFor = null;
 	}
 	
-	private OperatorType(String operator, String compiledName, OperatorType assignOperatorFor) {
+	OperatorType(String operator, String compiledName, OperatorType assignOperatorFor) {
 		this.operator = operator;
 		this.compiledName = compiledName;
 		this.assignOperatorFor = assignOperatorFor;

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

  * @author Hoofdgebruiker
  */
 public interface AnnotationDefinition {
-	public String getAnnotationName();
+	String getAnnotationName();
 	
-	public List<FunctionHeader> getInitializers(BaseScope scope);
+	List<FunctionHeader> getInitializers(BaseScope scope);
 	
-	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope);
+	ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope);
 	
-	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope);
+	ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope);
 	
-	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope);
+	ExpressionScope getScopeForStatement(Statement statement, StatementScope scope);
 	
-	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope);
+	ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope);
 	
-	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments);
+	MemberAnnotation createForMember(CodePosition position, CallArguments arguments);
 	
-	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments);
+	DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments);
 	
-	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments);
+	StatementAnnotation createForStatement(CodePosition position, CallArguments arguments);
 	
-	public ParameterAnnotation createForParameter(CodePosition position, CallArguments arguments);
+	ParameterAnnotation createForParameter(CodePosition position, CallArguments arguments);
 	
-	public MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member);
+	MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member);
 	
-	public DefinitionAnnotation deserializeForDefinition(CodeSerializationInput input, TypeContext context);
+	DefinitionAnnotation deserializeForDefinition(CodeSerializationInput input, TypeContext context);
 	
-	public StatementAnnotation deserializeForStatement(CodeSerializationInput input, StatementContext context);
+	StatementAnnotation deserializeForStatement(CodeSerializationInput input, StatementContext context);
 	
-	public ParameterAnnotation deserializeForParameter(CodeSerializationInput input, TypeContext context);
+	ParameterAnnotation deserializeForParameter(CodeSerializationInput input, TypeContext context);
 }

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

  * @author Hoofdgebruiker
  */
 public interface DefinitionAnnotation {
-	public static final DefinitionAnnotation[] NONE = new DefinitionAnnotation[0];
+	DefinitionAnnotation[] NONE = new DefinitionAnnotation[0];
 	
-	public AnnotationDefinition getDefinition();
+	AnnotationDefinition getDefinition();
 	
-	public void apply(HighLevelDefinition definition, BaseScope scope);
+	void apply(HighLevelDefinition definition, BaseScope scope);
 	
-	public void applyOnSubtype(HighLevelDefinition definition, BaseScope scope);
+	void applyOnSubtype(HighLevelDefinition definition, BaseScope scope);
 	
-	public void serialize(CodeSerializationOutput output, HighLevelDefinition definition, TypeContext context);
+	void serialize(CodeSerializationOutput output, HighLevelDefinition definition, TypeContext context);
 }

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

 
 	@Override
 	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public ParameterAnnotation createForParameter(CodePosition position, CallArguments arguments) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public DefinitionAnnotation deserializeForDefinition(CodeSerializationInput input, TypeContext context) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public StatementAnnotation deserializeForStatement(CodeSerializationInput input, StatementContext context) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 
 	@Override
 	public ParameterAnnotation deserializeForParameter(CodeSerializationInput input, TypeContext context) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		throw new UnsupportedOperationException("Not a valid annotation");
 	}
 }

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

 	public final CompileExceptionCode code;
 	public final String message;
 	
-	public InvalidMemberAnnotation(CodePosition position, CompileExceptionCode code, String message) {
-		this.position = position;
-		this.code = code;
-		this.message = message;
-	}
-	
 	public InvalidMemberAnnotation(CompileException ex) {
 		this.position = ex.position;
 		this.code = ex.code;
 
 	@Override
 	public void serialize(CodeSerializationOutput output, IDefinitionMember member, TypeContext context) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		output.serialize(position);
+		output.writeUInt(code.ordinal());
+		output.writeString(message);
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public interface MemberAnnotation {
-	public static final MemberAnnotation[] NONE = new MemberAnnotation[0];
+	MemberAnnotation[] NONE = new MemberAnnotation[0];
 	
-	public AnnotationDefinition getDefinition();
+	AnnotationDefinition getDefinition();
 	
-	public void apply(IDefinitionMember member, BaseScope scope);
+	void apply(IDefinitionMember member, BaseScope scope);
 	
-	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope);
+	void applyOnOverridingMethod(FunctionalMember member, BaseScope scope);
 	
-	public void applyOnOverridingGetter(GetterMember member, BaseScope scope);
+	void applyOnOverridingGetter(GetterMember member, BaseScope scope);
 	
-	public void applyOnOverridingSetter(SetterMember member, BaseScope scope);
+	void applyOnOverridingSetter(SetterMember member, BaseScope scope);
 	
-	public void serialize(CodeSerializationOutput output, IDefinitionMember member, TypeContext context);
+	void serialize(CodeSerializationOutput output, IDefinitionMember member, TypeContext context);
 }

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

  * @author Hoofdgebruiker
  */
 public interface ParameterAnnotation {
-	public static final ParameterAnnotation[] NONE = new ParameterAnnotation[0];
+	ParameterAnnotation[] NONE = new ParameterAnnotation[0];
 	
-	public AnnotationDefinition getDefinition();
+	AnnotationDefinition getDefinition();
 	
-	public void apply();
+	void apply();
 }

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.context.TypeContext;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.ExpressionBuilder;
 import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
-import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.IfStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
 			return body;
 		
 		try {
-			ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL.stored);
-			List<Statement> statements = new ArrayList<>();
-			ExpressionBuilder expressionBuilder = new ExpressionBuilder(position, expressionScope);
-			Expression inverseCondition = expressionBuilder.not(condition);
+			TypeMembers members = scope.getTypeMembers(condition.type);
+			Expression inverseCondition = members.getGroup(OperatorType.NOT)
+					.call(position, scope, condition, CallArguments.EMPTY, false);
+
 			Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID.stored, message));
+			List<Statement> statements = new ArrayList<>();
 			statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
 
 			if (body instanceof BlockStatement) {

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

  * @author Hoofdgebruiker
  */
 public interface StatementAnnotation {
-	public static final StatementAnnotation[] NONE = new StatementAnnotation[0];
+	StatementAnnotation[] NONE = new StatementAnnotation[0];
 	
-	public AnnotationDefinition getDefinition();
+	AnnotationDefinition getDefinition();
 	
-	public Statement apply(Statement statement, StatementScope scope);
+	Statement apply(Statement statement, StatementScope scope);
 }

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

  * @author Hoofdgebruiker
  */
 public interface DefinitionVisitor<T> {
-	public T visitClass(ClassDefinition definition);
+	T visitClass(ClassDefinition definition);
 	
-	public T visitInterface(InterfaceDefinition definition);
+	T visitInterface(InterfaceDefinition definition);
 	
-	public T visitEnum(EnumDefinition definition);
+	T visitEnum(EnumDefinition definition);
 	
-	public T visitStruct(StructDefinition definition);
+	T visitStruct(StructDefinition definition);
 	
-	public T visitFunction(FunctionDefinition definition);
+	T visitFunction(FunctionDefinition definition);
 	
-	public T visitExpansion(ExpansionDefinition definition);
+	T visitExpansion(ExpansionDefinition definition);
 	
-	public T visitAlias(AliasDefinition definition);
+	T visitAlias(AliasDefinition definition);
 	
-	public T visitVariant(VariantDefinition variant);
+	T visitVariant(VariantDefinition variant);
 }

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *

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

 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.Statement;
 	
 	@Override
 	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
-		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(position, scope, hints, arguments);
+		TypeMemberGroup group = scope.getTypeMembers(type).getGroup(OperatorType.CALL);
+		return group.predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override
 	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
-		return scope.getTypeMembers(type)
-				.getOrCreateGroup(OperatorType.CALL)
-				.getMethodMembers().stream()
-				.filter(method -> method.member.getHeader().parameters.length == arguments && !method.member.isStatic())
+		TypeMemberGroup group = scope.getTypeMembers(type).getGroup(OperatorType.CALL);
+		return group.getMethodMembers().stream()
+				.filter(method -> method.member.getHeader().accepts(arguments) && !method.member.isStatic())
 				.map(method -> method.member.getHeader())
 				.collect(Collectors.toList());
 	}
 	
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
-		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).call(position, scope, this, arguments, false);
+		TypeMemberGroup group = scope.getTypeMembers(type).getGroup(OperatorType.CALL);
+		return group.call(position, scope, this, arguments, false);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ExpressionBuilder.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 java.util.ArrayList;
-import java.util.List;
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.CompileException;
-import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
-import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.codemodel.GenericName;
-import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
-import stdlib.Strings;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class ExpressionBuilder {
-	public final CodePosition position;
-	public final ExpressionScope scope;
-	
-	public ExpressionBuilder(CodePosition position, ExpressionScope scope) {
-		this.position = position;
-		this.scope = scope;
-	}
-	
-	public Expression constructNew(CodePosition position, String typename, Expression... arguments) throws CompileException {
-		String[] nameParts = Strings.split(typename, '.');
-		List<GenericName> name = new ArrayList<>();
-		for (String namePart : nameParts)
-			name.add(new GenericName(namePart));
-		TypeID type = scope.getType(position, name);
-		if (type == null)
-			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "No such type: " + typename);
-		
-		return constructNew(position, type.stored(UniqueStorageTag.INSTANCE), arguments);
-	}
-	
-	public Expression constructNew(CodePosition position, StoredType type, Expression... arguments) throws CompileException {
-		TypeMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
-		List<StoredType>[] predictedTypes = constructors.predictCallTypes(position, scope, scope.hints, arguments.length);
-		CallArguments compiledArguments = new CallArguments(arguments);
-		FunctionalMemberRef member = constructors.selectMethod(position, scope, compiledArguments, true, true);
-		if (member == null)
-			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching constructor found");
-		if (!member.isConstructor())
-			throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "COMPILER BUG: constructor is not a constructor");
-		
-		return new NewExpression(
-				position,
-				type,
-				member,
-				compiledArguments,
-				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(CodePosition.BUILTIN, scope, compiledArguments.typeArguments));
-	}
-	
-	public Expression not(Expression value) throws CompileException {
-		TypeMembers members = scope.getTypeMembers(value.type);
-		return members.getOrCreateGroup(OperatorType.NOT)
-				.call(position, scope, value, CallArguments.EMPTY, false);
-	}
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ExpressionContext.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.zenscript.codemodel.statement.Statement;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface ExpressionContext {
-	void addStatementBefore(Statement statement);
-	
-	void addStatementAfter(Statement statement);
-}

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

 package org.openzen.zenscript.codemodel.expression;
 
 import java.util.function.BiFunction;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;

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

  * @author Hoofdgebruiker
  */
 public interface ExpressionVisitor<T> {
-	public T visitAndAnd(AndAndExpression expression);
+	T visitAndAnd(AndAndExpression expression);
 	
-	public T visitArray(ArrayExpression expression);
+	T visitArray(ArrayExpression expression);
 	
-	public T visitCompare(CompareExpression expression);
+	T visitCompare(CompareExpression expression);
 	
-	public T visitCall(CallExpression expression);
+	T visitCall(CallExpression expression);
 	
-	public T visitCallStatic(CallStaticExpression expression);
+	T visitCallStatic(CallStaticExpression expression);
 	
-	public T visitCapturedClosure(CapturedClosureExpression expression);
+	T visitCapturedClosure(CapturedClosureExpression expression);
 	
-	public T visitCapturedDirect(CapturedDirectExpression expression);
+	T visitCapturedDirect(CapturedDirectExpression expression);
 	
-	public T visitCapturedLocalVariable(CapturedLocalVariableExpression expression);
+	T visitCapturedLocalVariable(CapturedLocalVariableExpression expression);
 	
-	public T visitCapturedParameter(CapturedParameterExpression expression);
+	T visitCapturedParameter(CapturedParameterExpression expression);
 	
-	public T visitCapturedThis(CapturedThisExpression expression);
+	T visitCapturedThis(CapturedThisExpression expression);
 	
-	public T visitCast(CastExpression expression);
+	T visitCast(CastExpression expression);
 	
-	public T visitCheckNull(CheckNullExpression expression);
+	T visitCheckNull(CheckNullExpression expression);
 	
-	public T visitCoalesce(CoalesceExpression expression);
+	T visitCoalesce(CoalesceExpression expression);
 	
-	public T visitConditional(ConditionalExpression expression);
+	T visitConditional(ConditionalExpression expression);
 	
-	public T visitConst(ConstExpression expression);
+	T visitConst(ConstExpression expression);
 	
-	public T visitConstantBool(ConstantBoolExpression expression);
+	T visitConstantBool(ConstantBoolExpression expression);
 	
-	public T visitConstantByte(ConstantByteExpression expression);
+	T visitConstantByte(ConstantByteExpression expression);
 	
-	public T visitConstantChar(ConstantCharExpression expression);
+	T visitConstantChar(ConstantCharExpression expression);
 	
-	public T visitConstantDouble(ConstantDoubleExpression expression);
+	T visitConstantDouble(ConstantDoubleExpression expression);
 	
-	public T visitConstantFloat(ConstantFloatExpression expression);
+	T visitConstantFloat(ConstantFloatExpression expression);
 	
-	public T visitConstantInt(ConstantIntExpression expression);
+	T visitConstantInt(ConstantIntExpression expression);
 	
-	public T visitConstantLong(ConstantLongExpression expression);
+	T visitConstantLong(ConstantLongExpression expression);
 	
-	public T visitConstantSByte(ConstantSByteExpression expression);
+	T visitConstantSByte(ConstantSByteExpression expression);
 	
-	public T visitConstantShort(ConstantShortExpression expression);
+	T visitConstantShort(ConstantShortExpression expression);
 	
-	public T visitConstantString(ConstantStringExpression expression);
+	T visitConstantString(ConstantStringExpression expression);
 	
-	public T visitConstantUInt(ConstantUIntExpression expression);
+	T visitConstantUInt(ConstantUIntExpression expression);
 	
-	public T visitConstantULong(ConstantULongExpression expression);
+	T visitConstantULong(ConstantULongExpression expression);
 	
-	public T visitConstantUShort(ConstantUShortExpression expression);
+	T visitConstantUShort(ConstantUShortExpression expression);
 	
-	public T visitConstantUSize(ConstantUSizeExpression expression);
+	T visitConstantUSize(ConstantUSizeExpression expression);
 	
-	public T visitConstructorThisCall(ConstructorThisCallExpression expression);
+	T visitConstructorThisCall(ConstructorThisCallExpression expression);
 	
-	public T visitConstructorSuperCall(ConstructorSuperCallExpression expression);
+	T visitConstructorSuperCall(ConstructorSuperCallExpression expression);
 	
-	public T visitEnumConstant(EnumConstantExpression expression);
+	T visitEnumConstant(EnumConstantExpression expression);
 	
-	public T visitFunction(FunctionExpression expression);
+	T visitFunction(FunctionExpression expression);
 	
-	public T visitGetField(GetFieldExpression expression);
+	T visitGetField(GetFieldExpression expression);
 	
-	public T visitGetFunctionParameter(GetFunctionParameterExpression expression);
+	T visitGetFunctionParameter(GetFunctionParameterExpression expression);
 	
-	public T visitGetLocalVariable(GetLocalVariableExpression expression);
+	T visitGetLocalVariable(GetLocalVariableExpression expression);
 	
-	public T visitGetMatchingVariantField(GetMatchingVariantField expression);
+	T visitGetMatchingVariantField(GetMatchingVariantField expression);
 	
-	public T visitGetStaticField(GetStaticFieldExpression expression);
+	T visitGetStaticField(GetStaticFieldExpression expression);
 	
-	public T visitGetter(GetterExpression expression);
+	T visitGetter(GetterExpression expression);
 	
-	public T visitGlobal(GlobalExpression expression);
+	T visitGlobal(GlobalExpression expression);
 	
-	public T visitGlobalCall(GlobalCallExpression expression);
+	T visitGlobalCall(GlobalCallExpression expression);
 	
-	public T visitInterfaceCast(InterfaceCastExpression expression);
+	T visitInterfaceCast(InterfaceCastExpression expression);
 	
-	public default T visitInvalid(InvalidExpression expression) {
+	default T visitInvalid(InvalidExpression expression) {
 		throw new RuntimeException("Invalid expression");
 	}
 	
-	public T visitIs(IsExpression expression);
+	T visitIs(IsExpression expression);
 	
-	public T visitMakeConst(MakeConstExpression expression);
+	T visitMakeConst(MakeConstExpression expression);
 	
-	public T visitMap(MapExpression expression);
+	T visitMap(MapExpression expression);
 	
-	public T visitMatch(MatchExpression expression);
+	T visitMatch(MatchExpression expression);
 	
-	public T visitNew(NewExpression expression);
+	T visitNew(NewExpression expression);
 	
-	public T visitNull(NullExpression expression);
+	T visitNull(NullExpression expression);
 	
-	public T visitOrOr(OrOrExpression expression);
+	T visitOrOr(OrOrExpression expression);
 	
-	public T visitPanic(PanicExpression expression);
+	T visitPanic(PanicExpression expression);
 	
-	public T visitPostCall(PostCallExpression expression);
+	T visitPostCall(PostCallExpression expression);
 	
-	public T visitRange(RangeExpression expression);
+	T visitRange(RangeExpression expression);
 	
-	public T visitSameObject(SameObjectExpression expression);
+	T visitSameObject(SameObjectExpression expression);
 	
-	public T visitSetField(SetFieldExpression expression);
+	T visitSetField(SetFieldExpression expression);
 	
-	public T visitSetFunctionParameter(SetFunctionParameterExpression expression);
+	T visitSetFunctionParameter(SetFunctionParameterExpression expression);
 	
-	public T visitSetLocalVariable(SetLocalVariableExpression expression);
+	T visitSetLocalVariable(SetLocalVariableExpression expression);
 	
-	public T visitSetStaticField(SetStaticFieldExpression expression);
+	T visitSetStaticField(SetStaticFieldExpression expression);
 	
-	public T visitSetter(SetterExpression expression);
+	T visitSetter(SetterExpression expression);
 	
-	public T visitStaticGetter(StaticGetterExpression expression);
+	T visitStaticGetter(StaticGetterExpression expression);
 	
-	public T visitStaticSetter(StaticSetterExpression expression);
+	T visitStaticSetter(StaticSetterExpression expression);
 	
-	public T visitStorageCast(StorageCastExpression expression);
+	T visitStorageCast(StorageCastExpression expression);
 	
-	public T visitSupertypeCast(SupertypeCastExpression expression);
+	T visitSupertypeCast(SupertypeCastExpression expression);
 	
-	public T visitThis(ThisExpression expression);
+	T visitThis(ThisExpression expression);
 	
-	public T visitThrow(ThrowExpression expression);
+	T visitThrow(ThrowExpression expression);
 	
-	public T visitTryConvert(TryConvertExpression expression);
+	T visitTryConvert(TryConvertExpression expression);
 	
-	public T visitTryRethrowAsException(TryRethrowAsExceptionExpression expression);
+	T visitTryRethrowAsException(TryRethrowAsExceptionExpression expression);
 	
-	public T visitTryRethrowAsResult(TryRethrowAsResultExpression expression);
+	T visitTryRethrowAsResult(TryRethrowAsResultExpression expression);
 	
-	public T visitVariantValue(VariantValueExpression expression);
+	T visitVariantValue(VariantValueExpression expression);
 	
-	public T visitWrapOptional(WrapOptionalExpression expression);
+	T visitWrapOptional(WrapOptionalExpression expression);
 }

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

  * @author Hoofdgebruiker
  */
 public interface ExpressionVisitorWithContext<C, R> {
-	public R visitAndAnd(C context, AndAndExpression expression);
+	R visitAndAnd(C context, AndAndExpression expression);
 	
-	public R visitArray(C context, ArrayExpression expression);
+	R visitArray(C context, ArrayExpression expression);
 	
-	public R visitCompare(C context, CompareExpression expression);
+	R visitCompare(C context, CompareExpression expression);
 	
-	public R visitCall(C context, CallExpression expression);
+	R visitCall(C context, CallExpression expression);
 	
-	public R visitCallStatic(C context, CallStaticExpression expression);
+	R visitCallStatic(C context, CallStaticExpression expression);
 	
-	public R visitCapturedClosure(C context, CapturedClosureExpression expression);
+	R visitCapturedClosure(C context, CapturedClosureExpression expression);
 	
-	public R visitCapturedDirect(C context, CapturedDirectExpression expression);
+	R visitCapturedDirect(C context, CapturedDirectExpression expression);
 	
-	public R visitCapturedLocalVariable(C context, CapturedLocalVariableExpression expression);
+	R visitCapturedLocalVariable(C context, CapturedLocalVariableExpression expression);
 	
-	public R visitCapturedParameter(C context, CapturedParameterExpression expression);
+	R visitCapturedParameter(C context, CapturedParameterExpression expression);
 	
-	public R visitCapturedThis(C context, CapturedThisExpression expression);
+	R visitCapturedThis(C context, CapturedThisExpression expression);
 	
-	public R visitCast(C context, CastExpression expression);
+	R visitCast(C context, CastExpression expression);
 	
-	public R visitCheckNull(C context, CheckNullExpression expression);
+	R visitCheckNull(C context, CheckNullExpression expression);
 	
-	public R visitCoalesce(C context, CoalesceExpression expression);
+	R visitCoalesce(C context, CoalesceExpression expression);
 	
-	public R visitConditional(C context, ConditionalExpression expression);
+	R visitConditional(C context, ConditionalExpression expression);
 	
-	public R visitConst(C context, ConstExpression expression);
+	R visitConst(C context, ConstExpression expression);
 	
-	public R visitConstantBool(C context, ConstantBoolExpression expression);
+	R visitConstantBool(C context, ConstantBoolExpression expression);
 	
-	public R visitConstantByte(C context, ConstantByteExpression expression);
+	R visitConstantByte(C context, ConstantByteExpression expression);
 	
-	public R visitConstantChar(C context, ConstantCharExpression expression);
+	R visitConstantChar(C context, ConstantCharExpression expression);
 	
-	public R visitConstantDouble(C context, ConstantDoubleExpression expression);
+	R visitConstantDouble(C context, ConstantDoubleExpression expression);
 	
-	public R visitConstantFloat(C context, ConstantFloatExpression expression);
+	R visitConstantFloat(C context, ConstantFloatExpression expression);
 	
-	public R visitConstantInt(C context, ConstantIntExpression expression);
-	
-	public R visitConstantLong(C context, ConstantLongExpression expression);
+	R visitConstantInt(C context, ConstantIntExpression expression);
+
+	R visitConstantLong(C context, ConstantLongExpression expression);
 	
-	public R visitConstantSByte(C context, ConstantSByteExpression expression);
+	R visitConstantSByte(C context, ConstantSByteExpression expression);
 	
-	public R visitConstantShort(C context, ConstantShortExpression expression);
+	R visitConstantShort(C context, ConstantShortExpression expression);
 	
-	public R visitConstantString(C context, ConstantStringExpression expression);
+	R visitConstantString(C context, ConstantStringExpression expression);
 	
-	public R visitConstantUInt(C context, ConstantUIntExpression expression);
+	R visitConstantUInt(C context, ConstantUIntExpression expression);
 	
-	public R visitConstantULong(C context, ConstantULongExpression expression);
+	R visitConstantULong(C context, ConstantULongExpression expression);
 	
-	public R visitConstantUShort(C context, ConstantUShortExpression expression);
+	R visitConstantUShort(C context, ConstantUShortExpression expression);
 	
-	public R visitConstantUSize(C context, ConstantUSizeExpression expression);
+	R visitConstantUSize(C context, ConstantUSizeExpression expression);
 	
-	public R visitConstructorThisCall(C context, ConstructorThisCallExpression expression);
+	R visitConstructorThisCall(C context, ConstructorThisCallExpression expression);
 	
-	public R visitConstructorSuperCall(C context, ConstructorSuperCallExpression expression);
+	R visitConstructorSuperCall(C context, ConstructorSuperCallExpression expression);
 	
-	public R visitEnumConstant(C context, EnumConstantExpression expression);
+	R visitEnumConstant(C context, EnumConstantExpression expression);
 	
-	public R visitFunction(C context, FunctionExpression expression);
+	R visitFunction(C context, FunctionExpression expression);
 	
-	public R visitGetField(C context, GetFieldExpression expression);
+	R visitGetField(C context, GetFieldExpression expression);
 	
-	public R visitGetFunctionParameter(C context, GetFunctionParameterExpression expression);
+	R visitGetFunctionParameter(C context, GetFunctionParameterExpression expression);
 	
-	public R visitGetLocalVariable(C context, GetLocalVariableExpression expression);
+	R visitGetLocalVariable(C context, GetLocalVariableExpression expression);
 	
-	public R visitGetMatchingVariantField(C context, GetMatchingVariantField expression);
+	R visitGetMatchingVariantField(C context, GetMatchingVariantField expression);
 	
-	public R visitGetStaticField(C context, GetStaticFieldExpression expression);
+	R visitGetStaticField(C context, GetStaticFieldExpression expression);
 	
-	public R visitGetter(C context, GetterExpression expression);
+	R visitGetter(C context, GetterExpression expression);
 	
-	public R visitGlobal(C context, GlobalExpression expression);
+	R visitGlobal(C context, GlobalExpression expression);
 	
-	public R visitGlobalCall(C context, GlobalCallExpression expression);
+	R visitGlobalCall(C context, GlobalCallExpression expression);
 	
-	public R visitInterfaceCast(C context, InterfaceCastExpression expression);
+	R visitInterfaceCast(C context, InterfaceCastExpression expression);
 	
-	public R visitInvalid(C context, InvalidExpression expression);
+	R visitInvalid(C context, InvalidExpression expression);
 	
-	public R visitIs(C context, IsExpression expression);
+	R visitIs(C context, IsExpression expression);
 	
-	public R visitMakeConst(C context, MakeConstExpression expression);
+	R visitMakeConst(C context, MakeConstExpression expression);
 	
-	public R visitMap(C context, MapExpression expression);
+	R visitMap(C context, MapExpression expression);
 	
-	public R visitMatch(C context, MatchExpression expression);
+	R visitMatch(C context, MatchExpression expression);
 	
-	public R visitNew(C context, NewExpression expression);
+	R visitNew(C context, NewExpression expression);
 	
-	public R visitNull(C context, NullExpression expression);
+	R visitNull(C context, NullExpression expression);
 	
-	public R visitOrOr(C context, OrOrExpression expression);
+	R visitOrOr(C context, OrOrExpression expression);
 	
-	public R visitPanic(C context, PanicExpression expression);
+	R visitPanic(C context, PanicExpression expression);
 	
-	public R visitPostCall(C context, PostCallExpression expression);
+	R visitPostCall(C context, PostCallExpression expression);
 	
-	public R visitRange(C context, RangeExpression expression);
+	R visitRange(C context, RangeExpression expression);
 	
-	public R visitSameObject(C context, SameObjectExpression expression);
+	R visitSameObject(C context, SameObjectExpression expression);
 	
-	public R visitSetField(C context, SetFieldExpression expression);
+	R visitSetField(C context, SetFieldExpression expression);
 	
-	public R visitSetFunctionParameter(C context, SetFunctionParameterExpression expression);
+	R visitSetFunctionParameter(C context, SetFunctionParameterExpression expression);
 	
-	public R visitSetLocalVariable(C context, SetLocalVariableExpression expression);
+	R visitSetLocalVariable(C context, SetLocalVariableExpression expression);
 	
-	public R visitSetStaticField(C context, SetStaticFieldExpression expression);
+	R visitSetStaticField(C context, SetStaticFieldExpression expression);
 	
-	public R visitSetter(C context, SetterExpression expression);
+	R visitSetter(C context, SetterExpression expression);
 	
-	public R visitStaticGetter(C context, StaticGetterExpression expression);
+	R visitStaticGetter(C context, StaticGetterExpression expression);
 	
-	public R visitStaticSetter(C context, StaticSetterExpression expression);
+	R visitStaticSetter(C context, StaticSetterExpression expression);
 	
-	public R visitStorageCast(C context, StorageCastExpression expression);
+	R visitStorageCast(C context, StorageCastExpression expression);
 	
-	public R visitSupertypeCast(C context, SupertypeCastExpression expression);
+	R visitSupertypeCast(C context, SupertypeCastExpression expression);
 	
-	public R visitThis(C context, ThisExpression expression);
+	R visitThis(C context, ThisExpression expression);
 	
-	public R visitThrow(C context, ThrowExpression expression);
+	R visitThrow(C context, ThrowExpression expression);
 	
-	public R visitTryConvert(C context, TryConvertExpression expression);
+	R visitTryConvert(C context, TryConvertExpression expression);
 	
-	public R visitTryRethrowAsException(C context, TryRethrowAsExceptionExpression expression);
+	R visitTryRethrowAsException(C context, TryRethrowAsExceptionExpression expression);
 	
-	public R visitTryRethrowAsResult(C context, TryRethrowAsResultExpression expression);
+	R visitTryRethrowAsResult(C context, TryRethrowAsResultExpression expression);
 	
-	public R visitVariantValue(C context, VariantValueExpression expression);
+	R visitVariantValue(C context, VariantValueExpression expression);
 	
-	public R visitWrapOptional(C context, WrapOptionalExpression expression);
+	R visitWrapOptional(C context, WrapOptionalExpression expression);
 }

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
 	@Override
 	public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
 		return scope.getTypeMembers(getter.getOwnerType())
-				.getOrCreateGroup(getter.member.name, false)
+				.getGroup(getter.member.name)
 				.setter(position, scope, target, value, false);
 	}
 }

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

 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 
 /**
  *

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/SwitchValue.java

  * @author Hoofdgebruiker
  */
 public interface SwitchValue {
-	public <T> T accept(SwitchValueVisitor<T> visitor);
+	<T> T accept(SwitchValueVisitor<T> visitor);
 	
-	public <C, R> R accept(C context, SwitchValueVisitorWithContext<C, R> visitor);
+	<C, R> R accept(C context, SwitchValueVisitorWithContext<C, R> visitor);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/SwitchValueVisitor.java

  * @author Hoofdgebruiker
  */
 public interface SwitchValueVisitor <T> {
-	public T acceptInt(IntSwitchValue value);
+	T acceptInt(IntSwitchValue value);
 	
-	public T acceptChar(CharSwitchValue value);
+	T acceptChar(CharSwitchValue value);
 	
-	public T acceptString(StringSwitchValue value);
+	T acceptString(StringSwitchValue value);
 	
-	public T acceptEnumConstant(EnumConstantSwitchValue value);
+	T acceptEnumConstant(EnumConstantSwitchValue value);
 	
-	public T acceptVariantOption(VariantOptionSwitchValue value);
+	T acceptVariantOption(VariantOptionSwitchValue value);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/SwitchValueVisitorWithContext.java

  * @author Hoofdgebruiker
  */
 public interface SwitchValueVisitorWithContext <C, R> {
-	public R acceptInt(C context, IntSwitchValue value);
+	R acceptInt(C context, IntSwitchValue value);
 	
-	public R acceptChar(C context, CharSwitchValue value);
+	R acceptChar(C context, CharSwitchValue value);
 	
-	public R acceptString(C context, StringSwitchValue value);
+	R acceptString(C context, StringSwitchValue value);
 	
-	public R acceptEnumConstant(C context, EnumConstantSwitchValue value);
+	R acceptEnumConstant(C context, EnumConstantSwitchValue value);
 	
-	public R acceptVariantOption(C context, VariantOptionSwitchValue value);
+	R acceptVariantOption(C context, VariantOptionSwitchValue value);
 }

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

  * @author Hoofdgebruiker
  */
 public interface GenericParameterBoundVisitor<T> {
-	public T visitSuper(ParameterSuperBound bound);
+	T visitSuper(ParameterSuperBound bound);
 	
-	public T visitType(ParameterTypeBound bound);
+	T visitType(ParameterTypeBound bound);
 }

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

  * @author Hoofdgebruiker
  */
 public interface GenericParameterBoundVisitorWithContext<C, R> {
-	public R visitSuper(C context, ParameterSuperBound bound);
+	R visitSuper(C context, ParameterSuperBound bound);
 	
-	public R visitType(C context, ParameterTypeBound bound);
+	R visitType(C context, ParameterTypeBound bound);
 }

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

  *
  * @author Hoofdgebruiker
  */
-public class ParameterSuperBound extends TypeParameterBound {
+public final class ParameterSuperBound implements TypeParameterBound {
 	public final TypeID type;
 	
 	public ParameterSuperBound(TypeID type) {

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

  *
  * @author Hoofdgebruiker
  */
-public class ParameterTypeBound extends TypeParameterBound {
+public final class ParameterTypeBound implements TypeParameterBound {
 	public final CodePosition position;
 	public final TypeID type;
 	
 
 	@Override
 	public void registerMembers(LocalMemberCache cache, TypeMembers members) {
-		cache.get(this.type.stored(members.type.getSpecifiedStorage()))
-				.copyMembersTo(position, members, TypeMemberPriority.FROM_TYPE_BOUNDS);
+		cache.get(type.stored(members.type.getSpecifiedStorage()))
+				.copyMembersTo(members, TypeMemberPriority.FROM_TYPE_BOUNDS);
 	}
 
 	@Override

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

 		this.name = name;
 	}
 	
-	private TypeParameter(CodePosition position, String name, List<TypeParameterBound> bounds) {
-		this.position = position;
-		this.name = name;
-		bounds.addAll(bounds);
-	}
-	
 	public void addBound(TypeParameterBound bound) {
 		bounds.add(bound);
 	}
-	
+
 	public boolean isObjectType() {
 		for (TypeParameterBound bound : bounds)
 			if (bound.isObjectType())
 				return true;
-		
+
 		return false;
 	}
 	

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

  *
  * @author Hoofdgebruiker
  */
-public abstract class TypeParameterBound {
-	public abstract boolean isObjectType();
+public interface TypeParameterBound {
+	boolean isObjectType();
 	
-	public abstract <T> T accept(GenericParameterBoundVisitor<T> visitor);
+	<T> T accept(GenericParameterBoundVisitor<T> visitor);
 	
-	public abstract <C, R> R accept(C context, GenericParameterBoundVisitorWithContext<C, R> visitor);
+	<C, R> R accept(C context, GenericParameterBoundVisitorWithContext<C, R> visitor);
 	
-	public abstract void registerMembers(LocalMemberCache cache, TypeMembers type);
+	void registerMembers(LocalMemberCache cache, TypeMembers type);
 	
-	public abstract boolean matches(LocalMemberCache cache, TypeID type);
+	boolean matches(LocalMemberCache cache, TypeID type);
 	
-	public abstract TypeParameterBound instance(GenericMapper mapper);
+	TypeParameterBound instance(GenericMapper mapper);
 	
-	public abstract String getCanonical();
+	String getCanonical();
 }

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

 import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;

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

  * @author Hoofdgebruiker
  */
 public interface IDefinitionMember {
-	public CodePosition getPosition();
+	CodePosition getPosition();
 	
-	public int getSpecifiedModifiers();
+	int getSpecifiedModifiers();
 	
-	public int getEffectiveModifiers();
+	int getEffectiveModifiers();
 	
-	public MemberAnnotation[] getAnnotations();
+	MemberAnnotation[] getAnnotations();
 	
-	public HighLevelDefinition getDefinition();
+	HighLevelDefinition getDefinition();
 	
-	public String describe();
+	String describe();
 	
-	public BuiltinID getBuiltin();
+	BuiltinID getBuiltin();
 	
-	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper);
+	void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper);
 	
-	public <T> T accept(MemberVisitor<T> visitor);
+	<T> T accept(MemberVisitor<T> visitor);
 	
-	public <C, R> R accept(C context, MemberVisitorWithContext<C, R> visitor);
+	<C, R> R accept(C context, MemberVisitorWithContext<C, R> visitor);
 	
-	public <T extends Tag> T getTag(Class<T> tag);
+	<T extends Tag> T getTag(Class<T> tag);
 	
-	public <T extends Tag> void setTag(Class<T> tag, T value);
+	<T extends Tag> void setTag(Class<T> tag, T value);
 
 	<T extends Tag> boolean hasTag(Class<T> tag);
 	
 	DefinitionMemberRef getOverrides();
 
-	public void normalize(TypeScope scope);
+	void normalize(TypeScope scope);
 	
 	boolean isAbstract();
 	

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

 		members.addImplementation(new ImplementationMemberRef(this, members.type, instancedType.stored(members.type.getSpecifiedStorage())), priority);
 		
 		TypeMembers interfaceTypeMembers = members.getMemberCache().get(instancedType.stored(members.type.getActualStorage()));
-		interfaceTypeMembers.copyMembersTo(position, members, TypeMemberPriority.INTERFACE);
+		interfaceTypeMembers.copyMembersTo(members, TypeMemberPriority.INTERFACE);
 	}
 
 	@Override

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

  * @author Hoofdgebruiker
  */
 public interface MemberVisitor<T> {
-	public T visitConst(ConstMember member);
+	T visitConst(ConstMember member);
 	
-	public T visitField(FieldMember member);
+	T visitField(FieldMember member);
 	
-	public T visitConstructor(ConstructorMember member);
+	T visitConstructor(ConstructorMember member);
 	
-	public T visitDestructor(DestructorMember member);
+	T visitDestructor(DestructorMember member);
 	
-	public T visitMethod(MethodMember member);
+	T visitMethod(MethodMember member);
 	
-	public T visitGetter(GetterMember member);
+	T visitGetter(GetterMember member);
 	
-	public T visitSetter(SetterMember member);
+	T visitSetter(SetterMember member);
 	
-	public T visitOperator(OperatorMember member);
+	T visitOperator(OperatorMember member);
 	
-	public T visitCaster(CasterMember member);
+	T visitCaster(CasterMember member);
 	
-	public T visitCustomIterator(IteratorMember member);
+	T visitCustomIterator(IteratorMember member);
 	
-	public T visitCaller(CallerMember member);
+	T visitCaller(CallerMember member);
 	
-	public T visitImplementation(ImplementationMember member);
+	T visitImplementation(ImplementationMember member);
 	
-	public T visitInnerDefinition(InnerDefinitionMember member);
+	T visitInnerDefinition(InnerDefinitionMember member);
 	
-	public T visitStaticInitializer(StaticInitializerMember member);
+	T visitStaticInitializer(StaticInitializerMember member);
 }

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

  * @author Hoofdgebruiker
  */
 public interface MemberVisitorWithContext<C, R> {
-	public R visitConst(C context, ConstMember member);
+	R visitConst(C context, ConstMember member);
 	
-	public R visitField(C context, FieldMember member);
+	R visitField(C context, FieldMember member);
 	
-	public R visitConstructor(C context, ConstructorMember member);
+	R visitConstructor(C context, ConstructorMember member);
 	
-	public R visitDestructor(C context, DestructorMember member);
+	R visitDestructor(C context, DestructorMember member);
 	
-	public R visitMethod(C context, MethodMember member);
+	R visitMethod(C context, MethodMember member);
 	
-	public R visitGetter(C context, GetterMember member);
+	R visitGetter(C context, GetterMember member);
 	
-	public R visitSetter(C context, SetterMember member);
+	R visitSetter(C context, SetterMember member);
 	
-	public R visitOperator(C context, OperatorMember member);
+	R visitOperator(C context, OperatorMember member);
 	
-	public R visitCaster(C context, CasterMember member);
+	R visitCaster(C context, CasterMember member);
 	
-	public R visitIterator(C context, IteratorMember member);
+	R visitIterator(C context, IteratorMember member);
 	
-	public R visitCaller(C context, CallerMember member);
+	R visitCaller(C context, CallerMember member);
 	
-	public R visitImplementation(C context, ImplementationMember member);
+	R visitImplementation(C context, ImplementationMember member);
 	
-	public R visitInnerDefinition(C context, InnerDefinitionMember member);
+	R visitInnerDefinition(C context, InnerDefinitionMember member);
 	
-	public R visitStaticInitializer(C context, StaticInitializerMember member);
+	R visitStaticInitializer(C context, StaticInitializerMember member);
 }

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

  * @author Hoofdgebruiker
  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
-	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, TypeScope scope, String name, TypeID target, FunctionalMemberRef method, StoredType[] typeArguments) {
-		TypeMemberGroup group = new TypeMemberGroup(true, name);
-		group.addMethod(method, TypeMemberPriority.SPECIFIED);
-		return new PartialStaticMemberGroupExpression(position, scope, target, group, typeArguments);
-	}
-	
 	private final CodePosition position;
 	private final TypeScope scope;
 	private final TypeID target;

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

  */
 package org.openzen.zenscript.codemodel.partial;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
 
 /**
 
 	@Override
 	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
-		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(position, scope, hints, arguments);
+		TypeMemberGroup group = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL);
+		if (group == null)
+			return new List[0];
+
+		return group.predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override
 	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
-		return scope.getTypeMembers(type)
-				.getOrCreateGroup(OperatorType.CALL)
+		TypeMemberGroup group = scope.getTypeMembers(type).getGroup(OperatorType.CALL);
+		return group
 				.getMethodMembers().stream()
-				.filter(method -> method.member.getHeader().parameters.length == arguments && method.member.isStatic())
+				.filter(method -> method.member.getHeader().accepts(arguments) && method.member.isStatic())
 				.map(method -> method.member.getHeader())
 				.collect(Collectors.toList());
 	}
 	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
 		if (arguments.getNumberOfTypeArguments() == 0 && (typeArguments != null && typeArguments.length > 0))
 			arguments = new CallArguments(typeArguments, arguments.arguments);
-		
-		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).callStatic(position, type.type, scope, arguments);
+
+		TypeMemberGroup group = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL);
+		if (group == null)
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "This type has not call operator");
+
+		return group.callStatic(position, type.type, scope, arguments);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/processor/InterfaceProcessor.java

  * @author Hoofdgebruiker
  */
 public interface InterfaceProcessor {
-	public void apply(ImplementationMember implementation);
+	void apply(ImplementationMember implementation);
 
-	public void applyOnSubclass(HighLevelDefinition definition, ImplementationMember implementation);
+	void applyOnSubclass(HighLevelDefinition definition, ImplementationMember implementation);
 }

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Supplier;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 	private final StoredType type;
 	private final TypeMembers members;
 	private final TypeParameter[] typeParameters;
-	private final Map<String, Supplier<HighLevelDefinition>> innerTypes = new HashMap<>();
 	private final GenericMapper typeParameterMap;
 	
 	public DefinitionScope(BaseScope outer, HighLevelDefinition definition) {
 		typeParameterMap = outer.getLocalTypeParameters().getInner(definition.position, getTypeRegistry(), typeParameters);
 	}
 	
-	public void addInnerType(String name, Supplier<HighLevelDefinition> innerType) {
-		innerTypes.put(name, innerType);
-	}
-	
 	@Override
 	public ZSPackage getRootPackage() {
 		return outer.getRootPackage();
 				return new PartialTypeExpression(position, members.getInnerType(position, name), name.arguments);
 			if (members.hasMember(name.name) && !name.hasArguments())
 				return members.getMemberExpression(position, this, new ThisExpression(position, type), name, true);
-		} else if (innerTypes.containsKey(name.name)) {
-			return new PartialTypeExpression(position, getTypeRegistry().getForDefinition(innerTypes.get(name).get(), name.arguments), name.arguments);
 		}
 		if (!name.hasArguments()) {
 			for (TypeParameter parameter : typeParameters)
 			for (TypeParameter parameter : typeParameters)
 				if (parameter.name.equals(name.get(0).name))
 					return getTypeRegistry().getGeneric(parameter);
-		
-		if (innerTypes.containsKey(name.get(0).name)) {
-			TypeID result = getTypeRegistry().getForDefinition(innerTypes.get(name.get(0).name).get(), name.get(0).arguments);
-			for (int i = 1; i < name.size(); i++) {
-				result = getTypeMembers(result.stored(StaticExpressionStorageTag.INSTANCE)).getInnerType(position, name.get(i));
-			}
-			return result;
-		}
-		
+
 		return outer.getType(position, name);
 	}
 

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

 	
 	public final List<StoredType> hints;
 	public final Map<TypeParameter, StoredType> genericInferenceMap;
-	public final Map<String, Function<CodePosition, Expression>> innerVariables = new HashMap<>();
+	private final Map<String, Function<CodePosition, Expression>> innerVariables = new HashMap<>();
 	
 	public ExpressionScope(BaseScope outer) {
 		this.outer = outer;
 		this.innerVariables.putAll(innerVariables);
 	}
 	
-	public void addInnerVariable(VarStatement variable) {
-		innerVariables.put(variable.name, position -> new GetLocalVariableExpression(position, variable));
-	}
-	
 	public void addMatchingVariantOption(String name, int index, VariantOptionSwitchValue value) {
 		innerVariables.put(name, position -> new GetMatchingVariantField(position, value, index));
 	}

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

 	@Override
 	public DollarEvaluator getDollar() {
 		return dollar;
-		/*for (FunctionParameter parameter : header.parameters)
-			if (parameter.name.equals("$"))
-				return position -> new GetFunctionParameterExpression(position, parameter);
-		
-		return null;*/
 	}
 	
 	@Override

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

 
 	@Override
 	public DollarEvaluator getDollar() {
-		return null; // script arguments?
+		return null;
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/StatementVisitor.java

  * @author Hoofdgebruiker
  */
 public interface StatementVisitor<T> {
-	public T visitBlock(BlockStatement statement);
+	T visitBlock(BlockStatement statement);
 	
-	public T visitBreak(BreakStatement statement);
+	T visitBreak(BreakStatement statement);
 	
-	public T visitContinue(ContinueStatement statement);
+	T visitContinue(ContinueStatement statement);
 	
-	public T visitDoWhile(DoWhileStatement statement);
+	T visitDoWhile(DoWhileStatement statement);
 	
-	public T visitEmpty(EmptyStatement statement);
+	T visitEmpty(EmptyStatement statement);
 	
-	public T visitExpression(ExpressionStatement statement);
+	T visitExpression(ExpressionStatement statement);
 	
-	public T visitForeach(ForeachStatement statement);
+	T visitForeach(ForeachStatement statement);
 	
-	public T visitIf(IfStatement statement);
+	T visitIf(IfStatement statement);
 	
 	default T visitInvalid(InvalidStatement statement) {
 		throw new UnsupportedOperationException("Invalid statement");
 	}
 	
-	public T visitLock(LockStatement statement);
+	T visitLock(LockStatement statement);
 	
-	public T visitReturn(ReturnStatement statement);
+	T visitReturn(ReturnStatement statement);
 	
-	public T visitSwitch(SwitchStatement statement);
+	T visitSwitch(SwitchStatement statement);
 	
-	public T visitThrow(ThrowStatement statement);
+	T visitThrow(ThrowStatement statement);
 	
-	public T visitTryCatch(TryCatchStatement statement);
+	T visitTryCatch(TryCatchStatement statement);
 	
-	public T visitVar(VarStatement statement);
+	T visitVar(VarStatement statement);
 	
-	public T visitWhile(WhileStatement statement);
+	T visitWhile(WhileStatement statement);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/StatementVisitorWithContext.java

  * @author Hoofdgebruiker
  */
 public interface StatementVisitorWithContext<C, R> {
-	public R visitBlock(C context, BlockStatement statement);
+	R visitBlock(C context, BlockStatement statement);
 	
-	public R visitBreak(C context, BreakStatement statement);
+	R visitBreak(C context, BreakStatement statement);
 	
-	public R visitContinue(C context, ContinueStatement statement);
+	R visitContinue(C context, ContinueStatement statement);
 	
-	public R visitDoWhile(C context, DoWhileStatement statement);
+	R visitDoWhile(C context, DoWhileStatement statement);
 	
-	public R visitEmpty(C context, EmptyStatement statement);
+	R visitEmpty(C context, EmptyStatement statement);
 	
-	public R visitExpression(C context, ExpressionStatement statement);
+	R visitExpression(C context, ExpressionStatement statement);
 	
-	public R visitForeach(C context, ForeachStatement statement);
+	R visitForeach(C context, ForeachStatement statement);
 	
-	public R visitIf(C context, IfStatement statement);
+	R visitIf(C context, IfStatement statement);
 	
 	default R visitInvalid(C context, InvalidStatement statement) {
 		throw new UnsupportedOperationException("Invalid statement");
 	}
 	
-	public R visitLock(C context, LockStatement statement);
+	R visitLock(C context, LockStatement statement);
 	
-	public R visitReturn(C context, ReturnStatement statement);
+	R visitReturn(C context, ReturnStatement statement);
 	
-	public R visitSwitch(C context, SwitchStatement statement);
+	R visitSwitch(C context, SwitchStatement statement);
 	
-	public R visitThrow(C context, ThrowStatement statement);
+	R visitThrow(C context, ThrowStatement statement);
 	
-	public R visitTryCatch(C context, TryCatchStatement statement);
+	R visitTryCatch(C context, TryCatchStatement statement);
 	
-	public R visitVar(C context, VarStatement statement);
+	R visitVar(C context, VarStatement statement);
 	
-	public R visitWhile(C context, WhileStatement statement);
+	R visitWhile(C context, WhileStatement statement);
 }

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

 	
 	@Override
 	public String toString() {
-		StringBuilder result = new StringBuilder();
-		result.append(valueType.toString());
-		result.append('[');
-		result.append(keyType.toString());
-		result.append(']');
-		return result.toString();
+		return valueType.toString() + '[' + keyType.toString() + ']';
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public class DefinitionTypeID implements TypeID {
-	public static DefinitionTypeID forType(GlobalTypeRegistry registry, HighLevelDefinition definition) {
-		if (definition.typeParameters != null && definition.typeParameters.length > 0)
-			throw new IllegalArgumentException("Definition has type arguments!");
-		
-		return new DefinitionTypeID(registry, definition, StoredType.NONE);
-	}
-	
 	public final HighLevelDefinition definition;
 	public final StoredType[] typeArguments;
 	public final DefinitionTypeID outer;

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

  * @author Hoofdgebruiker
  */
 public interface ISymbol {
-	public IPartialExpression getExpression(CodePosition position, BaseScope scope, StoredType[] typeArguments);
+	IPartialExpression getExpression(CodePosition position, BaseScope scope, StoredType[] typeArguments);
 	
-	public TypeID getType(CodePosition position, TypeResolutionContext context, StoredType[] typeArguments);
+	TypeID getType(CodePosition position, TypeResolutionContext context, StoredType[] typeArguments);
 }

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

 public class OptionalTypeID implements TypeID {
 	public final TypeID baseType;
 	private final TypeID normalized;
-	private final GlobalTypeRegistry registry;
 	
 	public OptionalTypeID(GlobalTypeRegistry registry, TypeID baseType) {
 		this.baseType = baseType;
-		this.registry = registry;
 		
 		normalized = baseType.getNormalized() == baseType ? this : registry.getOptional(baseType.getNormalized());
 	}
 	
 	@Override
 	public String toString(StorageTag storage) {
-		StringBuilder result = new StringBuilder();
-		result.append(baseType.toString(storage));
-		result.append("?");
-		return result.toString();
+		return baseType.toString(storage) + '?';
 	}
 }

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

 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	public boolean isEnum() {
 		return type.isEnum();
 	}
-	
-	public boolean isDefinition(HighLevelDefinition definition) {
-		return type.isDefinition(definition);
-	}
-	
+
 	public DefinitionTypeID asDefinition() {
 		return (DefinitionTypeID)type;
 	}
 	public String toString() {
 		return storage == null ? type.toString() : type.toString(storage);
 	}
-	
-	public static class MatchingTypeVisitor implements TypeVisitor<Boolean> {
-		private final TypeID type;
-		private final Map<TypeParameter, StoredType> mapping;
-		private final LocalMemberCache cache;
-		
-		public MatchingTypeVisitor(LocalMemberCache cache, TypeID type, Map<TypeParameter, StoredType> mapping) {
-			this.type = type;
-			this.mapping = mapping;
-			this.cache = cache;
-		}
-
-		@Override
-		public Boolean visitBasic(BasicTypeID basic) {
-			return basic == type;
-		}
-		
-		@Override
-		public Boolean visitString(StringTypeID string) {
-			return string == type;
-		}
-
-		@Override
-		public Boolean visitArray(ArrayTypeID array) {
-			if (type instanceof ArrayTypeID) {
-				ArrayTypeID arrayType = (ArrayTypeID) type;
-				if (arrayType.dimension != array.dimension)
-					return false;
-				
-				return match(arrayType.elementType, array.elementType);
-			} else {
-				return false;
-			}
-		}
-
-		@Override
-		public Boolean visitAssoc(AssocTypeID assoc) {
-			if (type instanceof AssocTypeID) {
-				AssocTypeID assocType = (AssocTypeID) type;
-				return match(assocType.keyType, assoc.keyType)
-						&& match(assocType.valueType, assoc.valueType);
-			} else {
-				return false;
-			}
-		}
-		
-		@Override
-		public Boolean visitIterator(IteratorTypeID iterator) {
-			if (type instanceof IteratorTypeID) {
-				IteratorTypeID iteratorType = (IteratorTypeID) type;
-				if (iteratorType.iteratorTypes.length != iterator.iteratorTypes.length)
-					return false;
-				
-				boolean result = true;
-				for (int i = 0; i < iteratorType.iteratorTypes.length; i++)
-					result = result && match(iterator.iteratorTypes[i], iteratorType.iteratorTypes[i]);
-				
-				return result;
-			} else {
-				return false;
-			}
-		}
-
-		@Override
-		public Boolean visitFunction(FunctionTypeID function) {
-			if (type instanceof FunctionTypeID) {
-				FunctionTypeID functionType = (FunctionTypeID) type;
-				if (functionType.header.parameters.length != function.header.parameters.length)
-					return false;
-				
-				if (!match(functionType.header.getReturnType(), function.header.getReturnType()))
-					return false;
-				
-				for (int i = 0; i < function.header.parameters.length; i++) {
-					if (!match(functionType.header.parameters[i].type, function.header.parameters[i].type))
-						return false;
-				}
-				
-				return true;
-			} else {
-				return false;
-			}
-		}
-
-		@Override
-		public Boolean visitDefinition(DefinitionTypeID definition) {
-			if (type instanceof DefinitionTypeID) {
-				DefinitionTypeID definitionType = (DefinitionTypeID) type;
-				if (definitionType.definition != definition.definition)
-					return false;
-				
-				if (definition.typeArguments != null) {
-					for (int i = 0; i < definitionType.typeArguments.length; i++) {
-						if (!match(definitionType.typeArguments[i], definition.typeArguments[i]))
-							return false;
-					}
-				}
-				
-				return true;
-			} else {
-				return false;
-			}
-		}
-
-		@Override
-		public Boolean visitGeneric(GenericTypeID generic) {
-			if (mapping.containsKey(generic.parameter)) {
-				return mapping.get(generic.parameter) == type;
-			} else if (type == generic || generic.matches(cache, type.stored())) {
-				mapping.put(generic.parameter, type.stored());
-				return true;
-			} else {
-				return false;
-			}
-		}
-
-		@Override
-		public Boolean visitRange(RangeTypeID range) {
-			if (type instanceof RangeTypeID) {
-				RangeTypeID rangeType = (RangeTypeID) type;
-				return match(rangeType.baseType, range.baseType);
-			} else {
-				return false;
-			}
-		}
-
-		@Override
-		public Boolean visitOptional(OptionalTypeID type) {
-			if (this.type instanceof OptionalTypeID) {
-				OptionalTypeID constType = (OptionalTypeID) this.type;
-				return match(constType.baseType, type.baseType.stored());
-			} else {
-				return false;
-			}
-		}
-		
-		private boolean match(StoredType type, StoredType pattern) {
-			if (pattern.storage != null && type.storage != pattern.storage)
-				return false;
-			
-			return TypeMatcher.match(cache, type, pattern) != null;
-		}
-		
-		private boolean match(TypeID type, StoredType pattern) {
-			return TypeMatcher.match(cache, type.stored(), pattern) != null;
-		}
-
-		@Override
-		public Boolean visitGenericMap(GenericMapTypeID map) {
-			return map == type; // TODO: improve this
-		}
-	}
 }

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

  * @author Hoofdgebruiker
  */
 public interface TypeID {
-	public static final TypeID[] NONE = new TypeID[0];
+	TypeID[] NONE = new TypeID[0];
 	
 	default TypeID getSuperType(GlobalTypeRegistry registry) {
 		return null;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeParameterCollector.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.type;
-
-import java.util.Map;
-import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class TypeParameterCollector implements TypeVisitorWithContext<Map<TypeParameter, GenericTypeID>, Void, RuntimeException> {
-	private final Map<TypeParameter, GenericTypeID> map;
-	
-	public TypeParameterCollector(Map<TypeParameter, GenericTypeID> map) {
-		this.map = map;
-	}
-
-	@Override
-	public Void visitBasic(Map<TypeParameter, GenericTypeID> context, BasicTypeID basic) {
-		return null;
-	}
-	
-	@Override
-	public Void visitString(Map<TypeParameter, GenericTypeID> context, StringTypeID string) {
-		return null;
-	}
-
-	@Override
-	public Void visitArray(Map<TypeParameter, GenericTypeID> context, ArrayTypeID array) {
-		array.elementType.type.accept(context, this);
-		return null;
-	}
-
-	@Override
-	public Void visitAssoc(Map<TypeParameter, GenericTypeID> context, AssocTypeID assoc) {
-		assoc.keyType.type.accept(context, this);
-		assoc.valueType.type.accept(context, this);
-		return null;
-	}
-
-	@Override
-	public Void visitGenericMap(Map<TypeParameter, GenericTypeID> context, GenericMapTypeID map) {
-		return null;
-	}
-
-	@Override
-	public Void visitIterator(Map<TypeParameter, GenericTypeID> context, IteratorTypeID iterator) {
-		for (StoredType type : iterator.iteratorTypes)
-			type.type.accept(context, this);
-		return null;
-	}
-
-	@Override
-	public Void visitFunction(Map<TypeParameter, GenericTypeID> context, FunctionTypeID function) {
-		function.header.getReturnType().type.accept(context, this);
-		for (FunctionParameter parameter : function.header.parameters)
-			parameter.type.type.accept(context, this);
-		return null;
-	}
-
-	@Override
-	public Void visitDefinition(Map<TypeParameter, GenericTypeID> context, DefinitionTypeID definition) {
-		for (StoredType argument : definition.typeArguments)
-			argument.type.accept(context, this);
-		if (definition.outer != null)
-			visitDefinition(context, definition.outer);
-		return null;
-	}
-
-	@Override
-	public Void visitGeneric(Map<TypeParameter, GenericTypeID> context, GenericTypeID generic) {
-		map.put(generic.parameter, generic);
-		return null;
-	}
-
-	@Override
-	public Void visitRange(Map<TypeParameter, GenericTypeID> context, RangeTypeID range) {
-		range.baseType.type.accept(context, this);
-		return null;
-	}
-
-	@Override
-	public Void visitModified(Map<TypeParameter, GenericTypeID> context, OptionalTypeID type) {
-		type.baseType.accept(context, this);
-		return null;
-	}
-}

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

  * @author Hoofdgebruiker
  */
 public interface TypeVisitor<T> {
-	public T visitBasic(BasicTypeID basic);
+	T visitBasic(BasicTypeID basic);
 	
-	public T visitString(StringTypeID string);
+	T visitString(StringTypeID string);
 	
-	public T visitArray(ArrayTypeID array);
+	T visitArray(ArrayTypeID array);
 	
-	public T visitAssoc(AssocTypeID assoc);
+	T visitAssoc(AssocTypeID assoc);
 	
-	public T visitGenericMap(GenericMapTypeID map);
+	T visitGenericMap(GenericMapTypeID map);
 	
-	public T visitIterator(IteratorTypeID iterator);
+	T visitIterator(IteratorTypeID iterator);
 	
-	public T visitFunction(FunctionTypeID function);
+	T visitFunction(FunctionTypeID function);
 	
-	public T visitDefinition(DefinitionTypeID definition);
+	T visitDefinition(DefinitionTypeID definition);
 	
-	public T visitGeneric(GenericTypeID generic);
+	T visitGeneric(GenericTypeID generic);
 	
-	public T visitRange(RangeTypeID range);
+	T visitRange(RangeTypeID range);
 	
-	public T visitOptional(OptionalTypeID type);
+	T visitOptional(OptionalTypeID type);
 	
-	public default T visitInvalid(InvalidTypeID type) {
+	default T visitInvalid(InvalidTypeID type) {
 		throw new UnsupportedOperationException("Invalid type: " + type.message);
 	}
 }

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

 	}
 	
 	public TypeMember<T> resolve(TypeMember<T> other) {
-		if (priority == other.priority) {
-			//if (priority == TypeMemberPriority.SPECIFIED)
-			//	throw new CompileException(other.member.getPosition(), CompileExceptionCode.MEMBER_DUPLICATE, "Duplicate " + other.member.describe());
-			return this;
-		}
-		
+		if (priority == other.priority)
+			return this; // this is actually an error; but that error will be reported through the validator
+
 		if (priority.compareTo(other.priority) < 0) {
 			return other;
 		} else {

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

 			InterfaceDefinition interfaceDefinition = (InterfaceDefinition)definition;
 			for (TypeID baseType : interfaceDefinition.baseInterfaces)
 				cache.get(baseType.instance(mapper, type.getSpecifiedStorage()))
-						.copyMembersTo(definitionType.definition.position, members, TypeMemberPriority.INHERITED);
+						.copyMembersTo(members, TypeMemberPriority.INHERITED);
 		}
 		
 		if (definitionType.superType != null) {
 			cache.get(definitionType.superType.stored(type.getSpecifiedStorage()))
-					.copyMembersTo(definitionType.definition.position, members, TypeMemberPriority.INHERITED);
+					.copyMembersTo(members, TypeMemberPriority.INHERITED);
 		} else {
 			getter(definition, OBJECT_HASHCODE, "objectHashCode", INT.stored);
 		}

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

  * @author Hoofdgebruiker
  */
 public class TypeMemberGroup {
+	public static final TypeMemberGroup EMPTY = new TypeMemberGroup(false, "");
+
 	public static TypeMemberGroup forMethod(String name, FunctionalMemberRef member) {
 		TypeMemberGroup instance = new TypeMemberGroup(member.isStatic(), name);
 		instance.addMethod(member, TypeMemberPriority.SPECIFIED);
 		this.name = name;
 	}
 	
-	public void merge(CodePosition position, TypeMemberGroup other, TypeMemberPriority priority) {
+	public void merge(TypeMemberGroup other, TypeMemberPriority priority) {
 		if (other.constant != null)
 			setConst(other.constant.member, priority);
 		if (other.field != null)
 			scope.getPreparer().prepare(setter.member.member);
 			return new SetterExpression(position, target, setter.member, value.castImplicit(position, scope, setter.member.getType()));
 		} else if (field != null) {
-			// TODO: perform proper checks on val fields
-			//if (field.isFinal)
-			//	throw new CompileException(position, "This field cannot be modified");
 			if (field.member.isStatic()) {
 				if (!allowStaticUsage)
 					return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
 			scope.getPreparer().prepare(setter.member.member);
 			return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.getType()));
 		} else if (field != null) {
-			//if (field.member.isFinal)
-			//	throw new CompileException(position, CompileExceptionCode.MEMBER_IS_FINAL, "This field cannot be modified");
 			if (!field.member.isStatic())
 				return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This field is not static");
 

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

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 		return cache.getRegistry();
 	}
 	
-	public void copyMembersTo(CodePosition position, TypeMembers other, TypeMemberPriority priority) {
+	public void copyMembersTo(TypeMembers other, TypeMemberPriority priority) {
 		other.casters.addAll(casters);
 		other.iterators.addAll(iterators);
 		
 		for (Map.Entry<String, VariantOptionRef> entry : variantOptions.entrySet())
 			other.addVariantOption(entry.getValue());
 		for (Map.Entry<String, TypeMemberGroup> entry : members.entrySet())
-			other.getOrCreateGroup(entry.getKey(), entry.getValue().isStatic).merge(position, entry.getValue(), priority);
+			other.getOrCreateGroup(entry.getKey(), entry.getValue().isStatic).merge(entry.getValue(), priority);
 		for (Map.Entry<String, InnerDefinition> entry : innerTypes.entrySet())
 			other.innerTypes.put(entry.getKey(), entry.getValue());
 		for (Map.Entry<OperatorType, TypeMemberGroup> entry : operators.entrySet())
-			other.getOrCreateGroup(entry.getKey()).merge(position, entry.getValue(), priority);
+			other.getOrCreateGroup(entry.getKey()).merge(entry.getValue(), priority);
 	}
 	
 	public DefinitionMemberRef getBuiltin(BuiltinID builtin) {
 		group.setField(member, priority);
 	}
 	
-	public void addGetter(GetterMemberRef member) throws CompileException {
-		addGetter(member, TypeMemberPriority.SPECIFIED);
-	}
-	
 	public void addGetter(GetterMemberRef member, TypeMemberPriority priority) {
 		TypeMemberGroup group = getOrCreateGroup(member.member.name, member.isStatic());
 		group.setGetter(member, priority);
 	}
 	
-	public void addSetter(SetterMemberRef member) throws CompileException {
-		addSetter(member, TypeMemberPriority.SPECIFIED);
-	}
-	
 	public void addSetter(SetterMemberRef member, TypeMemberPriority priority) {
 		TypeMemberGroup group = getOrCreateGroup(member.member.name, member.isStatic());
 		group.setSetter(member, priority);
 	}
 	
-	public void addMethod(String name, FunctionalMemberRef member) {
-		addMethod(name, member, TypeMemberPriority.SPECIFIED);
-	}
-	
 	public void addMethod(String name, FunctionalMemberRef member, TypeMemberPriority priority) {
 		TypeMemberGroup group = getOrCreateGroup(name, member.isStatic());
 		group.addMethod(member, priority);
 	}
 	
 	public TypeMemberGroup getGroup(String name) {
+		if (!members.containsKey(name))
+			return new TypeMemberGroup(false, name);
+
 		return members.get(name);
 	}
 	
 	}
 	
 	public TypeMemberGroup getGroup(OperatorType operator) {
+		if (!operators.containsKey(operator))
+			return new TypeMemberGroup(false, operator.operator + " operator");
+
 		return operators.get(operator);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/StorageType.java

  * @author Hoofdgebruiker
  */
 public interface StorageType {
-	public static StorageType[] getStandard() {
+	static StorageType[] getStandard() {
 		return new StorageType[] {
 			AutoStorageType.INSTANCE,
 			BorrowStorageType.INSTANCE,

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

 package org.openzen.zenscript.constructor;
 
 import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeRunUnit;
 import org.openzen.zenscript.javabytecode.JavaCompiler;
 import org.openzen.zenscript.javashared.JavaCompileSpace;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.SimpleJavaCompileSpace;
 import org.openzen.zenscript.javasource.JavaDirectoryOutput;
 import org.openzen.zenscript.javasource.JavaSourceCompiler;
 		@Override
 		public void addModule(SemanticModule module) {
 			JavaSourceModule result = compiler.compile(module, space, module.modulePackage.fullName);
+			writeMappings(result);
+			
 			modules.add(result);
 			space.register(result);
 		}
 		public void run() {
 			throw new UnsupportedOperationException();
 		}
+		
+		private void writeMappings(JavaCompiledModule module) {
+			String mappings = module.generateMappings();
+			try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(new File(output, "java.map")), StandardCharsets.UTF_8)) {
+				writer.write(mappings);
+			} catch (IOException ex) {
+				
+			}
+		}
 	}
 	
 	private static class JavaBytecodeTargetType implements TargetType {

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

 package org.openzen.zenscript.javabytecode.compiler;
 
-import org.openzen.zenscript.javashared.JavaParameterInfo;
+import org.openzen.zenscript.javashared.*;
+
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.StringJoiner;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
-import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.type.*;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.javabytecode.*;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaField;
-import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.javashared.JavaTypeUtils;
-import org.openzen.zenscript.javashared.JavaVariantOption;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
 	private static final JavaField CHARACTER_MIN_VALUE = new JavaField(JavaClass.CHARACTER, "MIN_VALUE", "C");
 	private static final JavaField CHARACTER_MAX_VALUE = new JavaField(JavaClass.CHARACTER, "MAX_VALUE", "C");
 	private static final JavaMethod CHARACTER_TO_STRING = JavaMethod.getNativeStatic(JavaClass.CHARACTER, "toString", "(C)Ljava/lang/String;");
+	private static final JavaMethod STRING_INIT_CHARACTERS = JavaMethod.getNativeConstructor(JavaClass.STRING, "([C)V");
 	private static final JavaMethod STRING_COMPARETO = JavaMethod.getNativeVirtual(JavaClass.STRING, "compareTo", "(Ljava/lang/String;)I");
 	private static final JavaMethod STRING_CONCAT = JavaMethod.getNativeVirtual(JavaClass.STRING, "concat", "(Ljava/lang/String;)Ljava/lang/String;");
 	private static final JavaMethod STRING_CHAR_AT = JavaMethod.getNativeVirtual(JavaClass.STRING, "charAt", "(I)C");
 	private static final JavaMethod ENUM_COMPARETO = JavaMethod.getNativeVirtual(JavaClass.ENUM, "compareTo", "(Ljava/lang/Enum;)I");
 	private static final JavaMethod ENUM_NAME = JavaMethod.getNativeVirtual(JavaClass.ENUM, "name", "()Ljava/lang/String;");
 	private static final JavaMethod ENUM_ORDINAL = JavaMethod.getNativeVirtual(JavaClass.ENUM, "ordinal", "()I");
+	private static final JavaMethod HASHMAP_INIT = JavaMethod.getNativeConstructor(JavaClass.HASHMAP, "()V");
 	private static final JavaMethod MAP_GET = JavaMethod.getNativeVirtual(JavaClass.MAP, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
 	private static final JavaMethod MAP_PUT = JavaMethod.getNativeVirtual(JavaClass.MAP, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
 	private static final JavaMethod MAP_CONTAINS_KEY = JavaMethod.getNativeVirtual(JavaClass.MAP, "containsKey", "(Ljava/lang/Object;)Z");
 
     @Override
     public Void visitNew(NewExpression expression) {
+		if (expression.constructor.getBuiltin() != null) {
+			visitBuiltinConstructor(expression);
+			return null;
+		}
+
 		JavaMethod method = context.getJavaMethod(expression.constructor);
-        javaWriter.newObject(method.cls.internalName);
+        javaWriter.newObject(method.cls);
         javaWriter.dup();
 
 		for (Expression argument : expression.arguments.arguments) {
 		return null;
 	}
 
+	private void visitBuiltinConstructor(NewExpression expression) {
+		switch (expression.constructor.getBuiltin()) {
+			case STRING_CONSTRUCTOR_CHARACTERS:
+				javaWriter.newObject(JavaClass.STRING);
+				javaWriter.dup();
+				expression.arguments.arguments[0].accept(this);
+				javaWriter.invokeSpecial(STRING_INIT_CHARACTERS);
+				return;
+			case ASSOC_CONSTRUCTOR:
+			case GENERICMAP_CONSTRUCTOR: {
+				javaWriter.newObject(JavaClass.HASHMAP);
+				javaWriter.dup();
+				javaWriter.invokeSpecial(HASHMAP_INIT);
+				return;
+			}
+			case ARRAY_CONSTRUCTOR_SIZED: {
+				ArrayTypeID type = (ArrayTypeID) expression.type.type;
+				if (type.dimension == 1) {
+					// new T[arguments[0]]
+					expression.arguments.arguments[0].accept(this);
+					javaWriter.newArray(context.getType(type.elementType));
+					return;
+				} else {
+					// TODO: implement multidimensional arrays
+					throw new UnsupportedOperationException("Not yet supported!");
+				}
+			}
+			case ARRAY_CONSTRUCTOR_INITIAL_VALUE: {
+				ArrayTypeID type = (ArrayTypeID) expression.type.type;
+
+				if (type.dimension == 1) {
+					// array = new T[arguments[0]]
+					// value = arguments[1]
+					// for (int i = 0; i < array.length; i++)
+					//    array[i] = value;
+
+					expression.arguments.arguments[0].accept(this); // array size
+					javaWriter.newArray(context.getType(type.elementType));
+
+					int i = javaWriter.local(int.class);
+					javaWriter.iConst0();
+					javaWriter.storeInt(i);
+
+					Type valueType = context.getType(expression.arguments.arguments[1].type);
+
+					expression.arguments.arguments[1].accept(this); // initializer value
+					javaWriter.store(valueType, i);
+
+					// TODO: implement in bytecode
+					return;
+				} else {
+					// TODO: implement
+					throw new UnsupportedOperationException("Not yet supported!");
+				}
+			}
+			case ARRAY_CONSTRUCTOR_LAMBDA: {
+				ArrayTypeID type = (ArrayTypeID) expression.type.type;
+
+				if (type.dimension == 1) {
+					// array = new T[arguments[0]]
+					// lambda = arguments[1]
+					// for (int i = 0; i < array.length; i++)
+					//    array[i] = lambda.invoke(i);
+					//
+					// NOTE: arguments[1] can be a FunctionExpression; this can be optimized by running it inline
+
+					// TODO: implement in bytecode
+
+					return;
+				} else {
+					// TODO: implement
+					throw new UnsupportedOperationException("Not yet supported!");
+				}
+			}
+			case ARRAY_CONSTRUCTOR_PROJECTED: {
+				ArrayTypeID type = (ArrayTypeID) expression.type.type;
+
+				if (type.dimension == 1) {
+					// original = arguments[0] (this is an array)
+					// projector = arguments[1] (this is a lambda with 1 parameter)
+					// array = new T[original.length]
+					// for (int i = 0; i < array.length; i++)
+					//    array[i] = projector(original[i]);
+					//
+					// NOTE: arguments[1] can be a FunctionExpression; this can be optimized by running it inline
+
+					// TODO: implement in bytecode
+
+					return;
+				} else {
+					// TODO: implement
+					throw new UnsupportedOperationException("Not yet supported!");
+				}
+			}
+			case ARRAY_CONSTRUCTOR_PROJECTED_INDEXED: {
+				ArrayTypeID type = (ArrayTypeID) expression.type.type;
+
+				if (type.dimension == 1) {
+					// original = arguments[0] (this is an array)
+					// projector = arguments[1] (this is a lambda with 2 parameters)
+					// array = new T[original.length]
+					// for (int i = 0; i < array.length; i++)
+					//   array[i] = projector(i, original[i]);
+					//
+					// NOTE: arguments[1] can be a FunctionExpression; this can be optimized by running it inline
+
+					// TODO: implement in bytecode
+
+					return;
+				} else {
+					// TODO: implement
+					throw new UnsupportedOperationException("Not yet supported!");
+				}
+			}
+			case CLASS_DEFAULT_CONSTRUCTOR:
+				javaWriter.newObject(context.getInternalName(expression.type));
+				javaWriter.dup();
+				javaWriter.invokeSpecial(context.getJavaMethod(expression.constructor));
+				return;
+		}
+
+		throw new UnsupportedOperationException("Unknown builtin constructor: " + expression.constructor.getBuiltin());
+	}
+
 	@Override
 	public Void visitNull(NullExpression expression) {
 		if (!expression.type.isBasic(BasicTypeID.NULL) && expression.type.type.withoutOptional() == BasicTypeID.USIZE)

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

         visitor.visitTypeInsn(NEW, internalName);
     }
 
+    public void newObject(JavaClass cls) {
+        if (debug)
+            System.out.println("newObject " + cls.internalName);
+
+        visitor.visitTypeInsn(NEW, cls.internalName);
+    }
+
     public void goTo(Label lbl) {
         if (debug)
             System.out.println("goTo " + getLabelName(lbl));

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

-package org.openzen.zenscript.javashared;
-
-/*
- * 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.
- */
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public abstract class JavaBaseCompiler {
-	//public abstract JavaCompiledModule compile(SemanticModule module, JavaCompileSpace space);
-}

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

  * @author Hoofdgebruiker
  */
 public interface JavaCompileSpace {
-	public GlobalTypeRegistry getRegistry();
+	GlobalTypeRegistry getRegistry();
 	
-	public JavaCompiledModule getCompiled(Module module);
+	JavaCompiledModule getCompiled(Module module);
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 		this.module = module;
 	}
 	
+	public void loadMappings(String mappings) {
+		
+	}
+	
+	public String generateMappings() {
+		JavaMappingWriter writer = new JavaMappingWriter(this);
+		for (HighLevelDefinition definition : classes.keySet()) {
+			if (!(definition instanceof ExpansionDefinition))
+				definition.accept(writer);
+		}
+		for (HighLevelDefinition definition : expansionClasses.keySet()) {
+			definition.accept(writer);
+		}
+		
+		return writer.getOutput();
+	}
+	
 	public void setClassInfo(HighLevelDefinition definition, JavaClass cls) {
 		classes.put(definition, cls);
 	}
 		methods.put(member, method);
 	}
 	
+	public JavaMethod optMethodInfo(IDefinitionMember member) {
+		return methods.get(member);
+	}
+	
 	public JavaMethod getMethodInfo(DefinitionMemberRef member) {
 		return getMethodInfo(member.getTarget());
 	}

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

 		this.name = name;
 		this.descriptor = descriptor;
 	}
+	
+	public String getMapping(JavaClass definition) {
+		StringBuilder result = new StringBuilder();
+		result.append(name);
+		result.append(':');
+		result.append(descriptor);
+		
+		if (!cls.internalName.equals(definition.internalName))
+			result.append(definition.internalName);
+		
+		return result.toString();
+	}
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaMappingWriter.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.javashared;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.AliasDefinition;
+import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.member.CallerMember;
+import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstMember;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
+import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
+import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.MethodMember;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaMappingWriter implements DefinitionVisitor<Void> {
+	private final JavaCompiledModule module;
+	private final StringBuilder result = new StringBuilder();
+	
+	public JavaMappingWriter(JavaCompiledModule module) {
+		this.module = module;
+	}
+	
+	public String getOutput() {
+		return result.toString();
+	}
+
+	@Override
+	public Void visitClass(ClassDefinition definition) {
+		result.append("class:");
+		writeDefinitionDescriptor(definition);
+		return null;
+	}
+
+	@Override
+	public Void visitInterface(InterfaceDefinition definition) {
+		result.append("interface:");
+		writeDefinitionDescriptor(definition);
+		return null;
+	}
+
+	@Override
+	public Void visitEnum(EnumDefinition definition) {
+		result.append("enum:");
+		writeDefinitionDescriptor(definition);
+		return null;
+	}
+
+	@Override
+	public Void visitStruct(StructDefinition definition) {
+		result.append("struct:");
+		writeDefinitionDescriptor(definition);
+		return null;
+	}
+
+	@Override
+	public Void visitFunction(FunctionDefinition definition) {
+		result.append("function:").append(definition.name);
+		writeFunctionDescriptor(definition.header);
+		return null;
+	}
+
+	@Override
+	public Void visitExpansion(ExpansionDefinition definition) {
+		result.append("expansion:");
+		writeDefinitionDescriptor(definition);
+		return null;
+	}
+
+	@Override
+	public Void visitAlias(AliasDefinition definition) {
+		// aliases don't have mappings
+		return null;
+	}
+
+	@Override
+	public Void visitVariant(VariantDefinition variant) {
+		result.append("variant:");
+		writeDefinitionDescriptor(variant);
+		return null;
+	}
+	
+	private void writeFunctionDescriptor(FunctionHeader header) {
+		result.append(header.getCanonical());
+	}
+	
+	private void writeDefinitionDescriptor(HighLevelDefinition definition) {
+		if (definition.name != null)
+			result.append(definition.name);
+		if (definition.typeParameters.length > 0) {
+			result.append('<');
+			for (int i = 0; i < definition.typeParameters.length; i++) {
+				if (i > 0)
+					result.append(',');
+				result.append(definition.typeParameters[i].getCanonical());
+			}
+			result.append('>');
+		}
+		
+		JavaClass definitionClass = definition instanceof ExpansionDefinition
+				? module.getExpansionClassInfo(definition)
+				: module.getClassInfo(definition);
+		if (definitionClass != null) {
+			result.append('@').append(definitionClass.internalName);
+		}
+		result.append('\n');
+		
+		MemberMappingWriter memberWriter = new MemberMappingWriter(definitionClass);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(memberWriter);
+		}
+	}
+	
+	private class MemberMappingWriter implements MemberVisitor<Void> {
+		private final JavaClass definition;
+		
+		public MemberMappingWriter(JavaClass definition) {
+			this.definition = definition;
+		}
+
+		@Override
+		public Void visitConst(ConstMember member) {
+			JavaField field = module.optFieldInfo(member);
+			if (field == null)
+				return null;
+			
+			result.append(":const:");
+			result.append(member.name);
+			result.append("=");
+			result.append(field.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitField(FieldMember member) {
+			JavaField field = module.optFieldInfo(member);
+			if (field == null)
+				return null;
+			
+			result.append(":field:");
+			result.append(member.name);
+			result.append("=");
+			result.append(field.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitConstructor(ConstructorMember member) {
+			JavaMethod method = module.optMethodInfo(member);
+			if (method == null)
+				return null;
+			
+			result.append(":constructor:");
+			result.append(member.header.getCanonicalWithoutReturnType());
+			result.append("=");
+			result.append(method.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitDestructor(DestructorMember member) {
+			JavaMethod method = module.optMethodInfo(member);
+			if (method == null)
+				return null;
+			
+			result.append(":destructor=");
+			result.append(method.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitMethod(MethodMember member) {
+			JavaMethod method = module.optMethodInfo(member);
+			if (method == null)
+				return null;
+			
+			result.append(":method:");
+			result.append(member.name);
+			result.append(member.header.getCanonical());
+			result.append("=");
+			result.append(method.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitGetter(GetterMember member) {
+			JavaMethod method = module.optMethodInfo(member);
+			if (method == null)
+				return null;
+			
+			result.append(":getter:");
+			result.append(member.name);
+			result.append("=");
+			result.append(method.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitSetter(SetterMember member) {
+			JavaMethod method = module.optMethodInfo(member);
+			if (method == null)
+				return null;
+			
+			result.append(":setter:");
+			result.append(member.name);
+			result.append("=");
+			result.append(method.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitOperator(OperatorMember member) {
+			JavaMethod method = module.optMethodInfo(member);
+			if (method == null)
+				return null;
+			
+			result.append(":operator:");
+			result.append(member.operator.name().toLowerCase());
+			result.append(member.header.getCanonical());
+			result.append("=");
+			result.append(method.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitCaster(CasterMember member) {
+			JavaMethod method = module.optMethodInfo(member);
+			if (method == null)
+				return null;
+			
+			result.append(":caster:");
+			result.append(member.toType.type.toString());
+			result.append("=");
+			result.append(method.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitCustomIterator(IteratorMember member) {
+			return null;
+		}
+
+		@Override
+		public Void visitCaller(CallerMember member) {
+			JavaMethod method = module.optMethodInfo(member);
+			if (method == null)
+				return null;
+			
+			result.append(":caller:");
+			result.append(member.header.getCanonical());
+			result.append("=");
+			result.append(method.getMapping(definition));
+			result.append('\n');
+			return null;
+		}
+
+		@Override
+		public Void visitImplementation(ImplementationMember member) {
+			JavaImplementation implementation = module.getImplementationInfo(member);
+			return null;
+		}
+
+		@Override
+		public Void visitInnerDefinition(InnerDefinitionMember member) {
+			return null;
+		}
+
+		@Override
+		public Void visitStaticInitializer(StaticInitializerMember member) {
+			return null;
+		}
+	}
+}

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

 		this.genericResult = false;
 	}
 	
+	public String getMapping(JavaClass definition) {
+		if (cls == null)
+			return "!TODO";
+		
+		StringBuilder result = new StringBuilder();
+		result.append(name);
+		result.append(descriptor);
+		
+		if (definition == null || !definition.internalName.equals(cls.internalName))
+			result.append('@').append(cls.internalName);
+		
+		return result.toString();
+	}
+	
 	public enum Kind {
 		STATIC,
 		STATICINIT,

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

  *
  * @author Hoofdgebruiker
  */
+@FunctionalInterface
 public interface JavaNativeTranslation<T> {
-	public T translate(Expression expression, JavaNativeTranslator<T> translator);
+	T translate(Expression expression, JavaNativeTranslator<T> translator);
 }

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

 	public final boolean isKeyword;
 	public final boolean multiline;
 	
-	private ZSTokenType() {
+	ZSTokenType() {
 		this.regexp = null;
 		this.whitespace = false;
 		this.isKeyword = false;
 		this.multiline = false;
 	}
 	
-	private ZSTokenType(String regexp) {
+	ZSTokenType(String regexp) {
 		this.regexp = regexp;
 		this.whitespace = false;
 		this.isKeyword = false;
 		this.multiline = false;
 	}
 	
-	private ZSTokenType(String regexp, boolean whitespace) {
+	ZSTokenType(String regexp, boolean whitespace) {
 		this.regexp = regexp;
 		this.whitespace = whitespace;
 		this.isKeyword = false;
 		this.multiline = false;
 	}
 	
-	private ZSTokenType(String regexp, boolean whitespace, boolean multiline) {
+	ZSTokenType(String regexp, boolean whitespace, boolean multiline) {
 		this.regexp = regexp;
 		this.whitespace = whitespace;
 		this.isKeyword = false;
 		this.multiline = multiline;
 	}
 	
-	private ZSTokenType(String regexp, String content) {
+	ZSTokenType(String regexp, String content) {
 		this.regexp = regexp;
 		this.whitespace = false;
 		this.isKeyword = false;
 		this.multiline = false;
 	}
 	
-	private ZSTokenType(boolean isWhitespace, String regexp, String content) {
+	ZSTokenType(boolean isWhitespace, String regexp, String content) {
 		this.regexp = regexp;
 		this.whitespace = isWhitespace;
 		this.isKeyword = false;
 		this.multiline = false;
 	}
 	
-	private ZSTokenType(boolean isWhitespace, String regexp, String content, boolean multiline) {
+	ZSTokenType(boolean isWhitespace, String regexp, String content, boolean multiline) {
 		this.regexp = regexp;
 		this.whitespace = isWhitespace;
 		this.isKeyword = false;
 		this.multiline = multiline;
 	}
 	
-	private ZSTokenType(boolean isKeyword, String content) {
+	ZSTokenType(boolean isKeyword, String content) {
 		this.regexp = null;
 		this.whitespace = false;
 		this.isKeyword = isKeyword;

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

 		if (typesCompiled)
 			return;
 		typesCompiled = true;
-		
-		//System.out.println("compileTypes " + getCompiled().name);
+
 		linkTypesLocal(context);
 	}
 	
 	private class Compiling implements CompilingType {
 		private final TypeResolutionContext context;
 		
-		public Compiling(TypeResolutionContext context) {
+		private Compiling(TypeResolutionContext context) {
 			this.context = new LocalTypeResolutionContext(context, this, getCompiled().typeParameters);
 		}
 		

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

 	private class Compiling implements CompilingType {
 		private final TypeResolutionContext context;
 		
-		public Compiling(TypeResolutionContext context) {
+		private Compiling(TypeResolutionContext context) {
 			this.context = new LocalTypeResolutionContext(context, this, compiled.typeParameters);
 		}
 		

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

 		
 		StoredType cType = type.compile(context);
 		Expression cDefaultValue = null;
-		return compiled = new FunctionParameter(cType, name, cDefaultValue, variadic);
+		return compiled = new FunctionParameter(cType, name, null, variadic);
 	}
-	
+
+	// TODO: this isn't called!
 	public void compileInitializer(BaseScope scope, PrecompilationState state) {
 		if (defaultValue != null) {
 			try {