Hide methods marked as not-visible from reflective member lists and invocation.

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 468 matching lines @@
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= fields.At(i);
     member_mirror = CreateVariableMirror(field, owner_mirror);
     member_mirrors.Add(member_mirror);
   }
 
   Function& func = Function::Handle();
   for (intptr_t i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
+    if (!func.is_visible()) continue;

[srdjan, 2013/08/13 00:41:23]

Instead of 'continue', I would write:
if (func.is_visible()) {
  member_mirror = Create...
  member_mirrors.Add(....
}

     if (func.kind() == RawFunction::kRegularFunction ||
         func.kind() == RawFunction::kGetterFunction ||
         func.kind() == RawFunction::kSetterFunction) {
       member_mirror = CreateMethodMirror(func, owner_mirror);
       member_mirrors.Add(member_mirror);
     }
   }
 
   return member_mirrors.raw();
 }
@@ skipping 129 matching lines @@
 
 // Invoke the function, or noSuchMethod if it is null. Propagate any unhandled
 // exceptions. Wrap and propagate any compilation errors.
 static RawObject* ReflectivelyInvokeDynamicFunction(const Instance& receiver,
                                                     const Function& function,
                                                     const String& target_name,
                                                     const Array& arguments) {
   // Note "arguments" is already the internal arguments with the receiver as
   // the first element.
   Object& result = Object::Handle();
-  if (function.IsNull()) {
+  if (function.IsNull() || !function.is_visible()) {
     const Array& arguments_descriptor =
         Array::Handle(ArgumentsDescriptor::New(arguments.Length()));
     result = DartEntry::InvokeNoSuchMethod(receiver,
                                            target_name,
                                            arguments,
                                            arguments_descriptor);
   } else {
     result = DartEntry::InvokeFunction(function, arguments);
   }
 
@@ skipping 238 matching lines @@
       Array, positional_args, arguments->NativeArgAt(3));
 
   intptr_t number_of_arguments = positional_args.Length();
 
   const Function& function = Function::Handle(
       klass.LookupStaticFunctionAllowPrivate(function_name));
 
   if (function.IsNull() ||
       !function.AreValidArgumentCounts(number_of_arguments,
                                        /* named_args */ 0,
-                                       NULL)) {
+                                       NULL) ||
+      !function.is_visible()) {
     ThrowNoSuchMethod(klass,
                       function_name,
                       function,
                       InvocationMirror::kStatic,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   Object& result = Object::Handle(DartEntry::InvokeFunction(function,
                                                             positional_args));
@@ skipping 14 matching lines @@
   GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2));
 
   // Note static fields do not have implicit getters.
   const Field& field = Field::Handle(klass.LookupStaticField(getter_name));
   if (field.IsNull() || FieldIsUninitialized(field)) {
     const String& internal_getter_name = String::Handle(
         Field::GetterName(getter_name));
     const Function& getter = Function::Handle(
         klass.LookupStaticFunctionAllowPrivate(internal_getter_name));
 
-    if (getter.IsNull()) {
+    if (getter.IsNull() || !getter.is_visible()) {
       ThrowNoSuchMethod(klass,
                         getter_name,
                         getter,
                         InvocationMirror::kStatic,
                         InvocationMirror::kGetter);
       UNREACHABLE();
     }
 
     // Invoke the getter and return the result.
     Object& result = Object::Handle(
@@ skipping 18 matching lines @@
   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));
 
-    if (setter.IsNull()) {
+    if (setter.IsNull() || !setter.is_visible()) {
       ThrowNoSuchMethod(klass,
                         setter_name,
                         setter,
                         InvocationMirror::kStatic,
                         InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
     const int kNumArgs = 1;
@@ skipping 46 matching lines @@
   }
 
   Function& constructor = Function::Handle(
       klass.LookupFunctionAllowPrivate(internal_constructor_name));
 
   if (constructor.IsNull() ||
      (!constructor.IsConstructor() && !constructor.IsFactory()) ||
      !constructor.AreValidArgumentCounts(number_of_arguments +
                                          constructor.NumImplicitParameters(),
                                          /* named args */ 0,
-                                         NULL)) {
+                                         NULL) ||
+     !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.
     constructor = Function::null();
     ThrowNoSuchMethod(klass,
                       internal_constructor_name,
                       constructor,
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
@@ skipping 30 matching lines @@
       library.LookupFunctionAllowPrivate(function_name, &ambiguity_error_msg));
 
   if (function.IsNull() && !ambiguity_error_msg.IsNull()) {
     ThrowMirroredCompilationError(ambiguity_error_msg);
     UNREACHABLE();
   }
 
   if (function.IsNull() ||
      !function.AreValidArgumentCounts(number_of_arguments,
                                       0,
-                                      NULL) ) {
+                                      NULL) ||
+     !function.is_visible()) {
     ThrowNoSuchMethod(library,
                       function_name,
                       function,
                       InvocationMirror::kTopLevel,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   const Object& result = Object::Handle(
       DartEntry::InvokeFunction(function, positional_args));
@@ skipping 27 matching lines @@
     getter = library.LookupFunctionAllowPrivate(internal_getter_name,
                                                 &ambiguity_error_msg);
   } else if (!field.IsNull() && FieldIsUninitialized(field)) {
     // A 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);
   }
 
-  if (!getter.IsNull()) {
+  if (!getter.IsNull() && getter.is_visible()) {
     // Invoke the getter and return the result.
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(getter, Object::empty_array()));
     if (result.IsError()) {
       ThrowInvokeError(Error::Cast(result));
       UNREACHABLE();
     }
     return result.raw();
   }
   if (!field.IsNull()) {
@@ skipping 28 matching lines @@
   String& ambiguity_error_msg = String::Handle(isolate);
   const Field& field = Field::Handle(
       library.LookupFieldAllowPrivate(setter_name, &ambiguity_error_msg));
 
   if (field.IsNull() && ambiguity_error_msg.IsNull()) {
     const String& internal_setter_name =
         String::Handle(Field::SetterName(setter_name));
     const Function& setter = Function::Handle(
         library.LookupFunctionAllowPrivate(internal_setter_name,
                                            &ambiguity_error_msg));
-    if (setter.IsNull()) {
+    if (setter.IsNull() || !setter.is_visible()) {
       if (ambiguity_error_msg.IsNull()) {
         ThrowNoSuchMethod(library,
                           setter_name,
                           setter,
                           InvocationMirror::kTopLevel,
                           InvocationMirror::kSetter);
       } else {
         ThrowMirroredCompilationError(ambiguity_error_msg);
       }
       UNREACHABLE();
@@ skipping 76 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