Improve compile times for swarm application startup

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2001 matching lines @@
         &Type::ZoneHandle(Type::DynamicType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &method->params);
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
-      method->name = &String::ZoneHandle(Field::GetterName(*method->name));
+      method->name = &String::ZoneHandle(Field::GetterSymbol(*method->name));
     } else {
       ASSERT(method->IsSetter());
       expected_num_parameters = (method->has_static) ? 1 : 2;
-      method->name = &String::ZoneHandle(Field::SetterName(*method->name));
+      method->name = &String::ZoneHandle(Field::SetterSymbol(*method->name));
     }
     if ((method->params.num_fixed_parameters != expected_num_parameters) ||
         (method->params.num_optional_parameters != 0)) {
       ErrorMsg(method->name_pos, "illegal %s parameters",
                method->IsGetter() ? "getter" : "setter");
     }
   }
 
   // Parse initializers.
   if (CurrentToken() == Token::kCOLON) {
@@ skipping 174 matching lines @@
                     field->has_final,
                     field->name_pos));
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
     members->AddField(&class_field);
 
     // For static final fields, set value to "uninitialized" and
     // create a kConstImplicitGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(Instance::Handle(Object::sentinel()));
-      String& getter_name = String::ZoneHandle(Field::GetterName(*field->name));
+      String& getter_name =
+          String::ZoneHandle(Field::GetterSymbol(*field->name));
       Function& getter = Function::ZoneHandle(
           Function::New(getter_name, RawFunction::kConstImplicitGetter,
                         field->has_static, field->has_final,
                         field->name_pos));
       getter.set_result_type(*field->type);
       members->AddFunction(&getter);
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name =
-          String::ZoneHandle(Field::GetterName(*field->name));
+          String::ZoneHandle(Field::GetterSymbol(*field->name));
       Function& getter = Function::ZoneHandle(
           Function::New(getter_name, RawFunction::kImplicitGetter,
                         field->has_static, field->has_final,
                         field->name_pos));
       ParamList params;
       params.AddReceiver(token_index_);
       getter.set_result_type(*field->type);
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(&getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name = String::ZoneHandle(
-            Field::SetterName(*field->name));
+            Field::SetterSymbol(*field->name));
         Function& setter = Function::ZoneHandle(
             Function::New(setter_name, RawFunction::kImplicitSetter,
                          field->has_static, field->has_final,
                          field->name_pos));
         ParamList params;
         params.AddReceiver(token_index_);
         params.AddFinalParameter(token_index_, "value", field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(&setter);
@@ skipping 824 matching lines @@
         Field::New(var_name, is_static, is_final, name_pos));
     field.set_type(type);
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(&field);
     library_.AddObject(field, var_name);
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       SkipExpr();
       field.set_value(Instance::Handle(Object::sentinel()));
       // Create a static const getter.
-      String& getter_name = String::ZoneHandle(Field::GetterName(var_name));
+      String& getter_name = String::ZoneHandle(Field::GetterSymbol(var_name));
       Function& getter = Function::ZoneHandle(
           Function::New(getter_name, RawFunction::kConstImplicitGetter,
                         is_static, is_final, name_pos));
       getter.set_result_type(type);
       top_level->functions.Add(&getter);
     } else if (is_final) {
       ErrorMsg(name_pos, "missing initializer for final variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
@@ skipping 100 matching lines @@
     ErrorMsg("'(' expected");
   }
   const intptr_t accessor_pos = token_index_;
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, &params);
   String& accessor_name = String::ZoneHandle();
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
-    accessor_name = Field::GetterName(*field_name);
+    accessor_name = Field::GetterSymbol(*field_name);
   } else {
     expected_num_parameters = 1;
-    accessor_name = Field::SetterName(*field_name);
+    accessor_name = Field::SetterSymbol(*field_name);
   }
   if ((params.num_fixed_parameters != expected_num_parameters) ||
       (params.num_optional_parameters != 0)) {
     ErrorMsg(name_pos, "illegal %s parameters",
              is_getter ? "getter" : "setter");
   }
 
   if (library_.LookupObject(*field_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined in this library",
              field_name->ToCString());
@@ skipping 3217 matching lines @@
   LocalVariable* local = LookupLocalScope(ident);
   if (local != NULL) {
     *node = new LoadLocalNode(ident_pos, *local);
     return true;
   }
 
   // Try to find the identifier in the class scope.
   Class& cls = Class::Handle(isolate, current_class().raw());
   Function& func = Function::Handle(isolate, Function::null());
   Field& field = Field::Handle(isolate, Field::null());
-  String& accessor_name = String::Handle(isolate, String::null());
   while (!cls.IsNull()) {
     // First check if a field exists.
     field = cls.LookupField(ident);
     if (!field.IsNull()) {
       if (!field.is_static()) {
         CheckInstanceFieldAccess(ident_pos, ident);
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       } else {
         *node = GenerateStaticFieldLookup(field, ident_pos);
       }
       return true;
     }
 
     // Check if an instance/static function exists.
     func = cls.LookupFunction(ident);
     if (!func.IsNull() &&
         (func.IsDynamicFunction() || func.IsStaticFunction())) {
       *node = new PrimaryNode(ident_pos,
                               Function::ZoneHandle(isolate, func.raw()));
       return true;
     }
 
     // Now check if a getter/setter method exists for it in which case
     // it is still a field.
-    accessor_name = Field::GetterName(ident);
-    func = cls.LookupFunction(accessor_name);
+    func = cls.LookupGetterFunction(ident);
     if (!func.IsNull()) {
       if (func.IsDynamicFunction()) {
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
         return true;
       } else if (func.IsStaticFunction()) {
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = new StaticGetterNode(ident_pos,
                                      Class::ZoneHandle(isolate, cls.raw()),
                                      ident);
         return true;
       }
     }
-    accessor_name = Field::SetterName(ident);
-    func = cls.LookupFunction(accessor_name);
+    func = cls.LookupSetterFunction(ident);
     if (!func.IsNull()) {
       if (func.IsDynamicFunction()) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
         return true;
@@ skipping 1252 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart