Rename is_visible to is_reflectable; use is_debuggable instead of is_reflectable

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/mirrors.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 572 matching lines @@
     const Instance& receiver,
     const Function& function,
     const String& target_name,
     const Array& args,
     const Array& args_descriptor_array) {
   // Note "args" is already the internal arguments with the receiver as the
   // first element.
   Object& result = Object::Handle();
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
   if (function.IsNull() ||
-      !function.is_visible() ||
+      !function.is_reflectable() ||
       !function.AreValidArguments(args_descriptor, NULL)) {
     result = DartEntry::InvokeNoSuchMethod(receiver,
                                            target_name,
                                            args,
                                            args_descriptor_array);
   } else {
     result = DartEntry::InvokeFunction(function,
                                        args,
                                        args_descriptor_array);
   }
@@ skipping 30 matching lines @@
       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()) {
+  if (!getter.IsNull() && getter.is_reflectable()) {
     // 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,
@@ skipping 14 matching lines @@
                                       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.LookupStaticFunction(internal_getter_name));
 
-    if (getter.IsNull() || !getter.is_visible()) {
+    if (getter.IsNull() || !getter.is_reflectable()) {
       if (getter.IsNull()) {
         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) {
@@ skipping 345 matching lines @@
     field ^= fields.At(i);
     if (!field.is_synthetic()) {
       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() &&
+    if (func.is_reflectable() &&
         (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 14 matching lines @@
   const Array& functions = Array::Handle(klass.functions());
   const intptr_t num_functions = functions.Length();
 
   Instance& constructor_mirror = Instance::Handle();
   const GrowableObjectArray& constructor_mirrors = GrowableObjectArray::Handle(
       GrowableObjectArray::New(num_functions));
 
   Function& func = Function::Handle();
   for (intptr_t i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
-    if (func.is_visible() && func.kind() == RawFunction::kConstructor) {
+    if (func.is_reflectable() && func.kind() == RawFunction::kConstructor) {
       constructor_mirror = CreateMethodMirror(func, owner_mirror);
       constructor_mirrors.Add(constructor_mirror);
     }
   }
 
   return constructor_mirrors.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(LibraryMirror_members, 2) {
@@ skipping 31 matching lines @@
         member_mirrors.Add(member_mirror);
       }
     } else if (entry.IsField()) {
       const Field& field = Field::Cast(entry);
       if (!field.is_synthetic()) {
         member_mirror = CreateVariableMirror(field, owner_mirror);
         member_mirrors.Add(member_mirror);
       }
     } else if (entry.IsFunction()) {
       const Function& func = Function::Cast(entry);
-      if (func.is_visible() &&
+      if (func.is_reflectable() &&
           (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 277 matching lines @@
     }
   }
 
   const Array& args_descriptor_array =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
 
   if (function.IsNull() ||
       !function.AreValidArguments(args_descriptor, NULL) ||
-      !function.is_visible()) {
+      !function.is_reflectable()) {
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       function_name,
                       function,
                       Object::null_array(),
                       InvocationMirror::kStatic,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   Object& result = Object::Handle(
@@ skipping 32 matching lines @@
   const String& internal_setter_name = String::Handle(
       Field::SetterName(setter_name));
 
   if (field.IsNull()) {
     setter = klass.LookupStaticFunction(internal_setter_name);
 
     const int kNumArgs = 1;
     const Array& args = Array::Handle(Array::New(kNumArgs));
     args.SetAt(0, value);
 
-    if (setter.IsNull() || !setter.is_visible()) {
+    if (setter.IsNull() || !setter.is_reflectable()) {
       ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                         internal_setter_name,
                         setter,
                         args,
                         InvocationMirror::kStatic,
                         InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
@@ skipping 40 matching lines @@
   if (!constructor_name.IsNull()) {
     internal_constructor_name =
         String::Concat(internal_constructor_name, constructor_name);
   }
 
   Function& lookup_constructor = Function::Handle(
       klass.LookupFunction(internal_constructor_name));
 
   if (lookup_constructor.IsNull() ||
       !(lookup_constructor.IsConstructor() || lookup_constructor.IsFactory()) ||
-      !lookup_constructor.is_visible()) {
+      !lookup_constructor.is_reflectable()) {
     // 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,
                       Object::null_array(),
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
@@ skipping 57 matching lines @@
     explicit_argument = explicit_args.At(i);
     args.SetAt(i + num_implicit_args, explicit_argument);
   }
 
   const Array& args_descriptor_array =
       Array::Handle(ArgumentsDescriptor::New(args.Length(),
                                              arg_names));
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
   if (!redirected_constructor.AreValidArguments(args_descriptor, NULL) ||
-      !redirected_constructor.is_visible()) {
+      !redirected_constructor.is_reflectable()) {
     // 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.
     redirected_constructor = Function::null();
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_constructor_name,
                       redirected_constructor,
                       Object::null_array(),
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
@@ skipping 79 matching lines @@
       return call_result.raw();
     }
   }
 
   const Array& args_descriptor_array =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
 
   if (function.IsNull() ||
       !function.AreValidArguments(args_descriptor, NULL) ||
-      !function.is_visible()) {
+      !function.is_reflectable()) {
     ThrowNoSuchMethod(Instance::null_instance(),
                       function_name,
                       function,
                       Object::null_array(),
                       InvocationMirror::kTopLevel,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   const Object& result = Object::Handle(
@@ skipping 35 matching lines @@
   const String& internal_setter_name =
       String::Handle(Field::SetterName(setter_name));
 
   if (field.IsNull()) {
     setter = library.LookupLocalFunction(internal_setter_name);
 
     const int kNumArgs = 1;
     const Array& args = Array::Handle(Array::New(kNumArgs));
     args.SetAt(0, value);
 
-    if (setter.IsNull() || !setter.is_visible()) {
+    if (setter.IsNull() || !setter.is_reflectable()) {
       ThrowNoSuchMethod(Instance::null_instance(),
                         internal_setter_name,
                         setter,
                         args,
                         InvocationMirror::kTopLevel,
                         InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
@@ skipping 176 matching lines @@
 }
 
 DEFINE_NATIVE_ENTRY(TypeMirror_moreSpecificTest, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1));
   return Bool::Get(a.IsMoreSpecificThan(b, NULL)).raw();
 }
 
 
 }  // namespace dart