Delay Class parsing until the class is actually used.

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 11 matching lines @@
 #include "vm/datastream.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/double_conversion.h"
 #include "vm/exceptions.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/growable_array.h"
 #include "vm/heap.h"
 #include "vm/intermediate_language.h"
 #include "vm/intrinsifier.h"
+#include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 
 namespace dart {
@@ skipping 314 matching lines @@
     // Initialization from Class::New<Class>.
     // Directly set raw_ to break a circular dependency: SetRaw will attempt
     // to lookup class class in the class table where it is not registered yet.
     cls.raw_ = class_class_;
     cls.set_handle_vtable(fake.vtable());
     cls.set_instance_size(Class::InstanceSize());
     cls.set_next_field_offset(Class::InstanceSize());
     cls.set_id(Class::kClassId);
     cls.raw_ptr()->state_bits_ = 0;
     cls.set_is_finalized();
+    cls.set_is_type_finalized();
+    cls.set_is_parsed();
     cls.raw_ptr()->type_arguments_field_offset_in_words_ =
         Class::kNoTypeArguments;
     cls.raw_ptr()->num_native_fields_ = 0;
     cls.InitEmptyFields();
     isolate->class_table()->Register(cls);
   }
 
   // Allocate and initialize the null class.
   cls = Class::New<Instance>(kNullCid);
   cls.set_is_finalized();
+  cls.set_is_type_finalized();
+  cls.set_is_parsed();
   null_class_ = cls.raw();
 
   // Allocate and initialize the free list element class.
   cls = Class::New<FreeListElement::FakeInstance>(kFreeListElement);
   cls.set_is_finalized();
+  cls.set_is_type_finalized();
+  cls.set_is_parsed();
 
   // Allocate and initialize the sentinel values of Null class.
   {
     *sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
 
     *transition_sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
   }
 
   // Allocate and initialize optimizing compiler constants.
   {
     *unknown_constant_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
     *non_constant_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
   }
 
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_finalized();
+  cls.set_is_type_finalized();
+  cls.set_is_parsed();
   cls.set_is_abstract();
   dynamic_class_ = cls.raw();
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
   cls = Class::New<Instance>(kVoidCid);
   cls.set_is_finalized();
+  cls.set_is_type_finalized();
+  cls.set_is_parsed();
   void_class_ = cls.raw();
 
   cls = Class::New<TypeArguments>();
   type_arguments_class_ = cls.raw();
 
   cls = Class::New<InstantiatedTypeArguments>();
   instantiated_type_arguments_class_ = cls.raw();
 
   cls = Class::New<PatchClass>();
   patch_class_class_ = cls.raw();
@@ skipping 567 matching lines @@
   RegisterClass(cls, Symbols::Double(), core_lib);
   cls.set_is_prefinalized();
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_type(type);
 
   name = Symbols::New("String");
   cls = Class::New<Instance>(kIllegalCid);
   cls.set_is_prefinalized();
   RegisterClass(cls, name, core_lib);
+  cls.set_is_prefinalized();
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::List(), core_lib);
   cls.set_is_prefinalized();
   pending_classes.Add(cls, Heap::kOld);
   object_store->set_list_class(cls);
 
@@ skipping 529 matching lines @@
 
 void Class::set_class_state(RawClass::ClassState state) const {
   ASSERT((state == RawClass::kAllocated) ||
          (state == RawClass::kPreFinalized) ||
          (state == RawClass::kFinalized));
   set_state_bits(StateBits::update(state, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_state_bits(intptr_t bits) const {
-  raw_ptr()->state_bits_ = static_cast<uint8_t>(bits);
+  raw_ptr()->state_bits_ = static_cast<uint16_t>(bits);
 }
 
 
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
 void Class::set_type_parameters(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
@@ skipping 25 matching lines @@
   const Class& superclass = Class::Handle(cls.SuperClass());
   // Object is its own super class during bootstrap.
   if (!superclass.IsNull() && (superclass.raw() != raw())) {
     num_type_args += superclass.NumTypeArguments();
   }
   return num_type_args;
 }
 
 
 bool Class::HasTypeArguments() const {
-  if (!IsSignatureClass() && (is_finalized() || is_prefinalized())) {
+  if (!IsSignatureClass() && (is_type_finalized() || is_prefinalized())) {
     // More efficient than calling NumTypeArguments().
     return type_arguments_field_offset() != kNoTypeArguments;
   } else {
     // No need to check NumTypeArguments() if class has type parameters.
     return (NumTypeParameters() > 0) || (NumTypeArguments() > 0);
   }
 }
 
 
 RawClass* Class::SuperClass() const {
@@ skipping 173 matching lines @@
   }
   SetFields(new_list);
 
   // The functions and fields in the patch class are no longer needed.
   patch.SetFunctions(Object::empty_array());
   patch.SetFields(Object::empty_array());
   return NULL;
 }
 
 
+// Ensure that top level parsing of the class has been done.
+RawError* Class::EnsureIsParsed(Isolate* isolate) const {
+  if (!is_parsed()) {
+    ASSERT(isolate != NULL);
+    const Error& error = Error::Handle(isolate, Compiler::ParseClass(*this));
+    if (!error.IsNull() && (isolate->long_jump_base() != NULL)) {
+      isolate->long_jump_base()->Jump(1, error);
+      UNREACHABLE();
+    }
+    return error.raw();
+  }
+  return Error::null();
+}
+
+
 void Class::SetFields(const Array& value) const {
   ASSERT(!value.IsNull());
 #if defined(DEBUG)
   // Verify that all the fields in the array have this class as owner.
   Field& field = Field::Handle();
   intptr_t len = value.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= value.At(i);
     ASSERT(field.owner() == raw());
   }
@@ skipping 45 matching lines @@
                                    const Function& signature_function,
                                    const Script& script,
                                    intptr_t token_pos) {
   const Class& result = Class::Handle(New(name, script, token_pos));
   const Type& super_type = Type::Handle(Type::ObjectType());
   ASSERT(!super_type.IsNull());
   // Instances of a signature class can only be closures.
   result.set_instance_size(Closure::InstanceSize());
   result.set_next_field_offset(Closure::InstanceSize());
   result.set_super_type(super_type);
+  result.set_is_parsed();
   result.set_type_arguments_field_offset(Closure::type_arguments_offset());
   // Implements interface "Function".
   const Type& function_type = Type::Handle(Type::Function());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
   interfaces.SetAt(0, function_type);
   result.set_interfaces(interfaces);
   if (!signature_function.IsNull()) {
     result.PatchSignatureFunction(signature_function);
   }
   return result.raw();
@@ skipping 40 matching lines @@
     cls.SetFunctions(Object::empty_array());
     // Set super class to Object.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size. First word contains a pointer to a properly
     // sized typed array once the first native field has been set.
     intptr_t instance_size = sizeof(RawObject) + kWordSize;
     cls.set_instance_size(RoundedAllocationSize(instance_size));
     cls.set_next_field_offset(instance_size);
     cls.set_num_native_fields(field_count);
     cls.set_is_finalized();
+    cls.set_is_type_finalized();
+    cls.set_is_parsed();
     library.AddClass(cls);
     return cls.raw();
   } else {
     return Class::null();
   }
 }
 
 
 RawClass* Class::NewStringClass(intptr_t class_id) {
   intptr_t instance_size;
@@ skipping 66 matching lines @@
 void Class::set_is_implemented() const {
   set_state_bits(ImplementedBit::update(true, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_abstract() const {
   set_state_bits(AbstractBit::update(true, raw_ptr()->state_bits_));
 }
 
 
+void Class::set_is_type_finalized() const {
+  set_state_bits(TypeFinalizedBit::update(true, raw_ptr()->state_bits_));
+}
+
+
+void Class::set_is_patch() const {
+  set_state_bits(PatchBit::update(true, raw_ptr()->state_bits_));
+}
+
+
+void Class::set_is_parsed() const {
+  set_state_bits(ParsedBit::update(true, raw_ptr()->state_bits_));
+}
+
+
+void Class::set_is_synthesized_class() const {
+  set_state_bits(SynthesizedClassBit::update(true, raw_ptr()->state_bits_));
+}
+
+
 void Class::set_is_const() const {
   set_state_bits(ConstBit::update(true, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_finalized() const {
   ASSERT(!is_finalized());
   set_state_bits(StateBits::update(RawClass::kFinalized,
                                    raw_ptr()->state_bits_));
 }
@@ skipping 13 matching lines @@
 }
 
 
 void Class::set_mixin(const Type& value) const {
   // Resolution and application of mixin type occurs in finalizer.
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->mixin_, value.raw());
 }
 
 
+void Class::add_patch_class(const Class& patch_class) const {
+  ASSERT(!patch_class.IsNull());
+  GrowableObjectArray& patch_classes = GrowableObjectArray::Handle();
+  patch_classes ^= raw_ptr()->patch_classes_;
+  if (patch_classes.IsNull()) {
+    patch_classes ^= GrowableObjectArray::New(1, Heap::kOld);
+    StorePointer(&raw_ptr()->patch_classes_, patch_classes.raw());
+  }
+  patch_classes.Add(patch_class);
+}
+
+
 void Class::AddDirectSubclass(const Class& subclass) const {
   ASSERT(!subclass.IsNull());
   ASSERT(subclass.SuperClass() == raw());
   // Do not keep track of the direct subclasses of class Object.
   ASSERT(!IsObjectClass());
   GrowableObjectArray& direct_subclasses =
       GrowableObjectArray::Handle(raw_ptr()->direct_subclasses_);
   if (direct_subclasses.IsNull()) {
     direct_subclasses = GrowableObjectArray::New(4, Heap::kOld);
     StorePointer(&raw_ptr()->direct_subclasses_, direct_subclasses.raw());
@@ skipping 295 matching lines @@
     if (name.CharAt(j) != accessor_name.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawFunction* Class::LookupFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
+  if (EnsureIsParsed(isolate) != Error::null()) {

[hausner, 2013/05/21 20:07:30]

How do errors during parsing get propagated to the caller?

[siva, 2013/05/23 00:54:31]

The function EnsureIsParsed does a Longjump on error if there is a jump context.
During parsing there is a jump context and this produces errors.

On 2013/05/21 20:07:30, hausner wrote:

+    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());
   const intptr_t len = funcs.Length();
   if (name.IsSymbol()) {
     // Quick Symbol compare.
     NoGCScope no_gc;
@@ skipping 13 matching lines @@
       }
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAllowPrivate(const String& name) const {
   Isolate* isolate = Isolate::Current();
+  if (EnsureIsParsed(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());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
@@ skipping 14 matching lines @@
 
 RawFunction* Class::LookupSetterFunction(const String& name) const {
   return LookupAccessorFunction(kSetterPrefix, kSetterPrefixLength, name);
 }
 
 
 RawFunction* Class::LookupAccessorFunction(const char* prefix,
                                            intptr_t prefix_length,
                                            const String& name) const {
   Isolate* isolate = Isolate::Current();
+  if (EnsureIsParsed(isolate) != Error::null()) {
+    return Function::null();
+  }
   Array& funcs = Array::Handle(isolate, functions());
   Function& function = Function::Handle(isolate, Function::null());
   String& function_name = String::Handle(isolate, String::null());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
     if (MatchesAccessorName(function_name, prefix, prefix_length, name)) {
       return function.raw();
     }
   }
 
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAtToken(intptr_t token_pos) const {
   // TODO(hausner): we can shortcut the negative case if we knew the
   // beginning and end token position of the class.
-  Function& func = Function::Handle();
+  Isolate* isolate = Isolate::Current();
+  if (EnsureIsParsed(isolate) != Error::null()) {
+    return Function::null();
+  }
+  Function& func = Function::Handle(isolate);
   func = LookupClosureFunction(token_pos);
   if (!func.IsNull()) {
     return func.raw();
   }
-  Array& funcs = Array::Handle(functions());
+  Array& funcs = Array::Handle(isolate, functions());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     func ^= funcs.At(i);
     if ((func.token_pos() <= token_pos) &&
         (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 (EnsureIsParsed(isolate) != Error::null()) {
+    return Field::null();
+  }
   ASSERT(is_finalized());
-  const Field& field = Field::Handle(LookupField(name));
+  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();
 }
 
 
 RawField* Class::LookupStaticField(const String& name) const {
+  Isolate* isolate = Isolate::Current();
+  if (EnsureIsParsed(isolate) != Error::null()) {
+    return Field::null();
+  }
   ASSERT(is_finalized());
-  const Field& field = Field::Handle(LookupField(name));
+  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();
 }
 
 
 RawField* Class::LookupField(const String& name) const {
   Isolate* isolate = Isolate::Current();
+  if (EnsureIsParsed(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();
     }
@@ skipping 4396 matching lines @@
   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);
     while (it.HasNext()) {
       cls = it.GetNextClass();
+      error = cls.EnsureIsParsed(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()) {
@@ skipping 2264 matching lines @@
       }
       return true;
     }
     cls = cls.SuperClass();
   } while (!cls.IsNull());
   return false;
 }
 
 
 RawInstance* Instance::New(const Class& cls, Heap::Space space) {
-  Instance& result = Instance::Handle();
+  Isolate* isolate = Isolate::Current();
+  if (cls.EnsureIsParsed(isolate) != Error::null()) {
+    return Instance::null();
+  }
+  Instance& result = Instance::Handle(isolate);
   {
     intptr_t instance_size = cls.instance_size();
     ASSERT(instance_size > 0);
     RawObject* raw = Object::Allocate(cls.id(), instance_size, space);
     NoGCScope no_gc;
     result ^= raw;
   }
   return result.raw();
 }
 
@@ skipping 183 matching lines @@
         // but use actual vector.
         num_type_params = num_args;
       } else {
         ASSERT(num_args == 0);  // Type is raw.
         // No need to fill up with "dynamic".
         num_type_params = 0;
       }
     } else {
       // The actual type argument vector can be longer than necessary, because
       // of type optimizations.
-      if (IsFinalized() && cls.is_finalized()) {
+      if (IsFinalized() && cls.is_type_finalized()) {
         first_type_param_index = cls.NumTypeArguments() - num_type_params;
       } else {
         first_type_param_index = num_args - num_type_params;
       }
     }
     if (cls.IsSignatureClass()) {
       // We may be reporting an error about a malformed function type. In that
       // case, avoid instantiating the signature, since it may lead to cycles.
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
         return class_name.raw();
@@ skipping 3869 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart