Hide synthetic metadata field exposed in r35926.

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 778 matching lines @@
 
   // Set up names for object array and one byte string class which are
   // pre-allocated in the vm isolate also.
   cls = Dart::vm_isolate()->object_store()->array_class();
   cls.set_name(Symbols::_List());
   cls = Dart::vm_isolate()->object_store()->one_byte_string_class();
   cls.set_name(Symbols::OneByteString());
 }
 
 
-void Object::CreateInternalMetaData() {
-  // Initialize meta data for VM internal classes.
-  Class& cls = Class::Handle();
-  Array& fields = Array::Handle();
-  Field& fld = Field::Handle();
-  String& name = String::Handle();
-
-  // TODO(iposva): Add more of the VM classes here.
-  cls = context_class_;
-  fields = Array::New(1, Heap::kOld);
-  name = Symbols::New("@parent_");
-  fld = Field::New(name, false, false, false, cls, 0);
-  fields.SetAt(0, fld);
-  cls.SetFields(fields);
-}
-
-
 // Make unused space in an object whose type has been transformed safe
 // for traversing during GC.
 // The unused part of the transformed object is marked as an TypedDataInt8Array
 // object.
 void Object::MakeUnusedSpaceTraversable(const Object& obj,
                                         intptr_t original_size,
                                         intptr_t used_size) {
   ASSERT(Isolate::Current()->no_gc_scope_depth() > 0);
   ASSERT(!obj.IsNull());
   ASSERT(original_size >= used_size);
@@ skipping 555 matching lines @@
   Field& field = Field::Handle(isolate);
   Smi& value = Smi::Handle(isolate);
   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, cls, 0);                   \
+  field = Field::New(field_name, true, false, true, false, cls, 0);            \
   value = Smi::New(k##clazz##Cid);                                             \
   field.set_value(value);                                                      \
   field.set_type(Type::Handle(Type::IntType()));                               \
   cls.AddField(field);                                                         \
 
   CLASS_LIST_WITH_NULL(ADD_SET_FIELD)
 #undef ADD_SET_FIELD
 
   return Error::null();
 }
@@ skipping 5454 matching lines @@
                                     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_synthetic,
                      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);
   }
   result.set_is_final(is_final);
   result.set_is_const(is_const);
+  result.set_is_synthetic(is_synthetic);
   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);
   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);
@@ skipping 1579 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
+                                          true,   // is_synthetic
                                           cls,
                                           token_pos));
   field.set_type(Type::Handle(Type::DynamicType()));
   field.set_value(Array::empty_array());
   GrowableObjectArray& metadata =
       GrowableObjectArray::Handle(this->metadata());
   metadata.Add(field, Heap::kOld);
   cls.AddField(field);
 }
 
@@ skipping 1343 matching lines @@
   StorePointer(&raw_ptr()->metadata_field_, value.raw());
 }
 
 
 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
+                                          true,   // is_synthetic
                                           owner_class,
                                           token_pos));
   field.set_type(Type::Handle(Type::DynamicType()));
   field.set_value(Array::empty_array());
   set_metadata_field(field);
   owner_class.AddField(field);
 }
 
 
 RawObject* Namespace::GetMetadata() const {
@@ skipping 9170 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart