Implement tear-off closure operator #

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 7369 matching lines @@
     jsobj.AddProperty("_guardLength", guarded_list_length());
   }
   const Class& origin_cls = Class::Handle(origin());
   const Script& script = Script::Handle(origin_cls.script());
   if (!script.IsNull()) {
     jsobj.AddLocation(script, token_pos());
   }
 }
 
 
+// Build a closure object that gets the contents of a static field f
+// and cache the closure in a newly created static field named #f.
+RawInstance* Field::GetterClosure() const {
+  ASSERT(is_static());
+  const Class& field_owner = Class::Handle(owner());
+
+  String& closure_name = String::Handle();

[Florian Schneider, 2015/07/22 08:25:53]

String& closure_name = String::Handle(this->name())

to save vertical space below.

[hausner, 2015/07/22 18:41:09]

vertigo prevented :)

+  closure_name = this->name();
+  closure_name = Symbols::FromConcat(Symbols::HashMark(), closure_name);
+
+  Field& closure_field = Field::Handle();
+  closure_field = field_owner.LookupStaticField(closure_name);
+  if (!closure_field.IsNull()) {
+    ASSERT(closure_field.is_static());
+    const Instance& closure = Instance::Handle(closure_field.value());
+    ASSERT(!closure.IsNull());
+    ASSERT(closure.IsClosure());
+    return closure.raw();
+  }
+
+  // This is the first time a getter closure for this field is requested.
+  // Create the closure and a new static field in which the closure is
+  // stored.
+  const char* field_name = String::Handle(name()).ToCString();
+  String& expr_src = String::Handle(
+      String::NewFormatted("() { return %s; }", field_name));
+  Object& result =
+      Object::Handle(field_owner.Evaluate(expr_src,
+                                          Object::empty_array(),
+                                          Object::empty_array()));
+  ASSERT(result.IsInstance());
+  // The caller may expect the closure to be allocated in old space. Copy
+  // the result here, since Object::Clone() is a private method.
+  result = Object::Clone(result, Heap::kOld);
+
+  closure_field = Field::New(closure_name,
+                             true,  // is_static
+                             true,  // is_final
+                             true,  // is_const
+                             true,  // is_synthetic
+                             field_owner,
+                             this->token_pos());
+  closure_field.set_value(Instance::Cast(result));
+  closure_field.set_type(Type::Handle(Type::DynamicType()));
+  field_owner.AddField(closure_field);
+
+  return Instance::RawCast(result.raw());
+}
+
+
+// Build a closure object that sets the contents of a static field f
+// and cache the closure in a newly created static field named #f=.
+RawInstance* Field::SetterClosure() const {
+  ASSERT(is_static());
+  const Class& field_owner = Class::Handle(owner());
+
+  String& closure_name = String::Handle();

[Florian Schneider, 2015/07/22 08:25:53]

String& closure_name = String::Handle(this->name())

to save vertical space below.

[hausner, 2015/07/22 18:41:09]

Done.

+  closure_name = this->name();
+  closure_name = String::Concat(closure_name, Symbols::Equals());
+  closure_name = Symbols::FromConcat(Symbols::HashMark(), closure_name);
+
+  Field& closure_field = Field::Handle();
+  closure_field = field_owner.LookupStaticField(closure_name);
+  if (!closure_field.IsNull()) {
+    ASSERT(closure_field.is_static());
+    const Instance& closure = Instance::Handle(closure_field.value());
+    ASSERT(!closure.IsNull());
+    ASSERT(closure.IsClosure());
+    return closure.raw();
+  }
+
+  // This is the first time a getter closure for this field is requested.

[Florian Schneider, 2015/07/22 08:25:53]

Update comment for setter closure.

[hausner, 2015/07/22 18:41:09]

Done.

+  // Create the closure and a new static field in which the closure is
+  // stored.
+  const String& field_name = String::Handle(name());
+  String& expr_src = String::Handle();
+  if (field_owner.IsTopLevel()) {

[Florian Schneider, 2015/07/22 08:25:54]

Why is the top-level case needed here, and not for the getter case above?

Could most of the two methods GetterClosure/SetterClosure otherwise be unified
into one helper method? So that the only diff in input is the name, and the
evaluated function string?

[hausner, 2015/07/22 18:41:09]

The class name is added to avoid name conflicts when the field name and
parameter name are the same. I realize now that the problem still exists for
top-level variables, i.e. if the TL variable is named 'value'.

Solving this by mangling the parameter name if necessary and eliminating the
class name.

+    expr_src = String::NewFormatted("(value) { return %s = value; }",
+                                    field_name.ToCString());
+  } else {
+    const String& owner_name = String::Handle(field_owner.Name());
+    expr_src = String::NewFormatted("(value) { return %s.%s = value; }",
+                                    owner_name.ToCString(),
+                                    field_name.ToCString());
+  }
+  Object& result =
+      Object::Handle(field_owner.Evaluate(expr_src,
+                                          Object::empty_array(),
+                                          Object::empty_array()));
+  ASSERT(result.IsInstance());
+  // The caller may expect the closure to be allocated in old space. Copy
+  // the result here, since Object::Clone() is a private method.
+  result = Object::Clone(result, Heap::kOld);
+
+  closure_field = Field::New(closure_name,
+                             true,  // is_static
+                             true,  // is_final
+                             true,  // is_const
+                             true,  // is_synthetic
+                             field_owner,
+                             this->token_pos());
+  closure_field.set_value(Instance::Cast(result));
+  closure_field.set_type(Type::Handle(Type::DynamicType()));
+  field_owner.AddField(closure_field);

[Florian Schneider, 2015/07/22 08:25:54]

Maybe factor the creation of the field into a file-local helper to avoid
duplicating the code from above.

static RawField* CreateClosureField(...) {

}

[hausner, 2015/07/22 18:41:09]

Factoring out 4 lines of code that would require 3 parameters seems a bit
overkill.

I factored out the entire function into a separate method of class Field, rather
than a static method. The problem with the static method is that it could not
call Object::Clone().

+
+  return Instance::RawCast(result.raw());
+}
+
+
 RawArray* Field::dependent_code() const {
   return raw_ptr()->dependent_code_;
 }
 
 
 void Field::set_dependent_code(const Array& array) const {
   StorePointer(&raw_ptr()->dependent_code_, array.raw());
 }
 
 
@@ skipping 13810 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart