Lookup getter/setter symbols before alllocating them, thus eliminating extra String allocations in …

runtime/vm/ast.cc

 // Copyright (c) 2011, 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/ast.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
@@ skipping 554 matching lines @@
 }
 
 
 AstNode* StaticGetterNode::MakeAssignmentNode(AstNode* rhs) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   if (is_super_getter()) {
     ASSERT(receiver() != NULL);
     const String& setter_name =
-        String::ZoneHandle(zone, Field::SetterSymbol(field_name_));
-    Function& setter = Function::ZoneHandle(zone,
-        Resolver::ResolveDynamicAnyArgs(cls(), setter_name));
+        String::ZoneHandle(zone, Field::LookupSetterSymbol(field_name_));
+    Function& setter = Function::ZoneHandle(zone);
+    if (!setter_name.IsNull()) {
+      setter = Resolver::ResolveDynamicAnyArgs(cls(), setter_name);
+    }
     if (setter.IsNull() || setter.is_abstract()) {
       // No instance setter found in super class chain,
       // noSuchMethod will be called at runtime.
       return new StaticSetterNode(token_pos(),
                                   receiver(),
                                   cls(),
                                   field_name_,
                                   rhs);
     }
     return new StaticSetterNode(token_pos(),
@@ skipping 23 matching lines @@
           rhs = new AssignableNode(field.token_pos(),
                                    rhs,
                                    AbstractType::ZoneHandle(zone, field.type()),
                                    field_name_);
         }
         return new StoreStaticFieldNode(token_pos(), field, rhs);
       }
     }
 
     // No field found in prefix. Look for a setter function.
-    const String& setter_name = String::Handle(zone,
-                                               Field::SetterName(field_name_));
-    obj = prefix.LookupObject(setter_name);
-    if (obj.IsFunction()) {
-      const Function& setter = Function::ZoneHandle(zone,
-                                                    Function::Cast(obj).raw());
-      ASSERT(setter.is_static() && setter.IsSetterFunction());
-      return new StaticSetterNode(
-          token_pos(), NULL, field_name_, setter, rhs);
+    const String& setter_name =
+         String::Handle(zone, Field::LookupSetterSymbol(field_name_));
+    if (!setter_name.IsNull()) {
+      obj = prefix.LookupObject(setter_name);
+      if (obj.IsFunction()) {
+        const Function& setter =
+            Function::ZoneHandle(zone, Function::Cast(obj).raw());
+        ASSERT(setter.is_static() && setter.IsSetterFunction());
+        return new StaticSetterNode(
+            token_pos(), NULL, field_name_, setter, rhs);
+      }
     }
 
     // No writeable field and no setter found in the prefix. Return a
     // non-existing setter that will throw an NSM error.
     return new StaticSetterNode(token_pos(), NULL, cls(), field_name_, rhs);
   }
 
   if (owner().IsLibrary()) {
     const Library& library = Library::Cast(owner());
     Object& obj = Object::Handle(zone, library.ResolveName(field_name_));
     if (obj.IsField()) {
       const Field& field = Field::ZoneHandle(zone, Field::Cast(obj).raw());
       if (!field.is_final()) {
         if (isolate->flags().type_checks()) {
           rhs = new AssignableNode(field.token_pos(),
                                    rhs,
                                    AbstractType::ZoneHandle(zone, field.type()),
                                    field_name_);
         }
         return new StoreStaticFieldNode(token_pos(), field, rhs);
       }
     }
 
     // No field found in library. Look for a setter function.
-    const String& setter_name = String::Handle(zone,
-                                               Field::SetterName(field_name_));
-    obj = library.ResolveName(setter_name);
-    if (obj.IsFunction()) {
-      const Function& setter = Function::ZoneHandle(zone,
-                                                    Function::Cast(obj).raw());
-      ASSERT(setter.is_static() && setter.IsSetterFunction());
-      return new StaticSetterNode(token_pos(), NULL, field_name_, setter, rhs);
+    const String& setter_name =
+        String::Handle(zone, Field::LookupSetterSymbol(field_name_));
+    if (!setter_name.IsNull()) {
+      obj = library.ResolveName(setter_name);
+      if (obj.IsFunction()) {
+        const Function& setter =
+            Function::ZoneHandle(zone, Function::Cast(obj).raw());
+        ASSERT(setter.is_static() && setter.IsSetterFunction());
+        return
+            new StaticSetterNode(token_pos(), NULL, field_name_, setter, rhs);
+      }
     }
 
     // No writeable field and no setter found in the library. Return a
     // non-existing setter that will throw an NSM error.
     return new StaticSetterNode(token_pos(), NULL, cls(), field_name_, rhs);
   }
 
   const Function& setter =
       Function::ZoneHandle(zone, cls().LookupSetterFunction(field_name_));
   if (!setter.IsNull() && setter.IsStaticFunction()) {
     return new StaticSetterNode(token_pos(), NULL, field_name_, setter, rhs);
   }
   // Could not find a static setter. Look for a field.
   // Access to a lazily initialized static field that has not yet been
   // initialized is compiled to a static implicit getter.
   // A setter may not exist for such a field.
   const Field& field = Field::ZoneHandle(zone,
                                          cls().LookupStaticField(field_name_));
   if (!field.IsNull()) {
     if (field.is_final()) {
       // Attempting to assign to a final variable will cause a NoSuchMethodError
       // to be thrown. Change static getter to non-existent static setter in
       // order to trigger the throw at runtime.
       return new StaticSetterNode(token_pos(), NULL, cls(), field_name_, rhs);
     }
 #if defined(DEBUG)
-    const String& getter_name = String::Handle(zone,
-                                               Field::GetterName(field_name_));
+    const String& getter_name =
+        String::Handle(zone, Field::LookupGetterSymbol(field_name_));
+    ASSERT(!getter_name.IsNull());
     const Function& getter =
         Function::Handle(zone, cls().LookupStaticFunction(getter_name));
     ASSERT(!getter.IsNull() &&
            (getter.kind() == RawFunction::kImplicitStaticFinalGetter));
 #endif
     if (isolate->flags().type_checks()) {
       rhs = new AssignableNode(
           field.token_pos(),
           rhs,
           AbstractType::ZoneHandle(zone, field.type()),
@@ skipping 34 matching lines @@
   }
   return true;
 }
 
 
 const Instance* StaticGetterNode::EvalConstExpr() const {
   if (is_deferred_reference_) {
     return NULL;
   }
   const String& getter_name =
-      String::Handle(Field::GetterName(this->field_name()));
+      String::Handle(Field::LookupGetterSymbol(this->field_name()));
+  if (getter_name.IsNull()) {
+    return NULL;
+  }
   const Function& getter_func =
       Function::Handle(this->cls().LookupStaticFunction(getter_name));
   if (getter_func.IsNull() || !getter_func.is_const()) {
     return NULL;
   }
   const Object& result = Object::Handle(
       DartEntry::InvokeFunction(getter_func, Object::empty_array()));
   if (result.IsError() || result.IsNull()) {
     // TODO(turnidge): We could get better error messages by returning
     // the Error object directly to the parser.  This will involve
     // replumbing all of the EvalConstExpr methods.
     return NULL;
   }
   return &Instance::ZoneHandle(Instance::Cast(result).raw());
 }
 
 }  // namespace dart