Fix for issue 1835: record the 'final' information in the DeclaredIdentifier.

frog/parser.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(jimhug): Error recovery needs major work!
 /**
  * A simple recursive descent parser for the dart language.
  *
  * This parser is designed to be more permissive than the official
  * Dart grammar.  It is expected that many grammar errors would be
@@ skipping 443 matching lines @@
       } else {
         name = new Identifier('', names[0].span);
       }
     }
 
     if (names.length > 1) {
       // TODO(jimhug): This is nasty to support and currently unused.
       _error('unsupported qualified name for factory', names[0].span);
     }
     type = new NameTypeReference(false, names[0], null, names[0].span);
-    var di = new DeclaredIdentifier(type, name, _makeSpan(start));
+    var di = new DeclaredIdentifier(type, name, false, _makeSpan(start));
     return finishDefinition(start, [factoryToken], di);
   }
 
   ///////////////////////////////////////////////////////////////////
   // Statement productions
   ///////////////////////////////////////////////////////////////////
   Statement statement() {
     switch (_peek()) {
       case TokenKind.BREAK:
         return breakStatement();
@@ skipping 169 matching lines @@
     } else {
       var init = expression();
       // Weird code here is needed to handle generic type and for in
       // TODO(jmesserly): unify with block in finishExpressionAsStatement
       if (_peekKind(TokenKind.COMMA) && _isBin(init, TokenKind.LT)) {
         _eat(TokenKind.COMMA);
         var baseType = _makeType(init.x);
         var typeArgs = [_makeType(init.y)];
         var gt = _finishTypeArguments(baseType, 0, typeArgs);
         var name = identifier();
-        init = new DeclaredIdentifier(gt, name, _makeSpan(init.span.start));
+        init = new DeclaredIdentifier(gt, name, false, _makeSpan(init.span.start));
       }
 
       if (_maybeEat(TokenKind.IN)) {
         return _finishForIn(start, _makeDeclaredIdentifier(init));
       } else {
         return finishExpressionAsStatement(init);
       }
     }
   }
 
@@ skipping 173 matching lines @@
     }
   }
 
   infixExpression(int precedence) {
     return finishInfixExpression(unaryExpression(), precedence);
   }
 
   _finishDeclaredId(type) {
     var name = identifier();
     return finishPostfixExpression(
-      new DeclaredIdentifier(type, name, _makeSpan(type.span.start)));
+      new DeclaredIdentifier(type, name, false, _makeSpan(type.span.start)));
   }
 
   /**
    * Takes an initial binary expression of A < B and turns it into a
    * declared identifier included the A < B piece in the type.
    */
   _fixAsType(BinaryExpression x) {
     assert(_isBin(x, TokenKind.LT));
     // TODO(jimhug): good errors when expectations are violated
     if (_maybeEat(TokenKind.GT)) {
@@ skipping 153 matching lines @@
       // must be forbidden when parsing initializers.
       // TODO(jmesserly): is this still needed?
       case TokenKind.ARROW:
       case TokenKind.LBRACE:
          return expr;
 
       default:
         if (_peekIdentifier()) {
           return finishPostfixExpression(
             new DeclaredIdentifier(_makeType(expr), identifier(),
-              _makeSpan(expr.span.start)));
+              false, _makeSpan(expr.span.start)));
         } else {
           return expr;
         }
     }
   }
 
   finishCallOrLambdaExpression(expr) {
     if (_atClosureParameters()) {
       var formals = formalParameterList();
       var body = functionBody(true);
@@ skipping 282 matching lines @@
         return null;
     }
     return new Identifier(name, _makeSpan(start));
   }
 
   // always includes this and ... as legal names to simplify other code.
   declaredIdentifier([bool includeOperators=false]) {
     int start = _peekToken.start;
     var myType = null;
     var name = _specialIdentifier(includeOperators);
+    bool isFinal = false;
     if (name == null) {
       myType = type();
       name = _specialIdentifier(includeOperators);
       if (name == null) {
         if (_peekIdentifier()) {
           name = identifier();
         } else if (myType is NameTypeReference && myType.names == null) {
           name = _typeAsIdentifier(myType);
+          isFinal = myType.isFinal;
           myType = null;
         } else {
           // TODO(jimhug): Where do these errors get handled?
         }
       }
     }
-    return new DeclaredIdentifier(myType, name, _makeSpan(start));
+    return new DeclaredIdentifier(myType, name, isFinal, _makeSpan(start));
   }
 
   finishNewExpression(int start, bool isConst) {
     var type = type();
     var name = null;
     if (_maybeEat(TokenKind.DOT)) {
       name = identifier();
     }
     var args = arguments();
     return new NewExpression(isConst, type, name, args, _makeSpan(start));
@@ skipping 317 matching lines @@
     }
     var span = new SourceSpan(expr.span.file, expr.span.start, body.span.end);
     var func = new FunctionDefinition(null, type, name, formals, null, null,
                                       body, span);
     return new LambdaExpression(func, func.span);
   }
 
   /** Converts an expression to a [DeclaredIdentifier]. */
   _makeDeclaredIdentifier(e) {
     if (e is VarExpression) {
-      return new DeclaredIdentifier(null, e.name, e.span);
+      return new DeclaredIdentifier(null, e.name, false, e.span);
     } else if (e is DeclaredIdentifier) {
       return e;
     } else {
       _error('expected declared identifier');
-      return new DeclaredIdentifier(null, null, e.span);
+      return new DeclaredIdentifier(null, null, false, e.span);
     }
   }
 
   /** Converts an expression into a label. */
   _makeLabel(expr) {
     if (expr is VarExpression) {
       return expr.name;
     } else {
       _errorExpected('label');
       return null;
@@ skipping 26 matching lines @@
   int _pos = 0;
   next() {
     var token = tokens[_pos];
     ++_pos;
     if (_pos == tokens.length) {
       parser.tokenizer = previousTokenizer;
     }
     return token;
   }
 }