Minor cleanup for getter/setter lookup

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 6955 matching lines @@
 }
 
 
 void RedirectionData::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 RawString* Field::GetterName(const String& field_name) {
   CompilerStats::make_accessor_name++;
-  // TODO(koda): Avoid most of these allocations by adding prefix-based lookup
-  // to Class::Lookup*.
   return String::Concat(Symbols::GetterPrefix(), field_name);
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   return Symbols::FromConcat(Symbols::GetterPrefix(), field_name);
 }
 
 
 RawString* Field::SetterName(const String& field_name) {
   CompilerStats::make_accessor_name++;
-  // TODO(koda): Avoid most of these allocations by adding prefix-based lookup
-  // to Class::Lookup*.
   return String::Concat(Symbols::SetterPrefix(), field_name);
 }
 
 
 RawString* Field::SetterSymbol(const String& field_name) {
   return Symbols::FromConcat(Symbols::SetterPrefix(), field_name);
 }
 
 
 RawString* Field::NameFromGetter(const String& getter_name) {
@@ skipping 1906 matching lines @@
                                      field.token_pos());
     if (metadata.IsArray()) {
       ASSERT(Array::Cast(metadata).raw() != Object::empty_array().raw());
       field.set_value(Array::Cast(metadata));
     }
   }
   return metadata.raw();
 }
 
 
+static bool ShouldBePrivate(const String& name) {
+  return
+      (name.Length() >= 1 &&
+       name.CharAt(0) == '_') ||
+      (name.Length() >= 5 &&
+       (name.CharAt(4) == '_' &&
+        (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
+        name.CharAt(1) == 'e' &&
+        name.CharAt(2) == 't' &&
+        name.CharAt(3) == ':'));
+}
+
+
 RawObject* Library::ResolveName(const String& name) const {
   Object& obj = Object::Handle();
   if (FLAG_use_lib_cache && LookupResolvedNamesCache(name, &obj)) {
     return obj.raw();
   }
   obj = LookupLocalObject(name);
   if (!obj.IsNull()) {
     // Names that are in this library's dictionary and are unmangled
     // are not cached. This reduces the size of the the cache.
     return obj.raw();
   }
   String& accessor_name = String::Handle(Field::GetterName(name));
   obj = LookupLocalObject(accessor_name);
   if (obj.IsNull()) {
     accessor_name = Field::SetterName(name);
     obj = LookupLocalObject(accessor_name);
-    if (obj.IsNull()) {
+    if (obj.IsNull() && !ShouldBePrivate(name)) {
       obj = LookupImportedObject(name);
     }
   }
   AddToResolvedNamesCache(name, obj);
   return obj.raw();
 }
 
 
 class StringEqualsTraits {
  public:
@@ skipping 315 matching lines @@
   return Function::null();
 }
 
 
 RawObject* Library::LookupLocalObject(const String& name) const {
   intptr_t index;
   return LookupEntry(name, &index);
 }
 
 
-static bool ShouldBePrivate(const String& name) {
-  return
-      (name.Length() >= 1 &&
-       name.CharAt(0) == '_') ||
-      (name.Length() >= 5 &&
-       (name.CharAt(4) == '_' &&
-        (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
-        name.CharAt(1) == 'e' &&
-        name.CharAt(2) == 't' &&
-        name.CharAt(3) == ':'));
-}
-
-
 RawField* Library::LookupFieldAllowPrivate(const String& name) const {
   Object& obj = Object::Handle(LookupObjectAllowPrivate(name));
   if (obj.IsField()) {
     return Field::Cast(obj).raw();
   }
   return Field::null();
 }
 
 
 RawField* Library::LookupLocalField(const String& name) const {
@@ skipping 53 matching lines @@
 
 
 RawObject* Library::LookupImportedObject(const String& name) const {
   Object& obj = Object::Handle();
   Namespace& import = Namespace::Handle();
   Library& import_lib = Library::Handle();
   String& import_lib_url = String::Handle();
   String& first_import_lib_url = String::Handle();
   Object& found_obj = Object::Handle();
   String& found_obj_name = String::Handle();
+  // We don't look up getter names explicitly. Setter names are
+  // looked up explicitly when converting top-level getters to setters.
+  ASSERT(!Field::IsGetterName(name));
+  ASSERT(!ShouldBePrivate(name));
   for (intptr_t i = 0; i < num_imports(); i++) {
     import ^= ImportAt(i);
     obj = import.Lookup(name);
     if (!obj.IsNull()) {
       import_lib = import.library();
       import_lib_url = import_lib.url();
       if (found_obj.raw() != obj.raw()) {
         if (first_import_lib_url.IsNull() ||
             first_import_lib_url.StartsWith(Symbols::DartScheme())) {
           // This is the first object we found, or the
@@ skipping 989 matching lines @@
 
 
 // Look up object with given name in library and filter out hidden
 // names. Also look up getters and setters.
 RawObject* Namespace::Lookup(const String& name) const {
   Isolate* isolate = Isolate::Current();
   const Library& lib = Library::Handle(isolate, library());
   intptr_t ignore = 0;
 
   // Lookup the name in the library's symbols.
-  const String* filter_name = &name;
   Object& obj = Object::Handle(isolate, lib.LookupEntry(name, &ignore));
-  if (Field::IsGetterName(name)) {
-    filter_name = &String::Handle(Field::NameFromGetter(name));
-  } else if (Field::IsSetterName(name)) {
-    filter_name = &String::Handle(Field::NameFromSetter(name));
-  } else {
-    if (obj.IsNull() || obj.IsLibraryPrefix()) {
-      obj = lib.LookupEntry(String::Handle(Field::GetterName(name)), &ignore);
-      if (obj.IsNull()) {
-        obj = lib.LookupEntry(String::Handle(Field::SetterName(name)), &ignore);
-      }
+  if (!Field::IsGetterName(name) &&
+      !Field::IsSetterName(name) &&
+      (obj.IsNull() || obj.IsLibraryPrefix())) {
+    obj = lib.LookupEntry(String::Handle(Field::GetterName(name)), &ignore);
+    if (obj.IsNull()) {
+      obj = lib.LookupEntry(String::Handle(Field::SetterName(name)), &ignore);
     }
   }
 
   // Library prefixes are not exported.
   if (obj.IsNull() || obj.IsLibraryPrefix()) {
     // Lookup in the re-exported symbols.
     obj = lib.LookupReExport(name);
   }
-  if (obj.IsNull() || HidesName(*filter_name) || obj.IsLibraryPrefix()) {
+  if (obj.IsNull() || HidesName(name) || obj.IsLibraryPrefix()) {
     return Object::null();
   }
   return obj.raw();
 }
 
 
 RawNamespace* Namespace::New() {
   ASSERT(Object::namespace_class() != Class::null());
   RawObject* raw = Object::Allocate(Namespace::kClassId,
                                     Namespace::InstanceSize(),
@@ skipping 10328 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart