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

@@ -29,9 +29,7 @@ public class DefinitionTypeID implements TypeID {
 	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);
 	}
@@ -50,7 +48,7 @@ public class DefinitionTypeID implements TypeID {
 		this.definition = definition;
 		this.typeArguments = typeArguments;
 		this.outer = outer;
-		
+
 		normalized = isDenormalized() ? normalize(typeRegistry) : this;
 		if (normalized instanceof DefinitionTypeID && ((DefinitionTypeID)normalized).isDenormalized())
 			throw new AssertionError();
@@ -63,10 +61,8 @@ public class DefinitionTypeID implements TypeID {
 		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) {
@@ -114,7 +110,6 @@ public class DefinitionTypeID implements TypeID {
 	public DefinitionTypeID(HighLevelDefinition definition) {
 		this.definition = definition;
 		this.typeArguments = TypeID.NONE;
-		this.superType = definition.getSuperType();
 		this.outer = null;
 	}
 	
@@ -185,7 +180,8 @@ public class DefinitionTypeID implements TypeID {
 				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

@@ -9,6 +9,8 @@ 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.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
@@ -89,4 +91,12 @@ public interface TypeID {
 	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

@@ -518,11 +518,8 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 				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

@@ -423,6 +423,8 @@ public final class TypeMembers {
 			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;
@@ -466,6 +468,8 @@ public final class TypeMembers {
 		toType = toType.getNormalized();
 		if (canCastImplicit(toType))
 			return true;
+		if (type.canCastExplicit(toType))
+			return true;
 		
 		for (TypeMember<CasterMemberRef> caster : casters) {
 			if (caster.member.toType == toType)
@@ -552,6 +556,8 @@ public final class TypeMembers {
 			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);
@@ -578,6 +584,8 @@ public final class TypeMembers {
 		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

@@ -1,9 +1,13 @@
 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;
 
@@ -17,4 +21,22 @@ public class JavaFunctionalInterfaceTypeID extends FunctionTypeID {
         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

@@ -5,6 +5,6 @@ import org.openzen.zenscript.lexer.*;
 
 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

@@ -25,7 +25,7 @@ import org.openzen.zenscript.codemodel.type.TypeID;
  * @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 + ")");
@@ -33,7 +33,7 @@ public interface IParsedType {
 		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;
 		
@@ -67,7 +67,7 @@ public interface IParsedType {
 		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 {
@@ -85,7 +85,7 @@ public interface IParsedType {
 		return typeArguments;
 	}
 	
-	public static IParsedType tryParse(ZSTokenParser tokens) throws ParseException {
+	static IParsedType tryParse(ZSTokenParser tokens) throws ParseException {
 		CodePosition position = tokens.getPosition();
 		
 		IParsedType result;
@@ -211,7 +211,7 @@ public interface IParsedType {
 		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()];
@@ -222,7 +222,7 @@ public interface IParsedType {
 		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()];
@@ -233,13 +233,13 @@ public interface IParsedType {
 		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;
 	}
 }