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

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 1086 matching lines @@
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetReceivePort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Library& isolate_lib = Library::Handle(isolate, Library::IsolateLibrary());
   ASSERT(!isolate_lib.IsNull());
   const String& class_name = String::Handle(
       isolate, isolate_lib.PrivateName(Symbols::_ReceivePortImpl()));
+  // TODO(asiva): Symbols should contain private keys.
+  const String& function_name =
+      String::Handle(isolate_lib.PrivateName(Symbols::_get_or_create()));
   const int kNumArguments = 1;
   const Function& function = Function::Handle(
       isolate,
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
-                              Symbols::_get_or_create(),
+                              function_name,
                               kNumArguments,
                               Object::empty_array(),
                               Resolver::kIsQualified));
+  ASSERT(!function.IsNull());
   const Array& args = Array::Handle(isolate, Array::New(kNumArguments));
   args.SetAt(0, Integer::Handle(isolate, Integer::New(port_id)));
   return Api::NewHandle(isolate, DartEntry::InvokeStatic(function, args));
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return isolate->main_port();
@@ skipping 1650 matching lines @@
   if (func_name.IsNull()) {
     RETURN_TYPE_ERROR(isolate, function_name, String);
   }
 
   Function& func = Function::Handle(isolate);
   String& tmp_name = String::Handle(isolate);
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
 
     // Case 1.  Lookup the unmodified function name.
-    func = cls.LookupFunction(func_name);
+    func = cls.LookupFunctionAllowPrivate(func_name);
 
     // Case 2.  Lookup the function without the external setter suffix
     // '='.  Make sure to do this check after the regular lookup, so
     // that we don't interfere with operator lookups (like ==).
     if (func.IsNull() && HasExternalSetterSuffix(func_name)) {
       tmp_name = RemoveExternalSetterSuffix(func_name);
       tmp_name = Field::SetterName(tmp_name);
-      func = cls.LookupFunction(tmp_name);
+      func = cls.LookupFunctionAllowPrivate(tmp_name);
     }
 
     // Case 3.  Lookup the funciton with the getter prefix prepended.
     if (func.IsNull()) {
       tmp_name = Field::GetterName(func_name);
-      func = cls.LookupFunction(tmp_name);
+      func = cls.LookupFunctionAllowPrivate(tmp_name);
     }
 
     // Case 4.  Lookup the function with a . appended to find the
     // unnamed constructor.
     if (func.IsNull()) {
       tmp_name = String::Concat(func_name, Symbols::Dot());
-      func = cls.LookupFunction(tmp_name);
+      func = cls.LookupFunctionAllowPrivate(tmp_name);
     }
   } else if (obj.IsLibrary()) {
     const Library& lib = Library::Cast(obj);
 
     // Case 1.  Lookup the unmodified function name.
     func = lib.LookupFunctionAllowPrivate(func_name);
 
     // Case 2.  Lookup the function without the external setter suffix
     // '='.  Make sure to do this check after the regular lookup, so
     // that we don't interfere with operator lookups (like ==).
@@ skipping 474 matching lines @@
 
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
                                      const String& dotted_name,
                                      int num_args) {
   // The constructor must be present in the interface.
   String& constr_name = String::Handle(String::Concat(class_name, dotted_name));
   const Function& constructor =
-      Function::Handle(cls.LookupFunction(constr_name));
+      Function::Handle(cls.LookupFunctionAllowPrivate(constr_name));
   if (constructor.IsNull() ||
       (!constructor.IsConstructor() && !constructor.IsFactory())) {
     const String& lookup_class_name = String::Handle(cls.Name());
     if (!class_name.Equals(lookup_class_name)) {
       // When the class name used to build the constructor name is
       // different than the name of the class in which we are doing
       // the lookup, it can be confusing to the user to figure out
       // what's going on.  Be a little more explicit for these error
       // messages.
       const String& message = String::Handle(
@@ skipping 291 matching lines @@
                          CURRENT_FUNC);
   } else if (obj.IsInstance()) {
     // Every instance field has a getter Function.  Try to find the
     // getter in any superclass and use that function to access the
     // field.
     const Instance& instance = Instance::Cast(obj);
     Class& cls = Class::Handle(isolate, instance.clazz());
     while (!cls.IsNull()) {
       String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
-      getter = cls.LookupDynamicFunction(getter_name);
+      getter = cls.LookupDynamicFunctionAllowPrivate(getter_name);
       if (!getter.IsNull()) {
         break;
       }
       cls = cls.SuperClass();
     }
 
     if (getter.IsNull()) {
       return Api::NewError("%s: did not find instance field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
@@ skipping 10 matching lines @@
     if (msg != NULL) {
       return Api::NewError("%s", msg);
     }
     // To access a static field we may need to use the Field or the
     // getter Function.
     const Class& cls = Class::Cast(obj);
     field = cls.LookupStaticField(field_name);
     if (field.IsNull() || FieldIsUninitialized(isolate, field)) {
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
-      getter = cls.LookupStaticFunction(getter_name);
+      getter = cls.LookupStaticFunctionAllowPrivate(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
       return Api::NewHandle(
           isolate, DartEntry::InvokeStatic(getter, Object::empty_array()));
     } else if (!field.IsNull()) {
       return Api::NewHandle(isolate, field.value());
     } else {
       return Api::NewError("%s: did not find static field '%s'.",
@@ skipping 11 matching lines @@
     if (field.IsNull()) {
       // No field found.  Check for a getter in the lib.
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = lib.LookupFunctionAllowPrivate(getter_name);
     } else if (FieldIsUninitialized(isolate, field)) {
       // A field was found.  Check for a getter in the field's owner classs.
       const Class& cls = Class::Handle(isolate, field.owner());
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
-      getter = cls.LookupStaticFunction(getter_name);
+      getter = cls.LookupStaticFunctionAllowPrivate(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
       return Api::NewHandle(
           isolate, DartEntry::InvokeStatic(getter, Object::empty_array()));
     } else if (!field.IsNull()) {
       return Api::NewHandle(isolate, field.value());
     } else {
       return Api::NewError("%s: did not find top-level variable '%s'.",
@@ skipping 42 matching lines @@
     const Instance& instance = Instance::Cast(obj);
     Class& cls = Class::Handle(isolate, instance.clazz());
     while (!cls.IsNull()) {
       field = cls.LookupInstanceField(field_name);
       if (!field.IsNull() && field.is_final()) {
         return Api::NewError("%s: cannot set final field '%s'.",
                              CURRENT_FUNC, field_name.ToCString());
       }
       String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
-      setter = cls.LookupDynamicFunction(setter_name);
+      setter = cls.LookupDynamicFunctionAllowPrivate(setter_name);
       if (!setter.IsNull()) {
         break;
       }
       cls = cls.SuperClass();
     }
 
     if (setter.IsNull()) {
       return Api::NewError("%s: did not find instance field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
     // Invoke the setter and return the result.
     const int kNumArgs = 2;
     const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
     args.SetAt(0, instance);
     args.SetAt(1, value_instance);
     return Api::NewHandle(isolate, DartEntry::InvokeDynamic(setter, args));
 
   } else if (obj.IsClass()) {
     // To access a static field we may need to use the Field or the
     // setter Function.
     const Class& cls = Class::Cast(obj);
     field = cls.LookupStaticField(field_name);
     if (field.IsNull()) {
       String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
-      setter = cls.LookupStaticFunction(setter_name);
+      setter = cls.LookupStaticFunctionAllowPrivate(setter_name);
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
       const int kNumArgs = 1;
       const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
       args.SetAt(0, value_instance);
       const Object& result =
           Object::Handle(isolate, DartEntry::InvokeStatic(setter, args));
       if (result.IsError()) {
@@ skipping 741 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart