Revert setters for final variables.

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 Draft Version 0.71}}
 \author{The Dart Team}
 \begin{document}
@@ skipping 493 matching lines @@
 \ref{return}: Added warning if \RETURN{} without expression mixed with \RETURN{} with an expression.
 
 \ref{exports}: Ensure that exports treat \code{dart:} libs specially, like imports do.
 
 \ref{typePromotion}: Added notion of type promotion.
 
 \ref{typedef}: Banned all recursion in typedefs.
 
 \subsubsection{Changes Since Version 0.7}
 
+
+\ref{variables}: Final variables no longer introduce setters.
+
 \ref{new}: Instantiating subclasses of malbounded types is a dynamic error.
 
 \ref{leastUpperBounds}:  Extended LUBs to all types.
 
 
 
 \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:
@@ skipping 290 matching lines @@
 
 Taken as a whole, the rules ensure that any attempt to execute multiple assignments to a final variable will yield static warnings and repeated assignments will fail dynamically.
 }
 
 A {\em constant variable} is a variable whose declaration includes the modifier \CONST{}. A constant variable is always implicitly final. A constant variable must be initialized to a compile-time constant (\ref{constants}) or a compile-time error occurs.
 
 We say that a variable $v$ is {\em potentially mutated} in some scope $s$ if $v$ is not final or constant and an assignment to $v$ occurs in $s$.
 
 If a variable declaration does not explicitly specify a type, the type of the declared variable(s) is  \DYNAMIC{}, the unknown type (\ref{typeDynamic}). 
 
-Static and instance variable declarations always induce implicit getters and setters.
+A variable is {\em mutable} if it is not final.
+Static and instance variable declarations always induce implicit getters. If the variable is mutable it also introduces an implicit setter.
 The scope into which the implicit getters and setters are introduced depends on the kind of variable declaration involved. 
 
-A library variable introduces a getter and a setter into the top level scope of the enclosing library. A static class variable introduces a static getter and a static setter into the immediately enclosing class. An instance variable introduces an instance getter and an instance setter into the immediately enclosing class. 
+A library variable introduces a getter into the top level scope of the enclosing library. A static class variable introduces a static getter into the immediately enclosing class. An instance variable introduces an instance getter into the immediately enclosing class. 
+
+A mutable library variable introduces a setter into the top level scope of the enclosing library. A mutable static class variable introduces a static setter into the immediately enclosing class. A mutable instance variable introduces an instance setter into the immediately enclosing class. 
 
 Local variables are added to the innermost enclosing scope.  They do not induce getters and setters.  A local variable may only be referenced at a source code location that is after its initializer, if any, is complete, or a compile-time error occurs.  The error may be reported either at the point where the premature reference occurs, or at the variable declaration.
 
 \rationale {
 We allow the error to be reported at the declaration to allow implementations to avoid an extra processing phase. 
 }
 
 \commentary{
 The example below illustrates the expected behavior.  A variable $x$ is declared at the library level, and another $x$ is declared inside the function $f$.
 }
@@ skipping 64 matching lines @@
  \VOID{} \SET{} $v=(T$ $x)$
 
 whose execution sets the value of $v$ to the incoming argument $x$.
 
 A  non-final variable declaration  of the form \code{\VAR{} $v$;} or the form  \code{\VAR{} $v$ = $e$;}   always induces an implicit  setter function with signature 
 
 \SET{} $v=(x)$
 
 whose execution sets the value of $v$ to the incoming argument $x$.
 
-% A final variable introduces a setter that throws and causes a type warning
-
-A final or constant variable declaration  of the form \code{\FINAL{} $T$ $v$;}, \code{\FINAL{} $T$ $v$ = $e$;} or the form  \code{\CONST{} $T$ $v$ = $e$;}   always induces an implicit  setter function (\ref{setters}) with signature 
-
- \VOID{} \SET{} $v=(T$ $x)$
-
-whose execution causes a runtime exception. It is a static warning to invoke such a setter.
-
-A  final variable declaration  of the form \code{\FINAL{} $v$;},  \code{\FINAL{} $v$ = $e$;} or the form  \code{\CONST{} $v$ = $e$;}   always induces an implicit  setter function with signature 
-
-\SET{} $v=(x)$
-
-whose execution causes a runtime exception. It is a static warning to invoke such a setter. % maybe redundant with rules for assignment?
-
-\rationale{
-Creating a setter that may not be used may seem pointless, but it prevents situations where a setter from an enclosing scope might be accidentally accessed from a scope that defines an immutable variable.
-}
-
 
 \subsection{Evaluation of Implicit  Variable Getters}
 \label{evaluationOfImplicitVariableGetters}
 
 Let $d$ be the declaration of a static or instance variable $v$.  If $d$ is an instance variable, then the invocation of the implicit getter  of $v$ evaluates to the value stored in $v$.
 If $d$ is a static or library variable then the implicit getter method of $v$ executes as follows: 
 \begin{itemize}
 \item {\bf Non-constant variable declaration with initializer}. If $d$ is of one of the forms \code{\VAR{} $v$ = $e$;} ,  \code{$T$ $v$ = $e$;} ,   \code{\FINAL{} $v$ = $e$;} ,  \code{\FINAL{} $T$ $v$ = $e$;}, \code{\STATIC{} $v$ = $e$; }, \code{\STATIC{} $T$ $v$ = $e$; }, \code{\STATIC{} \FINAL{} $v$ = $e$; } or \code{\STATIC{} \FINAL{} $T$ $v$ = $e$;} and no value has yet been stored into $v$ then the initializer expression $e$ is evaluated. If, during the evaluation of $e$, the getter for $v$ is invoked, a \code{CyclicInitializationError} is thrown. If the evaluation succeeded yielding an object $o$, let $r = o$, otherwise let $r = \NULL{}$. In any case, $r$ is stored into $v$. The result of executing the getter is $r$. 
 \item  {\bf Constant variable declaration}. If $d$ is of one of the forms \code{\CONST{} $v$ = $e$; } ,  \code{\CONST{} $T$  $v$ = $e$; },  \code{\STATIC{} \CONST{} $v$ = $e$; }  or \code{\STATIC{} \CONST{} $T$ $v$ = $e$;} the result of the getter is the value of the compile time constant $e$. \commentary{Note that a compile time constant cannot depend on itself, so no cyclic references can occur.} 
 Otherwise
@@ skipping 5227 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}