Typed arguments to MAIN interact poorly

[kjpye]

Problem

When MAIN has both typed named arguments and named array arguments the argument parsing can fail, producing a usage message rather than running the routine.

For example, the script

#!/usr/bin/env perl6

sub MAIN(:@a, Bool :$b) { say 'ran'; }

when run, produces the following...

# ./testcli
ran

# ./testcli --a=c
ran

# ./testcli --a=c --a=d
ran

# ./testcli --b
ran

# ./testcli --/b
ran

# ./testcli --a=c --b
Usage:
  ./testcli [-a=<Any> ...] [-b]

# ./testcli --a=c --/b
Usage:
  ./testcli [-a=<Any> ...] [-b]

# ./testcli --a=c --a=d --b
ran

# ./testcli --a=c --a=d --/b
ran

# ./testcli --a=c --a=d --a=e --b
ran

# ./testcli --a=c --a=d --a=e --/b
ran

# ./testcli --b --a=c
Usage:
  ./testcli [-a=<Any> ...] [-b]

#2917  ./testcli --b --a=c --a=d
ran

Expected behaviour

It is expected that each case would produce "ran".

Analysis

It appears that when there is exactly one named parameter corresponding to an array argument, and another named argument which is restricted in type are both specified, then a usage message is produced rather than running the code.

This failure is also evident if you replace "Bool" with "Int".

A workaround is to remove the type restriction, in which case the code runs as expected.
[Update: The code does not run as expected in this case; the scalar variable may actually be a single-element array. See comments below.]

Environment

The above examples were run on OpenSuse Leap15 and Tumbleweed systems with the following Rakudo version:

This is Rakudo version 2019.03.1-667-gd4ceb97e0 built on MoarVM version 2019.05-95-g065b2b427
implementing Perl 6.d.

The behaviour is the same (with a differently worded usage message) on the following rakudo versions:

This is Rakudo version 2016.09 built on MoarVM version 2016.09
implementing Perl 6.c.

This is Rakudo version 2017.01 built on MoarVM version 2017.01
implementing Perl 6.c.

This is Rakudo version 2018.01 built on MoarVM version 2018.01
implementing Perl 6.c.

This is Rakudo version 2019.03.1 built on MoarVM version 2019.03
implementing Perl 6.d.

[treyharris]

This appears to overlap with issues raised in #2794.

[kjpye]

Conjecture, based on a reading of the rakudo source (core/Main.pm6 in particular), but not tested in practice:

The basic flow of RUN-MAIN (ignoring all sorts of side issues) is:

1. Parse the arguments into a hash ($positional) and then convert that to a capture (default-args-to-capture).
2. Attempt to use that capture to find a MAIN candidate. If that fails
3. Convert all the scalar named arguments to named arguments with a single-element array (scalars-into-arrays).
4. Attempt to use the new capture to find a MAIN candidate.

Then the candidate is run or a usage message displayed.

What appears to be happening here, with a single argument for the array, is...

1. Generate a capture with "a=>'c', b=>1". This fails, because a is not an array.
2. Convert the capture to "a=>['c'], b=>[1]".

The final step will succeed if the scalar variable b has no type associated with it, although it will contain an array rather than the expected value.

If the scalar variable has an associated type then the final step will fail, because the type of b (array) will fail to match the specified type ("Bool" in the example above).

Note that if no arguments for the array variable are specified the first step will find a valid candidate and the problem will not occur. If multiple arguments for the array variable are specified then the first capture will contain an array and the problem does not occur.

Fixing this will be interesting, but is way above my pay grade.

[kjpye]

To confirm:

Consider a script similar to that above which does not contain the typed argument, but prints the variable contents:

#!/usr/bin/env perl6

sub MAIN(:@a, :$b) { dd @a; dd $b; }

When run with similar arguments as before...

# ./testcli
Array element = []
Any
# ./testcli --b
Array element = []
Bool::True
# ./testcli --a=c
Array element = ["c"]
Any
# ./testcli --a=c --a=d
Array element = ["c", "d"]
Any
# ./testcli --a=c --b
Array element = ["c"]
$[Bool::True]
# ./testcli --a=c --a=d --b
Array element = ["c", "d"]
Bool::True

Note the incorrect output for the "./testcli --a=c --b" case.

[Leont]

Quite frankly, if you want typed arguments or array arguments in MAIN I would recommend using Getopt::Long. It has much more chance of succeeding than any blind parser.