The problem is that the spec is inconsistent.  In the first case, it's not an array literal, but an array initializer.

ArrayInitializer:
	[ ]
	[ ArrayMemberInitializations ]

ArrayMemberInitializations:
	ArrayMemberInitialization
	ArrayMemberInitialization ,
	ArrayMemberInitialization , ArrayMemberInitializations

versus

ArrayLiteral:
	[ ArgumentList ]

ArgumentList:
	AssignExpression
	AssignExpression , ArgumentList


Making these consistent is technically an enhancement request rather than a bug.  I nearly set this to enhancement, but the second issue (repetition of the error message) qualifies as a bug IMO.

Thanks for the spec digging, Stewart.  So I see three options:

1) change the ArrayMemberInitializations production to:

ArrayMemberInitializations:
        ArrayMemberInitialization
        ArrayMemberInitialization , ArrayMemberInitializations

(get rid of the trailing comma case for initializations)

2) change the ArrayLiteral productions to 

ArrayLiteral:
        [ ArrayLiteralMemberList ]

ArrayLiteralMemberList:
        AssignExpression
        AssignExpression ,
        AssignExpression , ArrayLiteralMemberList

3) Just make all argument lists have an optional trailing comma.  This is based on the thinking that if allowing a trailing comma is a nice feature for arrays, then why not general argument lists (which can be used as general array constructors with typesafe variadic A[]... style parameters.)?

ArgumentList:
        AssignExpression
        AssignExpression ,
        AssignExpression , ArgumentList

I vote for #2.

I'd originally submitted this on the ldc bugtracker and got forwarded here (since it is using the dmd front-end).  Here's a bit more info on the issue:

When using sabledd generated code, I'm seeing an error with ldc that was not present when I used gdc. It boils down to ldc not accepting only part of the endings of array initializers having commas. The following minimal test case does not build successfully on ldc x64 (but it will if you add a comma to the end of the second array initializer (like '[ 4, 5, 6, ],'). Curiously enough it also builds cleanly if I remove the commas after the 3 and the 6 in the example.

test.d: int arr[][] = [
    [ 1, 2, 3, ], [ 4, 5, 6, ]
];

int main(char[][] args) {
    return 0;
}

Error output:

test.d(7): expression expected, not ']' test.d(7): comma expected separating array initializers, not ; test.d(9): semicolon expected, not 'int' Error: Command failed, aborting.

I agree, ArgumentLists, ArrayLiterals etc. should allow a trailing comma, just like ParameterLists or enums.

Fixing this should be possible in 6 to 10 lines of code. Why is this issue still open?

(In reply to comment #4)
> I agree, ArgumentLists, ArrayLiterals etc. should allow a trailing comma, just
> like ParameterLists or enums.
> 
> Fixing this should be possible in 6 to 10 lines of code. Why is this issue
> still open?

Because there are over 1000 open bugs, and nearly all of them are more important than this one. Make a patch for it, if you care about it.

Created attachment 615 [details]
allow trailing commas in various places

modifications for ArrayLiteral, Arguments, TemplateParameterList, and TemplateArguments.

I haven't tested it too heavily, but the simple stuff works. There might be latent trouble in the ambiguity between ArrayInitializer and ArrayLiteral (aside from what's already present), as I'm not well versed in what happens past the parser.

Don, I know it's not extremely important. I care about it, but I can't make patches for the DMD front- or back-end. Not because I don't want to, but because I'm working on a similar project; my own D compiler, remember? :-)

Ellery, thanks for taking care of this.

(In reply to comment #7)
> Don, I know it's not extremely important. I care about it, but I can't make
> patches for the DMD front- or back-end. Not because I don't want to, but
> because I'm working on a similar project; my own D compiler, remember? :-)
> 

Come to think of it, so am I, or I was. I don't care much about the licensing, though. Or releasing it, if I ever finish it.

> Ellery, thanks for taking care of this.

Only needed to change 4 lines :)

Since this changes the language, I'm going to do it for D2 only and mark it as an enhancement request.

A more comprehensive test case:

void foo(T,)(T t) { T x; }

void main() {
    int[] data = [1,2,3,];
    data = [ 1,2,3, ];
    auto i = data[1,];
    foo!(int)(3);
    foo!(int,)(3);
    foo!(int,)(3,);
}

For D2:

http://www.dsource.org/projects/dmd/changeset/644

Phobos changeset 1939