Optimize getField by caching a closure generated from a specialized function kind.

runtime/vm/parser.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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 764 matching lines @@
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor:
       // The call to a redirecting factory is redirected.
       ASSERT(!func.IsRedirectingFactory());
       if (!func.IsImplicitConstructor()) {
         parser.SkipFunctionPreamble();
       }
       node_sequence = parser.ParseFunc(func, default_parameter_values);
       break;
+    case RawFunction::kGetFieldClosure:
+      node_sequence = parser.ParseGetFieldClosure(func);
+      break;
+    case RawFunction::kSetFieldClosure:
+      node_sequence = parser.ParseSetFieldClosure(func);
+      break;
     case RawFunction::kImplicitGetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
     case RawFunction::kImplicitStaticFinalGetter:
       node_sequence = parser.ParseStaticFinalGetter(func);
@@ skipping 428 matching lines @@
 
   EnsureExpressionTemp();
   StoreInstanceFieldNode* store_field =
       new StoreInstanceFieldNode(ident_pos, receiver, field, value);
   current_block_->statements->Add(store_field);
   current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos));
   return CloseBlock();
 }
 
 
+SequenceNode* Parser::ParseGetFieldClosure(const Function& func) {
+  TRACE_PARSER("ParseGetFieldClosure");
+  ParamList params;
+
+  const intptr_t ident_pos = func.token_pos();
+  ASSERT(func.token_pos() == 0);
+  ASSERT(current_class().raw() == func.Owner());
+  params.AddReceiver(ReceiverType(current_class()), ident_pos);
+  params.AddFinalParameter(0,  // token pos
+                           &Symbols::PhaseParameter(),
+                           &Type::ZoneHandle(Type::DynamicType()));
+  ASSERT(func.num_fixed_parameters() == 2);
+  ASSERT(!func.HasOptionalParameters());
+
+  OpenFunctionBlock(func);
+  AddFormalParamsToScope(&params, current_block_->scope);
+
+  LoadLocalNode* victim =
+      new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(1));
+
+  const String& selector = String::ZoneHandle(func.name());
+  AstNode* get_field = CallGetter(ident_pos, victim, selector);
+
+  ReturnNode* return_node = new ReturnNode(ident_pos, get_field);
+  current_block_->statements->Add(return_node);
+  return CloseBlock();
+}
+
+
+SequenceNode* Parser::ParseSetFieldClosure(const Function& func) {
+  TRACE_PARSER("ParseSetFieldClosure");
+  ParamList params;
+
+  const intptr_t ident_pos = func.token_pos();
+  ASSERT(func.token_pos() == 0);
+  ASSERT(current_class().raw() == func.Owner());
+  params.AddReceiver(ReceiverType(current_class()), ident_pos);
+  params.AddFinalParameter(0,  // token pos
+                           &Symbols::PhaseParameter(),
+                           &Type::ZoneHandle(Type::DynamicType()));
+  params.AddFinalParameter(0,  // token pos
+                           &Symbols::Value(),
+                           &Type::ZoneHandle(Type::DynamicType()));
+  ASSERT(func.num_fixed_parameters() == 3);
+  ASSERT(!func.HasOptionalParameters());
+
+  OpenFunctionBlock(func);
+  AddFormalParamsToScope(&params, current_block_->scope);
+
+  LoadLocalNode* victim =
+      new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(1));
+  LoadLocalNode* value =
+      new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(2));
+
+  const String& selector = String::ZoneHandle(func.name());
+  AstNode* get_field = CallGetter(ident_pos, victim, selector);
+  AstNode* set_field =
+      Parser::CreateAssignmentNode(get_field, value, &selector, ident_pos);
+  ASSERT(set_field->IsInstanceSetterNode());
+
+  ReturnNode* return_node = new ReturnNode(ident_pos, set_field);
+  current_block_->statements->Add(return_node);
+  return CloseBlock();
+}
+
+
 SequenceNode* Parser::ParseMethodExtractor(const Function& func) {
   TRACE_PARSER("ParseMethodExtractor");
   ParamList params;
 
   const intptr_t ident_pos = func.token_pos();
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // Receiver.
   ASSERT(!func.HasOptionalParameters());
@@ skipping 9557 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart