Varargs support

1 files changed, 53 insertions, 20 deletions

diff --git a/src/bind/AutoBinder.kt b/src/bind/AutoBinder.kt
index 53a4ebb..6d2cac2 100644
--- a/src/bind/AutoBinder.kt
+++ b/src/bind/AutoBinder.kt
@@ -6,20 +6,29 @@ import java.lang.reflect.Method
 import java.lang.reflect.Modifier
 import java.lang.reflect.Parameter
 
+typealias ObjectMapper = (() -> LispData, () -> LispAst, ErrorReporter, () -> Boolean) -> (Any?)
+
 class AutoBinder {
+    companion object {
+        val Parameter.effectiveType get() = if (this.isVarArgs) this.type.componentType else this.type
+    }
 
-    private fun mapLispData(parameter: Parameter): ((() -> LispData, () -> LispAst, ErrorReporter) -> Any)? {
-        if (LispData::class.java.isAssignableFrom(parameter.type)) return { a, b, c -> parameter.type.cast(a()) }
+    private fun mapLispData(parameter: Parameter): ObjectMapper? {
+        if (LispData::class.java.isAssignableFrom(parameter.effectiveType)) return { a, b, c, d ->
+            parameter.effectiveType.cast(
+                a()
+            )
+        }
         return null
     }
 
-    private fun mapErrorReporter(parameter: Parameter): ((() -> LispData, () -> LispAst, ErrorReporter) -> Any)? {
-        if (ErrorReporter::class.java.isAssignableFrom(parameter.type)) return { a, b, c -> c }
+    private fun mapErrorReporter(parameter: Parameter): ObjectMapper? {
+        if (ErrorReporter::class.java.isAssignableFrom(parameter.effectiveType)) return { a, b, c, d -> c }
         return null
     }
 
-    private fun mapString(parameter: Parameter): ((() -> LispData, () -> LispAst, ErrorReporter) -> Any?)? {
-        if (String::class.java == parameter.type) return { a, b, c ->
+    private fun mapString(parameter: Parameter): ObjectMapper? {
+        if (String::class.java == parameter.effectiveType) return { a, b, c, d ->
             when (val x = a()) {
                 is LispData.LispString -> x.string
                 is LispData.Atom -> x.label
@@ -29,8 +38,8 @@ class AutoBinder {
         return null
     }
 
-    private fun mapBoolean(parameter: Parameter): ((() -> LispData, () -> LispAst, ErrorReporter) -> Any?)? {
-        if (Boolean::class.java.isAssignableFrom(parameter.type)) return { a, b, c ->
+    private fun mapBoolean(parameter: Parameter): ObjectMapper? {
+        if (Boolean::class.java.isAssignableFrom(parameter.effectiveType)) return { a, b, c, d ->
             val x = a()
             val y = CoreBindings.isTruthy(x)
             if (y == null) {
@@ -41,31 +50,35 @@ class AutoBinder {
         return null
     }
 
-    private fun mapAST(parameter: Parameter): ((() -> LispData, () -> LispAst, ErrorReporter) -> Any?)? {
-        if (LispAst::class.java.isAssignableFrom(parameter.type)) return { a, b, c -> parameter.type.cast(b()) }
+    private fun mapAST(parameter: Parameter): ObjectMapper? {
+        if (LispAst::class.java.isAssignableFrom(parameter.effectiveType)) return { a, b, c, d ->
+            parameter.effectiveType.cast(
+                b()
+            )
+        }
         return null
     }
 
-    private fun mapNumber(parameter: Parameter): ((() -> LispData, () -> LispAst, ErrorReporter) -> Any?)? {
-        if (Double::class.java.isAssignableFrom(parameter.type)) return { a, b, c ->
+    private fun mapNumber(parameter: Parameter): ObjectMapper? {
+        if (Double::class.java.isAssignableFrom(parameter.effectiveType)) return { a, b, c, d ->
             when (val x = a()) {
                 is LispData.LispNumber -> x.value
                 else -> null.also { c.reportError("Could not coerce $x to number") }
             }
         }
-        if (Float::class.java.isAssignableFrom(parameter.type)) return { a, b, c ->
+        if (Float::class.java.isAssignableFrom(parameter.effectiveType)) return { a, b, c, d ->
             when (val x = a()) {
                 is LispData.LispNumber -> x.value.toFloat()
                 else -> null.also { c.reportError("Could not coerce $x to number") }
             }
         }
-        if (Int::class.java.isAssignableFrom(parameter.type)) return { a, b, c ->
+        if (Int::class.java.isAssignableFrom(parameter.effectiveType)) return { a, b, c, d ->
             when (val x = a()) {
                 is LispData.LispNumber -> x.value.toInt()
                 else -> null.also { c.reportError("Could not coerce $x to number") }
             }
         }
-        if (Long::class.java.isAssignableFrom(parameter.type)) return { a, b, c ->
+        if (Long::class.java.isAssignableFrom(parameter.effectiveType)) return { a, b, c, d ->
             when (val x = a()) {
                 is LispData.LispNumber -> x.value.toLong()
                 else -> null.also { c.reportError("Could not coerce $x to number") }
@@ -75,7 +88,7 @@ class AutoBinder {
     }
 
 
-    val objectMappers = mutableListOf<((Parameter) -> (((() -> LispData, () -> LispAst, ErrorReporter) -> Any?)?))>(
+    val objectMappers = mutableListOf<((Parameter) -> ObjectMapper?)>(
         ::mapLispData,
         ::mapErrorReporter,
         ::mapNumber,
@@ -88,8 +101,7 @@ class AutoBinder {
     fun generateInstanceBindings(obj: Any): Map<String, LispData> {
         val bindings = mutableMapOf<String, LispData>()
         for (method in obj.javaClass.methods) {
-            val annotation = method.getAnnotation(LispBinding::class.java)
-            if (annotation == null) continue
+            val annotation = method.getAnnotation(LispBinding::class.java) ?: continue
             require(LispParser.isValidIdentifier(annotation.name))
             bindings[annotation.name] = wrapMethod(obj, annotation.name, method)
         }
@@ -97,6 +109,21 @@ class AutoBinder {
         return bindings
     }
 
+    open fun makeVarArgMapper(
+        parameter: Parameter,
+        baseMapper: ObjectMapper
+    ): ObjectMapper? {
+        return { a, b, c, d ->
+            val l = buildList {
+                while (d())
+                    add(baseMapper(a, b, c, d)!!)
+            }
+            val a = java.lang.reflect.Array.newInstance(parameter.type.componentType, l.size) as Array<Any>
+            l.withIndex().forEach { a[it.index] = it.value }
+            a
+        }
+    }
+
     private val lookup = MethodHandles.publicLookup()
     fun wrapMethod(obj: Any, name: String, method: Method): LispData.LispExecutable {
         var mh = lookup.unreflect(method)
@@ -104,8 +131,13 @@ class AutoBinder {
             mh = mh.bindTo(obj)
         }
         val objectMappers = method.parameters.map { param ->
-            objectMappers.firstNotNullOfOrNull { it.invoke(param) }
+            val baseMapper = objectMappers.firstNotNullOfOrNull { it.invoke(param) }
                 ?: error("Could not find object mapper for parameter $param")
+            if (param.isVarArgs) {
+                makeVarArgMapper(param, baseMapper)
+                    ?: error("Could not transform object mapper to vararg object mapper")
+            } else
+                baseMapper
         }
         return LispData.externalRawCall(name) { context: LispExecutionContext, callsite: LispAst.LispNode, stackFrame: StackFrame, args: List<LispAst.LispNode> ->
             val e = object : ErrorReporter {
@@ -115,8 +147,9 @@ class AutoBinder {
             }
             try {
                 val iterator = args.iterator()
+                val (a, b, c) = Triple({ context.resolveValue(stackFrame, iterator.next()) }, { iterator.next() }, e)
                 val p = objectMappers.map {
-                    it.invoke({ context.resolveValue(stackFrame, iterator.next()) }, { iterator.next() }, e)
+                    it.invoke(a, b, c, { iterator.hasNext() })
                         ?: return@externalRawCall LispData.LispNil
                 }
                 if (iterator.hasNext()) return@externalRawCall e.reportError("Too many arguments")