Ongoing renaming of type classes:

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 386 matching lines @@
     return;
   }
   String& expected_type_name = String::Handle();
   String& actual_type_name = String::Handle();
   AbstractType& expected_type_extends = AbstractType::Handle();
   AbstractType& actual_type_extends = AbstractType::Handle();
   const Array& expected_type_names =
       Array::Handle(factory_signature_class.type_parameters());
   const Array& actual_type_names =
       Array::Handle(factory_class.type_parameters());
-  const TypeArray& expected_extends_array =
-      TypeArray::Handle(factory_signature_class.type_parameter_extends());
-  const TypeArray& actual_extends_array =
-      TypeArray::Handle(factory_class.type_parameter_extends());
+  const TypeArguments& expected_extends_array =
+      TypeArguments::Handle(factory_signature_class.type_parameter_extends());
+  const TypeArguments& actual_extends_array =
+      TypeArguments::Handle(factory_class.type_parameter_extends());
   for (intptr_t i = 0; !mismatch && (i < num_type_params); i++) {
     expected_type_name ^= expected_type_names.At(i);
     actual_type_name ^= actual_type_names.At(i);
     expected_type_extends = expected_extends_array.TypeAt(i);
     actual_type_extends = actual_extends_array.TypeAt(i);
     if (!expected_type_name.Equals(actual_type_name) ||
         !expected_type_extends.Equals(actual_type_extends)) {
       mismatch = true;
     }
   }
@@ skipping 35 matching lines @@
         Class::Handle(ResolveClass(cls, unresolved_class));
 
     // Replace unresolved class with resolved type class.
     ASSERT(type.IsType());
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
     parameterized_type.set_type_class(Object::Handle(type_class.raw()));
   }
 
   // Resolve type arguments, if any.
-  const TypeArguments& arguments = TypeArguments::Handle(type.arguments());
+  const AbstractTypeArguments& arguments =
+      AbstractTypeArguments::Handle(type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       ResolveType(cls, type_argument);
     }
   }
 }
 
 
 // Finalize the type argument vector 'arguments' of the type defined by the
 // class 'cls' parameterized with the type arguments 'cls_args'.
 // The vector 'cls_args' is already initialized as a subvector at the correct
 // position in the passed in 'arguments' vector.
 // The subvector 'cls_args' has length cls.NumTypeParameters() and starts at
 // offset cls.NumTypeArguments() - cls.NumTypeParameters() of the 'arguments'
 // vector.
 // Example:
 //   Declared: class C<K, V> extends B<V> { ... }
 //             class B<T> extends Array<int> { ... }
 //   Input:    C<String, double> expressed as
 //             cls = C, arguments = [null, null, String, double],
 //             i.e. cls_args = [String, double], offset = 2, length = 2.
 //   Output:   arguments = [int, double, String, double]
-void ClassFinalizer::FinalizeTypeArguments(const Class& cls,
-                                           const TypeArguments& arguments) {
+void ClassFinalizer::FinalizeTypeArguments(
+    const Class& cls, const AbstractTypeArguments& arguments) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     super_type ^= FinalizeType(super_type);
     cls.set_super_type(super_type);
     const Class& super_class = Class::Handle(super_type.type_class());
-    const TypeArguments& super_type_args =
-        TypeArguments::Handle(super_type.arguments());
+    const AbstractTypeArguments& super_type_args =
+        AbstractTypeArguments::Handle(super_type.arguments());
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
     const intptr_t offset = super_class.NumTypeArguments();
     const intptr_t super_offset = offset - num_super_type_params;
     ASSERT(offset == (cls.NumTypeArguments() - cls.NumTypeParameters()));
     AbstractType& super_type_arg = AbstractType::Handle();
     for (intptr_t i = 0; i < num_super_type_params; i++) {
       super_type_arg = super_type_args.TypeAt(super_offset + i);
       if (!super_type_arg.IsInstantiated()) {
         super_type_arg = super_type_arg.InstantiateFrom(arguments, offset);
       }
       super_type_arg = super_type_arg.Canonicalize();
       arguments.SetTypeAt(super_offset + i, super_type_arg);
     }
     FinalizeTypeArguments(super_class, arguments);
   }
 }
 
 
 // Verify the upper bounds of the type arguments of class cls.
 void ClassFinalizer::VerifyUpperBounds(const Class& cls,
-                                       const TypeArguments& arguments) {
+                                       const AbstractTypeArguments& arguments) {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   const intptr_t num_type_params = cls.NumTypeParameters();
   const intptr_t offset = cls.NumTypeArguments() - num_type_params;
   AbstractType& type = AbstractType::Handle();
   AbstractType& type_extends = AbstractType::Handle();
-  const TypeArguments& extends_array =
-      TypeArguments::Handle(cls.type_parameter_extends());
+  const AbstractTypeArguments& extends_array =
+      AbstractTypeArguments::Handle(cls.type_parameter_extends());
   ASSERT((extends_array.IsNull() && (num_type_params == 0)) ||
          (extends_array.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_extends = extends_array.TypeAt(i);
     if (!type_extends.IsDynamicType()) {
       type = arguments.TypeAt(offset + i);
       if (type.IsInstantiated()) {
         if (!type_extends.IsInstantiated()) {
           type_extends = type_extends.InstantiateFrom(arguments, offset);
         }
@@ skipping 39 matching lines @@
   if (parameterized_type.IsBeingFinalized()) {
     ReportError("type '%s' illegally refers to itself\n",
                 String::Handle(parameterized_type.Name()).ToCString());
   }
 
   // Mark type as being finalized in order to detect illegal self reference.
   parameterized_type.set_is_being_finalized();
 
   // Finalize the current type arguments of the type, which are still the
   // parsed type arguments.
-  TypeArguments& arguments =
-      TypeArguments::Handle(parameterized_type.arguments());
+  AbstractTypeArguments& arguments =
+      AbstractTypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
       type_argument = FinalizeType(type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 
   // The type class does not need to be finalized in order to finalize the type,
@@ skipping 27 matching lines @@
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // TODO(regis): We need to store the token_index in each type.
     ReportError("wrong number of type arguments in type '%s'\n",
                 String::Handle(type.Name()).ToCString());
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
   // type arguments, followed by the parsed type arguments.
   if (num_type_arguments > 0) {
     const TypeArguments& full_arguments = TypeArguments::Handle(
-        TypeArguments::NewTypeArray(num_type_arguments));
+        TypeArguments::New(num_type_arguments));
     // Copy the parsed type arguments at the correct offset in the full type
     // argument vector.
     const intptr_t offset = num_type_arguments - num_type_parameters;
     AbstractType& type = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = 0; i < num_type_parameters; i++) {
       // If no type parameters were provided, a raw type is desired, so we
       // create a vector of DynamicType.
       if (!arguments.IsNull()) {
         type = arguments.TypeAt(i);
       }
@@ skipping 149 matching lines @@
     super_class = super_class.SuperClass();
   }
   return Class::null();
 }
 
 
 // Resolve and finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::ResolveAndFinalizeUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   AbstractType& type_extends = AbstractType::Handle();
-  const TypeArguments& extends_array =
-      TypeArguments::Handle(cls.type_parameter_extends());
+  const AbstractTypeArguments& extends_array =
+      AbstractTypeArguments::Handle(cls.type_parameter_extends());
   ASSERT((extends_array.IsNull() && (num_type_params == 0)) ||
          (extends_array.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_extends = extends_array.TypeAt(i);
     ResolveType(cls, type_extends);
     type_extends = FinalizeType(type_extends);
     extends_array.SetTypeAt(i, type_extends);
   }
 }
 
@@ skipping 469 matching lines @@
   va_end(args);
   if (FLAG_warning_as_error) {
     Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
     UNREACHABLE();
   } else {
     OS::Print(message_buffer);
   }
 }
 
 }  // namespace dart