Add proper API for creating private symbols wrt a library.

runtime/lib/mirrors.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 "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
@@ skipping 215 matching lines @@
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
   return CreateMirror(Symbols::_LocalFunctionTypeMirrorImpl(), args);
 }
 
 
 static RawInstance* CreateMethodMirror(const Function& func,
                                        const Instance& owner_mirror) {
   const Array& args = Array::Handle(Array::New(12));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
-  args.SetAt(1, String::Handle(func.UserVisibleName()));
+
+  String& name = String::Handle(func.name());
+  name = String::IdentifierPrettyNameRetainPrivate(name);
+  args.SetAt(1, name);
+
   args.SetAt(2, owner_mirror);
   args.SetAt(3, Bool::Get(func.is_static()));
   args.SetAt(4, Bool::Get(func.is_abstract()));
   args.SetAt(5, Bool::Get(func.IsGetterFunction()));
   args.SetAt(6, Bool::Get(func.IsSetterFunction()));
   args.SetAt(7, Bool::Get(func.kind() == RawFunction::kConstructor));
   // TODO(mlippautz): Implement different constructor kinds.
   args.SetAt(8, Bool::False());
   args.SetAt(9, Bool::False());
   args.SetAt(10, Bool::False());
   args.SetAt(11, Bool::False());
   return CreateMirror(Symbols::_LocalMethodMirrorImpl(), args);
 }
 
 
 static RawInstance* CreateVariableMirror(const Field& field,
                                          const Instance& owner_mirror) {
   const MirrorReference& field_ref =
       MirrorReference::Handle(MirrorReference::New(field));
 
-  const String& name = String::Handle(field.UserVisibleName());
+  const String& name = String::Handle(field.name());
 
   const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, field_ref);
   args.SetAt(1, name);
   args.SetAt(2, owner_mirror);
   args.SetAt(3, Object::null_instance());  // Null for type.
   args.SetAt(4, Bool::Get(field.is_static()));
   args.SetAt(5, Bool::Get(field.is_final()));
 
   return CreateMirror(Symbols::_LocalVariableMirrorImpl(), args);
@@ skipping 37 matching lines @@
   const Bool& is_generic = Bool::Get(cls.NumTypeParameters() != 0);
   const Bool& is_mixin_typedef = Bool::Get(cls.is_mixin_typedef());
 
   const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
   // We do not set the names of anonymous mixin applications because the mirrors
   // use a different naming convention than the VM (lib.S with lib.M and S&M
   // respectively).
   if (!cls.IsMixinApplication() || cls.is_mixin_typedef()) {
-    args.SetAt(2, String::Handle(cls.UserVisibleName()));
+    args.SetAt(2, String::Handle(cls.Name()));
   }
   args.SetAt(3, is_generic);
   args.SetAt(4, is_mixin_typedef);
   args.SetAt(5, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
   return CreateMirror(Symbols::_LocalClassMirrorImpl(), args);
 }
 
 
 static RawInstance* CreateLibraryMirror(const Library& lib) {
   const Array& args = Array::Handle(Array::New(3));
@@ skipping 115 matching lines @@
 
 
 static RawInstance* InvokeLibraryGetter(const Library& library,
                                         const String& getter_name,
                                         const bool throw_nsm_if_absent) {
   // To access a top-level we may need to use the Field or the getter Function.
   // The getter function may either be in the library or in the field's owner
   // class, depending on whether it was an actual getter, or an uninitialized
   // field.
   const Field& field = Field::Handle(
+      library.LookupLocalField(getter_name));
+  Function& getter = Function::Handle();
+  if (field.IsNull()) {
+    // No field found. Check for a getter in the lib.
+    const String& internal_getter_name =
+        String::Handle(Field::GetterName(getter_name));
+    getter = library.LookupLocalFunction(internal_getter_name);
+    if (getter.IsNull()) {
+      getter = library.LookupLocalFunction(getter_name);
+      if (!getter.IsNull()) {
+        // Looking for a getter but found a regular method: closurize it.
+        const Function& closure_function =
+            Function::Handle(getter.ImplicitClosureFunction());
+        return closure_function.ImplicitStaticClosure();
+      }
+    }
+  } else {
+    if (!field.IsUninitialized()) {
+      return field.value();
+    }
+    // An uninitialized field was found.  Check for a getter in the field's
+    // owner classs.
+    const Class& klass = Class::Handle(field.owner());
+    const String& internal_getter_name =
+        String::Handle(Field::GetterName(getter_name));
+    getter = klass.LookupStaticFunction(internal_getter_name);
+  }
+
+  if (!getter.IsNull() && getter.is_visible()) {
+    // Invoke the getter and return the result.
+    const Object& result = Object::Handle(
+        DartEntry::InvokeFunction(getter, Object::empty_array()));
+    return ReturnResult(result);
+  }
+
+  if (throw_nsm_if_absent) {
+    ThrowNoSuchMethod(Instance::null_instance(),
+                      getter_name,
+                      getter,
+                      InvocationMirror::kTopLevel,
+                      InvocationMirror::kGetter);
+    UNREACHABLE();
+  }
+
+  // Fall through case: Indicate that we didn't find any function or field using
+  // a special null instance. This is different from a field being null. Callers
+  // make sure that this null does not leak into Dartland.
+  return Object::sentinel().raw();
+}
+
+
+// TODO(13656): Remove AllowPrivate.
+static RawInstance* InvokeLibraryGetterAllowImports(
+    const Library& library,
+    const String& getter_name,
+    const bool throw_nsm_if_absent) {
+  // To access a top-level we may need to use the Field or the getter Function.
+  // The getter function may either be in the library or in the field's owner
+  // class, depending on whether it was an actual getter, or an uninitialized
+  // field.
+  const Field& field = Field::Handle(
       library.LookupFieldAllowPrivate(getter_name));
   Function& getter = Function::Handle();
   if (field.IsNull()) {
     // No field found. Check for a getter in the lib.
     const String& internal_getter_name =
         String::Handle(Field::GetterName(getter_name));
     getter = library.LookupFunctionAllowPrivate(internal_getter_name);
     if (getter.IsNull()) {
       getter = library.LookupFunctionAllowPrivate(getter_name);
       if (!getter.IsNull()) {
         // Looking for a getter but found a regular method: closurize it.
         const Function& closure_function =
             Function::Handle(getter.ImplicitClosureFunction());
         return closure_function.ImplicitStaticClosure();
       }
     }
   } else {
     if (!field.IsUninitialized()) {
       return field.value();
     }
     // An uninitialized field was found.  Check for a getter in the field's
     // owner classs.
     const Class& klass = Class::Handle(field.owner());
     const String& internal_getter_name =
         String::Handle(Field::GetterName(getter_name));
-    getter = klass.LookupStaticFunctionAllowPrivate(internal_getter_name);
+    getter = klass.LookupStaticFunction(internal_getter_name);
   }
 
   if (!getter.IsNull() && getter.is_visible()) {
     // Invoke the getter and return the result.
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(getter, Object::empty_array()));
     return ReturnResult(result);
   }
 
   if (throw_nsm_if_absent) {
@@ skipping 14 matching lines @@
 
 static RawInstance* InvokeClassGetter(const Class& klass,
                                       const String& getter_name,
                                       const bool throw_nsm_if_absent) {
   // Note static fields do not have implicit getters.
   const Field& field = Field::Handle(klass.LookupStaticField(getter_name));
   if (field.IsNull() || field.IsUninitialized()) {
     const String& internal_getter_name = String::Handle(
         Field::GetterName(getter_name));
     Function& getter = Function::Handle(
-        klass.LookupStaticFunctionAllowPrivate(internal_getter_name));
+        klass.LookupStaticFunction(internal_getter_name));
 
     if (getter.IsNull() || !getter.is_visible()) {
       if (getter.IsNull()) {
-        getter = klass.LookupStaticFunctionAllowPrivate(getter_name);
+        getter = klass.LookupStaticFunction(getter_name);
         if (!getter.IsNull()) {
           // Looking for a getter but found a regular method: closurize it.
           const Function& closure_function =
               Function::Handle(getter.ImplicitClosureFunction());
           return closure_function.ImplicitStaticClosure();
         }
       }
       if (throw_nsm_if_absent) {
         ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                           getter_name,
@@ skipping 19 matching lines @@
 
 
 
 static RawInstance* InvokeInstanceGetter(const Class& klass,
                                          const Instance& reflectee,
                                          const String& getter_name,
                                          const bool throw_nsm_if_absent) {
   const String& internal_getter_name = String::Handle(
       Field::GetterName(getter_name));
   Function& function = Function::Handle(
-      Resolver::ResolveDynamicAnyArgsAllowPrivate(klass, internal_getter_name));
+      Resolver::ResolveDynamicAnyArgs(klass, internal_getter_name));
 
   if (!function.IsNull() || throw_nsm_if_absent) {
     const int kNumArgs = 1;
     const Array& args = Array::Handle(Array::New(kNumArgs));
     args.SetAt(0, reflectee);
     const Array& args_descriptor =
         Array::Handle(ArgumentsDescriptor::New(args.Length()));
 
     // InvokeDynamic invokes NoSuchMethod if the provided function is null.
     return InvokeDynamicFunction(reflectee,
@@ skipping 13 matching lines @@
 static RawInstance* LookupFunctionOrFieldInLibraryPrefix(
     const LibraryPrefix& prefix,
     const String& lookup_name) {
   const Object& entry = Object::Handle(prefix.LookupObject(lookup_name));
   if (!entry.IsNull()) {
     if (entry.IsField()) {
       const Field& field = Field::Cast(entry);
       const Class& field_owner = Class::Handle(field.owner());
       const Library& field_library = Library::Handle(field_owner.library());
       const Instance& result = Instance::Handle(
-          InvokeLibraryGetter(field_library, lookup_name, false));
+          InvokeLibraryGetterAllowImports(field_library, lookup_name, false));
       if (result.raw() != Object::sentinel().raw()) {
         return result.raw();
       }
     } else if (entry.IsFunction()) {
       const Function& func = Function::Cast(entry);
       const Function& closure_function = Function::Handle(
           func.ImplicitClosureFunction());
       return closure_function.ImplicitStaticClosure();
     }
   }
@@ skipping 10 matching lines @@
     const String& lookup_name) {
   Instance& result = Instance::Handle(
       InvokeClassGetter(klass, lookup_name, false));
   if (result.raw() != Object::sentinel().raw()) {
     return result.raw();
   }
 
   Function& func = Function::Handle();
   Class& lookup_class = Class::Handle(klass.raw());
   while (func.IsNull() && !lookup_class.IsNull()) {
-    func ^= lookup_class.LookupStaticFunctionAllowPrivate(lookup_name);
+    func ^= lookup_class.LookupStaticFunction(lookup_name);
     lookup_class = lookup_class.SuperClass();
   }
   if (!func.IsNull()) {
     const Function& closure_function = Function::Handle(
         func.ImplicitClosureFunction());
     ASSERT(!closure_function.IsNull());
     return closure_function.ImplicitStaticClosure();
   }
 
   // Fall through case: Indicate that we didn't find any function or field using
@@ skipping 40 matching lines @@
   return Object::sentinel().raw();
 }
 
 
 static RawInstance* LookupFunctionOrFieldInLibraryHelper(
     const Library& library,
     const String& class_name,
     const String& lookup_name) {
   if (class_name.IsNull()) {
     const Instance& result = Instance::Handle(
-        InvokeLibraryGetter(library, lookup_name, false));
+        InvokeLibraryGetterAllowImports(library, lookup_name, false));
     if (result.raw() != Object::sentinel().raw()) {
       return result.raw();
     }
     const Function& func = Function::Handle(
-        library.LookupFunctionAllowPrivate(lookup_name));
+        library.LookupLocalFunction(lookup_name));
     if (!func.IsNull()) {
       const Function& closure_function = Function::Handle(
           func.ImplicitClosureFunction());
       return closure_function.ImplicitStaticClosure();
     }
   } else {
     const Class& cls = Class::Handle(
-        library.LookupClassAllowPrivate(class_name));
+        library.LookupClass(class_name));
     if (!cls.IsNull()) {
       return LookupStaticFunctionOrFieldInClass(cls, lookup_name);
     }
   }
 
   // Fall through case: Indicate that we didn't find any function or field using
   // a special null instance. This is different from a field being null. Callers
   // make sure that this null does not leak into Dartland.
   return Object::sentinel().raw();
 }
@@ skipping 46 matching lines @@
                            Bool::True(),  // is_declaration
                            Object::null_instance());
 }
 
 
 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalTypeMirror, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   return CreateTypeMirror(type);
 }
 
+DEFINE_NATIVE_ENTRY(Mirrors_mangleName, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
+  const Library& lib = Library::Handle(ref.GetLibraryReferent());
+  return lib.IsPrivate(name) ? lib.PrivateName(name) : name.raw();
+}
+
+DEFINE_NATIVE_ENTRY(Mirrors_unmangleName, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(String, name, arguments->NativeArgAt(0));
+  // It would be nice to unconditionally use IdentifierPrettyName, alas it
+  // cannot cope with the symbols for the names of anonymous mixin applications.
+  if (Library::IsPrivate(name) ||
+      Field::IsGetterName(name) ||
+      Field::IsSetterName(name)) {
+    return String::IdentifierPrettyName(name);
+  }
+  return name.raw();
+}
+
 
 DEFINE_NATIVE_ENTRY(MirrorReference_equals, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, a, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, b, arguments->NativeArgAt(1));
   return Bool::Get(a.referent() == b.referent()).raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(DeclarationMirror_metadata, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(0));
@@ skipping 298 matching lines @@
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(
       String, function_name, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
   Class& klass = Class::Handle(reflectee.clazz());
   Function& function = Function::Handle(
-      Resolver::ResolveDynamicAnyArgsAllowPrivate(klass, function_name));
+      Resolver::ResolveDynamicAnyArgs(klass, function_name));
 
   const Array& args_descriptor =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
 
   return InvokeDynamicFunction(reflectee,
                                function,
                                function_name,
                                args,
                                args_descriptor);
 }
@@ skipping 28 matching lines @@
   while (!klass.IsNull()) {
     field = klass.LookupInstanceField(setter_name);
     if (!field.IsNull() && field.is_final()) {
       const String& message = String::Handle(
           String::NewFormatted("%s: cannot set final field '%s'.",
                                "InstanceMirror_invokeSetter",
                                setter_name.ToCString()));
       ThrowMirroredCompilationError(message);
       UNREACHABLE();
     }
-    setter = klass.LookupDynamicFunctionAllowPrivate(internal_setter_name);
+    setter = klass.LookupDynamicFunction(internal_setter_name);
     if (!setter.IsNull()) {
       break;
     }
     klass = klass.SuperClass();
   }
 
   // Invoke the setter and return the result.
   const int kNumArgs = 2;
   const Array& args = Array::Handle(Array::New(kNumArgs));
   args.SetAt(0, reflectee);
@@ skipping 122 matching lines @@
   const Class& klass = Class::Handle(ref.GetClassReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(
       String, function_name, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
   const Array& args_descriptor_array =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
 
   const Function& function = Function::Handle(
-      klass.LookupStaticFunctionAllowPrivate(function_name));
-
+      klass.LookupStaticFunction(function_name));
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
   if (function.IsNull() ||
       !function.AreValidArguments(args_descriptor, NULL) ||
       !function.is_visible()) {
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       function_name,
                       function,
                       InvocationMirror::kStatic,
                       InvocationMirror::kMethod);
@@ skipping 29 matching lines @@
   const Class& klass = Class::Handle(ref.GetClassReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
   GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
 
   // Check for real fields and user-defined setters.
   const Field& field = Field::Handle(klass.LookupStaticField(setter_name));
   if (field.IsNull()) {
     const String& internal_setter_name = String::Handle(
       Field::SetterName(setter_name));
     const Function& setter = Function::Handle(
-      klass.LookupStaticFunctionAllowPrivate(internal_setter_name));
+      klass.LookupStaticFunction(internal_setter_name));
 
     if (setter.IsNull() || !setter.is_visible()) {
       ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                         setter_name,
                         setter,
                         InvocationMirror::kStatic,
                         InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
@@ skipping 40 matching lines @@
   // This convention prevents users from explicitly calling constructors.
   const String& klass_name = String::Handle(klass.Name());
   String& internal_constructor_name =
       String::Handle(String::Concat(klass_name, Symbols::Dot()));
   if (!constructor_name.IsNull()) {
     internal_constructor_name =
         String::Concat(internal_constructor_name, constructor_name);
   }
 
   Function& lookup_constructor = Function::Handle(
-      klass.LookupFunctionAllowPrivate(internal_constructor_name));
+      klass.LookupFunction(internal_constructor_name));
 
   if (lookup_constructor.IsNull() ||
       !(lookup_constructor.IsConstructor() || lookup_constructor.IsFactory()) ||
       !lookup_constructor.is_visible()) {
     // Pretend we didn't find the constructor at all when the arity is wrong
     // so as to produce the same NoSuchMethodError as the non-reflective case.
     lookup_constructor = Function::null();
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_constructor_name,
                       lookup_constructor,
@@ skipping 111 matching lines @@
   const Library& library = Library::Handle(ref.GetLibraryReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(
       String, function_name, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
   const Array& args_descriptor_array =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
 
   const Function& function = Function::Handle(
-      library.LookupFunctionAllowPrivate(function_name));
+      library.LookupLocalFunction(function_name));
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
   if (function.IsNull() ||
       !function.AreValidArguments(args_descriptor, NULL) ||
       !function.is_visible()) {
     ThrowNoSuchMethod(Instance::null_instance(),
                       function_name,
                       function,
                       InvocationMirror::kTopLevel,
                       InvocationMirror::kMethod);
@@ skipping 27 matching lines @@
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Library& library = Library::Handle(ref.GetLibraryReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
   GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
 
   // To access a top-level we may need to use the Field or the
   // setter Function.  The setter function may either be in the
   // library or in the field's owner class, depending.
   const Field& field = Field::Handle(
-      library.LookupFieldAllowPrivate(setter_name));
+      library.LookupLocalField(setter_name));
 
   if (field.IsNull()) {
     const String& internal_setter_name =
         String::Handle(Field::SetterName(setter_name));
     const Function& setter = Function::Handle(
-        library.LookupFunctionAllowPrivate(internal_setter_name));
+        library.LookupLocalFunction(internal_setter_name));
     if (setter.IsNull() || !setter.is_visible()) {
       ThrowNoSuchMethod(Instance::null_instance(),
                         setter_name,
                         setter,
                         InvocationMirror::kTopLevel,
                         InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
@@ skipping 103 matching lines @@
 }
 
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
   return field.type();
 }
 
 }  // namespace dart