- Allow patching of top-level methods and accessors.

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/bigint_operations.h"
@@ skipping 4127 matching lines @@
                            intptr_t token_pos) {
   ASSERT(name.IsOneByteString());
   ASSERT(!owner.IsNull());
   const Function& result = Function::Handle(Function::New());
   result.set_parameter_types(Array::Handle(Array::Empty()));
   result.set_parameter_names(Array::Handle(Array::Empty()));
   result.set_name(name);
   result.set_kind(kind);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
+  result.set_is_abstract(is_abstract);
   result.set_is_external(is_external);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_end_token_pos(token_pos);
   result.set_num_fixed_parameters(0);
   result.set_num_optional_parameters(0);
   result.set_usage_counter(0);
   result.set_deoptimization_counter(0);
   result.set_is_optimizable(true);
   result.set_has_finally(false);
   result.set_is_native(false);
-  result.set_is_abstract(is_abstract);
   return result.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
   ASSERT(name.IsOneByteString());
   ASSERT(!parent.IsNull());
   const Class& parent_class = Class::Handle(parent.owner());
@@ skipping 1278 matching lines @@
     GrowDictionary(dict, dict_size);
   }
 
   // Invalidate the cache of loaded scripts.
   if (loaded_scripts() != Array::null()) {
     StorePointer(&raw_ptr()->loaded_scripts_, Array::null());
   }
 }
 
 
+RawObject* Library::LookupEntry(const String& name, intptr_t *index) const {
+  Isolate* isolate = Isolate::Current();
+  const Array& dict = Array::Handle(isolate, dictionary());
+  intptr_t dict_size = dict.Length() - 1;
+  *index = name.Hash() % dict_size;
+
+  Object& entry = Object::Handle(isolate);
+  Class& cls = Class::Handle(isolate);
+  Function& func = Function::Handle(isolate);
+  Field& field = Field::Handle(isolate);
+  LibraryPrefix& library_prefix = LibraryPrefix::Handle(isolate);
+  String& entry_name = String::Handle(isolate);
+  entry = dict.At(*index);
+  // Search the entry in the hash set.
+  while (!entry.IsNull()) {
+    // TODO(hausner): find a better way to handle this polymorphism.
+    // Either introduce a common base class for Class, Function, Field
+    // and LibraryPrefix or make the name() function virtual in Object.
+    if (entry.IsClass()) {
+      cls ^= entry.raw();
+      entry_name = cls.Name();
+    } else if (entry.IsFunction()) {
+      func ^= entry.raw();
+      entry_name = func.name();
+    } else if (entry.IsField()) {
+      field ^= entry.raw();
+      entry_name = field.name();
+    } else if (entry.IsLibraryPrefix()) {
+      library_prefix ^= entry.raw();
+      entry_name = library_prefix.name();
+    } else {
+      UNREACHABLE();
+    }
+    if (entry_name.Equals(name)) {
+      return entry.raw();
+    }
+    *index = (*index + 1) % dict_size;
+    entry = dict.At(*index);
+  }
+  return Object::null();
+}
+
+
+void Library::ReplaceObject(const Object& obj, const String& name) const {
+  ASSERT(obj.IsClass() || obj.IsFunction() || obj.IsField());
+  ASSERT(LookupLocalObject(name) != Object::null());
+
+  intptr_t index;
+  LookupEntry(name, &index);
+  // The value is guaranteed to be found.
+  const Array& dict = Array::Handle(dictionary());
+  dict.SetAt(index, obj);
+}
+
+
 void Library::AddClass(const Class& cls) const {
   AddObject(cls, String::Handle(cls.Name()));
   // Link class to this library.
   cls.set_library(*this);
 }
 
 
 RawArray* Library::LoadedScripts() const {
   // We compute the list of loaded scripts lazily. The result is
   // cached in loaded_scripts_.
@@ skipping 109 matching lines @@
       if (!func.IsNull()) {
         return func.raw();
       }
     }
   }
   return Function::null();
 }
 
 
 RawObject* Library::LookupLocalObject(const String& name) const {
-  Isolate* isolate = Isolate::Current();
-  const Array& dict = Array::Handle(isolate, dictionary());
-  intptr_t dict_size = dict.Length() - 1;
-  intptr_t index = name.Hash() % dict_size;
-
-  Object& entry = Object::Handle(isolate, Object::null());
-  Class& cls = Class::Handle(isolate, Class::null());
-  Function& func = Function::Handle(isolate, Function::null());
-  Field& field = Field::Handle(isolate, Field::null());
-  LibraryPrefix& library_prefix = LibraryPrefix::Handle(isolate,
-                                                        LibraryPrefix::null());
-  String& entry_name = String::Handle(isolate, String::null());
-  entry = dict.At(index);
-  // Search the entry in the hash set.
-  while (!entry.IsNull()) {
-    // TODO(hausner): find a better way to handle this polymorphism.
-    // Either introduce a common base class for Class, Function, Field
-    // and LibraryPrefix or make the name() function virtual in Object.
-    if (entry.IsClass()) {
-      cls ^= entry.raw();
-      entry_name = cls.Name();
-    } else if (entry.IsFunction()) {
-      func ^= entry.raw();
-      entry_name = func.name();
-    } else if (entry.IsField()) {
-      field ^= entry.raw();
-      entry_name = field.name();
-    } else if (entry.IsLibraryPrefix()) {
-      library_prefix ^= entry.raw();
-      entry_name = library_prefix.name();
-    } else {
-      UNREACHABLE();
-    }
-    if (entry_name.Equals(name)) {
-      return entry.raw();
-    }
-    index = (index + 1) % dict_size;
-    entry = dict.At(index);
-  }
-  return Class::null();
+  intptr_t index;
+  return LookupEntry(name, &index);
 }
 
 
 static bool ShouldBePrivate(const String& name) {
   return
       (name.Length() >= 1 &&
        name.CharAt(0) == '_') ||
       (name.Length() >= 5 &&
        (name.CharAt(4) == '_' &&
         (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
@@ skipping 558 matching lines @@
     lib ^= libs.At(i);
     error_message = lib.FindDuplicateDefinition();
     if (!error_message.IsNull()) {
       return error_message.raw();
     }
   }
   return String::null();
 }
 
 
+RawError* Library::Patch(const String& url, const String& source) const {
+  const Script& script = Script::Handle(
+      Script::New(url, source, RawScript::kPatchTag));
+  return Compiler::Compile(*this, script);
+}
+
+
 bool Library::IsKeyUsed(intptr_t key) {
   intptr_t lib_key;
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   String& lib_url = String::Handle();
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     lib_url ^= lib.url();
     lib_key = lib_url.Hash();
@@ skipping 4840 matching lines @@
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart