implement java native type support

ffi/src/main/kotlin/gay/pizza/pork/ffi/JavaAutogen.kt

@@ -11,7 +11,18 @@ class JavaAutogen(val javaClass: Class<*>) {
   fun generateCompilationUnit(): CompilationUnit {
     return CompilationUnit(
       declarations = listOf(),
-      definitions = generateFunctionDefinitions()
+      definitions = generateFunctionDefinitions() + generateTypeDefinition()
+    )
+  }
+
+  fun generateTypeDefinition(): TypeDefinition {
+    return TypeDefinition(
+      modifiers = DefinitionModifiers(export = true),
+      symbol = Symbol(prefix),
+      nativeTypeDescriptor = NativeTypeDescriptor(
+        form = Symbol("java"),
+        definitions = listOf(StringLiteral(javaClass.name)),
+      )
     )
   }
 
@@ -50,7 +61,9 @@ class JavaAutogen(val javaClass: Class<*>) {
         if (Modifier.isStatic(method.modifiers)) {
           definitions[name] = function(name, parameterNames, form("static"))
         } else {
-          definitions[name] = function(name, parameterNames, form("virtual"))
+          val finalParameterNames = parameterNames.toMutableList()
+          finalParameterNames.add(0, "__instance")
+          definitions[name] = function(name, finalParameterNames, form("virtual"))
         }
       }
 

ffi/src/main/kotlin/gay/pizza/pork/ffi/JavaNativeProvider.kt

@@ -1,8 +1,5 @@
 package gay.pizza.pork.ffi
 
-import gay.pizza.pork.ast.gen.ArgumentSpec
-import gay.pizza.pork.evaluator.CallableFunction
-import gay.pizza.pork.evaluator.SlabContext
 import gay.pizza.pork.evaluator.ExpandedNativeProvider
 import gay.pizza.pork.execution.NativeFunction
 import gay.pizza.pork.execution.NativeProvider
@@ -14,25 +11,6 @@ import java.lang.invoke.MethodType
 class JavaNativeProvider : ExpandedNativeProvider, NativeProvider {
   private val lookup = MethodHandles.lookup()
 
-  override fun provideNativeFunction(
-    definitions: List<String>,
-    arguments: List<ArgumentSpec>,
-    inside: SlabContext
-  ): CallableFunction {
-    val functionDefinition = JavaFunctionDefinition.parse(definitions)
-    val javaClass = lookupClass(functionDefinition.type)
-    val returnTypeClass = lookupClass(functionDefinition.returnType)
-    val parameterClasses = functionDefinition.parameters.map { lookupClass(it) }
-    val handle = mapKindToHandle(
-      functionDefinition.kind,
-      functionDefinition.symbol,
-      javaClass,
-      returnTypeClass,
-      parameterClasses
-    )
-    return CallableFunction { functionArguments, _ -> handle.invokeWithArguments(functionArguments) ?: None }
-  }
-
   private fun lookupClass(name: String): Class<*> = when (name) {
     "void" -> Void.TYPE
     "String" -> String::class.java
@@ -67,10 +45,23 @@ class JavaNativeProvider : ExpandedNativeProvider, NativeProvider {
   }
 
   override fun provideNativeFunction(definitions: List<String>): NativeFunction {
-    throw RuntimeException("Invalid Native Function Usage")
+    val functionDefinition = JavaFunctionDefinition.parse(definitions)
+    val javaClass = lookupClass(functionDefinition.type)
+    val returnTypeClass = lookupClass(functionDefinition.returnType)
+    val parameterClasses = functionDefinition.parameters.map { lookupClass(it) }
+    val handle = mapKindToHandle(
+      functionDefinition.kind,
+      functionDefinition.symbol,
+      javaClass,
+      returnTypeClass,
+      parameterClasses
+    )
+    return NativeFunction { functionArguments -> handle.invokeWithArguments(functionArguments) ?: None }
   }
 
   override fun provideNativeType(definitions: List<String>): NativeType {
-    throw RuntimeException("Invalid Native Type Usage")
+    val className = definitions[0]
+    val javaClass = Class.forName(className)
+    return JavaNativeType(javaClass)
   }
 }

ffi/src/main/kotlin/gay/pizza/pork/ffi/JavaNativeType.kt

@@ -0,0 +1,9 @@
+package gay.pizza.pork.ffi
+
+import gay.pizza.pork.execution.NativeType
+
+class JavaNativeType(val wrappedJavaClass: Class<*>) : NativeType {
+  override fun value(): Any {
+    return wrappedJavaClass
+  }
+}