Functional Wrappers, Bridge Methods, Type descriptor fix

Functional interface wrappers should work now
Implementing a method with a signature differing from the actual one (e.g. when dealing with generics) now creates a proper bridge method
The Java Bytecde compiler used an incorrect method in checkCast
We now no longer use hardcoded 'accept's as method names but whatever the context tells us to.

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

         ifaceWriter
 				.visitMethod(
 					Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT,
-					"accept",
+					function.method,
 					getMethodDescriptor(function.header),
 					getMethodSignature(function.header),
 					null)

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

 				break;
 			}
 			case FUNCTION_CALL:
-				javaWriter.invokeInterface(
-						JavaMethod.getNativeVirtual(
-								JavaClass.fromInternalName(context.getInternalName(expression.target.type), JavaClass.Kind.INTERFACE),
-								"accept",
-								context.getMethodDescriptor(expression.instancedHeader)));
+				javaWriter.invokeInterface(context.getFunctionalInterface(expression.target.type));
 				break;
 			case AUTOOP_NOTEQUALS:
 				throw new UnsupportedOperationException("Not yet supported!");
             return null;
         }*/
 
-		final String descriptor;
 		final String signature;
 		final String[] interfaces;
-		final String methodName;
 		final String className = context.getLambdaCounter();
 		
 		{//Fill the info above
 				//Let's implement the functional Interface instead
 				final Method functionalInterfaceMethod = ((JavaFunctionalInterfaceStorageTag) actualStorage).functionalInterfaceMethod;
 				
-				descriptor = Type.getMethodDescriptor(functionalInterfaceMethod);
 				//Should be the same, should it not?
 				signature = context.getMethodSignature(expression.header);
 				interfaces = new String[]{Type.getInternalName(functionalInterfaceMethod.getDeclaringClass())};
-				methodName = functionalInterfaceMethod.getName();
 			} else {
 				//Normal way, no casting to functional interface
-				descriptor = context.getMethodDescriptor(expression.header);
 				signature = context.getMethodSignature(expression.header);
 				interfaces = new String[]{context.getInternalName(new FunctionTypeID(null, expression.header).stored(UniqueStorageTag.INSTANCE))};
-				methodName = "accept";
 			}
 		}
 		
 		
-		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, methodName, descriptor);
+		final JavaMethod methodInfo;
+		{
+			final JavaMethod m = context.getFunctionalInterface(expression.type);
+			methodInfo = new JavaMethod(m.cls, m.kind, m.name, m.compile, m.descriptor, m.modifiers & ~JavaModifiers.ABSTRACT, m.genericResult, m.typeParameterArguments);
+		}
 		final ClassWriter lambdaCW = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", interfaces);
-		final JavaWriter functionWriter = new JavaWriter(expression.position, lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
+		final JavaWriter functionWriter;
+		
+		//Bridge method!!!
+		if(!Objects.equals(methodInfo.descriptor, signature)) {
+			final JavaMethod bridgeMethodInfo = new JavaMethod(methodInfo.cls, methodInfo.kind, methodInfo.name, methodInfo.compile, methodInfo.descriptor, methodInfo.modifiers | JavaModifiers.BRIDGE | JavaModifiers.SYNTHETIC, methodInfo.genericResult, methodInfo.typeParameterArguments);
+			final JavaWriter bridgeWriter = new JavaWriter(expression.position, lambdaCW, bridgeMethodInfo, null, methodInfo.descriptor, null, "java/lang/Override");
+			bridgeWriter.start();
+			
+			//This.name(parameters, casted)
+			bridgeWriter.loadObject(0);
+			
+			for (int i = 0; i < expression.header.parameters.length; i++) {
+				final FunctionParameter functionParameter = expression.header.parameters[i];
+				final Type type = context.getType(functionParameter.type);
+				bridgeWriter.load(type, i + 1);
+				bridgeWriter.checkCast(type);
+			}
+			
+			bridgeWriter.invokeVirtual(methodInfo);
+			if(expression.header.getReturnType().type != BasicTypeID.VOID) {
+				bridgeWriter.returnType(context.getType(expression.header.getReturnType()));
+			}
+			
+			bridgeWriter.ret();
+			bridgeWriter.end();
+			
+			
+			
+			final JavaMethod actualMethod = new JavaMethod(methodInfo.cls, methodInfo.kind, methodInfo.name, methodInfo.compile, signature, methodInfo.modifiers, methodInfo.genericResult, methodInfo.typeParameterArguments);
+			//No @Override
+			functionWriter = new JavaWriter(expression.position, lambdaCW, actualMethod, null, signature, null);
+		} else {
+			functionWriter = new JavaWriter(expression.position, lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
+		}
 
 		javaWriter.newObject(className);
 		javaWriter.dup();
 		final String constructorDesc = "(" + wrappedSignature + ")V";
 		
 		final String className = context.getLambdaCounter();
-		final String methodName = functionalInterfaceMethod.getName();
 		final String methodDescriptor = Type.getMethodDescriptor(functionalInterfaceMethod);
 		final String[] interfaces = new String[]{Type.getInternalName(functionalInterfaceMethod.getDeclaringClass())};
 
 
 		//The actual method
 		{
-			final JavaWriter functionWriter = new JavaWriter(expression.position, lambdaCW, tag.method, null, methodDescriptor, null, "java/lang/Override");
+			final JavaMethod actualMethod = new JavaMethod(tag.method.cls, tag.method.kind, tag.method.name, tag.method.compile, tag.method.descriptor, tag.method.modifiers & ~JavaModifiers.ABSTRACT, tag.method.genericResult, tag.method.typeParameterArguments);
+			final JavaWriter functionWriter = new JavaWriter(expression.position, lambdaCW, actualMethod, null, methodDescriptor, null, "java/lang/Override");
 			functionWriter.start();
 
 			//this.wrapped

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

         if (debug)
             System.out.println("checkCast " + type.getDescriptor());
 
-        visitor.visitTypeInsn(CHECKCAST, type.getDescriptor());
+        visitor.visitTypeInsn(CHECKCAST, type.getInternalName());
     }
 
     public void iNeg() {

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

 					function.getMethod(),
 					false,
 					getMethodDescriptor(function.getHeader()),
-					Modifiers.PUBLIC | Modifiers.ABSTRACT,
+					JavaModifiers.PUBLIC | JavaModifiers.ABSTRACT,
 					function.getHeader().getReturnType().isGeneric());
 		}
 	}

ScriptingExample/scripts/functionalInterfaces.zs

+//val x = ((a as string) => "hello" + a) as function`auto(a as string) as string`auto;
+//invokeFunctional(x);
+
+val y = (a as int, b as int) => a + b;
+
+
+//invokeFunctionalInt((a, b) => a + b);
+invokeFunctionalInt(y);
+
+
+println(((x as int) => x)(10));