Implement closurization of regular methods in ObjectMirror.getField in the VM.

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"
 #include "vm/parser.h"
 #include "vm/port.h"
+#include "vm/resolver.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 static RawInstance* CreateMirror(const String& mirror_class_name,
                                  const Array& constructor_arguments) {
   const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary());
   const String& constructor_name = Symbols::Dot();
 
   const Object& result = Object::Handle(
@@ skipping 759 matching lines @@
                                        args_descriptor_array);
   }
 
   if (result.IsError()) {
     ThrowInvokeError(Error::Cast(result));
     UNREACHABLE();
   }
   return result.raw();
 }
 
+
 DEFINE_NATIVE_ENTRY(InstanceMirror_invoke, 5) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // 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));
+
   const Array& args_descriptor =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
 
-  Class& klass = Class::Handle(reflectee.clazz());
-  Function& function = Function::Handle();
-  while (!klass.IsNull()) {
-    function = klass.LookupDynamicFunctionAllowPrivate(function_name);
-    if (!function.IsNull()) {
-      break;
-    }
-    klass = klass.SuperClass();
-  }
-
   return ReflectivelyInvokeDynamicFunction(reflectee,
                                            function,
                                            function_name,
                                            args,
                                            args_descriptor);
 }
 
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_invokeGetter, 3) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // 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, getter_name, arguments->NativeArgAt(2));
 
-  // Every instance field has a getter Function.  Try to find the
-  // getter in any superclass and use that function to access the
-  // field.
-  // NB: We do not use Resolver::ResolveDynamic because we want to find private
-  // members.
   Class& klass = Class::Handle(reflectee.clazz());
   String& internal_getter_name = String::Handle(Field::GetterName(getter_name));
-  Function& getter = Function::Handle();
-  while (!klass.IsNull()) {
-    getter = klass.LookupDynamicFunctionAllowPrivate(internal_getter_name);
-    if (!getter.IsNull()) {
-      break;
-    }
-    klass = klass.SuperClass();
-  }
+  Function& function = Function::Handle(
+      Resolver::ResolveDynamicAnyArgsAllowPrivate(klass, internal_getter_name));
 
   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()));
 
   return ReflectivelyInvokeDynamicFunction(reflectee,
-                                           getter,
+                                           function,
                                            internal_getter_name,
                                            args,
                                            args_descriptor);
 }
 
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_invokeSetter, 4) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
@@ skipping 118 matching lines @@
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   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(
+    Function& getter = Function::Handle(
         klass.LookupStaticFunctionAllowPrivate(internal_getter_name));
 
     if (getter.IsNull() || !getter.is_visible()) {
+      if (getter.IsNull()) {
+        getter = klass.LookupStaticFunctionAllowPrivate(getter_name);
+        if (!getter.IsNull()) {
+          // Looking for a getter but found a regular method: closurize.
+          const Function& closure_function =
+              Function::Handle(getter.ImplicitClosureFunction());
+          return closure_function.ImplicitStaticClosure();
+        }
+      }
       ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                         getter_name,
                         getter,
                         InvocationMirror::kStatic,
                         InvocationMirror::kGetter);
       UNREACHABLE();
     }
 
     // Invoke the getter and return the result.
     Object& result = Object::Handle(
@@ skipping 236 matching lines @@
   // getter Function.  The getter function may either be in the
   // library or in the field's owner class, depending.
   const Field& field = Field::Handle(
       library.LookupFieldAllowPrivate(getter_name));
   Function& getter = Function::Handle();
   if (field.IsNull()) {
     // No field found and no ambiguity error.  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.
+        const Function& closure_function =
+            Function::Handle(getter.ImplicitClosureFunction());
+        return closure_function.ImplicitStaticClosure();
+      }
+    }
   } 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() && getter.is_visible()) {
     // Invoke the getter and return the result.
@@ skipping 154 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