Reified metadata in the VM

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 5973 matching lines @@
 }
 
 
 void Library::SetLoadError() const {
   // Should not be already loaded or just allocated.
   ASSERT(LoadInProgress());
   raw_ptr()->load_state_ = RawLibrary::kLoadError;
 }
 
 
+static RawString* MakeClassMetaName(const Class& cls) {
+  String& cname = String::Handle(cls.Name());
+  return String::Concat(Symbols::At(), cname);
+}
+
+
+static RawString* MakeFieldMetaName(const Field& field) {
+  const String& cname =
+      String::Handle(MakeClassMetaName(Class::Handle(field.origin())));
+  String& fname = String::Handle(field.name());
+  fname = String::Concat(Symbols::At(), fname);
+  return String::Concat(cname, fname);

[siva, 2013/06/12 00:16:52]

Maybe more efficient to use ConcatAll
String name = String::Handle();
const Array& names = Array::Handle(Array::New(4));

names.SetAt(0, Symbols::At());
name = cls.Name();
names.SetAt(1, name);
names.SetAt(2, Symbols::At());
name = field.Name();
names.SetAt(3, name);
return String::ConcatAll(names);

[hausner, 2013/06/12 01:10:05]

I am not terribly concerned about speed here. ConcatAll seems less readable to
me.

+}
+
+
+static RawString* MakeFunctionMetaName(const Function& func) {
+  const String& cname =
+      String::Handle(MakeClassMetaName(Class::Handle(func.origin())));
+  String& fname = String::Handle(func.name());
+  fname = String::Concat(Symbols::At(), fname);
+  return String::Concat(cname, fname);

[siva, 2013/06/12 00:16:52]

Ditto here.

+}
+
+
+void Library::AddClassMetadata(const Class& cls, intptr_t token_pos) const {
+  String& metaname = String::Handle(MakeClassMetaName(cls));
+  metaname = Symbols::New(metaname);
+  Field& meta_field =
+      Field::Handle(Field::New(metaname,
+                               true,   // is_static
+                               false,  // is_final
+                               false,  // is_const
+                               cls,
+                               token_pos));
+  meta_field.set_type(Type::Handle(Type::DynamicType()));
+  meta_field.set_value(Array::empty_array());
+  GrowableObjectArray& metadata =
+      GrowableObjectArray::Handle(this->metadata());
+  metadata.Add(meta_field, Heap::kOld);

[siva, 2013/06/12 00:16:52]

Seems like the above code could be abstracted into a static helper method and
reused in AddFieldMetadata and AddFunctionMetadata

static void AddMetaData(const String& metaname,
                        const Class& cls,
                        intptr_t token_pos) {
  .... (code starting at line 6020).
}

[hausner, 2013/06/12 01:10:05]

Done.

+}
+
+
+void Library::AddFieldMetadata(const Field& field,
+                               intptr_t token_pos) const {
+  String& metaname = String::Handle(MakeFieldMetaName(field));
+  metaname = Symbols::New(metaname);
+  Field& meta_field =
+      Field::Handle(Field::New(metaname,
+                               true,   // is_static
+                               false,  // is_final
+                               false,  // is_const
+                               Class::Handle(field.origin()),
+                               token_pos));
+  meta_field.set_type(Type::Handle(Type::DynamicType()));
+  meta_field.set_value(Array::empty_array());
+  GrowableObjectArray& metadata = GrowableObjectArray::Handle(this->metadata());
+  metadata.Add(meta_field, Heap::kOld);
+}
+
+
+void Library::AddFunctionMetadata(const Function& func,
+                                  intptr_t token_pos) const {
+  String& metaname = String::Handle(MakeFunctionMetaName(func));
+  metaname = Symbols::New(metaname);
+  Field& meta_field =
+      Field::Handle(Field::New(metaname,
+                               true,   // is_static
+                               false,  // is_final
+                               false,  // is_const
+                               Class::Handle(func.origin()),
+                               token_pos));
+  meta_field.set_type(Type::Handle(Type::DynamicType()));
+  meta_field.set_value(Object::empty_array());
+  GrowableObjectArray& metadata = GrowableObjectArray::Handle(this->metadata());
+  metadata.Add(meta_field, Heap::kOld);
+}
+
+
+RawString* Library::MakeMetadataName(const Object& obj) const {
+  if (obj.IsClass()) {
+    return MakeClassMetaName(Class::Cast(obj));
+  } else if (obj.IsField()) {
+    return MakeFieldMetaName(Field::Cast(obj));
+  } else if (obj.IsFunction()) {
+    return MakeFunctionMetaName(Function::Cast(obj));
+  }
+  UNIMPLEMENTED();
+  return String::null();
+}
+
+
+RawField* Library::GetMetadataField(const String& metaname) const {
+  const GrowableObjectArray& metadata =
+      GrowableObjectArray::Handle(this->metadata());
+  Field& entry = Field::Handle();
+  String& entryname = String::Handle();
+  intptr_t num_entries = metadata.Length();
+  for (intptr_t i = 0; i < num_entries; i++) {
+    entry ^= metadata.At(i);
+    entryname = entry.name();
+    if (entryname.Equals(metaname)) {
+      return entry.raw();
+    }
+  }
+  return Field::null();
+}
+
+
+RawObject* Library::GetMetadata(const Object& obj) const {
+  if (!obj.IsClass() && !obj.IsField() && !obj.IsFunction()) {
+    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 = Parser::ParseMetadata(Class::Handle(field.owner()),
+                                     field.token_pos());
+    if (metadata.IsArray()) {

[siva, 2013/06/12 00:16:52]

ASSERT(Array::Cast(metadata).raw() != Object::empty_array().raw());

[hausner, 2013/06/12 01:10:05]

Done.

+      field.set_value(Array::Cast(metadata));
+    }
+  }
+  return metadata.raw();
+}
+
+
 void Library::GrowDictionary(const Array& dict, intptr_t dict_size) const {
   // TODO(iposva): Avoid exponential growth.
   intptr_t new_dict_size = dict_size * 2;
   const Array& new_dict =
       Array::Handle(Array::New(new_dict_size + 1, Heap::kOld));
   // Rehash all elements from the original dictionary
   // to the newly allocated array.
   Object& entry = Class::Handle();
   String& entry_name = String::Handle();
   Object& new_entry = Object::Handle();
@@ skipping 518 matching lines @@
 }
 
 
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.StorePointer(&result.raw_ptr()->name_, url.raw());
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
   result.raw_ptr()->private_key_ = Scanner::AllocatePrivateKey(result);
   result.raw_ptr()->dictionary_ = Object::empty_array().raw();
+  result.raw_ptr()->metadata_ = GrowableObjectArray::New(4, Heap::kOld);

[siva, 2013/06/12 00:16:52]

result.StorePointer(&result.raw_ptr()->metadata_, GrowableObjectArray::New(4,
Heap::kOld));

   result.raw_ptr()->anonymous_classes_ = Object::empty_array().raw();
   result.raw_ptr()->num_anonymous_ = 0;
   result.raw_ptr()->imports_ = Object::empty_array().raw();
   result.raw_ptr()->exports_ = Object::empty_array().raw();
   result.raw_ptr()->loaded_scripts_ = Array::null();
   result.set_native_entry_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.set_debuggable(false);
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
   result.raw_ptr()->index_ = -1;
@@ skipping 6855 matching lines @@
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart