Delay Class parsing until the class is actually used.

runtime/vm/object_test.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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/simulator.h"
 #include "vm/symbols.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
+static RawClass* CreateDummyClass(const String& class_name,
+                                  const Script& script) {
+  const Class& cls = Class::Handle(
+      Class::New(class_name, script, Scanner::kDummyTokenIndex));
+  cls.set_is_synthesized_class();  // Dummy class for testing.
+  return cls.raw();
+}
+
+
 TEST_CASE(Class) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
-  const Class& cls = Class::Handle(
-      Class::New(class_name, script, Scanner::kDummyTokenIndex));
+  const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
 
   // Class has no fields.
   cls.SetFields(Object::empty_array());
 
   // Create and populate the function arrays.
   const Array& functions = Array::Handle(Array::New(6));
   Function& function = Function::Handle();
   String& function_name = String::Handle();
   function_name = Symbols::New("foo");
   function = Function::New(
@@ skipping 29 matching lines @@
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
       true, false, false, false, cls, 0);
   functions.SetAt(4, function);
   function_name = Symbols::New("BaZ");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
       true, false, false, false, cls, 0);
   functions.SetAt(5, function);
 
-  // Setup the functions in the class.
+  // Setup the functions and interfaces in the class.
   cls.SetFunctions(functions);
+  const Array& interfaces = Array::Handle(Array::New(2));
+  Class& interface = Class::Handle();
+  String& interface_name = String::Handle();
+  interface_name = Symbols::New("Harley");
+  interface = CreateDummyClass(interface_name, script);
+  interfaces.SetAt(0, Type::Handle(Type::NewNonParameterizedType(interface)));
+  interface_name = Symbols::New("Norton");
+  interface = CreateDummyClass(interface_name, script);
+  interfaces.SetAt(1, Type::Handle(Type::NewNonParameterizedType(interface)));
+  cls.set_interfaces(interfaces);
+  ClassFinalizer::FinalizeTypesInClass(cls);
+  cls.Finalize();
 
   function_name = String::New("Foo");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(function.IsNull());
   function = cls.LookupStaticFunction(function_name);
   EXPECT(!function.IsNull());
   EXPECT(function_name.Equals(String::Handle(function.name())));
   EXPECT_EQ(cls.raw(), function.Owner());
   EXPECT(function.is_static());
   function_name = String::New("baz");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(!function.IsNull());
   EXPECT(function_name.Equals(String::Handle(function.name())));
   EXPECT_EQ(cls.raw(), function.Owner());
   EXPECT(!function.is_static());
   function = cls.LookupStaticFunction(function_name);
   EXPECT(function.IsNull());
 
   function_name = String::New("foo");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(!function.IsNull());
   EXPECT_EQ(0, function.num_fixed_parameters());
   EXPECT(!function.HasOptionalParameters());
 
   function_name = String::New("bar");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(!function.IsNull());
   EXPECT_EQ(kNumFixedParameters, function.num_fixed_parameters());
   EXPECT_EQ(kNumOptionalParameters, function.NumOptionalParameters());
-
-  const Array& interfaces = Array::Handle(Array::New(2));
-  Class& interface = Class::Handle();
-  String& interface_name = String::Handle();
-  interface_name = Symbols::New("Harley");
-  interface = Class::New(interface_name, script, Scanner::kDummyTokenIndex);
-  interfaces.SetAt(0, Type::Handle(Type::NewNonParameterizedType(interface)));
-  interface_name = Symbols::New("Norton");
-  interface = Class::New(interface_name, script, Scanner::kDummyTokenIndex);
-  interfaces.SetAt(1, Type::Handle(Type::NewNonParameterizedType(interface)));
-  cls.set_interfaces(interfaces);
-  cls.Finalize();
 }
 
 
 TEST_CASE(TypeArguments) {
   const Type& type1 = Type::Handle(Type::Double());
   const Type& type2 = Type::Handle(Type::StringType());
   const TypeArguments& type_arguments1 = TypeArguments::Handle(
     TypeArguments::New(2));
   type_arguments1.SetTypeAt(0, type1);
   type_arguments1.SetTypeAt(1, type2);
@@ skipping 32 matching lines @@
   iterator.Advance();  // Advance to end of stream.
   EXPECT_EQ(Token::kEOS, iterator.CurrentTokenKind());
 }
 
 
 TEST_CASE(InstanceClass) {
   // Allocate the class first.
   String& class_name = String::Handle(Symbols::New("EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
-      Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
+      Class::Handle(CreateDummyClass(class_name, script));
 
   // No functions and no super class for the EmptyClass.
   empty_class.SetFields(Object::empty_array());
+  ClassFinalizer::FinalizeTypesInClass(empty_class);
   empty_class.Finalize();
   EXPECT_EQ(kObjectAlignment, empty_class.instance_size());
   Instance& instance = Instance::Handle(Instance::New(empty_class));
   EXPECT_EQ(empty_class.raw(), instance.clazz());
 
   class_name = Symbols::New("OneFieldClass");
   const Class& one_field_class =
-      Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
+      Class::Handle(CreateDummyClass(class_name, script));
 
   // No functions and no super class for the OneFieldClass.
   const Array& one_fields = Array::Handle(Array::New(1));
   const String& field_name = String::Handle(Symbols::New("the_field"));
   const Field& field = Field::Handle(
        Field::New(field_name, false, false, false, one_field_class, 0));
   one_fields.SetAt(0, field);
   one_field_class.SetFields(one_fields);
+  ClassFinalizer::FinalizeTypesInClass(one_field_class);
   one_field_class.Finalize();
   intptr_t header_size = sizeof(RawObject);
   EXPECT_EQ(Utils::RoundUp((header_size + (1 * kWordSize)), kObjectAlignment),
             one_field_class.instance_size());
   EXPECT_EQ(header_size, field.Offset());
   EXPECT(!one_field_class.is_implemented());
   one_field_class.set_is_implemented();
   EXPECT(one_field_class.is_implemented());
 }
 
@@ skipping 1968 matching lines @@
   EXPECT_EQ(1, var_c->index());
   EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
             var_c->owner()->context_level());  // Adjusted context level.
 }
 
 
 TEST_CASE(Closure) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
-  const Class& cls =
-      Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
+  const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   const Array& functions = Array::Handle(Array::New(1));
 
   const Context& context = Context::Handle(Context::New(0));
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(Symbols::New("foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
                          false, false, false, false, cls, 0);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
@@ skipping 53 matching lines @@
   str3 = OneByteString::null();
   EXPECT(str3.IsString());
   EXPECT(!str3.IsOneByteString());
 }
 
 
 static Function* CreateFunction(const char* name) {
   const String& class_name = String::Handle(Symbols::New("ownerClass"));
   const Script& script = Script::Handle();
   const Class& owner_class =
-      Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
+      Class::Handle(CreateDummyClass(class_name, script));
   const String& function_name = String::ZoneHandle(Symbols::New(name));
   Function& function = Function::ZoneHandle(
       Function::New(function_name, RawFunction::kRegularFunction,
                     true, false, false, false, owner_class, 0));
   return &function;
 }
 
 
 // Test for Code and Instruction object creation.
 TEST_CASE(Code) {
@@ skipping 151 matching lines @@
   EXPECT_EQ(static_cast<uword>(80), pc_descs.PC(5));
   EXPECT_EQ(150, pc_descs.TokenPos(5));
   EXPECT_EQ(PcDescriptors::kOther, pc_descs.DescriptorKind(0));
   EXPECT_EQ(PcDescriptors::kDeopt, pc_descs.DescriptorKind(1));
 }
 
 
 static RawClass* CreateTestClass(const char* name) {
   const String& class_name = String::Handle(Symbols::New(name));
   const Class& cls = Class::Handle(
-      Class::New(class_name, Script::Handle(), Scanner::kDummyTokenIndex));
+      CreateDummyClass(class_name, Script::Handle()));
   return cls.raw();
 }
 
 
 static RawField* CreateTestField(const char* name) {
   const Class& cls = Class::Handle(CreateTestClass("global:"));
   const String& field_name = String::Handle(Symbols::New(name));
   const Field& field =
       Field::Handle(Field::New(field_name, true, false, false, cls, 0));
   return field.raw();
@@ skipping 19 matching lines @@
     ASSERT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   ASSERT(count == 2);
 }
 
 
 static RawFunction* GetDummyTarget(const char* name) {
   const String& function_name = String::Handle(Symbols::New(name));
   const Class& cls = Class::Handle(
-       Class::New(function_name, Script::Handle(), Scanner::kDummyTokenIndex));
+       CreateDummyClass(function_name, Script::Handle()));
   const bool is_static = false;
   const bool is_const = false;
   const bool is_abstract = false;
   const bool is_external = false;
   return Function::New(function_name,
                        RawFunction::kRegularFunction,
                        is_static,
                        is_const,
                        is_abstract,
                        is_external,
@@ skipping 52 matching lines @@
   EXPECT_EQ(kSmiCid, test_class_ids[0]);
   EXPECT_EQ(kSmiCid, test_class_ids[1]);
   EXPECT_EQ(target1.raw(), test_target.raw());
 }
 
 
 TEST_CASE(SubtypeTestCache) {
   String& class_name = String::Handle(Symbols::New("EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
-      Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
+      Class::Handle(CreateDummyClass(class_name, script));
   SubtypeTestCache& cache = SubtypeTestCache::Handle(SubtypeTestCache::New());
   ASSERT(!cache.IsNull());
   EXPECT_EQ(0, cache.NumberOfChecks());
   const TypeArguments& targ_0 = TypeArguments::Handle(TypeArguments::New(2));
   const TypeArguments& targ_1 = TypeArguments::Handle(TypeArguments::New(3));
   cache.AddCheck(empty_class.id(), targ_0, targ_1, Bool::True());
   EXPECT_EQ(1, cache.NumberOfChecks());
   intptr_t test_class_id = -1;
   AbstractTypeArguments& test_targ_0 = AbstractTypeArguments::Handle();
   AbstractTypeArguments& test_targ_1 = AbstractTypeArguments::Handle();
@@ skipping 658 matching lines @@
   const Function& test7 = Function::Handle(GetFunction(class_a, "test7"));
   EXPECT_EQ(test1.SourceFingerprint(), test2.SourceFingerprint());
   EXPECT_NE(test1.SourceFingerprint(), test3.SourceFingerprint());
   EXPECT_NE(test3.SourceFingerprint(), test4.SourceFingerprint());
   EXPECT_NE(test4.SourceFingerprint(), test5.SourceFingerprint());
   EXPECT_NE(test5.SourceFingerprint(), test6.SourceFingerprint());
   EXPECT_EQ(test6.SourceFingerprint(), test7.SourceFingerprint());
 }
 
 }  // namespace dart