Lookup functions by name that contains the private key, except for dart_api which allows ignoring t…

runtime/vm/dart_entry.cc

 // Copyright (c) 2011, 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/dart_entry.h"
 
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
@@ skipping 133 matching lines @@
 RawObject* DartEntry::InvokeNoSuchMethod(const Instance& receiver,
                                          const String& target_name,
                                          const Array& arguments,
                                          const Array& arguments_descriptor) {
   ASSERT(receiver.raw() == arguments.At(0));
   // Allocate an InvocationMirror object.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   Class& invocation_mirror_class = Class::Handle(
       core_lib.LookupClassAllowPrivate(Symbols::InvocationMirror()));
   ASSERT(!invocation_mirror_class.IsNull());
+  const String& function_name =
+      String::Handle(core_lib.PrivateName(Symbols::AllocateInvocationMirror()));
   const Function& allocation_function = Function::Handle(
       Resolver::ResolveStaticByName(invocation_mirror_class,
-                                    Symbols::AllocateInvocationMirror(),
+                                    function_name,
                                     Resolver::kIsQualified));
   ASSERT(!allocation_function.IsNull());
   const int kNumAllocationArgs = 3;
   const Array& allocation_args = Array::Handle(Array::New(kNumAllocationArgs));
   allocation_args.SetAt(0, target_name);
   allocation_args.SetAt(1, arguments_descriptor);
   allocation_args.SetAt(2, arguments);
   const Object& invocation_mirror = Object::Handle(
       InvokeStatic(allocation_function, allocation_args));
 
@@ skipping 227 matching lines @@
   Isolate* isolate = Isolate::Current();
   Function& function =
       Function::Handle(isolate,
                        isolate->object_store()->lookup_receive_port_function());
   const int kNumArguments = 1;
   if (function.IsNull()) {
     Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
     ASSERT(!isolate_lib.IsNull());
     const String& class_name =
         String::Handle(isolate_lib.PrivateName(Symbols::_ReceivePortImpl()));
+    const String& function_name =
+        String::Handle(isolate_lib.PrivateName(Symbols::_lookupReceivePort()));
     function = Resolver::ResolveStatic(isolate_lib,
                                        class_name,
-                                       Symbols::_lookupReceivePort(),
+                                       function_name,
                                        kNumArguments,
                                        Object::empty_array(),
                                        Resolver::kIsQualified);
     isolate->object_store()->set_lookup_receive_port_function(function);
   }
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, Integer::Handle(Integer::New(port_id)));
   const Object& result =
       Object::Handle(DartEntry::InvokeStatic(function, args));
   return result.raw();
 }
 
 
 RawObject* DartLibraryCalls::HandleMessage(const Object& receive_port,
                                            Dart_Port reply_port_id,
                                            const Instance& message) {
   Isolate* isolate = Isolate::Current();
   Function& function =
       Function::Handle(isolate,
                        isolate->object_store()->handle_message_function());
   const int kNumArguments = 3;
   if (function.IsNull()) {
     Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
     ASSERT(!isolate_lib.IsNull());
     const String& class_name =
         String::Handle(isolate_lib.PrivateName(Symbols::_ReceivePortImpl()));
+    const String& function_name =
+        String::Handle(isolate_lib.PrivateName(Symbols::_handleMessage()));
     function = Resolver::ResolveStatic(isolate_lib,
                                        class_name,
-                                       Symbols::_handleMessage(),
+                                       function_name,
                                        kNumArguments,
                                        Object::empty_array(),
                                        Resolver::kIsQualified);
     isolate->object_store()->set_handle_message_function(function);
   }
   const Array& args = Array::Handle(isolate, Array::New(kNumArguments));
   args.SetAt(0, receive_port);
   args.SetAt(1, Integer::Handle(isolate, Integer::New(reply_port_id)));
   args.SetAt(2, message);
   const Object& result =
       Object::Handle(isolate, DartEntry::InvokeStatic(function, args));
   ASSERT(result.IsNull() || result.IsError());
   return result.raw();
 }
 
 
 RawObject* DartLibraryCalls::NewSendPort(intptr_t port_id) {
   Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
   ASSERT(!isolate_lib.IsNull());
   const String& class_name =
       String::Handle(isolate_lib.PrivateName(Symbols::_SendPortImpl()));
   const int kNumArguments = 1;
+  const String& function_name =
+      String::Handle(isolate_lib.PrivateName(Symbols::_create()));
   const Function& function = Function::Handle(
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
-                              Symbols::_create(),
+                              function_name,
                               kNumArguments,
                               Object::empty_array(),
                               Resolver::kIsQualified));
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, Integer::Handle(Integer::New(port_id)));
   return DartEntry::InvokeStatic(function, args);
 }
 
 
 RawObject* DartLibraryCalls::MapSetAt(const Instance& map,
@@ skipping 11 matching lines @@
   args.SetAt(1, key);
   args.SetAt(2, value);
   const Object& result = Object::Handle(DartEntry::InvokeDynamic(function,
                                                                  args));
   return result.raw();
 }
 
 
 RawObject* DartLibraryCalls::PortGetId(const Instance& port) {
   const Class& cls = Class::Handle(port.clazz());
-  const String& func_name = String::Handle(Field::GetterName(Symbols::_id()));
+  const Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
+  const String& func_name =
+      String::Handle(isolate_lib.PrivateName(
+          String::Handle(Field::GetterName(Symbols::_id()))));
   const Function& func = Function::Handle(cls.LookupDynamicFunction(func_name));
   ASSERT(!func.IsNull());
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, port);
   return DartEntry::InvokeDynamic(func, args);
 }
 
 
 }  // namespace dart