- Avoid double iteration when accessing anonymous classes.

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 6298 matching lines @@
 
 
 void Script::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 DictionaryIterator::DictionaryIterator(const Library& library)
     : array_(Array::Handle(library.dictionary())),
-      // Last element in array is a Smi.
+      // Last element in array is a Smi indicating the number of entries used.
       size_(Array::Handle(library.dictionary()).Length() - 1),
       next_ix_(0) {
   MoveToNextObject();
 }
 
 
 RawObject* DictionaryIterator::GetNext() {
   ASSERT(HasNext());
   int ix = next_ix_++;
   MoveToNextObject();
   ASSERT(array_.At(ix) != Object::null());
   return array_.At(ix);
 }
 
 
 void DictionaryIterator::MoveToNextObject() {
   Object& obj = Object::Handle(array_.At(next_ix_));
   while (obj.IsNull() && HasNext()) {
     next_ix_++;
     obj = array_.At(next_ix_);
   }
 }
 
 
-ClassDictionaryIterator::ClassDictionaryIterator(const Library& library)
-    : DictionaryIterator(library) {
+ClassDictionaryIterator::ClassDictionaryIterator(const Library& library,
+                                                 IterationKind kind)
+    : DictionaryIterator(library),
+      anon_array_((kind == kIteratePrivate) ?
+          Array::Handle(library.anonymous_classes()) : Object::empty_array()),
+      anon_size_((kind == kIteratePrivate) ?
+                 library.num_anonymous_classes() : 0),
+      anon_ix_(0) {
   MoveToNextClass();
 }
 
 
 RawClass* ClassDictionaryIterator::GetNextClass() {
   ASSERT(HasNext());
-  int ix = next_ix_++;
-  Object& obj = Object::Handle(array_.At(ix));
-  MoveToNextClass();
-  return Class::Cast(obj).raw();
+  Class& cls = Class::Handle();
+  if (next_ix_ < size_) {
+    int ix = next_ix_++;
+    cls ^= array_.At(ix);
+    MoveToNextClass();
+    return cls.raw();
+  }
+  ASSERT(anon_ix_ < anon_size_);
+  cls ^= anon_array_.At(anon_ix_++);
+  return cls.raw();
 }
 
 
 void ClassDictionaryIterator::MoveToNextClass() {
-  Object& obj = Object::Handle(array_.At(next_ix_));
-  while (!obj.IsClass() && HasNext()) {
+  Object& obj = Object::Handle();
+  while (next_ix_ < size_) {
+    obj = array_.At(next_ix_);
+    if (obj.IsClass()) {
+      return;
+    }
     next_ix_++;
-    obj = array_.At(next_ix_);
   }
 }
 
 
 LibraryPrefixIterator::LibraryPrefixIterator(const Library& library)
     : DictionaryIterator(library) {
   Advance();
 }
 
 
@@ skipping 366 matching lines @@
     }
   }
   return Script::null();
 }
 
 
 RawFunction* Library::LookupFunctionInScript(const Script& script,
                                              intptr_t token_pos) const {
   Class& cls = Class::Handle();
   Function& func = Function::Handle();
-  ClassDictionaryIterator it(*this);
+  ClassDictionaryIterator it(*this, ClassDictionaryIterator::kIteratePrivate);
   while (it.HasNext()) {
     cls = it.GetNextClass();
     if (script.raw() == cls.script()) {
       func = cls.LookupFunctionAtToken(token_pos);
       if (!func.IsNull()) {
         return func.raw();
       }
     }
   }
-  // Look in anonymous classes for toplevel functions.
-  Array& anon_classes = Array::Handle(this->raw_ptr()->anonymous_classes_);
-  intptr_t num_anonymous = raw_ptr()->num_anonymous_;
-  for (int i = 0; i < num_anonymous; i++) {
-    cls ^= anon_classes.At(i);
-    ASSERT(!cls.IsNull());
-    if (script.raw() == cls.script()) {
-      func = cls.LookupFunctionAtToken(token_pos);
-      if (!func.IsNull()) {
-        return func.raw();
-      }
-    }
-  }
   return Function::null();
 }
 
 
 RawObject* Library::LookupLocalObject(const String& name) const {
   intptr_t index;
   return LookupEntry(name, &index);
 }
 
 
@@ skipping 837 matching lines @@
 
 
 RawError* Library::CompileAll() {
   Error& error = Error::Handle();
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   Class& cls = Class::Handle();
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
-    ClassDictionaryIterator it(lib);
+    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
     while (it.HasNext()) {
       cls = it.GetNextClass();
       error = cls.EnsureIsFinalized(Isolate::Current());
       if (!error.IsNull()) {
         return error.raw();
       }
       error = Compiler::CompileAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
-    Array& anon_classes = Array::Handle(lib.raw_ptr()->anonymous_classes_);
-    for (int i = 0; i < lib.raw_ptr()->num_anonymous_; i++) {
-      cls ^= anon_classes.At(i);
-      error = Compiler::CompileAllFunctions(cls);
-      if (!error.IsNull()) {
-        return error.raw();
-      }
-    }
   }
   return error.raw();
 }
 
 
 struct FpDiff {
   FpDiff(int32_t old_, int32_t new_): old_fp(old_), new_fp(new_) {}
   int32_t old_fp;
   int32_t new_fp;
 };
@@ skipping 6963 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart