Added support for functional interfaces.

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

 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaFunctionalInterfaceStorageTag;
 import org.openzen.zenscript.javashared.JavaImplementation;
 import org.openzen.zenscript.javashared.JavaMethod;
 import stdlib.Strings;
 			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
 			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
 			for (AnnotatedType bound : typeVariable.getAnnotatedBounds()) {
-				TypeID type = loadType(context, bound);
+				TypeID type = loadType(context, bound).type;
 				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
 			}
 			typeParameters[i] = parameter;
 			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
 			
 			if (cls.getAnnotatedSuperclass() != null && shouldLoadType(cls.getAnnotatedSuperclass().getType())) {
-				definition.setSuperType(loadType(context, cls.getAnnotatedSuperclass()));
+				definition.setSuperType(loadType(context, cls.getAnnotatedSuperclass()).type);
 			}
 		}
 		
 		for (AnnotatedType iface : cls.getAnnotatedInterfaces()) {
 			if (shouldLoadType(iface.getType())) {
-				TypeID type = loadType(context, iface);
+				TypeID type = loadType(context, iface).type;
 				ImplementationMember member = new ImplementationMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, type);
 				definition.members.add(member);
 				compiled.setImplementationInfo(member, new JavaImplementation(true, javaClass));
 			context.put(javaTypeParameter, typeParameters[i]);
 			
 			for (AnnotatedType bound : javaTypeParameter.getAnnotatedBounds())
-				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(context, bound)));
+				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(context, bound).type));
 		}
 		
 		if (exceptionTypes.length > 1)
 	}
 	
 	private StoredType loadStoredType(TypeVariableContext context, AnnotatedType annotatedType) {
-		TypeID baseType = loadType(context, annotatedType);
-		return baseType.stored();
+		return loadType(context, annotatedType);
 	}
 	
-	private TypeID loadType(TypeVariableContext context, AnnotatedType annotatedType) {
+	private StoredType loadType(TypeVariableContext context, AnnotatedType annotatedType) {
 		if (annotatedType.isAnnotationPresent(ZenCodeType.USize.class))
-			return BasicTypeID.USIZE;
+			return BasicTypeID.USIZE.stored;
 		else if (annotatedType.isAnnotationPresent(ZenCodeType.NullableUSize.class))
-			return registry.getOptional(BasicTypeID.USIZE);
+			return registry.getOptional(BasicTypeID.USIZE).stored();
 		
 		boolean nullable = annotatedType.isAnnotationPresent(ZenCodeType.Nullable.class);
 		boolean unsigned = annotatedType.isAnnotationPresent(ZenCodeType.Unsigned.class);
 		return loadType(context, type, nullable, unsigned);
 	}
 	
-	private TypeID loadType(TypeVariableContext context, Type type, boolean nullable, boolean unsigned) {
+	private StoredType loadType(TypeVariableContext context, Type type, boolean nullable, boolean unsigned) {
 		if (type instanceof Class) {
 			Class<?> classType = (Class<?>) type;
 			if (unsigned) {
 				if (unsignedByClass.containsKey(classType))
-					return unsignedByClass.get(classType);
+					return unsignedByClass.get(classType).stored();
 				else
 					throw new IllegalArgumentException("This class cannot be used as unsigned: " + classType);
 			} else if (classType.isArray()) {
-				return registry.getArray(loadType(context, classType.getComponentType(), false, false).stored(), 1);
+				return registry.getArray(loadType(context, classType.getComponentType(), false, false), 1).stored();
+			} else if (classType.isAnnotationPresent(FunctionalInterface.class)) {
+				return loadFunctionalInterface(context, classType, new Type[0]);
 			}
 			
 			if (typeByClass.containsKey(classType))
-				return typeByClass.get(classType);
+				return typeByClass.get(classType).stored();
 			
 			HighLevelDefinition definition = addClass(classType);
-			return registry.getForDefinition(definition);
+			return registry.getForDefinition(definition).stored();
 		} else if (type instanceof ParameterizedType) {
 			ParameterizedType parameterizedType = (ParameterizedType) type;
 			Class<?> rawType = (Class) parameterizedType.getRawType();
+			if (rawType.isAnnotationPresent(FunctionalInterface.class))
+				return loadFunctionalInterface(context, rawType, parameterizedType.getActualTypeArguments());
 			
 			HighLevelDefinition definition = addClass(rawType);
 			Type[] parameters = parameterizedType.getActualTypeArguments();
 			StoredType[] codeParameters = new StoredType[parameters.length];
 			for (int i = 0; i < parameters.length; i++)
-				codeParameters[i] = loadType(context, parameters[i], false, false).stored();
+				codeParameters[i] = loadType(context, parameters[i], false, false);
 			
-			return registry.getForDefinition(definition, codeParameters);
+			return registry.getForDefinition(definition, codeParameters).stored();
 		} else if (type instanceof TypeVariable) {
 			TypeVariable variable = (TypeVariable)type;
-			return registry.getGeneric(context.get(variable));
+			return registry.getGeneric(context.get(variable)).stored();
 		} else {
 			throw new IllegalArgumentException("Could not analyze type: " + type);
 		}
 	}
 	
+	private StoredType loadFunctionalInterface(TypeVariableContext loadContext, Class<?> cls, Type[] parameters) {
+		Method functionalInterfaceMethod = getFunctionalInterfaceMethod(cls);
+		TypeVariableContext context = convertTypeParameters(cls);
+		FunctionHeader header = getHeader(context, functionalInterfaceMethod);
+		
+		Map<TypeParameter, StoredType> mapping = new HashMap<>();
+		TypeVariable[] javaParameters = cls.getTypeParameters();
+		for (int i = 0; i < javaParameters.length; i++)
+			mapping.put(context.get(javaParameters[i]), loadType(loadContext, parameters[i], false, false));
+		
+		StorageTag tag = new JavaFunctionalInterfaceStorageTag(functionalInterfaceMethod);
+		return registry.getFunction(header).stored(tag);
+	}
+	
+	private <T> TypeVariableContext convertTypeParameters(Class<T> cls) {
+		TypeVariableContext context = new TypeVariableContext();
+		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
+		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
+			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
+			for (AnnotatedType bound : typeVariable.getAnnotatedBounds()) {
+				TypeID type = loadType(context, bound).type;
+				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
+			}
+			typeParameters[i] = parameter;
+			context.put(typeVariable, parameter);
+		}
+		return context;
+	}
+	
+	private Method getFunctionalInterfaceMethod(Class<?> functionalInterface) {
+		for (Method method : functionalInterface.getDeclaredMethods()) {
+			if (!method.isDefault())
+				return method;
+		}
+		
+		return null;
+	}
+	
 	private int getMethodModifiers(Method method) {
 		int result = Modifiers.PUBLIC;
 		if (isStatic(method.getModifiers()))

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import java.lang.reflect.Method;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
+
+public class JavaFunctionalInterfaceStorageTag implements StorageTag {
+	public final Method funtionalInterfaceMethod;
+	
+	public JavaFunctionalInterfaceStorageTag(Method functionalInterfaceMethod) {
+		this.funtionalInterfaceMethod = functionalInterfaceMethod;
+	}
+
+	@Override
+	public StorageType getType() {
+		return JavaFunctionalInterfaceStorageType.INSTANCE;
+	}
+
+	@Override
+	public boolean canCastTo(StorageTag other) {
+		return other instanceof JavaFunctionalInterfaceStorageTag
+				|| other instanceof AutoStorageTag
+				|| other instanceof SharedStorageTag
+				|| other instanceof BorrowStorageTag;
+	}
+
+	@Override
+	public boolean canCastFrom(StorageTag other) {
+		return other instanceof JavaFunctionalInterfaceStorageTag
+				|| other instanceof AutoStorageTag
+				|| other instanceof SharedStorageTag
+				|| other instanceof UniqueStorageTag;
+	}
+
+	@Override
+	public boolean isDestructible() {
+		return false;
+	}
+
+	@Override
+	public boolean isConst() {
+		return true;
+	}
+
+	@Override
+	public boolean isImmutable() {
+		return true;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaFunctionalInterfaceStorageType implements StorageType {
+	public static final JavaFunctionalInterfaceStorageType INSTANCE = new JavaFunctionalInterfaceStorageType();
+
+	private JavaFunctionalInterfaceStorageType() {}
+	
+	@Override
+	public String getName() {
+		return "JavaFunctionalInterface";
+	}
+
+	@Override
+	public StorageTag instance(CodePosition position, String[] arguments) {
+		throw new UnsupportedOperationException("This tag can only be instanced by java interfacing code");
+	}
+}

ScriptingExample/scripts/integration.zs

 
 var count = 10;
 floatMethod(5f * count);
+
+invokeFunctional(name => "Hello " + name);

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Globals.java

 		System.out.println(argument);
 	}
 	
+	@Global
+	public static void invokeFunctional(MyFunctionalInterface greeter) {
+		System.out.println("doSomething: " + greeter.doSomething("world"));
+	}
+	
 	public static TestClass bracket(String value) {
 		return new TestClass(value);
 	}
+	
+	@FunctionalInterface
+	public static interface MyFunctionalInterface {
+		String doSomething(String value);
+	}
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestClass.java

 		return "Interface method of " + name;
 	}
 	
+	@Override
+	public String getValue() {
+		return "getValue " + name;
+	}
+	
 	@Method
 	public TestGenericInterface<String> generate() {
 		return () -> name;

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestInterface.java

  *
  * @author Hoofdgebruiker
  */
-public interface TestInterface extends ZenCodeType {
+public interface TestInterface extends ZenCodeType, TestGenericInterface<String> {
 	@Method
 	String interfaceMethod();
 }