Pass type argument to Field construction, thus freezing that field, denoting it cannot be changed l…

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 1548 matching lines @@
   Field& field = Field::Handle(zone);
   Smi& value = Smi::Handle(zone);
   String& field_name = String::Handle(zone);
 
 #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);            \
+  field = Field::New(field_name, true, false, true, false, cls,                \
+      Type::Handle(Type::IntType()), 0);                                       \
   value = Smi::New(k##clazz##Cid);                                             \
   field.SetStaticValue(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).
   // Object::Init version when we are running in a version of dart that has
@@ skipping 5883 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();
 }
 
 
-void Field::set_type(const AbstractType& value) const {
+// Called at finalization time
+void Field::SetFieldType(const AbstractType& value) const {
+  ASSERT(Thread::Current()->IsMutatorThread());
   ASSERT(!value.IsNull());
-  StorePointer(&raw_ptr()->type_, value.raw());
+  if (value.raw() != type()) {
+    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,
+                     const AbstractType& type,
                      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.SetOffset(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.SetFieldType(type);
   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);
   result.set_is_nullable(FLAG_use_field_guards ? false : true);
   result.set_guarded_list_length_in_object_offset(Field::kUnknownLengthOffset);
   // Presently, we only attempt to remember the list length for final fields.
   if (is_final && FLAG_use_field_guards) {
     result.set_guarded_list_length(Field::kUnknownFixedLength);
   } else {
@@ skipping 11 matching lines @@
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, owner));
   clone.set_owner(clone_owner);
   if (!clone.is_static()) {
     clone.SetOffset(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);
+    clone.SetFieldType(type);
   }
   return clone.raw();
 }
 
 
 RawString* Field::PrettyName() const {
   const String& str = String::Handle(name());
   return String::IdentifierPrettyName(str);
 }
 
 
 RawString* Field::UserVisibleName() const {
   return PrettyName();
 }
 
 
 intptr_t Field::guarded_list_length() const {
   return Smi::Value(raw_ptr()->guarded_list_length_);
 }
 
 
 void Field::set_guarded_list_length(intptr_t list_length) const {
+  ASSERT(Thread::Current()->IsMutatorThread());
   StoreSmi(&raw_ptr()->guarded_list_length_, Smi::New(list_length));
 }
 
 
 intptr_t Field::guarded_list_length_in_object_offset() const {
   return raw_ptr()->guarded_list_length_in_object_offset_ + kHeapObjectTag;
 }
 
 
 void Field::set_guarded_list_length_in_object_offset(
     intptr_t list_length_offset) const {
+  ASSERT(Thread::Current()->IsMutatorThread());
   StoreNonPointer(&raw_ptr()->guarded_list_length_in_object_offset_,
                   static_cast<int8_t>(list_length_offset - kHeapObjectTag));
   ASSERT(guarded_list_length_in_object_offset() == list_length_offset);
 }
 
 
 const char* Field::ToCString() const {
   if (IsNull()) {
     return "Field::null";
   }
@@ skipping 107 matching lines @@
   // The caller may expect the closure to be allocated in old space. Copy
   // 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,
+                             Object::dynamic_type(),
                              this->token_pos());
   closure_field.SetStaticValue(Instance::Cast(result), true);
-  closure_field.set_type(Object::dynamic_type());
   field_owner.AddField(closure_field);
 
   return Instance::RawCast(result.raw());
 }
 
 
 RawInstance* Field::GetterClosure() const {
   return AccessorClosure(false);
 }
 
@@ skipping 1660 matching lines @@
 void Library::AddMetadata(const Class& cls,
                           const String& name,
                           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,
+                                          Object::dynamic_type(),
                                           token_pos));
-  field.set_type(Object::dynamic_type());
   field.SetStaticValue(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,
@@ skipping 1500 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,
+                                          Object::dynamic_type(),
                                           token_pos));
-  field.set_type(Object::dynamic_type());
   field.SetStaticValue(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.
@@ skipping 11006 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart