- Change "static final" to "static const" in the runtime/ directory.

runtime/vm/parser.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2547 matching lines @@
   Function& getter = Function::Handle();
   Function& setter = Function::Handle();
   Field& class_field = Field::Handle();
   Instance& init_value = Instance::Handle();
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
     if (has_initializer) {
       ConsumeToken();
       init_value = Object::sentinel();
-      // For static final fields, the initialization expression
+      // For static const fields, the initialization expression
       // will be parsed through the kConstImplicitGetter method
       // invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
       // is compiled.
       // For static fields with very simple initializer expressions
       // (e.g. a literal number or string) we optimize away the
       // kConstImplicitGetter and initialize the field here.
 
       if (field->has_static && (field->has_final || field->has_const) &&
           (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(*field->type, &init_value);
       }
       SkipExpr();
     } else {
       if (field->has_const || (field->has_static && field->has_final)) {
         ErrorMsg(field->name_pos,
                  "%s%s field '%s' must have an initializer expression",
                  field->has_static ? "static " : "",
                  field->has_const ? "const" : "final",
                  field->name->ToCString());
       }
     }
 
     // Create the field object.
-    // TODO(hausner): For now, all static final fields are constant. Remove
+    // TODO(hausner): For now, all static const fields are constant. Remove

[hausner, 2012/08/27 22:12:04]

Please revert change in this comment.

[Ivan Posva, 2012/08/27 23:49:49]

Mechanical replacement only works so far. Thanks for finding this.

     // this when lazy init of static variables is implemented.
     class_field = Field::New(*field->name,
                              field->has_static,
                              field->has_final,
                              field->has_const || field->has_final,
                              current_class(),
                              field->name_pos);
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
 
-    // For static final fields, set value to "uninitialized" and
+    // For static const fields, set value to "uninitialized" and
     // create a kConstImplicitGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(init_value);
       if (!has_simple_literal) {
         String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
         getter = Function::New(getter_name,
                                RawFunction::kConstImplicitGetter,
                                field->has_static,
                                field->has_final,
                                /* is_abstract = */ false,
@@ skipping 6619 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart