Type int[][] of the last argument to method println(Object...) doesn't exactly match the vararg parameter type

I have the following:

static public void println(Object what) {
    if (what == null) {
        out.println("null");    
        out.flush();
    }
    else if (what.getClass().isArray()) {
        printlnArray(what);
    }
    else {
        out.println(what);
        out.flush();
    }
}


static public void println(Object... variables) {

    for (int i = 0; i < variables.length; i++) {
        Object o = variables[i];
        if (o.getClass().isArray()) {
            printlnArray(o);
        }
        else {
            out.print(o);
            if (i != variables.length-1) out.print(" ");
        }
    }
    out.println();
    out.flush();  
}

If I call it like this:

int[][] array_2d = {{1}, {1, 2}, {1, 2, 3}};
println("array_2d");
println(array_2d);

Then I get the error:

> Type int[][] of the last argument to method println(Object...) doesn't exactly match the vararg parameter type. Cast to Object[] to confirm the non-varargs invocation, or pass individual arguments of type Object for a varargs invocation.

I can't seem to find a way to suppress this warning. Neither do I have any luck with fixing the error. Adding println(int[][] variables) is not an option.

I did an attempt in this direction:

enum Skip {
    SKIP
}

static public void println(Object[] variables) {
    println(Skip.SKIP, variables);
}

static public void println(Object first, Object... variables) {

    if (first instanceof Skip) {

    }
    else {
        print(first);
    }

But it does not work and would require to much obscure code to get it working.

Can this problem be fixed with reasonable clean code?

One problem is that invokes on println are ambiguous. After all, println(Object... x) is just syntax sugar for println(Object[] x) with the additional nicety that callers will silently create that array for you if invokes with multiple arguments. This makes invoking println with a single value, but that value is an array, ambiguous: Either form is plausible (an array is itself an Object!)

Simple solution is to disambiguate:

/*1*/ public void println() {}

/*2*/ public void println(Object o) { ... }

/*3*/ public void println(Object a, Object b, Object... rest) { }

Now all forms except println() work out and are not ambiguous:

println(); // invokes #1
println(x); // invokes #2, and only #2. Even if x is an array.
println(x, y); //invokes #3, with an empty array for 'rest'
println(x, y, a, b, c); // invokes #3.

NB: Do NOT write println(Object a, Object b) or println(Object a, Object... rest) - that would re-introduce ambiguity!

The warning occurs because it is ambiguous whether you want to:

• pass the 2D array as one whole Object to the varargs:

  // calling this as if it weren't a varargs method for clarity
  println(new Object[] { array_2d })
  

  or;

• "splat" the outer array such that each inner array is one of the varargs:

  println(new Object[] { array_2d[0], array_2d[1], array_2d[2] })
  

If you want the former, cast the 2D array to Object. If you want the latter, cast the 2D array to Object[].

println((Object)array_2d);
// or
println((Object[])array_2d);

Doing either will silence the warning.