Fixed remaining critical bugs in the current implementation.

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

 		
 		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
 		for (int i = 0; i < header.parameters.length; i++) {
-			if (arguments.arguments[i].type != header.parameters[i].type)
+			if (!arguments.arguments[i].type.equals(header.parameters[i].type))
 				return false;
 		}
 		
 	public FunctionHeader instanceForCall(GlobalTypeRegistry registry, CallArguments arguments) {
 		if (arguments.getNumberOfTypeArguments() > 0) {
 			Map<TypeParameter, StoredType> typeParameters = StoredType.getMapping(this.typeParameters, arguments.typeArguments);
-			return withGenericArguments(
-					registry,
-					new GenericMapper(registry, typeParameters));
+			return instance(new GenericMapper(registry, typeParameters));
 		} else {
 			return this;
 		}
 		if (typeParameters.length > 0)
 			mapper = mapper.getInner(registry, StoredType.getSelfMapping(registry, typeParameters));
 		
+		return instance(mapper);
+	}
+	
+	private FunctionHeader instance(GenericMapper mapper) {
 		StoredType returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		for (int i = 0; i < parameters.length; i++) {

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

 	}
 	
 	public StoredType map(GenericTypeID type) {
-		if (!mapping.containsKey(type.parameter))
-			throw new IllegalStateException("No mapping found for type " + 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();
 	}

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 	@Override
 	public TypeID getType(CodePosition position, List<GenericName> name) {
 		if (imports.containsKey(name.get(0).name)) {
+			HighLevelDefinition definition = imports.get(name.get(0).name);
+			if (definition.getNumberOfGenericParameters() != name.get(0).arguments.length)
+				return new InvalidTypeID(position, CompileExceptionCode.INVALID_TYPE_ARGUMENTS, "Invalid number of type arguments");
+			
 			return GenericName.getInnerType(
 					getTypeRegistry(),
-					getTypeRegistry().getForDefinition(imports.get(name.get(0).name), name.get(0).arguments),
+					getTypeRegistry().getForDefinition(definition, name.get(0).arguments),
 					name,
 					1);
 		}

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

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

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

 			typeParameters = StoredType.getSelfMapping(outer.getTypeRegistry(), expansion.typeParameters);
 		} else {
 			DefinitionTypeID definitionType = outer.getTypeRegistry().getForMyDefinition(definition);
-			type = definitionType.stored(BorrowStorageTag.THIS);
+			type = definitionType.stored();
 			
 			List<TypeParameter> typeParameterList = new ArrayList<>();
 			while (definitionType != null) {

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

 	}
 	
 	public StoredType getNormalized() {
-		return type.getNormalized() == type ? this : new StoredType(type, storage);
+		return type.getNormalized() == type ? this : new StoredType(type.getNormalized(), storage);
 	}
 	
 	public StoredType getSuperType(GlobalTypeRegistry registry) {

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

 				ARRAY_INDEXGET);
 		
 		if (dimension == 1) {
-			FunctionHeader sliceHeader = new FunctionHeader(type, new FunctionParameter(RangeTypeID.USIZE.stored, "range"));
+			FunctionHeader sliceHeader = new FunctionHeader(new StoredType(type.type, UniqueStorageTag.INSTANCE), new FunctionParameter(RangeTypeID.USIZE.stored, "range"));
 			operator(
 					definition,
 					OperatorType.INDEXGET,
 					VOID.stored,
 					null,
 					null,
-					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter).stored(BorrowStorageTag.INVOCATION), dimension).stored(BorrowStorageTag.INVOCATION), "original"),
+					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter).stored(), dimension).stored(BorrowStorageTag.INVOCATION), "original"),
 					new FunctionParameter(registry.getFunction(mappedConstructorHeaderWithoutIndex).stored(BorrowStorageTag.INVOCATION), "projection"));
 			members.addConstructor(new ConstructorMember(
 					BUILTIN,
 					VOID.stored,
 					null,
 					null,
-					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter).stored(BorrowStorageTag.INVOCATION), dimension).stored(BorrowStorageTag.INVOCATION), "original"),
+					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter).stored(), dimension).stored(BorrowStorageTag.INVOCATION), "original"),
 					new FunctionParameter(registry.getFunction(mappedConstructorHeaderWithIndex).stored(BorrowStorageTag.INVOCATION), "projection"));
 			constructor(definition, ARRAY_CONSTRUCTOR_PROJECTED_INDEXED, mappedConstructorFunctionWithIndex);
 		}

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

 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
-			FunctionHeader header = method.member.getHeader();
+			FunctionHeader header = method.member.getHeader().instanceForCall(scope.getTypeRegistry(), arguments);
 			if (header.matchesExactly(arguments, scope))
 				return method.member;
 		}
 			
 			scope.getPreparer().prepare(method.member.getTarget());
 			
-			FunctionHeader header = method.member.getHeader();
+			FunctionHeader header = method.member.getHeader().instanceForCall(scope.getTypeRegistry(), arguments);
 			if (!header.matchesImplicitly(arguments, scope))
 				continue;
 			
 			if (selected != null) {
 				StringBuilder explanation = new StringBuilder();
-				explanation.append("Function A: ").append(selected.getHeader().toString()).append("\n");
-				explanation.append("Function B: ").append(method.member.getHeader().toString());
+				FunctionHeader selectedHeader = selected.getHeader().instanceForCall(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());
 			}
 			
 					continue;
 				}
 				
-				message.append(method.member.getHeader().explainWhyIncompatible(scope, arguments)).append("\n");
+				FunctionHeader instancedHeader = method.member.getHeader().instanceForCall(scope.getTypeRegistry(), arguments);
+				message.append(instancedHeader.explainWhyIncompatible(scope, arguments)).append("\n");
 			}
 			
 			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching method found for " + name + ":\n" + message.toString());

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

 				return castEquivalent(position, caster.member.cast(position, value, implicit), toType);
 		}
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
-			if (implementation.member.implementsType.equals(toType.type))
+			if (implementation.member.implementsType.getNormalized() == toType.type)
 				return castEquivalent(position, new InterfaceCastExpression(position, value, toType.type.stored(type.getActualStorage())), toType);
 		}
 		if (extendsType(toType.type))

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

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
 		
 		register(range.cls.internalName, rangeWriter.toByteArray());
 	}
+	
+	private void createSharedClass() {
+		// TODO
+	}
 
     public String getLambdaCounter() {
         return "lambda" + ++lambdaCounter;
 		public void synthesizeRange(JavaSynthesizedRange range) {
 			createRangeClass(range);
 		}
+		
+		@Override
+		public void synthesizeShared() {
+			createSharedClass();
+		}
 	}
 }

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

 	private final GlobalTypeRegistry registry;
 	private final Map<String, JavaSynthesizedFunction> functions = new HashMap<>();
 	private final Map<String, JavaSynthesizedRange> ranges = new HashMap<>();
+	private boolean useShared = false;
 	
 	public JavaContext(GlobalTypeRegistry registry) {
 		this.registry = registry;
 	
 	public abstract String getDescriptor(StoredType type);
 	
+	public void useShared() {
+		if (useShared)
+			return;
+		
+		useShared = true;
+		getTypeGenerator().synthesizeShared();
+	}
+	
 	public String getMethodDescriptor(FunctionHeader header) {
 		return getMethodDescriptor(header, false);
 	}

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

 	void synthesizeFunction(JavaSynthesizedFunction function);
 	
 	void synthesizeRange(JavaSynthesizedRange range);
+	
+	void synthesizeShared();
 }

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

 	}
 	
 	public String process(StoredType type) {
-		if (JavaTypeUtils.isShared(type))
+		if (JavaTypeUtils.isShared(type)) {
+			context.useShared();
 			return "L" + JavaClass.SHARED.internalName + ";";
+		}
 		
 		return type.type.accept(this);
 	}

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

 	
 	@Override
 	public ExpressionString visitStorageCast(StorageCastExpression expression) {
-		ExpressionString value = expression.accept(this);
+		ExpressionString value = expression.value.accept(this);
 		if (expression.value.type.isDestructible()) {
 			StorageTag fromTag = expression.value.type.getActualStorage();
 			StorageTag toTag = expression.type.getActualStorage();
 
 	@Override
 	public ExpressionString visitThis(ThisExpression expression) {
-		if (scope.isExpansion || scope.thisType == expression.type) {
+		if (scope.isExpansion || scope.thisType == expression.type.type) {
 			return new ExpressionString(scope.isExpansion ? "self" : "this", JavaOperator.PRIMARY);
 		} else {
 			return new ExpressionString(constructThisName((DefinitionTypeID)expression.type.type) + ".this", JavaOperator.MEMBER);

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

 		writeFile(range.cls, importer, contents);
 	}
 	
+	@Override
+	public void synthesizeShared() {
+		JavaSourceImporter importer = new JavaSourceImporter(JavaClass.SHARED);
+		
+		StringBuilder contents = new StringBuilder();
+		contents.append("public final class Shared<T extends AutoCloseable> {\n");
+		contents.append(settings.indent).append("private final T value;\n");
+		contents.append(settings.indent).append("private int refcount = 1;\n");
+		contents.append(settings.indent).append("\n");
+		contents.append(settings.indent).append("public Shared(T value) {\n");
+		contents.append(settings.indent).append(settings.indent).append("this.value = value;\n");
+		contents.append(settings.indent).append("}\n");
+		contents.append(settings.indent).append("\n");
+		contents.append(settings.indent).append("public synchronized void addRef() {\n");
+		contents.append(settings.indent).append(settings.indent).append("refcount++;\n");
+		contents.append(settings.indent).append("}\n");
+		contents.append(settings.indent).append("\n");
+		contents.append(settings.indent).append("public synchronized void release() {\n");
+		contents.append(settings.indent).append(settings.indent).append("refcount--;\n");
+		contents.append(settings.indent).append(settings.indent).append("if (refcount == 0) {\n");
+		contents.append(settings.indent).append(settings.indent).append(settings.indent).append("try {\n");
+		contents.append(settings.indent).append(settings.indent).append(settings.indent).append(settings.indent).append("value.close();\n");
+		contents.append(settings.indent).append(settings.indent).append(settings.indent).append("} catch (Exception ex) {}\n");
+		contents.append(settings.indent).append(settings.indent).append("}\n");
+		contents.append(settings.indent).append("}\n");
+		contents.append("}\n");
+		
+		writeFile(JavaClass.SHARED, importer, contents);
+	}
+	
+	private void line(StringBuilder output, int level) {
+		for (int i = 0; i < level; i++)
+			output.append(settings.indent);
+	}
+	
 	private void writeFile(JavaClass cls, JavaSourceImporter importer, StringBuilder contents) {
 		if (!directory.exists())
 			directory.mkdirs();

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

 import org.openzen.zenscript.codemodel.scope.LambdaScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 		if (header.getReturnType().isBasic(BasicTypeID.UNDETERMINED)) {
 			StoredType returnType = statements.getReturnType();
 			if (returnType == null)
-				throw new CompileException(position, CompileExceptionCode.CANNOT_INFER_RETURN_TYPE, "Could not infer return type");
+				returnType = new InvalidTypeID(position, CompileExceptionCode.CANNOT_INFER_RETURN_TYPE, "Could not infer return type").stored();
 			
-			header.setReturnType(statements.getReturnType());
+			header.setReturnType(returnType);
 		}
 		
 		if (!scope.genericInferenceMap.isEmpty()) {

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

 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
+import org.openzen.zenscript.codemodel.type.member.TypeMember;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 /**
 	
 	public static Expression compile(CodePosition position, StoredType type, ParsedCallArguments arguments, ExpressionScope scope) {
 		try {
-			TypeMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
+			TypeMembers members = scope.getTypeMembers(type);
+			TypeMemberGroup constructors = members.getOrCreateGroup(OperatorType.CONSTRUCTOR);
+			for (TypeMember<FunctionalMemberRef> member : constructors.getMethodMembers()) {
+				if (member.member.getBuiltin() == BuiltinID.ARRAY_CONSTRUCTOR_PROJECTED)
+					System.out.println("X");
+			}
+
 			List<StoredType>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.arguments.size());
 			CallArguments compiledArguments = arguments.compileCall(position, scope, null, constructors);
 			FunctionalMemberRef member = constructors.selectMethod(position, scope, compiledArguments, true, true);

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

 	NO_SUCH_STORAGE_TYPE,
 	INVALID_STORAGE_TYPE_ARGUMENTS,
 	STORAGE_NOT_SUPPORTED,
-	INCOMPATIBLE_STORAGE_TAG
+	INCOMPATIBLE_STORAGE_TAG,
+	INVALID_TYPE_ARGUMENTS
 }

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

 		statement.value.accept(new ExpressionValidator(validator, new StatementExpressionScope()));
 		
 		for (SwitchCase switchCase : statement.cases) {
+			for (Statement caseStatement : switchCase.statements)
+				caseStatement.accept(this);
+			
 			// TODO: finish this
 		}