main function may take two arguments.

docs/language/dartLangSpec.tex

 \documentclass{article}
 \usepackage{epsfig}
 \usepackage{dart}
 \usepackage{bnf}
 \usepackage{hyperref}
 \newcommand{\code}[1]{{\sf #1}}
 \title{Dart Programming Language  Specification \\
 {\large Version 1.4}}
 %\author{The Dart Team}
 \begin{document}
@@ skipping 5205 matching lines @@
 A {\em part header} begins with  \PART{} \OF{}  followed by the name of the library the part belongs to.  A part declaration consists of a part header followed by a sequence of top-level declarations.
 
 Compiling a part directive of the form \code{\PART{} $s$;} causes the Dart system to attempt to compile the contents of the URI that is the value of $s$. The top-level declarations at that URI are then compiled by the Dart compiler in the scope of the current library. It is a compile-time error if the contents of the URI are not a valid part declaration. It is a static warning if the referenced part declaration $p$ names a library other than the current library as the library to which $p$ belongs.
 
 \subsection{Scripts}
 \label{scripts}
 
 A {\em script} is a library whose exported namespace  (\ref{exports}) includes a top-level function \code{main}. 
 A script $S$ may be executed as follows:
 
-First, $S$ is compiled as a library as specified above. Then, the top-level function \code{main} that is in the exported namespace of $S$ is invoked. If \code{main} has no formal parameters, it is invoked with no arguments. Otherwise \code{main} is invoked with a single actual argument whose type implements \code{List$<$String$>$}. It is a run time error if $S$ does not declare or import a top-level function \code{main}. It is a static warning if \code{main} has more than one required parameter.
+First, $S$ is compiled as a library as specified above. Then, the top-level function \code{main} that is in the exported namespace of $S$ is invoked. If \code{main} has no formal parameters, it is invoked with no arguments. Otherwise if \code{main} has exactly one parameter, it is invoked with a single actual argument whose type implements \code{List$<$String$>$}.  Otherwise \code{main} is invoked with the following two actual arguments:

[Lasse Reichstein Nielsen, 2014/05/15 20:44:48]

I believe the way it is implemented, and the way it is partially specified in
the documentation for Isolate.spawnUri
(https://api.dartlang.org/apidocs/channels/stable/dartdoc-viewer/dart-isolate....),
is that:
- if the main function's type is a subtype of (dynamic,dynamic)->dynamic, then
it is called with two arguments.
- otherwise, if the main function's type is a subtype of (dynamic)->dynamic,
then it is called with one argument,
- otherwise it is called with no arguments.

This specification differs from this if there are optional parameters :
 main([a, b, c]);    // two arguments
 main(a, [b, c]);    // two arguments
 main(a, b, [c]);    // two arguments
 main([a]);          // one argument
 main(a, b, {x:42}); // two arguments
 main(a, {x:42});    // one argument
 main({x: 42});      // zero arguments
All of these should be valid and cause no warning. Recursively calling main with
extra parameters isn't good style, but it is allowed.

More than two required parameters is still a static warning and runtime error.

+\begin{enumerate}
+\item An object whose type implements \code{List$<$String$>$}.
+\item The initial message of the current isolate $i$ as determined by the invocation of \code{Isolate.spawnUri} that spawned $i$. 
+\end{enumerate}
+
+It is a run time error if $S$ does not declare or import a top-level function \code{main}. It is a static warning if \code{main} has more than two required parameters.
 
 \commentary {
-If \code{main} requires more than one argument, a run time error will occur.
+Note that if \code{main} requires more than two arguments, a run time error will occur. 
 }
 
 \rationale{
 The names of scripts are optional, in the interests of interactive, informal use. However, any script of long term value should be given a name as a matter of good practice. 
 }
 
 \commentary {
 A Dart program will typically be executed by executing a script.
 }
 
@@ skipping 691 matching lines @@
 \item The names of compile time constant variables never use lower case letters. If they consist of multiple words, those words are separated by underscores. Examples: PI,  I\_AM\_A\_CONSTANT.
 \item The names of functions (including getters, setters, methods and local or library functions) and non-constant variables begin with a lowercase letter. If the name consists of multiple words, each  word (except the first) begins with an uppercase letter.  No other uppercase letters are used. Examples: camlCase, dart4TheWorld
 \item The names of types (including classes and type aliases) begin with an upper case letter.  If the name consists of multiple words, each  word  begins with an uppercase letter.  No other uppercase letters are used. Examples: CamlCase, Dart4TheWorld.
 \item The names of type variables are short (preferably single letter). Examples: T, S, K, V , E.
 \item The names of libraries or library prefixes never use upper case letters. If they consist of multiple words, those words are separated by underscores. Example: my\_favorite\_library.
 \end{itemize}
 }
 
 
 \end{document}