- 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)) {
@@ skipping 16 matching lines @@
     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 1010 matching lines @@
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
                var_name.ToCString());
     }
     accessor_name = Field::SetterName(var_name);
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "setter for '%s' is already defined",
                var_name.ToCString());
     }
 
-    field = Field::New(
-         var_name, is_static, is_final, is_const, current_class(), name_pos);
+    // TODO(hausner): const and final are equivalent at the moment.
+    field = Field::New(var_name,
+                       is_static,
+                       is_final || is_const,  // Const fields are also final.
+                       is_const || is_final,
+                       current_class(),
+                       name_pos);
     field.set_type(type);
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Object::sentinel());
       bool has_simple_literal = false;
       if ((is_final || is_const) && (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
@@ skipping 5587 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart