Hide ClosureMirror.findInContext behind a flag for 1.0.

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/compiler.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 {
 
 DEFINE_FLAG(bool, use_mirrored_compilation_error, false,
     "Wrap compilation errors that occur during reflective access in a "
     "MirroredCompilationError, rather than suspending the isolate.");
 
+DEFINE_FLAG(bool, support_find_in_context, false,
+    "Experimental support for ClosureMirror.findInContext.");
+
 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(
       DartLibraryCalls::InstanceCreate(mirrors_lib,
                                        mirror_class_name,
                                        constructor_name,
                                        constructor_arguments));
@@ skipping 681 matching lines @@
 
 static RawInstance* LookupStaticFunctionOrFieldInClass(
     const Class& klass,
     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.LookupStaticFunction(lookup_name);
-    lookup_class = lookup_class.SuperClass();
-  }
+  const Function& func =
+      Function::Handle(klass.LookupStaticFunction(lookup_name));
   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
   // a special null instance. This is different from a field being null. Callers
   // make sure that this null does not leak into Dartland.
@@ skipping 677 matching lines @@
       Object::Handle(DartEntry::InvokeClosure(args, args_descriptor));
   if (result.IsError()) {
     ThrowInvokeError(Error::Cast(result));
     UNREACHABLE();
   }
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClosureMirror_find_in_context, 2) {
+  if (!FLAG_support_find_in_context) {
+    return Object::empty_array().raw();
+  }
+
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, lookup_parts, arguments->NativeArgAt(1));
   ASSERT(lookup_parts.Length() >= 1 && lookup_parts.Length() <= 3);
 
   if (!closure.IsClosure()) {
     const Array& result_tuple = Array::Handle(Array::New(2));
     result_tuple.SetAt(0, Bool::False());
     return result_tuple.raw();
   }
 
@@ skipping 520 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