implement native type compilation

bir/src/main/kotlin/gay/pizza/pork/bir/IrDefinitionType.kt

@@ -6,5 +6,6 @@ import kotlinx.serialization.Serializable
 enum class IrDefinitionType {
   Variable,
   CodeFunction,
-  NativeFunction
+  NativeFunction,
+  NativeType,
 }

bir/src/main/kotlin/gay/pizza/pork/bir/IrNativeDefinition.kt

@@ -3,6 +3,6 @@ package gay.pizza.pork.bir
 import kotlinx.serialization.Serializable
 
 @Serializable
-data class IrNativeDefinition(var form: String, var definitions: List<String>) : IrCodeElement() {
+data class IrNativeDefinition(var kind: IrNativeDefinitionKind, var form: String, var definitions: List<String>) : IrCodeElement() {
   override fun crawl(block: (IrElement) -> Unit) {}
 }

bir/src/main/kotlin/gay/pizza/pork/bir/IrNativeDefinitionKind.kt

@@ -0,0 +1,9 @@
+package gay.pizza.pork.bir
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class IrNativeDefinitionKind {
+  Function,
+  Type
+}

bytecode/src/main/kotlin/gay/pizza/pork/bytecode/Opcode.kt

@@ -13,7 +13,8 @@ enum class Opcode(val id: UByte) {
   UnaryMinus(10u),
   BinaryNot(11u),
   And(20u),
-  Native(24u),
+  NativeFunction(24u),
+  NativeType(43u),
   Return(10u),
   StoreLocal(16u),
   LoadLocal(17u),

compiler/src/main/kotlin/gay/pizza/pork/compiler/AstIrEmitter.kt

@@ -308,6 +308,13 @@ class AstIrEmitter(
   }
 
   override fun visitNativeFunctionDescriptor(node: NativeFunctionDescriptor): IrCodeElement = IrNativeDefinition(
+    kind = IrNativeDefinitionKind.Function,
+    form = node.form.id,
+    definitions = node.definitions.map { it.text }
+  )
+
+  override fun visitNativeTypeDescriptor(node: NativeTypeDescriptor): IrCodeElement = IrNativeDefinition(
+    kind = IrNativeDefinitionKind.Type,
     form = node.form.id,
     definitions = node.definitions.map { it.text }
   )

compiler/src/main/kotlin/gay/pizza/pork/compiler/CompilableSymbol.kt

@@ -3,6 +3,8 @@ package gay.pizza.pork.compiler
 import gay.pizza.pork.ast.gen.FunctionDefinition
 import gay.pizza.pork.ast.gen.LetDefinition
 import gay.pizza.pork.ast.gen.NativeFunctionDescriptor
+import gay.pizza.pork.ast.gen.NativeTypeDescriptor
+import gay.pizza.pork.ast.gen.TypeDefinition
 import gay.pizza.pork.ast.gen.visit
 import gay.pizza.pork.bir.IrCodeBlock
 import gay.pizza.pork.bir.IrDefinition
@@ -36,25 +38,34 @@ class CompilableSymbol(val compilableSlab: CompilableSlab, val scopeSymbol: Scop
       scope = compilableSlab.slab.scope
     )
     irCodeEmitter.enterLocalScope()
-    val what = if (scopeSymbol.definition is FunctionDefinition) {
+    val what = when (scopeSymbol.definition) {
+      is FunctionDefinition -> {
         val functionDefinition = scopeSymbol.definition as FunctionDefinition
         irCodeEmitter.createFunctionArguments(functionDefinition)
         functionDefinition.block ?: functionDefinition.nativeFunctionDescriptor!!
-    } else {
+      }
+
+      is TypeDefinition -> {
+        val typeDefinition = scopeSymbol.definition as TypeDefinition
+        typeDefinition.nativeTypeDescriptor!!
+      }
+
+      else -> {
         val letDefinition = scopeSymbol.definition as LetDefinition
         letDefinition.value
       }
+    }
     val type = if (what is NativeFunctionDescriptor) {
       IrDefinitionType.NativeFunction
+    } else if (what is NativeTypeDescriptor) {
+      IrDefinitionType.NativeType
     } else if (scopeSymbol.definition is LetDefinition) {
       IrDefinitionType.Variable
     } else {
       IrDefinitionType.CodeFunction
     }
     val irCodeElement = irCodeEmitter.visit(what)
-    val irCodeBlock = if (irCodeElement is IrCodeBlock) {
+    val irCodeBlock = irCodeElement as? IrCodeBlock ?: IrCodeBlock(listOf(irCodeElement))
-      irCodeElement
-    } else IrCodeBlock(listOf(irCodeElement))
     irCodeEmitter.exitLocalScope()
     return IrDefinition(
       symbol = functionSymbol,

compiler/src/main/kotlin/gay/pizza/pork/compiler/IrStubOpEmitter.kt

@@ -233,7 +233,15 @@ class IrStubOpEmitter(val irDefinition: IrDefinition, val code: CodeBuilder) : I
       ConstantTag.NativeDefinition,
       buffer,
     )
-    code.emit(Opcode.Native, listOf(nativeDefinitionConstant, functionArgumentCount.toUInt()))
+
+    when (ir.kind) {
+      IrNativeDefinitionKind.Function -> {
+        code.emit(Opcode.NativeFunction, listOf(nativeDefinitionConstant, functionArgumentCount.toUInt()))
+      }
+      IrNativeDefinitionKind.Type -> {
+        code.emit(Opcode.NativeType, listOf(nativeDefinitionConstant))
+      }
+    }
   }
 
   override fun visitIrIndex(ir: IrIndex) {

execution/src/main/kotlin/gay/pizza/pork/execution/InternalNativeProvider.kt

@@ -8,16 +8,35 @@ class InternalNativeProvider(val quiet: Boolean = false) : NativeProvider {
     "listInitWith" to NativeFunction(::listInitWith)
   )
 
+  private val types = mutableMapOf(
+    "int32" to NativeType { Int::class.java },
+    "int64" to NativeType { Long::class.java },
+    "string" to NativeType { String::class.java },
+    "float32" to NativeType { Float::class.java },
+    "float64" to NativeType { Double::class.java },
+    "bool" to NativeType { Boolean::class.java },
+  )
+
   fun add(name: String, function: NativeFunction) {
     functions[name] = function
   }
 
+  fun add(name: String, type: NativeType) {
+    types[name] = type
+  }
+
   override fun provideNativeFunction(definitions: List<String>): NativeFunction {
     val definition = definitions[0]
     return functions[definition] ?:
       throw RuntimeException("Unknown internal function: $definition")
   }
 
+  override fun provideNativeType(definitions: List<String>): NativeType {
+    val definition = definitions[0]
+    return types[definition] ?:
+      throw RuntimeException("Unknown internal type: $definition")
+  }
+
   private fun printValues(arguments: ArgumentList): Any {
     if (quiet || arguments.isEmpty()) return None
     print(arguments.at<List<*>>(0).joinToString(" ") { it.toString() })

execution/src/main/kotlin/gay/pizza/pork/execution/NativeProvider.kt

@@ -2,4 +2,5 @@ package gay.pizza.pork.execution
 
 interface NativeProvider {
   fun provideNativeFunction(definitions: List<String>): NativeFunction
+  fun provideNativeType(definitions: List<String>): NativeType
 }

execution/src/main/kotlin/gay/pizza/pork/execution/NativeType.kt

@@ -0,0 +1,5 @@
+package gay.pizza.pork.execution
+
+fun interface NativeType {
+  fun value(): Any
+}

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

@@ -8,6 +8,7 @@ import gay.pizza.pork.evaluator.*
 import gay.pizza.pork.execution.ArgumentList
 import gay.pizza.pork.execution.NativeFunction
 import gay.pizza.pork.execution.NativeProvider
+import gay.pizza.pork.execution.NativeType
 import gay.pizza.pork.execution.None
 import kotlin.io.path.Path
 import kotlin.io.path.absolutePathString
@@ -231,6 +232,11 @@ class FfiNativeProvider : ExpandedNativeProvider, NativeProvider {
       callable.call(arguments, CallStack())
     }
   }
+
+  override fun provideNativeType(definitions: List<String>): NativeType {
+    throw RuntimeException("Unknown native type")
+  }
+
   companion object {
     fun typeConversion(type: FfiType): Type = when (type) {
       FfiPrimitiveType.UnsignedByte -> Type.UINT8

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

@@ -6,6 +6,7 @@ import gay.pizza.pork.evaluator.SlabContext
 import gay.pizza.pork.evaluator.ExpandedNativeProvider
 import gay.pizza.pork.execution.NativeFunction
 import gay.pizza.pork.execution.NativeProvider
+import gay.pizza.pork.execution.NativeType
 import gay.pizza.pork.execution.None
 import java.lang.invoke.MethodHandles
 import java.lang.invoke.MethodType
@@ -68,4 +69,8 @@ class JavaNativeProvider : ExpandedNativeProvider, NativeProvider {
   override fun provideNativeFunction(definitions: List<String>): NativeFunction {
     throw RuntimeException("Invalid Native Function Usage")
   }
+
+  override fun provideNativeType(definitions: List<String>): NativeType {
+    throw RuntimeException("Invalid Native Type Usage")
+  }
 }

frontend/src/main/kotlin/gay/pizza/pork/frontend/scope/ExternalSymbolUsageAnalyzer.kt

@@ -16,6 +16,9 @@ class ExternalSymbolUsageAnalyzer : FunctionLevelVisitor<Unit>() {
     internalSymbols.removeLast()
   }
 
+  override fun visitTypeDefinition(node: TypeDefinition) {
+  }
+
   override fun visitLetDefinition(node: LetDefinition) {
     node.value.visit(this)
   }

tool/src/main/kotlin/gay/pizza/pork/tool/CompileCommand.kt

@@ -69,7 +69,7 @@ class CompileCommand : CliktCommand("compile") {
           annotation = " ; ${annotations.joinToString(", ") { it.text }}"
         }
         print("  ${symbol.offset + index.toUInt()} ${op}${annotation}")
-        if (op.code == Opcode.Constant || op.code == Opcode.Native) {
+        if (op.code == Opcode.Constant || op.code == Opcode.NativeFunction) {
           val constant = compiledWorld.constantPool.constants[op.args[0].toInt()]
           val constantString = when (constant.tag) {
             ConstantTag.String -> "string = \"" + constant.readAsString() + "\""

vm/src/main/kotlin/gay/pizza/pork/vm/StandardOpHandlers.kt

@@ -47,7 +47,8 @@ val StandardOpHandlers: List<OpHandler> = listOf(
   CallOpHandler,
   ReturnOpHandler,
 
-  NativeOpHandler,
+  NativeFunctionOpHandler,
+  NativeTypeOpHandler,
 
   ScopeInOpHandler,
   ScopeOutOpHandler,

vm/src/main/kotlin/gay/pizza/pork/vm/ops/NativeFunctionOpHandler.kt

@@ -2,11 +2,10 @@ package gay.pizza.pork.vm.ops
 
 import gay.pizza.pork.bytecode.Op
 import gay.pizza.pork.bytecode.Opcode
-import gay.pizza.pork.execution.None
 import gay.pizza.pork.vm.InternalMachine
 import gay.pizza.pork.vm.OpHandler
 
-object NativeOpHandler : OpHandler(Opcode.Native) {
+object NativeFunctionOpHandler : OpHandler(Opcode.NativeFunction) {
   override fun handle(machine: InternalMachine, op: Op) {
     val handler = optimize(machine, op)
     handler.handle(machine, op)
@@ -17,6 +16,6 @@ object NativeOpHandler : OpHandler(Opcode.Native) {
     val form = nativeDefinition[0]
     val provider = machine.nativeRegistry.of(form)
     val function = provider.provideNativeFunction(nativeDefinition.subList(1, nativeDefinition.size))
-    return OptimizedNativeOpHandler(function)
+    return OptimizedNativeFunctionOpHandler(function)
   }
 }

vm/src/main/kotlin/gay/pizza/pork/vm/ops/NativeTypeOpHandler.kt

@@ -0,0 +1,21 @@
+package gay.pizza.pork.vm.ops
+
+import gay.pizza.pork.bytecode.Op
+import gay.pizza.pork.bytecode.Opcode
+import gay.pizza.pork.vm.InternalMachine
+import gay.pizza.pork.vm.OpHandler
+
+object NativeTypeOpHandler : OpHandler(Opcode.NativeType) {
+  override fun handle(machine: InternalMachine, op: Op) {
+    val handler = optimize(machine, op)
+    handler.handle(machine, op)
+  }
+
+  override fun optimize(machine: InternalMachine, op: Op): OpHandler {
+    val nativeDefinition = machine.world.constantPool.read(op.args[0]).readAsNativeDefinition()
+    val form = nativeDefinition[0]
+    val provider = machine.nativeRegistry.of(form)
+    val type = provider.provideNativeType(nativeDefinition.subList(1, nativeDefinition.size))
+    return OptimizedNativeTypeOpHandler(type)
+  }
+}

vm/src/main/kotlin/gay/pizza/pork/vm/ops/OptimizedNativeFunctionOpHandler.kt

@@ -7,7 +7,7 @@ import gay.pizza.pork.execution.None
 import gay.pizza.pork.vm.InternalMachine
 import gay.pizza.pork.vm.OpHandler
 
-class OptimizedNativeOpHandler(val function: NativeFunction) : OpHandler(Opcode.Native) {
+class OptimizedNativeFunctionOpHandler(val function: NativeFunction) : OpHandler(Opcode.NativeFunction) {
   override fun handle(machine: InternalMachine, op: Op) {
     val argumentCount = op.args[1]
     val arguments = mutableListOf<Any>()

vm/src/main/kotlin/gay/pizza/pork/vm/ops/OptimizedNativeTypeOpHandler.kt

@@ -0,0 +1,16 @@
+package gay.pizza.pork.vm.ops
+
+import gay.pizza.pork.bytecode.Op
+import gay.pizza.pork.bytecode.Opcode
+import gay.pizza.pork.execution.NativeFunction
+import gay.pizza.pork.execution.NativeType
+import gay.pizza.pork.execution.None
+import gay.pizza.pork.vm.InternalMachine
+import gay.pizza.pork.vm.OpHandler
+
+class OptimizedNativeTypeOpHandler(val type: NativeType) : OpHandler(Opcode.NativeType) {
+  override fun handle(machine: InternalMachine, op: Op) {
+    val result = type.value()
+    machine.push(if (result == Unit) None else result)
+  }
+}