Don't count optional parameters when trying to find an easy constructor

mockito-kotlin/src/main/kotlin/com/nhaarman/mockito_kotlin/CreateInstance.kt

@@ -34,10 +34,7 @@ import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Modifier
 import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Type
-import kotlin.reflect.KClass
-import kotlin.reflect.KFunction
-import kotlin.reflect.KType
-import kotlin.reflect.defaultType
+import kotlin.reflect.*
 import kotlin.reflect.jvm.isAccessible
 import kotlin.reflect.jvm.javaType
 import kotlin.reflect.jvm.jvmName
@@ -84,12 +81,12 @@ fun <T : Any> createInstance(kClass: KClass<T>): T {
  */
 private fun <T : Any> KClass<T>.easiestConstructor(): KFunction<T> {
     return constructors
-            .sortedBy { it.parameters.size }
+            .sortedBy { it.parameters.withoutOptionalParameters().size }
             .withoutParametersOfType(this.defaultType)
             .withoutArrayParameters()
-            .firstOrNull() ?: constructors.sortedBy { it.parameters.size }
-                                          .withoutParametersOfType(this.defaultType)
-                                          .first()
+            .firstOrNull() ?: constructors.sortedBy { it.parameters.withoutOptionalParameters().size }
+            .withoutParametersOfType(this.defaultType)
+            .first()
 }
 
 private fun <T> List<KFunction<T>>.withoutArrayParameters() = filter {
@@ -101,10 +98,12 @@ private fun <T> List<KFunction<T>>.withoutArrayParameters() = filter {
  * This is especially useful to avoid infinite loops where constructors
  * accepting a parameter of their own type, e.g. 'copy constructors'.
  */
-private fun <T: Any> List<KFunction<T>>.withoutParametersOfType(type: KType) = filter {
+private fun <T : Any> List<KFunction<T>>.withoutParametersOfType(type: KType) = filter {
     it.parameters.filter { it.type == type }.isEmpty()
 }
 
+private fun List<KParameter>.withoutOptionalParameters() = filterNot { it.isOptional }
+
 @Suppress("SENSELESS_COMPARISON")
 private fun KClass<*>.hasObjectInstance() = objectInstance != null
 
@@ -166,7 +165,7 @@ private fun <T : Any> KClass<T>.toClassObject(): T {
 private fun <T : Any> KFunction<T>.newInstance(): T {
     try {
         isAccessible = true
-        return callBy(parameters.associate {
+        return callBy(parameters.withoutOptionalParameters().associate {
             it to it.type.createNullableInstance<T>()
         })
     } catch(e: InvocationTargetException) {

mockito-kotlin/src/test/kotlin/CreateInstanceTest.kt

@@ -457,6 +457,25 @@ class CreateInstanceTest {
         expect(result).toNotBeNull()
     }
 
+    @Test
+    fun optionalParametersAreSkippedWhenSorting() {
+        /* When */
+        val result = createInstance(WithDefaultParameters::class)
+
+        /* Then */
+        expect(result).toNotBeNull()
+    }
+
+    @Test
+    fun defaultValuesAreUsedWithOptionalParameters() {
+        /* When */
+        val result = createInstance(WithDefaultParameters::class)
+
+        /* Then */
+        expect(result.first).toBe(1)
+        expect(result.second).toBe(2)
+    }
+
     private class PrivateClass private constructor(val data: String)
 
     class ClosedClass
@@ -503,7 +522,18 @@ class CreateInstanceTest {
      */
     data class WithCopyConstructor private constructor(val x: String,
                                                        val y: String) {
-        constructor(other: WithCopyConstructor): this(other.x, other.y)
+        constructor(other: WithCopyConstructor) : this(other.x, other.y)
+    }
+
+    /**
+     * A class that uses default parameters, but with a constructor without parameters that fails.
+     * This is to make sure default parameters are not counted when sorting by parameter size.
+     */
+    class WithDefaultParameters constructor(val first: Int = 1, val second: Int = 2) {
+
+        constructor(first: Int) : this() {
+            error("Should not be called")
+        }
     }
 
     enum class MyEnum { VALUE, ANOTHER_VALUE }