More cleanups to avoid Handle creation in hot paths.

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 2281 matching lines @@
   // is longer than necessary.
   return super_class.TypeTest(test_kind,
                               type_arguments,
                               other,
                               other_type_arguments,
                               malformed_error);
 }
 
 
 bool Class::IsTopLevel() const {
-  return String::Handle(Name()).Equals("::");
+  return Name() == Symbols::TopLevel().raw();
 }
 
 
 RawFunction* Class::LookupDynamicFunction(const String& name) const {
-  Function& function = Function::Handle(LookupFunction(name));
-  if (function.IsNull() || !function.IsDynamicFunction()) {
-    return Function::null();
-  }
-  return function.raw();
+  return LookupFunction(name, kInstance);
 }
 
 
 RawFunction* Class::LookupDynamicFunctionAllowPrivate(
     const String& name) const {
-  Function& function = Function::Handle(LookupFunctionAllowPrivate(name));
-  if (function.IsNull() || !function.IsDynamicFunction()) {
-    return Function::null();
-  }
-  return function.raw();
+  return LookupFunctionAllowPrivate(name, kInstance);
 }
 
 
 RawFunction* Class::LookupStaticFunction(const String& name) const {
-  Function& function = Function::Handle(LookupFunction(name));
-  if (function.IsNull() || !function.IsStaticFunction()) {
-    return Function::null();
-  }
-  return function.raw();
+  return LookupFunction(name, kStatic);
 }
 
 
 RawFunction* Class::LookupStaticFunctionAllowPrivate(const String& name) const {
-  Function& function = Function::Handle(LookupFunctionAllowPrivate(name));
-  if (function.IsNull() || !function.IsStaticFunction()) {
-    return Function::null();
-  }
-  return function.raw();
+  return LookupFunctionAllowPrivate(name, kStatic);
 }
 
 
 RawFunction* Class::LookupConstructor(const String& name) const {
-  Function& function = Function::Handle(LookupFunction(name));
-  if (function.IsNull() || !function.IsConstructor()) {
-    return Function::null();
-  }
-  ASSERT(!function.is_static());
-  return function.raw();
+  return LookupFunction(name, kConstructor);
 }
 
 
 RawFunction* Class::LookupConstructorAllowPrivate(const String& name) const {
-  Function& function = Function::Handle(LookupFunctionAllowPrivate(name));
-  if (function.IsNull() || !function.IsConstructor()) {
-    return Function::null();
-  }
-  ASSERT(!function.is_static());
-  return function.raw();
+  return LookupFunctionAllowPrivate(name, kConstructor);
 }
 
 
 RawFunction* Class::LookupFactory(const String& name) const {
-  Function& function = Function::Handle(LookupFunction(name));
-  if (function.IsNull() || !function.IsFactory()) {
-    return Function::null();
-  }
-  ASSERT(function.is_static());
-  return function.raw();
+  return LookupFunction(name, kFactory);
+}
+
+
+RawFunction* Class::LookupFunction(const String& name) const {
+  return LookupFunction(name, kAny);
+}
+
+
+RawFunction* Class::LookupFunctionAllowPrivate(const String& name) const {
+  return LookupFunctionAllowPrivate(name, kAny);
 }
 
 
 // Returns true if 'prefix' and 'accessor_name' match 'name'.
 static bool MatchesAccessorName(const String& name,
                                 const char* prefix,
                                 intptr_t prefix_length,
                                 const String& accessor_name) {
   intptr_t name_len = name.Length();
   intptr_t accessor_name_len = accessor_name.Length();
 
   if (name_len != (accessor_name_len + prefix_length)) {
     return false;
   }
   for (intptr_t i = 0; i < prefix_length; i++) {
     if (name.CharAt(i) != prefix[i]) {
       return false;
     }
   }
   for (intptr_t i = 0, j = prefix_length; i < accessor_name_len; i++, j++) {
     if (name.CharAt(j) != accessor_name.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
-RawFunction* Class::LookupFunction(const String& name) const {
+RawFunction* Class::CheckFunctionType(const Function& func, intptr_t type) {
+  if (type == kInstance) {
+    if (func.IsDynamicFunction()) {
+      return func.raw();
+    }
+  } else if (type == kStatic) {
+    if (func.IsStaticFunction()) {
+      return func.raw();
+    }
+  } else if (type == kConstructor) {
+    if (func.IsConstructor()) {
+      ASSERT(!func.is_static());
+      return func.raw();
+    }
+  } else if (type == kFactory) {
+    if (func.IsFactory()) {
+      ASSERT(func.is_static());
+      return func.raw();
+    }
+  } else if (type == kAny) {
+    return func.raw();
+  }
+  return Function::null();
+}
+
+
+RawFunction* Class::LookupFunction(const String& name, intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
   Array& funcs = Array::Handle(isolate, functions());
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
-  Function& function = Function::Handle(isolate, Function::null());
+  Function& function = Function::Handle(isolate);
   const intptr_t len = funcs.Length();
   if (name.IsSymbol()) {
     // Quick Symbol compare.
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; i++) {
       function ^= funcs.At(i);
       if (function.name() == name.raw()) {
-        return function.raw();
+        return CheckFunctionType(function, type);
       }
     }
   } else {
-    String& function_name = String::Handle(isolate, String::null());
+    String& function_name = String::Handle(isolate);
     for (intptr_t i = 0; i < len; i++) {
       function ^= funcs.At(i);
       function_name ^= function.name();
       if (function_name.Equals(name)) {
-        return function.raw();
+        return CheckFunctionType(function, type);
       }
     }
   }
   // No function found.
   return Function::null();
 }
 
 
-RawFunction* Class::LookupFunctionAllowPrivate(const String& name) const {
+RawFunction* Class::LookupFunctionAllowPrivate(const String& name,
+                                               intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
   Array& funcs = Array::Handle(isolate, functions());
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
-  Function& function = Function::Handle(isolate, Function::null());
-  String& function_name = String::Handle(isolate, String::null());
+  Function& function = Function::Handle(isolate);
+  String& function_name = String::Handle(isolate);
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
     if (String::EqualsIgnoringPrivateKey(function_name, name)) {
-        return function.raw();
+      return CheckFunctionType(function, type);
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupGetterFunction(const String& name) const {
   return LookupAccessorFunction(kGetterPrefix, kGetterPrefixLength, name);
 }
@@ skipping 48 matching lines @@
         (token_pos <= func.end_token_pos())) {
       return func.raw();
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawField* Class::LookupInstanceField(const String& name) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
-    return Field::null();
-  }
-  ASSERT(is_finalized());
-  const Field& field = Field::Handle(isolate, LookupField(name));
-  if (!field.IsNull()) {
-    if (field.is_static()) {
-      // Name matches but it is not of the correct kind, return NULL.
-      return Field::null();
-    }
-    return field.raw();
-  }
-  // No field found.
-  return Field::null();
+  return LookupField(name, kInstance);
 }
 
 
 RawField* Class::LookupStaticField(const String& name) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
-    return Field::null();
-  }
-  ASSERT(is_finalized());
-  const Field& field = Field::Handle(isolate, LookupField(name));
-  if (!field.IsNull()) {
-    if (!field.is_static()) {
-      // Name matches but it is not of the correct kind, return NULL.
-      return Field::null();
-    }
-    return field.raw();
-  }
-  // No field found.
-  return Field::null();
+  return LookupField(name, kStatic);
 }
 
 
 RawField* Class::LookupField(const String& name) const {
+  return LookupField(name, kAny);
+}
+
+
+RawField* Class::LookupField(const String& name, intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Field::null();
   }
   const Array& flds = Array::Handle(isolate, fields());
   Field& field = Field::Handle(isolate, Field::null());
   String& field_name = String::Handle(isolate, String::null());
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     field_name ^= field.name();
     if (String::EqualsIgnoringPrivateKey(field_name, name)) {
-      return field.raw();
+      if (type == kInstance) {
+        if (!field.is_static()) {
+          return field.raw();
+        }
+      } else if (type == kStatic) {
+        if (field.is_static()) {
+          return field.raw();
+        }
+      } else if (type == kAny) {
+        return field.raw();
+      }
+      return Field::null();
     }
   }
   // No field found.
   return Field::null();
 }
 
 
 RawLibraryPrefix* Class::LookupLibraryPrefix(const String& name) const {
   Isolate* isolate = Isolate::Current();
   const Library& lib = Library::Handle(isolate, library());
@@ skipping 10755 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart