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

.gitignore

 .nb-gradle
 build
 *.class
+
+out/

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

 				}
 				case INDEXGET: {
 					StringBuilder result = new StringBuilder();
-					result.append(expression.target);
+                    if(expression.target instanceof GetLocalVariableExpression) {
+                        result.append(((GetLocalVariableExpression) expression.target).variable.name);
+                    } else if(expression.target instanceof GetFunctionParameterExpression) {
+                        result.append(((GetFunctionParameterExpression) expression.target).parameter.name);
+                    } else {
+                        result.append(expression.target);
+                    }
 					result.append("[");
-					for (int i = 0; i < expression.arguments.arguments.length - 1; i++) {
+					//why -1?
+					for (int i = 0; i < expression.arguments.arguments.length; i++) {
 						if (i > 0)
 							result.append(", ");
 						
 
 	@Override
 	public ExpressionString visitConstantDouble(ConstantDoubleExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	    return new ExpressionString(Double.toString(expression.value), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitConstantFloat(ConstantFloatExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        return new ExpressionString(Float.toString(expression.value), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override

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

 	public Void visitExpression(ExpressionStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		output.append(statement.expression.accept(expressionFormatter).value)
-			  .append(";");
+        String value = statement.expression.accept(expressionFormatter).value;
+        output.append(value).append(";");
 		endSingleLine(whitespace);
 		return null;
 	}
 		}
 		if (statement.initializer != null) {
 			output.append(" = ");
-			output.append(statement.initializer.accept(expressionFormatter).value);
+            String value = statement.initializer.accept(expressionFormatter).value;
+            output.append(value);
 		}
 		output.append(";");
 		endSingleLine(whitespace);

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

 	@Override
 	public String visitDefinition(DefinitionTypeID definition) {
 		String importedName = importer.importDefinition(definition.definition);
-		if (definition.typeArguments == null)
+		if (definition.typeArguments == null || definition.typeArguments.length == 0)
 			return importedName;
 		
 		StringBuilder result = new StringBuilder();

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

  */
 package org.openzen.zenscript.codemodel;
 
-import java.util.Arrays;
-import java.util.Map;
+import java.util.*;
+
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 	
 	public FunctionParameter getParameter(boolean isVariadic, int index) {
 		if (isVariadic && index >= parameters.length - 1) {
-			return parameters[parameters.length - 1];
+			final FunctionParameter parameter = parameters[parameters.length - 1];
+			if(parameter.type.type instanceof ArrayTypeID) {
+				return new FunctionParameter(((ArrayTypeID) parameter.type.type).elementType, parameter.name);
+			}
+			return parameter;
 		} else {
 			return parameters[index];
 		}
 			return false;
 		
 		FunctionHeader header = fillGenericArguments(position, scope, arguments.typeArguments);
-		for (int i = 0; i < header.parameters.length; i++) {
-			if (!arguments.arguments[i].type.equals(header.parameters[i].type))
-				return false;
-		}
-		
-		return true;
+        final boolean variadicCall = header.isVariadicCall(arguments, scope);
+        for(int i = 0; i < arguments.arguments.length; i++) {
+            if(!arguments.arguments[i].type.equals(header.getParameterType(variadicCall, i)))
+                return false;
+        }
+        
+        return true;
 	}
 	
 	public boolean matchesImplicitly(CodePosition position, CallArguments arguments, TypeScope scope) {
 			return false;
 		
 		FunctionHeader header = fillGenericArguments(position, scope, arguments.typeArguments);
+		if(isVariadic()) {
+		    boolean matches = true;
+            for (int i = 0; i < arguments.arguments.length; i++) {
+                if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.getParameterType(true, i))) {
+                    matches = false;
+                    break;
+                }
+            }
+            if(matches) {
+                return true;
+            }
+        }
+		
 		for (int i = 0; i < arguments.arguments.length; i++) {
 			if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.parameters[i].type))
 				return false;
 	public boolean accepts(int arguments) {
 		return arguments >= this.minParameters && arguments <= this.maxParameters;
 	}
+    
+    @Override
+    public boolean equals(Object o) {
+        if(this == o)
+            return true;
+        if(o == null || getClass() != o.getClass())
+            return false;
+        
+        FunctionHeader that = (FunctionHeader) o;
+        
+        if(minParameters != that.minParameters)
+            return false;
+        if(maxParameters != that.maxParameters)
+            return false;
+        if(hasUnknowns != that.hasUnknowns)
+            return false;
+        if(!Arrays.equals(typeParameters, that.typeParameters))
+            return false;
+        if(!returnType.equals(that.returnType))
+            return false;
+        if(!Arrays.equals(parameters, that.parameters))
+            return false;
+        if(!Objects.equals(thrownType, that.thrownType))
+            return false;
+        return Objects.equals(storage, that.storage);
+    }
+    
+    @Override
+    public int hashCode() {
+        int result = Arrays.hashCode(typeParameters);
+        result = 31 * result + returnType.hashCode();
+        result = 31 * result + Arrays.hashCode(parameters);
+        result = 31 * result + (thrownType != null ? thrownType.hashCode() : 0);
+        result = 31 * result + (storage != null ? storage.hashCode() : 0);
+        result = 31 * result + minParameters;
+        result = 31 * result + maxParameters;
+        result = 31 * result + (hasUnknowns ? 1 : 0);
+        return result;
+    }
 }

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

  */
 package org.openzen.zenscript.codemodel;
 
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GenericTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.codemodel.generic.*;
+import org.openzen.zenscript.codemodel.type.*;
+
+import java.util.*;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class GenericMapper {
-	public static final GenericMapper EMPTY = new GenericMapper(CodePosition.BUILTIN, null, Collections.emptyMap());
-	
-	public final CodePosition position;
-	public final GlobalTypeRegistry registry;
-	private final Map<TypeParameter, StoredType> mapping;
-	
-	public GenericMapper(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
-		if (mapping == null)
-			throw new IllegalArgumentException();
-		
-		this.position = position;
-		this.registry = registry;
-		this.mapping = mapping;
-	}
-	
-	public Map<TypeParameter, StoredType> getMapping() {
-		return mapping;
-	}
-	
-	public StoredType map(StoredType original) {
-		return mapping.isEmpty() ? original : original.instance(this);
-	}
-	
-	public StoredType[] map(StoredType[] original) {
-		if (mapping.isEmpty() || original.length == 0)
-			return original;
-		
-		StoredType[] mapped = new StoredType[original.length];
-		for (int i = 0; i < original.length; i++)
-			mapped[i] = original[i].instance(this);
-		return mapped;
-	}
-	
-	public StoredType map(GenericTypeID type) {
-		//if (!mapping.containsKey(type.parameter))
-		//	throw new IllegalStateException("No mapping found for type " + type);
-		
-		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type.stored();
-	}
-	
-	public FunctionHeader map(FunctionHeader original) {
-		return mapping.isEmpty() ? original : original.withGenericArguments(this);
-	}
-	
-	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
-		Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
-		resultMap.putAll(mapping);
-		return new GenericMapper(position, registry, resultMap);
-	}
-	
-	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, TypeParameter[] parameters) {
-		Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
-		for (TypeParameter parameter : parameters)
-			resultMap.put(parameter, new StoredType(registry.getGeneric(parameter), null));
-		return new GenericMapper(position, registry, resultMap);
-	}
-	
-	@Override
-	public String toString() {
-		if (mapping.isEmpty())
-			return "{}";
-		
-		StringBuilder result = new StringBuilder();
-		result.append('{');
-		boolean first = true;
-		for (Map.Entry<TypeParameter, StoredType> entry : mapping.entrySet()) {
-			if (first) {
-				first = false;
-			} else {
-				result.append(", ");
-			}
-			result.append(entry.getKey().toString()).append(": ").append(entry.getValue());
-		}
-		result.append('}');
-		return result.toString();
-	}
+    
+    public static final GenericMapper EMPTY = new GenericMapper(CodePosition.BUILTIN, null, Collections
+            .emptyMap());
+    
+    public final CodePosition position;
+    public final GlobalTypeRegistry registry;
+    private final Map<TypeParameter, StoredType> mapping;
+    
+    public GenericMapper(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+        if(mapping == null)
+            throw new IllegalArgumentException();
+        
+        this.position = position;
+        this.registry = registry;
+        this.mapping = mapping;
+    }
+    
+    public Map<TypeParameter, StoredType> getMapping() {
+        return mapping;
+    }
+    
+    public StoredType map(StoredType original) {
+        return mapping.isEmpty() ? original : original.instance(this);
+    }
+    
+    public StoredType[] map(StoredType[] original) {
+        if(mapping.isEmpty() || original.length == 0)
+            return original;
+        
+        StoredType[] mapped = new StoredType[original.length];
+        for(int i = 0; i < original.length; i++)
+            mapped[i] = original[i].instance(this);
+        return mapped;
+    }
+    
+    public StoredType map(GenericTypeID type) {
+        //if (!mapping.containsKey(type.parameter))
+        //	throw new IllegalStateException("No mapping found for type " + type);
+        
+        return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type.stored();
+    }
+    
+    public FunctionHeader map(FunctionHeader original) {
+        return mapping.isEmpty() ? original : original.withGenericArguments(this);
+    }
+    
+    public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+        Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
+        mapping.forEach((typeParameter, storedType) -> {
+            if(resultMap.containsKey(typeParameter)) {
+                if(storedType.type instanceof GenericTypeID && ((GenericTypeID) storedType.type).parameter == typeParameter) {
+                    return;
+                }
+            }
+            resultMap.put(typeParameter, storedType);
+        });
+        
+        return new GenericMapper(position, registry, resultMap);
+    }
+    
+    public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, TypeParameter[] parameters) {
+        Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
+        for(TypeParameter parameter : parameters)
+            resultMap.put(parameter, new StoredType(registry.getGeneric(parameter), null));
+        return new GenericMapper(position, registry, resultMap);
+    }
+    
+    @Override
+    public String toString() {
+        if(mapping.isEmpty())
+            return "{}";
+        
+        StringBuilder result = new StringBuilder();
+        result.append('{');
+        boolean first = true;
+        for(Map.Entry<TypeParameter, StoredType> entry : mapping.entrySet()) {
+            if(first) {
+                first = false;
+            } else {
+                result.append(", ");
+            }
+            result.append(entry.getKey().toString()).append(": ").append(entry.getValue());
+        }
+        result.append('}');
+        return result.toString();
+    }
 }

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

 		}
 		
 		if (isDestructible() && destructor == null && !(this instanceof ExpansionDefinition)) {
-			System.out.println("Added destructor to " + position);
+			//System.out.println("Added destructor to " + position);
 			destructor = new DestructorMember(position, this, Modifiers.PUBLIC);
 			members.add(destructor);
 		}

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

 	public static boolean hasAccess(int modifiers) {
 		return (modifiers & (PRIVATE | PUBLIC | PROTECTED | INTERNAL)) > 0;
 	}
+    
+    public static String describe(int modifiers) {
+        StringBuilder builder = new StringBuilder();
+        if (isPublic(modifiers)) {
+            builder.append("public");
+        } else if (isPrivate(modifiers)) {
+            builder.append("private");
+        } else if (isProtected(modifiers)) {
+            builder.append("protected");
+        }
+        if (isAbstract(modifiers)) {
+            builder.append(" abstract");
+        } else if (isFinal(modifiers)) {
+            builder.append(" final");
+        } else if (isStatic(modifiers)) {
+            builder.append(" static");
+        }
+        return builder.toString();
+    }
+    
 }

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationProcessor;
 import org.openzen.zenscript.codemodel.context.ModuleContext;
 	public final List<ExpansionDefinition> expansions;
 	public final AnnotationDefinition[] annotations;
 	public final StorageType[] storageTypes;
+	public final IZSLogger logger;
 	
 	public SemanticModule(
-			Module module,
-			SemanticModule[] dependencies,
-			FunctionParameter[] parameters,
-			State state,
-			ZSPackage rootPackage,
-			ZSPackage modulePackage,
-			PackageDefinitions definitions,
-			List<ScriptBlock> scripts,
-			GlobalTypeRegistry registry,
-			List<ExpansionDefinition> expansions,
-			AnnotationDefinition[] annotations,
-			StorageType[] storageTypes)
+	        Module module,
+            SemanticModule[] dependencies,
+            FunctionParameter[] parameters,
+            State state,
+            ZSPackage rootPackage,
+            ZSPackage modulePackage,
+            PackageDefinitions definitions,
+            List<ScriptBlock> scripts,
+            GlobalTypeRegistry registry,
+            List<ExpansionDefinition> expansions,
+            AnnotationDefinition[] annotations,
+            StorageType[] storageTypes,
+            IZSLogger logger)
 	{
 		this.name = module.name;
 		this.module = module;
 		this.expansions = expansions;
 		this.annotations = annotations;
 		this.storageTypes = storageTypes;
-	}
+        this.logger = logger;
+    }
 	
 	public boolean isValid() {
 		return state != State.INVALID;
 				registry,
 				expansions,
 				annotations,
-				storageTypes);
+				storageTypes,
+                logger);
 	}
 	
 	public ModuleContext getContext() {

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

  */
 package org.openzen.zenscript.codemodel.annotations;
 
-import java.util.Collections;
-import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 
+import java.util.Collections;
+import java.util.List;
+
 /**
  *
  * @author Hoofdgebruiker
 public class NativeAnnotationDefinition implements AnnotationDefinition {
 	public static final NativeAnnotationDefinition INSTANCE = new NativeAnnotationDefinition();
 	
-	private static final List<FunctionHeader> INITIALIZERS = Collections.singletonList(
+	private final List<FunctionHeader> INITIALIZERS = Collections.singletonList(
 			new FunctionHeader(BasicTypeID.VOID, StringTypeID.UNIQUE));
 	
 	private NativeAnnotationDefinition() {}

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

 	public void serialize(CodeSerializationOutput output, HighLevelDefinition definition, TypeContext context) {
 		output.writeString(identifier);
 	}
+
+	public String getIdentifier() {
+		return identifier;
+	}
 }

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

 import java.util.Arrays;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.*;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.*;
 
 /**
  *
 		if (arguments.length < header.parameters.length) {
 			Expression[] newArguments = Arrays.copyOf(arguments, header.parameters.length);
 			for (int i = arguments.length; i < header.parameters.length; i++) {
-				if (header.parameters[i].defaultValue == null)
-					newArguments[i] = new InvalidExpression(position, header.parameters[i].type, CompileExceptionCode.MISSING_PARAMETER, "Parameter missing and no default value specified");
-				else
-					newArguments[i] = header.parameters[i].defaultValue;
+                final FunctionParameter parameter = header.parameters[i];
+                if (parameter.defaultValue == null) {
+				    if(parameter.variadic) {
+				        newArguments[i] = new ArrayExpression(position, Expression.NONE, parameter.type);
+                    } else {
+                        newArguments[i] = new InvalidExpression(position, parameter.type, CompileExceptionCode.MISSING_PARAMETER, "Parameter missing and no default value specified");
+                    }
+                } else {
+                    newArguments[i] = parameter.defaultValue;
+                }
 			}
 			result = new CallArguments(typeArguments, newArguments);
 		}

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

 	}
 	
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
 		TypeMembers members = scope.getTypeMembers(type);
 		IPartialExpression result = members.getMemberExpression(position, scope, this, name, false);
 		if (result == null)
-			System.out.println("No such member: " + name.name);
+		    throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "No such member: " + name.name);
 		return result;
 	}
 	

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

  */
 package org.openzen.zenscript.codemodel.generic;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
+
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.type.TypeID;
 		}
 		return result.toString();
 	}
-	
-	@Override
+    
+    @Override
+    public boolean equals(Object o) {
+        if(this == o)
+            return true;
+        if(o == null || getClass() != o.getClass())
+            return false;
+        
+        TypeParameter that = (TypeParameter) o;
+        
+        if(!name.equals(that.name))
+            return false;
+        if(!Objects.equals(storage, that.storage))
+            return false;
+        return bounds.equals(that.bounds);
+    }
+    
+    @Override
+    public int hashCode() {
+        int result = name.hashCode();
+        result = 31 * result + (storage != null ? storage.hashCode() : 0);
+        result = 31 * result + bounds.hashCode();
+        return result;
+    }
+    
+    @Override
 	public String toString() {
 		return name + "@" + position.toShortString();
 	}

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

 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 
+import java.util.*;
+
 /**
  *
  * @author Hoofdgebruiker
 	public Expression callStatic(CodePosition position, TypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		return new CallStaticExpression(position, target, this, instancedHeader, arguments);
 	}
+    
+    @Override
+    public boolean equals(Object o) {
+        if(this == o)
+            return true;
+        if(o == null || getClass() != o.getClass())
+            return false;
+        
+        FunctionalMemberRef that = (FunctionalMemberRef) o;
+        
+        if(!target.equals(that.target))
+            return false;
+        if(!header.equals(that.header))
+            return false;
+        if(!type.equals(that.type))
+            return false;
+        return Objects.equals(mapper, that.mapper);
+    }
+    
+    @Override
+    public int hashCode() {
+        int result = target.hashCode();
+        result = 31 * result + header.hashCode();
+        result = 31 * result + type.hashCode();
+        result = 31 * result + (mapper != null ? mapper.hashCode() : 0);
+        return result;
+    }
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.expression.CallArguments;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
-import org.openzen.zenscript.codemodel.expression.GlobalExpression;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 	public StoredType[] getTypeArguments() {
 		return typeArguments;
 	}
+
+	@Override
+	public IPartialExpression capture(CodePosition position, LambdaClosure closure) {
+		return this;
+	}
 }

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

 				// ignore this here
 			}
 		}
-		if (results.isEmpty())
-			System.out.println("!");
+		//if (results.isEmpty())
+		//	System.out.println("!");
 		return results;
 	}
 

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialGlobalExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
-import org.openzen.zenscript.codemodel.GenericName;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
 /**
  *
  * @author Hoofdgebruiker
 	private final LocalMemberCache memberCache;
 	private final Map<String, ISymbol> globals;
 	private final TypeMemberPreparer preparer;
-	
+
+	public FileScope(
+			TypeResolutionContext context,
+			List<ExpansionDefinition> expansions,
+			Map<String, ISymbol> globals) {
+		this(context, expansions, globals, member -> {
+		});
+	}
+
 	public FileScope(
 			TypeResolutionContext context,
 			List<ExpansionDefinition> expansions,

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

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
 			normalized[i++] = statement.normalize(scope, modified);
 		return new BlockStatement(position, normalized);
 	}
+
+	@Override
+	public StoredType getReturnType() {
+		final List<StoredType> collect = Arrays.stream(statements)
+				.map(Statement::getReturnType)
+				.filter(Objects::nonNull)
+				.distinct()
+				.collect(Collectors.toList());
+		if(collect.isEmpty())
+			return super.getReturnType();
+		if(collect.size() == 1)
+			return collect.get(0);
+
+		final long count = collect.stream().map(s -> s.type).distinct().count();
+		if(count == 1L)
+			return collect.get(0);
+
+		else
+			//TODO make this real?
+			throw new IllegalStateException("More than one possible storedType: " + count);
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 		result.content = content.normalize(scope, modified.concat(this, result));
 		return result;
 	}
+
+	@Override
+	public StoredType getReturnType() {
+		return content.getReturnType();
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 		result.content = content.normalize(scope, modified.concat(this, result));
 		return result;
 	}
+
+	@Override
+	public StoredType getReturnType() {
+		return content.getReturnType();
+	}
 }

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

 				onThen.normalize(scope, modified),
 				onElse == null ? null : onElse.normalize(scope, modified));
 	}
+
+	@Override
+	public StoredType getReturnType() {
+		final StoredType thenType = onThen.getReturnType();
+		if(onElse == null)
+			return thenType;
+		final StoredType elseType = onElse.getReturnType();
+		if(thenType == elseType)
+			return thenType;
+
+		if(thenType == null)
+			return elseType;
+		if(elseType == null)
+			return thenType;
+
+		if(thenType.type != elseType.type)
+			//TODO make this real?
+			throw new IllegalStateException("If and Else return different things?!?");
+		return thenType;
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
 	
 	@Override
 	public StoredType getReturnType() {
-		return value.type;
+		return value != null ? value.type : BasicTypeID.VOID.stored();
 	}
 	
 	@Override

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

 package org.openzen.zenscript.codemodel.statement;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 		}
 		return result;
 	}
+
+	@Override
+	public StoredType getReturnType() {
+		//return super.getReturnType();
+		final List<StoredType> collect = cases.stream()
+				.flatMap(aCase -> Arrays.stream(aCase.statements))
+				.map(Statement::getReturnType)
+				.filter(Objects::nonNull)
+				.collect(Collectors.toList());
+
+		if(collect.isEmpty())
+			return null;
+
+		if(collect.size() == 1)
+			return collect.get(0);
+
+		final long c = collect.stream().map(s -> s.type).distinct().count();
+		if(c == 1)
+			return collect.get(0);
+		else
+			//TODO make this real
+			throw new IllegalStateException("Too many possible types: " + c);
+	}
 }

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

 import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 		Statement tFinallyClause = finallyClause == null ? null : finallyClause.normalize(scope, modified);
 		return new TryCatchStatement(position, tResource, tContent, tCatchClauses, tFinallyClause);
 	}
+
+	@Override
+	public StoredType getReturnType() {
+		if(finallyClause != null && finallyClause.getReturnType() != null)
+			return finallyClause.getReturnType();
+
+		final StoredType contentType = content.getReturnType();
+		//TODO check catch clauses and do stuff I guess?
+		return contentType;
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 		result.content = content.normalize(scope, modified.concat(this, result));
 		return result;
 	}
+
+	@Override
+	public StoredType getReturnType() {
+		return content.getReturnType();
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import org.openzen.zenscript.codemodel.GenericName;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
 /**
  *
  * @author Hoofdgebruiker
 		if (typeArguments == null)
 			throw new NullPointerException("typeParameters cannot be null");
 		if (typeArguments.length != definition.getNumberOfGenericParameters())
-			throw new IllegalArgumentException("Wrong number of type parameters!");
+			throw new IllegalArgumentException("Wrong number of type parameters! " + definition.name + " expected: " + definition.getNumberOfGenericParameters() + " got: " + typeArguments.length);
 		if (definition.isInnerDefinition() && !definition.isStatic() && outer == null)
 			throw new IllegalArgumentException("Inner definition requires outer instance");
 		if ((!definition.isInnerDefinition() || definition.isStatic()) && outer != null)
 		DefinitionTypeID current = this;
 		do {
 			if (current.typeArguments != null) {
-				if (current.definition.typeParameters == null)
-					System.out.println("Type parameters but no generic parameters");
-				else
-					for (int i = 0; i < current.typeArguments.length; i++)
-						mapping.put(current.definition.typeParameters[i], current.typeArguments[i]);
-			}
+                if(current.definition.typeParameters != null) {
+                    for (int i = 0; i < current.typeArguments.length; i++)
+                        mapping.put(current.definition.typeParameters[i], current.typeArguments[i]);
+                }//else {
+                //    System.out.println("Type parameters but no generic parameters");
+                //}
+            }
 
 			current = current.outer;
 		} while (current != null && !current.definition.isStatic());

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

 			return false;
 		}
 		final GenericTypeID other = (GenericTypeID) obj;
-		return this.parameter == other.parameter;
+		return this.parameter.equals(other.parameter);
 	}
 	
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 			return id;
 		}
 	}
+
+	public Collection<DefinitionTypeID> getDefinitions() {
+		return definitionTypes.keySet();
+	}
 }

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

 	public String toString(StorageTag storage) {
 		return baseType.toString(storage) + '?';
 	}
+    
+    @Override
+    public boolean isGeneric() {
+        return baseType.isGeneric();
+    }
 }

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

+package org.openzen.zenscript.codemodel.type.member;
+
+import org.openzen.zenscript.codemodel.type.*;
+
+import java.util.Arrays;
+
+public class TagRemovingTypeVisitor implements TypeVisitor<StoredType> {
+    
+    private final LocalMemberCache cache;
+    
+    public TagRemovingTypeVisitor(LocalMemberCache cache) {
+        
+        this.cache = cache;
+    }
+    
+    @Override
+    public StoredType visitBasic(BasicTypeID basic) {
+        return basic.stored;
+    }
+    
+    @Override
+    public StoredType visitString(StringTypeID string) {
+        return string.stored();
+    }
+    
+    @Override
+    public StoredType visitArray(ArrayTypeID array) {
+        return new ArrayTypeID(cache.getRegistry(), array.elementType.type.accept(this), array.dimension).stored();
+    }
+    
+    @Override
+    public StoredType visitAssoc(AssocTypeID assoc) {
+        return new AssocTypeID(cache.getRegistry(), assoc.keyType.type.accept(this), assoc.valueType.type.accept(this)).stored();
+    }
+    
+    @Override
+    public StoredType visitGenericMap(GenericMapTypeID map) {
+        return new GenericMapTypeID(cache.getRegistry(), map.value.type.accept(this), map.key).stored();
+    }
+    
+    @Override
+    public StoredType visitIterator(IteratorTypeID iterator) {
+        return new IteratorTypeID(cache.getRegistry(), Arrays.stream(iterator.iteratorTypes).map(storedType -> storedType.type).map(typeID -> typeID.accept(this)).toArray(StoredType[]::new)).stored();
+    }
+    
+    @Override
+    public StoredType visitFunction(FunctionTypeID function) {
+        return function.stored();
+    }
+    
+    @Override
+    public StoredType visitDefinition(DefinitionTypeID definition) {
+        return definition.stored();
+    }
+    
+    @Override
+    public StoredType visitGeneric(GenericTypeID generic) {
+        return generic.stored();
+    }
+    
+    @Override
+    public StoredType visitRange(RangeTypeID range) {
+        return new RangeTypeID(cache.getRegistry(), range.baseType.type.accept(this)).stored;
+    }
+    
+    @Override
+    public StoredType visitOptional(OptionalTypeID type) {
+        return new OptionalTypeID(cache.getRegistry(), type.baseType.accept(this).type).stored();
+    }
+}

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

 		if (definitionType.superType != null) {
 			cache.get(definitionType.superType.stored(type.getSpecifiedStorage()))
 					.copyMembersTo(members, TypeMemberPriority.INHERITED);
+		} else if(definition.getSuperType() != null) {
+			cache.get(definition.getSuperType().stored(type.getSpecifiedStorage()))
+					.copyMembersTo(members, TypeMemberPriority.INHERITED);
 		} else {
 			getter(definition, OBJECT_HASHCODE, "objectHashCode", INT.stored);
 		}

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

  */
 package org.openzen.zenscript.codemodel.type.member;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.CompareType;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.ConstExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.CompareType;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.expression.ConstExpression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
-import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
 /**
  *
  * @author Hoofdgebruiker
 	
 	public FunctionalMemberRef selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) throws CompileException {
 		// try to match with exact types
+        List<TypeMember<FunctionalMemberRef>> possibleMethods = new ArrayList<>();
 		for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
 			FunctionHeader header = method.member.getHeader().instanceForCall(position, scope.getTypeRegistry(), arguments);
 			if (header.matchesExactly(position, arguments, scope))
-				return method.member;
+			    possibleMethods.add(method);
 		}
-		
+        if (!possibleMethods.isEmpty()) {
+            TypeMember<FunctionalMemberRef> selectedMethod = null;
+            for (TypeMember<FunctionalMemberRef> method : possibleMethods) {
+                if (selectedMethod == null) {
+                    selectedMethod = method;
+                    continue;
+                }
+                
+                selectedMethod = selectedMethod.resolve(method);
+            }
+            if (selectedMethod != null)
+                return selectedMethod.member;
+        }
 		// try to match with approximate types
-		FunctionalMemberRef selected = null;
+		TypeMember<FunctionalMemberRef> selected = null;
 		for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			if (!header.matchesImplicitly(position, arguments, scope))
 				continue;
 			
-			if (selected != null) {
+			if (selected == null) {
+				selected = method;
+			} else if (selected.member.equals(method.member)) {
+                selected = selected.resolve(method);
+            } else if(selected.priority == method.priority){
 				StringBuilder explanation = new StringBuilder();
-				FunctionHeader selectedHeader = selected.getHeader().instanceForCall(position, scope.getTypeRegistry(), arguments);
+				FunctionHeader selectedHeader = selected.member.getHeader().instanceForCall(position, scope.getTypeRegistry(), arguments);
 				explanation.append("Function A: ").append(selectedHeader.toString()).append("\n");
 				explanation.append("Function B: ").append(header.toString());
 				throw new CompileException(position, CompileExceptionCode.CALL_AMBIGUOUS, "Ambiguous call; multiple methods match:\n" + explanation.toString());
+			} else {
+				//For example:
+				//Child overrides parent: Priority.Specified vs. Priority.Inherited
+				selected = selected.resolve(method);
 			}
-			
-			selected = method.member;
 		}
 		
 		if (selected == null) {
 			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching method found for " + name + ":\n" + message.toString());
 		}
 		
-		return selected;
+		return selected.member;
 	}
 	
 	public FunctionalMemberRef getOverride(CodePosition position, TypeScope scope, FunctionalMember member) throws CompileException {

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

  */
 package org.openzen.zenscript.codemodel.type.member;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.CompareType;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.expression.CallArguments;
-import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
-import org.openzen.zenscript.codemodel.expression.NullExpression;
-import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
-import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
-import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinition;
-import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
-import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.partial.PartialMemberGroupExpression;
-import org.openzen.zenscript.codemodel.partial.PartialStaticMemberGroupExpression;
-import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
-import org.openzen.zenscript.codemodel.partial.PartialVariantOptionExpression;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.GenericName;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.member.ref.*;
+import org.openzen.zenscript.codemodel.partial.*;
 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.*;
+
+import java.util.*;
 
 /**
  *
 	
 	public boolean extendsOrImplements(TypeID other) {
 		other = other.getNormalized();
+		checkBoundaries:
+		if(this.type.type instanceof DefinitionTypeID && other instanceof DefinitionTypeID) {
+			DefinitionTypeID thisTypeId = (DefinitionTypeID) this.type.type;
+			DefinitionTypeID otherTypeId = (DefinitionTypeID) other;
+
+			if(thisTypeId.definition != otherTypeId.definition){
+				break checkBoundaries;
+			}
+
+			if(thisTypeId.definition.typeParameters.length != otherTypeId.typeArguments.length){
+				break checkBoundaries;
+			}
+
+			for (int i = 0; i < thisTypeId.definition.typeParameters.length; i++) {
+				final TypeID type = otherTypeId.typeArguments[i].type;
+				if (type == BasicTypeID.UNDETERMINED) {
+					continue;
+				}
+				if (type instanceof InvalidTypeID && ((InvalidTypeID) type).code == CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE) {
+					continue;
+				}
+				if (thisTypeId.definition.typeParameters[i].matches(cache, type)) {
+					continue;
+				}
+				break checkBoundaries;
+			}
+			return true;
+		}
+
+
 		TypeID superType = type.type.getSuperType(cache.getRegistry());
 		if (superType != null) {
 			if (superType == other)
 	
 	public void copyMembersTo(TypeMembers other, TypeMemberPriority priority) {
 		other.casters.addAll(casters);
-		other.iterators.addAll(iterators);
+        for(TypeMember<IteratorMemberRef> iterator : iterators) {
+            other.addIterator(iterator.member, priority);
+        }
 		
 		for (Map.Entry<String, EnumConstantMember> entry : enumMembers.entrySet())
 			other.addEnumMember(entry.getValue(), priority);
 			return other;
 		if (cache.get(other).canCastImplicit(type))
 			return type;
-		
+
+
+		for (TypeMember<ImplementationMemberRef> implementation : this.implementations) {
+			final StoredType union = cache.get(implementation.member.implementsType).union(other);
+			if(union != null)
+				return union;
+		}
+
+		if(this.type.type instanceof ArrayTypeID && other.type instanceof ArrayTypeID) {
+			ArrayTypeID thisArray = (ArrayTypeID) this.type.type;
+			ArrayTypeID otherArray = (ArrayTypeID) other.type;
+
+			if(thisArray.dimension == otherArray.dimension) {
+				final StoredType union = cache.get(thisArray.elementType).union(otherArray.elementType);
+				if(union != null) {
+					return getTypeRegistry().getArray(union, thisArray.dimension).stored();
+				}
+			}
+		}
+
+
 		return null;
 	}
 	
 			return true;
 		if (type.isOptional() && areEquivalent(type.withoutOptional(), toType))
 			return true;
-		
-		return getImplicitCaster(toType) != null || extendsOrImplements(toType.type);
+   
+		if( getImplicitCaster(toType) != null || extendsOrImplements(toType.type))
+		    return true;
+
+		if(type.type.isGeneric() && type.type instanceof GenericTypeID) {
+			final GenericTypeID genericTypeID = (GenericTypeID) type.type;
+			if(genericTypeID.parameter.matches(cache, toType.type)) {
+				return true;
+			}
+		}
+
+
+        final StoredType accept = type.type.accept(new TagRemovingTypeVisitor(cache));
+
+        if(!this.type.type.equals(accept.type) && cache.get(accept).canCastImplicit(toType)){
+            return true;
+        }
+        return false;
 	}
 	
 	private boolean areEquivalent(StoredType fromType, StoredType toType) {
-		if (fromType == toType)
+		if (fromType == toType || fromType.equals(toType))
 			return true;
 		if (!fromType.getActualStorage().canCastTo(toType.getActualStorage()) && !toType.getActualStorage().canCastFrom(fromType.getActualStorage()))
 			return false;
 		
-		return fromType.type == toType.type;
+		return fromType.type.equals(toType.type);
 	}
 	
 	public CasterMemberRef getImplicitCaster(StoredType toType) {
 			if (implementation.member.implementsType.type.getNormalized() == toType.type)
 				return castEquivalent(position, new InterfaceCastExpression(position, value, implementation.member), toType);
 		}
-		if (extendsType(toType.type))
+		if (extendsOrImplements(toType.type))
 			return new SupertypeCastExpression(position, value, toType);
 		
 		return new InvalidExpression(position, toType, CompileExceptionCode.INVALID_CAST, "Could not cast " + toString() + " to " + toType);
 		if (this.canCastImplicit(toType))
 			return castImplicit(position, value, toType, false);
 		
-		for (TypeMember<CasterMemberRef> caster : casters)
+        final TypeMembers typeMembers = cache.get(type.type.accept(new TagRemovingTypeVisitor(cache)));
+        if(this.type.type != typeMembers.type.type && typeMembers.canCast(toType)) {
+            return typeMembers.castExplicit(position, value, toType, optional);
+        }
+        
+        for (TypeMember<CasterMemberRef> caster : casters)
 			if (areEquivalent(caster.member.toType, toType))
 				return castEquivalent(position, caster.member.cast(position, value, false), toType);
 		

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

  */
 package org.openzen.zenscript.compiler;
 
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 
 /**
  * @author Hoofdgebruiker
  */
 public interface Target {
-	public ZenCodeCompiler createCompiler(SemanticModule module);
+	public ZenCodeCompiler createCompiler(SemanticModule module, IZSLogger logger);
 	
 	public String getModule();
 	

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 java.util.Map;
 import org.json.JSONObject;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.javabytecode.JavaBytecodeModule;
 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;
 import org.openzen.zenscript.javasource.JavaSourceModule;
 
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 /**
  *
  * @author Hoofdgebruiker
 		}
 
 		@Override
-		public ZenCodeCompiler createCompiler(SemanticModule module) {
-			return new JavaSourceZenCompiler(output, module.registry);
+		public ZenCodeCompiler createCompiler(SemanticModule module, IZSLogger logger) {
+			return new JavaSourceZenCompiler(output, module.registry, logger);
 		}
 
 		@Override
 		
 		public final GlobalTypeRegistry registry;
 		private final SimpleJavaCompileSpace space;
+		private final IZSLogger logger;
 		
-		public JavaSourceZenCompiler(File output, GlobalTypeRegistry registry) {
+		public JavaSourceZenCompiler(File output, GlobalTypeRegistry registry, IZSLogger logger) {
 			this.output = output;
 			compiler = new JavaSourceCompiler(registry);
 			this.registry = registry;
 			space = new SimpleJavaCompileSpace(registry);
-		}
+            this.logger = logger;
+        }
 
 		@Override
 		public void addModule(SemanticModule module) {
-			JavaSourceModule result = compiler.compile(module, space, module.modulePackage.fullName);
+			JavaSourceModule result = compiler.compile(logger, module, space, module.modulePackage.fullName);
 			writeMappings(result);
 			
 			modules.add(result);
 		}
 
 		@Override
-		public ZenCodeCompiler createCompiler(SemanticModule module) {
-			return new JavaBytecodeJarCompiler();
+		public ZenCodeCompiler createCompiler(SemanticModule module, IZSLogger logger) {
+			return new JavaBytecodeJarCompiler(logger);
 		}
 
 		@Override
 		private final ZSPackage stdlib = new ZSPackage(root, "stdlib");
 		public final GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
 		
-		private final JavaCompiler compiler = new JavaCompiler();
+		private final JavaCompiler compiler;
 		private final List<JavaBytecodeModule> modules = new ArrayList<>();
 		private final SimpleJavaCompileSpace space = new SimpleJavaCompileSpace(registry);
-
-		@Override
+        private final IZSLogger logger;
+        
+        public JavaBytecodeJarCompiler(IZSLogger logger) {
+            this.logger = logger;
+            compiler = new JavaCompiler(logger);
+        }
+        
+        @Override
 		public void addModule(SemanticModule module) {
 			JavaBytecodeModule result = compiler.compile(module.modulePackage.fullName, module, space);
 			modules.add(result);
 
 		@Override
 		public void run() {
-			JavaBytecodeRunUnit unit = new JavaBytecodeRunUnit();
+			JavaBytecodeRunUnit unit = new JavaBytecodeRunUnit(logger);
 			for (JavaBytecodeModule module : modules)
 				unit.add(module);
 			//unit.add(compiler.helpers);
-			unit.run();
-		}
+            try {
+                unit.run();
+            } catch(ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        }
 	}
 }

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

 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.constructor.module.SourceModuleReference;
 import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
+import org.openzen.zenscript.constructor.module.logging.*;
 
 public class Main {
     /**
 			return;
 		}
 		
-		Consumer<CompileException> exceptionLogger = exception -> System.err.println(exception.toString());
+        ModuleLogger exceptionLogger = new EmptyModuleLogger();
 		
 		File currentDirectory = new File(arguments.directory);
 		ZSPackage root = ZSPackage.createRoot();

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

 import java.util.Stack;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.constructor.module.logging.*;
 
 /**
  *
 	private final Stack<String> compilingModulesStack = new Stack<>();
 	
 	private final GlobalTypeRegistry registry;
-	private final Consumer<CompileException> exceptionLogger;
+	private final ModuleLogger exceptionLogger;
 	
-	public ModuleLoader(GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+	public ModuleLoader(GlobalTypeRegistry registry, ModuleLogger exceptionLogger) {
 		this.registry = registry;
 		this.exceptionLogger = exceptionLogger;
 	}

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

 import org.json.JSONObject;
 import org.json.JSONTokener;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 	public final String packageName;
 	public final String javaPackageName;
 	public final String host;
-	private final Consumer<CompileException> exceptionLogger;
+	//private final CompileExceptionLogger exceptionLogger;
 	
-	public ParsedModule(String name, File directory, File moduleFile, Consumer<CompileException> exceptionLogger) throws IOException {
+	public ParsedModule(String name, File directory, File moduleFile, CompileExceptionLogger exceptionLogger) throws IOException {
 		this.name = name;
 		this.sourceDirectory = new File(directory, "src");
-		this.exceptionLogger = exceptionLogger;
+		//this.exceptionLogger = exceptionLogger;
 		
 		BufferedInputStream input = new BufferedInputStream(new FileInputStream(moduleFile));
 		JSONObject json = new JSONObject(new JSONTokener(input));

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

 import org.openzen.zenscript.constructor.module.directory.SourceDirectoryPackage;
 import java.io.File;
 import java.io.IOException;
+import java.lang.*;
+import java.lang.String;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.function.Consumer;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.codemodel.type.TypeSymbol;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.constructor.module.logging.*;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.ParsedFile;
 
 	}
 
 	@Override
-	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, ModuleLogger exceptionLogger) {
 		if (!directory.exists())
 			throw new ConstructorException("Error: module directory not found: " + directory);
 		

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

 
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.constructor.module.logging.*;
 
 /**
  *
 public interface ModuleReference {
 	public String getName();
 	
-	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger);
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, ModuleLogger exceptionLogger);
 	
 	public SourcePackage getRootPackage();
 }

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

 import java.util.Map;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 	
 	public SourcePackage getRootPackage();
 	
-	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger);
+	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, CompileExceptionLogger exceptionLogger);
 	
 	public Map<String, ISymbol> getGlobals(SemanticModule module);
 }

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.constructor.ConstructorException;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.constructor.module.logging.*;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.ParsedFile;
 	}
 
 	@Override
-	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
-		SemanticModule[] dependencies = module.loadDependencies(loader, registry, exceptionLogger);
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, ModuleLogger logger) {
+		SemanticModule[] dependencies = module.loadDependencies(loader, registry, logger);
 
 		ModuleSpace space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
 		for (SemanticModule module : dependencies) {
 		Module module = new Module(getName());
 		CompilingPackage compilingPackage = new CompilingPackage(pkg, module);
 
-		ParsedFile[] parsedFiles = parse(compilingPackage, exceptionLogger);
-		SemanticModule result = ParsedFile.compileSyntaxToSemantic(dependencies, compilingPackage, parsedFiles, space, FunctionParameter.NONE, exceptionLogger);
+		ParsedFile[] parsedFiles = parse(compilingPackage, logger);
+		SemanticModule result = ParsedFile.compileSyntaxToSemantic(dependencies, compilingPackage, parsedFiles, space, FunctionParameter.NONE, logger);
 		result.globals.putAll(this.module.getGlobals(result));
 		return result;
 	}
 		return module.getRootPackage();
 	}
 	
-	public ParsedFile[] parse(CompilingPackage compilingPackage, Consumer<CompileException> exceptionLogger) {
+	public ParsedFile[] parse(CompilingPackage compilingPackage, CompileExceptionLogger exceptionLogger) {
 		// TODO: load bracket parsers from host plugins
 		List<ParsedFile> files = new ArrayList<>();
 		parse(files, compilingPackage, null, module.getRootPackage(), exceptionLogger);
 		return files.toArray(new ParsedFile[files.size()]);
 	}
 	
-	private static void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, SourcePackage directory, Consumer<CompileException> exceptionLogger) {
+	private static void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, SourcePackage directory, CompileExceptionLogger exceptionLogger) {
 		for (SourceFile file : directory.getFiles()) {
 			try {
 				files.add(ParsedFile.parse(pkg, bracketParser, file));
 			} catch (ParseException ex) {
-				exceptionLogger.accept(new CompileException(ex.position, CompileExceptionCode.PARSE_ERROR, ex.message));
+				exceptionLogger.logCompileException(new CompileException(ex.position, CompileExceptionCode.PARSE_ERROR, ex.message));
 			}
 		}
 		for (SourcePackage subpkg : directory.getSubPackages()) {

Constructor/src/main/java/org/openzen/zenscript/constructor/module/directory/DirectorySourceModule.java

 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.codemodel.SemanticModule;
 	}
 
 	@Override
-	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, CompileExceptionLogger exceptionLogger) {
 		List<String> dependencyNames = new ArrayList<>();
 		if (!isStdLib)
 			dependencyNames.add("stdlib");

Constructor/src/main/java/org/openzen/zenscript/constructor/module/logging/EmptyModuleLogger.java

+package org.openzen.zenscript.constructor.module.logging;
+
+import org.openzen.zencode.shared.*;
+
+public class EmptyModuleLogger implements ModuleLogger {
+    
+    @Override
+    public void logCompileException(CompileException exception) {
+        error(exception.getMessage());
+    }
+    
+    @Override
+    public void info(String message) {
+        System.out.println(message);
+    }
+    
+    @Override
+    public void debug(String message) {
+        System.out.println(message);
+    }
+    
+    @Override
+    public void warning(String message) {
+        System.out.println(message);
+    }
+    
+    @Override
+    public void error(String message) {
+        System.err.println(message);
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        System.err.println(message);
+        throwable.printStackTrace();
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        System.out.println(message);
+        throwable.printStackTrace(System.out);
+    }
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/logging/ModuleLogger.java

+package org.openzen.zenscript.constructor.module.logging;
+
+import org.openzen.zencode.shared.logging.*;
+import org.openzen.zenscript.parser.logger.*;
+
+public interface ModuleLogger extends CompileExceptionLogger, ParserLogger {}

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

 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEModuleType;
 import org.openzen.zenscript.ide.host.IDEPackage;
-import org.openzen.zenscript.validator.Validator;
+import org.openzen.zenscript.ide.host.local.logging.*;
+import org.openzen.zenscript.validator.*;
+import org.openzen.zenscript.validator.logger.*;
 
 /**
  *
 	@Override
 	public void prebuild(ModuleLoader loader, Consumer<IDECodeError> errors) {
 		SemanticModule module = loader.getModule(this.module.getName());
-		Validator.validate(module, entry -> errors.accept(new IDECodeError(null, entry.position, entry.message)));
+		Validator.validate(module, new LocalValidatorLogger(errors));
 	}
 }

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

 import java.util.function.Consumer;
 import live.LiveObject;
 import live.SimpleLiveObject;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.constructor.module.SourceModuleReference;
+import org.openzen.zenscript.constructor.module.logging.*;
 import org.openzen.zenscript.ide.host.IDECodeError;
 import org.openzen.zenscript.ide.host.IDECompileState;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 import org.openzen.zenscript.ide.host.IDETarget;
-import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
-import org.openzen.zenscript.ide.ui.view.output.OutputLine;
+import org.openzen.zenscript.ide.host.local.logging.*;
+import org.openzen.zenscript.ide.ui.view.output.*;
+import org.openzen.zenscript.parser.logger.*;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
+import org.openzen.zenscript.validator.logger.*;
 import stdlib.Strings;
 
 /**
 		ZSPackage root = ZSPackage.createRoot();
 		ZSPackage stdlibPackage = new ZSPackage(root, "stdlib");
 		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlibPackage);
-		
-		ModuleLoader moduleLoader = new ModuleLoader(registry, exception -> {
-			IDESourceFile sourceFile = new LocalSourceFile(exception.position.file);
-			state.addError(sourceFile, new IDECodeError(sourceFile, exception.position, exception.message));
-			
-			String[] lines = Strings.split(exception.getMessage(), '\n');
-			for (String line : lines) {
-				output.accept(new OutputLine(new ErrorOutputSpan(line)));
-			}
-		});
+        final LocalModuleLogger localModuleLogger = new LocalModuleLogger(state, output);
+        ModuleLoader moduleLoader = new ModuleLoader(registry, localModuleLogger);
+        
 		//moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
 		moduleLoader.register("stdlib", new SourceModuleReference(new DirectorySourceModule("stdlib", new File("../../StdLibs/stdlib"), true), true));
 		Set<String> compiledModules = new HashSet<>();
-		
-		Consumer<ValidationLogEntry> validationLogger = entry -> {
-			String[] message = Strings.split(entry.message, '\n');
-			output.accept(new OutputLine(new ErrorOutputSpan(entry.kind + " " + entry.position.toString() + ": " + message[0])));
-			for (int i = 1; i < message.length; i++)
-				output.accept(new OutputLine(new ErrorOutputSpan("    " + message[i])));
-			
-			IDESourceFile sourceFile = new LocalSourceFile(entry.position.file);
-			state.addError(sourceFile, new IDECodeError(sourceFile, entry.position, entry.message));
-		};
-		try {
+        
+        try {
 			for (Library library : project.libraries) {
 				for (ModuleReference module : library.modules)
 					moduleLoader.register(module.getName(), module);
 			}
 			
 			SemanticModule module = moduleLoader.getModule(target.getModule());
-			module = Validator.validate(module.normalize(), validationLogger);
+			module = Validator.validate(module.normalize(), localModuleLogger);
 			
 			if (compile) {
-				ZenCodeCompiler compiler = target.createCompiler(module);
+				ZenCodeCompiler compiler = target.createCompiler(module, localModuleLogger);
 				if (!module.isValid())
 					return compiler;
 
 				SemanticModule stdlib = moduleLoader.getModule("stdlib");
-				stdlib = Validator.validate(stdlib.normalize(), validationLogger);
+				stdlib = Validator.validate(stdlib.normalize(), localModuleLogger);
 				if (!stdlib.isValid())
 					return compiler;
 
 				compiler.addModule(stdlib);
 				compiledModules.add(stdlib.name);
 
-				boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, new Stack<>(), module, validationLogger);
+				boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, new Stack<>(), module, localModuleLogger);
 				if (!isValid)
 					return compiler;
 
 		}
 	}
 	
-	private boolean compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, Stack<String> compilingModules, SemanticModule module, Consumer<ValidationLogEntry> logger) {
+	private boolean compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, Stack<String> compilingModules, SemanticModule module, ValidatorLogger logger) {
 		for (SemanticModule dependency : module.dependencies) {
 			if (compiledModules.contains(dependency.name))
 				continue;

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

+package org.openzen.zenscript.ide.host.local.logging;
+
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.constructor.module.logging.*;
+import org.openzen.zenscript.ide.host.*;
+import org.openzen.zenscript.ide.host.local.*;
+import org.openzen.zenscript.ide.ui.view.output.*;
+import org.openzen.zenscript.validator.*;
+import org.openzen.zenscript.validator.logger.*;
+import stdlib.*;
+
+import java.util.function.*;
+
+public class LocalModuleLogger implements ModuleLogger, ValidatorLogger {
+    
+    private final LocalCompileState state;
+    private final Consumer<OutputLine> output;
+    
+    public LocalModuleLogger(LocalCompileState state, Consumer<OutputLine> output) {
+        this.state = state;
+        this.output = output;
+    }
+    
+    @Override
+    public void logCompileException(CompileException exception) {
+        IDESourceFile sourceFile = new LocalSourceFile(exception.position.file);
+        state.addError(sourceFile, new IDECodeError(sourceFile, exception.position, exception.message));
+        
+        String[] lines = Strings.split(exception.getMessage(), '\n');
+        for(String line : lines) {
+            output.accept(new OutputLine(new ErrorOutputSpan(line)));
+        }
+    }
+    
+    @Override
+    public void info(String message) {
+        output.accept(new OutputLine(new BasicOutputSpan(message)));
+    }
+    
+    @Override
+    public void debug(String message) {
+        output.accept(new OutputLine(new BasicOutputSpan(message)));
+    }
+    
+    @Override
+    public void warning(String message) {
+        output.accept(new OutputLine(new BasicOutputSpan(message)));
+    }
+    
+    @Override
+    public void error(String message) {
+        output.accept(new OutputLine(new ErrorOutputSpan(message)));
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        output.accept(new OutputLine(new ErrorOutputSpan(message)));
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        output.accept(new OutputLine(new BasicOutputSpan(message)));
+    }
+    
+    @Override
+    public void logValidationError(ValidationLogEntry entry) {
+        String[] message = Strings.split(entry.message, '\n');
+        output.accept(new OutputLine(new ErrorOutputSpan(entry.kind + " " + entry.position.toString() + ": " + message[0])));
+        for(int i = 1; i < message.length; i++)
+            output.accept(new OutputLine(new ErrorOutputSpan("    " + message[i])));
+        
+        IDESourceFile sourceFile = new LocalSourceFile(entry.position.file);
+        state.addError(sourceFile, new IDECodeError(sourceFile, entry.position, entry.message));
+    }
+    
+    @Override
+    public void logValidationWarning(ValidationLogEntry warningEntry) {
+        logValidationError(warningEntry);
+    }
+}

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

+package org.openzen.zenscript.ide.host.local.logging;
+
+import org.openzen.zenscript.ide.host.*;
+import org.openzen.zenscript.validator.*;
+import org.openzen.zenscript.validator.logger.*;
+
+import java.util.function.*;
+
+public class LocalValidatorLogger implements ValidatorLogger {
+    
+    private final Consumer<IDECodeError> errors;
+    
+    public LocalValidatorLogger(Consumer<IDECodeError> errors) {
+        this.errors = errors;
+    }
+    
+    @Override
+    public void info(String message) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void debug(String message) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void warning(String message) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void error(String message) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void logValidationError(ValidationLogEntry errorEntry) {
+        logValidationWarning(errorEntry);
+    }
+    
+    @Override
+    public void logValidationWarning(ValidationLogEntry entry) {
+        final IDECodeError ideCodeError = new IDECodeError(null, entry.position, entry.message);
+        errors.accept(ideCodeError);
+    }
+}

JavaAnnotations/src/main/java/org/openzen/zencode/java/StorageTagType.java

+package org.openzen.zencode.java;
+
+public enum StorageTagType {
+    STATIC
+}

JavaAnnotations/src/main/java/org/openzen/zencode/java/ZenCodeStorageTag.java

+package org.openzen.zencode.java;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE_USE)
+public @interface ZenCodeStorageTag {
+    
+    StorageTagType value();
+    
+}

JavaAnnotations/src/main/java/org/openzen/zencode/java/ZenCodeType.java

 	
 	@Retention(RetentionPolicy.RUNTIME)
 	@Target(ElementType.PARAMETER)
-	@interface Optional {}
+	@interface Optional {
+		String value() default "";
+	}
 	
 	@Retention(RetentionPolicy.RUNTIME)
 	@Target(ElementType.PARAMETER)

JavaBytecodeCompiler/build.gradle

 }
 
 dependencies {
-	compile 'org.ow2.asm:asm-debug-all:6.0_BETA'
-	compile project(':CodeModel')
+    compile group: 'org.ow2.asm', name: 'asm', version: '7.2'
+    compile group: 'org.ow2.asm', name: 'asm-commons', version: '7.2'
+    compile project(':CodeModel')
 	compile project(':JavaShared')
 }

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

 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 	private final JavaTypeDescriptorVisitor descriptorVisitor;
 	private int lambdaCounter = 0;
 	
-	public JavaBytecodeContext(JavaBytecodeModule target, JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
-		super(space, modulePackage, basePackage);
+	public JavaBytecodeContext(JavaBytecodeModule target, JavaCompileSpace space, ZSPackage modulePackage, String basePackage, IZSLogger logger) {
+		super(space, modulePackage, basePackage, logger);
 		
 		this.target = target;
 		
 		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(range.baseType), null, null).visitEnd();
 		
 		JavaMethod method = JavaMethod.getConstructor(range.cls, "(" + getDescriptor(range.baseType) + getDescriptor(range.baseType) + ")V", Opcodes.ACC_PUBLIC);
-		JavaWriter constructorWriter = new JavaWriter(CodePosition.GENERATED, rangeWriter, method, null, method.descriptor, null);
+		JavaWriter constructorWriter = new JavaWriter(logger, CodePosition.GENERATED, rangeWriter, method, null, method.descriptor, null);
 		constructorWriter.loadObject(0);
 		constructorWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
 		constructorWriter.loadObject(0);

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 public class JavaBytecodeModule extends JavaCompiledModule {
 	private final Map<String, byte[]> classes = new HashMap<>();
 	private final List<JavaScriptMethod> scripts = new ArrayList<>();
-	
-	public JavaBytecodeModule(Module module, FunctionParameter[] parameters) {
+    private final IZSLogger logger;
+    
+    public JavaBytecodeModule(Module module, FunctionParameter[] parameters, IZSLogger logger) {
 		super(module, parameters);
-	}
+        this.logger = logger;
+    }
 	
 	public void addClass(String name, byte[] bytecode) {
 		if (bytecode == null)
 			return;
-		
-		classes.put(name, bytecode);
+
+		if(name.startsWith("java")) {
+			logger.debug("Warning: Invalid name " + name);
+		} else if(classes.containsKey(name)) {
+			logger.error("Trying to register " + name + " a 2nd time");
+		} else {
+			classes.put(name, bytecode);
+		}
 	}
 	
 	public void addScript(JavaScriptMethod method) {

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

 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.*;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * @author Hoofdgebruiker
 	private final List<JavaParameterInfo> scriptParameterInfo = new ArrayList<>();
 
 	private boolean scriptsWritten = false;
-
-	public void add(JavaBytecodeModule module) {
+	private final IZSLogger logger;
+    
+    public JavaBytecodeRunUnit(IZSLogger logger) {
+        this.logger = logger;
+    }
+    
+    public void add(JavaBytecodeModule module) {
 		scriptsWritten = false;
 
 		for (Map.Entry<String, byte[]> classEntry : module.getClasses().entrySet())
 		}
 	}
 
-	public void run() {
+	public void run() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 		run(Collections.emptyMap(), this.getClass().getClassLoader());
 	}
 
-	public void run(Map<FunctionParameter, Object> arguments) {
+	public void run(Map<FunctionParameter, Object> arguments) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 		run(arguments, this.getClass().getClassLoader());
 	}
 
-	public void run(Map<FunctionParameter, Object> arguments, ClassLoader parentClassLoader) {
+	public void run(Map<FunctionParameter, Object> arguments, ClassLoader parentClassLoader) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
 		writeScripts();
 
 		ScriptClassLoader classLoader = new ScriptClassLoader(parentClassLoader);
 
 			argumentsArray[i] = arguments.get(parameter);
 		}
-		try {
 			Class[] classes = new Class[scriptParameters.size()];
 			for (int i = 0; i < classes.length; i++)
 				classes[i] = loadClass(classLoader, scriptParameterInfo.get(i).typeDescriptor);
 			classLoader.loadClass("Scripts").getMethod("run", classes).invoke(null, argumentsArray);
-		} catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | IllegalAccessException | SecurityException | IllegalArgumentException ex) {
-			Logger.getLogger(JavaBytecodeRunUnit.class.getName()).log(Level.SEVERE, null, ex);
-		}
 	}
 
 	public void dump(File directory) {
 			directory.mkdirs();
 
 		for (Map.Entry<String, byte[]> classEntry : classes.entrySet()) {
-			File output = new File(directory, classEntry.getKey() + ".class");
+			File output = new File(directory, classEntry.getKey().replace('.', File.separatorChar) + ".class");
+			if (!output.getParentFile().exists() && !output.getParentFile().mkdirs()) {
+				//Throw error?
+				continue;
+			}
 			try (FileOutputStream outputStream = new FileOutputStream(output)) {
 				outputStream.write(classEntry.getValue());
 			} catch (IOException ex) {
 		headerBuilder.append(")V");
 
 		JavaMethod runMethod = JavaMethod.getStatic(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", headerBuilder.toString(), Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
-		final JavaWriter runWriter = new JavaWriter(CodePosition.GENERATED, scriptsClassWriter, runMethod, null, null, null);
+		final JavaWriter runWriter = new JavaWriter(logger, CodePosition.GENERATED, scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (JavaScriptMethod method : scripts) {
 			for (int i = 0; i < method.parameters.length; i++) {

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

  */
 package org.openzen.zenscript.javabytecode;
 
-import java.util.HashMap;
-import java.util.Map;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Opcodes;
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.ScriptBlock;
-import org.openzen.zenscript.codemodel.SemanticModule;
-import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
-import org.openzen.zenscript.javabytecode.compiler.JavaScriptFile;
-import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
-import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
-import org.openzen.zenscript.javabytecode.compiler.definitions.JavaDefinitionVisitor;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaCompileSpace;
-import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.javashared.JavaParameterInfo;
-import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
-import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
+import org.objectweb.asm.*;
+import org.openzen.zencode.shared.*;
+import org.openzen.zencode.shared.logging.*;
+import org.openzen.zenscript.codemodel.*;
+import org.openzen.zenscript.codemodel.definition.*;
+import org.openzen.zenscript.codemodel.statement.*;
+import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.javabytecode.compiler.*;
+import org.openzen.zenscript.javabytecode.compiler.definitions.*;
+import org.openzen.zenscript.javashared.*;
+import org.openzen.zenscript.javashared.prepare.*;
+
+import java.io.*;
+import java.util.*;
+import java.util.stream.*;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaCompiler {
-	private int generatedScriptBlockCounter = 0;
-	
-	public JavaCompiler() {}
+    
+    private int generatedScriptBlockCounter = 0;
+	private int expansionCounter = 0;
+	private final IZSLogger logger;
+    
+    public JavaCompiler(IZSLogger logger) {
+        this.logger = logger;
+    }
 	
 	public JavaBytecodeModule compile(String packageName, SemanticModule module, JavaCompileSpace space) {
-		Map<String, JavaScriptFile> scriptBlocks = new HashMap<>();
+		Map<String, JavaScriptFile> scriptBlocks = new LinkedHashMap<>();
+		Set<JavaScriptFile> scriptFilesThatAreActuallyUsedInScripts = new HashSet<>();
 		
-		JavaBytecodeModule target = new JavaBytecodeModule(module.module, module.parameters);
-		JavaBytecodeContext context = new JavaBytecodeContext(target, space, module.modulePackage, packageName);
+		JavaBytecodeModule target = new JavaBytecodeModule(module.module, module.parameters, logger);
+		JavaBytecodeContext context = new JavaBytecodeContext(target, space, module.modulePackage, packageName, logger);
 		context.addModule(module.module, target);
 		
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
-			String filename = getFilename(definition);
-			JavaPrepareDefinitionVisitor definitionPreparer = new JavaPrepareDefinitionVisitor(context, target, filename, null);
-			definition.accept(definitionPreparer);
+			final String className = getClassName(getFilename(definition));
+			final String filename;
+            if(definition instanceof FunctionDefinition) {
+                filename = className;
+            } else {
+                filename = className + "_" + (definition.name == null ? "generated" : definition.name) + "_" + expansionCounter++;
+            }
+            JavaPrepareDefinitionVisitor definitionPreparer = new JavaPrepareDefinitionVisitor(context, target, filename, null, filename);
+            definition.accept(definitionPreparer);
 		}
 		
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, target);
 			definition.accept(memberPreparer);
 		}
-		
-		for (HighLevelDefinition definition : module.definitions.getAll()) {
-			String className = getClassName(definition.position.getFilename());
-			JavaScriptFile scriptFile = getScriptFile(scriptBlocks, definition.pkg.fullName + "/" + className);
-			
-			JavaClass cls = definition instanceof ExpansionDefinition ? context.getJavaExpansionClass(definition) : context.getJavaClass(definition);
-			target.addClass(cls.internalName, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
-		}
+        
+        for(HighLevelDefinition definition : module.definitions.getAll()) {
+            final String internalName;
+            final JavaScriptFile scriptFile;
+            if(definition instanceof FunctionDefinition) {
+                internalName = getClassName(getFilename(definition));
+                scriptFile = getScriptFile(scriptBlocks, module.modulePackage.fullName + "/" + internalName);
+                scriptFilesThatAreActuallyUsedInScripts.add(scriptFile);
+            } else {
+                JavaClass cls = definition instanceof ExpansionDefinition ? context.getJavaExpansionClass(definition) : context
+                        .getJavaClass(definition);
+                scriptFile = getScriptFile(scriptBlocks, cls.fullName);
+                internalName = cls.internalName;
+            }
+            scriptFile.classWriter.visitSource(definition.position.getFilename(), null);
+            target.addClass(internalName, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
+        }
 		
 		FunctionHeader scriptHeader = new FunctionHeader(BasicTypeID.VOID, module.parameters);
 		String scriptDescriptor = context.getMethodDescriptor(scriptHeader);
 			final SourceFile sourceFile = script.file;
 			final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
 			JavaScriptFile scriptFile = getScriptFile(scriptBlocks, script.pkg.fullName + "/" + className);
+			scriptFilesThatAreActuallyUsedInScripts.add(scriptFile);
+			if(sourceFile != null) {
+                scriptFile.classWriter.visitSource(sourceFile.getFilename(), null);
+            }
 
 			String methodName = scriptFile.scriptMethods.isEmpty() ? "run" : "run" + scriptFile.scriptMethods.size();
 
 			JavaMethod method = JavaMethod.getStatic(new JavaClass(context.getPackageName(script.pkg), className, JavaClass.Kind.CLASS), methodName, scriptDescriptor, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 			scriptFile.scriptMethods.add(new JavaScriptMethod(method, module.parameters, javaScriptParameters));
 
-			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(script.module), new JavaWriter(CodePosition.UNKNOWN, visitor, method, null, null, null));
+			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(script.module), new JavaWriter(logger, CodePosition.UNKNOWN, visitor, method, null, null, null));
 			statementVisitor.start();
 			for (Statement statement : script.statements) {
 				statement.accept(statementVisitor);
 				target.addScript(method);
 
 			entry.getValue().classWriter.visitEnd();
-			target.addClass(entry.getKey(), entry.getValue().classWriter.toByteArray());
+			if(scriptFilesThatAreActuallyUsedInScripts.contains(entry.getValue())) {
+				target.addClass(entry.getKey(), entry.getValue().classWriter.toByteArray());
+			}
 		}
 
 		return target;
 	private String getFilename(HighLevelDefinition definition) {
 		SourceFile source = definition.position.file;
 		if (source != null) {
-			int slash = Math.max(source.getFilename().lastIndexOf('/'), source.getFilename().lastIndexOf('\\'));
-			String filename = source.getFilename().substring(slash < 0 ? 0 : slash + 1);
-			filename = filename.substring(0, filename.lastIndexOf('.'));
-			return filename;
+			//int slash = Math.max(source.getFilename().lastIndexOf('/'), source.getFilename().lastIndexOf('\\'));
+			//String filename = source.getFilename().substring(slash < 0 ? 0 : slash + 1);
+			//filename = filename.substring(0, filename.lastIndexOf('.'));
+			//return filename;
+			return source.getFilename();
 		} else {
 			return definition.name == null ? "Expansion" : definition.name;
 		}
 		if (filename == null) {
 			return "generatedBlock" + (generatedScriptBlockCounter++);
 		} else {
-			// TODO: remove special characters
-			return filename.substring(0, filename.lastIndexOf('.')).replace("/", "_");
+            // TODO: find all special characters
+            final String specialCharRegex = Stream.of('/', '\\', '.', ';')
+                    .filter(character -> character != File.separatorChar)
+                    .map(String::valueOf)
+                    .collect(Collectors.joining("", "[", "]"));
+            
+			return filename
+                    .substring(0, filename.lastIndexOf('.')) //remove the .zs part
+                    .replaceAll(specialCharRegex, "_")
+                    .replace('[', '_')
+                    .replace(File.separatorChar, '/');
 		}
 	}
 

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

 	}
 
 	/**
-	 * Checks if an expression can be inlined
+	 * Checks if an expression can be inLined
 	 *
 	 * @param expression Expression to check for.
-	 * @return can expression be inlined
+	 * @return can expression be inLined
 	 */
-	static boolean canBeInlined(Expression expression) {
+	static boolean canBeInLined(Expression expression) {
 		while (expression instanceof StorageCastExpression)
 			expression = ((StorageCastExpression) expression).value;
 
 	 * @param currentArrayType  The current type of the array, reduced during the recursions of the functions
 	 * @param innermostFunction The function that will decide what to add to the array, needs to increase the stack size by one and may not touch the other stacks!
 	 */
-	private static void visitMultiDimArray(JavaWriter javaWriter, int[] sizeLocations, int[] counterLocations, int dim, Type currentArrayType, InnermostFunction innermostFunction) {
+	static void visitMultiDimArray(JavaWriter javaWriter, int[] sizeLocations, int[] counterLocations, int dim, Type currentArrayType, InnermostFunction innermostFunction) {
 		final Label begin = new Label();
 		final Label end = new Label();
 		javaWriter.label(begin);

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaTypeParameterInfo;
 
+import java.util.List;
+
 public class CompilerUtils {
 
 	private CompilerUtils() {}
 	}
 
 	public static boolean isLarge(StoredType type) {
-		return type.type == BasicTypeID.DOUBLE || type.type == BasicTypeID.DOUBLE;
+		return type.type == BasicTypeID.DOUBLE || type.type == BasicTypeID.LONG;
 	}
 	
 	public static int calcAccess(int modifiers) {
 		return out;
 	}
 
-    public static void tagMethodParameters(JavaBytecodeContext context, JavaCompiledModule module, FunctionHeader header, boolean isStatic) {
-		int index = header.getNumberOfTypeParameters();
+    public static void tagMethodParameters(JavaBytecodeContext context, JavaCompiledModule module, FunctionHeader header, boolean isStatic, List<TypeParameter> baseTypeTypeParameters) {
+		int index = isStatic ? 0 : 1;
+
+		for (TypeParameter baseTypeTypeParameter : baseTypeTypeParameters) {
+			module.setTypeParameterInfo(baseTypeTypeParameter, new JavaTypeParameterInfo(index));
+			index++;
+		}
+
 		for (int i = 0; i < header.typeParameters.length; i++) {
 			TypeParameter parameter = header.typeParameters[i];
-			module.setTypeParameterInfo(parameter, new JavaTypeParameterInfo(index++));
+			module.setTypeParameterInfo(parameter, new JavaTypeParameterInfo(index));
+			index++;
 		}
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
             String parameterType = context.getDescriptor(parameter.type);
-            module.setParameterInfo(parameter, new JavaParameterInfo(isStatic ? index : index + 1, parameterType));
+            module.setParameterInfo(parameter, new JavaParameterInfo(index, parameterType));
 			index++;
         }
     }
 
     public static void tagConstructorParameters(JavaBytecodeContext context, JavaCompiledModule module, HighLevelDefinition definition, FunctionHeader header, boolean isEnum) {
+		int index = 1;
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			final JavaField field = new JavaField(context.getJavaClass(definition),
+					"typeOf" + typeParameter.name,
+					"Ljava/lang/Class;",
+					//"Ljava/lang/Class;"
+					"Ljava/lang/Class<T" + typeParameter.name + ";>;"
+			);
+			final JavaTypeParameterInfo info = new JavaTypeParameterInfo(index, field);
+			module.setTypeParameterInfo(typeParameter, info);
+			index++;
+		}
+
+		for (int i = 0; i < header.typeParameters.length; i++) {
+			TypeParameter typeParameter = header.typeParameters[i];
+			final JavaField field = new JavaField(context.getJavaClass(definition),
+					"typeOf" + typeParameter.name,
+					"Ljava/lang/Class;",
+					//"Ljava/lang/Class;"
+					"Ljava/lang/Class<T" + typeParameter.name + ";>;"
+					);
+			final JavaTypeParameterInfo info = new JavaTypeParameterInfo(index, field);
+			module.setTypeParameterInfo(typeParameter, info);
+			index++;
+		}
+		for (int i = 0; i < header.parameters.length; i++) {
+			FunctionParameter parameter = header.parameters[i];
+			String parameterType = context.getDescriptor(parameter.type);
+			module.setParameterInfo(parameter, new JavaParameterInfo(index, parameterType));
+			index++;
+		}
+		/*
 		int index = header.getNumberOfTypeParameters();
 		for (int i = 0; i < definition.typeParameters.length; i++) {
 			JavaTypeParameterInfo info = module.getTypeParameterInfo(definition.typeParameters[i]);
             String parameterType = context.getDescriptor(parameter.type);
 			module.setParameterInfo(parameter, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
         }
+		 */
     }
 
     public static void writeDefaultFieldInitializers(JavaBytecodeContext context, JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {

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

 			default:
 				return null;
 		}
-		writer.dup();
 		
 		if (method != null)
 			writer.invokeStatic(method);

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
 
 import java.util.Map;
-
+@SuppressWarnings("Duplicates")
 public class JavaForeachWriter {
 
 	private final JavaWriter javaWriter;
 	private final Label startLabel;
 	private final Label endLabel;
 	private final JavaStatementVisitor statementVisitor;
+	private final JavaUnboxingTypeVisitor unboxingTypeVisitor;
 
 	public JavaForeachWriter(JavaStatementVisitor statementVisitor, VarStatement[] variables, Statement content, Label start, Label end) {
 		this.statementVisitor = statementVisitor;
 		this.content = content;
 		this.startLabel = start;
 		this.endLabel = end;
-	}
+        this.unboxingTypeVisitor = new JavaUnboxingTypeVisitor(this.javaWriter);
+    }
 
-	public void visitIntRange() {
+	public void visitIntRange(RangeTypeID type) {
+		final String owner = statementVisitor.context.getInternalName(type);
 		javaWriter.dup();
-		javaWriter.getField("zsynthetic/IntRange", "to", "I");
+		javaWriter.getField(owner, "to", "I");
 		javaWriter.swap();
-		javaWriter.getField("zsynthetic/IntRange", "from", "I");
+		javaWriter.getField(owner, "from", "I");
 
 		final int z = javaWriter.getLocalVariable(variables[0].variable).local;
 		javaWriter.storeInt(z);
 	}
 
 	public void visitStringCharacterIterator() {
-		//TODO UNTESTED!
-		javaWriter.invokeSpecial("java/lang/String", "toCharArray()", "()[C");
+        javaWriter.invokeVirtual(JavaMethod.getVirtual(JavaClass.STRING, "toCharArray", "()[C", JavaModifiers.PUBLIC));
 		handleArray(javaWriter.local(int.class), javaWriter.getLocalVariable(variables[0].variable));
 	}
 
 
 		javaWriter.label(startLabel);
 		javaWriter.dup();
-		javaWriter.dup();
 		javaWriter.arrayLength();
-		javaWriter.loadInt(z);
-
-		javaWriter.ifICmpLE(endLabel);
-		javaWriter.loadInt(z);
+        javaWriter.loadInt(z);
+        
+        javaWriter.ifICmpLE(endLabel);
+        javaWriter.dup();
+        javaWriter.loadInt(z);
 
 		javaWriter.arrayLoad(arrayTypeInfo.type);
 		javaWriter.store(arrayTypeInfo.type, arrayTypeInfo.local);
 	}
 
 	public void visitCustomIterator() {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        javaWriter.invokeInterface(JavaMethod.getVirtual(new JavaClass("java.lang", "Iterable", JavaClass.Kind.INTERFACE), "iterator", "()Ljava/util/Iterator;", 0));
+        
+        javaWriter.label(startLabel);
+        javaWriter.dup();
+        javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "hasNext", "()Z", 0));
+        javaWriter.ifEQ(endLabel);
+        javaWriter.dup();
+        javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "next", "()Ljava/lang/Object;", 0));
+        
+        final JavaLocalVariableInfo keyVariable = javaWriter.getLocalVariable(variables[0].variable);
+        this.downCast(0, keyVariable.type);
+        javaWriter.store(keyVariable.type, keyVariable.local);
+        
+        content.accept(statementVisitor);
 	}
 
 	public void visitAssocKeyIterator() {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	    javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.MAP, "keySet", "()Ljava/util/Set;", 0));
+        javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.COLLECTION, "iterator", "()Ljava/util/Iterator;", 0));
+        
+        javaWriter.label(startLabel);
+        javaWriter.dup();
+        javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "hasNext", "()Z", 0));
+        javaWriter.ifEQ(endLabel);
+        javaWriter.dup();
+        javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "next", "()Ljava/lang/Object;", 0));
+        
+        final JavaLocalVariableInfo keyVariable = javaWriter.getLocalVariable(variables[0].variable);
+        this.downCast(0, keyVariable.type);
+        javaWriter.store(keyVariable.type, keyVariable.local);
+        
+        content.accept(statementVisitor);
 	}
 
 	public void visitAssocKeyValueIterator() {
 		javaWriter.dup();
 		javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "hasNext", "()Z", 0));
 		javaWriter.ifEQ(endLabel);
+		javaWriter.dup();
 		javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "next", "()Ljava/lang/Object;", 0));
 		javaWriter.checkCast(Type.getType(Map.Entry.class));
 		javaWriter.dup(false);
 		final JavaLocalVariableInfo valueVariable = javaWriter.getLocalVariable(variables[1].variable);
 
 		javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.fromInternalName("java/util/Map$Entry", JavaClass.Kind.INTERFACE), "getKey", "()Ljava/lang/Object;", 0));
+		this.downCast(0, keyVariable.type);
 		javaWriter.store(keyVariable.type, keyVariable.local);
-
+		
 		javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.fromInternalName("java/util/Map$Entry", JavaClass.Kind.INTERFACE), "getValue", "()Ljava/lang/Object;", 0));
+        this.downCast(1, valueVariable.type);
 		javaWriter.store(valueVariable.type, valueVariable.local);
+		
 		content.accept(statementVisitor);
-
-
-		//throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
+	
+	private void downCast(int typeNumber, Type t) {
+        if(CompilerUtils.isPrimitive(variables[typeNumber].type.type)) {
+            variables[typeNumber].type.type.accept(variables[typeNumber].type, unboxingTypeVisitor);
+        } else {
+            javaWriter.checkCast(t);
+        }
+    }
 }

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

 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 	@Override
 	public Void visitSetter(SetterExpression expression) {
 		expression.target.accept(original);
+
+		if (expression.setter.member.definition.isExpansion()) {
+			for (TypeParameter typeParameter : expression.setter.member.definition.typeParameters) {
+				javaWriter.aConstNull(); //TODO replace with actual type
+				javaWriter.checkCast("java/lang/Class");
+			}
+		}
+
 		expression.value.accept(original);
 		original.checkAndExecuteMethodInfo(expression.setter, expression.type, expression);
 		return null;

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

 import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.statement.*;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 
 import java.util.Arrays;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
-	private final JavaBytecodeContext context;
-    public JavaExpressionVisitor expressionVisitor;
-	public JavaNonPushingExpressionVisitor nonPushingExpressionVisitor;
+	final JavaBytecodeContext context;
+    public final JavaExpressionVisitor expressionVisitor;
+	public final JavaNonPushingExpressionVisitor nonPushingExpressionVisitor;
 
     /**
      * @param javaWriter the method writer that compiles the statement
         this.javaWriter = javaWriter;
 		this.context = context;
         this.expressionVisitor = new JavaExpressionVisitor(context, module, javaWriter);
-		nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(context, module, javaWriter, expressionVisitor);
+		this.nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(context, module, javaWriter, expressionVisitor);
     }
 
     public JavaStatementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionVisitor) {
         this.javaWriter = expressionVisitor.getJavaWriter();
 		this.context = context;
         this.expressionVisitor = expressionVisitor;
+		this.nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(expressionVisitor.context, expressionVisitor.module, expressionVisitor.javaWriter, expressionVisitor);
     }
 
 	@Override
 	public Boolean visitBlock(BlockStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		Boolean returns = false;
 		for (Statement statement1 : statement.statements) {
 			returns = statement1.accept(this);
 
 	@Override
 	public Boolean visitBreak(BreakStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_end"));
 		return false;
 	}
 
 	@Override
 	public Boolean visitContinue(ContinueStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_start"));
 		return false;
 	}
 
 	@Override
 	public Boolean visitDoWhile(DoWhileStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		Label start = new Label();
 		Label end = new Label();
 		if (statement.label == null)
 
 	@Override
 	public Boolean visitExpression(ExpressionStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		statement.expression.accept(nonPushingExpressionVisitor);
 		return false;
 	}
 
 	@Override
 	public Boolean visitForeach(ForeachStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		//Create Labels
 		Label start = new Label();
 		Label end = new Label();
 		} else {
 			switch (statement.iterator.target.getBuiltin()) {
 				case ITERATOR_INT_RANGE:
-					iteratorWriter.visitIntRange();
+					iteratorWriter.visitIntRange(((RangeTypeID) statement.iterator.getOwnerType().type));
 					break;
 				case ITERATOR_ARRAY_VALUES:
 					iteratorWriter.visitArrayValueIterator();
 		
 		javaWriter.goTo(start);
 		javaWriter.label(end);
+		javaWriter.pop();
 		return false;
 	}
 
 	@Override
 	public Boolean visitIf(IfStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		statement.condition.accept(expressionVisitor);
 		Label onElse = null;
 		Label end = new Label();
 	public Boolean visitLock(LockStatement statement) {
 		return false;
 	}
-
+	
+	@Override
+	public Boolean visitInvalid(InvalidStatement statement) {
+		throw new UnsupportedOperationException("Invalid Statement: " + statement.message);
+	}
+	
 	@Override
 	public Boolean visitReturn(ReturnStatement statement) {
-		statement.value.accept(expressionVisitor);
-		javaWriter.returnType(context.getType(statement.value.type));
+    	javaWriter.position(statement.position.fromLine);
+    	if(statement.value == null) {
+    		javaWriter.ret();
+		} else {
+			statement.value.accept(expressionVisitor);
+			javaWriter.returnType(context.getType(statement.value.type));
+		}
+
 		return true;
 	}
 
 	@Override
 	public Boolean visitSwitch(SwitchStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 
 		final Label start = new Label();
 		final Label end = new Label();
 
 	@Override
 	public Boolean visitThrow(ThrowStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		statement.value.accept(expressionVisitor);
 		javaWriter.aThrow();
 		return false;
 
 	@Override
 	public Boolean visitTryCatch(TryCatchStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		final Label tryCatchStart = new Label();
 		final Label tryFinish = new Label();
 		final Label tryCatchFinish = new Label();
 
 	@Override
 	public Boolean visitVar(VarStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		if (statement.initializer != null) {
 			statement.initializer.accept(expressionVisitor);
 		}
 
 	@Override
 	public Boolean visitWhile(WhileStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		Label start = new Label();
 		Label end = new Label();
 

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
+
+public class JavaUnboxingTypeVisitor implements TypeVisitorWithContext<StoredType, Void, RuntimeException> {
+    
+    private static final JavaMethod UNBOX_BOOLEAN = JavaMethod.getNativeVirtual(JavaClass.BOOLEAN, "booleanValue", "()Z");
+    private static final JavaMethod UNBOX_BYTE = JavaMethod.getNativeVirtual(JavaClass.BYTE, "byteValue", "()B");
+    private static final JavaMethod UNBOX_SHORT = JavaMethod.getNativeVirtual(JavaClass.SHORT, "shortValue", "()S");
+    private static final JavaMethod UNBOX_INTEGER = JavaMethod.getNativeVirtual(JavaClass.INTEGER, "intValue", "()I");
+    private static final JavaMethod UNBOX_LONG = JavaMethod.getNativeVirtual(JavaClass.LONG, "longValue", "()J");
+    private static final JavaMethod UNBOX_FLOAT = JavaMethod.getNativeVirtual(JavaClass.FLOAT, "floatValue", "()F");
+    private static final JavaMethod UNBOX_DOUBLE = JavaMethod.getNativeVirtual(JavaClass.DOUBLE, "doubleValue", "()D");
+    private static final JavaMethod UNBOX_CHARACTER = JavaMethod.getNativeVirtual(JavaClass.CHARACTER, "charValue", "()C");
+    
+    private final JavaWriter writer;
+    
+    public JavaUnboxingTypeVisitor(JavaWriter writer) {
+        this.writer = writer;
+    }
+    
+    
+    @Override
+    public Void visitBasic(StoredType context, BasicTypeID basic) throws RuntimeException {
+        final JavaMethod method;
+        
+        switch(basic) {
+            case BOOL:
+                writer.checkCast(JavaClass.BOOLEAN.internalName);
+                method = UNBOX_BOOLEAN;
+                break;
+            case BYTE:
+            case SBYTE:
+                writer.checkCast(JavaClass.BYTE.internalName);
+                method = UNBOX_BYTE;
+                break;
+            case SHORT:
+            case USHORT:
+                writer.checkCast(JavaClass.SHORT.internalName);
+                method = UNBOX_SHORT;
+                break;
+            case INT:
+            case UINT:
+                writer.checkCast(JavaClass.INTEGER.internalName);
+                method = UNBOX_INTEGER;
+                break;
+            case LONG:
+            case ULONG:
+            case USIZE:
+                writer.checkCast(JavaClass.LONG.internalName);
+                method = UNBOX_LONG;
+                break;
+            case FLOAT:
+                writer.checkCast(JavaClass.FLOAT.internalName);
+                method = UNBOX_FLOAT;
+                break;
+            case DOUBLE:
+                writer.checkCast(JavaClass.DOUBLE.internalName);
+                method = UNBOX_DOUBLE;
+                break;
+            case CHAR:
+                writer.checkCast(JavaClass.CHARACTER.internalName);
+                method = UNBOX_CHARACTER;
+                break;
+            case VOID:
+            case UNDETERMINED:
+            case NULL:
+            default:
+                return null;
+        }
+        writer.invokeVirtual(method);
+        return null;
+    }
+    
+    @Override
+    public Void visitString(StoredType context, StringTypeID string) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitArray(StoredType context, ArrayTypeID array) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitAssoc(StoredType context, AssocTypeID assoc) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitGenericMap(StoredType context, GenericMapTypeID map) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitIterator(StoredType context, IteratorTypeID iterator) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitFunction(StoredType context, FunctionTypeID function) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitDefinition(StoredType context, DefinitionTypeID definition) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitGeneric(StoredType context, GenericTypeID generic) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitRange(StoredType context, RangeTypeID range) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitOptional(StoredType context, OptionalTypeID type) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+}

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

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
-import org.openzen.zenscript.codemodel.member.MethodMember;
-import org.openzen.zenscript.javashared.*;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
-import org.openzen.zenscript.codemodel.definition.*;
+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.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javabytecode.compiler.*;
+import org.openzen.zenscript.javabytecode.compiler.CompilerUtils;
+import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
+import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
+import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
+import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
+import org.openzen.zenscript.javashared.JavaTypeGenericVisitor;
+import org.openzen.zenscript.javashared.JavaVariantOption;
 
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
-import org.openzen.zenscript.codemodel.member.ImplementationMember;
-import org.openzen.zenscript.codemodel.type.StoredType;
 
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
-	private static final JavaMethod CLASS_FORNAME
+	private final JavaMethod CLASS_FORNAME
 			= JavaMethod.getNativeStatic(JavaClass.CLASS, "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
-	private static final JavaMethod ENUM_VALUEOF
+	private final JavaMethod ENUM_VALUEOF
 			= JavaMethod.getNativeStatic(JavaClass.CLASS, "valueOf", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;");
-	private static final JavaMethod ARRAY_CLONE
+	private final JavaMethod ARRAY_CLONE
 			= JavaMethod.getNativeVirtual(JavaClass.ARRAYS, "clone", "()Ljava/lang/Object;");
 
 	private final JavaClassWriter outerWriter;
 			if (member instanceof ImplementationMember)
 				interfaces.add(context.getInternalName(((ImplementationMember) member).type));
 		}
-        String signature = null;
+        String signature;
+
+		{
+			final StringBuilder signatureBuilder = new StringBuilder();
+			if(definition.typeParameters.length != 0) {
+				signatureBuilder.append("<");
+				for (TypeParameter typeParameter : definition.typeParameters) {
+					signatureBuilder.append(typeParameter.name);
+					signatureBuilder.append(":");
+					signatureBuilder.append("Ljava/lang/Object;");
+				}
+				signatureBuilder.append(">");
+			}
+
+			signatureBuilder.append("L").append(superTypeInternalName).append(";");
+			for (IDefinitionMember member : definition.members) {
+				if(member instanceof ImplementationMember) {
+					signatureBuilder.append(context.getInternalName(((ImplementationMember) member).type));
+				}
+			}
+
+			signature = signatureBuilder.toString();
+		}
 
         writer.visit(Opcodes.V1_8, definition.modifiers, toClass.internalName, signature, superTypeInternalName, interfaces.toArray(new String[0]));
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			//Add it to the class
+			writer.visitField(
+					Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL,
+					"typeOf" + typeParameter.name,
+					"Ljava/lang/Class;",
+					"Ljava/lang/Class<T" + typeParameter.name + ";>;",
+					//"Ljava/lang/Class;",
+					null
+			);
+		}
+
 		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
             member.accept(memberVisitor);
 
 	@Override
 	public byte[] visitEnum(EnumDefinition definition) {
-		System.out.println("Compiling enum " + definition.name + " in " + definition.position.getFilename());
+		context.logger.debug("Compiling enum " + definition.name + " in " + definition.position.getFilename());
 
 		String superTypeInternalName = definition.getSuperType() == null ? "java/lang/Object" : context.getInternalName(definition.getSuperType());
 
         }
 
 		JavaMethod valuesMethod = JavaMethod.getStatic(toClass, "values", "()[L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valuesWriter = new JavaWriter(definition.position, writer, true, valuesMethod, definition, null, null);
+		JavaWriter valuesWriter = new JavaWriter(context.logger, definition.position, writer, true, valuesMethod, definition, null, null);
 		valuesWriter.start();
 		valuesWriter.getStaticField(toClass.internalName, "$VALUES", "[L" + toClass.internalName + ";");
 		valuesWriter.invokeVirtual(ARRAY_CLONE);
 		valuesWriter.end();
 
 		JavaMethod valueOfMethod = JavaMethod.getStatic(toClass, "valueOf", "(Ljava/lang/String;)L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valueOfWriter = new JavaWriter(definition.position, writer, true, valueOfMethod, definition, null, null);
+		JavaWriter valueOfWriter = new JavaWriter(context.logger, definition.position, writer, true, valueOfMethod, definition, null, null);
 		valueOfWriter.start();
 		valueOfWriter.invokeStatic(CLASS_FORNAME);
 		valueOfWriter.loadObject(0);
 
 	@Override
 	public byte[] visitFunction(FunctionDefinition definition) {
-		CompilerUtils.tagMethodParameters(context, context.getJavaModule(definition.module), definition.header, true);
+		CompilerUtils.tagMethodParameters(context, context.getJavaModule(definition.module), definition.header, true, Collections
+                .emptyList());
 
         final String signature = context.getMethodSignature(definition.header);
 		final JavaMethod method = context.getJavaMethod(definition.caller);
 
-		final JavaWriter writer = new JavaWriter(definition.position, outerWriter, true, method, definition, signature, null);
+		final JavaWriter writer = new JavaWriter(context.logger, definition.position, outerWriter, true, method, definition, signature, null);
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(definition.module), writer);
         statementVisitor.start();
 		boolean returns = definition.caller.body.accept(statementVisitor);
 		writer.visitEnd();
 
 
-		final byte[] classBytes = writer.toByteArray();
-
-		try (FileOutputStream out = new FileOutputStream("ttt.class")) {
-			out.write(classBytes);
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-
-		return classBytes;
+		return writer.toByteArray();
 	}
 
 	@Override
 			optionInitSignatureBuilder.append(")V");
 
 			JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOptionClass, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
-			final JavaWriter initWriter = new JavaWriter(option.position, optionWriter, constructorMethod, variant, optionInitSignatureBuilder.toString(), null);
+			final JavaWriter initWriter = new JavaWriter(context.logger, option.position, optionWriter, constructorMethod, variant, optionInitSignatureBuilder.toString(), null);
 			initWriter.start();
 			initWriter.loadObject(0);
 			initWriter.dup();
 
 			//Denominator for switch-cases
 			JavaMethod denominator = JavaMethod.getVirtual(optionTag.variantOptionClass, "getDenominator", "()I", JavaModifiers.PUBLIC);
-			final JavaWriter getDenominator = new JavaWriter(option.position, optionWriter, denominator, null, null, null, "java/lang/Override");
+			final JavaWriter getDenominator = new JavaWriter(context.logger, option.position, optionWriter, denominator, null, null, null, "java/lang/Override");
 			getDenominator.start();
 			getDenominator.constant(option.ordinal);
 			getDenominator.returnInt();
 			optionWriter.visitEnd();
 			final byte[] byteArray = optionWriter.toByteArray();
 			context.register(optionTag.variantOptionClass.internalName, byteArray);
-
-			//Print the option files, won't be in production
-			try (FileOutputStream out = new FileOutputStream(optionTag.variantOptionClass.internalName.replace('/', '_') + ".class")) {
-				out.write(byteArray);
-			} catch (IOException e) {
-				e.printStackTrace();
-			}
 		}
 
 
 			member.accept(visitor);
 		}
 
-		final JavaWriter superInitWriter = new JavaWriter(variant.position, writer, JavaMethod.getConstructor(toClass, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
+		final JavaWriter superInitWriter = new JavaWriter(context.logger, variant.position, writer, JavaMethod.getConstructor(toClass, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
 		superInitWriter.start();
 		superInitWriter.loadObject(0);
 		superInitWriter.invokeSpecial("java/lang/Object", "<init>", "()V");

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.*;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
+
+import java.util.ArrayList;
+import java.util.stream.Collectors;
 
 public class JavaExpansionMemberVisitor implements MemberVisitor<Void> {
 
 		this.context = context;
 		javaModule = context.getJavaModule(definition.module);
 
-		final JavaWriter javaWriter = new JavaWriter(definition.position, writer, new JavaMethod(context.getJavaClass(definition), JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
+		final JavaWriter javaWriter = new JavaWriter(context.logger, definition.position, writer, new JavaMethod(context.getJavaClass(definition), JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
 		this.clinitStatementVisitor = new JavaStatementVisitor(context, javaModule, javaWriter);
 		this.clinitStatementVisitor.start();
 		CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
 		if (!method.compile)
 			return null;
 
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
 
-		CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic());
+		CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic(), typeParameters);
 
 		final String expandedClassDescriptor = context.getDescriptor(expandedClass);
+		final String expandedClassSignature = context.getSignature(expandedClass);
 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
 		final String methodSignature;
+		final String methodDescriptor;
+
+
 
 		if (!isStatic) {
-			methodSignature = "(" + expandedClassDescriptor + context.getMethodSignature(member.header).substring(1);
+			String methodSignature1 = context.getMethodSignature(member.header);
+
+			//Add the expanded type as first generic parameter to the list.
+			if(!typeParameters.isEmpty()){
+				final String collect = typeParameters.stream()
+						.map(t -> t.name + ":" + "Ljava/lang/Object;")
+						.collect(Collectors.joining("", "<", ""));
+				if(methodSignature1.startsWith("<")) {
+					methodSignature1 = collect + methodSignature1.substring(1);
+				} else {
+					methodSignature1 = collect + ">" + methodSignature1;
+				}
+			}
+
+			final StringBuilder typeParamSigBuilder = new StringBuilder();
+			final StringBuilder typeParamDescBuilder = new StringBuilder();
+			int i = 1;
+			for (TypeParameter typeParameter : typeParameters) {
+				typeParamSigBuilder.append("Ljava/lang/Class<T").append(typeParameter.name).append(";>;");
+				typeParamDescBuilder.append("Ljava/lang/Class;");
+			}
+
+
+			final int index = methodSignature1.lastIndexOf('(') + 1;
+			methodSignature = methodSignature1.substring(0, index) + expandedClassSignature + typeParamSigBuilder.toString() + methodSignature1.substring(index);
+			methodDescriptor = "(" + expandedClassDescriptor + typeParamDescBuilder.toString() + context.getMethodDescriptor(member.header).substring(1);
 		} else {
 			methodSignature = context.getMethodSignature(member.header);
+			methodDescriptor = context.getMethodDescriptor(member.header);
 		}
 
 
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, method, definition, true, methodSignature, methodSignature, null);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, method, definition, true, methodSignature, methodDescriptor, null);
 		methodWriter.label(methodStart);
 
 		if (!isStatic) {
 			methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, Type.getType(expandedClassDescriptor));
 			methodWriter.nameParameter(0, "expandedObj");
-			for (final FunctionParameter parameter : member.header.parameters) {
-				methodWriter.nameParameter(0, parameter.name);
-				methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
-			}
-		} else {
-			for (final FunctionParameter parameter : member.header.parameters) {
-				methodWriter.nameParameter(0, parameter.name);
-				methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
+
+			for (TypeParameter typeParameter : typeParameters) {
+				methodWriter.nameParameter(0, "typeOf" + typeParameter.name);
+				methodWriter.nameVariable(javaModule.getTypeParameterInfo(typeParameter).parameterIndex, "typeOf" + typeParameter.name, methodStart, methodEnd, Type.getType(Class.class));
 			}
 		}
 
+		for (TypeParameter typeParameter : member.header.typeParameters) {
+			methodWriter.nameParameter(0, "typeOf" + typeParameter.name);
+			methodWriter.nameVariable(javaModule.getTypeParameterInfo(typeParameter).parameterIndex, "typeOf" + typeParameter.name, methodStart, methodEnd, Type.getType(Class.class));
+		}
+
+		for (final FunctionParameter parameter : member.header.parameters) {
+			methodWriter.nameParameter(0, parameter.name);
+			methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
+		}
+
 
 		{
 			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
 
 	@Override
 	public Void visitGetter(GetterMember member) {
+		final boolean isStatic = member.isStatic();
+		final StoredType returnType = member.getType();
+		final String descriptor;
+		final String signature;
+
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
+		{
+
+			final String descMiddle, signatureMiddle, signatureStart;
+			if (typeParameters.isEmpty()) {
+				descMiddle = signatureMiddle = signatureStart = "";
+			} else {
+				final StringBuilder descMiddleBuilder = new StringBuilder();
+				final StringBuilder signatureMiddleBuilder = new StringBuilder();
+				final StringBuilder signatureStartBuilder = new StringBuilder("<");
+
+				for (TypeParameter typeParameter : typeParameters) {
+					descMiddleBuilder.append("Ljava/lang/Class;");
+					signatureMiddleBuilder.append("Ljava/lang/Class<T").append(typeParameter.name).append(";>;");
+					signatureStartBuilder.append(typeParameter.name).append(":Ljava/lang/Object;");
+				}
+
+				descMiddle = descMiddleBuilder.toString();
+				signatureMiddle = signatureMiddleBuilder.toString();
+				signatureStart = signatureStartBuilder.append(">").toString();
+			}
+
+
+			if (isStatic) {
+				descriptor = "(" + descMiddle + ")" + context.getDescriptor(returnType);
+				signature = signatureStart + "(" + signatureMiddle + ")" + context.getSignature(returnType);
+			} else {
+				descriptor = "(" + context.getDescriptor(expandedClass) + descMiddle + ")" + context.getDescriptor(returnType);
+				signature = signatureStart + "(" + context.getSignature(expandedClass) + signatureMiddle + ")" + context
+						.getSignature(returnType);
+			}
+		}
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+		final JavaMethod method = context.getJavaMethod(member);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, this.writer, true, method, definition, true, signature, descriptor, new String[0]);
+
+		methodWriter.label(methodStart);
+
+		if (!isStatic) {
+			methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, context.getType(this.expandedClass));
+			methodWriter.nameParameter(0, "expandedObj");
+		}
+
+		int i = isStatic ? 0 : 1;
+		for (TypeParameter typeParameter : typeParameters) {
+			final String name = "typeOf" + typeParameter.name;
+			methodWriter.nameVariable(i, name, methodStart, methodEnd, Type.getType(Class.class));
+			methodWriter.nameParameter(0, name);
+		}
+
+		{
+			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+			statementVisitor.start();
+			member.body.accept(statementVisitor);
+			methodWriter.label(methodEnd);
+			statementVisitor.end();
+		}
+
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
+		final boolean isStatic = member.isStatic();
+		final StoredType setterType = member.parameter.type;
+
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
+		CompilerUtils.tagMethodParameters(context, javaModule, member.getHeader(), isStatic, typeParameters);
+		setterType.type.extractTypeParameters(typeParameters);
+
+
+		final String signature = context.getMethodSignatureExpansion(member.getHeader(), expandedClass);
+		final String description = context.getMethodDescriptorExpansion(member.getHeader(), expandedClass);
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, javaMethod, member.definition, true, signature, description, new String[0]);
+
+
+		methodWriter.label(methodStart);
+		if (!isStatic) {
+			methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, context.getType(this.expandedClass));
+			methodWriter.nameParameter(0, "expandedObj");
+		}
+
+		int i = isStatic ? 0 : 1;
+		for (TypeParameter typeParameter : typeParameters) {
+			final String name = "typeOf" + typeParameter.name;
+			methodWriter.nameVariable(i, name, methodStart, methodEnd, Type.getType(Class.class));
+			methodWriter.nameParameter(0, name);
+			i++;
+		}
+
+		//in script you use $ but the parameter is named "value", which to choose?
+		//final String name = member.parameter.name;
+		final String name = "$";
+		methodWriter.nameVariable(i, name, methodStart, methodEnd, context.getType(setterType));
+		methodWriter.nameParameter(0, name);
+
+		javaModule.setParameterInfo(member.parameter, new JavaParameterInfo(i, context.getDescriptor(setterType)));
+
+		final JavaStatementVisitor javaStatementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		javaStatementVisitor.start();
+		member.body.accept(javaStatementVisitor);
+		javaStatementVisitor.end();
+		methodWriter.label(methodEnd);
+
 		return null;
 	}
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
-		return null;
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final MethodMember methodMember = new MethodMember(member.position, member.definition, member.getEffectiveModifiers(), javaMethod.name, member.header, member.builtin);
+		methodMember.body = member.body;
+		methodMember.annotations = member.annotations;
+		javaModule.setMethodInfo(methodMember, javaMethod);
+
+		return methodMember.accept(this);
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
+
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
+
+		CompilerUtils.tagMethodParameters(context, javaModule, member.getHeader(), false, typeParameters);
+		member.toType.type.extractTypeParameters(typeParameters);
+
+		final String methodSignature = context.getMethodSignatureExpansion(member.getHeader(), expandedClass);
+		final String methodDescriptor = context.getMethodDescriptorExpansion(member.getHeader(), expandedClass);
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, javaMethod, member.definition, true, methodSignature, methodDescriptor, new String[0]);
+
+		methodWriter.label(methodStart);
+		methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, context.getType(this.expandedClass));
+		methodWriter.nameParameter(0, "expandedObj");
+
+		int i = 1;
+		for (TypeParameter typeParameter : typeParameters) {
+			final String name = "typeOf" + typeParameter.name;
+			methodWriter.nameVariable(i, name, methodStart, methodEnd, Type.getType(Class.class));
+			methodWriter.nameParameter(0, name);
+		}
+
+		final JavaStatementVisitor javaStatementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		javaStatementVisitor.start();
+		member.body.accept(javaStatementVisitor);
+		javaStatementVisitor.end();
+		methodWriter.label(methodEnd);
 		return null;
 	}
 
 
 	@Override
 	public Void visitCaller(CallerMember member) {
-		return null;
+		//It's gonna be a method anyways, so why not reuse the code ^^
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final MethodMember call = new MethodMember(member.position, member.definition, member.getEffectiveModifiers(), javaMethod.name, member.header, member.builtin);
+		call.body = member.body;
+		call.annotations = member.annotations;
+
+		javaModule.setMethodInfo(call, javaMethod);
+		return call.accept(this);
 	}
 
 	@Override

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

 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.*;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaField;
-import org.openzen.zenscript.javashared.JavaImplementation;
-import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.*;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
     private final ClassWriter writer;
 		this.context = context;
 		javaModule = context.getJavaModule(definition.module);
 
-        final JavaWriter javaWriter = new JavaWriter(definition.position, writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
+        final JavaWriter javaWriter = new JavaWriter(context.logger, definition.position, writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
         this.clinitStatementVisitor = new JavaStatementVisitor(context, javaModule, javaWriter);
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
 
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
-        final JavaWriter constructorWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
+        final JavaWriter constructorWriter = new JavaWriter(context.logger, member.position, writer, method, definition, context.getMethodSignature(member.header), null);
         constructorWriter.label(constructorStart);
         CompilerUtils.tagConstructorParameters(context, javaModule, member.definition, member.header, isEnum);
+        if(isEnum) {
+			constructorWriter.nameParameter(0, "name");
+			constructorWriter.nameParameter(0, "index");
+		}
+
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			constructorWriter.nameParameter(0, "typeof" + typeParameter.name);
+			constructorWriter.nameVariable(
+					javaModule.getTypeParameterInfo(typeParameter).parameterIndex,
+					"typeOf" + typeParameter.name,
+					constructorStart,
+					constructorEnd,
+					Type.getType(Class.class)
+			);
+		}
+
         for (FunctionParameter parameter : member.header.parameters) {
             constructorWriter.nameVariable(
                     javaModule.getParameterInfo(parameter).index,
 
 		if (!member.isConstructorForwarded()) {
 			if (isEnum) {
-				System.out.println("Writing enum constructor");
+				context.logger.debug("Writing enum constructor");
 				constructorWriter.getVisitor().newLocal(Type.getType(String.class));
 				constructorWriter.getVisitor().newLocal(Type.getType(int.class));
 				constructorWriter.loadObject(0);
 				constructorWriter.loadInt(2);
 				constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
 			} else if (definition.getSuperType() == null) {
-				System.out.println("Writing regular constructor");
+				context.logger.debug("Writing regular constructor");
 				constructorWriter.loadObject(0);
 				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
 			}
         }
+    
+        for(IDefinitionMember membersOfSameType : member.definition.members) {
+            if(membersOfSameType instanceof FieldMember) {
+                final FieldMember fieldMember = ((FieldMember) membersOfSameType);
+                final Expression initializer = fieldMember.initializer;
+                if(initializer != null) {
+                    constructorWriter.loadObject(0);
+                    initializer.accept(statementVisitor.expressionVisitor);
+                    constructorWriter.putField(context.getJavaField(fieldMember));
+                }
+            }
+        }
+
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			final JavaTypeParameterInfo typeParameterInfo = javaModule.getTypeParameterInfo(typeParameter);
+			final JavaField field = typeParameterInfo.field;
+
+			//Init from Constructor
+			final int parameterIndex = typeParameterInfo.parameterIndex;
+			constructorWriter.loadObject(0);
+			constructorWriter.loadObject(parameterIndex);
+			constructorWriter.putField(field);
+		}
 
 		if (member.body != null) {
 			member.body.accept(statementVisitor);
 
 		final Label constructorStart = new Label();
 		final Label constructorEnd = new Label();
-		final JavaWriter destructorWriter = new JavaWriter(member.position, writer, method, definition, null, null);
+		final JavaWriter destructorWriter = new JavaWriter(context.logger, member.position, writer, method, definition, null, null);
 		destructorWriter.label(constructorStart);
 		
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, destructorWriter);
 
     @Override
     public Void visitMethod(MethodMember member) {
-        CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic());
+        CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic(), Collections.emptyList());
 
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.getEffectiveModifiers());
         final JavaMethod method = context.getJavaMethod(member);
 		
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, method, definition, context.getMethodSignature(member.header), null);
 
 		if (!isAbstract) {
 			if (method.isAbstract() || method.cls.kind == JavaClass.Kind.INTERFACE)
 
 	@Override
 	public Void visitGetter(GetterMember member) {
+		if (member.hasTag(NativeTag.class)) {
+			return null;
+		}
+
+		final String descriptor = context.getMethodDescriptor(member.getHeader());
+		final String signature = context.getMethodSignature(member.getHeader(), true);
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+		final JavaMethod method = context.getJavaMethod(member);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, this.writer, true, method, definition, false, signature, descriptor, new String[0]);
+
+		methodWriter.label(methodStart);
+		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		statementVisitor.start();
+		member.body.accept(statementVisitor);
+		methodWriter.label(methodEnd);
+		statementVisitor.end();
+
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
+		final String signature = context.getMethodSignature(member.getHeader());
+		final String description = context.getMethodDescriptor(member.getHeader());
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, javaMethod, member.definition, false, signature, description, new String[0]);
+		methodWriter.label(methodStart);
+
+		//in script you use $ but the parameter is named "value", which to choose?
+		//final String name = member.parameter.name;
+		final String name = "$";
+		methodWriter.nameVariable(1, name, methodStart, methodEnd, context.getType(member.getType()));
+		methodWriter.nameParameter(0, name);
+
+		javaModule.setParameterInfo(member.parameter, new JavaParameterInfo(1, context.getDescriptor(member.getType())));
+
+		final JavaStatementVisitor javaStatementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		javaStatementVisitor.start();
+		member.body.accept(javaStatementVisitor);
+		javaStatementVisitor.end();
+		methodWriter.label(methodEnd);
+
 		return null;
 	}
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
-		return null;
+
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final MethodMember methodMember = new MethodMember(member.position, member.definition, member.getEffectiveModifiers(), javaMethod.name, member.header, member.builtin);
+		methodMember.body = member.body;
+		methodMember.annotations = member.annotations;
+		javaModule.setMethodInfo(methodMember, javaMethod);
+
+		return methodMember.accept(this);
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		if(javaMethod == null || !javaMethod.compile) {
+			return null;
+		}
+
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>(Arrays.asList(this.definition.typeParameters));
+
+		CompilerUtils.tagMethodParameters(context, javaModule, member.getHeader(), false, typeParameters);
+		member.toType.type.extractTypeParameters(typeParameters);
+
+		final String methodSignature = context.getMethodSignature(member.getHeader());
+		final String methodDescriptor = context.getMethodDescriptor(member.getHeader());
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, javaMethod, member.definition, false, methodSignature, methodDescriptor, new String[0]);
+
+		methodWriter.label(methodStart);
+
+		int i = 1;
+		for (TypeParameter typeParameter : typeParameters) {
+			final String name = "typeOf" + typeParameter.name;
+			methodWriter.nameVariable(i, name, methodStart, methodEnd, Type.getType(Class.class));
+			methodWriter.nameParameter(0, name);
+		}
+
+		final JavaStatementVisitor javaStatementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		javaStatementVisitor.start();
+		member.body.accept(javaStatementVisitor);
+		javaStatementVisitor.end();
+		methodWriter.label(methodEnd);
 		return null;
 	}
 
 
 	@Override
 	public Void visitCaller(CallerMember member) {
-		return null;
+		//It's gonna be a method anyways, so why not reuse the code ^^
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final MethodMember call = new MethodMember(member.position, member.definition, member.getEffectiveModifiers(), javaMethod.name, member.header, member.builtin);
+		call.body = member.body;
+		call.annotations = member.annotations;
+
+		javaModule.setMethodInfo(call, javaMethod);
+		return call.accept(this);
 	}
 
 	@Override
 			for (IDefinitionMember imember : member.members)
 				imember.accept(this);
 		} else {
+			//TODO: Fixme???
+			// What should I do if a native class has interfaces to be visited?
+			if(javaModule.getNativeClassInfo(member.definition) != null) {
+				return null;
+			}
+
+
 			throw new UnsupportedOperationException("Non-inline interface implementations not yet available");
 		}
 		return null;

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeLoader.java

  */
 package org.openzen.zencode.java;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 
 /**
 public class JavaNativeLoader {
 	private final Class<?>[] classes;
 	private final Class<?>[] globals;
-	private final Map<String, LoadingModule> modulesByBasePackage = new HashMap<>();
 	private final Map<String, LoadingModule> modulesByName = new HashMap<>();
-	private boolean loaded = false;
+    private final IZSLogger logger;
+    private boolean loaded = false;
 	
-	public JavaNativeLoader(Class<?>[] classes, Class<?>[] globals) {
+	public JavaNativeLoader(Class<?>[] classes, Class<?>[] globals, IZSLogger logger) {
 		this.classes = classes;
 		this.globals = globals;
+		this.logger = logger;
 	}
 	
 	public LoadingModule addModule(
 			throw new IllegalArgumentException("Module already exists: " + name);
 		
 		LoadingModule module = new LoadingModule(pkg, name, basePackage, dependencies);
-		modulesByBasePackage.put(name, module);
 		modulesByName.put(name, module);
 		
 		return module;
 		sortClasses();
 		
 		ScriptingEngine engine = new ScriptingEngine();
-		for (LoadingModule module : modulesByBasePackage.values()) {
+		for (LoadingModule module : modulesByName.values()) {
 			load(engine, module);
 		}
 		return engine;
 		for (Class<?> cls : classes) {
 			LoadingModule module = findModuleByPackage(modulesByPackage, getPackageName(cls));
 			if (module == null) {
-				System.out.println("Warning: module not found for class " + cls.getName());
+				logger.warning("Module not found for class " + cls.getName());
 			} else {
 				module.classes.add(cls);
 			}
 		for (Class<?> cls : globals) {
 			LoadingModule module = findModuleByPackage(modulesByPackage, getPackageName(cls));
 			if (module == null) {
-				System.out.println("Warning: module not found for class " + cls.getName());
+				logger.warning("Module not found for class " + cls.getName());
 			} else {
 				module.globals.add(cls);
 			}
 		}
 		
 		module.resolved = new JavaNativeModule(
+                logger,
 				module.pkg,
 				module.name,
 				module.basePackage,

JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java

  */
 package org.openzen.zencode.java;
 
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import org.openzen.zencode.shared.CompileException;
-import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.Module;
-import org.openzen.zenscript.codemodel.ModuleSpace;
-import org.openzen.zenscript.codemodel.SemanticModule;
-import org.openzen.zenscript.codemodel.context.CompilingPackage;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ISymbol;
-import org.openzen.zenscript.codemodel.type.storage.StorageType;
-import org.openzen.zenscript.javabytecode.JavaBytecodeRunUnit;
-import org.openzen.zenscript.javabytecode.JavaCompiler;
-import org.openzen.zenscript.javashared.SimpleJavaCompileSpace;
-import org.openzen.zenscript.lexer.ParseException;
-import org.openzen.zenscript.parser.BracketExpressionParser;
-import org.openzen.zenscript.parser.ParsedFile;
-import org.openzen.zenscript.parser.ZippedPackage;
-import org.openzen.zenscript.validator.Validator;
+import org.openzen.zencode.java.logger.*;
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.codemodel.*;
+import org.openzen.zenscript.codemodel.context.*;
+import org.openzen.zenscript.codemodel.definition.*;
+import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.codemodel.type.storage.*;
+import org.openzen.zenscript.javabytecode.*;
+import org.openzen.zenscript.javashared.*;
+import org.openzen.zenscript.lexer.*;
+import org.openzen.zenscript.parser.*;
+import org.openzen.zenscript.validator.*;
+
+import java.io.*;
+import java.lang.reflect.InvocationTargetException;
+import java.util.*;
 
 /**
  *
 	
 	public boolean debug = false;
 	
+	public final ScriptingEngineLogger logger;
+	
 	public ScriptingEngine() {
-		space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
-		
-		try {
-			ZippedPackage stdlibs = new ZippedPackage(ScriptingEngine.class.getResourceAsStream("/StdLibs.zip"));
-			SemanticModule stdlibModule = stdlibs.loadModule(space, "stdlib", null, new SemanticModule[0], FunctionParameter.NONE, stdlib);
-			stdlibModule = Validator.validate(stdlibModule, error -> System.out.println(error.toString()));
-			space.addModule("stdlib", stdlibModule);
-		} catch (IOException ex) {
-			throw new RuntimeException(ex);
-		} catch (CompileException ex) {
-			throw new RuntimeException(ex);
-		} catch (ParseException ex) {
-			throw new RuntimeException(ex);
-		}
-	}
+        this(new ScriptingEngineStreamLogger());
+    }
+    
+    public ScriptingEngine(ScriptingEngineLogger logger) {
+        this.space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
+        this.logger = logger;
+        try {
+            ZippedPackage stdlibs = new ZippedPackage(ScriptingEngine.class.getResourceAsStream("/StdLibs.jar"));
+            SemanticModule stdlibModule = stdlibs.loadModule(space, "stdlib", null, SemanticModule.NONE, FunctionParameter.NONE, stdlib, logger);
+            stdlibModule = Validator.validate(stdlibModule, logger);
+            space.addModule("stdlib", stdlibModule);
+            registerCompiled(stdlibModule);
+        } catch (CompileException | ParseException | IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
 	
 	public JavaNativeModule createNativeModule(String name, String basePackage, JavaNativeModule... dependencies) {
 		ZSPackage testPackage = new ZSPackage(space.rootPackage, name);
-		return new JavaNativeModule(testPackage, name, basePackage, registry, dependencies);
+		return new JavaNativeModule(logger, testPackage, name, basePackage, registry, dependencies);
 	}
 	
 	public void registerNativeProvided(JavaNativeModule module) throws CompileException {
 		SemanticModule semantic = Validator.validate(
-				module.toSemantic(space),
-				entry -> System.out.println(entry));
+				module.toSemantic(space), logger);
 		if (!semantic.isValid())
 			return;
 		
 		CompilingPackage scriptPackage = new CompilingPackage(new ZSPackage(space.rootPackage, name), scriptModule);
 		
 		ParsedFile[] files = new ParsedFile[sources.length];
-		for (int i = 0; i < sources.length; i++)
+		for (int i = 0; i < sources.length; i++) {
+			logger.logSourceFile(sources[i]);
 			files[i] = ParsedFile.parse(scriptPackage, bracketParser, sources[i]);
+		}
 		
 		SemanticModule[] dependencyModules = new SemanticModule[dependencies.length + 1];
 		dependencyModules[0] = space.getModule("stdlib");
 				files,
 				space,
 				scriptParameters,
-				ex -> ex.printStackTrace());
+				logger);
 		if (!scripts.isValid())
 			return scripts;
 		
 		return Validator.validate(
 				scripts.normalize(),
-				error -> System.out.println(error.toString()));
+				logger);
 	}
 	
 	public void registerCompiled(SemanticModule module) {
 	public void run(Map<FunctionParameter, Object> arguments) {
 		run(arguments, this.getClass().getClassLoader());
 	}
+	
+	public JavaBytecodeRunUnit createRunUnit() {
+        SimpleJavaCompileSpace javaSpace = new SimpleJavaCompileSpace(registry);
+        for (JavaNativeModule nativeModule : nativeModules)
+            javaSpace.register(nativeModule.getCompiled());
+        
+        JavaCompiler compiler = new JavaCompiler(logger);
+        
+        JavaBytecodeRunUnit runUnit = new JavaBytecodeRunUnit(logger);
+        for (SemanticModule compiled : compiledModules)
+            runUnit.add(compiler.compile(compiled.name, compiled, javaSpace));
+        if (debug)
+            runUnit.dump(new File("classes"));
+        
+        return runUnit;
+    }
 
 	public void run(Map<FunctionParameter, Object> arguments, ClassLoader parentClassLoader) {
-		SimpleJavaCompileSpace javaSpace = new SimpleJavaCompileSpace(registry);
-		for (JavaNativeModule nativeModule : nativeModules)
-			javaSpace.register(nativeModule.getCompiled());
-
-		JavaCompiler compiler = new JavaCompiler();
-
-		JavaBytecodeRunUnit runUnit = new JavaBytecodeRunUnit();
-		for (SemanticModule compiled : compiledModules)
-			runUnit.add(compiler.compile(compiled.name, compiled, javaSpace));
-		if (debug)
-			runUnit.dump(new File("classes"));
-		runUnit.run(arguments, parentClassLoader);
+	    JavaBytecodeRunUnit runUnit = createRunUnit();
+        
+        try {
+            runUnit.run(arguments, parentClassLoader);
+        } catch(ClassNotFoundException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+            logger.throwingErr(e.getCause().getMessage(), e.getCause());
+        }
+    }
+	
+	public List<JavaNativeModule> getNativeModules() {
+		return Collections.unmodifiableList(this.nativeModules);
 	}
 }

JavaIntegration/src/main/java/org/openzen/zencode/java/logger/ScriptingEngineLogger.java

+package org.openzen.zencode.java.logger;
+
+import org.openzen.zencode.shared.logging.*;
+import org.openzen.zenscript.parser.logger.*;
+import org.openzen.zenscript.validator.logger.*;
+
+public interface ScriptingEngineLogger extends ValidatorLogger, SourceFileLogger, ParserLogger {}

JavaIntegration/src/main/java/org/openzen/zencode/java/logger/ScriptingEngineStreamLogger.java

+package org.openzen.zencode.java.logger;
+
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.validator.*;
+
+import java.io.*;
+
+public class ScriptingEngineStreamLogger implements ScriptingEngineLogger {
+    
+    private final PrintStream infoStream, debugStream, warningStream, errorStream;
+    
+    public ScriptingEngineStreamLogger(PrintStream debugStream, PrintStream infoStream, PrintStream warningStream, PrintStream errorStream) {
+        this.infoStream = infoStream;
+        this.debugStream = debugStream;
+        this.warningStream = warningStream;
+        this.errorStream = errorStream;
+    }
+    
+    public ScriptingEngineStreamLogger(PrintStream normalStream, PrintStream errorStream) {
+        this(normalStream, normalStream, normalStream, errorStream);
+    }
+    
+    public ScriptingEngineStreamLogger() {
+        this(System.out, System.err);
+    }
+    
+    @Override
+    public void info(String message) {
+        infoStream.println("INFO: " + message);
+        infoStream.flush();
+    }
+    
+    @Override
+    public void debug(String message) {
+        debugStream.println("DEBUG:   " + message);
+        debugStream.flush();
+    }
+    
+    @Override
+    public void warning(String message) {
+        warningStream.println("WARNING: " + message);
+        warningStream.flush();
+    }
+    
+    @Override
+    public void error(String message) {
+        errorStream.println("ERROR:   " + message);
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        errorStream.println("ERROR:   " + message);
+        throwable.printStackTrace(errorStream);
+        errorStream.flush();
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        warningStream.println("WARNING: " + message);
+        throwable.printStackTrace(warningStream);
+        warningStream.flush();
+    }
+    
+    @Override
+    public void logCompileException(CompileException exception) {
+        throwingErr("Compile Exception:", exception);
+    }
+    
+    @Override
+    public void logSourceFile(SourceFile file) {
+        info("Loading File: " + file.getFilename());
+    }
+    
+    @Override
+    public void logValidationError(ValidationLogEntry errorEntry) {
+        error(errorEntry.toString());
+    }
+    
+    @Override
+    public void logValidationWarning(ValidationLogEntry warningEntry) {
+        warning(warningEntry.toString());
+    }
+}

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

 			return new JavaClass("", internalName, kind, new String[0]);
 		
 		int lastSlash = internalName.lastIndexOf('/');
-		if (lastSlash < 0)
-			System.out.println(internalName);
+		//if (lastSlash < 0)
+		//	System.out.println(internalName);
 		
 		String pkg = lastSlash < 0 ? "" : internalName.substring(0, lastSlash);
 		String className = lastSlash < 0 ? internalName : internalName.substring(lastSlash + 1);
 	
 	public static String getNameFromFile(String filename) {
 		if (filename.indexOf('.') > 0)
-			return filename.substring(0, filename.indexOf('.'));
+			return filename.substring(0, filename.lastIndexOf('.'));
 		else
 			return filename;
 	}

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

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

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

 		
 		return info;
 	}
+    
+    public void addAllFrom(JavaCompiledModule compiled) {
+        this.classes.putAll(compiled.classes);
+        this.expansionClasses.putAll(compiled.expansionClasses);
+        this.nativeClasses.putAll(compiled.nativeClasses);
+        this.implementations.putAll(compiled.implementations);
+        this.fields.putAll(compiled.fields);
+        this.methods.putAll(compiled.methods);
+        this.typeParameters.putAll(compiled.typeParameters);
+        this.parameters.putAll(compiled.parameters);
+        this.variantOptions.putAll(compiled.variantOptions);
+    }
 }

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 	
 	public final ZSPackage modulePackage;
 	public final String basePackage;
+	public final IZSLogger logger;
 	
-	public JavaContext(JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
+	public JavaContext(JavaCompileSpace space, ZSPackage modulePackage, String basePackage, IZSLogger logger) {
+	    this.logger = logger;
 		this.space = space;
 		this.registry = space.getRegistry();
 		
 	public abstract String getDescriptor(TypeID type);
 	
 	public abstract String getDescriptor(StoredType type);
-	
+
+	public String getSignature(StoredType type) {
+		return new JavaTypeGenericVisitor(this).getGenericSignature(type);
+	}
+
 	public void addModule(Module module, JavaCompiledModule target) {
 		modules.put(module, target);
+
+		//TODO: can we do this here?
+		space.register(target);
 	}
 	
 	public JavaCompiledModule getJavaModule(Module module) {
 	}
 	
 	public String getMethodDescriptor(FunctionHeader header) {
-		return getMethodDescriptor(header, false);
+		return getMethodDescriptor(header, false, "");
+	}
+
+	public String getMethodDescriptorExpansion(FunctionHeader header, StoredType expandedType) {
+		StringBuilder startBuilder = new StringBuilder(getDescriptor(expandedType));
+		final List<TypeParameter> typeParameters = new ArrayList<>();
+		expandedType.type.extractTypeParameters(typeParameters);
+		for (TypeParameter typeParameter : typeParameters) {
+			startBuilder.append("Ljava/lang/Class;");
+		}
+
+		return getMethodDescriptor(header, false, startBuilder.toString());
+	}
+
+	public String getMethodSignatureExpansion(FunctionHeader header, StoredType expandedClass) {
+		return new JavaTypeGenericVisitor(this).getMethodSignatureExpansion(header, expandedClass);
 	}
 	
     public String getMethodSignature(FunctionHeader header) {
-        return new JavaTypeGenericVisitor(this).getGenericMethodSignature(header);
+        return getMethodSignature(header, true);
     }
+
+    public String getMethodSignature(FunctionHeader header, boolean withGenerics) {
+		return new JavaTypeGenericVisitor(this).getGenericMethodSignature(header, withGenerics);
+	}
 	
 	public String getEnumConstructorDescriptor(FunctionHeader header) {
-		return getMethodDescriptor(header, true);
+		return getMethodDescriptor(header, true, "");
 	}
 	
 	public JavaSynthesizedFunctionInstance getFunction(FunctionTypeID type) {
 			return new JavaSynthesizedClass(range.cls, new TypeID[] { type.baseType.type });
 		}
 	}
-	
-	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor) {
+
+	/**
+	 * @param header Function Header
+	 * @param isEnumConstructor If this is an enum constructor, add String, int as parameters
+	 * @param expandedType If this is for an expanded type, add the type at the beginning.
+	 *                        Can be null or an empty string if this is not an expansion method header
+	 * @return Method descriptor {@code (<LClass;*No.TypeParameters><LString;I if enum><expandedType><headerTypes>)<retType> }
+	 */
+	public String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor, String expandedType) {
         StringBuilder descBuilder = new StringBuilder("(");
 		for (int i = 0; i < header.getNumberOfTypeParameters(); i++)
 			descBuilder.append("Ljava/lang/Class;");
 		
         if (isEnumConstructor)
             descBuilder.append("Ljava/lang/String;I");
+
+        //TODO: Put this earlier? We'd need to agree on one...
+        if(expandedType != null)
+        	descBuilder.append(expandedType);
 		
         for (FunctionParameter parameter : header.parameters) {
 			descBuilder.append(getDescriptor(parameter.type));
         descBuilder.append(getDescriptor(header.getReturnType()));
         return descBuilder.toString();
     }
+
+	public String getMethodDescriptorConstructor(FunctionHeader header, DefinitionMember member) {
+		StringBuilder startBuilder = new StringBuilder();
+		for (TypeParameter typeParameter : member.definition.typeParameters) {
+			startBuilder.append("Ljava/lang/Class;");
+		}
+		return getMethodDescriptor(header, member.definition instanceof EnumDefinition, startBuilder.toString());
+	}
 }

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

-package org.openzen.zenscript.javashared;
-
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.expression.*;
-import org.openzen.zenscript.codemodel.type.*;
-
-public class JavaDefaultExpressionTypeVisitor implements TypeVisitor<Expression> {
-
-	public static final JavaDefaultExpressionTypeVisitor INSTANCE = new JavaDefaultExpressionTypeVisitor();
-
-	private JavaDefaultExpressionTypeVisitor(){}
-
-	@Override
-	public Expression visitBasic(BasicTypeID basic) {
-
-
-		if (basic == null)
-			throw new IllegalStateException("Null basic type!");
-
-		switch (basic) {
-			case UNDETERMINED:
-			case VOID:
-				throw new IllegalStateException("Void and Undetermined have no default type");
-			case NULL:
-				return new NullExpression(CodePosition.UNKNOWN);
-			case BOOL:
-				return new ConstantBoolExpression(CodePosition.UNKNOWN, false);
-			case BYTE:
-				return new ConstantByteExpression(CodePosition.UNKNOWN, 0);
-			case SBYTE:
-				return new ConstantSByteExpression(CodePosition.UNKNOWN, (byte) 0);
-			case SHORT:
-				return new ConstantShortExpression(CodePosition.UNKNOWN, (short) 0);
-			case USHORT:
-				return new ConstantUShortExpression(CodePosition.UNKNOWN, 0);
-			case INT:
-				return new ConstantIntExpression(CodePosition.UNKNOWN, 0);
-			case UINT:
-				return new ConstantUIntExpression(CodePosition.UNKNOWN, 0);
-			case LONG:
-				return new ConstantLongExpression(CodePosition.UNKNOWN, 0L);
-			case ULONG:
-				return new ConstantULongExpression(CodePosition.UNKNOWN, 0L);
-			case USIZE:
-				return new ConstantUSizeExpression(CodePosition.UNKNOWN, 0L);
-			case FLOAT:
-				return new ConstantFloatExpression(CodePosition.UNKNOWN, 0.0f);
-			case DOUBLE:
-				return new ConstantDoubleExpression(CodePosition.UNKNOWN, 0.0d);
-			case CHAR:
-				return new ConstantCharExpression(CodePosition.UNKNOWN, '\0');
-			default:
-				throw new IllegalStateException("Unknown basic type!");
-		}
-
-
-	}
-
-	@Override
-	public Expression visitString(StringTypeID string) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitArray(ArrayTypeID array) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitAssoc(AssocTypeID assoc) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitGenericMap(GenericMapTypeID map) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitIterator(IteratorTypeID iterator) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitFunction(FunctionTypeID function) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitDefinition(DefinitionTypeID definition) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitGeneric(GenericTypeID generic) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitRange(RangeTypeID range) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitOptional(OptionalTypeID type) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitInvalid(InvalidTypeID type) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-}

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

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

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

 package org.openzen.zenscript.javashared;
 
 import java.lang.reflect.Method;
+import java.util.*;
+
 import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
 	public boolean isImmutable() {
 		return true;
 	}
+    
+    @Override
+    public boolean equals(Object o) {
+        if(this == o)
+            return true;
+        if(o == null || getClass() != o.getClass())
+            return false;
+        
+        JavaFunctionalInterfaceStorageTag other = (JavaFunctionalInterfaceStorageTag) o;
+        return Objects.equals(functionalInterfaceMethod, other.functionalInterfaceMethod);
+    }
+    
+    @Override
+    public int hashCode() {
+        return functionalInterfaceMethod != null ? functionalInterfaceMethod.hashCode() : 0;
+    }
 }

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

     public static JavaMethod getInterface(JavaClass cls, String name, String descriptor) {
         return new JavaMethod(cls, Kind.INTERFACE, name, false, descriptor, JavaModifiers.PUBLIC, false);
     }
-
+    
 	public static JavaMethod getNativeExpansion(JavaClass cls, String name, String descriptor) {
 		return new JavaMethod(cls, Kind.EXPANSION, name, false, descriptor, JavaModifiers.PUBLIC | JavaModifiers.STATIC, false);
 	}

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.generic.*;
 import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 
 public class JavaTypeGenericVisitor implements TypeVisitorWithContext<StoredType, String, RuntimeException> {
 				getGenericSignature(header.getReturnType());
 	}
 
+	public String getGenericMethodSignature(FunctionHeader header, boolean addGenerics) {
+		final StringBuilder sb = new StringBuilder();
+		final boolean doGenerics = addGenerics && header.typeParameters.length > 0;
+
+		if(doGenerics) {
+			sb.append("<");
+			for (TypeParameter typeParameter : header.typeParameters) {
+				//TODO: Eventually replace with upper bound
+				sb.append(typeParameter.name).append(":").append("Ljava/lang/Object;");
+			}
+			sb.append(">");
+		}
+
+
+		sb.append("(");
+		if(doGenerics) {
+			for (TypeParameter typeParameter : header.typeParameters) {
+				//TODO: Eventually replace with -TT; or +TT; for "? super T" and "? extends T"
+				sb.append("Ljava/lang/Class<T").append(typeParameter.name).append(";>;");
+			}
+		}
+
+		sb.append(getGenericSignature(header.parameters));
+		sb.append(")");
+		sb.append(getGenericSignature(header.getReturnType()));
+		return sb.toString();
+	}
+
 
 	public String getGenericBounds(Collection<TypeParameterBound> collection) {
 		if (collection == null)
 
 	@Override
 	public String visitArray(StoredType context, ArrayTypeID array) {
-		return this.context.getDescriptor(array);
+		final char[] dim = new char[array.dimension];
+		Arrays.fill(dim, '[');
+		return new String(dim) + this.context.getSignature(array.elementType);
 	}
 
 	@Override
 	public String visitAssoc(StoredType context, AssocTypeID assoc) {
-		return this.context.getDescriptor(assoc);
+		return "Ljava/util/Map<"
+				+ assoc.keyType.type.accept(context, this)
+				+ assoc.valueType.type.accept(context, this)
+				+ ">;";
 	}
 
 	@Override
 
 	@Override
 	public String visitFunction(StoredType context, FunctionTypeID function) {
-		return this.context.getDescriptor(function);
+		final JavaSynthesizedFunctionInstance function1 = this.context.getFunction(function);
+		if(function1.typeArguments == null || function1.typeArguments.length == 0) {
+			return this.context.getDescriptor(function);
+		}
+
+		StringBuilder sb = new StringBuilder("L").append(function1.getCls().internalName).append("<");
+		for (TypeID typeArgument : function1.typeArguments) {
+			final String n = typeArgument instanceof GenericTypeID
+					? ((GenericTypeID) typeArgument).parameter.name
+					: "Ljava/lang/Object"; //Can latter even happen?
+
+			sb.append("T").append(n).append(";");
+		}
+
+		return sb.append(">;").toString();
 	}
 
 	@Override
 	public String visitOptional(StoredType context, OptionalTypeID type) {
 		return type.baseType.accept(context, this);
 	}
+
+	public String getMethodSignatureExpansion(FunctionHeader header, StoredType expandedClass) {
+		final StringBuilder stringBuilder = new StringBuilder();
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
+		for (TypeParameter typeParameter : header.typeParameters) {
+			if(!typeParameters.contains(typeParameter)){
+				typeParameters.add(typeParameter);
+			}
+		}
+
+		if(typeParameters.size() != 0) {
+			stringBuilder.append("<");
+			for (TypeParameter typeParameter : typeParameters) {
+				stringBuilder.append(typeParameter.name);
+				stringBuilder.append(":Ljava/lang/Object;");
+			}
+			stringBuilder.append(">");
+		}
+		stringBuilder.append("(");
+		stringBuilder.append(context.getSignature(expandedClass));
+		for (TypeParameter typeParameter : typeParameters) {
+			stringBuilder.append("Ljava/lang/Class<T");
+			stringBuilder.append(typeParameter.name);
+			stringBuilder.append(";>;");
+		}
+		stringBuilder.append(getGenericSignature(header.parameters));
+		stringBuilder.append(")");
+		stringBuilder.append(context.getSignature(header.getReturnType()));
+
+		return stringBuilder.toString();
+	}
 }

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

 		this.parameterIndex = -1;
 		this.field = field;
 	}
+
+	public JavaTypeParameterInfo(int parameterIndex, JavaField field) {
+		this.parameterIndex = parameterIndex;
+		this.field = field;
+	}
 }

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

 	public SimpleJavaCompileSpace(GlobalTypeRegistry registry) {
 		this.registry = registry;
 	}
-	
+
+	@Override
 	public void register(JavaCompiledModule module) {
 		modules.put(module.module, module);
 	}

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

 	@Override
 	public Void visitConst(ConstMember member) {
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of const " + member.name);
+			context.logger.debug("Class " + cls.fullName + " not empty because of const " + member.name);
 		
 		cls.empty = false;
-		module.setFieldInfo(member, new JavaField(cls, member.name, context.getDescriptor(member.getType())));
+		module.setFieldInfo(member, new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType())));
 		return null;
 	}
 	
 	@Override
 	public Void visitField(FieldMember member) {
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType()));
 		module.setFieldInfo(member, field);
 		if (member.hasAutoGetter()) {
 			visitGetter(member.autoGetter);
 	@Override
 	public Void visitDestructor(DestructorMember member) {
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of destructor");
+			context.logger.debug("Class " + cls.fullName + " not empty because of destructor");
 		
 		cls.empty = false;
 		return null;
 				m.accept(this);
 		} else {
 			if (DEBUG_EMPTY && cls.empty)
-				System.out.println("Class " + cls.fullName + " not empty because of unmergeable implementation");
+				context.logger.debug("Class " + cls.fullName + " not empty because of unmergeable implementation");
 			
 			cls.empty = false;
 			
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of inner definition " + member.innerDefinition.name);
+			context.logger.debug("Class " + cls.fullName + " not empty because of inner definition " + member.innerDefinition.name);
 		cls.empty = false;
 		return null;
 	}
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of static initializer");
+			context.logger.debug("Class " + cls.fullName + " not empty because of static initializer");
 		
 		cls.empty = false;
 		return null;
 					header.getReturnType().type instanceof GenericTypeID,
 					header.useTypeParameters());
 		} else if (method == null) {
-			method = new JavaMethod(
-					cls,
-					getKind(member),
-					name,
-					true,
-					context.getMethodDescriptor(header),
-					modifiers | JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
-					header.getReturnType().type instanceof GenericTypeID,
-					header.useTypeParameters());
+			if(member instanceof ConstructorMember) {
+				method = new JavaMethod(
+						cls,
+						getKind(member),
+						name,
+						true,
+						context.getMethodDescriptorConstructor(header, member),
+						modifiers | JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+						false,
+						header.useTypeParameters()
+				);
+			} else {
+				method = new JavaMethod(
+						cls,
+						getKind(member),
+						name,
+						true,
+						context.getMethodDescriptor(header),
+						modifiers | JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+						header.getReturnType().type instanceof GenericTypeID,
+						header.useTypeParameters());
+			}
 		}
 		
 		if (method.compile && member.getBuiltin() != BuiltinID.CLASS_DEFAULT_CONSTRUCTOR) {
 			if (DEBUG_EMPTY && cls.empty)
-				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
+				context.logger.debug("Class " + cls.fullName + " not empty because of " + member.describe());
 			
 			cls.empty = false;
 		}

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

  */
 package org.openzen.zenscript.javashared.prepare;
 
-import org.openzen.zenscript.javashared.JavaNativeClass;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.javashared.*;
 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.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaContext;
-import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.javashared.JavaModifiers;
 
 /**
  *
 		if (definition.module != module.module)
 			throw new IllegalArgumentException("Definition is not in the same module as the current module!");
 		
-		System.out.println("~~ Preparing " + definition.name);
+		context.logger.debug("~~ Preparing " + definition.name);
 		definition.accept(this);
 	}
 	
 	public JavaClass visitClass(ClassDefinition definition) {
 		if (isPrepared(definition))
 			return context.getJavaClass(definition);
-		
+
 		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
 	}
 
 	}
 	
 	private JavaClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty, JavaClass.Kind kind) {
+
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			module.setTypeParameterInfo(typeParameter, new JavaTypeParameterInfo(-1));
+		}
+
 		if (definition.getSuperType() != null)
 			prepare(definition.getSuperType());
 		
 	}
 	
 	private void visitClassMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
-		System.out.println("Preparing " + cls.internalName);
+		context.logger.debug("Preparing " + cls.internalName);
 		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, module, cls, nativeClass, this, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 	}
 	
 	private void visitExpansionMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass) {
-		System.out.println("Preparing " + cls.internalName);
+		context.logger.debug("Preparing " + cls.internalName);
 		JavaPrepareExpansionMethodVisitor methodVisitor = new JavaPrepareExpansionMethodVisitor(context, module, cls, nativeClass);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);

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

  */
 package org.openzen.zenscript.javashared.prepare;
 
-import org.openzen.zenscript.javashared.JavaNativeClass;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaModifiers;
+import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaPrepareDefinitionVisitor implements DefinitionVisitor<JavaClass> {
-	private static final Map<String, JavaNativeClass> nativeClasses = new HashMap<>();
+	private final Map<String, JavaNativeClass> nativeClasses = new HashMap<>();
 	
-	static {
+	 {
 		{
 			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "StringBuilder", JavaClass.Kind.CLASS));
 			cls.addConstructor("constructor", "()V");
 			JavaNativeClass list = new JavaNativeClass(new JavaClass("java.util", "List", JavaClass.Kind.INTERFACE));
 			JavaClass arrayList = new JavaClass("java.util", "ArrayList", JavaClass.Kind.CLASS);
 			list.addMethod("constructor", JavaMethod.getNativeConstructor(arrayList, "()V"));
-			list.addInstanceMethod("add", "add", "(Ljava/lang/Object;)Z"); List<?> l;
+			list.addInstanceMethod("add", "add", "(Ljava/lang/Object;)Z");
 			list.addInstanceMethod("insert", "add", "(Ljava/lang/Object;I)V");
 			list.addInstanceMethod("remove", "remove", "(Ljava/lang/Object;)Z");
 			list.addInstanceMethod("indexOf", "indexOf", "(Ljava/lang/Object;)I");
 		}
 		
 		{
-			JavaNativeClass iterator = new JavaNativeClass(JavaClass.ITERATOR);
+			JavaNativeClass iterator = new JavaNativeClass(new JavaClass("java.util", "Iterator", JavaClass.Kind.INTERFACE));
 			iterator.addMethod("empty", new JavaMethod(JavaClass.COLLECTIONS, JavaMethod.Kind.STATIC, "emptyIterator", false, "()Ljava/lang/Iterator;", JavaModifiers.STATIC | JavaModifiers.PUBLIC, false));
 			iterator.addInstanceMethod("hasNext", "hasNext", "()Z");
 			iterator.addInstanceMethod("next", "next", "()Ljava/lang/Object;");
 	
 	private final JavaContext context;
 	private final String filename;
+	private final String className;
 	private final JavaClass outerClass;
 	private final JavaCompiledModule module;
-	
+
 	public JavaPrepareDefinitionVisitor(JavaContext context, JavaCompiledModule module, String filename, JavaClass outerClass) {
+		this(context, module, filename, outerClass, JavaClass.getNameFromFile(filename));
+	}
+
+	public JavaPrepareDefinitionVisitor(JavaContext context, JavaCompiledModule module, String filename, JavaClass outerClass, String className) {
 		this.context = context;
 		this.filename = filename;
 		this.outerClass = outerClass;
 		this.module = module;
+		this.className = className;
 	}
 	
 	private boolean isPrepared(HighLevelDefinition definition) {
 		if (isPrepared(definition))
 			return context.getJavaClass(definition);
 		
-		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), className, JavaClass.Kind.CLASS);
 		context.setJavaClass(definition, cls);
 		return cls;
 	}
 			context.setJavaNativeClass(definition, nativeClasses.get(nativeTag.value));
 		}
 		
-		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), className, JavaClass.Kind.CLASS);
 		context.setJavaClass(definition, cls);
 		return cls;
 	}

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

  */
 package org.openzen.zenscript.javashared.prepare;
 
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 	
 	@Override
 	public Void visitConst(ConstMember member) {
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType()));
 		module.setFieldInfo(member, field);
 		
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of const");
+			context.logger.debug("Class " + cls.fullName + " not empty because of const");
 		
 		cls.empty = false;
 		return null;
 	@Override
 	public Void visitField(FieldMember member) {
 		// TODO: expansion fields
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType()));
 		module.setFieldInfo(member, field);
 		
 		if (member.hasAutoGetter() || member.hasAutoSetter())
 		JavaMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
-		if (method == null)
-			method = new JavaMethod(
-					cls,
-					getKind(member),
-					name,
-					true,
-					context.getMethodDescriptor(header),
-					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
-					header.getReturnType().type instanceof GenericTypeID,
-					header.useTypeParameters()); 
+		if (method == null) {
+
+			if(member instanceof ConstructorMember) {
+				method = new JavaMethod(
+						cls,
+						getKind(member),
+						name,
+						true,
+						context.getMethodDescriptorConstructor(header, member),
+						JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+						false,
+						header.useTypeParameters()
+				);
+			} else {
+				final JavaMethod.Kind kind = getKind(member);
+				final String descriptor;
+				if (kind == JavaMethod.Kind.EXPANSION && member.definition instanceof ExpansionDefinition) {
+					descriptor = context.getMethodDescriptorExpansion(header, ((ExpansionDefinition) member.definition).target);
+				} else {
+					descriptor = context.getMethodDescriptor(header);
+				}
+				method = new JavaMethod(
+						cls,
+						kind,
+						name,
+						true,
+						descriptor,
+						JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+						header.getReturnType().type instanceof GenericTypeID,
+						header.useTypeParameters());
+			}
+		}
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)
-				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
+				context.logger.debug("Class " + cls.fullName + " not empty because of " + member.describe());
 			
 			cls.empty = false;
 		}

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

 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 		settings = new JavaSourceFormattingSettings.Builder().build();
 	}
 	
-	public JavaSourceModule compile(SemanticModule module, JavaCompileSpace space, String basePackage) {
-		JavaSourceContext context = new JavaSourceContext(helpers, settings, space, module.modulePackage, basePackage);
+	public JavaSourceModule compile(IZSLogger logger, SemanticModule module, JavaCompileSpace space, String basePackage) {
+		JavaSourceContext context = new JavaSourceContext(logger, helpers, settings, space, module.modulePackage, basePackage);
 		
 		JavaSourceModule result = new JavaSourceModule(module.module, module.parameters);
 		context.addModule(module.module, result);

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

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 	private final JavaSyntheticClassGenerator generator;
 	public final JavaSourceSyntheticHelperGenerator helperGenerator;
 	
-	public JavaSourceContext(JavaSourceModule helpers, JavaSourceFormattingSettings settings, JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
-		super(space, modulePackage, basePackage);
+	public JavaSourceContext(IZSLogger logger, JavaSourceModule helpers, JavaSourceFormattingSettings settings, JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
+		super(space, modulePackage, basePackage, logger);
 		
 		typeDescriptorVisitor = new JavaTypeDescriptorVisitor(this);
 		this.generator = new JavaSourceSyntheticTypeGenerator(helpers, settings, this);

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

 /* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
 package org.openzen.zenscript.lexer;
 
-import gnu.trove.iterator.TIntIterator;
-import gnu.trove.map.hash.TIntIntHashMap;
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Represents a compiled DFA. A compiled DFA has a compact representation and
 		return new NFA<>(regexps, tokens, tokenClass).compile();
 	}
 	
-    public TIntIntHashMap[] transitions;
+    public Map<Integer, Integer>[] transitions;
     public T[] finals;
 
     /**
      * @param transitions transitions graph
      * @param finals finals
      */
-    public CompiledDFA(TIntIntHashMap[] transitions, T[] finals)
+    public CompiledDFA(Map<Integer, Integer>[] transitions, T[] finals)
 	{
         this.transitions = transitions;
         this.finals = finals;
 	{
         StringBuilder result = new StringBuilder();
         for (int i = 0; i < transitions.length; i++) {
-            TIntIntHashMap map = transitions[i];
+            Map<Integer, Integer> map = transitions[i];
 
-            TIntIterator it = map.keySet().iterator();
+            Iterator<Integer> it = map.keySet().iterator();
             while (it.hasNext()) {
                 int v = it.next();
                 result.append("edge(");

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

 /* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
 package org.openzen.zenscript.lexer;
 
-import gnu.trove.iterator.TIntIterator;
-import gnu.trove.map.hash.TIntIntHashMap;
-import gnu.trove.map.hash.TIntObjectHashMap;
-import gnu.trove.set.hash.TIntHashSet;
+
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.Map;
 import java.util.Queue;
+import java.util.Set;
 
 /**
  * Implements a DFA. Used as intermediate form when compiling an NFA to a
 
         while (!todo.isEmpty()) {
             DFAState<T> current = todo.poll();
-
-            TIntIterator it = current.transitions.keySet().iterator();
+    
+            Iterator<Integer> it = current.transitions.keySet().iterator();
             while (it.hasNext()) {
                 int k = it.next();
                 DFAState<T> next = current.transitions.get(k);
         }
 
         /* Compile */
-        TIntIntHashMap[] transitions = new TIntIntHashMap[counter];
+        Map<Integer, Integer>[] transitions = new HashMap[counter];
 		@SuppressWarnings("unchecked")
         T[] finals2 = (T[]) Array.newInstance(tokenClass, counter);
 		
         for (DFAState<T> node : nodeList) {
             int index = nodes.get(node);
             finals2[index] = node.finalCode;
-
-            transitions[index] = new TIntIntHashMap();
-            TIntIterator it = node.transitions.keySet().iterator();
+    
+            transitions[index] = new HashMap<>();
+            Iterator<Integer> it = node.transitions.keySet().iterator();
             while (it.hasNext()) {
                 int k = it.next();
                 DFAState<T> next = node.transitions.get(k);
     public DFA<T> optimize()
 	{
         CompiledDFA<T> compiled = compile();
-        TIntIntHashMap[] transitions = compiled.transitions;
+        Map<Integer, Integer>[] transitions = compiled.transitions;
         int size = transitions.length;
 
         /* Collect all edges and determine alphabet */
-        TIntHashSet alphabet = new TIntHashSet();
+        Set<Integer> alphabet = new HashSet<>();
         for (int i = 0; i < size; i++) {
-            TIntIterator it = transitions[i].keySet().iterator();
+            Iterator<Integer> it = transitions[i].keySet().iterator();
             while (it.hasNext()) {
                 int k = it.next();
                 alphabet.add(k);
         boolean changed;
         do {
             changed = false;
-            TIntIterator ita = alphabet.iterator();
+            Iterator<Integer> ita = alphabet.iterator();
             while (ita.hasNext()) {
                 int x = ita.next();
                 for (int i = 0; i < size; i++) {
         } while (changed);
 
         /* Group nodes */
-        TIntObjectHashMap<DFAState<T>> nodeMap = new TIntObjectHashMap<>();
+        Map<Integer, DFAState<T>> nodeMap = new HashMap<>();
         outer: for (int i = 0; i < size; i++) {
             for (int j = 0; j < size; j++) {
                 if (!distinguishable[i][j] && nodeMap.containsKey(j)) {
         }
 
         for (int i = 0; i < compiled.transitions.length; i++) {
-            TIntIterator iter = transitions[i].keySet().iterator();
+            Iterator<Integer> iter = transitions[i].keySet().iterator();
             while (iter.hasNext()) {
                 int k = iter.next();
 
         StringBuilder result = new StringBuilder();
         CompiledDFA<T> dfs = compile();
         for (int i = 0; i < dfs.transitions.length; i++) {
-            TIntIntHashMap map = dfs.transitions[i];
-            
-            TIntIterator it = map.keySet().iterator();
+            Map<Integer, Integer> map = dfs.transitions[i];
+    
+            Iterator<Integer> it = map.keySet().iterator();
             while (it.hasNext()) {
                 int v = it.next();
                 result.append("edge(");
      */
     public static class DFAState<T>
 	{
-        private TIntObjectHashMap<DFAState<T>> transitions;
+        
+        private Map<Integer, DFAState<T>> transitions;
         private T finalCode = null;
 
         /**
          * Creates a new DFA state.
          */
         public DFAState() {
-            transitions = new TIntObjectHashMap<>();
+            transitions = new HashMap<>();
         }
 
         /**

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

 /* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
 package org.openzen.zenscript.lexer;
 
-import gnu.trove.iterator.TIntIterator;
-import gnu.trove.set.hash.TIntHashSet;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
+import java.util.Set;
 
 /**
  * Represents an NFA. NFAs can be compiled from a list of regular expressions.
             NFAState<T> head = new NFAState<>();
             NFAState<T> tail = new NFAState<>();
 
-            TIntIterator iter = processCharList(stream).iterator();
+            Iterator<Integer> iter = processCharList(stream).iterator();
             while (iter.hasNext()) {
                 tail.addTransition(iter.next(), head);
             }
     }
 
     /* Processes a character list */
-    private TIntHashSet processCharList(CharStream stream)
+    private Set<Integer> processCharList(CharStream stream)
 	{
         boolean invert = stream.optional('^');
-        TIntHashSet base = new TIntHashSet();
+        Set<Integer>base = new HashSet();
         do {
             processCharPartial(base, stream);
         } while (!stream.peek(']'));
         if (invert) {
-            TIntHashSet result = new TIntHashSet();
+            Set<Integer>result = new HashSet();
             for (int i = 0; i <= 256; i++) {
                 if (!base.contains(i)) result.add(i);
             }
 
     /* Processes a character partial, which can be a single character or a range
      * of characters. */
-    private void processCharPartial(TIntHashSet out, CharStream stream)
+    private void processCharPartial(Set<Integer>out, CharStream stream)
 	{
         if (stream.optional('.')) {
             for (int i = 0; i <= 256; i++) {

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

 /* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
 package org.openzen.zenscript.lexer;
 
-import java.io.IOException;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.SourceFile;
 
+import java.io.IOException;
+
 /**
  * Represents a token stream. A token stream reads characters from a reader and
  * presents it as a series of tokens. Can be used to implement LL(*) parsers.
             while (dfa.transitions[state].containsKey(reader.peek())) {
 				char c = (char) reader.next();
                 value.append(c);
-                state = dfa.transitions[state].get(c);
+                state = dfa.transitions[state].get((int)c);
             }
 			
             if (dfa.finals[state] != null) {

Parser/src/main/java/org/openzen/zenscript/parser/EscapableBracketParser.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.parser;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.lexer.ZSToken;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+import org.openzen.zenscript.parser.expression.ParsedExpressionBinary;
+import org.openzen.zenscript.parser.expression.ParsedExpressionString;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Hoofdgebruiker and kindlich
+ */
+public class EscapableBracketParser implements BracketExpressionParser {
+    private final FunctionalMemberRef method;
+    private final TypeID targetType;
+
+    public EscapableBracketParser(GlobalTypeRegistry registry, FunctionalMemberRef method) {
+        if (!method.isStatic())
+            throw new IllegalArgumentException("Method must be static");
+        if (method.getHeader().getNumberOfTypeParameters() > 0)
+            throw new IllegalArgumentException("Method cannot have type parameters");
+
+        this.method = method;
+        this.targetType = registry.getForDefinition(method.getTarget().definition);
+    }
+
+    @Override
+    public ParsedExpression parse(CodePosition position, ZSTokenParser tokens) throws ParseException {
+        StringBuilder string = new StringBuilder();
+
+        //This list will contain the BEP calls
+        //If this is only a normal BEP, then it will contain exactly one String ParsedExpression.
+        final List<ParsedExpression> expressionList = new ArrayList<>();
+
+        while (tokens.optional(ZSTokenType.T_GREATER) == null) {
+            ZSToken next = tokens.next();
+
+            if (next.type != ZSTokenType.T_DOLLAR) {
+                string.append(next.content);
+                string.append(tokens.getLastWhitespace());
+                continue;
+            }
+
+            //We found a $, now check that it has a { directly after it.
+            final String ws = tokens.getLastWhitespace();
+            if (!ws.isEmpty()) {
+                //$  {..} is not ${..} so we print it as literal
+                string.append(next.content).append(ws);
+                continue;
+            }
+
+            next = tokens.next();
+            //Now we check if it is a {
+            if (next.type == ZSTokenType.T_AOPEN) {
+                if (string.length() != 0) {
+                    expressionList.add(new ParsedExpressionString(position, string.toString(), false));
+                    string = new StringBuilder();
+                }
+                expressionList.add(ParsedExpression.parse(tokens));
+                tokens.required(ZSTokenType.T_ACLOSE, "} expected.");
+                string.append(tokens.getLastWhitespace());
+            } else {
+                //No { after the $, so we treat them both as literal
+                string.append("$").append(ws); //Technically, the whitespace here is empty, but let's be sure
+                string.append(next.content).append(tokens.getLastWhitespace());
+            }
+
+        }
+
+        if (string.length() != 0) {
+            expressionList.add(new ParsedExpressionString(position, string.toString(), false));
+        }
+
+        return new StaticMethodCallExpression(position, expressionList);
+    }
+
+    private class StaticMethodCallExpression extends ParsedExpression {
+
+        private final ParsedExpression call;
+
+        public StaticMethodCallExpression(CodePosition position, List<ParsedExpression> expressions) {
+            super(position);
+            ParsedExpression p = null;
+            for (ParsedExpression expression : expressions) {
+                p = p == null ? expression : new ParsedExpressionBinary(expression.position, p, expression, OperatorType.ADD);
+            }
+
+            this.call = p;
+        }
+
+        @Override
+        public IPartialExpression compile(ExpressionScope scope) throws CompileException {
+            final Expression methodCall = call.compile(scope.withHint(StringTypeID.AUTO)).eval();
+            final CallArguments arguments = new CallArguments(methodCall);
+            return new CallStaticExpression(position, targetType, method, method.getHeader(), arguments);
+        }
+
+        @Override
+        public boolean hasStrongType() {
+            return true;
+        }
+    }
+}

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

+package org.openzen.zenscript.parser;
+
+import org.openzen.zencode.shared.LiteralSourceFile;
+import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.ModuleSpace;
+import org.openzen.zenscript.codemodel.SemanticModule;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.parser.logger.*;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class FolderPackage {
+    
+    private Map<String, List<SourceFile>> files = new HashMap<>();
+    
+    public FolderPackage(File file) {
+        ArrayList<File> foundFiles = new ArrayList<>();
+        getFiles(file, foundFiles);
+    
+        String srcString = File.separator + "src" + File.separator;
+        foundFiles.stream().filter(fil -> (fil.getPath()+File.separator).substring(file.getPath().length()+ File.separator.length()).indexOf(srcString) > 0).forEach(fil -> {
+            String name = (fil.getPath() + File.separator).substring(file.getPath().length() + File.separator.length());
+            int slash = name.indexOf(srcString);
+            String moduleName = name.substring(0, slash);
+            String filename = name.substring(slash + srcString.length());
+            if(!files.containsKey(moduleName))
+                files.put(moduleName, new ArrayList<>());
+            
+            try {
+                if(!fil.isDirectory())
+                    files.get(moduleName).add(new LiteralSourceFile(filename, new BufferedReader(new FileReader(fil)).lines().collect(Collectors.joining("\n"))));
+                else
+                    files.get(moduleName).add(new LiteralSourceFile(filename, ""));
+            } catch(FileNotFoundException e) {
+                e.printStackTrace();
+            }
+            
+        });
+    }
+    
+    public void getFiles(File parent, List<File> files) {
+        if(parent.isDirectory()) {
+            for(File file : parent.listFiles()) {
+                if(file.isDirectory()) {
+                    getFiles(file, files);
+                }
+            }
+        }
+        files.add(parent);
+    }
+	
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ParserLogger logger) throws ParseException {
+		return loadModule(space, name, bracketParser, dependencies, scriptParameters, new ZSPackage(space.rootPackage, name), logger);
+	}
+	
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ZSPackage pkg, ParserLogger logger) throws ParseException {
+		List<SourceFile> sourceFiles = files.get(name);
+		if (sourceFiles == null)
+			return null; // no such module
+		
+		Module scriptModule = new Module(name);
+		CompilingPackage scriptPackage = new CompilingPackage(pkg, scriptModule);
+		ParsedFile[] files = new ParsedFile[sourceFiles.size()];
+		for (int i = 0; i < files.length; i++)
+			files[i] = ParsedFile.parse(scriptPackage, bracketParser, sourceFiles.get(i));
+		
+		SemanticModule scripts = ParsedFile.compileSyntaxToSemantic(
+				dependencies,
+				scriptPackage,
+				files,
+				space,
+				scriptParameters,
+                logger);
+		return scripts.normalize();
+	}
+}