Changes required for ECMA standardization, plus allow void in getter return type.

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.2}}
-\author{The Dart Team}
+{\large Version 1.3}}
+%\author{The Dart Team}
 \begin{document}
 \maketitle
-
 \tableofcontents
 
 
 \newpage
 
 \pagestyle{myheadings}
 \markright{Dart Programming Language Specification}
 
-\section{Notes}
+% begin Ecma boilerplate
+\section{Scope}
+\label{ecmaScope}
 
-\subsection{Licensing}
-\label{licensing}
+This Ecma standard specifies the syntax and semantics of the Dart programming language.  It does not specify the APIs of the Dart libraries except where those library elements are essential to the correct functioning of the language itself (e.g., the existence of class \cd{Object} with methods such as \cd{noSuchMethod}, \cd{runtimeType}).
+
+\section{Conformance}
+\label{ecmaConformance}
+
+A conforming  implementation of the Dart programming language must provide and support all the  APIs (libraries, types, functions, getters, setters, whether top-level, static, instance or local) mandated in this specification. 
+
+A conforming implementation is permitted to provide additional APIs, but not additional syntax, except for experimental features in support of enumerated types and deferred loading which are expected to be added in the next revision of this specification.
+
+% A claim of conformance with this Ecma Standard shall specify?
+
+\section{Normative References}
+\label{ecmaNormativeReferences}
+
+The following referenced documents are indispensable for the application of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.
+
+\begin{enumerate}
+\item
+The Unicode Standard, Version 5.0, as amended by Unicode 5.1.0, or successor.
+\item
+Dart API Reference, https://api.dartlang.org/
+\end{enumerate}
 
 
-Except as otherwise noted at https://developers.google.com/site-policies, the content of this document is licensed under the Creative Commons Attribution 3.0 License available at:
+\section{Terms and Definitions}
+\label{ecmaTermsAndDefinitions}
 
-  http://creativecommons.org/licenses/by/3.0/
-  
-  and code samples are licensed under the license available at
-  
-  https://code.google.com/p/dart/source/browse/trunk/dart/LICENSE.
+Terms and definitions used in this specification are given in the body of the specification proper. Such terms are highlighted in italics when they are introduced, e.g., `we use the term {\em verbosity} to refer to the property of excess verbiage'.
+% End Ecma Boilerplate
+
   
 \section{Notation}
 \label{notation}
 
 We distinguish between normative and non-normative text. Normative text defines the rules of Dart. It is given in this font. At this time, non-normative text includes:
 \begin{itemize}
 \item[Rationale] Discussion of the motivation for language design decisions appears in italics. \rationale{Distinguishing normative from non-normative helps clarify what part of the text is binding and what part is merely expository.}
 \item[Commentary] Comments such as  ``\commentary{The careful reader will have noticed that the name Dart has four characters}'' serve to illustrate or clarify the specification, but are redundant with the normative text.  \commentary{The difference between commentary and rationale can be subtle.} \rationale{ Commentary is more general than rationale, and may include illustrative examples or clarifications. }
 \item[Open questions] (\Q{in this font}). Open questions are points that are unsettled in the mind of the author(s) of the specification; expect them (the questions, not the authors; precision is important in a specification) to be eliminated in the final specification. \Q{Should the text at the end of the previous bullet be rationale or commentary?}
 \end{itemize}
@@ skipping 809 matching lines @@
 It is a static warning if the return type of the user-declared operator \code{[]=} is explicitly declared and not \VOID{}.
 
 
 \subsection{Getters} 
 \label{getters}
 
 Getters are functions (\ref{functions})  that are used to retrieve the values of object properties.
 
 \begin{grammar}
 {\bf getterSignature:}
-       type? \GET{} identifier 
+       returnType? \GET{} identifier 
 .
 \end{grammar}
 
 %\Q{Why does a getter have a formal parameter list at all?}
 
 If no return type is specified, the return type of the getter is  \DYNAMIC{}.
 
 A getter definition that is prefixed with the \STATIC{} modifier defines a static getter. Otherwise, it defines an instance getter. The name of the getter is given by the identifier in the definition.
 
 %It is a compile-time error if a getter`s formal parameter list is not empty.
 
 The instance getters of a class $C$ are those instance getters declared by $C$, either implicitly or explicitly, and the instance getters inherited by $C$ from its superclass. The static getters of a class $C$ are those static getters declared by $C$.
 
 It is a compile-time error if a class has both a getter and a method with the same name. This restriction holds regardless of whether the getter is defined explicitly or implicitly, or whether the getter or the method are inherited or not.
 
 \commentary{
 This implies that a getter can never override a method, and a method can never override a getter or field. 
 }
 
+It is a static warning if the return type of a getter is \VOID.
 It is a static warning if a getter $m_1$ overrides  (\ref{inheritanceAndOverriding}) a getter 
 $m_2$ and the type of $m_1$ is not a subtype of the type of $m_2$.   
 
 It is a static warning if a class  declares a static getter named $v$ and also has a non-static setter named $v=$. It is a static warning if a class $C$ declares an instance getter named $v$ and an accessible static member named $v$ or $v=$ is declared in a superclass of $C$. These warnings must be issued regardless of whether the getters or setters are declared explicitly or implicitly.
 
 \subsection{Setters}
 \label{setters}
 
 Setters are functions (\ref{functions}) that are used to set the values of object properties.
 
@@ skipping 334 matching lines @@
 \commentary{
 It follows that if $type$ or $type.id$ are not defined, or do not refer to a class or constructor, a dynamic error occurs, as with any other undefined constructor call. The same holds if $k$ is called with fewer required parameters or more positional parameters than $k^\prime$ expects, or if $k$  is called with a named parameter that is not declared by $k^\prime$.
 }
 
 It is a compile-time error if $k$ explicitly specifies a default value for an optional parameter.\commentary{
 Default values specified in $k$ would be ignored, since it is the {\em actual} parameters that are passed to $k^\prime$. Hence, default values are disallowed.
 }
 
 It is a compile-time error if a redirecting factory constructor redirects to itself, either directly or indirectly via a sequence of redirections. %does not redirect to a non-redirecting factory constructor or to a generative constructor in a finite number of steps.
 
+% Make this a runtime error so deferred loading works
+
 \rationale{
 If a redirecting factory $F_1$ redirects to another redirecting factory $F_2$ and $F_2$ then redirects to $F_1$, then both $F_1$ and $F_2$ are ill-defined. Such cycles are therefore illegal.
 } 
 
 
 It is a static warning if $type$ does not denote a class accessible in the current scope; if $type$ does denote such a class $C$ it is a static warning if the referenced constructor (be it $type$ or $type.id$) is not a constructor of $C$.
 
 \commentary{
 Note that it is not possible to modify the arguments being passed to  $k'$.  
 }
@@ skipping 2630 matching lines @@
       IDENTIFIER\_START\_NO\_DOLLAR IDENTIFIER\_PART\_NO\_DOLLAR*
     .
 
 {\bf IDENTIFIER:}
       IDENTIFIER\_START IDENTIFIER\_PART*
     .
 
 {\bf BUILT\_IN\_IDENTIFIER:} \ABSTRACT{};
      \AS{};
 %     \ASSERT{};
+     \DEFERRED{};
      \DYNAMIC{};
      \EXPORT{};
      \EXTERNAL{};
      \FACTORY{};
      \GET{};
      \IMPLEMENTS{};
      \IMPORT{};
      \LIBRARY{};
      \OPERATOR{};
      \PART{};
@@ skipping 1736 matching lines @@
 A {\em parameterized type} is an invocation of a generic type declaration.
 
 Let $T$ be a parameterized type  $G<S_1,  \ldots, S_n>$. If $G$ is not a generic type, the type arguments $S_i$, $1 \le i \le n$ are discarded. If $G$ has $m \ne n$ type parameters, $T$ is treated as as a parameterized type with $m$ arguments, all of which are \DYNAMIC{}. 
 
 \commentary{In short, any arity mismatch results in all type arguments being dropped, and replaced with the correct number of type arguments, all set to \DYNAMIC{}. Of course, a static warning will be issued. 
 }
 
 Otherwise, let
  $T_i$ be the type parameters of $G$ and let $B_i$ be the bound of $T_i,  i \in 1.. n$,. $T$ is {\em malbounded} iff either $S_i$ is malbounded  or $S_i$ is not a subtype of $[S_1,  \ldots, S_n/T_1, \ldots, T_n]B_i,   i \in 1.. n$. 
  
+\commentary{
 Note, that, in checked mode, it is a dynamic type error if a malbounded type is used in a type test as specified in \ref{dynamicTypeSystem}.
+}
  
 Any use of a malbounded type gives rise to a static warning.
 
 If $S$ is the static type of a member $m$ of $G$, then the static type of the member $m$ of  $G<A_1, \ldots, A_n>$  is $[A_1,  \ldots, A_n/T_1,  \ldots, T_n]S$ where $T_1,  \ldots, T_n$ are the formal type parameters of $G$.   Let $B_i$, be the bounds of $T_i, 1 \le i \le n$. It is a static type warning if $A_i$ is not a subtype of  $[A_1,  \ldots, A_n/T_1,  \ldots, T_n]B_i, i \in 1..n$. It is a static type warning if $G$ is not a generic type with exactly $n$ type parameters.
 
 
 
 
 
 \subsubsection{Actual Type of Declaration}
@@ skipping 188 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}