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

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 1492 matching lines @@
   String& field_name = String::Handle(isolate);
 
 #define CLASS_LIST_WITH_NULL(V)                                                \
   V(Null)                                                                      \
   CLASS_LIST_NO_OBJECT(V)
 
 #define ADD_SET_FIELD(clazz)                                                   \
   field_name = Symbols::New("cid"#clazz);                                      \
   field = Field::New(field_name, true, false, true, false, cls, 0);            \
   value = Smi::New(k##clazz##Cid);                                             \
-  field.set_value(value);                                                      \
+  field.SetStaticFieldValue(value, true);                                      \
   field.set_type(Type::Handle(Type::IntType()));                               \
   cls.AddField(field);                                                         \
 
   CLASS_LIST_WITH_NULL(ADD_SET_FIELD)
 #undef ADD_SET_FIELD
 
   isolate->object_store()->InitKnownObjects();
 
   return Error::null();
 #else  // defined(DART_NO_SNAPSHOT).
@@ skipping 503 matching lines @@
     const intptr_t length = raw_ptr()->instance_size_in_words_;
     array = Array::New(length, Heap::kOld);
     Class& cls = Class::Handle(this->raw());
     Array& fields = Array::Handle();
     Field& f = Field::Handle();
     while (!cls.IsNull()) {
       fields = cls.fields();
       for (intptr_t i = 0; i < fields.Length(); ++i) {
         f ^= fields.At(i);
         if (!f.is_static()) {
-          array.SetAt(f.Offset() >> kWordSizeLog2, f);
+          array.SetAt(f.InstanceFieldOffset() >> kWordSizeLog2, f);
         }
       }
       cls = cls.SuperClass();
     }
     StorePointer(&raw_ptr()->offset_in_words_to_field_, array.raw());
   }
   return array.raw();
 }
 
 
@@ skipping 529 matching lines @@
     }
   }
   set_type_arguments_field_offset(type_args_field_offset);
   ASSERT(offset > 0);
   Field& field = Field::Handle();
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     // Offset is computed only for instance fields.
     if (!field.is_static()) {
-      ASSERT(field.Offset() == 0);
-      field.SetOffset(offset);
+      ASSERT(field.InstanceFieldOffset() == 0);
+      field.SetInstanceFieldOffset(offset);
       offset += kWordSize;
     }
   }
   set_instance_size(RoundedAllocationSize(offset));
   set_next_field_offset(offset);
 }
 
 
 RawFunction* Class::GetInvocationDispatcher(const String& target_name,
                                             const Array& args_desc,
@@ skipping 4640 matching lines @@
 RawClass* Field::origin() const {
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).source_class();
 }
 
 
-RawInstance* Field::value() const {
+RawInstance* Field::StaticFieldValue() const {
   ASSERT(is_static());  // Valid only for static dart fields.
-  return raw_ptr()->value_;
+  return raw_ptr()->value_.static_value_;
 }
 
 
-void Field::set_value(const Instance& value) const {
+void Field::SetStaticFieldValue(const Instance& value,
+                                bool save_initial_value) const {
   ASSERT(is_static());  // Valid only for static dart fields.
-  StorePointer(&raw_ptr()->value_, value.raw());
+  StorePointer(&raw_ptr()->value_.static_value_, value.raw());
+  if (save_initial_value) {
+    StorePointer(&raw_ptr()->initializer_.saved_initial_value_, value.raw());
+  }
 }
 
 
 void Field::set_type(const AbstractType& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->type_, value.raw());
 }
 
 
 RawField* Field::New() {
   ASSERT(Object::field_class() != Class::null());
   RawObject* raw = Object::Allocate(Field::kClassId,
                                     Field::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawField*>(raw);
 }
 
 
 RawField* Field::New(const String& name,
                      bool is_static,
                      bool is_final,
                      bool is_const,
                      bool is_reflectable,
                      const Class& owner,
                      intptr_t token_pos) {
   ASSERT(!owner.IsNull());
   const Field& result = Field::Handle(Field::New());
   result.set_name(name);
   result.set_is_static(is_static);
-  if (is_static) {
-    result.set_value(Object::null_instance());
-  } else {
-    result.SetOffset(0);
+  if (!is_static) {
+    result.SetInstanceFieldOffset(0);
   }
   result.set_is_final(is_final);
   result.set_is_const(is_const);
   result.set_is_reflectable(is_reflectable);
   result.set_is_double_initialized(false);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_has_initializer(false);
   result.set_is_unboxing_candidate(true);
   result.set_guarded_cid(FLAG_use_field_guards ? kIllegalCid : kDynamicCid);
@@ skipping 11 matching lines @@
 
 
 RawField* Field::Clone(const Class& new_owner) const {
   Field& clone = Field::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   const Class& owner = Class::Handle(this->owner());
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, owner));
   clone.set_owner(clone_owner);
   if (!clone.is_static()) {
-    clone.SetOffset(0);
+    clone.SetInstanceFieldOffset(0);
   }
   if (new_owner.NumTypeParameters() > 0) {
     // Adjust the field type to refer to type parameters of the new owner.
     AbstractType& type = AbstractType::Handle(clone.type());
     type ^= type.CloneUninstantiated(new_owner);
     clone.set_type(type);
   }
   return clone.raw();
 }
 
@@ skipping 88 matching lines @@
 
   AbstractType& declared_type = AbstractType::Handle(type());
   jsobj.AddProperty("declaredType", declared_type);
   jsobj.AddProperty("static", is_static());
   jsobj.AddProperty("final", is_final());
   jsobj.AddProperty("const", is_const());
   if (ref) {
     return;
   }
   if (is_static()) {
-    const Instance& valueObj = Instance::Handle(value());
+    const Instance& valueObj = Instance::Handle(StaticFieldValue());
     jsobj.AddProperty("staticValue", valueObj);
   }
 
   jsobj.AddProperty("_guardNullable", is_nullable());
   if (guarded_cid() == kIllegalCid) {
     jsobj.AddProperty("_guardClass", "unknown");
   } else if (guarded_cid() == kDynamicCid) {
     jsobj.AddProperty("_guardClass", "dynamic");
   } else {
     ClassTable* table = Isolate::Current()->class_table();
@@ skipping 25 matching lines @@
   String& closure_name = String::Handle(this->name());
   closure_name = Symbols::FromConcat(Symbols::HashMark(), closure_name);
   if (make_setter) {
     closure_name = Symbols::FromConcat(Symbols::HashMark(), closure_name);
   }
 
   Field& closure_field = Field::Handle();
   closure_field = field_owner.LookupStaticField(closure_name);
   if (!closure_field.IsNull()) {
     ASSERT(closure_field.is_static());
-    const Instance& closure = Instance::Handle(closure_field.value());
+    const Instance& closure =
+        Instance::Handle(closure_field.StaticFieldValue());
     ASSERT(!closure.IsNull());
     ASSERT(closure.IsClosure());
     return closure.raw();
   }
 
   // This is the first time a closure for this field is requested.
   // Create the closure and a new static field in which it is stored.
   const char* field_name = String::Handle(name()).ToCString();
   String& expr_src = String::Handle();
   if (make_setter) {
@@ skipping 12 matching lines @@
   // the result here, since Object::Clone() is a private method.
   result = Object::Clone(result, Heap::kOld);
 
   closure_field = Field::New(closure_name,
                              true,  // is_static
                              true,  // is_final
                              true,  // is_const
                              false,  // is_reflectable
                              field_owner,
                              this->token_pos());
-  closure_field.set_value(Instance::Cast(result));
+  closure_field.SetStaticFieldValue(Instance::Cast(result), true);
   closure_field.set_type(Type::Handle(Type::DynamicType()));
   field_owner.AddField(closure_field);
 
   return Instance::RawCast(result.raw());
 }
 
 
 RawInstance* Field::GetterClosure() const {
   return AccessorClosure(false);
 }
@@ skipping 55 matching lines @@
 }
 
 
 void Field::DeoptimizeDependentCode() const {
   FieldDependentArray a(*this);
   a.DisableCode();
 }
 
 
 bool Field::IsUninitialized() const {
-  const Instance& value = Instance::Handle(raw_ptr()->value_);
+  const Instance& value = Instance::Handle(raw_ptr()->value_.static_value_);
   ASSERT(value.raw() != Object::transition_sentinel().raw());
   return value.raw() == Object::sentinel().raw();
 }
 
 
-void Field::set_initializer(const Function& initializer) const {
-  StorePointer(&raw_ptr()->initializer_, initializer.raw());
+void Field::SetPrecompiledInitializer(const Function& initializer) const {
+  StorePointer(&raw_ptr()->initializer_.precompiled_initializer_,
+               initializer.raw());
+}
+
+
+bool Field::HasPrecompiledInitializer() const {
+  return raw_ptr()->initializer_.value_->IsFunction();
+}
+
+
+void Field::SetSavedInitialStaticValue(const Instance& value) const {
+  StorePointer(&raw_ptr()->initializer_.saved_initial_value_, value.raw());
 }
 
 
 void Field::EvaluateInitializer() const {
   ASSERT(is_static());
-  if (value() == Object::sentinel().raw()) {
-    set_value(Object::transition_sentinel());
+  if (StaticFieldValue() == Object::sentinel().raw()) {
+    SetStaticFieldValue(Object::transition_sentinel());
     Object& value = Object::Handle(Compiler::EvaluateStaticInitializer(*this));
     if (value.IsError()) {
-      set_value(Object::null_instance());
+      SetStaticFieldValue(Object::null_instance());
       Exceptions::PropagateError(Error::Cast(value));
       UNREACHABLE();
     }
     ASSERT(value.IsNull() || value.IsInstance());
-    set_value(value.IsNull() ? Instance::null_instance()
+    SetStaticFieldValue(value.IsNull() ? Instance::null_instance()
                              : Instance::Cast(value));
     return;
-  } else if (value() == Object::transition_sentinel().raw()) {
-    set_value(Object::null_instance());
+  } else if (StaticFieldValue() == Object::transition_sentinel().raw()) {
+    SetStaticFieldValue(Object::null_instance());
     const Array& ctor_args = Array::Handle(Array::New(1));
     const String& field_name = String::Handle(name());
     ctor_args.SetAt(0, field_name);
     Exceptions::ThrowByType(Exceptions::kCyclicInitializationError, ctor_args);
     UNREACHABLE();
     return;
   }
   UNREACHABLE();
 }
 
@@ skipping 1468 matching lines @@
                           intptr_t token_pos) const {
   const String& metaname = String::Handle(Symbols::New(name));
   Field& field = Field::Handle(Field::New(metaname,
                                           true,   // is_static
                                           false,  // is_final
                                           false,  // is_const
                                           false,  // is_reflectable
                                           cls,
                                           token_pos));
   field.set_type(Type::Handle(Type::DynamicType()));
-  field.set_value(Array::empty_array());
+  field.SetStaticFieldValue(Array::empty_array(), true);
   GrowableObjectArray& metadata =
       GrowableObjectArray::Handle(this->metadata());
   metadata.Add(field, Heap::kOld);
   cls.AddField(field);
 }
 
 
 void Library::AddClassMetadata(const Class& cls,
                                const Class& toplevel_class,
                                intptr_t token_pos) const {
@@ skipping 73 matching lines @@
       !obj.IsLibrary() && !obj.IsTypeParameter()) {
     return Object::null();
   }
   const String& metaname = String::Handle(MakeMetadataName(obj));
   Field& field = Field::Handle(GetMetadataField(metaname));
   if (field.IsNull()) {
     // There is no metadata for this object.
     return Object::empty_array().raw();
   }
   Object& metadata = Object::Handle();
-  metadata = field.value();
-  if (field.value() == Object::empty_array().raw()) {
+  metadata = field.StaticFieldValue();
+  if (field.StaticFieldValue() == Object::empty_array().raw()) {
     metadata = Parser::ParseMetadata(Class::Handle(field.owner()),
                                      field.token_pos());
     if (metadata.IsArray()) {
       ASSERT(Array::Cast(metadata).raw() != Object::empty_array().raw());
-      field.set_value(Array::Cast(metadata));
+      field.SetStaticFieldValue(Array::Cast(metadata), true);
     }
   }
   return metadata.raw();
 }
 
 
 static bool ShouldBePrivate(const String& name) {
   return
       (name.Length() >= 1 &&
        name.CharAt(0) == '_') ||
@@ skipping 1387 matching lines @@
 void Namespace::AddMetadata(intptr_t token_pos, const Class& owner_class) {
   ASSERT(Field::Handle(metadata_field()).IsNull());
   Field& field = Field::Handle(Field::New(Symbols::TopLevel(),
                                           true,   // is_static
                                           false,  // is_final
                                           false,  // is_const
                                           false,  // is_reflectable
                                           owner_class,
                                           token_pos));
   field.set_type(Type::Handle(Type::DynamicType()));
-  field.set_value(Array::empty_array());
+  field.SetStaticFieldValue(Array::empty_array(), true);
   set_metadata_field(field);
   owner_class.AddField(field);
 }
 
 
 RawObject* Namespace::GetMetadata() const {
   Field& field = Field::Handle(metadata_field());
   if (field.IsNull()) {
     // There is no metadata for this object.
     return Object::empty_array().raw();
   }
   Object& metadata = Object::Handle();
-  metadata = field.value();
-  if (field.value() == Object::empty_array().raw()) {
+  metadata = field.StaticFieldValue();
+  if (field.StaticFieldValue() == Object::empty_array().raw()) {
     metadata = Parser::ParseMetadata(Class::Handle(field.owner()),
                                      field.token_pos());
     if (metadata.IsArray()) {
       ASSERT(Array::Cast(metadata).raw() != Object::empty_array().raw());
-      field.set_value(Array::Cast(metadata));
+      field.SetStaticFieldValue(Array::Cast(metadata), true);
     }
   }
   return metadata.raw();
 }
 
 
 const char* Namespace::ToCString() const {
   const char* kFormat = "Namespace for library '%s'";
   const Library& lib = Library::Handle(library());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, lib.ToCString()) + 1;
@@ skipping 10851 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart