Implement Evaluate without creating new classes.

runtime/vm/object.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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 2725 matching lines @@
     piece ^= formal_params.At(i);
     src_pieces.Add(piece);
   }
   src_pieces.Add(Symbols::RParenArrow());
   src_pieces.Add(expr);
   src_pieces.Add(Symbols::Semicolon());
   return String::ConcatAll(Array::Handle(Array::MakeArray(src_pieces)));
 }
 
 
-static RawPatchClass* MakeTempPatchClass(const Class& cls,
-                                         const String& expr,
-                                         const Array& formal_params) {
+static RawFunction* EvaluateHelper(const Class& cls,
+                                   const String& expr,
+                                   const Array& param_names,
+                                   bool is_static) {
   const String& func_src =
-      String::Handle(BuildClosureSource(formal_params, expr));
+      String::Handle(BuildClosureSource(param_names, expr));
   Script& script = Script::Handle();
   script = Script::New(Symbols::Empty(), func_src, RawScript::kSourceTag);
   // In order to tokenize the source, we need to get the key to mangle
-  // private names from the library from which the object's class
-  // originates.
+  // private names from the library from which the class originates.
   const Library& lib = Library::Handle(cls.library());
   ASSERT(!lib.IsNull());
   const String& lib_key = String::Handle(lib.private_key());
   script.Tokenize(lib_key);
 
-  const String& src_class_name = String::Handle(Symbols::New(":internal"));
-  const Class& src_class = Class::Handle(
-      Class::New(src_class_name, script, Scanner::kNoSourcePos));
-  src_class.set_is_finalized();
-  src_class.set_library(lib);
-  return PatchClass::New(cls, src_class);
+  const Function& func = Function::Handle(
+       Function::NewEvalFunction(cls, script, is_static));
+  func.set_result_type(Type::Handle(Type::DynamicType()));
+  const intptr_t num_implicit_params = is_static ? 0 : 1;
+  func.set_num_fixed_parameters(num_implicit_params + param_names.Length());
+  func.SetNumOptionalParameters(0, true);
+  func.SetIsOptimizable(false);
+  return func.raw();
 }
 
 
 RawObject* Class::Evaluate(const String& expr,
                            const Array& param_names,
                            const Array& param_values) const {
-  const PatchClass& temp_class =
-      PatchClass::Handle(MakeTempPatchClass(*this, expr, param_names));
-  const String& eval_func_name = String::Handle(Symbols::New(":eval"));
   const Function& eval_func =
-      Function::Handle(Function::New(eval_func_name,
-                                     RawFunction::kRegularFunction,
-                                     true,   // Static.
-                                     false,  // Not const.
-                                     false,  // Not abstract.
-                                     false,  // Not external.
-                                     false,  // Not native.
-                                     temp_class,
-                                     0));
-  eval_func.set_result_type(Type::Handle(Type::DynamicType()));
-  eval_func.set_num_fixed_parameters(param_names.Length());
-  eval_func.SetNumOptionalParameters(0, true);
-  eval_func.SetIsOptimizable(false);
-
+      Function::Handle(EvaluateHelper(*this, expr, param_names, true));
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(eval_func, param_values));
   return result.raw();
 }
 
 
 // Ensure that top level parsing of the class has been done.
 RawError* Class::EnsureIsFinalized(Isolate* isolate) const {
   // Finalized classes have already been parsed.
   if (is_finalized()) {
@@ skipping 2265 matching lines @@
   if (IsImplicitStaticClosureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(!obj.IsNull());
     ClosureData::Cast(obj).set_implicit_static_closure(closure);
     return;
   }
   UNREACHABLE();
 }
 
 
+RawScript* Function::eval_script() const {
+  if (IsEvalFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    return Script::Cast(obj).raw();
+  }
+  return Script::null();
+}
+
+
+void Function::set_eval_script(const Script& script) const {
+  if (IsEvalFunction()) {
+    ASSERT(!script.IsNull());
+    set_data(script);
+    return;
+  }
+  UNREACHABLE();
+}
+
+
 RawFunction* Function::extracted_method_closure() const {
   ASSERT(kind() == RawFunction::kMethodExtractor);
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(obj.IsFunction());
   return Function::Cast(obj).raw();
 }
 
 
 void Function::set_extracted_method_closure(const Function& value) const {
   ASSERT(kind() == RawFunction::kMethodExtractor);
@@ skipping 52 matching lines @@
     return;
   }
   UNREACHABLE();
 }
 
 
 RawFunction* Function::implicit_closure_function() const {
   if (IsClosureFunction() ||
       IsSignatureFunction() ||
       IsStaticInitializerFunction() ||
-      IsFactory()) {
+      IsFactory() ||
+      IsEvalFunction()) {
     return Function::null();
   }
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(obj.IsNull() || obj.IsFunction());
   return (obj.IsNull()) ? Function::null() : Function::Cast(obj).raw();
 }
 
 
 void Function::set_implicit_closure_function(const Function& value) const {
-  ASSERT(!IsClosureFunction() && !IsSignatureFunction());
+  ASSERT(!IsClosureFunction() && !IsSignatureFunction() && !IsEvalFunction());
   set_data(value);
 }
 
 
 RawClass* Function::signature_class() const {
   if (IsSignatureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(obj.IsNull() || obj.IsClass());
     return (obj.IsNull()) ? Class::null() : Class::Cast(obj).raw();
   }
@@ skipping 72 matching lines @@
       break;
     case RawFunction::kMethodExtractor:
       return "kMethodExtractor";
       break;
     case RawFunction::kNoSuchMethodDispatcher:
       return "kNoSuchMethodDispatcher";
       break;
     case RawFunction::kInvokeFieldDispatcher:
       return "kInvokeFieldDispatcher";
       break;
+    case RawFunction::kEvalFunction:
+      return "kEvalFunction";
+      break;
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 void Function::SetRedirectionType(const Type& type) const {
   ASSERT(IsFactory());
   Object& obj = Object::Handle(raw_ptr()->data_);
@@ skipping 811 matching lines @@
       Function::New(name,
                     RawFunction::kClosureFunction,
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     parent.is_native(),
                     parent_owner,
                     token_pos));
   result.set_parent_function(parent);
-
   return result.raw();
 }
 
 
+RawFunction* Function::NewEvalFunction(const Class& owner,
+                                       const Script& script,
+                                       bool is_static) {
+  ASSERT(!owner.IsNull());
+  ASSERT(!script.IsNull());
+  const Function& result = Function::Handle(
+      Function::New(String::Handle(Symbols::New(":Eval")),
+                    RawFunction::kEvalFunction,
+                    is_static,
+                    /* is_const = */ false,
+                    /* is_abstract = */ false,
+                    /* is_external = */ false,
+                    /* is_native = */ false,
+                    owner,
+                    0));
+  result.set_eval_script(script);
+  return result.raw();
+}
+
 RawFunction* Function::ImplicitClosureFunction() const {
   // Return the existing implicit closure function if any.
   if (implicit_closure_function() != Function::null()) {
     return implicit_closure_function();
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
   // Create closure function.
   const String& closure_name = String::Handle(name());
   const Function& closure_function = Function::Handle(
       NewClosureFunction(closure_name, *this, token_pos()));
@@ skipping 244 matching lines @@
 RawClass* Function::origin() const {
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).source_class();
 }
 
 
 RawScript* Function::script() const {

[hausner, 2014/07/10 20:12:34]

I think it should be possible to do the trick of storing the eval script in
data_ without introducing a new function kind. Instead, eval_script() returns a
script object if that is what's stored in data_. If nothing is stored in data_,
or something that isn't a script, then it returns null.

Here, you write:

if (token_pos() == 0) {
  if (eval_script() != null) return eval_script();
}
if (IsClosureFunction...

The check for token_pos is an optimization and eliminates the eval_script()
lookup in practically all cases.

+  if (IsEvalFunction()) {
+    return eval_script();
+  }
+  if (IsClosureFunction()) {
+    return Function::Handle(parent_function()).script();
+  }
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   if (obj.IsClass()) {
     return Class::Cast(obj).script();
   }
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).Script();
 }
 
 
 bool Function::HasOptimizedCode() const {
@@ skipping 2907 matching lines @@
   // classes are coming from the VM isolate, and are shared between multiple
   // isolates so setting their library pointers would be wrong.
   const Class& cls = Class::Handle(Object::dynamic_class());
   core_lib.AddObject(cls, String::Handle(cls.Name()));
 }
 
 
 RawObject* Library::Evaluate(const String& expr,
                              const Array& param_names,
                              const Array& param_values) const {
-  // Make a fake top-level class and evaluate the expression
+  // Take a fake top-level class and evaluate the expression
   // as a static function of the class.
-  Script& script = Script::Handle();
-  script = Script::New(Symbols::Empty(),
-                       Symbols::Empty(),
-                       RawScript::kSourceTag);
-  Class& temp_class =
-      Class::Handle(Class::New(Symbols::TopLevel(), script, 0));
-  temp_class.set_library(*this);
-  temp_class.set_is_finalized();
-  return temp_class.Evaluate(expr, param_names, param_values);
+  Class& top_level_class = Class::Handle();
+  Array& top_level_classes = Array::Handle(anonymous_classes());
+  top_level_class ^= top_level_classes.At(0);

[hausner, 2014/07/10 20:12:34]

I'm not sure this array is guaranteed to have entries. I think the parser does
not generate an anonymous class if a library has no top-level variables or
fields.

[rmacnak, 2014/07/10 22:26:21]

That can happen. Now creating and remembering a class in this case.

+  return top_level_class.Evaluate(expr, param_names, param_values);
 }
 
 
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
   static const int kNumNativeWrappersClasses = 4;
   ASSERT(kNumNativeWrappersClasses > 0 && kNumNativeWrappersClasses < 10);
   const String& native_flds_lib_url = Symbols::DartNativeWrappers();
   const Library& native_flds_lib = Library::Handle(
       Library::NewLibraryHelper(native_flds_lib_url, false));
   const String& native_flds_lib_name = Symbols::DartNativeWrappersLibName();
@@ skipping 3455 matching lines @@
   jsobj.AddProperty("id", "");
   jsobj.AddProperty("kind", JSONType(false));
   jsobj.AddProperty("message", ToErrorCString());
 }
 
 
 RawObject* Instance::Evaluate(const String& expr,
                               const Array& param_names,
                               const Array& param_values) const {
   const Class& cls = Class::Handle(clazz());
-  const PatchClass& temp_class = PatchClass::Handle(
-      MakeTempPatchClass(cls, expr, param_names));
-  const String& eval_func_name = String::Handle(Symbols::New(":eval"));
   const Function& eval_func =
-      Function::Handle(Function::New(eval_func_name,
-                                     RawFunction::kRegularFunction,
-                                     false,  // Not static.
-                                     false,  // Not const.
-                                     false,  // Not abstract.
-                                     false,  // Not external.
-                                     false,  // Not native.
-                                     temp_class,
-                                     0));
-  eval_func.set_result_type(Type::Handle(Type::DynamicType()));
-  eval_func.set_num_fixed_parameters(1 + param_values.Length());
-  eval_func.SetNumOptionalParameters(0, true);
-  eval_func.SetIsOptimizable(false);
-
+      Function::Handle(EvaluateHelper(cls, expr, param_names, false));
   const Array& args = Array::Handle(Array::New(1 + param_values.Length()));
   Object& param = Object::Handle();
   args.SetAt(0, *this);
   for (intptr_t i = 0; i < param_values.Length(); i++) {
     param = param_values.At(i);
     args.SetAt(i + 1, param);
   }
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(eval_func, args));
   return result.raw();
@@ skipping 6261 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart