Rename accessors of class Field to make it more apparent as to what is being accessed - static fiel…

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 1343 matching lines @@
         ReportError(cls, field.token_pos(),
                     "field '%s' of class '%s' conflicts with method '%s' "
                     "of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     }
     if (field.is_static() &&
-        (field.value() != Object::null()) &&
-        (field.value() != Object::sentinel().raw())) {
+        (field.StaticValue() != Object::null()) &&
+        (field.StaticValue() != Object::sentinel().raw())) {
       // The parser does not preset the value if the type is a type parameter or
       // is parameterized unless the value is null.
       Error& error = Error::Handle(Z);
       if (type.IsMalformedOrMalbounded()) {
         error = type.error();
       } else {
         ASSERT(type.IsInstantiated());
       }
-      const Instance& const_value = Instance::Handle(Z, field.value());
+      const Instance& const_value =
+          Instance::Handle(Z, field.StaticValue());
       if (!error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
                                      Object::null_type_arguments(),
                                      &error))) {
         if (Isolate::Current()->flags().error_on_bad_type()) {
           const AbstractType& const_value_type = AbstractType::Handle(
               Z, const_value.GetType());
           const String& const_value_type_name = String::Handle(
               Z, const_value_type.UserVisibleName());
@@ skipping 21 matching lines @@
                             /* is_static = */ true,
                             /* is_const = */ field.is_const(),
                             /* is_abstract = */ false,
                             /* is_external = */ false,
                             /* is_native = */ false,
                             cls,
                             field.token_pos()));
           getter.set_result_type(type);
           getter.set_is_debuggable(false);
           cls.AddFunction(getter);
-          field.set_value(Object::sentinel());
+          field.SetStaticValue(Object::sentinel(), true);
         }
       }
     }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   GrowableArray<const Class*> interfaces(Z, 4);
   CollectInterfaces(cls, &interfaces);
   // Include superclasses in list of interfaces and super interfaces.
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
@@ skipping 997 matching lines @@
 // getter function object for each enumeration value and for the
 // values field. We also don't have to generate the code for these getters
 // from thin air (no source code is available).
 void ClassFinalizer::AllocateEnumValues(const Class &enum_cls) {
   const Field& index_field =
       Field::Handle(enum_cls.LookupInstanceField(Symbols::Index()));
   ASSERT(!index_field.IsNull());
   const Field& values_field =
       Field::Handle(enum_cls.LookupStaticField(Symbols::Values()));
   ASSERT(!values_field.IsNull());
-  ASSERT(Instance::Handle(values_field.value()).IsArray());
-  Array& values_list = Array::Handle(Array::RawCast(values_field.value()));
+  ASSERT(Instance::Handle(values_field.StaticValue()).IsArray());
+  Array& values_list = Array::Handle(
+      Array::RawCast(values_field.StaticValue()));
 
   const Array& fields = Array::Handle(enum_cls.fields());
   Field& field = Field::Handle();
   Instance& ordinal_value = Instance::Handle();
   Instance& enum_value = Instance::Handle();
 
   for (intptr_t i = 0; i < fields.Length(); i++) {
     field = Field::RawCast(fields.At(i));
     if (!field.is_static()) continue;
-    ordinal_value = field.value();
+    ordinal_value = field.StaticValue();
     // The static fields that need to be initialized with enum instances
     // contain the smi value of the ordinal number, which was stored in
     // the field by the parser. Other fields contain non-smi values.
     if (!ordinal_value.IsSmi()) continue;
     enum_value = Instance::New(enum_cls, Heap::kOld);
     enum_value.SetField(index_field, ordinal_value);
     const char* error_msg = "";
     enum_value = enum_value.CheckAndCanonicalize(&error_msg);
     if (enum_value.IsNull()) {
       ReportError(enum_cls, enum_cls.token_pos(), "Failed finalizing values.");
       UNREACHABLE();
     }
     ASSERT(enum_value.IsCanonical());
-    field.set_value(enum_value);
+    field.SetStaticValue(enum_value, true);
     field.RecordStore(enum_value);
     intptr_t ord = Smi::Cast(ordinal_value).Value();
     ASSERT(ord < values_list.Length());
     values_list.SetAt(ord, enum_value);
   }
   values_list.MakeImmutable();
 }
 
 
 bool ClassFinalizer::IsSuperCycleFree(const Class& cls) {
@@ skipping 745 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart