Method overloading problem

[rezayi]

Hi.
I have a problem with method overloading in javet.
in js we can define a method and call it with some of inputs. So other input parameters will set as undefined.
for example:

function a(x,y,z){
    console.log(x);
    console.log(y);
    console.log(z);
}

we can call function a as below:

a(1);
a(1,2)
a(1,2,3)

but the problem is when function a is defined in java. if parameters count of function call not equals with java function input parameters count it will throw an error.
The solution can be method Overloading in java, but just first method of methods with same name will perform and other will be ignored.
The final solution I found is doing such as javascript,I mean if function called with a part of input parameters we call other parameters as null .

In class V8FuntionCallback at method receiveCallback this change can resolve this problem

 if (args != null) {
     final int length = args.getLength();
     for (int i = 0; i < length; ++i) {
           values.add(args.get(i));
     }
}

to

 if (args != null) {
     final int length = args.getLength();
     for (int i = 0; i < length; ++i) {
           values.add(args.get(i));
     }
     while (values.size() < method.getParameterCount()) {
        values.add(null);
     }
}

[caoccao]

Please check this doc out.

[rezayi]

Regarding case 1, I should say that when you set a parameter as optional, you should not use primitive types. In fact, this situation is a bug. The problem can be solved by specifying Object instead of primitive.
Regarding item 2, when vararg really needed we can use your solution.
and Regarding item 3, I should say that our function is specified in Java and Java is a static language. So you can define all required parameters in Java and make sure that no more parameters will receive.
And finally, for exceeding parameters, you can do almost like JavaScript. when exceeding parameters passed to a function javascript will accept them but implemented code ignores them.when we implement a method in java we don't expect exceeding parameters. so we can ignore exceeding parameters when calling a Java method.
Finally, it seems that the best solution is to have both ways.

[caoccao]

That makes sense. I'll think it over.

[caoccao]

Maybe Strict Mode vs. Loose Mode, so that both of the Javet users can be satisfied.

[caoccao]

I decided to support it without a switch. Please check this commit out. It will be included in the next release.

[rezayi]

Thank you for your attention. :)