WIP fixing stdlibs and compilation on the new version

Added functional interface types (Java)

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

 	public final TypeID[] typeArguments;
 	public final DefinitionTypeID outer;
 	private TypeID normalized;
-	
-	public TypeID superType;
-	
+
 	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, TypeID[] typeArguments) {
 		this(typeRegistry, definition, typeArguments, null);
 	}
 		this.definition = definition;
 		this.typeArguments = typeArguments;
 		this.outer = outer;
-		
+
 		normalized = isDenormalized() ? normalize(typeRegistry) : this;
 		if (normalized instanceof DefinitionTypeID && ((DefinitionTypeID)normalized).isDenormalized())
 			throw new AssertionError();
 		for (TypeID typeArgument : typeArguments)
 			if (!typeArgument.getNormalized().equals(typeArgument))
 				return true;
-		if (outer != null && !outer.getNormalized().equals(outer))
-			return true;
-		
-		return false;
+
+		return outer != null && !outer.getNormalized().equals(outer);
 	}
 	
 	private TypeID normalize(GlobalTypeRegistry typeRegistry) {
 	public DefinitionTypeID(HighLevelDefinition definition) {
 		this.definition = definition;
 		this.typeArguments = TypeID.NONE;
-		this.superType = definition.getSuperType();
 		this.outer = null;
 	}
 	
 				if (typeArgument.hasInferenceBlockingTypeParameters(parameters))
 					return true;
 		}
-		
+
+		TypeID superType = definition.getSuperType();
 		return superType != null && superType.hasInferenceBlockingTypeParameters(parameters);
 	}
 

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

 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	default boolean isDefinition(HighLevelDefinition definition) {
 		return false;
 	}
+
+	default boolean canCastImplicit(TypeID other) { return false; }
+
+	default boolean canCastExplicit(TypeID other) { return false; }
+
+	default Expression castImplicit(CodePosition position, TypeID other, Expression value) { return null; }
+
+	default Expression castExplicit(CodePosition position, TypeID other, Expression value) { return null; }
 }

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

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

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

 			throw new IllegalArgumentException("Cannot cast to undetermined type!");
 		if (type == BasicTypeID.NULL && toType.isOptional())
 			return true;
+		if (type.canCastImplicit(toType))
+			return true;
 		
 		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
 			return true;
 		toType = toType.getNormalized();
 		if (canCastImplicit(toType))
 			return true;
+		if (type.canCastExplicit(toType))
+			return true;
 		
 		for (TypeMember<CasterMemberRef> caster : casters) {
 			if (caster.member.toType == toType)
 			return value;
 		if (type == toType)
 			return value;
+		if (type.canCastImplicit(toType))
+			return type.castImplicit(position, toType, value);
 
 		if (type == BasicTypeID.NULL && toType.isOptional())
 			return new NullExpression(position, toType);
 		toType = toType.getNormalized();
 		if (this.canCastImplicit(toType))
 			return castImplicit(position, value, toType, false);
+		if (type.canCastExplicit(toType))
+			return type.castExplicit(position, toType, value);
 		
         final TypeMembers typeMembers = cache.get(type);
         if(this.type != typeMembers.type && typeMembers.canCast(toType)) {

JavaShared/src/main/java/org/openzen/zenscript/javashared/types/JavaFunctionalInterfaceTypeID.java

 package org.openzen.zenscript.javashared.types;
 
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.expressions.JavaFunctionInterfaceCastExpression;
 
 import java.lang.reflect.Method;
 
         this.functionalInterfaceMethod = functionalInterfaceMethod;
         this.method = method;
     }
+
+    @Override
+    public Expression castImplicit(CodePosition position, TypeID other, Expression value) {
+        if (other instanceof JavaFunctionalInterfaceTypeID) {
+            JavaFunctionalInterfaceTypeID otherType = (JavaFunctionalInterfaceTypeID)other;
+            if (header.isEquivalentTo(otherType.header))
+                return new JavaFunctionInterfaceCastExpression(position, otherType, value);
+
+            return null;
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public Expression castExplicit(CodePosition position, TypeID other, Expression value) {
+        return this.castImplicit(position, other, value);
+    }
 }

Parser/src/main/java/org/openzen/zenscript/parser/logger/ParserLogger.java

 
 public interface ParserLogger extends IZSLogger, CompileExceptionLogger {
     default void logParseException(ParseException exception) {
-        throwingErr("Parser Exeption", exception);
+        throwingErr("Parser Exception @ " + exception.position.toString() + " : " + exception.message, exception);
     }
 }

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

  * @author Hoofdgebruiker
  */
 public interface IParsedType {
-	public static IParsedType parse(ZSTokenParser tokens) throws ParseException {
+	static IParsedType parse(ZSTokenParser tokens) throws ParseException {
 		IParsedType result = tryParse(tokens);
 		if (result == null)
 			throw new ParseException(tokens.getPosition(), "Type expected (got " + tokens.peek().content + ")");
 		return result;
 	}
 	
-	public static List<IParsedType> parseTypeArguments(ZSTokenParser tokens) throws ParseException {
+	static List<IParsedType> parseTypeArguments(ZSTokenParser tokens) throws ParseException {
 		if (!tokens.isNext(T_LESS))
 			return null;
 		
 		return genericParameters;
 	}
 	
-	public static List<IParsedType> parseTypeArgumentsForCall(ZSTokenParser tokens) throws ParseException {
+	static List<IParsedType> parseTypeArgumentsForCall(ZSTokenParser tokens) throws ParseException {
 		List<IParsedType> typeArguments = null;
 		if (tokens.optional(ZSTokenType.T_LESS) != null) {
 			try {
 		return typeArguments;
 	}
 	
-	public static IParsedType tryParse(ZSTokenParser tokens) throws ParseException {
+	static IParsedType tryParse(ZSTokenParser tokens) throws ParseException {
 		CodePosition position = tokens.getPosition();
 		
 		IParsedType result;
 		return result;
 	}
 	
-	public static TypeID[] compileList(List<IParsedType> typeParameters, TypeResolutionContext context) {
+	static TypeID[] compileList(List<IParsedType> typeParameters, TypeResolutionContext context) {
 		TypeID[] result = TypeID.NONE;
 		if (typeParameters != null) {
 			result = new TypeID[typeParameters.size()];
 		return result;
 	}
 	
-	public static TypeID[] compileTypes(List<IParsedType> typeParameters, TypeResolutionContext context) {
+	static TypeID[] compileTypes(List<IParsedType> typeParameters, TypeResolutionContext context) {
 		TypeID[] result = TypeID.NONE;
 		if (typeParameters != null && typeParameters.size() > 0) {
 			result = new TypeID[typeParameters.size()];
 		return result;
 	}
 	
-	public TypeID compile(TypeResolutionContext context);
+	TypeID compile(TypeResolutionContext context);
 	
-	public default AnnotationDefinition compileAnnotation(BaseScope scope) {
+	default AnnotationDefinition compileAnnotation(BaseScope scope) {
 		return null;
 	}
 	
-	public default TypeID[] compileTypeArguments(BaseScope scope) {
+	default TypeID[] compileTypeArguments(BaseScope scope) {
 		return TypeID.NONE;
 	}
 }