Add trailing commas to argument and parameter lists.

docs/language/dartLangSpec.tex

Index: docs/language/dartLangSpec.tex
diff --git a/docs/language/dartLangSpec.tex b/docs/language/dartLangSpec.tex
index 3b7bdeb8c5c35cd8a6a8c2af36d1f76f84ef6e05..24753c21216362c656417f88d2145f28304800c9 100644
--- a/docs/language/dartLangSpec.tex
+++ b/docs/language/dartLangSpec.tex
@@ -655,9 +655,11 @@ The body of a function introduces a new scope known as the function's {\em  body
 It is a compile-time error if a formal parameter is declared as a constant variable (\ref{variables}).
 
 \begin{grammar}
-{\bf formalParameterList:}`(' `)';
- `(' normalFormalParameters ( `,'  optionalFormalParameters)? `)';
-  `(' optionalFormalParameters `)'
+{\bf formalParameterList:}
+     `(' `)';
+     `(' normalFormalParameters `,'? `)';
+     `(' normalFormalParameters `,'  optionalFormalParameters `)';
+     `(' optionalFormalParameters `)'
    .
 %\end{grammar}
 %}
@@ -673,15 +675,16 @@ It is a compile-time error if a formal parameter is declared as a constant varia
       normalFormalParameter (`,' normalFormalParameter)*
     .
 
-{\bf optionalFormalParameters:}optionalPositionalFormalParameters;
+{\bf optionalFormalParameters:}
+      optionalPositionalFormalParameters;
       namedFormalParameters
     .
 
 {\bf optionalPositionalFormalParameters:}
-      `[' defaultFormalParameter (`,' defaultFormalParameter)* `]'
+      `[' defaultFormalParameter (`,' defaultFormalParameter)* `,'? `]'
     .
 {\bf namedFormalParameters:}
-      `\{' defaultNamedParameter (`,' defaultNamedParameter)* `\}'
+      `\{' defaultNamedParameter (`,' defaultNamedParameter)* `,'? `\}'
     .
 \end{grammar}
 
@@ -3608,13 +3611,12 @@ Function invocation involves evaluation of the list of actual arguments to the f
 
 \begin{grammar}
 {\bf arguments:}
-      `(' argumentList? `)'
+      `(' (argumentList  `,'?)? `)'
     .
 
-{\bf argumentList:}namedArgument (`,' namedArgument)*;
-  %    expressionList ',' spreadArgument;
+{\bf argumentList:}
+      namedArgument (`,' namedArgument)*;
       expressionList (`,' namedArgument)*

[eernst, 2016/06/14 09:08:32]

I think we should gather all the changes motivated by "this is a comment, and it
is not a TODO, so we just delete it" in a separate CL, such that we have a
reasonably easy target to search for those parts in case we do want to browse
them.

In that case, we should just leave them as they are now in this CL.

[Lasse Reichstein Nielsen, 2016/06/27 17:27:53]

Let's do that. Reinserted for now.

-%      spreadArgument
     .
 
 {\bf namedArgument:}
@@ -3627,7 +3629,7 @@ Evaluation of an actual argument list of the form
 
 $(a_1, \ldots, a_m, q_1: a_{m+1}, \ldots, q_l: a_{m+l})$
 
-proceeds as follows:
+(ignoring any trailing comma) proceeds as follows:

[eernst, 2016/06/14 09:08:33]

The given argument list serves as the basis for specifying the semantics, i.e.,
it is intended to be a template for all possible argument lists (rather than,
say, an example).

In order to uphold this interpretation, I think it might be better to say
'(omitting any trailing comma)', because we avoid giving the reader the
impression that anything is imprecise here because we 'ignore' some details.

But I think it would be better to say once and for all at the location where the
grammar introduces the trailing commas (at line 694 and 3626) that _all_
argument/parameter lists in the specification will use the form where no
trailing comma is present, and the addition of a trailing comma does not have
any effect on the semantics of the given construct.

The same issue would come up with 'Type of a Function' and a number of other
places, so we had better make sure it is handled collectively (and surely we
wouldn't want to make such a comma semantically significant anywhere).

 
 \LMHash{}
 The arguments $a_1, \ldots, a_{m+l}$ are evaluated in the order they appear in the program, yielding objects $o_1, \ldots, o_{m+l}$.
@@ -3643,7 +3645,7 @@ The arguments $a_1, \ldots, a_{m+l}$ are evaluated in the order they appear in t
 Let $f$ be a function with $h$ required parameters,  let $p_1 \ldots p_n$ be the positional parameters of $f$ and let $p_{h+1}, \ldots, p_{h+k}$ be the optional parameters declared by $f$.
 
 \LMHash{}
-An evaluated actual argument list $o_1 \ldots o_{m+l}$ derived from an actual argument list of the form $(a_1, \ldots, a_m, q_1: a_{m+1}, \ldots, q_l: a_{m+l})$ is bound to the formal parameters of $f$ as follows:
+An evaluated actual argument list $o_1 \ldots o_{m+l}$ derived from an actual argument list of the form $(a_1, \ldots, a_m, q_1: a_{m+1}, \ldots, q_l: a_{m+l})$ (ignoring any trailing comma) is bound to the formal parameters of $f$ as follows:

[eernst, 2016/06/14 09:08:33]

Same issue as line 3632.

 
 \commentary{
 We have an argument list consisting of $m$ positional arguments and $l$ named arguments. We have a function with $h$ required parameters and $k$ optional parameters. The number of positional arguments must be at least as large as the number of required parameters, and no larger than the number of positional parameters. All named arguments must have a corresponding named parameter. You may not provide a given named argument more than once.  If an optional parameter has no corresponding argument, it gets its default value. In checked mode, all arguments must belong to subtypes of the type of their corresponding formal.