Ongoing renaming of type classes:

runtime/vm/code_generator_ia32.cc

 // Copyright (c) 2011, 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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 955 matching lines @@
   // Evaluate the array elements.
   for (int i = 0; i < node->length(); i++) {
     AstNode* element = node->ElementAt(i);
     element->Visit(this);
   }
 
   // Allocate the array.
   //   EDX : Array length as Smi.
   //   ECX : element type for the array.
   __ movl(EDX, Immediate(Smi::RawValue(node->length())));
-  const TypeArguments& element_type = node->type_arguments();
+  const AbstractTypeArguments& element_type = node->type_arguments();
   ASSERT(element_type.IsNull() || element_type.IsInstantiated());
   __ LoadObject(ECX, element_type);
   GenerateCall(node->token_index(), &StubCode::AllocateArrayLabel());
 
   // Pop the element values from the stack into the array.
   __ leal(ECX, FieldAddress(EAX, Array::data_offset()));
   for (int i = node->length() - 1; i >= 0; i--) {
     __ popl(Address(ECX, i * kWordSize));
   }
 
@@ skipping 413 matching lines @@
     __ jmp(&done, Assembler::kNearJump);
 
     __ Bind(&non_null);
 
     const Class& type_class = Class::ZoneHandle(type.type_class());
     const bool requires_type_arguments = type_class.HasTypeArguments();
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable with a dst type of a
     // non-parameterized class or with a raw dst type of a parameterized class.
     if (requires_type_arguments) {
-      const TypeArguments& type_arguments =
-          TypeArguments::Handle(type.arguments());
+      const AbstractTypeArguments& type_arguments =
+          AbstractTypeArguments::Handle(type.arguments());
       const bool is_raw_type = type_arguments.IsNull() ||
           type_arguments.IsDynamicTypes(type_arguments.Length());
       Label runtime_call;
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(ZERO, &runtime_call, Assembler::kNearJump);
       // Object not Smi.
       if (is_raw_type) {
         if (type.IsListInterface()) {
           Label push_result;
           // TODO(srdjan) also accept List<Object>.
@@ skipping 132 matching lines @@
 
   // If dst_type is instantiated and non-parameterized, we can inline code
   // checking whether the assigned instance is a Smi.
   if (dst_type.IsInstantiated()) {
     const Class& dst_type_class = Class::ZoneHandle(dst_type.type_class());
     const bool dst_class_has_type_arguments = dst_type_class.HasTypeArguments();
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable with a dst type of a
     // non-parameterized class or with a raw dst type of a parameterized class.
     if (dst_class_has_type_arguments) {
-      const TypeArguments& dst_type_arguments =
-          TypeArguments::Handle(dst_type.arguments());
+      const AbstractTypeArguments& dst_type_arguments =
+          AbstractTypeArguments::Handle(dst_type.arguments());
       const bool is_raw_dst_type = dst_type_arguments.IsNull() ||
           dst_type_arguments.IsDynamicTypes(dst_type_arguments.Length());
       if (is_raw_dst_type) {
         // Dynamic type argument, check only classes.
         if (dst_type.IsListInterface()) {
           // TODO(srdjan) also accept List<Object>.
           __ testl(EAX, Immediate(kSmiTagMask));
           __ j(ZERO, &runtime_call, Assembler::kNearJump);
           __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
           TestClassAndJump(*CoreClass("ObjectArray"), &done);
@@ skipping 673 matching lines @@
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     instantiator_class = outer_function.signature_class();
   } else {
     instantiator_class = outer_function.owner();
   }
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
-    TypeArguments& type_arguments = TypeArguments::ZoneHandle();
+    AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::NewParameterizedType(instantiator_class, type_arguments));
     String& errmsg = String::Handle();
     type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(token_index, errmsg.ToCString());
     }
     type_arguments = type.arguments();
     __ PushObject(type_arguments);
   } else {
     ASSERT(parsed_function().instantiator() != NULL);
     parsed_function().instantiator()->Visit(this);
     if (!outer_function.IsFactory()) {
       __ popl(EAX);  // Pop instantiator.
       // The instantiator is the receiver of the caller, which is not a factory.
-      // The receiver cannot be null; extract its TypeArguments object.
+      // The receiver cannot be null; extract its AbstractTypeArguments object.
       // Note that in the factory case, the instantiator is the first parameter
-      // of the factory, i.e. already a TypeArguments object.
+      // of the factory, i.e. already an AbstractTypeArguments object.
       intptr_t type_arguments_instance_field_offset =
           instantiator_class.type_arguments_instance_field_offset();
       ASSERT(type_arguments_instance_field_offset != Class::kNoTypeArguments);
       __ movl(EAX, FieldAddress(EAX, type_arguments_instance_field_offset));
       __ pushl(EAX);
     }
   }
 }
 
 
@@ skipping 22 matching lines @@
       if (!node->constructor().IsFactory()) {
         // The allocator additionally requires the instantiator type arguments.
         __ pushl(raw_null);  // Null instantiator.
       }
     }
   } else {
     // The type arguments are uninstantiated.
     ASSERT(requires_type_arguments);
     GenerateInstantiatorTypeArguments(node->token_index());
     __ popl(EAX);  // Pop instantiator.
-    // EAX is the instantiator TypeArguments object (or null).
+    // EAX is the instantiator AbstractTypeArguments object (or null).
     // If EAX is null, no need to instantiate the type arguments, use null, and
     // allocate an object of a raw type.
     Label type_arguments_instantiated, type_arguments_uninstantiated;
     __ cmpl(EAX, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
 
     // Instantiate non-null type arguments.
     if (node->type_arguments().IsUninstantiatedIdentity()) {
-      // Check if the instantiator type argument vector is a TypeArray of a
+      // Check if the instantiator type argument vector is a TypeArguments of a
       // matching length and, if so, use it as the instantiated type_arguments.
-      __ LoadObject(ECX, Class::ZoneHandle(Object::type_array_class()));
+      __ LoadObject(ECX, Class::ZoneHandle(Object::type_arguments_class()));
       __ cmpl(ECX, FieldAddress(EAX, Object::class_offset()));
       __ j(NOT_EQUAL, &type_arguments_uninstantiated, Assembler::kNearJump);
       Immediate arguments_length = Immediate(reinterpret_cast<int32_t>(
           Smi::New(node->type_arguments().Length())));
-      __ cmpl(FieldAddress(EAX, TypeArray::length_offset()), arguments_length);
+      __ cmpl(FieldAddress(EAX, TypeArguments::length_offset()),
+          arguments_length);
       __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     }
     __ Bind(&type_arguments_uninstantiated);
     if (node->constructor().IsFactory()) {
       // A runtime call to instantiate the type arguments is required before
       // calling the factory.
       const Object& result = Object::ZoneHandle();
       __ PushObject(result);  // Make room for the result of the runtime call.
       __ PushObject(node->type_arguments());
       __ pushl(EAX);  // Push instantiator type arguments.
@@ skipping 19 matching lines @@
       __ Bind(&type_arguments_pushed);
     }
   }
 }
 
 
 void CodeGenerator::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     const bool requires_type_arguments = true;  // Always first arg to factory.
     GenerateTypeArguments(node, requires_type_arguments);
-    // The top of stack is an instantiated TypeArguments object (or null).
+    // The top of stack is an instantiated AbstractTypeArguments object
+    // (or null).
     int num_args = node->arguments()->length() + 1;  // +1 to include type args.
     node->arguments()->Visit(this);
     // Call the factory.
     __ LoadObject(ECX, node->constructor());
     __ LoadObject(EDX, ArgumentsDescriptor(num_args,
                                            node->arguments()->names()));
     GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
     // Factory constructor returns object in EAX.
     __ addl(ESP, Immediate(num_args * kWordSize));
     if (IsResultNeeded(node)) {
@@ skipping 354 matching lines @@
                         message_buffer, kMessageBufferSize,
                         format, args);
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32