sumar - ¿Por qué la función de Kotlin con parámetros predeterminados crea un método con parámetros no utilizados?

pasar parametros en kotlin

Question

Vea este código de ejemplo en Kotlin:

fun foo(bar: Int = 0, baz: Int) {
    /* ... */
}

Después de descompilarlo en código Java (Herramientas -> Kotlin -> Mostrar código de bytes de Kotlin -> Descompilar) obtuve el siguiente código

public static final void foo(int bar, int baz) {
}

// $FF: synthetic method
// $FF: bridge method
public static void foo$default(int var0, int var1, int var2, Object var3) {
  if ((var2 & 1) != 0) {
     var0 = 0;
  }

  foo(var0, var1);
}

Noté que el método Java resultante tiene un parámetro Object var3 no utilizado.

En cierto modo pensé que podría estar relacionado con las funciones de una clase, pero al descompilar este código

class Foo {
    fun foo(bar: Int = 0, baz: Int) {
        /* ... */
    }
}

Tengo este codigo

public final class Foo {
   public final void foo(int bar, int baz) {
   }

   // $FF: synthetic method
   // $FF: bridge method
   public static void foo$default(Foo var0, int var1, int var2, int var3, Object var4) {
      if ((var3 & 1) != 0) {
         var1 = 0;
      }

      var0.foo(var1, var2);
   }
}

Como puede ver, el parámetro Object todavía no se usa y simplemente se queda allí. En pruebas adicionales, noté el mismo comportamiento para los métodos de extensión. Lo mismo ocurre cuando el parámetro predeterminado es el último (es decir, fun foo(bar: Int, baz: Int = 0) {} )

También he realizado una prueba básica para verificar a qué se establece ese valor cuando se llama a esa función utilizando el código a continuación

fun main(args: Array<String>) {
    foo(baz = 2)
}

Y

class Something {
    init {
        foo(baz = 2)
    }
}

Después de descompilarlo obtuve el siguiente código.

public static final void main(@NotNull String[] args) {
      Intrinsics.checkParameterIsNotNull(args, "args");
      foo$default(0, 2, 1, (Object)null);
}

Y

public final class Something {
   public Something() {
      FooKt.foo$default(0, 2, 1, (Object)null);
   }
}

Lo que tiene aún menos sentido en absoluto.

Mi pregunta es: ¿Por qué Kotlin genera un parámetro no utilizado para funciones con parámetros predeterminados? ¿Es un error?

Answer 1

De acuerdo con this , actualmente no está en uso, pero está reservado para agregar súper llamadas con valores predeterminados más tarde.

Puedes verlo en acción aqui:

open class Foo {
    open fun foo(bar: Int = 0, baz: Int) {
        /* ... */
    }
}

class Blah: Foo() {
    override fun foo(bar: Int, baz: Int) {
    }
}

el cual generará un bytecode-to-Java Foo de:

public class Foo {
   public void foo(int bar, int baz) {
   }

   // $FF: synthetic method
   // $FF: bridge method
   public static void foo$default(Foo var0, int var1, int var2, int var3, Object var4) {
      if(var4 != null) {
         throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: foo");
      } else {
         if((var3 & 1) != 0) {
            var1 = 0;
         }

         var0.foo(var1, var2);
      }
   }
}